备注：以下方法用时需要看下流是否加了关闭，没有需要在finally里面加下
1.字符流读取（按行来读）常用于读文本，数字等类型的文件：
/**
* 以行为单位读取文件，常用于读面向行的格式化文件
*/
public static void readFileByLines(String fileName) {
File file = new File(fileName);
BufferedReader reader = null;
try {
System.out.println("以行为单位读取文件内容，一次读一整行：");
reader = new BufferedReader(new FileReader(file));
String tempString = null;
int line = 1;
// 一次读入一行，直到读入null为文件结束
while ((tempString = reader.readLine()) != null) {
// 显示行号
System.out.println("line " + line + ": " + tempString);
line++;
}
reader.close();
} catch (IOException e) {
e.printStackTrace();
} finally {
if (reader != null) {
try {
reader.close();
} catch (IOException e1) {
}
}
}
}
2.字节流读取：
/**
* 以字节为单位读取文件，常用于读二进制文件，如图片、声音、影像等文件。
*/
public static void readFileByBytes(String fileName) {
File file = new File(fileName);
InputStream in = null;
try {
System.out.println("以字节为单位读取文件内容，一次读一个字节：");
// 一次读一个字节
in = new FileInputStream(file);
int tempbyte;
while ((tempbyte = in.read()) != -1) {
System.out.write(tempbyte);
}
in.close();
} catch (IOException e) {
e.printStackTrace();
return;
}
try {
System.out.println("以字节为单位读取文件内容，一次读多个字节：");
// 一次读多个字节
byte[] tempbytes = new byte[100];
int byteread = 0;
in = new FileInputStream(fileName);
ReadFromFile.showAvailableBytes(in);
// 读入多个字节到字节数组中，byteread为一次读入的字节数
while ((byteread = in.read(tempbytes)) != -1) {
System.out.write(tempbytes, 0, byteread);
}
} catch (Exception e1) {
e1.printStackTrace();
} finally {
if (in != null) {
try {
in.close();
} catch (IOException e1) {
}
}
}
}
3.字符流写入（追加方式）
/**
* 字符流写入（追加方式）关键词true = append file
*/
public static void AppendToFile(String fileName) {
try {
String data = " This content will append to the end of the file";
File file = new File("javaio-appendfile.txt");
// if file doesnt exists, then create it
if (!file.exists()) {
file.createNewFile();
}
// true = append file
FileWriter fileWritter = new FileWriter(file.getName(), true);
BufferedWriter bufferWritter = new BufferedWriter(fileWritter);
bufferWritter.write(data);
bufferWritter.close();
System.out.println("Done");
} catch (IOException e) {
e.printStackTrace();
}
}
4.BufferedWriter写入文件
/**
* 缓冲字符（BufferedWriter ）是一个字符流类来处理字符数据。不同于字节流（数据转换成字节），你可以直接写字符串，数组或字符数据保存到文件。
*/
public static void WriteToFile(String fileName) {
try {
String content = "This is the content to write into file";
File file = new File(fileName);
// if file doesnt exists, then create it
if (!file.exists()) {
file.createNewFile();
}
FileWriter fw = new FileWriter(file.getAbsoluteFile());
BufferedWriter bw = new BufferedWriter(fw);
bw.write(content);
bw.close();
System.out.println("Done");
} catch (IOException e) {
e.printStackTrace();
}
}
/**
*文件输出流是一种用于处理原始二进制数据的字节流类。为了将数据写入到文件中，必须将数据转换为字节，并保存到文件
*/
public static void WriteFileStream(String fileName) {
FileOutputStream fop = null;
File file;
String content = "This is the text content";
try {
file = new File(fileName);
fop = new FileOutputStream(file);
// if file doesnt exists, then create it
if (!file.exists()) {
file.createNewFile();
}
// get the content in bytes
byte[] contentInBytes = content.getBytes();
fop.write(contentInBytes);
fop.flush();
fop.close();
System.out.println("Done");
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
if (fop != null) {
fop.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
---上面这些方法我基于JDK的提供的内置方法实现，下面提供些封装的
6.基于Spring(commons-io),例如：commons-io-2.2.jar 里面有封装好的FileUtils
介绍一些：
文件写入：
（1） FileUtils.writeStringToFile(new File("/target"),"string","utf-8",true);
注：1）四个参数分别为：目标文件，写入的字符串，字符集，是否追加
2) write可以接受charsequence类型的数据，string,stringbuilder和stringbuffer都是实现了charsequence接口,如下：
FileUtils.writeByteArrayToFile(new File("/target"),"bytes".getBytes());//(file,字符数组)
FileUtils.writeByteArrayToFile(new File("/target"),"bytes".getBytes(),true);//(file,字符数组，是否追加)
FileUtils.writeByteArrayToFile(new File("/target"),"bytes".getBytes(),0,10);//(file,字符数组，起始位置，结束位置)
FileUtils.writeByteArrayToFile(new File("/target"),"bytes".getBytes(),0,10,true);//(file,字符数组，起始位置，结束位置，是否追加)
(2) FileUtils.writeLines(new File("/target"),"utf-8", FileUtils.readLines(new File("/target"),"utf-8"));//writeLines多了一个lineEnding参数
文件读取：
（1） String str = FileUtils.readFileToString(new File("/dir"),"utf-8");//读取目标文件，内部调用IOUtils.toString(inputstream,"utf-8")
(2) byte[] bytes = FileUtils.readFileToByteArray(new File("/dir"));//内部调用IOUtils.toByteArray(in)
(3) List<String> strs = FileUtils.readLines(new File("/dir"),"utf-8");//内部调用IOUtils.readLines(in, Charsets.toCharset(encoding));
(4) FileUtils.lineIterator(new File("/dir"),"utf-8");//内部调用IOUtils.lineIterator(in, encoding)
7.参考6中可以看见IOUtils（文件输入输出流工具）
常用方法：
copy（拷贝）：
copy(inputstream,outputstream)
copy(inputstream,writer)
copy(inputstream,writer,encoding)
copy(reader,outputstream)
copy(reader,writer)
copy(reader,writer,encoding)
copyLarge（适合拷贝较大的数据流，比如2G以上）：
copyLarge(reader,writer) 默认会用1024*4的buffer来读取
copyLarge(reader,writer,buffer)
read（读取）：
read(inputstream,byte[])
read(inputstream,byte[],offset,length)
//offset是buffer的偏移值，length是读取的长度
read(reader,char[])
read(reader,char[],offset,length)
readFully（读取指定长度的流，如果读取的长度不够，就会抛出异常）：
readFully(inputstream,byte[])
readFully(inputstream,byte[],offset,length)
readFully(reader,charp[])
readFully(reader,char[],offset,length)
readLines（从流中读取内容，并转换为String的list）：
readLines(inputstream)
readLines(inputstream,charset)
readLines(inputstream,encoding)readLines(reader)
skip（跳过指定长度的流）：
skip(inputstream,skip_length)
skip(ReadableByteChannel,skip_length)
skip(reader,skip_length)
skipFully（类似skip，只是如果忽略的长度大于现有的长度，就会抛出异常）：
skipFully(inputstream,toSkip)
skipFully(readableByteChannel,toSkip)
skipFully(inputstream,toSkip)
write（写入）：
write(byte[] data, OutputStream output)
write(byte[] data, Writer output)
write(byte[] data, Writer output, Charset encoding)
write(byte[] data, Writer output, String encoding)
write(char[] data, OutputStream output)
write(char[] data, OutputStream output, Charset encoding)
write(char[] data, OutputStream output, String encoding)
write(char[] data, Writer output)
write(CharSequence data, OutputStream output)
write(CharSequence data, OutputStream output, Charset encoding)
write(CharSequence data, OutputStream output, String encoding)
write(CharSequence data, Writer output)
write(StringBuffer data, OutputStream output)
write(StringBuffer data, OutputStream output, String encoding)
write(StringBuffer data, Writer output)
write(String data, OutputStream output)
write(String data, OutputStream output, Charset encoding)
write(String data, OutputStream output, String encoding)
write(String data, Writer output)
writeLines（把string的List写入到输出流中）：
writeLines(Collection<?> lines, String lineEnding, OutputStream output)
writeLines(Collection<?> lines, String lineEnding, OutputStream output, Charset encoding)
writeLines(Collection<?> lines, String lineEnding, OutputStream output, String encoding)
writeLines(Collection<?> lines, String lineEnding, Writer writer)
注:（这里是对泛型用法做个大概了解，想了解更多你可以参考：https://www.zhihu.com/question/31429113,https://www.cnblogs.com/jpfss/p/9929045.html）：
“<T>"和"<?>"，首先要区分开两种不同的场景：
第一，声明一个泛型类或泛型方法。
第二，使用泛型类或泛型方法。
类型参数“<T>”主要用于第一种，声明泛型类或泛型方法。
无界通配符“<?>”主要用于第二种，使用泛型类或泛型方法
举例：（2）List<T> getList<T param1,T param2> （2）public void test(? extends Fruit){};--extends是对声明的泛型类型加以限制
close(别管干啥都记得用完把流关了，占用资源很严重的)：
close(URLConnection conn)--关闭URL
closeQuietly（忽略nulls和异常，关闭某个流）：
close(URLConnection conn)
closeQuietly(Closeable... closeables)
closeQuietly(Closeable closeable)
closeQuietly(InputStream input)
closeQuietly(OutputStream output)
closeQuietly(Reader input)
closeQuietly(Selector selector)
closeQuietly(ServerSocket sock)
closeQuietly(Socket sock)
closeQuietly(Writer output)
contentEquals（比较两个流是否相同）：
contentEquals(InputStream input1, InputStream input2)
contentEquals(Reader input1, Reader input2)
contentEqualsIgnoreEOL（比较两个流，忽略换行符）：
contentEqualsIgnoreEOL(Reader input1, Reader input2)
lineIterator（读取流，返回迭代器）：
lineIterator(InputStream input, Charset encoding)
lineIterator(InputStream input, String encoding)
lineIterator(Reader reader)
toBufferedInputStream（把流的全部内容放在另一个流中--追加）：
toBufferedInputStream(InputStream input)
toBufferedInputStream(InputStream input, int size)
toBufferedReader（返回输入流）：
toBufferedReader(Reader reader)
toBufferedReader(Reader reader, int size)
toByteArray（返回字节数组）：
toByteArray(InputStream input)
toByteArray(InputStream input, int size)
toByteArray(InputStream input, long size)toByteArray(Reader input)
toByteArray(Reader input, Charset encoding)
toByteArray(Reader input, String encoding)
toByteArray(String input)
toByteArray(URI uri)
toByteArray(URL url)
toByteArray(URLConnection urlConn)
toCharArray（返回字符数组）：
toCharArray(InputStream is)
toCharArray(InputStream is, Charset encoding)
toCharArray(InputStream is, String encoding)
toCharArray(Reader input)
toInputStream（返回输入流）：
toInputStream(CharSequence input)
toInputStream(CharSequence input, Charset encoding)
toInputStream(CharSequence input, String encoding)
toInputStream(String input)
toInputStream(String input, Charset encoding)
toInputStream(String input, String encoding)
toString（返回字符串）：
toString(byte[] input)
toString(byte[] input, String encoding)
toString(InputStream input)
toString(InputStream input, Charset encoding)
toString(InputStream input, String encoding)
toString(Reader input)
toString(URI uri)
toString(URI uri, Charset encoding)
toString(URI uri, String encoding)
toString(URL url)
toString(URL url, Charset encoding)
toString(URL url, String encoding)
