public class BioServer {
    public static void main(String[] args) throws IOException {
        ServerSocket serverSocket = new ServerSocket(8080);
        System.out.println("BIO服務(wù)器啟動，端口：8080");
        
        while (true) {
            Socket clientSocket = serverSocket.accept(); // 阻塞
            new Thread(() -> handle(clientSocket)).start();
        }
    }

    private static void handle(Socket socket) {
        try (BufferedReader reader = new BufferedReader(
                new InputStreamReader(socket.getInputStream()));
             BufferedWriter writer = new BufferedWriter(
                new OutputStreamWriter(socket.getOutputStream()))) {

            String line;
            while ((line = reader.readLine()) != null) {
                System.out.println("收到消息: " + line);
                writer.write("Echo: " + line + "\n");
                writer.flush();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

SocketChannel channel = SocketChannel.open();
channel.configureBlocking(false); // 設(shè)置為非阻塞

AsynchronousSocketChannel channel = AsynchronousSocketChannel.open();
ByteBuffer buffer = ByteBuffer.allocate(1024);
channel.read(buffer, buffer, new CompletionHandler<Integer, ByteBuffer>() {
    @Override
    public void completed(Integer result, ByteBuffer attachment) {
        System.out.println("異步讀取完成: " + result);
    }

    @Override
    public void failed(Throwable exc, ByteBuffer attachment) {
        System.err.println("讀取失敗: " + exc.getMessage());
    }
});

InputStream in = socket.getInputStream();
byte[] buffer = new byte[1024];
int len = in.read(buffer); // 可能阻塞

ByteBuffer buffer = ByteBuffer.allocate(1024);
SocketChannel channel = socket.getChannel();
int len = channel.read(buffer); // 非阻塞

java.nio.channels.Channel
 ├── ReadableByteChannel
 ├── WritableByteChannel
 ├── ByteChannel
 ├── NetworkChannel
 └── InterruptibleChannel

FileChannel fileChannel = new FileInputStream("data.txt").getChannel();

SocketChannel socketChannel = SocketChannel.open();
socketChannel.connect(new InetSocketAddress("localhost", 8080));

socketChannel.configureBlocking(false);

ByteBuffer buffer = ByteBuffer.allocate(1024);
socketChannel.write(buffer);
socketChannel.read(buffer);

ServerSocketChannel serverChannel = ServerSocketChannel.open();
serverChannel.bind(new InetSocketAddress(8080));

serverChannel.configureBlocking(false);
SocketChannel client = serverChannel.accept(); // 非阻塞可能返回null

DatagramChannel datagramChannel = DatagramChannel.open();
datagramChannel.bind(new InetSocketAddress(8888));

ByteBuffer buffer = ByteBuffer.allocate(1024);
datagramChannel.receive(buffer);
datagramChannel.send(buffer, new InetSocketAddress("localhost", 9999));

ByteBuffer buffer = ByteBuffer.allocate(1024); // 創(chuàng)建非直接緩沖區(qū)
buffer.put("Hello NIO".getBytes());           // 寫入數(shù)據(jù)
buffer.flip();                                // 切換為讀模式

while (buffer.hasRemaining()) {
    System.out.print((char) buffer.get());    // 讀取數(shù)據(jù)
}

buffer.clear();                               // 清空緩沖區(qū)準備再次寫入

IntBuffer intBuffer = IntBuffer.allocate(5);
intBuffer.put(10);
intBuffer.put(20);
intBuffer.flip();
System.out.println(intBuffer.get()); // 輸出10

ByteBuffer directBuffer = ByteBuffer.allocateDirect(1024);
directBuffer.put("Netty Rocks".getBytes());
directBuffer.flip();

ByteBuffer buffer = ByteBuffer.allocate(10);
buffer.put("abc".getBytes());
buffer.flip();
System.out.println((char) buffer.get()); // 讀取a
buffer.compact(); // b和c移動到緩沖區(qū)前端，準備繼續(xù)寫入

SelectionKey.OP_CONNECT  // 客戶端連接就緒
SelectionKey.OP_ACCEPT   // 服務(wù)器接收連接就緒
SelectionKey.OP_READ     // 讀就緒
SelectionKey.OP_WRITE    // 寫就緒

Selector selector = Selector.open();

SocketChannel socketChannel = SocketChannel.open();
socketChannel.configureBlocking(false);
socketChannel.register(selector, SelectionKey.OP_READ);

socketChannel.register(selector, SelectionKey.OP_READ | SelectionKey.OP_WRITE);

int readyChannels = selector.select();

Set<SelectionKey> selectedKeys = selector.selectedKeys();

for (SelectionKey key : selectedKeys) {
    if (key.isAcceptable()) {
        // 處理連接請求
    } else if (key.isReadable()) {
        // 讀取數(shù)據(jù)
    } else if (key.isWritable()) {
        // 寫入數(shù)據(jù)
    }
}
selectedKeys.clear(); // 處理完需清除集合

Selector selector = Selector.open();
ServerSocketChannel serverChannel = ServerSocketChannel.open();
serverChannel.configureBlocking(false);
serverChannel.bind(new InetSocketAddress(8080));
serverChannel.register(selector, SelectionKey.OP_ACCEPT);

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

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

        if (key.isAcceptable()) {
            ServerSocketChannel server = (ServerSocketChannel) key.channel();
            SocketChannel client = server.accept();
            client.configureBlocking(false);
            client.register(selector, SelectionKey.OP_READ);
        } else if (key.isReadable()) {
            SocketChannel client = (SocketChannel) key.channel();
            ByteBuffer buffer = ByteBuffer.allocate(1024);
            int read = client.read(buffer);
            if (read > 0) {
                buffer.flip();
                client.write(buffer);
                buffer.clear();
            }
        }
        iterator.remove(); // 防止重復(fù)處理
    }
}

ServerSocketChannel serverChannel = ServerSocketChannel.open();
serverChannel.configureBlocking(false); // 設(shè)置為非阻塞模式
serverChannel.bind(new InetSocketAddress(8888)); // 綁定端口

Selector selector = Selector.open();
serverChannel.register(selector, SelectionKey.OP_ACCEPT); // 監(jiān)聽連接事件

while (true) {
    selector.select(); // 阻塞直到有事件就緒
    Set<SelectionKey> selectedKeys = selector.selectedKeys();
    Iterator<SelectionKey> iter = selectedKeys.iterator();

    while (iter.hasNext()) {
        SelectionKey key = iter.next();
        iter.remove(); // 清除已處理的key

        if (key.isAcceptable()) {
            handleAccept(key);
        } else if (key.isReadable()) {
            handleRead(key);
        }
    }
}

private static void handleAccept(SelectionKey key) throws IOException {
    ServerSocketChannel server = (ServerSocketChannel) key.channel();
    SocketChannel clientChannel = server.accept();
    clientChannel.configureBlocking(false);
    clientChannel.register(key.selector(), SelectionKey.OP_READ);
    System.out.println("客戶端連接: " + clientChannel.getRemoteAddress());
}

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

    if (bytesRead == -1) {
        clientChannel.close();
        System.out.println("客戶端斷開連接");
        return;
    }

    buffer.flip();
    clientChannel.write(buffer); // Echo 回寫
    buffer.clear();
}

public class NioEchoServer {
    public static void main(String[] args) throws IOException {
        Selector selector = Selector.open();
        ServerSocketChannel serverChannel = ServerSocketChannel.open();
        serverChannel.configureBlocking(false);
        serverChannel.bind(new InetSocketAddress(8888));
        serverChannel.register(selector, SelectionKey.OP_ACCEPT);

        System.out.println("NIO服務(wù)器啟動，端口: 8888");

        while (true) {
            selector.select();
            Iterator<SelectionKey> iter = selector.selectedKeys().iterator();
            while (iter.hasNext()) {
                SelectionKey key = iter.next();
                iter.remove();

                if (key.isAcceptable()) {
                    ServerSocketChannel server = (ServerSocketChannel) key.channel();
                    SocketChannel client = server.accept();
                    client.configureBlocking(false);
                    client.register(selector, SelectionKey.OP_READ);
                    System.out.println("客戶端連接: " + client.getRemoteAddress());
                } else if (key.isReadable()) {
                    SocketChannel client = (SocketChannel) key.channel();
                    ByteBuffer buffer = ByteBuffer.allocate(1024);
                    int read = client.read(buffer);
                    if (read == -1) {
                        client.close();
                        continue;
                    }
                    buffer.flip();
                    client.write(buffer);
                    buffer.clear();
                }
            }
        }
    }
}

class ClientContext {
    String username;
    ByteBuffer readBuffer = ByteBuffer.allocate(1024);
    ByteBuffer writeBuffer = ByteBuffer.allocate(1024);
    // 可擴展更多字段，如身份標識、狀態(tài)等
}

// 注冊時綁定
ClientContext context = new ClientContext();
SelectionKey key = clientChannel.register(selector, SelectionKey.OP_READ);
key.attach(context);

private static void handleAccept(SelectionKey key) throws IOException {
    ServerSocketChannel server = (ServerSocketChannel) key.channel();
    SocketChannel clientChannel = server.accept();
    clientChannel.configureBlocking(false);

    ClientContext context = new ClientContext();
    SelectionKey clientKey = clientChannel.register(key.selector(), SelectionKey.OP_READ);
    clientKey.attach(context);

    System.out.println("新客戶端接入: " + clientChannel.getRemoteAddress());
}

private static void handleRead(SelectionKey key) throws IOException {
    SocketChannel channel = (SocketChannel) key.channel();
    ClientContext context = (ClientContext) key.attachment();
    ByteBuffer buffer = context.readBuffer;

    int bytesRead = channel.read(buffer);
    if (bytesRead == -1) {
        System.out.println("客戶端斷開連接: " + channel.getRemoteAddress());
        channel.close();
        return;
    }

    buffer.flip();
    byte[] data = new byte[buffer.remaining()];
    buffer.get(data);
    String message = new String(data);
    System.out.println("收到消息: " + message);

    // 將消息寫入寫緩沖區(qū)，準備寫回（或廣播）
    context.writeBuffer.put(("[Echo] " + message).getBytes());
    buffer.clear();

    // 關(guān)注寫事件
    key.interestOps(SelectionKey.OP_READ | SelectionKey.OP_WRITE);
}

private static void handleWrite(SelectionKey key) throws IOException {
    SocketChannel channel = (SocketChannel) key.channel();
    ClientContext context = (ClientContext) key.attachment();
    ByteBuffer buffer = context.writeBuffer;

    buffer.flip();
    channel.write(buffer);
    if (!buffer.hasRemaining()) {
        // 清空后停止關(guān)注寫事件
        key.interestOps(SelectionKey.OP_READ);
        buffer.clear();
    } else {
        buffer.compact(); // 還有數(shù)據(jù)未寫完，下次繼續(xù)
    }
}

if (key.isWritable()) {
    handleWrite(key);
}

// 方式1：通過FileInputStream
FileInputStream fis = new FileInputStream("example.txt");
FileChannel readChannel = fis.getChannel();

// 方式2：通過RandomAccessFile
RandomAccessFile raf = new RandomAccessFile("example.txt", "rw");
FileChannel rwChannel = raf.getChannel();

FileInputStream fis = new FileInputStream("data.txt");
FileChannel channel = fis.getChannel();

ByteBuffer buffer = ByteBuffer.allocate(1024);
int bytesRead = channel.read(buffer);
while (bytesRead != -1) {
    buffer.flip();
    while (buffer.hasRemaining()) {
        System.out.print((char) buffer.get());
    }
    buffer.clear();
    bytesRead = channel.read(buffer);
}
channel.close();

FileOutputStream fos = new FileOutputStream("output.txt");
FileChannel channel = fos.getChannel();

ByteBuffer buffer = ByteBuffer.wrap("Hello NIO!".getBytes());
channel.write(buffer);
channel.close();

FileChannel source = new FileInputStream("source.txt").getChannel();
FileChannel target = new FileOutputStream("target.txt").getChannel();

source.transferTo(0, source.size(), target);
// 或者 target.transferFrom(source, 0, source.size());

source.close();
target.close();

RandomAccessFile raf = new RandomAccessFile("mapped.txt", "rw");
FileChannel channel = raf.getChannel();

MappedByteBuffer mappedBuf = channel.map(FileChannel.MapMode.READ_WRITE, 0, 1024);
mappedBuf.put(0, (byte) 'H'); // 寫入位置0
System.out.println((char) mappedBuf.get(0)); // 讀取位置0

FileChannel channel = new RandomAccessFile("lock.txt", "rw").getChannel();
FileLock lock = channel.lock(); // 獨占鎖（阻塞）

try {
    // 安全寫入
    channel.write(ByteBuffer.wrap("lock write".getBytes()));
} finally {
    lock.release();
    channel.close();
}

FileLock lock = channel.tryLock();

Charset charset = Charset.forName("UTF-8");

SortedMap<String, Charset> charsets = Charset.availableCharsets();
for (String name : charsets.keySet()) {
    System.out.println(name);
}

Charset charset = Charset.forName("UTF-8");
CharsetDecoder decoder = charset.newDecoder();

ByteBuffer byteBuffer = ByteBuffer.wrap("你好，世界".getBytes("UTF-8"));
CharBuffer charBuffer = decoder.decode(byteBuffer);
System.out.println(charBuffer.toString());

Charset charset = Charset.forName("UTF-8");
CharsetEncoder encoder = charset.newEncoder();

CharBuffer charBuffer = CharBuffer.wrap("你好，Java NIO");
ByteBuffer byteBuffer = encoder.encode(charBuffer);

while (byteBuffer.hasRemaining()) {
    System.out.print(byteBuffer.get() + " ");
}

Charset charset = Charset.forName("UTF-8");
CharsetEncoder encoder = charset.newEncoder();
CharsetDecoder decoder = charset.newDecoder();

String text = "Java NIO 字符集測試";

// 寫入文件
FileChannel outChannel = new FileOutputStream("charset.txt").getChannel();
ByteBuffer buffer = encoder.encode(CharBuffer.wrap(text));
outChannel.write(buffer);
outChannel.close();

// 讀取文件
FileChannel inChannel = new FileInputStream("charset.txt").getChannel();
ByteBuffer inBuffer = ByteBuffer.allocate(1024);
inChannel.read(inBuffer);
inBuffer.flip();
CharBuffer result = decoder.decode(inBuffer);
System.out.println(result.toString());
inChannel.close();

decoder.onMalformedInput(CodingErrorAction.REPLACE);
decoder.onUnmappableCharacter(CodingErrorAction.IGNORE);

RandomAccessFile raf = new RandomAccessFile("scatter.txt", "rw");
FileChannel channel = raf.getChannel();

ByteBuffer header = ByteBuffer.allocate(8);  // 假設(shè)頭部8字節(jié)
ByteBuffer body = ByteBuffer.allocate(32);   // 正文最大32字節(jié)

ByteBuffer[] buffers = {header, body};
channel.read(buffers); // 按順序填滿 header，再填 body

header.flip();
body.flip();

System.out.println("Header:");
while (header.hasRemaining()) {
    System.out.print((char) header.get());
}
System.out.println("\nBody:");
while (body.hasRemaining()) {
    System.out.print((char) body.get());
}
channel.close();

RandomAccessFile raf = new RandomAccessFile("gather.txt", "rw");
FileChannel channel = raf.getChannel();

ByteBuffer header = ByteBuffer.wrap("HEAD1234".getBytes());
ByteBuffer body = ByteBuffer.wrap("This is the body content.".getBytes());

ByteBuffer[] buffers = {header, body};
channel.write(buffers); // 會依次寫出 header 和 body
channel.close();

+---------+--------------+
| Header  |   Payload    |
| (固定)  |   (可變)     |
+---------+--------------+

ByteBuffer header = ByteBuffer.allocate(12);
ByteBuffer payload = ByteBuffer.allocate(1024);
channel.read(new ByteBuffer[]{header, payload});

ByteBuffer httpHeader = ByteBuffer.wrap("HTTP/1.1 200 OK\r\n\r\n".getBytes());
ByteBuffer content = ByteBuffer.wrap("Hello, client!".getBytes());
socketChannel.write(new ByteBuffer[]{httpHeader, content});

ExecutorService threadPool = Executors.newFixedThreadPool(4);
AsynchronousChannelGroup channelGroup = AsynchronousChannelGroup.withThreadPool(threadPool);

import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.*;

import java.util.concurrent.Executors;
import java.util.concurrent.ExecutorService;

public class AsyncNIOServer {

    public static void main(String[] args) throws Exception {
        ExecutorService threadPool = Executors.newFixedThreadPool(4);
        AsynchronousChannelGroup group = AsynchronousChannelGroup.withThreadPool(threadPool);

        AsynchronousServerSocketChannel server = AsynchronousServerSocketChannel.open(group)
            .bind(new InetSocketAddress(8080));

        System.out.println("服務(wù)器已啟動，等待客戶端連接...");

        server.accept(null, new CompletionHandler<AsynchronousSocketChannel, Void>() {
            @Override
            public void completed(AsynchronousSocketChannel client, Void attachment) {
                // 繼續(xù)接收其他客戶端連接
                server.accept(null, this);

                ByteBuffer buffer = ByteBuffer.allocate(1024);

                // 異步讀取客戶端數(shù)據(jù)
                client.read(buffer, buffer, new CompletionHandler<Integer, ByteBuffer>() {
                    @Override
                    public void completed(Integer bytesRead, ByteBuffer buf) {
                        if (bytesRead == -1) {
                            try {
                                client.close();
                            } catch (Exception e) {
                                e.printStackTrace();
                            }
                            return;
                        }

                        buf.flip();
                        byte[] data = new byte[buf.remaining()];
                        buf.get(data);
                        System.out.println("收到客戶端消息: " + new String(data));

                        // 異步寫回客戶端
                        client.write(ByteBuffer.wrap("收到消息，謝謝！".getBytes()), null, new CompletionHandler<Integer, Void>() {
                            @Override
                            public void completed(Integer result, Void attachment) {
                                // 寫入完成后繼續(xù)讀取
                                buf.clear();
                                client.read(buf, buf, this);
                            }

                            @Override
                            public void failed(Throwable exc, Void attachment) {
                                exc.printStackTrace();
                                try { client.close(); } catch (Exception e) { e.printStackTrace(); }
                            }
                        });
                    }

                    @Override
                    public void failed(Throwable exc, ByteBuffer buf) {
                        exc.printStackTrace();
                        try { client.close(); } catch (Exception e) { e.printStackTrace(); }
                    }
                });
            }

            @Override
            public void failed(Throwable exc, Void attachment) {
                exc.printStackTrace();
            }
        });

        // 主線程可以繼續(xù)執(zhí)行其他任務(wù)
        Thread.currentThread().join();
    }
}

import java.nio.ByteBuffer;
import java.nio.channels.AsynchronousFileChannel;
import java.nio.channels.CompletionHandler;
import java.nio.file.Paths;
import java.nio.file.StandardOpenOption;

public class AsyncFileReadExample {

    public static void main(String[] args) throws Exception {
        AsynchronousFileChannel fileChannel = AsynchronousFileChannel.open(
                Paths.get("asyncFile.txt"), StandardOpenOption.READ);

        ByteBuffer buffer = ByteBuffer.allocate(1024);

        fileChannel.read(buffer, 0, buffer, new CompletionHandler<Integer, ByteBuffer>() {
            @Override
            public void completed(Integer bytesRead, ByteBuffer buf) {
                System.out.println("讀取到字節(jié)數(shù): " + bytesRead);
                buf.flip();
                while (buf.hasRemaining()) {
                    System.out.print((char) buf.get());
                }
                try {
                    fileChannel.close();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }

            @Override
            public void failed(Throwable exc, ByteBuffer buf) {
                System.err.println("讀取失敗: " + exc);
                try {
                    fileChannel.close();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        });

        // 主線程可以繼續(xù)執(zhí)行其他邏輯
        Thread.sleep(3000);
    }
}

while (true) {
    int readyChannels = selector.select();
    if (readyChannels == 0) {
        Thread.sleep(10); // 避免空輪詢CPU飆升
        continue;
    }
    // 處理IO事件...
}