Java NIO 的应用

@Yi-Xing 2020-12-10 0 评论 0 浏览

JavaSE

一、NIO 简介

Java NIO ( New lO）是从 Java 1.4 版本开始引入的一个新的 IO API，可以替代标准的 Java lO API。NIO 与原来的 lO 有同样的作用和目的，但是使用的方式完全不同，NIO 支持面向缓冲区的、基于通道的 IO 操作。NIO 将以更加高效的方式进行文件的读写操作。

NIO 与 IO 的区别

IO 是通过流进行数据传输的；
NIO 面向缓冲区基于通道进行数据传输。

| IO | NIO |
| - | - |
| 面向流（Stream Oriented） | 面向缓冲区（Buffer Oriented） |
| 阻塞 IO（Blocking IO） | 非阻塞 IO（Non Blocking IO） |
| 无 | 选择器（Selectors） |

二、缓冲区（Buffer）和通道（Channel）

Java NIO 系统的核心在于：通道（Channel）和缓冲区（Buffer）。通道表示打开到 IO 设备（如：文件、套接字）的连接。若需要使用 NIO 系统，需要获取用于连接 IO 设备的通道以及用于容纳数据的缓冲区。然后操作缓冲区，对数据进行处理。

1、缓冲区

缓冲区：一个用于存储特定基本数据类型的容器（就是数组）。由 java.nio 包定义，所有缓冲区都是 Buffer 抽象类的子类。Java NIO 中的 Buffer 主要用于 NIO 通道进行交互，数据是从通道读入缓冲区，从缓冲区写入通道中的。根据数据类型不同（boolean 除外），提供了响应类型的缓冲区：ByteBuffer、CharBuffer、ShortBuffer、IntBuffer、LongBuffer、FloatBuffer、DoubleBuffer。

四个核心属性

capacity（容量）：表示缓冲区中最大存储数据的容量，一旦声明不能改变；
limit（界限）：表示缓冲区中可以操作数据的大小（limit 后的数据不能进行读写）；
position（位置）：表示缓冲区中正在操作数据的位置；
mark（标记）：标记缓冲区中的一个位置，可以通过 reset() 恢复到 mark。

之间的关系：0<=mark=position<=limit<=capacity。

（1）缓冲区的应用

基本方法如下：

allocate() 获取缓冲区（非直接缓冲区）；
put()：存入数据到缓冲区中；
get()：获取缓冲区中的数据，读取前先通过 flip() 方法进入读取模式；
（详见下）...

import org.junit.Test;

import java.nio.ByteBuffer;

/**
 * @date 2020-12-10
 */
public class TestBuffer {

    @Test
    public void test() {
        String str = "zyxwmj.top";

        //1、分配一个指定大小的缓冲区（非直接缓冲区）
        ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
        System.out.println("------allocate()------");
        System.out.println(byteBuffer.position());
        System.out.println(byteBuffer.limit());
        System.out.println(byteBuffer.capacity());

        //2、利用 put() 存入数据到缓冲区中
        byteBuffer.put(str.getBytes());
        System.out.println("------put()------");
        System.out.println(byteBuffer.position());
        System.out.println(byteBuffer.limit());
        System.out.println(byteBuffer.capacity());

        //3、切换读取数据模式
        byteBuffer.flip();

        System.out.println("------flip()------");
        System.out.println(byteBuffer.position());
        System.out.println(byteBuffer.limit());
        System.out.println(byteBuffer.capacity());

        //4、利用 get() 读取缓冲区中的数据
        byte[] value = new byte[byteBuffer.limit()];
        byteBuffer.get(value);
        System.out.println("值：" + new String(value, 0, value.length));
        System.out.println("------get()------");
        System.out.println(byteBuffer.position());
        System.out.println(byteBuffer.limit());
        System.out.println(byteBuffer.capacity());

        //5、rewind() 可重读读
        byteBuffer.rewind();
        System.out.println("------rewind()------");
        System.out.println(byteBuffer.position());
        System.out.println(byteBuffer.limit());
        System.out.println(byteBuffer.capacity());

        //6、mark() 标记
        byteBuffer.get(value, 0, 6);
        System.out.println("------mark()------");
        System.out.println("值：" + new String(value, 0, 6));
        System.out.println(byteBuffer.position());
        //标记
        byteBuffer.mark();
        byteBuffer.get(value, 0, 4);
        System.out.println("值：" + new String(value, 0, 4));
        //恢复到 mark 的位置
        byteBuffer.reset();
        System.out.println(byteBuffer.position());
        // 判断缓冲区中是否还有剩余的数据
        if (byteBuffer.hasRemaining()) {
            // 获取缓冲区中可以操作的数据数量
            System.out.println(byteBuffer.remaining());
        }

        //7、clear() 清空缓冲区，但是缓冲区中的数据依然存在，但是处于“被遗忘”状态
        byteBuffer.clear();
        System.out.println("------clear()------");
        System.out.println(byteBuffer.position());
        System.out.println(byteBuffer.limit());
        System.out.println(byteBuffer.capacity());

    }
}

运行结果：

------allocate()------
0
1024
1024
------put()------
10
1024
1024
------flip()------
0
10
1024
值：zyxwmj.top
------get()------
10
10
1024
------rewind()------
0
10
1024
------mark()------
值：zyxwmj
6
值：.top
6
4
------clear()------
0
1024
1024

（2）直接与非直接缓冲区

非直接缓冲区：通过 allocate() 方法分配缓冲区，将缓冲区建立在 JVM 的内存中；
直接缓冲区：通过 allocateDirect() 方法分配直接缓冲区，将缓冲区建立在物理内存中。

字节缓冲区要么是直接的，要么是非直接的。如果为直接字节缓冲区，则 Java 虚拟机会尽最大努力直接在此缓冲区上执行本机 I/O 操作。也就是说，在每次调用基础操作系统的一个本机 l/O 操作之前（或之后)，虚拟机都会尽量避免将缓冲区的内容复制到中间缓冲区中（或从中间缓冲区中复制内容）。
直接字节缓冲区可以通过调用此类的 allocateDirect() 工厂方法来创建。此方法返回的缓冲区进行分配和取消分配所需成本通常高于非直接缓冲区。直接缓冲区的内容可以驻留在常规的垃圾回收堆之外，因此，它们对应用程序的内存需求量造成的影响可能并不明显。所以，建议将直接缓冲区主要分配给那些易受基础系统的本机 l/O 操作影响的大型、持久的缓冲区。一般情况下，最好仅在直接缓冲区能在程序性能方面带来明显好处时分配它们。

直接字节缓冲区还可以通过 FileChannel 的 map() 方法将文件区域直接映射到内存中来创建。该方法返回 MappedByteBuffer。Java 平台的实现有助于通过 JNI 从本机代码创建直接字节缓冲区。如果以上这些缓冲区中的某个缓冲区实例指的是不可访问的内存区域，则试图访问该区域不会更改该缓冲区的内容，并且将会在访问期间或稍后的某个时间导致抛出不确定的异常。

字节缓冲区是直接缓冲区还是非直接缓冲区可通过调用其 isDirect() 方法来确定。提供此方法是为了能够在性能关键型代码中执行显式缓冲区管理。

2、通道

通道（Channel） : 由 java.nio.channels 包定义的，Channel 表示 IO 源与目标打开的连接。Channel 类似于传统的“流”，只不过 Channel 本身不能直接访问数据，Channel 只能与 Buffer 进行交互。它只负责缓冲区中数据的传输。

通道其实是一个硬件（简单版的 CPU），通道可以识别并执行一系列通道指令。与 CPU 相比，通道可以执行的指令很单一，并且通道程序是放在主机内存中的，也就是说通道与 CPU 共享内存。通道是为了减少 CPU 对 I/O 操作的干预。（该段为操作系统相关知识）

java.nio.channels.Channel 接口的实现类

FileChannel
SocketChannel
ServerSocketChannel
DatagramChannel

获取通道的方法

支持通道的类提供了 getChannel() 方法：
- 本地 I/O：FileInputStream/FileOutputStream、RandomAccessFile；
- 网络 I/O：Socket、ServerSocket、DatagraSocket。
jdk1.7 中的 NIO.2 针对各个通道提供了静态方法 open()；
jdk1.7 中的 NIO.2 的 Files 工具类的 newByteChannel()。

三、文件通道（FileChannel）

1、使用非直接存储完成文件的复制

    @Test
    public void test() {
        // jdk7 新特性，流关闭的顺序和创建的顺序是相反的
        try (FileInputStream fileInputStream = new FileInputStream("E:\\图片\\IR)TWGF7]_ZO}ZP$$H1U}8K.png");
             FileOutputStream fileOutputStream = new FileOutputStream("E:\\123.png");
             //1、获取通道
             FileChannel inChannel = fileInputStream.getChannel();
             FileChannel outChannel = fileOutputStream.getChannel()) {

            //2、分配指定大小的缓冲区
            ByteBuffer byteBuffer = ByteBuffer.allocate(1024);

            //3、将通道中的数据存入缓冲区中
            while (inChannel.read(byteBuffer) != -1) {
                // 切换读取数据的模式
                byteBuffer.flip();
                // 将缓冲区中的数据写入通道中
                outChannel.write(byteBuffer);
                // 清空缓冲区
                byteBuffer.clear();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

2、使用直接缓冲区完成文件的复制（内存映射文件）

    @Test
    public void test1() {
        try (FileChannel inChannel = FileChannel.open(Paths.get("E:\\图片\\IR)TWGF7]_ZO}ZP$$H1U}8K.png"), StandardOpenOption.READ);
             FileChannel outChannel = FileChannel.open(Paths.get("E:\\1234.png"), StandardOpenOption.WRITE, StandardOpenOption.READ, StandardOpenOption.CREATE)) {

            //内存映射文件
            MappedByteBuffer inMappedByteBuffer = inChannel.map(FileChannel.MapMode.READ_ONLY, 0, inChannel.size());

            // 注意后面用的是 inChannel.size() 不是 outChannel.size()
            MappedByteBuffer outMappedByteBuffer = outChannel.map(FileChannel.MapMode.READ_WRITE, 0, inChannel.size());

            //直接对缓冲区进行数据的读写操作
            byte[] value = new byte[inMappedByteBuffer.limit()];
            inMappedByteBuffer.get(value);
            outMappedByteBuffer.put(value);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

3、通道之间的数据传输

transferTo()：将当前通道的数据装入到指定通道中；
transferFrom()：将指定通道的数据装入到当前通道中。

    @Test
    public void test2() {
        try (FileChannel inChannel = FileChannel.open(Paths.get("E:\\图片\\IR)TWGF7]_ZO}ZP$$H1U}8K.png"), StandardOpenOption.READ);
             FileChannel outChannel = FileChannel.open(Paths.get("E:\\1234567.png"), StandardOpenOption.WRITE, StandardOpenOption.READ, StandardOpenOption.CREATE)) {
            // inChannel.transferTo(0,inChannel.size(),outChannel);
            outChannel.transferFrom(inChannel, 0, inChannel.size());
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

4、分散（Scatter）与聚集（Gather）

分散读取：将通道中的数据分散到多个缓冲区，按照缓冲区的顺序，从通道中读取的数据依次将缓冲区填满；

聚集写入：将多个缓冲区中的数据聚集到通信中，按照缓冲区的顺序，写入 position 和 limit 之间的数据到通道。写入文件后出现乱码的两种解决办法：

更改字节缓冲区大小，因为写入文件时，是根据字节数来创建文件编码类型的；
先对字节缓冲区进行解码再进行编码。

    @Test
    public void test3() {
        try (RandomAccessFile randomAccessFile = new RandomAccessFile("E:\\123.txt", "rw");
             RandomAccessFile randomAccessFile1 = new RandomAccessFile("E:\\1234.txt", "rw");
             //1、获取通道
             FileChannel inChannel = randomAccessFile.getChannel();
             FileChannel outChannel = randomAccessFile1.getChannel()) {

            //2、分配指定大小的缓冲区，如果出现乱码尝试将缓冲区大小设置为 3 的倍数。
            ByteBuffer byteBuffer1 = ByteBuffer.allocate(102);
            ByteBuffer byteBuffer2 = ByteBuffer.allocate(1023);

            //3、分散读取
            ByteBuffer[] byteBuffers = {byteBuffer1, byteBuffer2};
            inChannel.read(byteBuffers);

            System.out.println(new String(byteBuffers[0].array(), 0, byteBuffers[0].limit()));
            System.out.println("----------");
            System.out.println(new String(byteBuffers[1].array(), 0, byteBuffers[1].limit()));

            // 进入写模式
            for (ByteBuffer byteBuffer : byteBuffers) {
                byteBuffer.flip();
            }

            //4、聚集写入
            outChannel.write(byteBuffers);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

四、字符集

编码：字符串->字节数组；
解码：字节数组->字符串。

1、查看支持的所有字符集

    @Test
    public void test4() {
        // 查看支持的所有字符集
        Map<String, Charset> map = Charset.availableCharsets();
        for (Map.Entry<String, Charset> entry : map.entrySet()) {
            System.out.println(entry.getKey() + "=" + entry.getValue());
        }
    }

2、编码器和解码器的应用

    @Test
    public void test5() throws CharacterCodingException {
        Charset charset = Charset.forName("GBK");

        // 获取编码器
        CharsetEncoder charsetEncoder = charset.newEncoder();

        // 获取解码器
        CharsetDecoder charsetDecoder = charset.newDecoder();

        CharBuffer charBuffer = CharBuffer.allocate(1024);
        charBuffer.put("博客地址：zyxwmj.top");
        charBuffer.flip();

        // 编码
        ByteBuffer byteBuffer = charsetEncoder.encode(charBuffer);

        System.out.println(Arrays.toString(byteBuffer.array()));

        // 解码
        charBuffer.flip();
        System.out.println(charsetDecoder.decode(byteBuffer));

        System.out.println("-------------------");
        // Charset.forName("UTF-8")
        Charset charset1 = StandardCharsets.UTF_8;
        byteBuffer.flip();
        // 解码方式不对出现乱码，如果使用解码器则直接抛异常
        System.out.println(charset1.decode(byteBuffer));
    }

五、NIO 的非阻塞式网络通信

传统的 IO 流都是阻塞式的。也就是说，当一个线程调用 read() 或 write() 时，该线程被阻塞，直到有一些数据被读取或写入，该线程在此期间不能执行其他任务。因此，在完成网络通信进行 IO 操作时，由于线程会阻塞，所以服务器端必须为每个客户端都提供一个独立的线程进行处理，当服务器端需要处理大量客户端时，性能急剧下降。
Java NIO 是非阻塞模式的。当线程从某通道进行读写数据时，若没有数据可用时，该线程可以进行其他任务。线程通常将非阻塞 lO 的空闲时间用于在其他通道上执行 IO 操作，所以单独的线程可以管理多个输入和输出通道。因此，NIO 可以让服务器端使用一个或有限几个线程来同时处理连接到服务器端的所有客户端。

1、选择器（Selector）

选择器（Selector）是 SelectableChannel 的多路复用器。Selector 可以同时监控多个 SelectableChannel 的 IO 状况，也就是说，利用 Selector 可使一个单独的线程管理多个 Channel。Selector 是非阻塞 IO 的核心。

java.nio.channels.Channel 接口的 SelectableChannel 抽象类的实现类

SocketChannel
ServerSocketChannel
DatagramChannel
Pipe.SinkChannel
Pipe.SourceChannel

SelectionKey

SelectionKey 表示 SelectableChannel 和 Selector 之间的注册关系。每次向选择器注册通道时就会选择一个事件（选择键）。选择键包含两个表示为整数值的操作集，操作集的每一位都表示该键的通道所支持的一类可选择操作。

当调用 register(Selector sel, int ops) 为通道注册选择器时，选择器对通道的监听事件，需要通过第二个参数 ops 指定。

可以监听的事件类型：（可使用 SelectionKey 的四个常量表示）

读：SelectionKey.OP_READ；
写：SelectionKey.OP_WRITE；
连接：SelectionKey.OP_CONNECT；
接收：SelectionKey.OP_ACCEPT。

若注册时不止监听一个时间，则可以使用“位或”操作符连接。例如：

int interestSet = SelectionKey.OP_READ | SelectionKey.OP_WRITE;

常用方法：

2、BIO 的网络通信

服务端

    @Test
    public void server() {
        // 1、获取通道
        try (ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
             FileChannel outChannel = FileChannel.open(Paths.get("E:\\12.jpg"), StandardOpenOption.WRITE, StandardOpenOption.CREATE)) {

            // 2、绑定连接
            serverSocketChannel.bind(new InetSocketAddress(8080));
            System.out.println("等待连接。。。");

            // 3、获取客户端连接的通道
            try (SocketChannel socketChannel = serverSocketChannel.accept()) {
                System.out.println("连接成功");

                // 4、分配指定大小的缓冲区
                ByteBuffer byteBuffer = ByteBuffer.allocate(1024);

                // 5、接收客户端的数据，并保存到本地
                while (socketChannel.read(byteBuffer) != -1) {
                    System.out.println("正在接收数据");
                    byteBuffer.flip();
                    outChannel.write(byteBuffer);
                    byteBuffer.clear();
                }
                System.out.println("接收完毕");

                // 6、发送反馈给客户端
                byteBuffer.put("服务端接收数据成功".getBytes());
                byteBuffer.flip();
                socketChannel.write(byteBuffer);
            } catch (IOException e) {
                e.printStackTrace();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

客户端

    @Test
    public void client() {
        // 1、获取通道
        try (SocketChannel socketChannel = SocketChannel.open(new InetSocketAddress("127.0.0.1", 8080));
             FileChannel inChannel = FileChannel.open(Paths.get("E:\\图片\\12.jpg"), StandardOpenOption.READ)) {

            // 2、配置指定大小的缓冲区
            ByteBuffer byteBuffer = ByteBuffer.allocate(1024);

            // 3、读取本地文件，并发送给服务器
            while (inChannel.read(byteBuffer) != -1) {
                System.out.println("正在发送数据");
                byteBuffer.flip();
                socketChannel.write(byteBuffer);
                byteBuffer.clear();
            }
            System.out.println("发送完毕");

            // 4、在非阻塞模式中，如果客户端数据发送完毕，必须关闭连接，否则服务端一直在阻塞等待客户端发送数据
            socketChannel.shutdownOutput();

            // 5、接收服务端的反馈
            while (socketChannel.read(byteBuffer) != -1) {
                byteBuffer.flip();
                System.out.print(new String(byteBuffer.array(), 0, byteBuffer.limit()));
                byteBuffer.clear();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

3、NIO 的网络通信

服务端

    @Test
    public void server() {
        // 1、获取通道
        try (ServerSocketChannel serverSocketChannel = ServerSocketChannel.open()) {

            // 2、切换非阻塞模式
            serverSocketChannel.configureBlocking(false);

            // 3、绑定连接
            serverSocketChannel.bind(new InetSocketAddress(8080));

            // 4、获取选择器
            try (Selector selector = Selector.open()) {

                // 5、将通道注册到选择器上，并且指定“监听接收事件”
                serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);

                // 6、轮询式的获取选择器上已经“准备就绪”的事件
                System.out.println("等待...");
                while (selector.select() > 0) {

                    // 7、获取当前选择器中所有注册的“选择键（已就绪的监听事件）”
                    Iterator<SelectionKey> iterator = selector.selectedKeys().iterator();

                    while (iterator.hasNext()) {
                        // 8、获取准备“就绪”的事件
                        SelectionKey selectionKey = iterator.next();

                        // 9、判断具体是什么事件准备就绪
                        if (selectionKey.isAcceptable()) {
                            // 10、若“接收就绪”，获取客户端连接
                            SocketChannel socketChannel = serverSocketChannel.accept();

                            // 11、切换非阻塞模式
                            socketChannel.configureBlocking(false);

                            // 12、将该通道注册到选择器上
                            socketChannel.register(selector, SelectionKey.OP_READ);
                        } else if (selectionKey.isReadable()) {
                            // 13、获取当前选择器上“读就绪”状态的通道
                            SocketChannel socketChannel = (SocketChannel) selectionKey.channel();

                            // 14、读取数据
                            ByteBuffer byteBuffer = ByteBuffer.allocate(1024);

                            // 注意这里必须是 >0
                            while (socketChannel.read(byteBuffer) > 0) {
                                byteBuffer.flip();
                                System.out.println(new String(byteBuffer.array(), 0, byteBuffer.limit()));
                                byteBuffer.clear();
                            }
                        }
                        // 15、删除处理过的选择键 SelectionKey
                        iterator.remove();
                    }
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

客户端

    @Test
    public void client() {
        // 1、获取通道
        try (SocketChannel socketChannel = SocketChannel.open(new InetSocketAddress("127.0.0.1", 8080))) {

            // 2、切换非阻塞模式
            socketChannel.configureBlocking(false);

            // 3、配置指定大小的缓冲区
            ByteBuffer byteBuffer = ByteBuffer.allocate(1024);

            // 4、发送数据给服务端
//            byteBuffer.put("发送数据".getBytes());
//            byteBuffer.flip();
//            socketChannel.write(byteBuffer);
//            byteBuffer.clear();

            System.out.println("等待..");

            Scanner scanner = new Scanner(System.in);
            while (scanner.hasNext()) {
                byteBuffer.put(scanner.next().getBytes());
                byteBuffer.flip();
                socketChannel.write(byteBuffer);
                byteBuffer.clear();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

4、DatagramChannel

Java NIO 中的 DatagramChannel 是一个能收发 UDP 包的通道。

接收端

    @Test
    public void receive() {
        try (DatagramChannel datagramChannel = DatagramChannel.open()) {
            datagramChannel.configureBlocking(false);

            datagramChannel.bind(new InetSocketAddress(8080));

            try (Selector selector = Selector.open()) {

                datagramChannel.register(selector, SelectionKey.OP_READ);

                while (selector.select() > 0) {
                    Iterator<SelectionKey> iterator = selector.selectedKeys().iterator();

                    while (iterator.hasNext()) {
                        SelectionKey selectionKey = iterator.next();
                        if (selectionKey.isReadable()) {
                            ByteBuffer byteBuffer = ByteBuffer.allocate(1024);

                            datagramChannel.receive(byteBuffer);
                            byteBuffer.flip();
                            System.out.println(new String(byteBuffer.array(), 0, byteBuffer.limit()));
                            byteBuffer.clear();
                        }
                    }
                    iterator.remove();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

发送端

    @Test
    public void send() {
        try (DatagramChannel datagramChannel = DatagramChannel.open()) {

            datagramChannel.configureBlocking(false);

            ByteBuffer byteBuffer = ByteBuffer.allocate(1024);

            Scanner scanner = new Scanner(System.in);

            while (scanner.hasNext()) {
                byteBuffer.put(scanner.next().getBytes());
                byteBuffer.flip();
                datagramChannel.send(byteBuffer, new InetSocketAddress("127.0.0.1", 8080));
                byteBuffer.clear();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

六、管道（Pipe）

Java NIO 管道是 2 个线程之间的单向数据连接。Pipe 有一个 source 通道和一个 sink 通道。数据会被写到 sink 通道，从 source 通道读取。

    @Test
    public void test() {
        try {
            // 1、获取管道
            Pipe pipe = Pipe.open();

            ByteBuffer byteBuffer = ByteBuffer.allocate(1024);

            // 2、将缓冲区中的数据写入管道
            try (Pipe.SinkChannel sinkChannel = pipe.sink()) {
                byteBuffer.put("通过单向管道发送数据".getBytes());
                byteBuffer.flip();
                sinkChannel.write(byteBuffer);
            } catch (IOException e) {
                e.printStackTrace();
            }

            // 3、读取缓冲区中的数据
            try (Pipe.SourceChannel sourceChannel = pipe.source()) {
                byteBuffer.flip();
                sourceChannel.read(byteBuffer);
                System.out.println(new String(byteBuffer.array(), 0, byteBuffer.limit()));
            } catch (IOException e) {
                e.printStackTrace();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

标题：Java NIO 的应用
作者：Yi-Xing
地址：http://47.94.239.232/articles/2020/12/10/1607611588722.html
博客中若有不恰当的地方，请您一定要告诉我。前路崎岖，望我们可以互相帮助，并肩前行！