1
// 设置通道为非阻塞模式
2
SocketChannel socketChannel = SocketChannel.open();
3
socketChannel.configureBlocking(false);
4

5
// 尝试连接
6
boolean connected = socketChannel.connect(new InetSocketAddress("localhost", 8080));
7
if (!connected) {
8
    while (!socketChannel.finishConnect()) {
9
        // 连接尚未完成，可以执行其他任务
10
        System.out.println("Waiting for connection...");
11
    }
12
}
13

14
// 非阻塞读取
15
ByteBuffer buffer = ByteBuffer.allocate(1024);
16
int bytesRead = socketChannel.read(buffer);
17
if (bytesRead == -1) {
18
    // 连接关闭
19
} else if (bytesRead > 0) {
20
    // 有数据可读
21
    buffer.flip();
22
    // 处理数据...
23
} else {
24
    // 没有数据可读，可以执行其他任务
25
}

1
// 分配直接缓冲区
2
ByteBuffer directBuffer = ByteBuffer.allocateDirect(1024);
3

4
// 使用直接缓冲区
5
FileChannel fileChannel = new RandomAccessFile("data.txt", "rw").getChannel();
6
directBuffer.put("Hello, Direct Buffer!".getBytes());
7
directBuffer.flip();
8
fileChannel.write(directBuffer);
9

10
// 关闭通道
11
fileChannel.close();

1
// 打开文件通道
2
FileChannel fileChannel = new RandomAccessFile("data.txt", "rw").getChannel();
3

4
// 映射文件到内存
5
MappedByteBuffer mappedBuffer = fileChannel.map(FileChannel.MapMode.READ_WRITE, 0, fileChannel.size());
6

7
// 直接操作内存中的文件数据
8
for (int i = 0; i < mappedBuffer.limit(); i++) {
9
    byte b = mappedBuffer.get(i);
10
    mappedBuffer.put(i, (byte) (b + 1)); // 简单修改数据
11
}
12

13
// 关闭通道
14
fileChannel.close();

1
public class NIOServer {
2
    public static void main(String[] args) throws IOException {
3
        // 创建选择器
4
        Selector selector = Selector.open();
5

6
        // 打开ServerSocketChannel
7
        ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
8
        serverSocketChannel.bind(new InetSocketAddress(8080));
9
        serverSocketChannel.configureBlocking(false);
10

11
        // 注册到选择器
12
        serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
13

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

16
        while (true) {
17
            // 阻塞直到有事件发生
18
            int readyChannels = selector.select();
19
            if (readyChannels == 0) {
20
                continue;
21
            }
22

23
            // 处理事件
24
            Set<SelectionKey> selectionKeys = selector.selectedKeys();
25
            Iterator<SelectionKey> iterator = selectionKeys.iterator();
26

27
            while (iterator.hasNext()) {
28
                SelectionKey key = iterator.next();
29

30
                if (key.isAcceptable()) {
31
                    // 处理连接事件
32
                    ServerSocketChannel serverChannel = (ServerSocketChannel) key.channel();
33
                    SocketChannel socketChannel = serverChannel.accept();
34
                    socketChannel.configureBlocking(false);
35
                    socketChannel.register(selector, SelectionKey.OP_READ);
36
                    System.out.println("Client connected: " + socketChannel.getRemoteAddress());
37
                } else if (key.isReadable()) {
38
                    // 处理读取事件
39
                    SocketChannel socketChannel = (SocketChannel) key.channel();
40
                    ByteBuffer buffer = ByteBuffer.allocate(1024);
41
                    int bytesRead = socketChannel.read(buffer);
42

43
                    if (bytesRead == -1) {
44
                        // 连接关闭
45
                        socketChannel.close();
46
                        key.cancel();
47
                        System.out.println("Client disconnected");
48
                    } else if (bytesRead > 0) {
49
                        // 处理数据
50
                        buffer.flip();
51
                        byte[] data = new byte[buffer.remaining()];
52
                        buffer.get(data);
53
                        String message = new String(data);
54
                        System.out.println("Received: " + message);
55

56
                        // 响应客户端
57
                        ByteBuffer responseBuffer = ByteBuffer.wrap(("Server response: " + message).getBytes());
58
                        socketChannel.write(responseBuffer);
59
                    }
60
                }
61

62
                // 移除已处理的SelectionKey
63
                iterator.remove();
64
            }
65
        }
66
    }
67
}

1
public class NIOClient {
2
    public static void main(String[] args) throws IOException {
3
        // 打开SocketChannel
4
        SocketChannel socketChannel = SocketChannel.open();
5
        socketChannel.configureBlocking(false);
6

7
        // 连接服务器
8
        boolean connected = socketChannel.connect(new InetSocketAddress("localhost", 8080));
9
        if (!connected) {
10
            while (!socketChannel.finishConnect()) {
11
                System.out.println("Connecting to server...");
12
            }
13
        }
14

15
        System.out.println("Connected to server");
16

17
        // 发送数据
18
        String message = "Hello, Server!";
19
        ByteBuffer buffer = ByteBuffer.wrap(message.getBytes());
20
        socketChannel.write(buffer);
21

22
        // 读取响应
23
        buffer.clear();
24
        int bytesRead = socketChannel.read(buffer);
25
        if (bytesRead > 0) {
26
            buffer.flip();
27
            byte[] data = new byte[buffer.remaining()];
28
            buffer.get(data);
29
            System.out.println("Received: " + new String(data));
30
        }
31

32
        // 关闭通道
33
        socketChannel.close();
34
    }
35
}

1
public class NIOFileOperations {
2
    public static void main(String[] args) throws IOException {
3
        // 文件复制
4
        copyFile("source.txt", "destination.txt");
5

6
        // 文件读取
7
        readFile("source.txt");
8

9
        // 文件写入
10
        writeFile("output.txt", "Hello, NIO File Operations!");
11
    }
12

13
    private static void copyFile(String sourcePath, String destinationPath) throws IOException {
14
        try (FileChannel sourceChannel = new FileInputStream(sourcePath).getChannel();
15
             FileChannel destinationChannel = new FileOutputStream(destinationPath).getChannel()) {
16
            // 使用transferTo方法复制文件，效率更高
17
            sourceChannel.transferTo(0, sourceChannel.size(), destinationChannel);
18
            System.out.println("File copied successfully");
19
        }
20
    }
21

22
    private static void readFile(String filePath) throws IOException {
23
        try (FileChannel fileChannel = new FileInputStream(filePath).getChannel()) {
24
            ByteBuffer buffer = ByteBuffer.allocate(1024);
25
            while (fileChannel.read(buffer) != -1) {
26
                buffer.flip();
27
                while (buffer.hasRemaining()) {
28
                    System.out.print((char) buffer.get());
29
                }
30
                buffer.clear();
31
            }
32
            System.out.println();
33
        }
34
    }
35

36
    private static void writeFile(String filePath, String content) throws IOException {
37
        try (FileChannel fileChannel = new FileOutputStream(filePath).getChannel()) {
38
            ByteBuffer buffer = ByteBuffer.wrap(content.getBytes());
39
            fileChannel.write(buffer);
40
            System.out.println("File written successfully");
41
        }
42
    }
43
}