概览

Java 的 I/O 大概可以分为以下几类：

• 磁盘操作：File
• 字节操作：InputStream 与 OutputStream
• 字符操作：Reader 与 Writer
• 对象操作：Serializable
• 网络操作：Socket
• 新的输入 / 输出：NIO

磁盘操作

File 类可以用于表示文件和目录的信息，但是它不表示文件的内容。

// 递归地列出一个目录下所有文件
public static void listAllFiles(File dir) {
    if (dir == null || !dir.exists()) {
        return;
    }
    if (dir.isFile()) {
        System.out.println(dir.getName());
        return;
    }
    for (File file : dir.listFiles()) {
        listAllFiles(file);
    }
}

从 Java7 开始，可以使用 Paths 和 Files 代替 File。

字节操作

文件复制

public static void copyFile(String src, String dist) throws IOException {
    FileInputStream in = new FileInputStream(src);
    FileOutputStream out = new FileOutputStream(dist);

    byte[] buffer = new byte[20 * 1024];
    int cnt;

    // read() 最多读取 buffer.length 个字节
    // 返回的是实际读取的个数
    // 返回 -1 的时候表示读到 eof，即文件尾
    while ((cnt = in.read(buffer, 0, buffer.length)) != -1) {
        out.write(buffer, 0, cnt);
    }

    in.close();
    out.close();
}

装饰者模式

• 概念：不改变现有对象的结构，动态的给对象添加一些额外的属性或行为。相比于使用继承，装饰者模式更加灵活。

Java I/O 使用了装饰者模式来实现。以 InputStream 为例，

• InputStream 是抽象组件
• FileInputStream 是 InputStream 的子类，属于具体组件，提供了字节流的输入操作
• FilterInputStream 属于抽象装饰者，装饰者用于装饰组件，为组件提供额外的功能。该类可为装饰器类提供接口，以控制特定输入流与输出流。例如 BufferedInputStream 为 FileInputStream 提供缓存的功能。
  
  实例化一个具有缓存功能的字节流对象时，只需要在 FileInputStream 对象上再套一层 BufferedInputStream 对象即可。

FileInputStream fileInputStream = new FileInputStream(filePath);
BufferedInputStream bufferedInputStream = new BufferedInputStream(fileInputStream);

DataInputStream 装饰者提供了对更多数据类型进行输入的操作，比如 int、double 等基本类型。

字符操作

编码与解码

编码就是把字符转换为字节，而解码是把字节重新组合成字符。

如果编码和解码过程使用不同的编码方式那么就出现了乱码。

• GBK 编码中，中文字符占 2 个字节，英文字符占 1 个字节；
• UTF-8 编码中，中文字符占 3 个字节，英文字符占 1 个字节；
• UTF-16be 编码中，中文字符和英文字符都占 2 个字节。

UTF-16be 中的 be 指的是 Big Endian，也就是大端。相应地也有 UTF-16le，le 指的是 Little Endian，也就是小端。

Java 的内存编码使用双字节编码 UTF-16be，这不是指 Java 只支持这一种编码方式，而是说 char 这种类型使用 UTF-16be 进行编码。char 类型占 16 位，也就是两个字节，Java 使用这种双字节编码是为了让一个中文或者一个英文都能使用一个 char 来存储。

String 的编码方式

String 可以看成一个字符序列，可以指定一个编码方式将它编码为字节序列，也可以指定一个编码方式将一个字节序列解码为 String。

String str1 = "中文";
byte[] bytes = str1.getBytes("UTF-8");
String str2 = new String(bytes, "UTF-8");
System.out.println(str2);

在调用无参数 getBytes () 方法时，默认的编码方式不是 UTF-16be。双字节编码的好处是可以使用一个 char 存储中文和英文，而将 String 转为 bytes [] 字节数组就不再需要这个好处，因此也就不再需要双字节编码。getBytes () 的默认编码方式与平台有关，一般为 UTF-8。

byte[] bytes = str1.getBytes();

Reader 与 Writer

不管是磁盘还是网络传输，最小的存储单元都是字节，而不是字符。但是在程序中操作的通常是字符形式的数据，因此需要提供对字符进行操作的方法。

• InputStreamReader 实现从字节流解码成字符流
• OutputStreamWriter 实现字符流编码成为字节流

// 实现逐行输出文本文件的内容
public static void readFileContent(String filePath) throws IOException {
    FileReader fileReader = new FileReader(filePath);
    BufferedReader bufferedReader = new BufferedReader(fileReader);

    String line;
    while ((line = bufferedReader.readLine()) != null) {
        System.out.println(line);
    }

    // 装饰者模式使得 BufferedReader 组合了一个 Reader 对象
    // 在调用 BufferedReader 的 close() 方法时会去调用 Reader 的 close() 方法
    // 因此只要一个 close() 调用即可
    bufferedReader.close();
}

对象操作

序列化概念

• 保存（持久化）对象及其状态到内存或磁盘

  Java 平台允许在内存中创建可复用的 Java 对象，但在一般情况下，只有在 JVM 处于运行时，这些对象才有可能存在，即对象的生命周期不会长于 JVM 的生命周期。

  现实应用中，存在在 JVM 停止运行之后能够保存（持久化）对象，并在将来重新读取被保存对象的需求。则借以序列化实现。

• 序列化对象以字节数组保存（静态成员不保存）

  在保存对象时，会将其状态保存为一组字节，将来再将这些字节组装成对象。

  此处所说的状态是指其成员变量。因此，序列化不会关注类中的静态变量（类的状态）。

• 序列化用户远程对象传输

  在使用远程方法调用（Remote Method Invocation，RMI）或在网络中传递对象时都会用到对象序列化。

• JavaBeans

  使用时在设计阶段配置其状态信息，保存状态信息以供程序启动时进行后期恢复

• 字节序列完全以存储的二进制位为基础构造，不调用任何构造器，可完全恢复为原始对象

Serializable 实现序列化

序列化的类需要实现 Serializable 接口，它只是一个标准，没有任何方法需要实现，但是如果不去实现它的话而进行序列化，会抛出异常。

• 序列化：ObjectOutputStream.writeObject ()
• 反序列化：ObjectInputStream.readObject ()
• 在类中增加 writeObject() 和 readObject() 可以实现自定义序列化

public static void main(String[] args) throws IOException, ClassNotFoundException {

    A a1 = new A(123, "abc");
    String objectFile = "file/a1";

    ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream(objectFile));
    objectOutputStream.writeObject(a1);
    objectOutputStream.close();

    ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream(objectFile));
    A a2 = (A) objectInputStream.readObject();
    objectInputStream.close();
    System.out.println(a2);
}

private static class A implements Serializable {
    private int x;
    private String y;

    A(int x, String y) {
        this.x = x;
        this.y = y;
    }

    @Override
    public String toString() {
        return "x = " + x + " " + "y = " + y;
    }
}

transient

• 在变量声明前加上 transient 关键字，可以阻止该变量被序列化到文件中，在被反序列化后，transient 变量的值被设为初始值，如 int 型的是 0，对象型的是 null。

ArrayList 中存储数据的数组 elementData 是用 transient 修饰的，因为这个数组是动态扩展的，并不是所有的空间都被使用，因此就不需要所有的内容都被序列化。通过重写序列化和反序列化方法，使得可以只序列化数组中有内容的那部分数据。

private transient Object[] elementData;

序列化 ID

**情境：**两个客户端 A 和 B 试图通过网络传递对象数据，A 端将对象 C 序列化为二进制数据再传给 B，B 反序列化得到 C。

**问题：**C 对象的全类路径假设为 com.inout.Test，在 A 和 B 端都有这么一个类文件，功能代码完全一致。也都实现了 Serializable 接口，但是反序列化时总是提示不成功。

// A 端
package com.inout; 
import java.io.Serializable; 

public class A implements Serializable { 
    private static final long serialVersionUID = 1L; 
    private String name; 

    public String getName() { 
        return name; 
    } 

    public void setName(String name) { 
        this.name = name; 
    } 
} 

// B 端
package com.inout; 
import java.io.Serializable; 

public class A implements Serializable { 
    private static final long serialVersionUID = 2L; 
    private String name; 

    public String getName() { 
        return name; 
    } 

    public void setName(String name) { 
        this.name = name; 
    } 
}

**解决：**虚拟机是否允许反序列化，不仅取决于类路径和功能代码是否一致，一个非常重要的一点是两个类的序列化 ID 是否一致（就是 private static final long serialVersionUID = 1L）。清单 1 中，虽然两个类的功能代码完全一致，但是序列化 ID 不同，他们无法相互序列化和反序列化。

特殊序列化 Externalizable

• 在恢复原始对象时会调用所有普通默认构造器（包括字段定义时的初始化），并在默认情况不保存任何字段，变量变为默认值。
• 新增 writeExternal() 和 readExternal()（搭配操作）。这两个方法会在序列化和反序列化还原的过程中被自动调用，以便执行一些特殊的操作，如序列化时写入变量值与反序列化时根据写入值初始化变量等。

网络操作

Java 中的网络支持：

• InetAddress：用于表示网络上的硬件资源，即 IP 地址
• URL：统一资源定位符
• Sockets：使用 TCP 协议实现网络通信
• Datagram：使用 UDP 协议实现网络通信

InetAddress

没有公有的构造函数，只能通过静态方法来创建实例。

InetAddress.getByName(String host);
InetAddress.getByAddress(byte[] address);

URL

可以直接从 URL 中读取字节流数据。

public static void main(String[] args) throws IOException {

    URL url = new URL("http://www.baidu.com");

    /* 字节流 */
    InputStream is = url.openStream();
    /* 字符流 */
    InputStreamReader isr = new InputStreamReader(is, "utf-8");
    /* 提供缓存功能 */
    BufferedReader br = new BufferedReader(isr);

    String line;
    while ((line = br.readLine()) != null) {
        System.out.println(line);
    }

    br.close();
}

Sockets

• ServerSocket：服务器端类
• Socket：客户端类
• 服务器和客户端通过 InputStream 和 OutputStream 进行输入输出
  

Datagram

• DatagramSocket：通信类
• DatagramPacket：数据包类

阻塞 IO 模型

传统 IO 模型在读写过程中会发生阻塞现象

当用户线程发出 IO 请求后，内核会去查看数据是否就绪，若数据没有就绪则会等待其就绪，使得用户线程处于阻塞状态，交出 CPU。当数据就绪之后，内核会将数据拷贝到用户线程，并返回结果给用户线程，此时用户线程才解除 block 状态。

典型阻塞 IO 模型实例：data = socket.read()，若数据没有就绪则会一直阻塞在 read() 方法。

非阻塞 IO 模型

• 当用户线程发起一个 read 操作后，并不需要等待，而是马上得到结果。

  若结果是 error ，线程得知数据尚未就绪，于是它可以再次发送 read 操作。一旦内核中的数据准备好了，并且又再次收到了用户线程的请求，那么它马上就将数据拷贝到了用户线程，继而返回。

  所以事实上，在非阻塞 IO 模型中，用户线程需要不断地询问内核数据是否就绪，即非阻塞 IO 不会交出 CPU ，而会一直占用 CPU。典型的非阻塞 IO 模型一般如下：

while(true) {
	data = socket.read();
	if(data!= error) {
	// 处理数据
	break;
	}
}

但是对于非阻塞 IO 就有一个非常严重的问题，在 while 循环中需要不断地去询问内核数据是否就绪，这样会导致 CPU 占用率非常高，因此一般情况下很少使用 while 循环这种方式来读取数据。

多路复用 IO 模型

• 多路复用 IO 模型是目前使用较多的模型，Java NIO 实际上也是多路复用 IO 模型。
• 在该模型中，会有一个线程不断去轮询多个 socket 的状态，只有当 socket 真正出现读写事件时，才真正调用实际的 IO 读写操作。大大减少了资源占用。
• 可使用单个线程管理多个 socket，系统无需建立新的线程或进程，也无需对其进行管理。
• 适用于连接数较多的情况。

与非阻塞 IO 模型性能对比

• 效率高于非阻塞 IO 模型

  因为在非阻塞 IO 模型中，轮询 socket 状态通过用户线程进行，而在多路复用 IO 中，轮询每个 socket 状态是内核在进行的，效率比用户线程高的多。

问题

多路复用IO模型通过轮询的方式来检测是否有事件到达，并且对到达的事件逐一进行响应。

因此对于多路复用IO模型来说，一旦事件响应体很大，那么就会导致后续的事件迟迟得不到处理，并且会影响新的事件轮询。

信号驱动 IO 模型

1. 当用户线程发起 IO 请求操作，会给对应的 socket 注册信号函数
2. 用户线程会继续执行，当内核数据就绪时会发送信号给用户线程
3. 用户线程接收到信号之后，便在信号函数中调用 IO 读写操作来进行实际的 IO 请求操作

异步 IO 模型

• 流程原理：用户线程仅需发起请求，而后等待内核返回的成功信号即可直接使用数据
  1. 用户线程发起 read 操作后，可继续执行其他操作
  2. 从内核的角度，接收到一个 asynchronous read 后，它会立刻返回，表明 read 请求成功发起，并且不会对用户线程产生任何 block
  3. 内核等待数据准备完成并将数据拷贝到用户线程
  4. 内核给用户线程发送信号，告知其 read 操作已完成
• IO 操作的两个阶段都不会阻塞用户线程，由内核自动完成并发送信号告知用户线程。在用户线程中不需要再次调用 IO 函数进行具体的读写，收到信号即代表 IO 操作已经完成。
• 需要操作系统的底层支持，在 Java 7 中，提供了 Asynchronous IO

NIO

流与块

• I/O 与 NIO 最重要的区别是数据打包和传输的方式，I/O 以流的方式处理数据，而 NIO 以块的方式处理数据。I/O 面向流、NIO 面向缓冲区。
• 面向流的 I/O 一次处理一个字节数据：一个输入流产生一个字节数据，一个输出流消费一个字节数据。为流式数据创建过滤器非常容易，链接几个过滤器，以便每个过滤器只负责复杂处理机制的一部分。不利的一面是，面向流的 I/O 通常相当慢。
• 面向块的 I/O 一次处理一个数据块，按块处理数据比按流处理数据要快得多。但是面向块的 I/O 缺少一些面向流的 I/O 所具有的优雅性和简单性。
• I/O 包和 NIO 已经很好地集成了，java.io.* 已经以 NIO 为基础重新实现了，所以现在它可以利用 NIO 的一些特性。例如，java.io.* 包中的一些类包含以块的形式读写数据的方法，这使得即使在面向流的系统中，处理速度也会更快。
• NIO 的实现结构更接近于操作系统执行 IO 的方式，由通道与缓冲区结合实现。

通道

通道 Channel 是对原 I/O 包中的流的模拟，可以通过它读取和写入数据。

通道与流的不同之处在于，流只能在一个方向上移动 (一个流必须是 InputStream 或者 OutputStream 的子类)，而通道是双向的，可以用于读、写或者同时用于读写。

类型

• FileChannel：从文件中读写数据
• DatagramChannel：通过 UDP 读写网络中数据
• SocketChannel：通过 TCP 读写网络中数据
• ServerSocketChannel：可以监听新进来的 TCP 连接，对每一个新进来的连接都会创建一个 SocketChannel

适用场景

• 传送用于读写的 ByteBuffer （缓冲区数据）

• 锁定文件的某些区域用于独占式访问

  FileLock 类的 tryLock()（设法获取锁，已被其他线程持有无法获取时从方法调用返回）、lock()（阻塞线程直到锁可以获取）

  共享锁支持由底层操作系统提供，若操作系统不支持共享锁并为每一个请求都创建一个锁则使用独占锁

缓冲区

发送给一个通道的所有数据都必须首先放到缓冲区中，同样地，从通道中读取的任何数据都要先读到缓冲区中。即不会直接对通道进行读写数据，而是要先经过缓冲区。

缓冲区实质上是一个连续数组，但它不仅仅是一个数组。缓冲区提供了对数据的结构化访问，而且还可以跟踪系统的读 / 写进程。

类型

• ByteBuffer
• CharBuffer
• ShortBuffer
• IntBuffer
• LongBuffer
• FloatBuffer
• DoubleBuffer

适用场景

• 大部分映射

缓冲区状态变量

• capacity：最大容量
• position：当前已经读写的字节数
• limit：还可以读写的字节数

状态变量的改变过程举例：

① 新建一个大小为 8 个字节的缓冲区，此时 position 为 0，而 limit = capacity = 8。capacity 变量不会改变，下面的讨论会忽略它。

② 从输入通道中读取 5 个字节数据写入缓冲区中，此时 position 为 5，limit 保持不变。

③ 在将缓冲区的数据写到输出通道之前，需要先调用 flip () 方法将 limit 设置为当前 position，并将 position 设置为 0。

④ 从缓冲区中取 4 个字节到输出缓冲中，此时 position 设为 4。

⑤ 最后需要调用 clear () 方法来清空缓冲区，此时 position 和 limit 都被设置为最初位置。

文件 NIO 实例

以下展示了使用 NIO 快速复制文件的实例：

public static void fastCopy(String src, String dist) throws IOException {

    /* 获得源文件的输入字节流 */
    FileInputStream fin = new FileInputStream(src);
    /* 获取输入字节流的文件通道 */
    FileChannel fcin = fin.getChannel();
    /* 获取目标文件的输出字节流 */
    FileOutputStream fout = new FileOutputStream(dist);
    /* 获取输出字节流的文件通道 */
    FileChannel fcout = fout.getChannel();
    /* 为缓冲区分配 1024 个字节 */
    ByteBuffer buffer = ByteBuffer.allocateDirect(1024);

    while (true) {
        /* 从输入通道中读取数据到缓冲区中 */
        int r = fcin.read(buffer);
        /* read() 返回 -1 表示 EOF */
        if (r == -1) {
            break;
        }
        /* 切换读写 */
        buffer.flip();
        /* 把缓冲区的内容写入输出文件中 */
        fcout.write(buffer);
        /* 清空缓冲区 */
        buffer.clear();
    }
}

选择器

• NIO 常常被叫做非阻塞 IO，主要是因为 NIO 在网络通信中的非阻塞特性被广泛使用。

• NIO 实现了 IO 多路复用中的 Reactor 模型，一个线程 Thread 使用一个选择器 Selector 通过轮询的方式去监听多个通道 Channel 上的事件，从而让一个线程就可以处理多个事件。

  Selector 类是 NIO 的核心类，Selector 能够检测多个注册的通道上是否有事件发生，如果有事件发生，便获取事件然后针对每个事件进行相应的响应处理。

• 通过配置监听的通道 Channel 为非阻塞，那么当 Channel 上的 IO 事件还未到达时，就不会进入阻塞状态一直等待，而是继续轮询其它 Channel，找到 IO 事件已经到达的 Channel 执行。

  只有套接字 Channel 才能配置为非阻塞，而 FileChannel 不能，为 FileChannel 配置非阻塞也没有意义。

• 只有在连接真正有读写事件发生时才会调用函数来进行读写，则大大地减少了系统开销，并且不必为每个连接都创建一个线程，不用去维护多个线程，并且避免了多线程之间的上下文切换导致的开销。
  

创建选择器

Selector selector = Selector.open();

注册通道至选择器

ServerSocketChannel ssChannel = ServerSocketChannel.open();
ssChannel.configureBlocking(false);
ssChannel.register(selector, SelectionKey.OP_ACCEPT);

通道必须配置为非阻塞模式，否则使用选择器就没有任何意义了，因为如果通道在某个事件上被阻塞，那么服务器就不能响应其它事件，必须等待这个事件处理完毕才能去处理其它事件，显然这和选择器的作用背道而驰。

在将通道注册到选择器上时，还需要指定要注册的具体事件，主要有以下几类：

• SelectionKey.OP_CONNECT
• SelectionKey.OP_ACCEPT
• SelectionKey.OP_READ
• SelectionKey.OP_WRITE

它们在 SelectionKey 的定义如下：

public static final int OP_READ = 1 << 0;
public static final int OP_WRITE = 1 << 2;
public static final int OP_CONNECT = 1 << 3;
public static final int OP_ACCEPT = 1 << 4;

可以看出每个事件可以被当成一个位域，从而组成事件集整数。例如：

int interestSet = SelectionKey.OP_READ | SelectionKey.OP_WRITE;

监听事件

int num = selector.select();

使用 select () 来监听到达的事件，它会一直阻塞直到有至少一个事件到达。

获取到达的事件

Set<SelectionKey> keys = selector.selectedKeys();
Iterator<SelectionKey> keyIterator = keys.iterator();
while (keyIterator.hasNext()) {
    SelectionKey key = keyIterator.next();
    if (key.isAcceptable()) {
        // ...
    } else if (key.isReadable()) {
        // ...
    }
    keyIterator.remove();
}

事件循环

因为一次 select () 调用不能处理完所有的事件，并且服务器端有可能需要一直监听事件，因此服务器端处理事件的代码一般会放在一个死循环内。

while (true) {
    int num = selector.select();
    Set<SelectionKey> keys = selector.selectedKeys();
    Iterator<SelectionKey> keyIterator = keys.iterator();
    while (keyIterator.hasNext()) {
        SelectionKey key = keyIterator.next();
        if (key.isAcceptable()) {
            // ...
        } else if (key.isReadable()) {
            // ...
        }
        keyIterator.remove();
    }
}

套接字 NIO 实例

public class NIOServer {
    public static void main(String[] args) throws IOException {
        Selector selector = Selector.open();

        ServerSocketChannel ssChannel = ServerSocketChannel.open();
        ssChannel.configureBlocking(false);	// 非阻塞
        ssChannel.register(selector, SelectionKey.OP_ACCEPT);

        ServerSocket serverSocket = ssChannel.socket();
        InetSocketAddress address = new InetSocketAddress("127.0.0.1", 8888);
        serverSocket.bind(address);

        while (true) {
            selector.select();
            Set<SelectionKey> keys = selector.selectedKeys();
            Iterator<SelectionKey> keyIterator = keys.iterator();

            while (keyIterator.hasNext()) {
                SelectionKey key = keyIterator.next();

                if (key.isAcceptable()) {
                    ServerSocketChannel ssChannel1 = (ServerSocketChannel) key.channel();
                    // 服务器会为每个新连接创建一个 SocketChannel
                    SocketChannel sChannel = ssChannel1.accept();
                    sChannel.configureBlocking(false);
                    // 这个新连接主要用于从客户端读取数据
                    sChannel.register(selector, SelectionKey.OP_READ);

                } else if (key.isReadable()) {
                    SocketChannel sChannel = (SocketChannel) key.channel();
                    System.out.println(readDataFromSocketChannel(sChannel));
                    sChannel.close();
                }
                keyIterator.remove();
            }
        }
    }

    private static String readDataFromSocketChannel(SocketChannel sChannel) throws IOException {
        ByteBuffer buffer = ByteBuffer.allocate(1024);
        StringBuilder data = new StringBuilder();

        while (true) {
            buffer.clear();
            int n = sChannel.read(buffer);
            if (n == -1) {
                break;
            }
            buffer.flip();
            int limit = buffer.limit();
            char[] dst = new char[limit];
            for (int i = 0; i < limit; i++) {
                dst[i] = (char) buffer.get(i);
            }
            data.append(dst);
            buffer.clear();
        }
        return data.toString();
    }
}

public class NIOClient {
    public static void main(String[] args) throws IOException {
        Socket socket = new Socket("127.0.0.1", 8888);
        OutputStream out = socket.getOutputStream();
        String s = "hello world";
        out.write(s.getBytes());
        out.close();
    }
}

内存映射文件

内存映射文件 I/O 是一种读取和写入文件数据的方法，它可以比常规的基于流或者基于通道的 I/O 快得多。允许创建和修改因大小过大而无法放入内存的文件，其假定整个文件都放在内存中并将其作为巨大数组来访问。

向内存映射文件写入可能是危险的，只是改变数组的单个元素这样的简单操作，就可能会直接修改磁盘上的文件。修改数据与将数据保存到磁盘是没有分开的。

下面代码行将文件的前 1024 个字节映射到内存中，map () 方法返回一个 MappedByteBuffer，它是 ByteBuffer 的子类。因此，可以像使用其他任何 ByteBuffer 一样使用新映射的缓冲区，操作系统会在需要时负责执行映射。

MappedByteBuffer mbb = fc.map(FileChannel.MapMode.READ_WRITE, 0, 1024);

对比

NIO 与普通 I/O 的区别主要有以下两点：

• NIO 是非阻塞的；
• NIO 面向块（缓冲区），I/O 面向流。

• 参考：
  https://cyc2018.github.io/CS-Notes/#/notes/Java IO
  《Java 编程思想第四版》