Java 中的IO

IO介绍

IO示例

如何使用缓冲流提高性能

扫描二维码关注公众号，回复： 16805708 查看本文章

示例1：接收客户端连接并向客户端发送消息

示例2：监听客户端连接，并将客户端发送的消息回显给客户端

示例3：接受多个客户端连接并回显客户端发送

NIO的应用领域

IO介绍

Java的IO（Input/Output，输入/输出）是用于处理数据的一种机制，它允许你从外部源读取数据（输入）或将数据写入外部目标（输出）。Java的IO库提供了多种类和方法，用于在Java程序中执行各种IO操作。以下是Java IO的一些基础知识：

流（Streams）：

流是Java IO的核心概念之一，它代表了数据在程序和外部设备之间的传输通道。

Java的流分为输入流（用于读取数据）和输出流（用于写入数据）。

常见的流类包括InputStream、OutputStream、Reader和Writer。

字节流和字符流：

字节流（Byte Streams）用于处理二进制数据，适用于图像、音频、视频等文件。

字符流（Character Streams）用于处理文本数据，适用于文本文件等。

字节流通常以InputStream和OutputStream为基础，字符流以Reader和Writer为基础。

文件IO：

Java的File类用于操作文件和目录。你可以创建、删除、重命名、检查文件是否存在等。

用于文件IO的常见类包括FileInputStream、FileOutputStream、FileReader和FileWriter。

缓冲流（Buffered Streams）：

缓冲流是对基本流的包装，它们通过内部缓冲区提高了IO操作的性能。

常见的缓冲流包括BufferedInputStream、BufferedOutputStream、BufferedReader和BufferedWriter。

数据流（Data Streams）：

数据流用于以原始数据类型而不是字节或字符的形式读写数据。

DataInputStream和DataOutputStream是用于数据流的类。

对象序列化：

Java提供了对象序列化机制，允许对象以字节流的形式进行持久化，以便在不同的Java虚拟机之间传输或存储。

用于对象序列化的类包括ObjectInputStream和ObjectOutputStream。

管道流（Piped Streams）：

管道流用于在线程之间进行通信。一个线程可以将数据写入管道，另一个线程可以从管道中读取数据。

PipedInputStream和PipedOutputStream用于字节流，PipedReader和PipedWriter用于字符流。

处理异常：

在处理IO操作时，需要处理可能出现的异常，如IOException。

通常使用try-catch块来捕获和处理这些异常。

关闭流：

在使用完流之后，应该关闭它们以释放资源。通常使用close()方法来关闭流。

NIO（New IO）：

Java提供了NIO包，它引入了一种更灵活和高效的IO处理方式，包括通道（Channels）和缓冲区（Buffers）。

NIO可以处理非阻塞IO，适用于构建高性能的网络应用程序。

IO主要分为BIO与NIO

BIO

在BIO模型中，IO操作是阻塞的，也就是说当一个线程执行IO操作时，它将被阻塞，直到操作完成。
传统的Java IO（java.io包）就是基于BIO模型的，例如InputStream和OutputStream等类。
BIO适用于连接数量较少且连接时间较短的情况，但在高并发环境下会导致性能问题，因为每个连接都需要一个独立的线程来处理。

BIO示例

文件读取示例：

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

public class FileReadExample {
    public static void main(String[] args) {
        String fileName = "example.txt"; // 文件名

        try (BufferedReader reader = new BufferedReader(new FileReader(fileName))) {
            String line;
            while ((line = reader.readLine()) != null) {
                System.out.println(line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

文件写入示例：

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;

public class FileWriteExample {
    public static void main(String[] args) {
        String fileName = "output.txt"; // 输出文件名
        String content = "Hello, Java IO!";

        try (BufferedWriter writer = new BufferedWriter(new FileWriter(fileName))) {
            writer.write(content);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

使用缓冲流读取文件示例：

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

public class BufferedInputStreamExample {
    public static void main(String[] args) {
        String fileName = "example.bin"; // 二进制文件名

        try (BufferedInputStream inputStream = new BufferedInputStream(new FileInputStream(fileName))) {
            int data;
            while ((data = inputStream.read()) != -1) {
                System.out.print((char) data); // 将读取的字节数据转换为字符输出
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

NIO介绍

介绍

NIO（New I/O，也称为非阻塞IO）是Java中用于处理IO操作的一种更高效、更灵活的机制。它在Java 1.4 版本中引入，提供了一种非阻塞、事件驱动的IO模型，适用于构建高性能、高并发的网络和IO应用程序。

NIO相对于传统的IO模型（也称为IO或阻塞IO）具有以下主要特点：

非阻塞操作： NIO允许程序在执行IO操作时不必等待数据准备就绪。程序可以继续执行其他任务，而不是一直等待数据。这使得NIO非常适合处理多个连接的高并发场景。

通道和缓冲区： NIO引入了通道（Channel）和缓冲区（Buffer）的概念，通道负责数据的读取和写入，缓冲区负责存储数据。这种方式可以更高效地管理数据，减少了数据的拷贝操作。

选择器（Selector）： 选择器是NIO的核心组件之一，它允许程序监视多个通道的事件状态，并在通道就绪时通知程序。这种事件驱动的方式减少了线程的数量，提高了系统的性能和资源利用率。

多路复用： NIO允许单个线程处理多个通道，从而降低了线程的开销。这是通过选择器和非阻塞IO操作实现的。

文件IO： NIO不仅适用于网络编程，还可以用于文件IO。它提供了FileChannel用于文件操作，使得文件读写更高效。

NIO在构建高性能的网络服务器、代理服务器、聊天应用程序等领域得到广泛应用。然而，NIO相对于传统IO模型更为复杂，需要更多的编程工作，因此在开发过程中需要谨慎处理。

Java的NIO包括java.nio和java.nio.channels等包，用于实现非阻塞IO操作。如果需要构建高性能、高并发的IO应用程序，可以考虑使用Java的NIO。另外，Java后续版本中引入了NIO.2（也称为NIO2或Java 7 NIO.2），进一步增强了NIO功能。

Java NIO 运行过程

Java NIO的运行过程可以简要描述为以下几个步骤：

创建 Selector： 首先，创建一个 Selector 对象。Selector是NIO的核心，用于管理多个通道的事件，比如接受连接、读取数据等。
创建 ServerSocketChannel： 如果你是构建服务器，需要创建一个 ServerSocketChannel，并绑定到一个端口上。ServerSocketChannel用于监听客户端连接请求。
注册通道到 Selector： 将 ServerSocketChannel 注册到 Selector 上，并指定监听的事件，通常是 SelectionKey.OP_ACCEPT，表示监听连接事件。
等待事件发生： 调用 Selector 的 select() 方法会阻塞，直到至少有一个注册的通道上发生了指定的事件。
处理就绪的事件： 一旦 select() 返回，你可以通过 selectedKeys() 方法获取就绪的事件集合（SelectionKey 集合），然后迭代处理这些事件。
接受连接或读取数据： 如果有连接事件，你可以调用 accept() 方法来接受客户端连接，或者如果有读事件，你可以读取通道中的数据。
处理完毕后取消 SelectionKey： 在处理完某个事件后，通常需要取消对应的 SelectionKey，以便下次继续监听它。
循环处理事件： 重复步骤4至步骤7，继续监听和处理事件。

这个流程可以让服务器同时处理多个连接，而不需要为每个连接创建一个独立的线程，从而提高了服务器的性能和资源利用率。

需要注意的是，NIO的编程模型相对复杂，需要仔细处理事件、通道的注册和取消等。通常，开发者需要编写更多的代码来实现完整的NIO应用程序，包括处理网络通信协议、数据的读写、异常处理等。但上述步骤提供了一个基本的NIO运行过程的概览。

NIO应用示例

示例1：接收客户端连接并向客户端发送消息

以下是一个简单的Java NIO应用示例，演示如何使用NIO来创建一个简单的网络服务器，它能够接受客户端连接并向客户端发送消息。

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.*;
import java.util.Iterator;
import java.util.Set;

public class NIOServer {
    public static void main(String[] args) {
        try {
            // 创建一个ServerSocketChannel并设置为非阻塞模式
            ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
            serverSocketChannel.configureBlocking(false);

            // 绑定服务器端口
            serverSocketChannel.socket().bind(new InetSocketAddress(8080));

            // 创建一个选择器（Selector）用于监听通道事件
            Selector selector = Selector.open();

            // 将ServerSocketChannel注册到选择器上，监听ACCEPT事件
            serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);

            System.out.println("服务器启动，监听端口 8080...");

            // 处理事件循环
            while (true) {
                // 选择器等待事件的到来
                selector.select();

                // 获取所有就绪事件的SelectionKey
                Set<SelectionKey> selectedKeys = selector.selectedKeys();
                Iterator<SelectionKey> keyIterator = selectedKeys.iterator();

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

                    if (key.isAcceptable()) {
                        // 有新连接接入，创建SocketChannel处理
                        SocketChannel socketChannel = serverSocketChannel.accept();
                        socketChannel.configureBlocking(false);
                        socketChannel.register(selector, SelectionKey.OP_READ);
                        System.out.println("客户端连接成功：" + socketChannel.getRemoteAddress());
                    } else if (key.isReadable()) {
                        // 通道可读，读取数据并回应
                        SocketChannel socketChannel = (SocketChannel) key.channel();
                        ByteBuffer buffer = ByteBuffer.allocate(1024);
                        int bytesRead = socketChannel.read(buffer);

                        if (bytesRead > 0) {
                            buffer.flip(); // 切换至读模式
                            byte[] data = new byte[bytesRead];
                            buffer.get(data);
                            String message = new String(data, "UTF-8");
                            System.out.println("接收到客户端消息：" + message);

                            // 回应客户端
                            String response = "Hello, client!";
                            ByteBuffer responseBuffer = ByteBuffer.wrap(response.getBytes());
                            socketChannel.write(responseBuffer);
                        }
                    }

                    // 从已选择的集合中移除当前处理的SelectionKey
                    keyIterator.remove();
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

这个示例创建了一个简单的NIO服务器，监听端口8080，可以接受客户端连接并处理客户端发送的消息。要运行此示例，你可以创建一个Java应用程序，并将上述代码粘贴到main方法中。

需要注意的是，这只是一个简单的NIO示例，真实的生产级服务器可能需要更复杂的逻辑和错误处理。此外，NIO的使用需要仔细处理缓冲区的管理、多线程同步等方面的问题。在实际开发中，你可能会考虑使用NIO框架或库，如Netty，以简化网络编程和提高性能。

示例2：监听客户端连接，并将客户端发送的消息回显给客户端

以下是一个简单的Java NIO应用示例，演示了如何使用NIO来创建一个简单的服务器，监听客户端连接，并将客户端发送的消息回显给客户端。

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.nio.channels.Selector;
import java.util.Iterator;
import java.util.Set;

public class NIOServer {
    public static void main(String[] args) {
        try {
            // 创建一个Selector
            Selector selector = Selector.open();

            // 创建ServerSocketChannel并绑定端口
            ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
            serverSocketChannel.socket().bind(new InetSocketAddress(8080));
            serverSocketChannel.configureBlocking(false);

            // 注册ServerSocketChannel到Selector，并监听ACCEPT事件
            serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);

            System.out.println("Server started on port 8080");

            while (true) {
                // 阻塞等待就绪的事件
                int readyChannels = selector.select();

                if (readyChannels == 0) {
                    continue;
                }

                // 获取就绪事件的SelectionKey集合
                Set<SelectionKey> selectedKeys = selector.selectedKeys();
                Iterator<SelectionKey> keyIterator = selectedKeys.iterator();

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

                    if (key.isAcceptable()) {
                        // 客户端连接事件
                        acceptClientConnection(serverSocketChannel, selector);
                    } else if (key.isReadable()) {
                        // 客户端数据可读事件
                        readAndEchoData(key);
                    }

                    // 移除处理过的SelectionKey
                    keyIterator.remove();
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    private static void acceptClientConnection(ServerSocketChannel serverSocketChannel, Selector selector) throws IOException {
        // 接受客户端连接
        SocketChannel clientChannel = serverSocketChannel.accept();
        clientChannel.configureBlocking(false);

        // 注册客户端通道到Selector，并监听读事件
        clientChannel.register(selector, SelectionKey.OP_READ);
        System.out.println("Accepted connection from: " + clientChannel.getRemoteAddress());
    }

    private static void readAndEchoData(SelectionKey key) throws IOException {
        SocketChannel clientChannel = (SocketChannel) key.channel();
        ByteBuffer buffer = ByteBuffer.allocate(1024);

        // 读取客户端发送的数据
        int bytesRead = clientChannel.read(buffer);

        if (bytesRead > 0) {
            buffer.flip();
            byte[] data = new byte[bytesRead];
            buffer.get(data);

            // 打印接收到的数据
            System.out.println("Received: " + new String(data));

            // 回显数据给客户端
            clientChannel.write(ByteBuffer.wrap(data));
        } else {
            // 客户端关闭连接
            clientChannel.close();
            System.out.println("Connection closed by client.");
        }
    }
}

这个示例创建了一个简单的NIO服务器，它监听8080端口，接受客户端连接，并将客户端发送的消息回显给客户端。关键的概念包括Selector、ServerSocketChannel、SocketChannel以及SelectionKey。通过使用Selector，服务器可以同时处理多个连接，而不需要创建一个线程来处理每个连接，从而提高了性能。

请注意，这只是一个简单的演示示例，实际的NIO应用程序可能涉及更复杂的逻辑和多线程处理。但这个示例提供了一个基本的框架，用于理解如何使用Java NIO构建服务器应用程序。

示例3：接受多个客户端连接并回显客户端发送

以下是一个简单的Java NIO应用示例，演示如何使用NIO来实现一个简单的网络服务器，该服务器可以接受多个客户端连接并回显客户端发送的消息。

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

public class NIOServer {
    public static void main(String[] args) {
        try {
            // 创建服务器Socket通道
            ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
            serverSocketChannel.socket().bind(new InetSocketAddress(8080));

            while (true) {
                // 等待客户端连接
                SocketChannel clientChannel = serverSocketChannel.accept();

                // 处理客户端连接
                handleClient(clientChannel);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    private static void handleClient(SocketChannel clientChannel) throws IOException {
        ByteBuffer buffer = ByteBuffer.allocate(1024);
        String welcomeMessage = "Welcome to the NIO Server! Type 'exit' to quit.\n";
        buffer.clear();
        buffer.put(welcomeMessage.getBytes(StandardCharsets.UTF_8));
        buffer.flip();
        clientChannel.write(buffer);

        while (true) {
            buffer.clear();
            int bytesRead = clientChannel.read(buffer);

            if (bytesRead == -1) {
                // 客户端关闭连接
                break;
            }

            buffer.flip();
            byte[] data = new byte[buffer.remaining()];
            buffer.get(data);

            String message = new String(data, StandardCharsets.UTF_8).trim();
            System.out.println("Received from client: " + message);

            // 回显消息给客户端
            buffer.clear();
            buffer.put(("Server: " + message + "\n").getBytes(StandardCharsets.UTF_8));
            buffer.flip();
            clientChannel.write(buffer);
        }

        // 关闭客户端连接
        clientChannel.close();
    }
}

这个简单的NIO服务器示例使用了ServerSocketChannel来监听指定端口（8080），并在客户端连接时创建SocketChannel来处理连接。服务器会向客户端发送欢迎消息，并将客户端发送的消息回显给客户端。客户端可以通过输入消息并按回车来与服务器进行通信，输入"exit"可以关闭客户端。

这只是一个简单的示例，实际的NIO应用程序可能更加复杂，涉及到多线程处理、非阻塞事件处理和更复杂的协议。但这个示例演示了NIO的基本原理和用法，以帮助你入门NIO编程。

NIO的应用领域

Java NIO（New I/O）在各种领域和技术中都得到了广泛应用，特别是在构建高性能、高并发的系统时。以下是一些使用Java NIO的技术和应用领域的示例：

网络编程： NIO最常见的用途之一是在网络编程中，特别是构建高性能的网络服务器和客户端。例如，gRPC、Netty、Apache MINA等网络库广泛使用了NIO来实现异步、非阻塞的网络通信。
消息中间件： 许多消息中间件，如Apache Kafka和RabbitMQ，使用NIO来处理消息的传输和分发。NIO可以提高消息中间件的性能和吞吐量。
数据库连接池： 一些数据库连接池库使用NIO来管理数据库连接，从而提高了数据库访问的效率。例如，HikariCP是一个使用NIO的高性能数据库连接池。
文件处理： NIO也适用于文件处理，特别是大文件的读取和写入。通过使用FileChannel，可以在文件处理中实现高效的IO操作。
分布式系统： 在构建分布式系统中，NIO可用于节点之间的通信。例如，Apache ZooKeeper使用NIO来处理集群通信。
游戏开发： 许多在线游戏和游戏服务器使用NIO来处理玩家之间的实时通信。NIO的低延迟特性使其成为游戏领域的有力选择。
Web框架： 一些Web框架，如Spring Webflux，使用NIO来实现异步的Web请求处理，以提高Web应用程序的并发性能。
HTTP服务器： 一些HTTP服务器，如Tomcat和Undertow，支持NIO模式以处理大量并发的HTTP请求。
实时数据处理： 在实时数据处理领域，例如金融领域的实时数据传输和处理，NIO也经常被应用。

这些只是一些示例，NIO的应用领域非常广泛，几乎在任何需要高性能、高并发IO操作的情况下都可以考虑使用它。然而，需要注意的是，NIO编程相对复杂，需要谨慎处理事件和状态，因此需要一定的经验和技巧来正确地使用它。

缓冲流

缓冲流是用于提高IO性能的Java IO流的一种特殊类型，通常用于包装其他底层的输入流和输出流，以减少IO操作的次数，从而提高数据读写的效率。它们可以用于BIO（Blocking IO）和NIO（New IO）模型中，不仅可以加速文件IO，还可以用于网络通信中的数据读写。

BufferedInputStream：用于包装输入流（例如FileInputStream、SocketInputStream等）。它将数据从底层输入流读入一个内部缓冲区，然后从缓冲区中逐个字节或一定长度的字节数组中读取数据。

try (FileInputStream fileInputStream = new FileInputStream("example.txt");
     BufferedInputStream bufferedInputStream = new BufferedInputStream(fileInputStream)) {

    int byteRead;
    while ((byteRead = bufferedInputStream.read()) != -1) {
        // 处理读取的数据
    }
} catch (IOException e) {
    e.printStackTrace();
}

BufferedOutputStream：用于包装输出流（例如FileOutputStream、SocketOutputStream等）。它将数据写入一个内部缓冲区，然后在缓冲区满或刷新时才将数据写入底层输出流。

try (FileOutputStream fileOutputStream = new FileOutputStream("example.txt");
     BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(fileOutputStream)) {

    byte[] data = "Hello, BufferedOutputStream!".getBytes();
    bufferedOutputStream.write(data);
    bufferedOutputStream.flush(); // 手动刷新缓冲区
} catch (IOException e) {
    e.printStackTrace();
}

BufferedReader：用于包装字符输入流（例如FileReader、InputStreamReader等）。它提供了更高级别的字符读取方法，以及可以按行读取文本数据的功能。

try (FileReader fileReader = new FileReader("example.txt");
     BufferedReader bufferedReader = new BufferedReader(fileReader)) {

    String line;
    while ((line = bufferedReader.readLine()) != null) {
        // 处理读取的行数据
    }
} catch (IOException e) {
    e.printStackTrace();
}

BufferedWriter：用于包装字符输出流（例如FileWriter、OutputStreamWriter等）。它提供了更高级别的字符写入方法，以及可以按行写入文本数据的功能。

try (FileWriter fileWriter = new FileWriter("example.txt");
     BufferedWriter bufferedWriter = new BufferedWriter(fileWriter)) {

    String data = "Hello, BufferedWriter!";
    bufferedWriter.write(data);
    bufferedWriter.newLine(); // 换行
} catch (IOException e) {
    e.printStackTrace();
}

缓冲流的优点在于它们可以减少IO操作的次数，从而提高了数据读写的效率。特别是在处理大量数据或频繁IO操作的情况下，使用缓冲流可以显著改善性能。因此，在进行文件IO或网络通信时，使用缓冲流通常是一个良好的实践。

如何使用缓冲流提高性能

文件复制示例：

import java.io.*;

public class FileCopyWithBufferedStreams {
    public static void main(String[] args) {
        String sourceFile = "source.txt";
        String destinationFile = "destination.txt";

        try (BufferedInputStream inputStream = new BufferedInputStream(new FileInputStream(sourceFile));
             BufferedOutputStream outputStream = new BufferedOutputStream(new FileOutputStream(destinationFile))) {

            byte[] buffer = new byte[4096]; // 创建一个缓冲区
            int bytesRead;

            while ((bytesRead = inputStream.read(buffer)) != -1) {
                outputStream.write(buffer, 0, bytesRead); // 将缓冲区的数据写入目标文件
            }

            System.out.println("文件复制完成！");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

这个示例中，我们使用了BufferedInputStream来读取源文件的数据，并使用BufferedOutputStream来将数据写入目标文件。缓冲区的大小通常可以根据实际需求进行调整。较大的缓冲区通常可以提高性能，但也会占用更多内存。

通过使用缓冲流，数据会被缓冲在内存中，减少了频繁的IO操作，从而提高了复制操作的效率。这对于处理大型文件或网络数据传输非常有用。要注意，在使用完缓冲流后，要及时关闭它们以释放资源。

使用缓冲写入文件示例：

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;

public class BufferedWriteExample {
    public static void main(String[] args) {
        String fileName = "output.txt"; // 输出文件名
        String content = "Hello, Buffered IO!";

        try (BufferedWriter writer = new BufferedWriter(new FileWriter(fileName))) {
            writer.write(content);
            // 注意：虽然我们是一次写入的，但缓冲流内部可能会将数据缓冲一段时间后才写入磁盘，以提高性能。
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

在这个示例中，BufferedWriter内部维护了一个缓冲区，可以一次性写入多个字符，提高了文件写入的效率。

使用缓冲流时需要注意以下几点：

缓冲流的性能提升通常在大量读写操作时更为明显，对于小数据量的IO操作可能不会带来很大的性能提升。
使用try-with-resources语句（Java 7及以上版本）来确保在使用完缓冲流后自动关闭它们。
缓冲流内部会根据需要自动将缓冲区的数据刷新（写入磁盘），但你也可以使用flush()方法手动刷新缓冲区。
可以根据需要设置缓冲区的大小，通常来说，较大的缓冲区可以提高性能，但会占用更多内存。

总之，使用缓冲流可以有效提高IO操作的性能，特别是在处理大量数据时。在开发中，根据实际需求选择合适的缓冲流类（如BufferedReader或BufferedWriter）以及适当的缓冲区大小。

IO介绍

BIO

BIO示例

NIO介绍

介绍

Java NIO 运行过程

NIO应用示例

示例1： 接收客户端连接并向客户端发送消息

示例2：监听客户端连接，并将客户端发送的消息回显给客户端

示例3：接受多个客户端连接并回显客户端发送

NIO的应用领域

缓冲流

如何使用缓冲流提高性能

文件复制示例：

使用缓冲写入文件示例：

猜你喜欢

示例1：接收客户端连接并向客户端发送消息