Java I/O系统（三）

I/O

首先我们要来接触一下缓冲流。在Java I/O系统以Buffered开头的流类共有4个。对这4个类查看API可以发现，它们的构造器都必须依赖其他流对象。在I/O中不止是缓冲流，还有很多其他的类，都是依赖于其他流对象，例如行号缓冲字符输入流LineNumberReader、管道流（以Piped开头的流）和转换流（InputStreamReader和OutputStreamWriter）等等。

Java I/O类库之所以提供如此多的对象，是为了可以通过叠合多个对象来获得我们所希望的功能，而这正是装饰器模式（实现动态的为对象添加功能）。虽然给我们提供了相当多的灵活性，但是它同时也增加了代码的复杂度。

那么缓冲流能有给我们带来什么功能呢？它使我们可以高效的进行读写操作。如果使用了缓存流，就应该使用读取单个字符的read()方法。还记得上一篇，在对四个基本流的基本方法进行介绍时，有这么一行话“支持高效的单字符输入或输出的子类应重写此方法”，当然不止是字符，字节也是一样的，在缓存流中其实就对该方法进行了重写。

为什么缓冲流会高效

缓冲流为什么会高效，其实底层使用的就是目标缓冲区数组，重写后的读取单个字符的方法，是从缓冲区数组中进行读取的。因此笔者在上面的例子中并不介绍使用缓冲区数组的读方法。

硬盘磁头寻道将字节码读取并首先查询编码表获得字符加载到内存中，每读取一个字符然后放入内存中，直到结束。使用了缓存字符流的效率会明显高于直接使用底层资源从硬盘上读。

举一个例子：当我在餐馆吃饭时，点了几道菜，此时菜都做好了，需要服务员从厨房将这几道菜拿到我面前。

• 未使用缓冲区：服务员每拿一道菜就立即送我这。
• 使用了缓冲区：服务员用一个篮子，将菜先放入到篮子里，装满之后然后带着篮子来到我这，把菜一道道放在我面前。

显然是使用缓冲区效率会更高。将菜先放入到篮子里的操作就是read(char[] cbuf)，把菜一道道放在我面前就是从这个字符数组中取，即覆盖后的read()方法。

由于底层是使用了缓冲区数组，所以缓冲流的构造函数还可以指定缓存数组的大小。

缓冲字符输入流

对于纯文本的操作，应该使用字符流，所以就使用BufferedReader缓冲输入字符流来对文件进行读取操作。

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
public class Buffered {
    public static void main(String[] args) throws IOException {
        read1();
    }
    public static void read1() throws IOException {
        // 读取当前项目下的file.txt文件
        FileReader fr = new FileReader("file.txt");
        // 创建了一个字符读入流的缓冲区对象，并和指定要被缓冲的流对象相关联
        BufferedReader br = new BufferedReader(fr);
        int ch = 0;
        while ((ch = br.read()) != -1) {
            System.out.print((char) ch);
        }
        br.close(); //  关闭资源，其实关闭的就是被缓冲的流对象。
    }
} /* Output:
abc
你好！Hello World
你好，世界。
*///:~

对于纯文本的BufferedReader缓冲输入字符流，其中有一个很常用的方法String readLine()，每次读一行，如果已到达流末尾，则返回null。

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
public class Buffered {
    public static void main(String[] args) throws IOException {
        read2();
    }
    public static void read2() throws IOException {
        FileReader fr = new FileReader("file.txt");
        BufferedReader br = new BufferedReader(fr);
        String line = null;
        while((line=br.readLine())!=null){ // 读一行
            System.out.println(line);
        }
        br.close();
    }
} /* Output:
abc
你好！Hello World
你好，世界。
*///:~

上面这种方式是我们使用缓冲字符流常用的读方式，即读一行readLine()方法。

缓存字符输出流

下面会对BufferedWriter进行讲解。其中BufferedWriter有一个很常用的方法newLine()，写入一个行分隔符（其实底层就是调用了系统属性line.separator）。

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
public class Buffered {
    public static void main(String[] args) throws IOException {
        read3();
    }
    public static void read3() throws IOException {
        FileReader fr = new FileReader("file.txt");
        FileWriter fw = new FileWriter("D:"+File.separator+"copy_file.txt");
        BufferedReader br = new BufferedReader(fr);
        BufferedWriter bw = new BufferedWriter(fw);
        String line = null;
        while((line=br.readLine())!=null){
            bw.write(line);
            bw.newLine(); // 写入一行的同时，要记得行分隔符。
        }
        br.close();
        bw.close();
    }
} ///:~

上面是我们使用缓存字符流常用的方式。

缓冲字节流

我们可以使用缓冲字节流来实现一个高效的复制非纯文本文件的操作。

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class Buffered {
    public static void main(String[] args) throws IOException {
        copy();
    }
    public static void copy() throws IOException {
        File file = new File("D:"+File.separator+"Destroyer.mp3");
        FileInputStream fis = new FileInputStream(file);
        BufferedInputStream bis = new BufferedInputStream(fis);
        FileOutputStream fos = new FileOutputStream("G:"+File.separator+"copy_Destroyer.mp3");
        BufferedOutputStream bos = new BufferedOutputStream(fos);
        int by = 0;
        while((by=bis.read())!=-1){ // 使用了重写后的read和write方法
            bos.write(by);
        }
        bis.close();
        bos.close();
    }
} ///:~

到这里，对缓冲流的介绍也已经结束了，不知道读者有没有感到Java I/O流其实并没有想象的那么难呢。

行号缓冲字符输入流

跟踪行号的LineNumberReader缓冲字符输入流，该流提供的功能很简单，就是通过行号来方便操作。此类定义了方法setLineNumber(int)和getLineNumber()，它们可分别用于设置和获取当前行号。

import java.io.FileReader;
import java.io.IOException;
import java.io.LineNumberReader;
public class LineNumber {
    public static void main(String[] args) throws IOException {
        // 当前项目下的file.txt文件有三行内容
        FileReader fr = new FileReader("file.txt");
        LineNumberReader lnr = new LineNumberReader(fr);
        lnr.setLineNumber(1); // 定义初始行，默认为0
        String line = null;
        while ((line = lnr.readLine()) != null) {
            System.out.println(lnr.getLineNumber() + ":" + line); // 有一行便加一，所以从2开始显示内容
        }
        lnr.close();
    }
} /* Output:
2:abc
3:你好！Hello World
4:你好，世界。
*///:~

LineNumberReader行号缓冲字符输入流的使用就介绍到这里，它使用还是很简单的。

转换流

转换流有两个类，InputStreamReader和OutputStreamWriter。看起来就像是四个基本流的组合，下面来分别介绍一下这两个流类：

• InputStreamReader是字节流通向字符流的桥梁：它使用指定的charset（字符编码）读取字节并将其解码为字符。它使用的字符集可以由名称指定或显式给定，或者可以接受平台默认的字符集。
• OutputStreamWriter是字符流通向字节流的桥梁：可使用指定的charset（字符编码）将要写入流中的字符编码成字节。它使用的字符集可以由名称指定或显式给定，否则将接受平台默认的字符集。

// 两种方式获取系统默认的字符编码
public class Charset {
    public static void main(String[] args) throws IOException {
        System.out.println(System.getProperty("file.encoding"));   
        System.out.println(java.nio.charset.Charset.defaultCharset());
    }
} /* Output:
GBK
GBK
*///:~

这两个转换流都具有String getEncoding()方法来获取此流使用的字符编码的名称。下面将介绍使用转换流来实现文件的复制。

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
public class Charset {
    private static final String LINE_SEPARATOR = System.getProperty("line.separator");
    public static void main(String[] args) throws IOException {
        copy();
    }
    public static void copy() throws IOException {
        FileInputStream fis = new FileInputStream("file.txt");
        InputStreamReader isr = new InputStreamReader(fis);
        String charsetName = isr.getEncoding();
        System.out.println("charsetName:" + charsetName); // 查看编码
        BufferedReader br = new BufferedReader(isr);
        FileOutputStream fos = new FileOutputStream(new File("D:" + File.separator + "copy_file.txt"));
        OutputStreamWriter os = new OutputStreamWriter(fos, charsetName);
        String line = null;
        while ((line = br.readLine()) != null) {
            os.write(line);
            os.write(LINE_SEPARATOR);
            os.flush();
        }
        br.close();
        os.close();
    }
} /* Output:
charsetName:GBK // 也就是我系统中默认的字符编码
*///:~

下面将介绍将文件输入主控台

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
public class Charset {
    public static void main(String[] args) throws IOException {
        FileInputStream fis = new FileInputStream("file.txt");
        // 字节流转字符流
        InputStreamReader isr = new InputStreamReader(fis);
        // 高效装饰
        BufferedReader br = new BufferedReader(isr);
        // 字符流转标准输出流
        OutputStreamWriter osw= new OutputStreamWriter(System.out);
        BufferedWriter bw = new BufferedWriter(osw);
        String line = null;
        while((line=br.readLine())!=null){
            bw.write(line);
            bw.newLine();
            bw.flush(); // 如果没有这行，在主控台看不到任何输出
        }
        br.close();
    }
} /* Output:
abc
你好！Hello World
你好，世界。
*///:~

标准输入流和标准输出流都不应该调用close()方法。

打印输出流

打印输出流有两个，分别为PrintWriter字符流和PrintStream字节流。我们其实很早就接触到打印流了，只是一直不知道而已，System.out标准输出流就是PrintStream类型。

• PrintStream的构造函数
  
  • 接受一个File对象
  • 接受一个虚拟文件路径
  • 接受一个输出字节流
• PrintWriter的构造函数
  
  • 接受一个File对象
  • 接受一个虚拟文件路径
  • 接受一个输出字节流
  • 接受一个输出字符流

这两个流类通过构造器可以看出，要么对其他流进行装饰，要么指定打印输出的目的地为文件。要注意PrintWriter这个字符打印流，它可以对一个字节流进行装饰。（此便捷构造方法创建必要的中间 OutputStreamWriter，后者使用默认字符编码将字符转换为字节。）

尽管打印流的某些构造方法可能抛出异常，但是它们的方法永远不会抛出IOException。

这两个类有大类重载的print()和println()方法，正因如此，可以保持任意类型数据表现形式的原样性，将数据输出到目的地（字节流write一个字节，低8位；字符流write一个字符，低16位）。

打印流装饰其他流的时候，可以在构造时指定另一个参数为true，这将对println()、printf()或format()具有自动刷新的功能。

// print方法保证了数据的原样性
public class Print {
    public static void main(String[] args) {
        printStream();
    }
    public static void printStream() {
        System.out.print(98);
        System.out.print(610);
        // 0110-0010
        System.out.write(98);
        // 10-0110-0010
        System.out.write(610); // 输出低8位
        System.out.flush(); // 不调用将看不到输出“bb”
    }
} /* Output:
98610bb // 看到了b字符，是因为底层已经将字节查询了系统默认编码
*///:~

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.io.PrintWriter;
// 将文本文件打印输出到控制台
public class Print {
    public static void main(String[] args) throws IOException {
        printWriter1();
    }
    public static void printWriter1() throws IOException {
        BufferedReader br = new BufferedReader(new FileReader("file.txt"));
        PrintWriter pw = new PrintWriter(System.out, true); // 使println方法具有自动刷新
        String line = null;
        while ((line = br.readLine()) != null) {
            pw.println(line); // 换行和自动刷新
            // pw.flush(); // 不必调用
        }
        br.close();
    }
} /* Output:
abc
你好！Hello World
你好，世界。
*///:~

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.io.PrintWriter;
// 复制文本文件
public class Print {
    public static void main(String[] args) throws IOException {
        printWriter2();
    }
    public static void printWriter2() throws IOException {
        BufferedReader br = new BufferedReader(new FileReader("file.txt"));
        PrintWriter pw = new PrintWriter(new FileOutputStream("copy_file.txt"), true);
        String line = null;
        while((line=br.readLine())!=null){
            pw.println(line);
        }
        br.close();
        pw.close();
    }
} ///:~

打印流最常见用于Web编程（服务器将所请求的内容显示到客户端浏览器上，就是使用了PrintWriter），如果与文件结合使用也一般是纯文本，因为装饰其他流使具有自动刷新功能，常和println()方法结合使用，输出一行的前提是读取一行，只有缓冲字符流和行号缓存字符流才具有读行的功能，读入的操作是字符，所以打印输出往往为文本文件。