Java IO和NIO的基本概念和API详解

一、 Java IO (Blocking IO)

基本概念

• Java IO 是 Java 平台提供的用于进行输入和输出操作的 API。
• Java IO 基于 流 (Stream) 的模型，数据像水流一样从一个地方流向另一个地方。
• Java IO 主要是 阻塞式 I/O (Blocking I/O)，即线程在执行 I/O 操作时会被阻塞，直到操作完成。
• 传统IO指的是java.io包下的部分组件（File, InputStream, OutputStream, Reader, Writer）。

IO 流的分类

按数据传输方向：

• 输入流 (Input Stream)： 用于从数据源读取数据（例如，从文件、网络连接、键盘等）。 以 InputStream 或 Reader 作为基类。
• 输出流 (Output Stream)： 用于将数据写入到目标（例如，写入到文件、网络连接、控制台等）。 以 OutputStream 或 Writer 作为基类。

按数据传输单位：

• 字节流 (Byte Stream)： 以字节 (8 bits) 为单位进行数据传输。 以 InputStream 和 OutputStream 作为基类。 适用于处理二进制数据（例如，图片、音频、视频等）。
• 字符流 (Character Stream)： 以字符 (16 bits) 为单位进行数据传输。 以 Reader 和 Writer 作为基类。 适用于处理文本数据。

核心类和接口

InputStream (字节输入流)：

• FileInputStream: 从文件中读取字节。
• ByteArrayInputStream: 从字节数组中读取字节。
• ObjectInputStream: 从对象流中读取对象。
• BufferedInputStream: 带缓冲的字节输入流，提高读取效率。

OutputStream (字节输出流)：

• FileOutputStream: 向文件中写入字节。
• ByteArrayOutputStream: 向字节数组中写入字节。
• ObjectOutputStream: 向对象流中写入对象。
• BufferedOutputStream: 带缓冲的字节输出流，提高写入效率。

Reader (字符输入流)：

• FileReader: 从文件中读取字符。
• CharArrayReader: 从字符数组中读取字符。
• BufferedReader: 带缓冲的字符输入流，提高读取效率。
• InputStreamReader: 将字节输入流转换为字符输入流（需要指定字符编码）。

Writer (字符输出流)：

• FileWriter: 向文件中写入字符。
• CharArrayWriter: 向字符数组中写入字符。
• BufferedWriter: 带缓冲的字符输出流，提高写入效率。
• OutputStreamWriter: 将字节输出流转换为字符输出流（需要指定字符编码）。
• File: 表示文件或目录的抽象表示。

IO 操作流程 (以读取文件为例)

1. 创建 File 对象： 指定要读取的文件路径。
2. 创建 FileInputStream 对象： 将 File 对象作为参数传递给 FileInputStream 的构造方法，创建一个 FileInputStream 对象。
3. 创建 BufferedInputStream 对象 (可选)： 将 FileInputStream 对象作为参数传递给 BufferedInputStream 的构造方法，创建一个 BufferedInputStream 对象，提高读取效率。
4. 读取数据： 使用 read() 方法从输入流中读取数据。
5. 关闭流： 在完成读取操作后，务必关闭输入流，释放资源（先关闭 BufferedInputStream，再关闭 FileInputStream）。

代码示例 (读取文件内容)：

import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;

public class IOExample {
    public static void main(String[] args) {
        File file = new File("test.txt"); // 替换为你的文件路径

        try (FileInputStream fis = new FileInputStream(file);
             BufferedInputStream bis = new BufferedInputStream(fis)) { // 使用 try-with-resources 语句，自动关闭流

            byte[] buffer = new byte[1024];
            int bytesRead;

            while ((bytesRead = bis.read(buffer)) != -1) {
                // 处理读取到的数据
                String data = new String(buffer, 0, bytesRead);
                System.out.print(data);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

二、 Java NIO (Non-blocking IO)

基本概念

• Java NIO 是 Java 1.4 引入的一组新的 I/O API，旨在提供高性能、非阻塞的 I/O 操作。
• NIO 使用 通道 (Channel) 和 缓冲区 (Buffer) 的模型，而不是流。
• NIO 主要是 非阻塞式 I/O (Non-blocking I/O)，即线程在执行 I/O 操作时不会被阻塞，而是可以执行其他任务。
• NIO 使用 选择器 (Selector) 来监听多个通道的事件，实现单线程管理多个连接。

核心组件

通道 (Channel):

• 通道类似于流，但可以进行双向数据传输（既可以读取数据，也可以写入数据）。
• 常见的通道：
  • FileChannel: 用于文件 I/O。
  • SocketChannel: 用于 TCP 网络 I/O (客户端)。
  • ServerSocketChannel: 用于 TCP 网络 I/O (服务器端)。
  • DatagramChannel: 用于 UDP 网络 I/O。

缓冲区 (Buffer):

• 缓冲区是用于存储数据的容器，本质上是一个字节数组 (ByteBuffer) 或字符数组 (CharBuffer)。
• NIO 使用缓冲区进行数据传输，而不是直接从通道读取数据或向通道写入数据。
• 常见的缓冲区：
  • ByteBuffer: 字节缓冲区。
  • CharBuffer: 字符缓冲区。
  • ShortBuffer: 短整型缓冲区。
  • IntBuffer: 整型缓冲区。
  • LongBuffer: 长整型缓冲区。
  • FloatBuffer: 浮点型缓冲区。
  • DoubleBuffer: 双精度浮点型缓冲区。

选择器 (Selector):

• 选择器允许单个线程监听多个通道的事件（例如连接建立、数据可读、数据可写等）。
• 使用选择器可以避免为每个连接创建一个线程，从而提高并发性能。

NIO 操作流程 (以读取 SocketChannel 数据为例)

1. 创建 ServerSocketChannel： 监听客户端连接。
2. 创建 SocketChannel： 接受客户端连接。
3. 将 SocketChannel 注册到 Selector： 指定要监听的事件（例如 OP_READ, OP_WRITE, OP_CONNECT, OP_ACCEPT）。
4. 创建 ByteBuffer： 用于存储读取到的数据。
5. 调用 selector.select() 方法： 阻塞等待有事件发生的通道。
6. 获取就绪的通道： selector.selectedKeys() 返回所有就绪通道的集合。
7. 处理事件： 遍历就绪通道的集合，根据不同的事件类型执行相应的操作（例如读取数据、写入数据）。
8. 读取数据： 调用 channel.read(buffer) 从通道读取数据到缓冲区。
9. 处理缓冲区数据： 从缓冲区读取数据并进行处理。
10. 关闭通道和选择器： 在完成操作后，务必关闭通道和选择器，释放资源。

代码示例 (使用 SocketChannel 读取数据)：

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SocketChannel;

public class NIOExample {
    public static void main(String[] args) throws IOException {
        // 1. 创建 SocketChannel
        SocketChannel socketChannel = SocketChannel.open();
        socketChannel.connect(new InetSocketAddress("www.example.com", 80));
        socketChannel.configureBlocking(false); // 设置为非阻塞模式

        // 2. 创建 ByteBuffer
        ByteBuffer buffer = ByteBuffer.allocate(1024);

        // 3. 从 Channel 读取数据到 Buffer
        int bytesRead = socketChannel.read(buffer);

        while (bytesRead > 0) {
            // 切换到读模式
            buffer.flip();

            // 4. 从 Buffer 读取数据
            while (buffer.hasRemaining()) {
                System.out.print((char) buffer.get());
            }

            // 清空 Buffer，准备下一次读取
            buffer.clear();
            bytesRead = socketChannel.read(buffer);
        }

        socketChannel.close();
    }
}

三、 Java IO 与 NIO 的区别

四、 选择哪种 I/O 模式？

• 如果你的应用是低并发、连接数较少，并且可以接受阻塞，那么 Java IO 仍然是一个不错的选择，因为它简单易用。
• 如果你的应用是高并发、连接数较多，并且对性能要求很高，那么应该使用 Java NIO。
• 一般情况建议直接使用NIO模型，性能更好。

总结

Java IO 和 NIO 都是 Java 平台提供的用于进行输入和输出操作的 API。

Java IO 基于流的模型，使用简单但性能较低； Java NIO 基于通道和缓冲区的模型，提供高性能、非阻塞的 I/O 操作。

以上为个人经验，希望能给大家一个参考，也希望大家多多支持脚本之家。

最新评论