摘要：本文主要介绍了Java的文件处理以及常用的IO流操作。
文件操作
概念
File是数据源（保存数据的地方）的一种，可以表示一个文件，也可以表示一个文件目录。
File类只能对文件和文件夹进行创建和删除等操作，可以查看文件和文件夹的属性，不能读取或修改内容。如果需要读取或修改文件的内容，需要使用IO流。
常常将File类的对象作为参数传递到IO流的类的构造器中。
绝对路径和相对路径
绝对路径：绝对路径名是完整的路径名，不需要任何其他信息就可以定位它所表示的文件或文件夹。
相对路径：相对路径名必须使用取自其他路径名的信息进行解释。
相对路径创建的实例不等于绝对路径创建的实例。
常用方法
◆ 查看文件和文件夹
获得文件名或目录名：String getName();
获得相对路径：String getPath();
获得绝对路径：String getAbsolutePath();
◆ 创建或删除文件和文件夹
创建一个空文件：boolean createNewFile();
创建一个空目录：boolean mkdir();
创建指定的目录及父目录：boolean mkdirs();
删除文件或空目录：boolean delete();
◆ 常用的判断方法
判断是否存在：boolean exists();
判断是否目录：boolean isDirectory();
判断是否文件：boolean isFile();
常量
◆ File.separator
与系统有关的默认名称分隔符，为了方便，它被表示为一个字符串。此字符串只包含一个字符，即separatorChar。
separatorChar被初始化为包含系统属性file.separator值的第一个字符。在UNIX系统上，此字段的值为“/”；在Windows系统上，它为“\”。
◆ File.pathSeparator
与系统有关的路径分隔符，为了方便，它被表示为一个字符串。此字符串只包含一个字符，即pathSeparatorChar。
pathSeparatorChar被初始为包含系统属性path.separator值的第一个字符。此字符用于分隔以路径列表形式给定的文件序列中的文件名。在UNIX系统上，此字段为“:”；在Windows系统上，它为“;”。
IO流
概念
流：数据在数据源（文件）和程序（内存）之间经历的路径。
以内存为参照，如果数据流向内存流动，则是输入流，反之，则是输出流。
文件和文件夹在程序中是以流的形式来操作的。
凡是与输入输出相关的都定义在java.io包下。
打开的资源不属于内存里的资源，垃圾回收机制无法回收该资源，所以应该显式关闭IO资源。不过在JDK1.7之后，可以在try代码块中打开流，最后程序会自动关闭流对象，不再需要显示地关闭流。
关闭流时只需要考虑关闭最外层的流即可，如果要强制关闭所有流，必须先关闭外层的流。
流的分类
按数据流的流向不同分为：输入流，输出流。
按操作数据单位不同分为：字节流（InputStream、OutputStream），字符流（Reader、Writer）。
按流的角色的不同分为：节点流，处理流。
文件流
文件流主要有：FileInputStream、FileOutputStream、FileReader、FileWriter。
这四个类是专门操作文件流的，用法高度相似，区别在于前面两个是操作字节流，后面两个是操作字符流。
它们都会直接操作文件流，直接与OS底层交互，因此他们也被称为节点流，节点流在输出时不需要考虑flush操作。
FileInputStream
构造方法
FileInputStream(File file);
FileInputStream(String name);
常用方法
从输入流中读入一个字节：int read();
从输入流中读入到数组：int read(byte[] b);
从输入流中将len个数据读入到数组：int read(byte[] b, int off, int len);
关闭输入流并释放系统资源：void close();
读入文件到输入流
1 public void test() {
2 FileInputStream fis = null;
3 try {
4 fis = new FileInputStream(new File("D:" + File.separator + "hello.txt"));
5 byte[] buffer = new byte[1024];
6 int len = 0;
7 String txt = "";
8 while ((len = fis.read(buffer)) != -1) {
9 txt += new String(buffer, 0, len);
10 }
11 System.out.println(txt);
12 } catch (IOException e) {
13 e.printStackTrace();
14 } finally {
15 if (fis != null) {
16 try {
17 fis.close();
18 } catch (IOException e) {
19 e.printStackTrace();
20 }
21 }
22 }
23 }
FileOutputStream
构造方法
FileOutputStream(File file);
FileOutputStream(File file, boolean append);
FileOutputStream(String name);
FileOutputStream(String name, boolean append);
常用方法
从指定字节中写出到输出流：void write(int b);
从数组中写出到输出流：void write(byte[] b);
从数组中将len个数据写出到输出流：void write(byte[] b, int off, int len);
刷新该流的缓冲：void flush();
关闭输出流并释放系统资源：void close();
读出文件到输出流
1 public void test() {
2 FileOutputStream fos = null;
3 try {
4 fos = new FileOutputStream(new File("D:" + File.separator + "hello.txt"));
5 fos.write("hello".getBytes());
6 } catch (IOException e) {
7 e.printStackTrace();
8 } finally {
9 if (fos != null) {
10 try {
11 fos.close();
12 } catch (IOException e) {
13 e.printStackTrace();
14 }
15 }
16 }
17 }
FileReader
构造方法
FileReader(File file);
FileReader(String fileName);
常用方法
返回此流使用的字符编码的名称：String getEncoding();
从输入流中读入一个字节：int read();
从输入流中读入到数组：int read(char[] cbuf);
从输入流中将len个数据读入到数组：int read(char[] cbuf, int off, int len);
关闭输入流并释放系统资源：void close();
读入文本到输入流
1 public void test() {
2 FileReader fr = null;
3 try {
4 fr = new FileReader(new File("D:" + File.separator + "hello.txt"));
5 char[] buffer = new char[1024];
6 int len = 0;
7 String txt = "";
8 while ((len = fr.read(buffer)) != -1) {
9 txt = new String(buffer, 0, len);
10 }
11 System.out.print(txt);
12 } catch (IOException e) {
13 e.printStackTrace();
14 } finally {
15 if (fr != null) {
16 try {
17 fr.close();
18 } catch (IOException e) {
19 e.printStackTrace();
20 }
21 }
22 }
23 }
FileWriter
构造方法
FileWriter(File file);
FileWriter(File file, boolean append);
FileWriter(String fileName);
FileWriter(String fileName, boolean append);
常用方法
返回此流使用的字符编码的名称：String getEncoding();
从指定字节中写出到输出流：void write(int b);
从数组中写出到输出流：void write(byte[] b);
从数组中将len个数据写出到输出流：void write(byte[] b, int off, int len);
从字符串中写出到输出流：void write(String str);
从字符串中将len个数据写出到输出流：void write(String str, int off, int len);
刷新该流的缓冲：void flush();
关闭输出流并释放系统资源：void close();
读出文本到输出流
1 public void test() {
2 FileWriter fw = null;
3 try {
4 fw = new FileWriter(new File("D:" + File.separator + "hello.txt"));
5 fw.write("hello");
6 } catch (IOException e) {
7 e.printStackTrace();
8 } finally {
9 if (fw != null) {
10 try {
11 fw.close();
12 } catch (IOException e) {
13 e.printStackTrace();
14 }
15 }
16 }
17 }
文件的复制
字节文件的复制
1 public void test() {
2 FileInputStream fis = null;
3 FileOutputStream fos = null;
4 try {
5 fis = new FileInputStream("D:" + File.separator + "old.jpeg");
6 fos = new FileOutputStream("D:" + File.separator + "new.jpeg");
7 byte[] buffer = new byte[1024];
8 int len = 0;
9 while ((len = fis.read(buffer)) != -1) {
10 fos.write(buffer, 0, len);
11 }
12 } catch (IOException e) {
13 e.printStackTrace();
14 } finally {
15 if (fis != null) {
16 try {
17 fis.close();
18 } catch (IOException e) {
19 e.printStackTrace();
20 }
21 }
22 if (fos != null) {
23 try {
24 fos.close();
25 } catch (IOException e) {
26 e.printStackTrace();
27 }
28 }
29 }
30 }
字符文件的复制
1 public void test() {
2 FileReader fr = null;
3 FileWriter fw = null;
4 try {
5 fr = new FileReader("D:" + File.separator + "old.txt");
6 fw = new FileWriter("D:" + File.separator + "new.txt");
7 char[] buffer = new char[1024];
8 int len = 0;
9 while ((len = fr.read(buffer)) != -1) {
10 fw.write(buffer, 0, len);
11 }
12 } catch (IOException e) {
13 e.printStackTrace();
14 } finally {
15 if (fr != null) {
16 try {
17 fr.close();
18 } catch (IOException e) {
19 e.printStackTrace();
20 }
21 }
22 if (fw != null) {
23 try {
24 fw.close();
25 } catch (IOException e) {
26 e.printStackTrace();
27 }
28 }
29 }
30 }
缓冲流
缓冲流主要有：BufferedInputStream、BufferedOutputStream、BufferedReader、BufferedWriter。
这四个类可以封装现有的节点流，实现对数据传输的效率的提升。
缓冲流比文件流多了一个缓冲区，执行read时先从缓冲区读取，当缓冲区数据读完时再把缓冲区填满。因此，当每次读取的数据量很小时，文件流每次都是从硬盘读入，而缓冲流大部分是从缓冲区读入。读取内存速度比读取硬盘速度快得多，因此缓冲流效率高。
缓冲流的默认缓冲区大小是8192字节。当每次读取数据量接近或远超这个值时，两者效率就没有明显差别了。
缓冲流属于处理流，在输出时需要考虑使用flush操作。
BufferedInputStream
构造方法
BufferedInputStream(InputStream in);
BufferedInputStream(InputStream in, int size);
常用方法
从输入流中读入一个字节：int read();
从输入流中读入到数组：int read(byte[] b);
从输入流中将len个数据读入到数组：int read(byte[] b, int off, int len);
关闭输入流并释放系统资源：void close();
BufferedOutputStream
构造方法
BufferedOutputStream(OutputStream out);
BufferedOutputStream(OutputStream out, int size);
常用方法
从指定字节中写出到输出流：void write(int b);
从数组中写出到输出流：void write(byte[] b);
从数组中将len个数据写出到输出流：void write(byte[] b, int off, int len);
刷新该流的缓冲：void flush();
关闭输出流并释放系统资源：void close();
BufferedReader
构造方法
BufferedReader(Reader in);
BufferedReader(Reader in, int size);
常用方法
从输入流中读入一个字节：int read();
从输入流中读入到数组：int read(char[] cbuf);
从输入流中将len个数据读入到数组：int read(char[] cbuf, int off, int len);
关闭输入流并释放系统资源：void close();
BufferedWriter
构造方法
BufferedWriter(Writer out);
BufferedWriter(Writer out, int size);
常用方法
从指定字节中写出到输出流：void write(int c);
从数组中写出到输出流：void write(char[] cbuf);
从数组中将len个数据写出到输出流：void write(char[] cbuf, int off, int len);
从字符串中写出到输出流：void write(String str);
从字符串中将len个数据写出到输出流：void write(String str, int off, int len);
刷新该流的缓冲：void flush();
关闭输出流并释放系统资源：void close();
文件的复制
字节文件的复制
1 public void test() {
2 BufferedInputStream bis = null;
3 BufferedOutputStream bos = null;
4 try {
5 bis = new BufferedInputStream(new FileInputStream("D:" + File.separator + "old.mp3"));
6 bos = new BufferedOutputStream(new FileOutputStream("D:" + File.separator + "new.mp3"));
7 byte[] buffer = new byte[1024];
8 int len = 0;
9 while ((len = bis.read(buffer)) != -1) {
10 bos.write(buffer, 0, len);
11 }
12 } catch (IOException e) {
13 e.printStackTrace();
14 } finally {
15 if (bis != null) {
16 try {
17 bis.close();
18 } catch (IOException e) {
19 e.printStackTrace();
20 }
21 }
22 if (bos != null) {
23 try {
24 bos.close();
25 } catch (IOException e) {
26 e.printStackTrace();
27 }
28 }
29 }
30 }
字符文件的复制
1 public void test() {
2 BufferedReader br = null;
3 BufferedWriter bw = null;
4 try {
5 br = new BufferedReader(new FileReader("D:" + File.separator + "old.txt"));
6 bw = new BufferedWriter(new FileWriter("D:" + File.separator + "new.txt"));
7 char[] buffer = new char[1024];
8 int len = 0;
9 while ((len = br.read(buffer)) != -1) {
10 bw.write(buffer, 0, len);
11 }
12 } catch (IOException e) {
13 e.printStackTrace();
14 } finally {
15 if (br != null) {
16 try {
17 br.close();
18 } catch (IOException e) {
19 e.printStackTrace();
20 }
21 }
22 if (bw != null) {
23 try {
24 bw.close();
25 } catch (IOException e) {
26 e.printStackTrace();
27 }
28 }
29 }
30 }
转换流
转换流主要有：InputStreamReader、OutputStreamWriter。
这两个流可以将文本在字节流和字符流之间进行转换，但只能处理文本文件。
InputStreamReader
构造方法
InputStreamReader(InputStream in);
InputStreamReader(InputStream in, String charsetName);
常用方法
返回此流使用的字符编码的名称：String getEncoding();
从输入流中读入一个字节：int read();
从输入流中读入到数组：int read(char[] cbuf);
从输入流中将len个数据读入到数组：int read(char[] cbuf, int off, int len);
关闭输入流并释放系统资源：void close();
OutputStreamWriter
构造方法
OutputStreamWriter(OutputStream out);
OutputStreamWriter(OutputStream out, String charsetName);
常用方法
返回此流使用的字符编码的名称：String getEncoding();
从指定字节中写出到输出流：void write(int c);
从数组中写出到输出流：void write(char[] cbuf);
从数组中将len个数据写出到输出流：void write(char[] cbuf, int off, int len);
从字符串中写出到输出流：void write(String str);
从字符串中将len个数据写出到输出流：void write(String str, int off, int len);
刷新该流的缓冲：void flush();
关闭输出流并释放系统资源：void close();
文件的复制
1 public void test() {
2 InputStreamReader isr = null;
3 OutputStreamWriter osw = null;
4 try {
5 isr = new InputStreamReader(new FileInputStream("D:" + File.separator + "old.txt"), "UTF-8");// 确定解码集
6 osw = new OutputStreamWriter(new FileOutputStream("D:" + File.separator + "new.txt"), "UTF-8");// 确定编码集
7 char[] buffer = new char[20];
8 int len = 0;
9 while ((len = isr.read(buffer)) != -1) {
10 osw.write(buffer, 0, len);
11 }
12 } catch (IOException e) {
13 e.printStackTrace();
14 } finally {
15 if (isr != null) {
16 try {
17 isr.close();
18 } catch (IOException e) {
19 e.printStackTrace();
20 }
21 }
22 if (osw != null) {
23 try {
24 osw.close();
25 } catch (IOException e) {
26 e.printStackTrace();
27 }
28 }
29 }
30 }
内存读写流
内存读写流主要有：ByteArrayOutputStream、ByteArrayInputStream。
内存读写流将数组当作流输入输出对象的类。
不同于指向硬盘的流，它内部是使用字节数组读内存的，这个字节数组是它的成员变量，当这个数组不再使用变成垃圾的时候，Java的垃圾回收机制会将它回收，所以内存读写流不需要关流。
ByteArrayInputStream
构造方法
ByteArrayInputStream(byte[] b);
ByteArrayInputStream(byte[] b, int off, int len);
常用方法
从输入流中读入一个字节：int read();
从输入流中将len个数据读入到数组：int read(byte[] b, int off, int len);
ByteArrayIOutputStream
构造方法
ByteArrayIOutputStream();
ByteArrayIOutputStream(int size);
常用方法
从指定字节中写出到输出流：void write(int b);
从数组中将len个数据写出到输出流：void write(byte[] b, int off, int len);
将缓冲区内容转换字节数组：byte toByteArray();
将缓冲区内容转换为字符串：String toString();
将缓冲区内容转换为指定编码格式的字符串：String toString(String charsetName);
将缓冲区内容输出到指定的输出流：void writeTo(OutputStream out);
解决乱码
当用字节数组读取字符串时，受数组长度的影响，导致产生乱码。
如果用String类型接收，则不能完全解析出正常的文字，需要使用字节数组输出流将字节数组的内容输出到缓冲区，待读取完成后再转换为String类型的字符串。
1 public void test() {
2 ByteArrayInputStream bais = null;
3 ByteArrayOutputStream baos = null;
4 try {
5 bais = new ByteArrayInputStream("测试写入内容".getBytes());
6 baos = new ByteArrayOutputStream();
7 byte[] buffer = new byte[1];
8 int len = -1;
9 String txt = "";
10 while ((len = bais.read(buffer)) != -1) {
11 baos.write(buffer, 0, len);
12 txt += new String(buffer, 0, len);
13 }
14 System.out.println("正常：" + baos.toString());
15 System.out.println("乱码：" + txt);
16 } catch (IOException e) {
17 e.printStackTrace();
18 }
19 }
标准流
System.in
可以获取键盘输入的值，属于字节流。
获取方式
static InputStream in;
System.out
可以将文本从控制台输出，属于字节流。
PrintStream是FileOutputStream下的子类，而FileOutputStream是OutputStream下的子类。
获取方式
static PrintStream out;
获取输入内容
获取输入内容并显示在控制台
1 public void test() {
2 BufferedReader br = null;
3 try {
4 br = new BufferedReader(new InputStreamReader(System.in));
5 System.out.println("请输入字符串：");
6 System.out.println("输入的字符串为：" + br.readLine());
7 } catch (IOException e) {
8 e.printStackTrace();
9 } finally {
10 if (br != null) {
11 try {
12 br.close();
13 } catch (IOException e) {
14 e.printStackTrace();
15 }
16 }
17 }
18 }
将内容保存在文件
1 public void test() {
2 try {
3 System.out.println("这是输出到控制台的文字。");
4 System.setOut(new PrintStream("D:" + File.separator + "input.txt"));
5 System.out.println("这是输出到文件里的文字。");
6 } catch (IOException e) {
7 e.printStackTrace();
8 }
9 }
从文件中读取内容
1 public void test() {
2 try {
3 System.setIn(new FileInputStream("D:" + File.separator + "output.txt"));
4 byte[] buffer = new byte[1024];
5 int len = 0;
6 String str = "";
7 while ((len = System.in.read(buffer)) != -1) {
8 str += new String(buffer, 0, len);
9 }
10 System.out.println(str);
11 } catch (IOException e) {
12 e.printStackTrace();
13 }
14 }
对象流
对象流主要有：ObjectInputStream、ObjectOutputStream。
这两个类型都是字节流，可以处理所有文件，可以将内存中的对象保存到本地，也可以将本地的对象还原到内存中。
序列化
概念
对象序列化机制允许把内存中的Java对象转换成平台无关的二进制流，当其它程序获取了这种二进制流，就可以恢复成原来的Java对象。
如果想将一个对象进行网络传输，要求是该对象必须是可序列化的，该类必须实现Serializable接口或者Externalizable接口。
不能序列化static和transient修饰的属性。
好处
序列化的好处在于可将任何实现了Serializable接口的对象转化为字节数据，使其在保存和传输时可被还原。
序列化是远程方法调用(Remote Method Invoke)过程的参数和返回值都必须实现的机制，而RMI是JavaEE的基础，因此序列化机制是JavaEE平台的基础。
实现
序列化：用ObjectOutputStream类保存基本类型数据或对象的机制，因为是输出到文件里，所以是输出流。
反序列化：用ObjectInputStream类读取基本类型数据或对象的机制，因为将数据输入到内存里，所以是输入流。
手动序列化
进行序列化、反序列化时，虚拟机会首先试图调用对象里的writeObject和readObject方法，进行用户自定义的序列化和反序列化。
如果没有这样的方法，那么默认调用的是ObjectOutputStream的defaultWriteObject以及ObjectInputStream的defaultReadObject方法。
serialVersionUID
Java的序列化机制是通过判断类的serialVersionUID来验证版本一致性的。
在进行反序列化时，JVM会把传来的字节流中的serialVersionUID与本地相应实体类的serialVersionUID进行比较，如果相同就认为是一致的，可以进行反序列化，否则就会出现序列化版本不一致的异常，即是InvalidCastException。
serialVersionUID有两种生成方式：默认的1L，生成一个64位的Hash字段。
ObjectInputStream
构造方法
ObjectInputStream(InputStream in);
常用方法
从输入流中读入一个字节：int read();
从输入流中读入到数组：int read(byte[] buf);
从输入流中将len个数据读入到数组：int read(byte[] buf, int off, int len);
使用UTF-8编码读取字符串：String readUTF();
读取要保存的变量：Object readObject();
默认的读取变量的方法：void defaultReadObject();
关闭输入流并释放系统资源：void close();
反序列化实例
1 public void deserialize() {
2 try {
3 ObjectInputStream ois = new ObjectInputStream(new FileInputStream("D:" + File.separator + "object.obj"));
4 System.out.println(ois.readInt());
5 System.out.println(ois.readObject());
6 System.out.println((Box) ois.readObject());
7 ois.close();
8 } catch (IOException e) {
9 e.printStackTrace();
10 }
11 }
ObjectOutputStream
构造方法
DataOutputStream(OutputStream out);
常用方法
从指定字节中写出到输出流：void write(int b);
从数组中写出到输出流：void write(byte[] b);
从数组中将len个数据写出到输出流：void write(byte[] b, int off, int len);
使用UTF-8编码写入字符串：void writeUTF(String str);
写入要保存的变量：void writeObject(Object obj);
默认的写入变量的方法：void defaultWriteObject();
刷新该流的缓冲：void flush();
关闭输出流并释放系统资源：void close();
序列化实例
1 public void serialize() {
2 try {
3 ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("D:" + File.separator + "object.obj"));
4 oos.writeInt(100);
5 oos.writeObject("String");
6 oos.writeObject(new Box("box", 6, 8));
7 oos.close();
8 } catch (IOException e) {
9 e.printStackTrace();
10 }
11 }
随机存取文件流
字节流，可以处理所有文件。
既可以充当输入流，又可以充当输出流。
若此将要输出文件不存在则尝试自动创建，并将内容输出到此文件中。若此将要输出的文件存在，则将对文件内容进行覆盖，默认从开头进行覆盖。
RandomAccessFile
构造方法
RandomAccessFile(File file, String mode);
RandomAccessFile(String name, String mode);
mode指定文件的访问模式：
r：以只读方式打开。
rw：打开以便读取和写入。
rws：还要求对文件的内容或元数据的更新都同步到底层存储设备。
rwd：还要求对文件内容的更新都同步到底层存储设备。
常用方法
从指定字节中写出到输出流：void write(byte[] b);
从数组中写出到输出流：void write(int b);
从数组中将len个数据写出到输出流：void write(byte[] b, int off, int len);
从输入流中读入一个字节：int read();
从输入流中读入到数组：int read(byte[] b);
从输入流中将len个数据读入到数组：int read(byte[] b, int off, int len);
获取文件记录指针的当前位置：long getFilePointer();
将文件记录指针定位到pos位置：void seek(long pos);
关闭流并释放系统资源：void close();
复制文件
1 public void test() {
2 RandomAccessFile r = null;
3 RandomAccessFile w = null;
4 try {
5 r = new RandomAccessFile(new File("D:" + File.separator + "read.txt"), "r");
6 w = new RandomAccessFile(new File("D:" + File.separator + "write.txt"), "rw");
7 byte[] buffer = new byte[1024];
8 int len = 0;
9 while ((len = r.read(buffer)) != -1) {
10 w.write(buffer, 0, len);
11 }
12 } catch (IOException e) {
13 e.printStackTrace();
14 } finally {
15 if (r != null) {
16 try {
17 r.close();
18 } catch (IOException e) {
19 e.printStackTrace();
20 }
21 }
22 if (w != null) {
23 try {
24 w.close();
25 } catch (IOException e) {
26 e.printStackTrace();
27 }
28 }
29 }
30 }
插入内容
1 public void test() {
2 RandomAccessFile raf = null;
3 try {
4 raf = new RandomAccessFile("D:" + File.separator + "read.txt", "rw");
5 raf.seek(3);
6 byte[] buffer = new byte[1024];
7 int len = 0;
8 String str = "";
9 while ((len = raf.read(buffer)) != -1) {
10 str += new String(buffer, 0, len);
11 }
12 raf.seek(3);
13 raf.write("read".getBytes());
14 raf.write(str.getBytes());
15 } catch (IOException e) {
16 e.printStackTrace();
17 } finally {
18 try {
19 raf.close();
20 } catch (IOException e) {
21 e.printStackTrace();
22 }
23 }
24 }
原文地址：https://www.cnblogs.com/shamao/p/10523350.html