Java9新特性案例

本文目录导读：

1. 模块化系统（最重要特性）
2. JShell（交互式编程工具）
3. 私有接口方法
4. 集合工厂方法（of 方法）
5. Stream API 增强
6. Optional 增强
7. 进程 API 改进
8. 改进的 try-with-resources
9. HttpClient（标准化）
10. 钻石操作符改进
11. 接口中的私有方法（详细示例）

Java 9 最重要的特性是模块化系统（Project Jigsaw），但也包含了许多其他实用特性，下面用具体案例来演示主要新特性：

模块化系统（最重要特性）

模块定义 (module-info.java)：

// com.example.myapp/module-info.java
module com.example.myapp {
    requires java.sql;
    requires transitive java.logging;
    exports com.example.myapp.api;
    uses com.example.myapp.spi.ServiceProvider;
}

使用模块的示例：

// 模块A的定义
module com.example.util {
    exports com.example.util.strings;
    exports com.example.util.collections;
}

JShell（交互式编程工具）

$ jshell
|  欢迎使用 JShell -- 版本 9
|  要大致了解该版本, 请键入: /help intro
jshell> int add(int a, int b) {
   ...>     return a + b;
   ...> }
|  已创建 方法 add(int,int)
jshell> add(5, 3)
$1 ==> 8
jshell> /exit

私有接口方法

public interface Calculator {
    // Java 9 允许接口中的私有方法
    default int addNumbers(int... nums) {
        return calculate(nums, 0);
    }
    default int multiplyNumbers(int... nums) {
        return calculate(nums, 1);
    }
    // 私有方法（Java 9 新特性）
    private int calculate(int[] nums, int initial) {
        int result = initial;
        for (int num : nums) {
            if (initial == 0) {
                result += num;
            } else {
                result *= num;
            }
        }
        return result;
    }
}

集合工厂方法（of 方法）

import java.util.*;
public class CollectionFactoryExample {
    public static void main(String[] args) {
        // 创建不可变集合
        List<String> list = List.of("Java", "Python", "JavaScript");
        Set<Integer> set = Set.of(1, 2, 3, 4, 5);
        Map<String, Integer> map = Map.of("one", 1, "two", 2);
        // 创建 Map 的高级方法（超过10个键值对）
        Map<String, Integer> largeMap = Map.ofEntries(
            Map.entry("a", 1),
            Map.entry("b", 2),
            // ... 更多条目
            Map.entry("z", 26)
        );
        System.out.println(list);
        System.out.println(set);
        System.out.println(map);
    }
}

Stream API 增强

import java.util.stream.Stream;
public class StreamEnhancements {
    public static void main(String[] args) {
        // takeWhile: 获取满足条件的元素直到第一个不满足条件
        Stream.of(1, 2, 3, 4, 5, 6, 7, 8)
              .takeWhile(n -> n < 5)
              .forEach(System.out::print); // 输出: 1234
        System.out.println();
        // dropWhile: 丢弃满足条件的元素直到第一个不满足条件
        Stream.of(1, 2, 3, 4, 5, 6, 7, 8)
              .dropWhile(n -> n < 5)
              .forEach(System.out::print); // 输出: 5678
        System.out.println();
        // ofNullable: 避免空指针
        Stream.ofNullable(null)
              .forEach(System.out::println); // 不输出任何内容
        // iterate 重载
        Stream.iterate(1, n -> n < 100, n -> n * 2)
              .forEach(n -> System.out.print(n + " ")); // 1 2 4 8 16 32 64
    }
}

Optional 增强

import java.util.Optional;
import java.util.stream.Stream;
public class OptionalEnhancements {
    public static void main(String[] args) {
        // ifPresentOrElse: 如果存在则执行一个操作，否则执行另一个操作
        Optional<String> optional = Optional.of("Hello");
        optional.ifPresentOrElse(
            value -> System.out.println("Value: " + value),
            () -> System.out.println("Value is empty")
        );
        // or: Optional 为空则返回另一个 Optional
        Optional<String> empty = Optional.empty();
        Optional<String> fallback = empty.or(() -> Optional.of("Default"));
        System.out.println(fallback.get()); // 输出: Default
        // stream: 将 Optional 转换为 Stream
        Optional<String> opt = Optional.of("Java");
        opt.stream().forEach(System.out::println);
    }
}

进程 API 改进

import java.lang.ProcessHandle;
import java.util.stream.Collectors;
public class ProcessAPIExample {
    public static void main(String[] args) {
        // 获取当前进程信息
        ProcessHandle currentProcess = ProcessHandle.current();
        System.out.println("当前进程 PID: " + currentProcess.pid());
        System.out.println("当前进程信息: " + currentProcess.info());
        // 获取所有运行中的进程
        ProcessHandle.allProcesses()
            .forEach(process -> {
                System.out.printf("PID: %d, Command: %s%n", 
                    process.pid(), 
                    process.info().command().orElse("unknown"));
            });
    }
}

改进的 try-with-resources

import java.io.BufferedReader;
import java.io.FileReader;
public class TryWithResourcesExample {
    public static void main(String[] args) {
        // Java 9: 可以在 try 中使用已有变量
        BufferedReader reader = new BufferedReader(new FileReader("test.txt"));
        // 之前需要声明在 try 中，现在可以直接使用
        try (reader) {
            String line;
            while ((line = reader.readLine()) != null) {
                System.out.println(line);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

HttpClient（标准化）

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.util.concurrent.CompletableFuture;
public class HttpClientExample {
    public static void main(String[] args) throws Exception {
        // 同步请求
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://api.github.com/users/octocat"))
            .GET()
            .build();
        HttpResponse<String> response = client.send(request, 
            HttpResponse.BodyHandlers.ofString());
        System.out.println("响应状态码: " + response.statusCode());
        System.out.println("响应体: " + response.body());
        // 异步请求
        CompletableFuture<HttpResponse<String>> future = 
            client.sendAsync(request, HttpResponse.BodyHandlers.ofString());
        future.thenAccept(res -> {
            System.out.println("异步响应: " + res.body());
        }).join();
    }
}

钻石操作符改进

// Java 9 允许在匿名类中使用钻石操作符
public class DiamondOperatorImprovement {
    public static void main(String[] args) {
        // 以前不允许，现在可以
        Comparator<String> comparator = new Comparator<>() {
            @Override
            public int compare(String s1, String s2) {
                return s1.compareTo(s2);
            }
        };
    }
}

接口中的私有方法（详细示例）

interface StringHelper {
    // 默认方法
    default String reverse(String input) {
        return process(input, true);
    }
    default String removeVowels(String input) {
        return process(input, false);
    }
    // 私有方法（Java 9 新特性）
    private String process(String input, boolean reverseStr) {
        String result = input.toLowerCase();
        if (reverseStr) {
            return new StringBuilder(result).reverse().toString();
        }
        return result.replaceAll("[aeiou]", "");
    }
    // 静态方法也可以有私有方法
    static String toUpperCase(String input) {
        return processStatic(input);
    }
    private static String processStatic(String input) {
        return input.toUpperCase();
    }
}

这些是 Java 9 的主要特性示例，模块化系统是最重要的变更，而其他特性如集合工厂方法、Stream 增强、私有接口方法等都是日常开发中非常有用的改进。