Java基础之文件IO

概述

Java 的 I/O 操作类在包 java.io 下，大概有将近 80 个类，但是这些类大概可以分成四组，分别是：

按处理数据类型来分：字节流和字符流：

• 基于字节操作的 I/O 接口：InputStream 和 OutputStream
• 基于字符操作的 I/O 接口：Writer 和 Reader

按传输数据的方式：磁盘操作和网络操作

• 基于磁盘操作的 I/O 接口：File
• 基于网络操作的 I/O 接口：Socket

按流的方向来分：输入流和输入流

• 要读的话就用输入流，要写的话，就用输出流

前两组主要是根据传输数据的数据格式，后两组主要是根据传输数据的方式，虽然 Socket 类并不在 java.io 包下，但是我仍然把它们划分在一起，因为我个人认为 I/O 的核心问题要么是数据格式影响 I/O 操作，要么是传输方式影响 I/O 操作，也就是将什么样的数据写到什么地方的问题，I/O 只是人与机器或者机器与机器交互的手段，除了在它们能够完成这个交互功能外，我们关注的就是如何提高它的运行效率了，而数据格式和传输方式是影响效率最关键的因素了。

3.什么时候使用字节流？什么时候使用字符流？

首先需要知道的是，任何数据存在硬盘上时，都是以二进制的形式存储的。而通过使用字节流，可以读取任意文件。字节流一次读取一个字节，而字符流使用了字节流读到一个或者多个字节时，去查找指定的编码表，返回对应的编码。所以字符流只能处理纯文本字符数据，而字节流可以处理更多类型的数据，比如图片，视频，音频文件等。因此，只要是纯文本数据处理，优先考虑使用字符流。其他情况就使用字节流。

基于字节的 I/O 操作接口

概述

基于字节的 I/O 操作接口输入和输出分别是：InputStream 和 OutputStream，InputStream 输入流的类继承层次如下图所示：

图 1. InputStream 相关类层次结构（查看大图）

输入流根据数据类型和操作方式又被划分成若干个子类，每个子类分别处理不同操作类型，OutputStream 输出流的类层次结构也是类似，如下图所示：

图 2. OutputStream 相关类层次结构（查看大图）

示例1：使用字节流，读取和存储图片

首先使用输入流读取图片信息，然后通过输出流写入图片信息：

package org.example.io;  import java.io.File;  import java.io.FileInputStream;  import java.io.FileOutputStream;  public class TestIOStream {      /**      *       * DOC 将F盘下的test.jpg文件，读取后，再存到E盘下面.      *       * @param args      * @throws Exception      */      public static void main(String[] args) throws Exception {          FileInputStream in = new FileInputStream(new File("F:\\test.jpg"));// 指定要读取的图片          File file = new File("E:\\test.jpg");          if (!file.exists()) {// 如果文件不存在，则创建该文件              file.createNewFile();          }          FileOutputStream out = new FileOutputStream(new File("E:\\test.jpg"));// 指定要写入的图片          int n = 0;// 每次读取的字节长度          byte[] bb = new byte[1024];// 存储每次读取的内容          while ((n = in.read(bb)) != -1) {              out.write(bb, 0, n);// 将读取的内容，写入到输出流当中          }          out.close();// 关闭输入输出流          in.close();      }  }  

示例2: 使用BufferedInputStream和BufferedOuputStream读写图片

使用方式和FileInputStrem和FileOutputStream基本一致：

package org.example.io;  import java.io.BufferedInputStream;  import java.io.BufferedOutputStream;  import java.io.File;  import java.io.FileInputStream;  import java.io.FileOutputStream;  public class TestBufferedString {      public static void main(String[] args) throws Exception {          // 指定要读取文件的缓冲输入字节流          BufferedInputStream in = new BufferedInputStream(new FileInputStream("F:\\test.jpg"));          File file = new File("E:\\test.jpg");          if (file != null) {              file.createNewFile();          }          // 指定要写入文件的缓冲输出字节流          BufferedOutputStream out = new BufferedOutputStream(new FileOutputStream(file));          byte[] bb = new byte[1024];// 用来存储每次读取到的字节数组          int n;// 每次读取到的字节数组的长度          while ((n = in.read(bb)) != -1) {              out.write(bb, 0, n);// 写入到输出流          }          out.close();// 关闭流          in.close();      }  }  

基于字符的 I/O 操作接口

概述

不管是磁盘还是网络传输，最小的存储单元都是字节，而不是字符，所以 I/O 操作的都是字节而不是字符，但是为啥有操作字符的 I/O 接口呢？这是因为我们的程序中通常操作的数据都是以字符形式，为了操作方便当然要提供一个直接写字符的 I/O 接口，如此而已。我们知道字符到字节必须要经过编码转换，而这个编码又非常耗时，而且还会经常出现乱码问题，所以 I/O 的编码问题经常是让人头疼的问题。关于 I/O 编码问题请参考另一篇文章 《深入分析Java中的中文编码问题。

读字符的操作接口中也是 int read(char cbuf[], int off, int len)，返回读到的 n 个字节数，不管是 Writer 还是 Reader 类它们都只定义了读取或写入的数据字符的方式，也就是怎么写或读，但是并没有规定数据要写到哪去，写到哪去就是我们后面要讨论的基于磁盘和网络的工作机制

图 3.Reader 类层次结构（查看大图）

下图是写字符的 I/O 操作接口涉及到的类，Writer 类提供了一个抽象方法 write(char cbuf[], int off, int len) 由子类去实现。

图 4. Writer 相关类层次结构（查看大图）

示例1：使用字符流，读取和存储纯文本文件

存储文件，也就是像一个文件里写内容，既然是写，那就需要使用输出流。而且我们写的是纯文本文件，所以这里使用字符流来操作，java api提供给我们FileWriter这么一个类，我们来试试：(读取文件同理使用FileReader类)

package org.example.io;  import java.io.File;  import java.io.FileNotFoundException;  import java.io.FileReader;  import java.io.FileWriter;  import java.io.IOException;  public class TestFileWriter {      public static void main(String[] args) throws Exception {          writeToFile();          readFromFile();      }      /**      * DOC 从文件里读取数据.      *       * @throws FileNotFoundException      * @throws IOException      */      private static void readFromFile() throws FileNotFoundException, IOException {          File file = new File("E:\\helloworld.txt");// 指定要读取的文件          FileReader reader = new FileReader(file);// 获取该文件的输入流          char[] bb = new char[1024];// 用来保存每次读取到的字符          String str = "";// 用来将每次读取到的字符拼接，当然使用StringBuffer类更好          int n;// 每次读取到的字符长度          while ((n = reader.read(bb)) != -1) {              str += new String(bb, 0, n);          }          reader.close();// 关闭输入流，释放连接          System.out.println(str);      }      /**      * DOC 往文件里写入数据.      *       * @throws IOException      */      private static void writeToFile() throws IOException {          String writerContent = "hello world,你好世界";// 要写入的文本          File file = new File("E:\\helloworld.txt");// 要写入的文本文件          if (!file.exists()) {// 如果文件不存在，则创建该文件              file.createNewFile();          }          FileWriter writer = new FileWriter(file);// 获取该文件的输出流          writer.write(writerContent);// 写内容          writer.flush();// 清空缓冲区，立即将输出流里的内容写到文件里          writer.close();// 关闭输出流，施放资源      }  }  

测试结果：

hello world,你好世界

示例2: 通过BufferedReader和BufferedWriter来读写文件

package org.example.io;  import java.io.BufferedReader;  import java.io.BufferedWriter;  import java.io.File;  import java.io.FileNotFoundException;  import java.io.FileReader;  import java.io.FileWriter;  import java.io.IOException;  public class TestBufferedWriter {      public static void main(String[] args) throws Exception {          write();          read();      }      /**      * DOC 读取信息.      *       * @throws FileNotFoundException      * @throws IOException      */      private static void read() throws FileNotFoundException, IOException {          File file = new File("E:\\a.txt");// 指定要读取的文件          // 获得该文件的缓冲输入流          BufferedReader bufferedReader = new BufferedReader(new FileReader(file));          String line = "";// 用来保存每次读取一行的内容          while ((line = bufferedReader.readLine()) != null) {              System.out.println(line);          }          bufferedReader.close();// 关闭输入流      }      /**      * DOC 写入信息.      *       * @throws IOException      */      private static void write() throws IOException {          File file = new File("E:\\a.txt");// 指定要写入的文件          if (!file.exists()) {// 如果文件不存在则创建              file.createNewFile();          }          // 获取该文件的缓冲输出流          BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(file));          // 写入信息          bufferedWriter.write("你好世界");          bufferedWriter.newLine();// 表示换行          bufferedWriter.write("hello world");          bufferedWriter.flush();// 清空缓冲区          bufferedWriter.close();// 关闭输出流      }  }  

字节与字符的转化接口

概述

另外数据持久化或网络传输都是以字节进行的，所以必须要有字符到字节或字节到字符的转化。字符到字节需要转化，其中读的转化过程如下图所示：

InputStreamReader 类是字节到字符的转化桥梁，InputStream 到 Reader 的过程要指定编码字符集，否则将采用操作系统默认字符集，很可能会出现乱码问题。StreamDecoder 正是完成字节到字符的解码的实现类。也就是当你用如下方式读取一个文件时：

 try {             StringBuffer str = new StringBuffer();             char[] buf = new char[1024];             FileReader f = new FileReader("file");             while(f.read(buf)>0){                 str.append(buf);             }             str.toString();  } catch (IOException e) {}

FileReader 类就是按照上面的工作方式读取文件的，FileReader 是继承了 InputStreamReader 类，实际上是读取文件流，然后通过 StreamDecoder 解码成 char，只不过这里的解码字符集是默认字符集。

写入也是类似的过程如下图所示：

通过 OutputStreamWriter 类完成，字符到字节的编码过程，由 StreamEncoder 完成编码过程。

示例：使用转换流InputStreamReader和OutputStreamWriter

当字节流和字符流之间需要转化的时候，或者要对字节数据进行编码转换的时候，就需要使用转换流

package org.example.io;  import java.io.File;  import java.io.FileInputStream;  import java.io.FileOutputStream;  import java.io.InputStreamReader;  import java.io.OutputStreamWriter;  public class TestStreamReader {      public static void main(String[] args) throws Exception {          File file = new File("E:\\b.txt");          if (!file.exists()) {              file.createNewFile();          }          OutputStreamWriter out = new OutputStreamWriter(new FileOutputStream(file), "GBK");          out.write("hello world,你好世界");          out.close();          InputStreamReader in = new InputStreamReader(new FileInputStream(file), "gbk");          char[] cc = new char[1024];          int n = 0;          String str = "";          while ((n = in.read(cc)) != -1) {              str += new String(cc, 0, n);          }          in.close();          System.out.println(str);      }  }  

参考

深入分析 Java I/O 的工作机制：
https://www.ibm.com/developerworks/cn/java/j-lo-javaio/

深入分析 Java 中的中文编码问题
http://www.ibm.com/developerworks/cn/java/j-lo-chinesecoding/

java IO流
http://blog.csdn.net/a107494639/article/details/7586365