NIO

// 传统 BIO 服务器模型（伪代码）
ServerSocket serverSocket = new ServerSocket(8080); // 绑定端口
 
while (true) {
    // accept() 是阻塞的：线程在此停住，直到有新客户端连接进来
    Socket clientSocket = serverSocket.accept();
 
    // 为每个客户端连接创建一个新线程来处理
    new Thread(() -> {
        try {
            InputStream in = clientSocket.getInputStream();   // 获取输入流
            byte[] buffer = new byte[1024];                   // 创建缓冲区
 
            // read() 是阻塞的：线程在此停住，直到客户端发来数据
            int bytesRead = in.read(buffer);
 
            // 处理数据...
        } catch (IOException e) {
            e.printStackTrace();                              // 异常处理
        }
    }).start();
}

// NIO 读取文件的基本模式
RandomAccessFile file = new RandomAccessFile("data.txt", "rw"); // 打开文件
FileChannel channel = file.getChannel();                         // 获取通道
 
ByteBuffer buffer = ByteBuffer.allocate(1024);                   // 分配 1024 字节的缓冲区
 
// 从 Channel 读取数据到 Buffer 中
int bytesRead = channel.read(buffer);                            // 数据被填入 buffer
 
// 切换 buffer 为读模式（这一步至关重要，后续章节会详解）
buffer.flip();
 
// 从 buffer 中逐字节读取数据
while (buffer.hasRemaining()) {
    System.out.print((char) buffer.get());                       // 从 buffer 中取出一个字节
}
 
// 清空 buffer，准备下一次写入
buffer.clear();
channel.close();                                                 // 关闭通道
file.close();                                                    // 关闭文件

// 将 SocketChannel 设置为非阻塞模式
SocketChannel socketChannel = SocketChannel.open();
socketChannel.configureBlocking(false);                // 关键：设置为非阻塞
 
socketChannel.connect(new InetSocketAddress("example.com", 80)); // 发起连接
 
// 非阻塞模式下，connect 可能还没完成，需要轮询检查
while (!socketChannel.finishConnect()) {
    // 连接尚未建立，线程可以做其他事情
    // 不会阻塞在这里
}
 
ByteBuffer buffer = ByteBuffer.allocate(1024);
int bytesRead = socketChannel.read(buffer);            // 非阻塞：没数据就返回 0，不会卡住

// 面向缓冲的灵活性演示
ByteBuffer buffer = ByteBuffer.allocate(64);
 
// 假设 buffer 中已经有数据，且已 flip 到读模式
buffer.get();                    // 读第 1 个字节，position 前进到 1
buffer.get();                    // 读第 2 个字节，position 前进到 2
 
buffer.rewind();                 // 将 position 重置为 0
buffer.get();                    // 又可以重新读第 1 个字节了
 
buffer.position(5);              // 直接跳到第 6 个字节的位置
byte b = buffer.get();           // 读取第 6 个字节

// ========== 初始状态（写模式）==========
// 刚 allocate 出来，position=0, limit=capacity=10
//
//  position                          limit/capacity
//     ↓                                   ↓
//  [ ][ ][ ][ ][ ][ ][ ][ ][ ][ ]
//   0  1  2  3  4  5  6  7  8  9
//
// ========== 写入 5 个字节后（仍在写模式）==========
// position 移动到 5，limit 不变
//
//                    position          limit/capacity
//                       ↓                   ↓
//  [A][B][C][D][E][ ][ ][ ][ ][ ]
//   0  1  2  3  4  5  6  7  8  9
//
// ========== 调用 flip() 切换到读模式 ==========
// limit = 旧position(5), position = 0
//
//  position          limit          capacity
//     ↓                ↓                ↓
//  [A][B][C][D][E][ ][ ][ ][ ][ ]
//   0  1  2  3  4  5  6  7  8  9
//
// 现在可读范围: position(0) ~ limit(5)，正好是写入的那 5 个字节

// java.nio.Buffer#flip 的等价逻辑
public Buffer flip() {
    limit = position;   // 把 limit 设置为当前写到的位置（即有效数据的末尾）
    position = 0;       // 把 position 归零（从头开始读）
    mark = -1;          // 清除之前的 mark 标记
    return this;
}

ByteBuffer buf = ByteBuffer.allocate(64);  // 创建 64 字节的缓冲区
buf.put("Hello".getBytes());               // 写入 5 个字节, position=5
 
// ❌ 错误：忘记 flip，直接读
byte[] wrong = new byte[5];
buf.get(wrong);  // 读到的是 position=5 之后的空数据！
 
// ✅ 正确：先 flip 再读
buf.flip();      // position=0, limit=5
byte[] correct = new byte[5];
buf.get(correct); // 读到 "Hello"

// java.nio.Buffer#clear 的等价逻辑
public Buffer clear() {
    position = 0;       // 归零
    limit = capacity;   // limit 恢复到最大容量
    mark = -1;          // 清除 mark
    return this;
}

// clear 后的状态
//  position                          limit/capacity
//     ↓                                   ↓
//  [A][B][C][D][E][ ][ ][ ][ ][ ]    ← 旧数据还在，但逻辑上已"不可见"
//   0  1  2  3  4  5  6  7  8  9

// compact() 的行为（以 ByteBuffer 为例）
// 假设当前状态: position=3, limit=5 (已读3个，还剩2个未读)
//
//  已读区域    未读     空闲
//  [A][B][C] [D][E] [ ][ ][ ][ ][ ]
//   0  1  2   3  4   5  6  7  8  9
//            ↑pos    ↑limit
//
// 调用 compact() 后:
// 1. 把未读数据 [D][E] 拷贝到缓冲区开头
// 2. position = 剩余未读数量 (2)
// 3. limit = capacity
//
//  [D][E][ ][ ][ ][ ][ ][ ][ ][ ]
//   0  1  2  3  4  5  6  7  8  9
//         ↑pos                   ↑limit/capacity
//
// 现在可以从 position=2 的位置继续写入新数据，而 D、E 被保留了

// java.nio.Buffer#rewind 的等价逻辑
public Buffer rewind() {
    position = 0;   // 只把 position 归零
    mark = -1;      // 清除 mark
    return this;    // limit 保持不变！
}

ByteBuffer buf = ByteBuffer.allocate(64);
buf.put("NIO".getBytes());
buf.flip();                    // position=0, limit=3
 
// 第一次读取
byte[] first = new byte[3];
buf.get(first);                // 读完后 position=3
System.out.println(new String(first)); // "NIO"
 
// 想再读一遍
buf.rewind();                  // position=0, limit 仍然=3
byte[] second = new byte[3];
buf.get(second);               // 再次从头读
System.out.println(new String(second)); // "NIO"

buf.position(2);   // 移动到位置 2
buf.mark();        // 在位置 2 打一个书签 (mark = 2)
buf.get();         // 读一个字节, position 变成 3
buf.get();         // 再读一个, position 变成 4
buf.reset();       // 跳回 mark 的位置, position 恢复为 2

// === 方式一：堆内缓冲区 (Heap Buffer) ===
// 数据存储在 JVM 堆内存中，由 GC 管理
// 分配快，但做 IO 时内核需要额外拷贝一次
ByteBuffer heapBuf = ByteBuffer.allocate(1024);  // 分配 1024 字节
 
// === 方式二：直接缓冲区 (Direct Buffer) ===
// 数据存储在 JVM 堆外的本地内存 (native memory)
// 分配慢、不受 GC 直接管理，但 IO 性能更高（少一次拷贝）
ByteBuffer directBuf = ByteBuffer.allocateDirect(1024);
 
// === 方式三：包装已有数组 (Wrap) ===
// 不分配新内存，直接把现有 byte[] 包装成 Buffer
// Buffer 和数组共享同一块内存，修改一方会影响另一方
byte[] data = {1, 2, 3, 4, 5};
ByteBuffer wrappedBuf = ByteBuffer.wrap(data);   // position=0, limit=capacity=5

import java.nio.ByteBuffer;
 
public class BufferDemo {
    public static void main(String[] args) {
        // 1. 创建一个容量为 10 的堆内缓冲区
        ByteBuffer buf = ByteBuffer.allocate(10);
        // 此时: position=0, limit=10, capacity=10
 
        // 2. 写入数据
        buf.put((byte) 'H');   // position: 0 → 1
        buf.put((byte) 'e');   // position: 1 → 2
        buf.put((byte) 'l');   // position: 2 → 3
        buf.put((byte) 'l');   // position: 3 → 4
        buf.put((byte) 'o');   // position: 4 → 5
        // 此时: position=5, limit=10, capacity=10
 
        // 3. 切换到读模式（最关键的一步）
        buf.flip();
        // 此时: position=0, limit=5, capacity=10
        // 可读数据范围: [0, 5)
 
        // 4. 读取数据
        StringBuilder sb = new StringBuilder();
        while (buf.hasRemaining()) {          // hasRemaining() 等价于 position < limit
            char c = (char) buf.get();        // 每次 get() 后 position 自动 +1
            sb.append(c);
        }
        System.out.println(sb.toString());    // 输出: Hello
        // 此时: position=5, limit=5 (已读完)
 
        // 5. 清空缓冲区，准备下一轮写入
        buf.clear();
        // 此时: position=0, limit=10, capacity=10
        // 缓冲区逻辑上为空，可以重新写入
    }
}

import java.nio.ByteBuffer;
 
public class CompactDemo {
    public static void main(String[] args) {
        ByteBuffer buf = ByteBuffer.allocate(10);
 
        // 写入 5 个字节
        buf.put("ABCDE".getBytes());   // position=5, limit=10
 
        // 切换到读模式
        buf.flip();                     // position=0, limit=5
 
        // 只读取前 3 个字节
        for (int i = 0; i < 3; i++) {
            System.out.print((char) buf.get());  // 输出: ABC
        }
        System.out.println();
        // 此时: position=3, limit=5, 还剩 D、E 未读
 
        // 调用 compact：保留未读的 D、E，切换回写模式
        buf.compact();
        // 此时: [D][E][?][?][?][?][?][?][?][?]
        //        0   1  2  3  4  5  6  7  8  9
        //            ↑pos                      ↑limit/capacity
        // position=2 (未读数据量), limit=10
 
        // 继续写入新数据
        buf.put("FGH".getBytes());     // 从 position=2 开始写入
        // 此时: [D][E][F][G][H][?][?][?][?][?]
        //        0   1  2  3  4  5  ...
        //                          ↑pos
 
        // 再次 flip 读取全部有效数据
        buf.flip();                     // position=0, limit=5
        while (buf.hasRemaining()) {
            System.out.print((char) buf.get());  // 输出: DEFGH
        }
        System.out.println();
    }
}

ByteBuffer buf = ByteBuffer.allocate(10);
buf.put("Hello".getBytes());
buf.flip();
 
// remaining(): 返回剩余可读/可写元素数量 (limit - position)
int remaining = buf.remaining();       // 5
 
// hasRemaining(): 是否还有剩余 (position < limit)
boolean has = buf.hasRemaining();      // true
 
// position(int): 手动设置 position（随机访问）
buf.position(2);                       // 跳到索引 2
byte b = buf.get();                    // 读取索引 2 的值 ('l'), position → 3
 
// get(int): 绝对读取，不移动 position
byte abs = buf.get(0);                 // 读取索引 0 的值 ('H'), position 不变
 
// put(int, byte): 绝对写入，不移动 position
buf.put(0, (byte) 'X');               // 把索引 0 改为 'X', position 不变
 
// slice(): 创建一个共享底层数据的子缓冲区
buf.position(1);
buf.limit(4);
ByteBuffer slice = buf.slice();        // slice 的 capacity=3, 对应原 buf 的 [1,4)
// 修改 slice 的数据会影响原 buf（共享内存）
 
// duplicate(): 创建一个共享底层数据的副本，但有独立的 position/limit/mark
ByteBuffer dup = buf.duplicate();      // dup 和 buf 共享数据，但指针独立
 
// asReadOnlyBuffer(): 创建只读视图
ByteBuffer readOnly = buf.asReadOnlyBuffer();
// readOnly.put((byte) 1);  // ❌ 抛出 ReadOnlyBufferException

ByteBuffer buf = ByteBuffer.allocate(16);
 
// 写入一个 int (4 字节) 和一个 double (8 字节)
buf.putInt(42);              // position: 0 → 4
buf.putDouble(3.14);         // position: 4 → 12
 
buf.flip();                  // 切换到读模式
 
// 按写入顺序读取
int i = buf.getInt();        // 42,  position: 0 → 4
double d = buf.getDouble();  // 3.14, position: 4 → 12
 
// 也可以通过视图操作
buf.clear();
buf.putInt(100);
buf.putInt(200);
buf.putInt(300);
buf.flip();
 
// 把 ByteBuffer 当作 IntBuffer 来用
IntBuffer intView = buf.asIntBuffer();  // 共享底层数据
System.out.println(intView.get());      // 100
System.out.println(intView.get());      // 200
System.out.println(intView.get());      // 300

ByteBuffer buf = ByteBuffer.allocate(4);
 
// 默认 Big-Endian
buf.order(ByteOrder.BIG_ENDIAN);       // 网络字节序（Java 默认）
buf.putInt(0x01020304);
// 内存中: [01][02][03][04]
 
buf.clear();
 
// 切换为 Little-Endian
buf.order(ByteOrder.LITTLE_ENDIAN);    // x86 CPU 原生字节序
buf.putInt(0x01020304);
// 内存中: [04][03][02][01]

ByteBuffer buf = ByteBuffer.allocate(10);
buf.put(new byte[]{65, 66, 67, 68, 69}); // A B C D E
buf.flip();
buf.get();
buf.get();
buf.compact();
buf.put((byte) 70); // F
buf.flip();
byte[] result = new byte[buf.remaining()];
buf.get(result);
System.out.println(new String(result));

// 从 FileInputStream 获取 —— 只读 Channel
FileInputStream fis = new FileInputStream("data.txt");
FileChannel readChannel = fis.getChannel(); // 只能调用 read()
 
// 从 FileOutputStream 获取 —— 只写 Channel
FileOutputStream fos = new FileOutputStream("output.txt");
FileChannel writeChannel = fos.getChannel(); // 只能调用 write()
 
// 从 RandomAccessFile 获取 —— 可读可写 Channel
RandomAccessFile raf = new RandomAccessFile("data.txt", "rw");
FileChannel rwChannel = raf.getChannel(); // read() 和 write() 都可用

// 以只读模式打开
FileChannel readCh = FileChannel.open(
    Path.of("data.txt"),        // 文件路径
    StandardOpenOption.READ     // 只读
);
 
// 以读写模式打开，文件不存在则创建
FileChannel rwCh = FileChannel.open(
    Path.of("data.txt"),
    StandardOpenOption.READ,            // 读
    StandardOpenOption.WRITE,           // 写
    StandardOpenOption.CREATE           // 不存在则创建
);
 
// 以追加模式打开
FileChannel appendCh = FileChannel.open(
    Path.of("log.txt"),
    StandardOpenOption.WRITE,           // 写
    StandardOpenOption.APPEND,          // 追加到末尾
    StandardOpenOption.CREATE           // 不存在则创建
);

public static void readFile(String path) throws IOException {
    // 1. 以只读模式打开 FileChannel
    //    try-with-resources 确保 Channel 自动关闭
    try (FileChannel channel = FileChannel.open(
            Path.of(path), StandardOpenOption.READ)) {
 
        // 2. 分配一个 1024 字节的堆内缓冲区
        //    这是数据的"中转站"，Channel 会把数据读到这里
        ByteBuffer buffer = ByteBuffer.allocate(1024);
 
        // 3. 循环读取，直到文件末尾
        //    channel.read(buffer) 将数据从文件写入 buffer
        //    返回值是本次实际读取的字节数，-1 表示 EOF
        while (channel.read(buffer) != -1) {
 
            // 4. 切换 buffer 为读模式
            //    flip() 将 limit 设为当前 position，position 归零
            //    这样后续的 get 操作才能读到刚写入的数据
            buffer.flip();
 
            // 5. 使用 Charset 将 buffer 中的字节解码为字符串
            //    StandardCharsets.UTF_8 指定解码字符集
            System.out.print(
                StandardCharsets.UTF_8.decode(buffer).toString()
            );
 
            // 6. 清空 buffer，为下一轮读取做准备
            //    clear() 将 position 归零，limit 设为 capacity
            //    注意：数据并未真正擦除，只是重置了指针
            buffer.clear();
        }
    } // 7. try-with-resources 自动调用 channel.close()
}

public static void writeFile(String path, String content) throws IOException {
    // 1. 以写模式打开 Channel，文件不存在则创建，存在则清空
    try (FileChannel channel = FileChannel.open(
            Path.of(path),
            StandardOpenOption.WRITE,
            StandardOpenOption.CREATE,
            StandardOpenOption.TRUNCATE_EXISTING)) {
 
        // 2. 将字符串编码为 ByteBuffer
        //    wrap() 创建的 buffer 已经处于"可读"状态
        //    即 position=0, limit=字节数组长度
        ByteBuffer buffer = ByteBuffer.wrap(
            content.getBytes(StandardCharsets.UTF_8)
        );
 
        // 3. 循环写入，确保所有数据都写完
        //    hasRemaining() 检查 position < limit
        //    即 buffer 中是否还有未写出的数据
        while (buffer.hasRemaining()) {
            // write() 不保证一次写完所有数据
            // 所以必须循环调用直到 buffer 清空
            channel.write(buffer);
        }
    }
}

public static void copyFile(String src, String dst) throws IOException {
    // 同时打开源文件（只读）和目标文件（写+创建）
    try (FileChannel srcChannel = FileChannel.open(
                Path.of(src), StandardOpenOption.READ);
         FileChannel dstChannel = FileChannel.open(
                Path.of(dst),
                StandardOpenOption.WRITE,
                StandardOpenOption.CREATE,
                StandardOpenOption.TRUNCATE_EXISTING)) {
 
        // 获取源文件总大小
        long fileSize = srcChannel.size();
 
        // transferTo 在某些操作系统上单次传输有上限（如 Linux 约 2GB）
        // 所以对大文件需要循环传输
        long transferred = 0; // 已传输字节数
        while (transferred < fileSize) {
            // 从 transferred 位置开始，传输剩余字节到目标 Channel
            long bytes = srcChannel.transferTo(
                transferred,                    // 源文件起始位置
                fileSize - transferred,         // 要传输的字节数
                dstChannel                      // 目标 Channel
            );
            transferred += bytes; // 累加已传输量
        }
    }
}

try (FileChannel channel = FileChannel.open(
        Path.of("data.txt"),
        StandardOpenOption.READ, StandardOpenOption.WRITE)) {
 
    // 获取当前位置（初始为 0）
    long pos = channel.position();       // 0
 
    // 跳转到文件第 100 字节处
    channel.position(100);               // 设置位置为 100
 
    // 从第 100 字节处开始读取
    ByteBuffer buf = ByteBuffer.allocate(50);
    channel.read(buf);                   // 读取 50 字节（位置 100~149）
 
    // 获取文件总大小（字节数）
    long size = channel.size();
 
    // 截断文件为 200 字节（超出部分被丢弃）
    channel.truncate(200);
 
    // 强制将数据刷写到磁盘
    // 参数 true 表示同时刷写文件内容和元数据（修改时间等）
    // 参数 false 表示只刷写文件内容
    channel.force(true);
}

try (FileChannel channel = FileChannel.open(
        Path.of("large_data.bin"),
        StandardOpenOption.READ, StandardOpenOption.WRITE)) {
 
    // 将文件从位置 0 开始、整个文件大小的区域映射到内存
    // MapMode.READ_WRITE 表示可读可写
    // 返回的 MappedByteBuffer 是 ByteBuffer 的子类
    MappedByteBuffer mappedBuffer = channel.map(
        FileChannel.MapMode.READ_WRITE,  // 映射模式
        0,                                // 起始位置
        channel.size()                    // 映射长度
    );
 
    // 现在可以像操作普通 ByteBuffer 一样操作文件内容
    // 读取第 0 个字节
    byte firstByte = mappedBuffer.get(0);
 
    // 在位置 0 写入一个字节，会直接反映到文件中
    mappedBuffer.put(0, (byte) 0x41);  // 写入 'A'
 
    // 读取位置 100 处的一个 int（4 字节）
    int value = mappedBuffer.getInt(100);
 
    // 强制将修改刷写到磁盘
    mappedBuffer.force();
}

try (FileChannel channel = FileChannel.open(
        Path.of("shared.dat"),
        StandardOpenOption.READ, StandardOpenOption.WRITE)) {
 
    // 获取独占锁（排他锁），会阻塞直到获取成功
    // lock() 锁定整个文件
    FileLock lock = channel.lock();
 
    try {
        // 在锁保护下安全地读写文件
        ByteBuffer buf = ByteBuffer.allocate(1024);
        channel.read(buf);
        // ... 处理数据 ...
    } finally {
        // 必须释放锁
        lock.release();
    }
 
    // 也可以锁定文件的一部分区域
    // lock(position, size, shared)
    // shared=true 为共享锁（允许其他进程同时读）
    // shared=false 为独占锁（其他进程不能读也不能写）
    FileLock regionLock = channel.lock(0, 100, true); // 共享锁，锁前 100 字节
 
    // tryLock() 是非阻塞版本，获取不到锁时返回 null 而不是阻塞
    FileLock tryResult = channel.tryLock();
    if (tryResult != null) {
        // 获取到锁，执行操作
        tryResult.release();
    } else {
        // 未获取到锁，执行其他逻辑
    }
}

// 同时注册读事件和写事件
// OP_READ = 0001, OP_WRITE = 0100, 位或结果 = 0101
channel.register(selector, SelectionKey.OP_READ | SelectionKey.OP_WRITE);

// 1. 阻塞式 select —— 一直阻塞，直到至少有一个 Channel 就绪
//    返回值是"新增"就绪的 Channel 数量（不是总数）
int readyCount = selector.select();
 
// 2. 带超时的 select —— 最多阻塞 timeout 毫秒
//    超时后即使没有就绪事件也会返回 0
int readyCount = selector.select(long timeout);
 
// 3. 非阻塞式 selectNow —— 立即返回，不阻塞
//    如果没有就绪事件，返回 0
int readyCount = selector.selectNow();

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 NioEchoServer {
 
    public static void main(String[] args) throws IOException {
 
        // ========== 1. 初始化阶段 ==========
 
        // 打开一个 Selector（底层会根据操作系统选择 epoll/kqueue/IOCP）
        Selector selector = Selector.open();
 
        // 打开一个 ServerSocketChannel，用于监听客户端连接
        ServerSocketChannel serverChannel = ServerSocketChannel.open();
 
        // 绑定到本地 8080 端口
        serverChannel.bind(new InetSocketAddress(8080));
 
        // 【关键】设置为非阻塞模式，这是注册到 Selector 的前提条件
        serverChannel.configureBlocking(false);
 
        // 将 ServerSocketChannel 注册到 Selector 上，关心 ACCEPT 事件
        // 返回的 SelectionKey 可以保存下来，但这里我们暂时不需要
        serverChannel.register(selector, SelectionKey.OP_ACCEPT);
 
        System.out.println("NIO Echo Server started on port 8080...");
 
        // ========== 2. 事件循环（Event Loop） ==========
 
        // 这就是 NIO 服务器的核心——一个无限循环，不断轮询就绪事件
        while (true) {
 
            // 阻塞等待，直到至少有一个 Channel 上有就绪事件
            // 返回值是新增就绪的 Channel 数量
            int readyChannels = selector.select();
 
            // 如果返回 0，说明是被 wakeup() 唤醒或超时，跳过本轮
            if (readyChannels == 0) {
                continue;
            }
 
            // 获取所有有就绪事件的 SelectionKey 集合
            Set<SelectionKey> selectedKeys = selector.selectedKeys();
 
            // 使用 Iterator 遍历，因为我们需要在遍历过程中移除元素
            Iterator<SelectionKey> keyIterator = selectedKeys.iterator();
 
            while (keyIterator.hasNext()) {
 
                // 取出当前的 SelectionKey
                SelectionKey key = keyIterator.next();
 
                // 【关键】处理完后必须手动移除！
                // 否则下次 select() 返回时这个 Key 还在集合中，会重复处理
                keyIterator.remove();
 
                // 判断事件类型并分发处理
                if (key.isAcceptable()) {
                    // ---- 处理新连接 ----
                    handleAccept(key, selector);
 
                } else if (key.isReadable()) {
                    // ---- 处理读事件 ----
                    handleRead(key);
                }
            }
        }
    }
 
    /**
     * 处理 OP_ACCEPT 事件：接受新的客户端连接
     */
    private static void handleAccept(SelectionKey key, Selector selector)
            throws IOException {
 
        // 通过 SelectionKey 获取对应的 ServerSocketChannel
        ServerSocketChannel serverChannel = (ServerSocketChannel) key.channel();
 
        // 接受客户端连接，返回一个新的 SocketChannel
        // 因为 ServerSocketChannel 是非阻塞的，accept() 不会阻塞
        SocketChannel clientChannel = serverChannel.accept();
 
        // 将新的客户端 Channel 也设置为非阻塞模式
        clientChannel.configureBlocking(false);
 
        // 将客户端 Channel 注册到同一个 Selector 上，关心 READ 事件
        // 同时附带一个 ByteBuffer 作为 attachment，用于后续读写
        clientChannel.register(selector, SelectionKey.OP_READ,
                ByteBuffer.allocate(1024));
 
        System.out.println("New client connected: "
                + clientChannel.getRemoteAddress());
    }
 
    /**
     * 处理 OP_READ 事件：读取客户端数据并回传（Echo）
     */
    private static void handleRead(SelectionKey key) throws IOException {
 
        // 通过 SelectionKey 获取对应的 SocketChannel
        SocketChannel clientChannel = (SocketChannel) key.channel();
 
        // 获取注册时附带的 ByteBuffer（attachment）
        ByteBuffer buffer = (ByteBuffer) key.attachment();
 
        // 清空 buffer，准备读入新数据
        buffer.clear();
 
        // 从 Channel 读取数据到 Buffer
        // 返回值：正数 = 读取的字节数，0 = 没有数据，-1 = 连接关闭
        int bytesRead = clientChannel.read(buffer);
 
        if (bytesRead == -1) {
            // 客户端关闭了连接
            System.out.println("Client disconnected: "
                    + clientChannel.getRemoteAddress());
            // 取消这个 Key 的注册（会在下次 select 时清理）
            key.cancel();
            // 关闭 Channel
            clientChannel.close();
            return;
        }
 
        if (bytesRead > 0) {
            // 翻转 buffer：从写模式切换到读模式
            // position 归零，limit 设为之前写入的位置
            buffer.flip();
 
            // 将 buffer 中的数据原样写回客户端（Echo）
            // 注意：实际生产中应该循环写入，因为 write() 不保证一次写完
            clientChannel.write(buffer);
 
            // 如果 buffer 中还有未写完的数据（write 没有写完）
            if (buffer.hasRemaining()) {
                // compact() 将未读数据移到 buffer 开头，为下次写入做准备
                buffer.compact();
            } else {
                // 全部写完，清空 buffer
                buffer.clear();
            }
        }
    }
}

// ❌ 错误写法：使用 for-each 无法在遍历中移除元素
for (SelectionKey key : selector.selectedKeys()) {
    // 处理事件...
    // 没有 remove，下次还会处理这个 key！
}
 
// ✅ 正确写法：使用 Iterator 并在处理后 remove
Iterator<SelectionKey> it = selector.selectedKeys().iterator();
while (it.hasNext()) {
    SelectionKey key = it.next();
    it.remove(); // 处理前或处理后移除，但必须移除
    // 处理事件...
}

while (it.hasNext()) {
    SelectionKey key = it.next();
    it.remove();
    // 先检查 Key 是否仍然有效
    if (!key.isValid()) {
        continue; // 跳过无效的 Key
    }
    if (key.isAcceptable()) {
        // ...
    }
}

// 当需要写数据时，先尝试直接写
int written = channel.write(buffer);
 
// 如果 buffer 还有剩余数据没写完（说明 Socket 写缓冲区满了）
if (buffer.hasRemaining()) {
    // 这时才注册 OP_WRITE，等待缓冲区可写时继续写
    key.interestOps(key.interestOps() | SelectionKey.OP_WRITE);
} else {
    // 写完了，取消 OP_WRITE 注册，避免空转
    key.interestOps(key.interestOps() & ~SelectionKey.OP_WRITE);
}

try {
    handleRead(key);
} catch (IOException e) {
    // 发生异常，关闭连接并取消注册
    key.cancel();          // 取消 Key
    key.channel().close(); // 关闭 Channel
}

// 对比：原生 NIO vs Netty 实现同样的 Echo Server
 
// ---- 原生 NIO：约 80-100 行代码（如上面的完整示例）----
 
// ---- Netty：核心代码约 20 行 ----
// EventLoopGroup bossGroup = new NioEventLoopGroup(1);    // Main Reactor
// EventLoopGroup workerGroup = new NioEventLoopGroup();    // Sub Reactors
// ServerBootstrap b = new ServerBootstrap();
// b.group(bossGroup, workerGroup)
//  .channel(NioServerSocketChannel.class)
//  .childHandler(new ChannelInitializer<SocketChannel>() {
//      protected void initChannel(SocketChannel ch) {
//          ch.pipeline().addLast(new EchoServerHandler());
//      }
//  });
// b.bind(8080).sync();

// 旧方式：File 的痛点
File file = new File("/tmp/test.txt");
boolean deleted = file.delete(); // 失败了？为什么？不知道。
 
// 新方式：Files 直接抛异常，原因清清楚楚
Path path = Path.of("/tmp/test.txt");
Files.delete(path); // 文件不存在？抛 NoSuchFileException
                     // 权限不够？抛 AccessDeniedException

// ========== 创建 Path 的三种主要方式 ==========
 
// 方式一：Path.of()（Java 11+，最推荐的写法）
Path p1 = Path.of("/home/user/documents/report.txt");  // 绝对路径
Path p2 = Path.of("src", "main", "java");              // 可变参数自动拼接，等价于 "src/main/java"
 
// 方式二：Paths.get()（Java 7+，功能与 Path.of() 完全相同）
// 实际上 Path.of() 内部就是调用 Paths.get()
Path p3 = Paths.get("/home/user/documents/report.txt");
Path p4 = Paths.get("src", "main", "java");
 
// 方式三：从 FileSystem 获取（用于访问非默认文件系统，如 ZIP 文件内部）
Path p5 = FileSystems.getDefault().getPath("/tmp", "test.txt");
 
// 与旧 API 互转（兼容遗留代码时使用）
File oldFile = new File("/tmp/test.txt");
Path fromFile = oldFile.toPath();        // File -> Path
File backToFile = fromFile.toFile();     // Path -> File

Path path = Path.of("/home/user/documents/report.txt");
 
// ========== 基本信息提取 ==========
path.getFileName();    // report.txt     —— 路径的最后一个元素（文件名或目录名）
path.getParent();      // /home/user/documents —— 父路径
path.getRoot();        // /              —— 根元素（Windows 上可能是 "C:\"）
path.getNameCount();   // 4              —— 名称元素个数（不含根）
 
// ========== 按索引访问名称元素 ==========
path.getName(0);       // home           —— 第 0 个元素
path.getName(1);       // user           —— 第 1 个元素
path.getName(2);       // documents
path.getName(3);       // report.txt
 
// ========== 子路径截取 ==========
path.subpath(0, 2);   // home/user      —— 从索引 0 到 2（不含 2）的子路径
 
// ========== 路径类型判断 ==========
path.isAbsolute();     // true           —— 是否为绝对路径
Path rel = Path.of("src/Main.java");
rel.isAbsolute();      // false          —— 相对路径

// ========== resolve：拼接子路径 ==========
// resolve 是最常用的路径拼接方法
Path base = Path.of("/home/user");
Path full = base.resolve("documents/report.txt");
// 结果：/home/user/documents/report.txt
// 如果参数是绝对路径，则直接返回参数本身
Path abs = base.resolve("/etc/config");
// 结果：/etc/config（参数是绝对路径，base 被忽略）
 
// ========== resolveSibling：替换最后一个元素（兄弟路径） ==========
// 常用于"同目录下换个文件名"的场景
Path original = Path.of("/home/user/photo.jpg");
Path sibling = original.resolveSibling("photo_backup.jpg");
// 结果：/home/user/photo_backup.jpg
 
// ========== relativize：计算相对路径 ==========
// 从一个路径到另一个路径需要怎么走
Path p1 = Path.of("/home/user");
Path p2 = Path.of("/home/user/documents/report.txt");
Path relative = p1.relativize(p2);
// 结果：documents/report.txt（从 p1 出发到 p2 的相对路径）
 
Path p3 = Path.of("/home/admin");
Path rel2 = p1.relativize(p3);
// 结果：../admin（先回退一级，再进入 admin）
 
// ========== normalize：清理冗余的 . 和 .. ==========
Path messy = Path.of("/home/user/../user/./documents/../documents/report.txt");
Path clean = messy.normalize();
// 结果：/home/user/documents/report.txt（干干净净）
 
// ========== toAbsolutePath：转为绝对路径 ==========
Path rel = Path.of("src/Main.java");
Path absolute = rel.toAbsolutePath();
// 结果取决于当前工作目录，例如：/project/src/Main.java
 
// ========== toRealPath：解析符号链接，返回真实的规范路径 ==========
// 这个方法会实际访问文件系统，文件必须存在
Path real = Path.of("/tmp/link").toRealPath();
// 如果 /tmp/link 是指向 /var/data 的符号链接，返回 /var/data

// ========== 创建文件 ==========
Path newFile = Path.of("/tmp/hello.txt");
Files.createFile(newFile);
// 文件已存在？抛 FileAlreadyExistsException
 
// ========== 创建单层目录 ==========
Path dir = Path.of("/tmp/mydir");
Files.createDirectory(dir);
// 父目录不存在？抛 NoSuchFileException
 
// ========== 创建多层目录（递归创建，最常用） ==========
Path dirs = Path.of("/tmp/a/b/c/d");
Files.createDirectories(dirs);
// 自动创建所有不存在的中间目录，已存在也不报错
 
// ========== 创建临时文件和临时目录 ==========
// 临时文件：前缀 + 随机字符 + 后缀
Path tempFile = Files.createTempFile("app_", ".tmp");
// 例如：/tmp/app_8234792347.tmp
 
// 临时目录
Path tempDir = Files.createTempDirectory("cache_");
// 例如：/tmp/cache_1234567890

Path path = Path.of("example.txt");
 
// ========== 一次性读写（适合小文件） ==========
 
// 读取全部内容为字符串（Java 11+）
String content = Files.readString(path);
 
// 读取全部行为 List<String>
List<String> lines = Files.readAllLines(path, StandardCharsets.UTF_8);
 
// 读取全部字节
byte[] bytes = Files.readAllBytes(path);
 
// 写入字符串（Java 11+）
Files.writeString(path, "Hello NIO!", StandardCharsets.UTF_8);
 
// 写入多行
List<String> data = List.of("第一行", "第二行", "第三行");
Files.write(path, data, StandardCharsets.UTF_8);
 
// 写入字节
Files.write(path, new byte[]{72, 101, 108, 108, 111});
 
// ========== 追加写入 ==========
// 使用 StandardOpenOption.APPEND 选项
Files.writeString(path, "\n追加的内容",
        StandardCharsets.UTF_8,
        StandardOpenOption.APPEND);       // 追加模式
 
Files.write(path, List.of("追加行1", "追加行2"),
        StandardCharsets.UTF_8,
        StandardOpenOption.APPEND,        // 追加
        StandardOpenOption.CREATE);       // 不存在则创建
 
// ========== 流式读写（适合大文件） ==========
 
// 获取 BufferedReader（自动处理编码）
try (BufferedReader reader = Files.newBufferedReader(path, StandardCharsets.UTF_8)) {
    String line;
    while ((line = reader.readLine()) != null) {
        // 逐行处理，内存友好
        System.out.println(line);
    }
}
 
// 获取 BufferedWriter
try (BufferedWriter writer = Files.newBufferedWriter(path, StandardCharsets.UTF_8)) {
    writer.write("通过 BufferedWriter 写入");
    writer.newLine();  // 写入平台相关的换行符
}
 
// 获取 InputStream / OutputStream（处理二进制数据）
try (InputStream in = Files.newInputStream(path)) {
    // 读取二进制数据
}
try (OutputStream out = Files.newOutputStream(path, StandardOpenOption.APPEND)) {
    // 写入二进制数据
}
 
// ========== lines()：惰性流式读取（大文件首选） ==========
// 返回 Stream<String>，按需读取，不会一次性加载整个文件
try (Stream<String> stream = Files.lines(path, StandardCharsets.UTF_8)) {
    stream.filter(line -> line.contains("ERROR"))   // 只筛选包含 ERROR 的行
          .map(String::trim)                         // 去除首尾空白
          .forEach(System.out::println);             // 输出
}
// 注意：Files.lines() 返回的 Stream 必须关闭（用 try-with-resources）
// 因为底层持有文件句柄（file handle）

Path source = Path.of("original.txt");
Path target = Path.of("backup/original.txt");
 
// ========== 复制 ==========
Files.copy(source, target);
// 目标已存在？抛 FileAlreadyExistsException
 
// 覆盖已有文件
Files.copy(source, target, StandardCopyOption.REPLACE_EXISTING);
 
// 复制文件属性（权限、时间戳等）
Files.copy(source, target,
        StandardCopyOption.REPLACE_EXISTING,
        StandardCopyOption.COPY_ATTRIBUTES);  // 保留原文件的元数据
 
// 从 InputStream 复制到文件（下载场景常用）
try (InputStream in = new URL("https://example.com/file.zip").openStream()) {
    Files.copy(in, Path.of("downloaded.zip"),
            StandardCopyOption.REPLACE_EXISTING);
}
 
// ========== 移动（重命名也是移动） ==========
Files.move(source, target);
 
// 原子移动（要么完全成功，要么完全不动，不会出现中间状态）
Files.move(source, target,
        StandardCopyOption.ATOMIC_MOVE);      // 原子操作，保证数据安全
 
// ========== 删除 ==========
Files.delete(path);              // 文件不存在？抛 NoSuchFileException
Files.deleteIfExists(path);      // 文件不存在？静默返回 false，不抛异常
 
// 注意：Files 没有递归删除目录的方法
// 删除非空目录会抛 DirectoryNotEmptyException
// 需要自己用 walkFileTree 实现递归删除（后面会讲）

Path path = Path.of("example.txt");
 
// ========== 存在性与类型检查 ==========
Files.exists(path);              // 是否存在
Files.notExists(path);           // 是否确定不存在（注意：和 !exists() 不完全等价）
Files.isRegularFile(path);       // 是否为普通文件
Files.isDirectory(path);         // 是否为目录
Files.isSymbolicLink(path);      // 是否为符号链接
Files.isReadable(path);          // 是否可读
Files.isWritable(path);          // 是否可写
Files.isExecutable(path);        // 是否可执行
Files.isHidden(path);            // 是否为隐藏文件
 
// ========== 文件大小 ==========
long size = Files.size(path);    // 返回字节数
 
// ========== 最后修改时间 ==========
FileTime lastModified = Files.getLastModifiedTime(path);
System.out.println(lastModified);  // 2024-01-15T08:30:00Z
 
// 修改最后修改时间
Files.setLastModifiedTime(path, FileTime.fromMillis(System.currentTimeMillis()));
 
// ========== MIME 类型探测 ==========
String mimeType = Files.probeContentType(path);
// 例如："text/plain", "image/png", "application/pdf"
 
// ========== 详细属性（BasicFileAttributes） ==========
BasicFileAttributes attrs = Files.readAttributes(path, BasicFileAttributes.class);
attrs.creationTime();            // 创建时间
attrs.lastModifiedTime();        // 最后修改时间
attrs.lastAccessTime();          // 最后访问时间
attrs.size();                    // 文件大小
attrs.isRegularFile();           // 是否普通文件
attrs.isDirectory();             // 是否目录
attrs.isSymbolicLink();          // 是否符号链接

// Files.list() 只列出直接子项（不递归），返回惰性 Stream
try (Stream<Path> entries = Files.list(Path.of("/home/user"))) {
    entries.filter(Files::isRegularFile)       // 只要文件，不要目录
           .filter(p -> p.toString().endsWith(".java"))  // 只要 .java 文件
           .sorted()                            // 按路径排序
           .forEach(System.out::println);       // 输出
}
// 同样需要 try-with-resources 关闭底层目录流

// Files.walk() 递归遍历整个目录树，深度优先（depth-first）
try (Stream<Path> tree = Files.walk(Path.of("/project/src"))) {
    // 统计所有 .java 文件的总行数
    long totalLines = tree
            .filter(p -> p.toString().endsWith(".java"))  // 筛选 Java 文件
            .mapToLong(p -> {
                try {
                    return Files.lines(p).count();         // 统计每个文件的行数
                } catch (IOException e) {
                    return 0L;
                }
            })
            .sum();                                        // 求和
    System.out.println("Total lines of Java code: " + totalLines);
}
 
// 限制遍历深度（第二个参数）
try (Stream<Path> shallow = Files.walk(Path.of("/project"), 2)) {
    // 最多往下走 2 层
    shallow.forEach(System.out::println);
}

// ========== 经典用例：递归删除目录 ==========
Path dirToDelete = Path.of("/tmp/old_project");
 
Files.walkFileTree(dirToDelete, new SimpleFileVisitor<Path>() {
 
    // 访问每个文件时调用
    @Override
    public FileVisitResult visitFile(Path file, BasicFileAttributes attrs)
            throws IOException {
        Files.delete(file);                    // 删除文件
        return FileVisitResult.CONTINUE;       // 继续遍历
    }
 
    // 离开目录时调用（此时目录内的文件已经全部删除）
    @Override
    public FileVisitResult postVisitDirectory(Path dir, IOException exc)
            throws IOException {
        Files.delete(dir);                     // 删除空目录
        return FileVisitResult.CONTINUE;       // 继续遍历
    }
});

// ========== 递归复制目录 ==========
Path src = Path.of("/project/source");
Path dest = Path.of("/project/backup");
 
Files.walkFileTree(src, new SimpleFileVisitor<Path>() {
 
    // 进入目录前：在目标位置创建对应目录
    @Override
    public FileVisitResult preVisitDirectory(Path dir, BasicFileAttributes attrs)
            throws IOException {
        // src.relativize(dir) 计算 dir 相对于 src 的路径
        // dest.resolve(...) 拼接到目标路径
        Path targetDir = dest.resolve(src.relativize(dir));
        Files.createDirectories(targetDir);    // 创建目标目录
        return FileVisitResult.CONTINUE;
    }
 
    // 访问文件时：复制到目标位置
    @Override
    public FileVisitResult visitFile(Path file, BasicFileAttributes attrs)
            throws IOException {
        Path targetFile = dest.resolve(src.relativize(file));
        Files.copy(file, targetFile,
                StandardCopyOption.REPLACE_EXISTING);  // 复制文件
        return FileVisitResult.CONTINUE;
    }
});

// 搜索 /project 下所有大于 1MB 的 .log 文件，最多递归 10 层
try (Stream<Path> results = Files.find(
        Path.of("/project"),          // 起始目录
        10,                           // 最大递归深度
        (path, attrs) ->              // BiPredicate<Path, BasicFileAttributes>
                attrs.isRegularFile()                          // 是普通文件
                && path.toString().endsWith(".log")            // 以 .log 结尾
                && attrs.size() > 1024 * 1024                  // 大于 1MB
)) {
    results.sorted(Comparator.comparingLong(p -> {
                try {
                    return Files.size(p);                      // 按文件大小排序
                } catch (IOException e) {
                    return 0L;
                }
            }))
           .forEach(p -> System.out.println(p + " -> " + formatSize(p)));
}

// ========== 旧方式：java.io.File ==========
public static void copyDirectoryOld(File src, File dest) {
    if (src.isDirectory()) {                       // 判断是否为目录
        if (!dest.exists()) {
            boolean created = dest.mkdirs();       // 创建目录，失败只返回 false
            if (!created) {
                // 为什么失败？不知道。权限？磁盘满了？路径非法？
                System.err.println("Failed to create: " + dest);
                return;
            }
        }
        String[] children = src.list();            // 可能返回 null！
        if (children != null) {                    // 必须判空
            for (String child : children) {
                copyDirectoryOld(
                    new File(src, child),
                    new File(dest, child)
                );
            }
        }
    } else {
        // 手动用流复制文件，一堆样板代码...
        try (InputStream in = new FileInputStream(src);
             OutputStream out = new FileOutputStream(dest)) {
            byte[] buf = new byte[8192];
            int len;
            while ((len = in.read(buf)) > 0) {
                out.write(buf, 0, len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
 
// ========== 新方式：Path + Files ==========
public static void copyDirectoryNew(Path src, Path dest) throws IOException {
    // 简洁、安全、异常信息明确
    Files.walkFileTree(src, new SimpleFileVisitor<>() {
        @Override
        public FileVisitResult preVisitDirectory(Path dir, BasicFileAttributes attrs)
                throws IOException {
            Files.createDirectories(dest.resolve(src.relativize(dir)));
            return FileVisitResult.CONTINUE;
        }
 
        @Override
        public FileVisitResult visitFile(Path file, BasicFileAttributes attrs)
                throws IOException {
            Files.copy(file, dest.resolve(src.relativize(file)),
                    StandardCopyOption.REPLACE_EXISTING);
            return FileVisitResult.CONTINUE;
        }
    });
}

// ========== 常用 OpenOption 组合 ==========
 
// 默认行为（不指定时）：CREATE + TRUNCATE_EXISTING + WRITE
Files.writeString(path, "hello");
// 等价于：
Files.writeString(path, "hello",
        StandardOpenOption.CREATE,              // 不存在则创建
        StandardOpenOption.TRUNCATE_EXISTING,   // 存在则清空
        StandardOpenOption.WRITE);              // 写模式
 
// 追加模式
Files.writeString(path, "appended",
        StandardOpenOption.CREATE,              // 不存在则创建
        StandardOpenOption.APPEND);             // 追加到末尾
 
// 仅创建新文件（文件已存在则报错，防止意外覆盖）
Files.writeString(path, "new content",
        StandardOpenOption.CREATE_NEW,          // 必须是新文件
        StandardOpenOption.WRITE);
 
// 同步写入（每次写操作都刷盘，保证数据安全，但性能较低）
Files.newOutputStream(path,
        StandardOpenOption.CREATE,
        StandardOpenOption.WRITE,
        StandardOpenOption.SYNC);               // 同步刷盘

// ========== 创建符号链接 ==========
Path target = Path.of("/var/data/app.log");        // 实际文件
Path link = Path.of("/home/user/current.log");     // 符号链接
 
Files.createSymbolicLink(link, target);
// 现在访问 /home/user/current.log 实际上访问的是 /var/data/app.log
 
// ========== 读取符号链接指向的目标 ==========
Path linkTarget = Files.readSymbolicLink(link);
System.out.println(linkTarget);  // /var/data/app.log
 
// ========== 判断是否为符号链接 ==========
Files.isSymbolicLink(link);      // true
Files.isSymbolicLink(target);    // false
 
// ========== LinkOption 控制是否跟随符号链接 ==========
// 默认情况下，Files 的方法会跟随（follow）符号链接
// 使用 NOFOLLOW_LINKS 可以操作链接本身而非目标
 
// 检查符号链接本身是否存在（而非它指向的目标）
Files.exists(link, LinkOption.NOFOLLOW_LINKS);
 
// 读取符号链接本身的属性（而非目标文件的属性）
BasicFileAttributes linkAttrs = Files.readAttributes(
        link, BasicFileAttributes.class,
        LinkOption.NOFOLLOW_LINKS);

// ========== 监听目录变化 ==========
Path watchDir = Path.of("/project/config");
 
// 创建 WatchService（文件系统级别的服务）
WatchService watcher = FileSystems.getDefault().newWatchService();
 
// 注册要监听的事件类型
watchDir.register(watcher,
        StandardWatchEventKinds.ENTRY_CREATE,    // 文件创建
        StandardWatchEventKinds.ENTRY_MODIFY,    // 文件修改
        StandardWatchEventKinds.ENTRY_DELETE);   // 文件删除
 
System.out.println("开始监听目录: " + watchDir);
 
// 事件循环（通常在独立线程中运行）
while (true) {
    WatchKey key = watcher.take();               // 阻塞等待事件
 
    for (WatchEvent<?> event : key.pollEvents()) {
        WatchEvent.Kind<?> kind = event.kind();
 
        // OVERFLOW 表示事件丢失（系统来不及处理）
        if (kind == StandardWatchEventKinds.OVERFLOW) {
            continue;
        }
 
        // 获取触发事件的文件名
        @SuppressWarnings("unchecked")
        WatchEvent<Path> pathEvent = (WatchEvent<Path>) event;
        Path fileName = pathEvent.context();     // 相对于监听目录的文件名
 
        System.out.printf("事件: %-15s 文件: %s%n", kind.name(), fileName);
        // 输出示例：事件: ENTRY_MODIFY    文件: application.yml
    }
 
    // 重置 key，准备接收下一批事件
    boolean valid = key.reset();
    if (!valid) {
        break;  // 目录不可访问了，退出循环
    }
}

Path p1 = Path.of("/home/user/docs");
Path p2 = Path.of("/home/user/docs/java/nio/Buffer.java");
Path relative = p1.relativize(p2);
System.out.println(relative);
System.out.println(relative.getNameCount());
System.out.println(p1.resolve(relative).normalize());