Java IO6：字符流进阶及BufferedWriter、BufferedReader

参考资料：常见IO类继承关系图，Java IO6：字符流进阶及BufferedWriter、BufferedReader

一、字符流和字节流的区别

　　拿一下上一篇文章的例子：

public class Test {
    public static void main(String[] args) throws IOException {
        File file = new File("D:" + File.separator + "readerAndWriter.txt");
        //创建字符输出流
        Writer writer = new FileWriter(file);
        String content = "hello World 中国 center 执行";
        //将内容写入文件
        writer.write(content);
        //关闭输出流
//        writer.close();

        //创建字符输入流
        Reader reader = new FileReader(file);
        char[] chars = new char[1024];
        //将文件的内容读取到chars数组中，并返回读取到的字符个数
        int characterNumbers = reader.read(chars);
        if(characterNumbers == -1){
            System.out.println("文件中无内容");
        }else{
            //输出读取到的内容
            System.out.println(new String(chars));
        }
        reader.close();
    }
}

　　注意第十行，将writer.close()方法注释之后，此时将无法将字符串写入文件

　　

　　控制台输出：

　　

　　说明一下原因：

　　字符流和字节流非常相似，但也有区别，从网上找了一张图：

　　

　　从图上看，字符流和字节流最大的区别在于，字节流在操作时本身不会用到缓冲区（内存），是文件本身直接操作的，而字符流操作时使用了缓冲区，通过缓冲区再操作文件。这也解释了上面程序的那个问题，为什么不对资源进行close()就无法写入文件的原因。因为在关闭字符流时会强制性地将缓冲区中的内容进行输出，但是如果没有关闭，缓冲区中的内容是无法输出的。

　　什么是缓冲区？简单理解，缓冲区就是一块特殊的内存区域。为什么要使用缓冲区？因为如果一个程序频繁操作一个资源（文件或数据库），则性能会很低，为了提升性能，就可以将一部分数据暂时读入到内存的一块区域之中，以后直接从此区域读取数据即可，因为读取内存的速度要快于读取磁盘中文件内容的速度。

　　在字符流的操作中，所有的字符都是在内存中形成的，在输出前会将所有的内容暂时保存在内存之中，所以使用了缓冲区。

　　如果不想在关闭时再输出字符流的内容也行，使用Writer的flush()方法就可以了。

二、字符流的原理

　　Java支持字符流和字节流，字符流本身就是一种特殊的字节流，之所以要专门有字符流，是因为Java中有大量对于字符的操作，所以专门有字符流。以FileReader为例，看一下字符流的构造函数：

/**
    * Creates a new <tt>FileReader</tt>, given the <tt>File</tt>
    * to read from.
    *
    * @param file the <tt>File</tt> to read from
    * @exception  FileNotFoundException  if the file does not exist,
    *                   is a directory rather than a regular file,
    *                   or for some other reason cannot be opened for
    *                   reading.
    */
    public FileReader(File file) throws FileNotFoundException {
        super(new FileInputStream(file));
    }

　　可以看到，FileReader构造函数中是通过new一个字节流来创建字符流的，即字符流的创建是通过字节流实现的。

　　字节流和字符流之间的转换是通过InputStreamReader和OutputStreamWriter来实现的，InputStreamReader可以将一个字节流中的字节解码成字符，OutputStreamWriter可以将写入的字符编码成字节后写入一个字节流。　　

　　InputStreamReader中的解码字节，是由StreamDecoder完成的，StreamDecoder是Reader的实现类，定义在InputStreamReader的开头：

public class InputStreamReader extends Reader {

    private final StreamDecoder sd;

　　同样，OutputStreadWriter中的编码字节，是由StreamEncoder完成的，StreamEncoder是Writer的实现类，定义在OutputStreamWriter的开头：

public class OutputStreamWriter extends Writer {

    private final StreamEncoder se;

　　假如不对StreamDecoder和StreamEncoder指定Charset编码格式，将使用本地环境中的默认字符集，例如中文环境中将使用GBK编码。

　　InputStreamReader有两个主要的构造函数：

　　1、InputStreamReader(InputStream in)

　　2、InputStreamReader(InputStream in, String charsetName)

　　OutputStreamWriter也有两个主要的构造函数：

　　1、OutputStreamWriter(OutputStream out)

　　2、OutputStreamWriter(OutputStream out, String charsetName)

　　举例：前面已经说明，直接通过字节流读取文本中包含汉字的内容会产生乱码，而InputStreamReader就可以将字节流转成字符流，将汉字显示出来

public class Test {
    public static void main(String[] args) throws IOException {
        File file = new File("D:" + File.separator + "test.txt");
        //构建字节流
        InputStream inputStream = new FileInputStream(file);
        //构建字节流转换成字符流
        InputStreamReader inputStreamReader = new InputStreamReader(inputStream);
        int read = -2;
        while(read != -1){
            read = inputStreamReader.read();
            if(read >= 0){
                //将读取到的单个字符由int表示（in the range 0 to 65535）转成char
                System.out.println((char)read);
            }
        }
    }
}

　　结果：

h
e
l
l
o
 
中
国
 
w
o
r
l
d
 
执
行

 三、BufferedWriter、BufferedReader

　　为了达到最高的效率，避免频繁地进行字符与字节之间的相互转换，最好不要直接使用FileReader和FileWriter这两个类进行读写，而使用BufferedWriter（字符缓冲输出流）进行写入，使用BufferedReader（字符缓冲输入流）进行读取。

　　FileReader和BufferedReader区别：

　　BufferedReader类带有缓冲区，它可以先把一批数据读到缓冲区，接下来的读操作都是从缓冲区内获取数据，避免每次都从数据源读取数据进行字符编码转换，从而提高读取操作的效率。

　　举例：使用字符缓冲输出流和字符缓冲输入流进行写入和读取操作

public class Test {
    public static void main(String[] args) throws IOException {
        File file = new File("D:" + File.separator + "buffered.txt");
        Writer writer = new FileWriter(file);
        //构建字符缓冲输出流
        BufferedWriter bufferedWriter = new BufferedWriter(writer);
        //将字符串输入到文件中
        bufferedWriter.write("hello\n");
        bufferedWriter.write("中国\n");
        bufferedWriter.write("world\n");
        bufferedWriter.write("执行\n");
        //关闭输出流
        bufferedWriter.close();
        writer.close();

        Reader reader = new FileReader(file);
        //构建字符缓冲输入流
        BufferedReader bufferedReader = new BufferedReader(reader);
        String lineContent = null;
        //逐行读取文件的内容
        while((lineContent = bufferedReader.readLine()) != null){
            System.out.println(lineContent );
        }
        //关闭输入流
        bufferedReader.close();
        reader.close();

    }
}

　　结果：运行一下，D盘下多出了"buffered.txt"这个文件：

　　

hello
中国
world
执行

　　没什么问题，输出了文件中的内容。注意两点：

　　1、利用BufferedWriter进行写操作，写入的内容会放在缓冲区内，直到遇到close()、flush()的时候才会将内容一次性写入文件。另外注意close()的顺序，一定要先关闭BufferedWriter，再关闭Writer，不可以倒过来，因为BufferedWriter的写操作是通过Writer的write方法写的，如果先关闭Writer的话，就无法将缓冲区内的数据写入文件了，会抛出异常

　　2、利用BufferedReader进行读操作，不可以用父类Reader指向它，因为readLine()这个方法是BufferedReader独有的，readLine()的作用是逐行读取文件中的内容