IO、NIO 与 HttpClient

Path 与 Files：先掌握这 12 个方法01

Path dir = Path.of("data", "2026");
Files.createDirectories(dir);              // 父目录不存在也能建

Path file = dir.resolve("users.txt");
Path abs = file.toAbsolutePath().normalize();
System.out.println(abs);

Path base = Path.of("data");
System.out.println(base.relativize(file)); // 2026/users.txt

Path src = Path.of("a.txt");
Path dst = Path.of("backup", "a.txt");
Files.createDirectories(dst.getParent());

Files.copy(src, dst, StandardCopyOption.REPLACE_EXISTING);
Files.move(dst, Path.of("backup", "b.txt"), StandardCopyOption.ATOMIC_MOVE);
Files.deleteIfExists(Path.of("backup", "b.txt"));

文本读写：优先用 Files 一行搞定02

JDK 11 的 readString / writeString 覆盖了大多数小文件场景。大文件不要 readAllBytes，改用缓冲读取或流式处理。

Path path = Path.of("data", "notes.txt");

// 小文件：一行读写
Files.writeString(path, "第一行\n第二行\n", StandardCharsets.UTF_8);
String all = Files.readString(path, StandardCharsets.UTF_8);
System.out.println(all);

// 按行读取（自动关闭）
try (BufferedReader reader = Files.newBufferedReader(path, StandardCharsets.UTF_8)) {
    String line;
    while ((line = reader.readLine()) != null) {
        System.out.println(line);
    }
}

// 流式处理（必须关闭）
try (Stream<String> lines = Files.lines(path, StandardCharsets.UTF_8)) {
    long count = lines.filter(s -> !s.isBlank()).count();
    System.out.println(count);
}

• Files.lines 返回的 Stream 持有文件句柄，必须 try-with-resources。
• Files.walk / Files.list 同理，必须关闭。
• readAllLines 一次性加载全部行，只适合小文件。
• 写文件默认截断；追加用 StandardOpenOption.APPEND。
• Files.writeString 默认 CREATE + TRUNCATE_EXISTING + WRITE。

try (Stream<Path> paths = Files.walk(Path.of("src"))) {
    List<Path> javaFiles = paths
            .filter(p -> p.toString().endsWith(".java"))
            .toList();
    System.out.println(javaFiles.size());
}

JDK 18 起 file.encoding 默认 UTF-8（JEP 400），但不要依赖平台默认值：显式传 StandardCharsets.UTF_8，代码在旧 JDK 或其他平台上也一致。

HttpClient：同步与异步03

JDK 11 标准化的 java.net.http.HttpClient 支持 HTTP/1.1、HTTP/2、WebSocket，且是线程安全、可复用的。不要为每个请求 new 一个客户端。

HttpClient client = HttpClient.newBuilder()
        .version(HttpClient.Version.HTTP_2)
        .connectTimeout(Duration.ofSeconds(5))
        .followRedirects(HttpClient.Redirect.NORMAL)
        .build();

HttpRequest request = HttpRequest.newBuilder(
                URI.create("https://httpbin.org/get?q=jdk21"))
        .timeout(Duration.ofSeconds(10))
        .header("Accept", "application/json")
        .GET()
        .build();

HttpResponse<String> response = client.send(
        request, HttpResponse.BodyHandlers.ofString());

System.out.println(response.statusCode());
System.out.println(response.body());

client.sendAsync(request, HttpResponse.BodyHandlers.ofString())
        .thenApply(HttpResponse::body)
        .thenAccept(System.out::println)
        .exceptionally(ex -> {
            System.err.println("请求失败: " + ex.getMessage());
            return null;
        });

// 组合多个请求
CompletableFuture<String> a = client.sendAsync(reqA, HttpResponse.BodyHandlers.ofString())
        .thenApply(HttpResponse::body);
CompletableFuture<String> b = client.sendAsync(reqB, HttpResponse.BodyHandlers.ofString())
        .thenApply(HttpResponse::body);

String merged = a.thenCombine(b, (x, y) -> x + y).join();

• send 阻塞当前线程；sendAsync 返回 CompletableFuture，底层使用客户端执行器。
• 请求体用 BodyPublishers.ofString / ofFile / ofByteArray。
• 响应体用 BodyHandlers.ofString / ofFile / ofLines / discarding。
• HTTP/3 在 JDK 26 才进入标准 HTTP Client（JEP 517）；JDK 21 只能到 HTTP/2。
• 生产环境要设置连接超时、请求超时和重试策略。

// 带查询参数的 URL 需要编码
String q = "jdk 21";
String url = "https://example.com/search?q=" +
        URLEncoder.encode(q, StandardCharsets.UTF_8);

// POST JSON
HttpRequest post = HttpRequest.newBuilder(URI.create("https://example.com/api"))
        .header("Content-Type", "application/json")
        .POST(HttpRequest.BodyPublishers.ofString("{\"name\":\"jdk\"}"))
        .build();

NIO：什么时候需要下沉04

大多数业务不需要直接操作 ByteBuffer。只有大文件、内存映射、零拷贝、非阻塞网络等场景才值得增加复杂度。

// FileChannel + ByteBuffer 读取
try (FileChannel channel = FileChannel.open(path, StandardOpenOption.READ)) {
    ByteBuffer buffer = ByteBuffer.allocate(4096);
    while (channel.read(buffer) != -1) {
        buffer.flip();
        while (buffer.hasRemaining()) {
            byte b = buffer.get();
            // 处理字节
        }
        buffer.clear();
    }
}

// 内存映射：适合超大文件随机访问
try (FileChannel channel = FileChannel.open(path, StandardOpenOption.READ)) {
    MappedByteBuffer mapped = channel.map(
            FileChannel.MapMode.READ_ONLY, 0, channel.size());
    byte first = mapped.get(0);
    System.out.println((char) first);
}

• ByteBuffer 的 flip / clear / rewind 是新手最容易搞混的三兄弟。
• 直接缓冲区（DirectBuffer）分配成本高，受 -XX:MaxDirectMemorySize 限制，泄漏时表现为 OOM: Direct buffer memory。
• 内存映射文件释放依赖 GC / Cleaner，长期持有会占用虚拟内存。
• Files.readAllBytes 对大文件会直接吃满堆内存。

try-with-resources 与异常05

IO 资源必须关闭。try-with-resources 按声明的逆序关闭；主异常与关闭异常同时发生时，关闭异常作为 suppressed 附加在主异常上。

try (InputStream in = Files.newInputStream(src);
     OutputStream out = Files.newOutputStream(dst)) {
    in.transferTo(out);
} catch (IOException e) {
    for (Throwable suppressed : e.getSuppressed()) {
        System.err.println("关闭时异常: " + suppressed);
    }
    throw e;
}

• 实现 AutoCloseable 的对象都可以放进 try-with-resources。
• 不要手动在 finally 里关闭多个资源而不处理关闭异常；try-with-resources 会正确合并。
• InputStream.transferTo 是 JDK 9+ 的便捷拷贝方法，但不会自动缓冲；大文件可配合 BufferedInputStream。
• 网络请求失败时区分连接超时、读取超时、非 2xx 状态码，不要统一吞掉。

版本边界BOUNDARY

这张表比 API 本身更值得记。写代码时先确认你的运行时版本。

费曼自检SELF CHECK

先合上页面，用自己的话回答，再展开对照。能讲出因果和反例，才算真正掌握。