Java IO流

本文是作者在毕业入职后写的第一篇博客。
入职后因工作需要学习java编程知识，在此记录下Java IO流的相关操作（都在 java.io包里面），为后续学习网络编程奠定基础。
本文参考廖雪峰老师的 教程以及《Java核心技术》卷二。

一、文件和目录

Java提供了java.io.File类和java.nio.file.Path类用来处理文件和目录以及其路径，比较简单，不再赘述。

二、InputStream输入流

1、简介

Java标准库提供的最基本的输入流是java.io.InputStream。InputStream是一个抽象类，是所有输入流的基类。定义的最重要的方法是:

public abstract int read() throws IOException;

此方法用于读取输入流的下一个字节，并返回int值（0~255），读到末尾返回-1，有多种重载方式，如下：

abstract int read(); // 读入一个字节并返回，碰到输入流的结尾时返回-1
int read(byte[] bytes); // 读入若干字节到bytes中，返回读入的字节数或碰到输入流的结尾时返回-1
int read(byte[] bytes, int off, int len); // 未阻塞时读入len个字节并到bytes的off位置，返回实际读入的字节数或碰到输入流的结尾时返回-1

在Java 9中又添加了一些读取字节的方法：

byte[] readAllBytes(); // 产生一个包含可以从输入流中读入的所有字节的byte数组
int readNBytes(byte[] b, int off, int len); // 阻塞至读入len个字符，返回实际读入的字节数或碰到输入流的结尾时返回-1

2、基本使用

为了确保打开的输入流无论是否发生读写异常都能被正确的关闭，以便操作系统释放资源，一般我们需要在try ... finally中使用InputStream，下面使用InputStream的子类FileInputStream举例来说明：

public void readFile() throws IOException {
    InputStream input = null;
    try {
        input = new FileInputStream("readme.txt"); // 打开输入流
        int n;
        while ((n = input.read()) != -1) { // 利用while同时读取并判断
            System.out.println(n);
        }
    } finally {
        if (input != null) { 
        	input.close(); 
        }
    }
}

为了简化try ... finally的写法，Java 7引入了try-with-resource语法糖，写法如下：

public void readFile() throws IOException {
	try (InputStream input = new FileInputStream("readme.txt")) {
		int n;
		while ((n = input.read()) != -1) {
			System.out.println(n);
		}
	} // 编译器在此自动添加finally并调用close()
}

实际上，只要try(resource = ...)中的对象实现了java.lang.AutoCloseable接口，编译器就会自动添加finally并调用close()方法。

3、解决read阻塞

由于read()方法是阻塞的，无法确定read()方法调用到底要花费多长时间。InputStream提供了available()方法检查输入流有多少可读入的字节数量，下面的代码不可能被阻塞：

InputStream in = ...;
int num = in.available();
if (n > 0) {
	byte[] data = new byte[num];
	in.read(data);
}

4、重读输入流

InputStream还提供了在当前位置打标记的功能void mark(int readlimit)和返回到最后一个标记的功能void reset()，如果需要重读某些字节，可以采用这两个方法实现。这个功能用得较少，不在赘述。

三、OutputStream输出流

1、简介

Java标准库提供的最基本的输出流是java.io.OutputStream。OutputStream是一个抽象类，是所有输出流的基类。定义的最重要的方法是:

public abstract void write(int b) throws IOException;

此方法写入一个字节到输出流。虽然传入的参数是int，但只会将int的低8位部分表示的字节写入。此方法也有多种重载形式：

abstract void write(int n); // 写入一个字节的数据
void write(byte[] b); // 写入若干字节
void write(byte[] b, int off, int len); //

2、基本使用

类似于InputStream，我们可以使用try-with-resource语法糖来确保无论是否发生异常输出流都被正确地关闭，这里使用OutputStream的子类FileOutputStream举例说明：

public void writeFile() throws IOException {
	try (OutputStream output = new FileOutputStream("readme.txt")) {
		output.write("Hello".getBytes("UTF-8"));
	} // 编译器在此自动添加finally并调用close()
}

因此，OutputStream也实现了java.lang.AutoCloseable接口。

拓展：try-with-resource语法糖可以同时操作多个AutoCloseable资源，用;分开，例如，同时读写两个文件：

// 读取input.txt，写入到output.txt
try (InputStream input = new FileInputStream("input.txt");
	OutputStream output = new FileOutputStream("output.txt")) {
	input.transferTo(output);
}

3、冲刷输出缓冲区

OutputStream还提供了flush()用于将缓冲区中的内容真正输出到目的地。处于效率考虑，在向磁盘或网络写入数据时，操作系统首先把输出的字节放入内存的一个缓冲区，等到缓冲区满了再一次性写入到磁盘或网络。flush()方法用于强制将缓冲区中现有内容输出。

4、阻塞

和InputStream一样，OutputStream的write()方法也是阻塞的。

四、ByteArrayInputStream和ByteArrayOutputStream

ByteArrayInputStream和ByteArrayOutputStream分别是把一个byte[]数组在内存中编程一个InputStream和OutputStream，多用于测试。构造方法如下：

byte[] data = {72, 23, 55, 12, 5};
InputStream input = new ByteArrayInputStream(data); // 从byte数组构造ByteArrayInputStream
OutputStream output = new ByteArrayOutputStream();  // 构造ByteArrayOutputStream
data  = output.toByteArray(); // 将ByteArrayOutputStream转为byte数组

五、Filter模式

1、简介

InputStream的子类可分为两部分：

1. 直接提供数据的基础InputStream，例如FileInputStream、ByteArrayInputStream、ServletInputStream等。
2. 提供额外附加功能的InputStream，此类InputStream都是FilterInputStream的子类，例如BufferedInputStream、DigestInputStream、DataInputStream等。

例如，我们要从文件中读入数字，首先需要创建一个FileInputStream，然后将其传递给DataInputStream的构造函数创建：

InputStream fin = new FileInputStream("readme.txt");
InputStream din = new DataInputStream(fin);
double x = din.readDouble();

如果我们想要添加缓冲机制以增加读取效率，可以再添加BufferedInputStream：

InputStream din = new DataInputStream(
					new BufferedInputStream(
						new FileInputStream("readme.txt")));

对于OutputStream，与InputStream类似，不再赘述。

2、定制Filter

在定制自己的FilterInputStream之前，先简单看一下FilterInputStream的源码：

public class FilterInputStream extends InputStream {
    protected volatile InputStream in; // 提供数据的InputStream
    
    // 构造函数
    protected FilterInputStream(InputStream in) {
        this.in = in;
    }
    
    public int read() throws IOException {
        return in.read();
    }
    
    public int read(byte b[]) throws IOException {
        return read(b, 0, b.length);
    }
    
    public int read(byte b[], int off, int len) throws IOException {
        return in.read(b, off, len);
    }
    
    public long skip(long n) throws IOException {
        return in.skip(n);
    }
    
    public int available() throws IOException {
        return in.available();
    }
    
    public void close() throws IOException {
        in.close();
    }
    
    public synchronized void mark(int readlimit) {
        in.mark(readlimit);
    }
    
    public synchronized void reset() throws IOException {
        in.reset();
    }
    
    public boolean markSupported() {
        return in.markSupported();
    }
}

重点需要实现的是read函数以及一些满足自己需要的定制化的函数。下面是一个对输入的字节进行计数的CountInputStream：

class CountInputStream extends FilterInputStream {
    private int count = 0;

    CountInputStream(InputStream in) {
        super(in);
    }

    public int getBytesRead() {
        return this.count;
    }

    public int read() throws IOException {
        int n = in.read();
        if (n != -1) {
            this.count ++;
        }
        return n;
    }

    public int read(byte[] b, int off, int len) throws IOException {
        int n = in.read(b, off, len);
        if (n != -1) {
            this.count += n;
        }
        return n;
    }
}

3、操作zip

Java提供了ZipInputStream用于直接读取zip包的内容，它也是一个FilterInputStream，通常传入一个FileInputStream作为数据源，循环调用getNextEntryJ()函数，此函数返回ZipEntry对象（zip流结束时返回null），表示一个压缩文件或目录，若是压缩文件，就可以用read()不断读取，直到返回-1。下面是一个使用ZipInputStream的示例：

try (ZipInputStream zip = new ZipInputStream(new FileInputStream(...))) {
    ZipEntry entry = null;
    while ((entry = zip.getNextEntry()) != null) {
        String name = entry.getName();
        if (!entry.isDirectory()) {
            int n;
            while ((n = zip.read()) != -1) {
                ...
            }
        }
    }
}

ZipOutputStream是一种FilterOutputStream，它可以直接写入内容到zip包。我们要先创建一个ZipOutputStream，通常是包装一个FileOutputStream，然后，每写入一个文件前，先调用putNextEntry()，然后用write()写入byte[]数据，写入完毕后调用closeEntry()结束这个文件的打包。如下：

try (ZipOutputStream zip = new ZipOutputStream(new FileOutputStream(...))) {
    File[] files = ...
    for (File file : files) {
        zip.putNextEntry(new ZipEntry(file.getName()));
        zip.write(getFileDataAsBytes(file));
        zip.closeEntry();
    }
}

上面的代码没有考虑文件的目录结构。如果要实现目录层次结构，new ZipEntry(name)传入的name要用相对路径。

六、序列化

上面我们讲到的都是将byte数据输入输出，那如果我们自己定义了一个类并实例化后，想要把实例化的对象输出到文件或网络，或者想要从文件或网络将对象输入到内存，应该如何处理？答案是使用序列化的方式。对象序列化机制就是将对象转化为二进制内容，本质上就是byte[]；对象反序列化则是相反的过程。实现序列化和反序列化分别采用ObjectOutputStream和ObjectInputStream，具体用法详见《Java核心技术 卷二》P70，这里不再赘述。

七、字符输入/输出流

Reader和Writer是Java的IO库提供的以char为单位输入输出的流接口。

InputStream	Reader
字节流，以byte为单位	字符流，以char为单位
读取字节（-1，0~255）：int read()	读取字符（-1，0~65535）：int read()
读取字节数组：int read(byte[] b)	读取字符数组：int read(char[] c)

OutputStream	Writer
字节流，以byte为单位	字符流，以char为单位
写入字节（-1，0~255）：void write(int b)	读取字符（-1，0~65535）：void write(int c)
读取字节数组：void write(byte[] b)	读取字符数组：void write(char[] c)
	写入String：void write(String s)