JDK9到JDK21中值得掌握的29个实用特性分享

2025-05-23 10:44 开发作者：风象南

JDK 9 模块化与API增强

1. 集合工厂方法：一行代码创建不可变集合

在JDK9之前，创建小型不可变集合相当繁琐，现在只需要一行代码：

// 旧方式
List<String> list = Collections.unmodifiableList(Arrays.asList("Java", "Kotlin", "Scala"));
Map<String, Integer> map = Collections.unmodifiableMap(new HashMap<String, Integer>() {{
    put("Java", 1995);
    put("Kotlin", 2011);
    put("Scala", 2004);
}});

// JDK9方式
List<String> list = List.of("Java", "Kotlin", "Scala");
Set<String> set = Set.of("Java", "Kotlin", "Scala");
Map<String, Integer> map = Map.of(
    "Java", 1995,
    "Kotlin", 2011,
    "Scala", 2004
);

对于更多键值对，可以使用Map.ofEntries()：

Map<String, Integer> largeMap = Map.ofEntries(
    Map.entry("Java", 1995),
    Map.entry("Kotlin", 2011),
    Map.entry("Scala", 2004),
    Map.entry("Groovy", 2003)
    // ...可以有更多entries
);

实用场景：常量定义、配置集合、测试数据准备、API返回不可变结果。

2. 私有接口方法：接口代码复用不再尴尬

JDK8引入了接口默认方法，JDK9进一步允许接口拥有私有方法，便于在接口内部复用代码：

public interface FileProcessor {
    // 公共抽象方法
    void process(Path path);
    
    // 默认方法
    default void processFile(String fileName) {
        validateFileName(fileName); // 复用私有方法进行验证
        process(Path.of(fileName));
        log("Processed file: " + fileName);
    }
    
    default void processDirectory(String dirName) {
        validateFileName(dirName); // 复用相同的验证逻辑
        try (Stream<Path> paths = Files.list(Path.of(dirName))) {
            paths.forEach(this::proc编程客栈ess);
        } catch (IOException e) {
            handleException(e); // 复用私有方法处理异常
        }
        log("Processed directory: " + dirName);
    }
    
    // 私有方法 - 供默认方法使用
    private void validateFileName(String fileName) {
        if (fileName == null || fileName.isEmpty()) {
            throw new IllegalArgumentException("File name cannot be empty");
        }
    }
    
    // 私有静态方法
    private static void log(String message) {
        System.out.println("[" + LocalDateTime.now() + "] " + message);
    }
    
    private void handleException(Exception e) {
        log("Error: " + e.getMessage());
    }
}

实用场景：API设计、接口默认方法逻辑复用、框架开发。

3. Stream API增强：流操作更灵活

JDK9为Stream API增加了几个实用方法：

// 1. takeWhile - 从头开始获取元素，直到条件不满足
Stream.of(2, 4, 6, 8, 9, 10, 12)
      .takeWhile(n -> n % 2 == 0) // 结果: [2, 4, 6, 8]
      .forEach(System.out::println);

// 2. dropWhile - 从头开始丢弃元素，直到条件不满足
Stream.of(2, 4, 6, 8, 9, 10, 12)
      .dropWhile(n -> n % 2 == 0) // 结果: [9, 10, 12]
      .forEach(System.out::println);

// 3. ofNullable - 安全创建单元素流，处理null值
Stream.ofNullable(null).count(); // 0
Stream.ofNullable("Java").count(); // 1

// 4. iterate方法重载 - 带终止条件的迭代
// 旧方式需要使用limit或filter来限制
Stream.iterate(1, n -> n * 2)
      .limit(5)
      .forEach(System.out::println);

// 新方式更直接
Stream.iterate(1, n -> n < 100, n -> n * 2)
      .forEach(System.out::println); // 1, 2, 4, 8, 16, 32, 64

实用场景：数据处理管道、复杂条件过滤、有界数据生成。

4. InputStream.transferTo()：流复制不再繁琐

在JDK9之前，在流之间复制数据需要手动处理缓冲区，现在只需要一行代码：

// 旧方式 - 冗长且易错
try (InputStream is = new FileInputStream("source.txt");
     OutputStream os = new FileOutputStream("target.txt")) {
    byte[] buffer = new byte[8192];
    int length;
    while ((length = is.read(buffer)) > 0) {
        os.write(buffer, 0, length);
    }
}

// JDK9方式 - 简洁明了
try (InputStream is = new FileInputStream("source.txt");
     OutputStream os = new FileOutputStream("target.txt")) {
    is.transferTo(os); // 一行代码搞定
}

实用场景：文件复制、网络数据传输、流处理。

5. 改进的Process API：管理系统进程更容易

JDK9大幅增强了Process API，让Java程序与系统进程的交互更加强大：

// 获取当前进程
ProcessHandle current = ProcessHandle.current();
System.out.println("Current PID: " + current.pid());

// 获取进程信息
current.info().user().ifPresent(user -> System.out.println("User: " + user));
current.info().commandLine().ifPresent(cmd -> System.out.println("Command: " + cmd));
current.info().startInstant().ifPresent(start -> System.out.println("Start time: " + start));
current.info().totalCpuDuration().ifPresent(cpu -> System.out.println("CPU time: " + cpu));

// 列出所有子进程
current.children().forEach(child -> System.out.println("Child PID: " + child.pid()));

// 列出所有进程
ProcessHandle.allProcesses()
    .filter(ph -> ph.info().command().isPresent())
    .forEach(ph -> System.out.println(ph.pid() + ": " + ph.info().command().get()));

// 启动并等待进程完成
ProcessBuilder pb = new ProcessBuilder("ls", "-l");
Process process = pb.start();
ProcessHandle handle = process.toHandle();
boolean terminated = handle.onExit().thenAccept(p -> 
    System.out.println("Process " + p.pid() + " terminated")
).isDone();

实用场景：系统管理工具、守护进程、执行外部命令、监控应用。

JDK 10 局部变量推断

6. 局部变量类型推断(var)：告别冗长的变量声明

JDK10引入了局部变量类型推断，使用var关键字让编译器推断变量类型：

// 旧方式 - 类型重复且冗长
HashMap<String, List<Customer>> customersByCity = new HashMap<>();
BufferedReader reader = new BufferedReader(new FileReader("data.txt"));
URLConnection connection = new URL("https://example.com").openConnection();

// JDK10方式 - 简洁明了
var customersByCity = new HashMap<String, List<Customer>>();
var reader = new BufferedReader(new FileReader("data.txt"));
var connection = new URL("https://example.com").openConnection();

// 在for循环中特别有用
for (var entry : customersByCity.entrySet()) {
    var city = entry.getKey();
    var customers = entry.getValue();
    // ...
}

注意事项：

var只能用于局部变量，不能用于字段、方法参数或返回类型
声明时必须初始化变量
不要过度使用，当类型不明显时应该明确声明类型

最佳实践：

// 好的用法 - 类型明确
var customers = new ArrayList<Customer>();
var entry = Map.entry("key", "value");

// 避免的用法 - 类型不明确
var result = getResult(); // 返回类型不明显
var x = 1; // 基本类型推荐显式声明

实用场景：复杂泛型类型、匿名类、lambda表达式中的变量。

7. 不可修改集合的复制方法：集合转换更安全

JDK10为集合框架增加了copyOf方法，创建不可修改的集合副本：

// 原始集合
List<String> original = new ArrayList<>(List.of("Java", "Kotlin", "Scala"));
Set<Integer> originalSet = new HashSet<>(Set.of(1, 2, 3));
Map<String, Integer> originalMap = new HashMap<>(Map.of("one", 1, "two", 2));

// 创建不可修改的副本
List<String> copy = List.copyOf(original);
Set<Integer> copiedSet = Set.copyOf(originalSet);
Map<String, Integer> copiedMap = Map.copyOf(originalMap);

// 修改原集合不影响副本
original.add("Groovy");
System.out.println(original); // [Java, Kotlin, Scala, Groovy]
System.out.println(copy);     // [Java, Kotlin, Scala]

// 尝试修改副本会抛出异常
try {
    copy.add("Clojure"); // 抛出 UnsupportedOperationException
} catch (UnsupportedOperationException e) {
    System.out.println("Cannot modify immutable copy");
}

与Collections.unmodifiableList()不同，List.copyOf()会创建一个全新的集合，如果原集合已经是不可修改的，则可能直接返回原集合而不是副本。

实用场景：防御性编程、返回安全的集合副本、创建常量集合。

JDK 11 长期支持版功能增强

8. String新方法：文本处理得心应手

JDK11为String类增加了几个实用方法：

// 1. lines() - 按行分割字符串
String multiline = "Java\nKotlin\nScala";
multiline.lines()
    .map(String::toUpperCase)
    .forEach(System.out::println);

// 2. strip(), stripLeading(), stripTrailing() - 去除空白字符
String text = "  Hello World  ";
System.out.println(">" + text.strip() + "<");          // >Hello World<
System.out.println(">" + text.stripLeading() + "<");   // >Hello World  <
System.out.println(">" + text.stripTrailing() + "<");  // >  Hello World<

// strip()与trim()的区别: strip()识别更多的Unicode空白字符
String unicodeWhitespace = "\u2005Hello\u2005";
System.out.println(">" + unicodeWhitespace.trim() + "<");   // >⠀Hello⠀<
System.out.println(">" + unicodeWhitespace.strip() + "<");  // >Hello<

// 3. isBlank() - 检查字符串是否为空白
System.out.println("  ".isBlank());     // true
System.out.println("".isBlank());       // true
System.out.println(" a ".isBlank());    // false

// 4. repeat() - 重复字符串
String star = "*";
System.out.println(star.repeat(10));    // **********
System.out.println("=".repeat(20));     // ====================

实用场景：处理用户输入、解析文本文件、构建格式化输出。

9. Files新方法：文件读写一步到位

JDK11为Files类添加了几个便捷方法：

// 读取文件为String
String content = Files.readString(Path.of("config.json"));

// 写入String到文件
Files.writeString(Path.of("output.txt"), "Hello Java 11!");

// 使用指定编码
String content = Files.readString(Path.of("data.txt"), StandardCharsets.UTF_8);
Files.writeString(Path.of("log.txt"), "Logged at: " + LocalDateTime.now(), 
                 StandardCharsets.UTF_8);

// 写入字符串集合
List<String> lines = List.of("Line 1", "Line 2", "Line 3");
Files.write(Path.of("lines.txt"), lines);

实用场景：读取配置文件、生成报告、日志记录、快速文件I/O。

10. 标准HTTP客户端：现代化网络请求

JDK11将HTTP Client从孵化模块升级为标准API，提供了现代化的HTTP客户端：

// 创建HTTP客户端
HttpClient client = HttpClient.newBuilder()
    .connectTimeout(Duration.ofSeconds(10))
    .build();

// 构建GET请求
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("https://api.github.com/users/octocat"))
    .header("User-Agent", "Java 11 HttpClient")
    .GET()
    .build();

// 同步发送请求，接收JSON响应
HttpResponse<String> response = client.send(request, 
    HttpResponse.BodyHandlers.ofString());

System.out.println("Status code: " + response.statusCode());
System.out.println("Body: " + response.body());

// POST请求示例
HttpRequest postRequest = HttpRequest.newBuilder()
    .uri(URI.create("https://httpbin.org/post"))
    .header("Content-Type", "application/json")
    .POST(HttpRequest.BodyPublishers.ofString("{"name": "Java"}"))
    .build();

// 异步发送请求
client.sendAsync(postRequest, HttpResponse.BodyHandlers.ofString())
    .thenApply(HttpResponse::body)
    .thenAccept(System.out::println)
    .join();

// 处理JSON响应(需要JSON库)
client.sendAsync(request, HttpResponse.BodyHandlers.ofString())
    .thenApply(HttpResponse::body)
    .thenApply(body -> {
        // 使用Jackson或Gson解析JSON
        return body;
    })
    .thenAccept(System.out::println)
    .join();

实用场景：RESTful API调用、微服务通信、网络爬虫、数据集成。

JDK 12 语言和库的改进

11. String.transform()：链式字符串处理

JDK12为String类添加了transform方法，支持链式函数转换：

// 传统方式
String original = "hello, world!";
String result = original.toUpperCase();
result = result.substring(0, 5);
result = result + "...";

// 使用transform方式
String result = "hello, world!"
    .transform(String::toUpperCase)
    .transform(s -> s.substring(0, 5))
    .transform(s -> s + "...");
System.out.println(result); // HELLO...

// 复杂转换
String parsed = "{ "name": "John", "age": 30 }"
    .transform(json -> {
        // 解析JSON
        // 此处简化，实际应使用Jackson等
        return json.substring(json.indexOf("name") + 7, json.indexOf("age") - 3);
    })
    .transform(String::trim)
    .transform(String::toUpperCase);

System.out.println(parsed); // JOHN

对于多步转换特别有用，提高了代码可读性。

实用场景：数据转换链、复杂字符串处理、函数式数据处理管道。

12. Compact Number Formatting：数字的可读性表示

JDK12引入了紧凑数字格式化功能，可以将大数字格式化为更易读的形式：

// 创建简短格式的格式化器
NumberFormat shortFormatter = NumberFormat.getCompactNumberInstance(
    Locale.US, NumberFormat.Style.SHORT);

// 格式化数字
System.out.println(shortFormatter.format(1000));       // 1K
System.out.println(shortFormatter.format(1500));       // 2K (四舍五入)
System.out.println(shortFormatter.format(1000000));    // 1M
System.out.println(shortFormatter.format(1000000000)); // 1B

// 长格式
NumberFormat longFormatter = NumberFormat.getCompactNumberInstance(
    Locale.US, NumberFormat.Style.LONG);
System.out.println(longFormatter.format(1000));        // 1 thousand
System.out.println(longFormatter.format(1000000));     // 1 million

// 其他语言的格式化
NumberFormat germanFormatter = NumberFormat.getCompactNumberInstance(
    Locale.GERMANY, NumberFormat.Style.SHORT);
System.out.println(germanFormatter.format(1000));      // 1.000

NumberFormat chineseFormatter = NumberFormat.getCompactNumberInstance(
    Locale.CHINA, NumberFormat.Style.SHORT);
System.out.println(chineseFormatter.format(1000));     // 1千
System.out.println(chineseFormatter.format(1000000));  // 100万

// 自定义精度
shortFormatter.setMaximumFractionDigits(1);
System.out.println(shortFormatter.format(1234));       // 1.2K
System.out.println(shortFormatter.format(1500));       // 1.5K

实用场景：用户界面显示、仪表盘开发、数据可视化、国际化应用。

JDK 14 友好错误信息与语言改进

13. 友好的NullPointerException：告别空指针调试噩梦

JDK14增强了NullPointerException，异常消息中会准确指出哪个变量是null：

// 假设有这样的代码
User user = null;
String city = user.getAddress().getCity();

在JDK14之前，你会得到一个简单的消息：

Exception in thread "main" java.lang.NullPointerException
    at Main.main(Main.java:5)

在JDK14及之后，异常消息变得非常具体：

Exception in thread "main" java.lang.NullPointerException: 
  Cannot invoke "User.getAddress()" because "user" is null
    at Main.main(Main.java:5)

对于更复杂的表达式：

map.get("key").process().getNestedValue();

增强的NPE消息会明确指出哪一部分是null：

Exception in thread "main" java.lang.NullPointerException: 
  Cannot invoke "Result.getNestedValue()" because the return value of 
  "ProcessedData.process()" is null

实用场景：调试复杂对象链、排查第三方库错误、缩短问题定位时间。

14. Switch表达式：更简洁的分支处理

JDK14正式发布了switch表达式（最初在JDK12引入为预览特性）：

// 传统switch语句
String result;
DayOfWeek day = LocalDate.now().getDayOfWeek();

switch (day) {
    case MONDAY:
    case TUESDAY:
    case WEDNESDAY:
    case THURSDAY:
    case FRIDAY:
        result = "Weekday";
        break;
    case SATURDAY:
    case SUNDAY:
        result = "Weekend";
        break;
    default:
        result = "Invalid day";
        break;
}

// 新的switch表达式
String result = switch (day) {
    case MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY -> "Weekday";
    case SATURDAY, SUNDAY -> "Weekend";
    default -> "Invalid day";
};

// 复杂表达式，带代码块
int numLetters = switch (day) {
    case MONDAY, FRIDAY, SUNDAY -> {
        System.out.println("Six letters day");
        yield 6;
    }
    case TUESDAY -> {
        System.out.println("Seven letters day");
        yield 7;
    }
    case THURSDAY, SATURDAY -> {
        System.out.println("Eight letters day");
        yield 8;
    }
    case WEDNESDAY -> {
        System.out.println("Nine letters day");
        yield 9;
    }
    default -> {
        throw new IllegalStateException("Invalid day: " + day);
    }
};

主要优点：

可以作为表达式返回值
箭头语法更简洁
使用逗号可以合并多个case
不需要break语句，消除了常见的错误源
穷尽性检查，确保所有情况都被处理

实用场景：状态机实现、命令处理、配置解析、业务逻辑分派。

15. 记录类(Records)：数据类不再冗长

JDK14引入了Records作为预览特性，在JDK16正式发布，为不可变数据类提供了简洁的语法：

// 传统POJO类
public final class Employee {
    private final String name;
    private final int id;
    private final Department department;
    
    public Employee(String name, int id, Department department) {
        this.name = name;
        this.id = id;
        this.department = department;
    }
    
    public String getName() { return name; }
    public int getId() { return id; }
    public Department getDepartment() { return department; }
    
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Employee employee = (Employee) o;
        return id == employee.id && 
               Objects.equals(name, employee.name) && 
               Objects.equals(department, employee.department);
    }
    
    @Override
    public int hashCode() {
        return Objects.hash(name, id, department);
    }
    
    @Override
    public String toString() {
        return "Employee{" +
               "name='" + name + ''' +
               ", id=" + id +
               ", department=" + department +
               '}';
    }
}

// 使用Record
public record Employee(String name, int id, Department department) { }

Records自动生成构造器、访问器、equals/hashCode和toString方法。

你也可以向Record添加额外的构造器、方法和静态成员：

public record Point(int x, int y) {
    // 自定义紧凑构造器
    public Point {
        if (x < 0 || y < 0) {
            throw new IllegalArgumentException("Coordinates cannot be negative");
        }
    }
    
    // 重载构造器
    public Point() {
        this(0, 0);
    }
    
    // 实例方法
    public double distance(Point other) {
        return Math.sqrt(Math.pow(this.x - other.x, 2) + 
                          Math.pow(this.y - other.y, 2));
    }
    
    // 静态成员
    public static final Point ORIGIN = new Point(0, 0);
    
    // 静态方法
    public static Point of(int x, int y) {
        return new Point(x, y);
    }
}

实用场景：DTO对象、API响应模型、消息体、不可变数据容器、值对象。

JDK 15-16 文本和类型检查优化

16. 文本块：多行字符串不再痛苦

JDK15正式发布了文本块功能（在JDK13首次预览），让多行字符串变得简单优雅：

// 传统多行字符串
String json = "{\n" +
              "  "name": "John Doe",\n" +
              "  "age": 30,\n" +
              "  "address": {\n" +
              "    "street": "123 Main St",\n" +
              "    "city": "Anytown"\n" +
              "  }\n" +
              "}";

// 使用文本块
String json = """
              {
                "name": "John Doe",
                "age": 30,
                "address": {
                  "street": "123 Main St",
                  "city": "Anytown"
                }
              }
              """;

// html示例
String html = """
              <html>
                <body>
                  <h1>Hello, World!</h1>
                </body>
              </html>
              """;

// SQL查询
String query = """
               SELECT id, first_name, last_name
               FROM employees
               WHERE department_id = ?
               ORDER BY last_name, first_name
               """;

文本块还支持字符串插值和格式控制：

// 使用\避免行尾换行
String compact = """
                 <html>\
                 <body>\
                 <p>Hello</p>\
                 </body>\
                 </html>\
                 """;

// 与String::formatted配合使用
String template = """
                  Dear %s,
                  
                  Your order #%d has been shipped on %s.
                  
                  Thank you,
                  Customer Service
                  """;
                  
String message = template.formatted("John", 12345, "2023-05-15");

实用场景：SQL查询、HTML/JSON/XML模板、代码生成、多行文本配置。

17. instanceohttp://www.devze.comf模式匹配：类型检查与转换合二为一

JDK16正式发布的instanceof模式匹配简化了类型检查和转换：

// 传统方式
if (obj instanceof String) {
    String s = (String) obj;
    if (s.length() > 5) {
        System.out.println(s.toUpperCase());
    }
}

// 使用模式匹配
if (obj instanceof String s && s.length() > 5) {
    System.out.println(s.toUpperCase());
}

// 在复杂条件中使用
if (obj instanceof String s && s.length() > 10 
    || obj instanceof List<?> list && list.size() > 5) {
    // 使用s或list
}

// 与switch配合使用(JDK1CtepyQTEKW7预览特性)
Object value = getValue();
switch (value) {
    case String s when s.length() > 5 -> System.out.println("Long string: " + s);
    case String s -> System.out.println("Short string: " + s);
    case List<?> l -> System.out.println("List with " + l.size() + " elements");
    default -> System.out.println("Unknown type");
}

实用场景：多态对象处理、类型安全转换、空检查简化。

18. 外部内存访问API (Foreign Memory Access)：安全高效的本地内存操作

JDK16引入了Foreign Memory Access API（孵化器阶段），为Java提供了安全高效的本地内存访问能力：

// 分配堆外内存
try (Arena arena = Arena.ofConfined()) {
    // 分配100字节的本地内存
    MemorySegment segment = arena.allocate(100);
    
    // 写入数据
    MemorySegment.copy(new byte[] {1, 2, 3, 4, 5}, 0, segment, 0, 5);
    
    // 读取数据
    byte value = segment.get(ValueLayout.JAVA_BYTE, 2); // 读取索引2的值
    System.out.println("Value at index 2: " + value);   // 输出 3
    
    // 填充内存段
    MemorySegment.fill(segment, (byte) 10);
    
    // 使用VarHandle操作内存
    VarHandle intHandle = ValueLayout.JAVA_INT.varHandle();
    intHandle.set(segment, 0, 42);
    int result = (int) intHandle.get(segment, 0);
    System.out.println("Integer value: " + result);     // 输出 42
    
    // 内存地址操作
    long address = segment.address().toRawLongValue();
    System.out.println("Memory address: 0x" + Long.toHexString(address));
}

这个API在JDK17中得到了改进，在JDK21中正式发布。它为需要处理大量数据的应用程序提供了比ByteBuffer更强大的替代方案。

实用场景：高性能计算、大数据处理、网络应用、与本地库集成。

JDK 17 长期支持版的强大特性

19. 密封类(Sealed Classes)：精确控制继承关系

JDK17正式发布的密封类允许更精确地控制哪些类可以继承一个类：

// 声明一个密封接口，只允许特定的类实现它
public sealed interface Shape 
    permits Circle, Rectangle, Triangle {
    double area();
}

// 最终实现类，不允许进一步继承
public final class Circle implements Shape {
    private final double radius;
    
    public Circle(double radius) {
        this.radius = radius;
    }
    
    @Override
    public double area() {
        return Math.PI * radius * radius;
    }
}

// 允许进一步继承的类
public non-sealed class Rectangle implements Shape {
    private final double width;
    private final double height;
    
    public Rectangle(double width, double height) {
        this.width = width;
        this.height = height;
    }
    
    @Override
    public double area() {
        return width * height;
    }
}

// 限制继承的类
public sealed class Triangle implements Shape 
    permits EquilateralTriangle, RightTriangle {
    // ...实现...
}

// 允许的子类
public final class EquilateralTriangle extends Triangle {
    // ...实现...
}

public final class RightTriangle extends Triangle {
    // ...实现...
}

密封类与switch模式匹配和记录类结合使用时特别强大，编译器可以进行穷尽性检查：

double calculateArea(Shape shape) {
    return switch (shape) {
        case Circle c -> Math.PI * c.radius() * c.radius();
        case Rectangle r -> r.width() * r.height();
        case Triangle t -> t.base() * t.height() / 2;
        // 不需要default分支，因为编译器知道这些是Shape的所有可能实现
    };
}

实用场景：领域模型设计、类型安全的API、状态机实现、编译器检查增强。

20. 增强的伪随机数生成器：更灵活、可预测的随机数

JDK17引入了增强的伪随机数生成器(PRNG)框架，提供了更多算法和更好的接口：

// 获取默认的随机数生成器
RandomGenerator random = RandomGenerator.getDefault();
System.out.println(random.nextInt(100)); // 0-99之间的随机数

// 使用特定算法的生成器
RandomGenerator xoroshiro = RandomGenerator.of("Xoroshiro128PlusPlus");
System.out.println(xoroshiro.nextLong());

// 使用L32X64MixRandom - 平衡了速度和质量的算法
RandomGenerator fastRandom = RandomGenerator.of("L32X64MixRandom");
for (int i = 0; i < 5; i++) {
    System.out.println(fastRandom.nextInt(1000));
}

// 创建可复现的随机数序列 (使用相同的种子)
RandomGenerator seeded = RandomGenerator.of("Xoshiro256PlusPlus");
((SplittableRandomGenerator) seeded).setSeed(42);
for (int i = 0; i < 5; i++) {
    System.out.println(seeded.nextInt(100));
}

// 生成随机流
DoubleStream randomDoubles = RandomGenerator.getDefault().doubles(1000);
randomDoubles.forEach(System.out::println);

// 查看所有可用的算法
RandomGenerator.all()
    .map(provider -> provider.name() + ": " + provider.group())
    .sorted()
    .forEach(System.out::println);

实用场景：科学计算、模拟、游戏开发、测试数据生成、加密应用。

21. 向量API (Incubator)：性能密集型计算

JDK17引入了孵化器阶段的向量API，支持SIMD(单指令多数据)风格的操作，显著加速特定类型的计算：

// 使用IntVector加速数组求和
static int sumArrayVectorized(int[] a) {
    var species = IntVector.SPECIES_PREFERRED;
    var sum = IntVector.zero(species);
    var i = 0;
    
    // 处理可以向量化的部分
    for (; i <= a.length - species.length(); i += species.length()) {
        var v = IntVector.fromArray(species, a, i);
        sum = sum.add(v);
    }
    
    // 处理剩余元素
    var result = sum.reduceLanes(VectorOperators.ADD);
    for (; i < a.length; i++) {
        result += a[i];
    }
    
    return result;
}

// 向量化矩阵乘法
static void multiplyMatricesVectorized(float[] a, float[] b, float[] c, int n) {
    var species = FloatVector.SPECIES_PREFERRED;
    int limit = species.length();
    
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            var sum = FloatVector.zero(species);
            int k = 0;
            
            // 使用向量计算
            for (; k <= n - limit; k += limit) {
                var va = FloatVector.fromArray(species, a, i * n + k);
                var vb = FloatVector.fromArray(species, b, k * n + j);
                sum = sum.add(va.mul(vb));
            }
            
            // 累加向量结果
            float dotProduct = sum.reduceLanes(VectorOperators.ADD);
            
            // 处理剩余元素
            for (; k < n; k++) {
                dotProduct += a[i * n + k] * b[k * n + j];
            }
            
            c[i * n + j] = dotProduct;
        }
    }
}

JDK19和JDK21继续改进了向量API，但截至JDK21仍处于孵化器阶段。

实用场景：科学计算、图像处理、机器学习、信号处理、金融模拟。

JDK 18-19 工具链和API增强

22. 简单Web服务器：快速启动静态文件服务

JDK18引入了一个简单的命令行HTTP服务器，可以快速启动静态文件服务：

// 命令行用法
// jwebserver -p 8000 -d /path/to/directory

// 在代码中使用:
import com.sun.net.httpserver.*;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.file.Path;

public class SimpleFileServer {
    public static void main(String[] args) throws IOException {
        var server = SimpleFileServer.createFileServer(
            new InetSocketAddress(8000), 
            Path.of("/path/to/directory"), 
            SimpleFileServer.OutputLevel.VERBOSE
        );
        server.start();
        System.out.println("Server started at http://localhost:8000");
    }
}

这个功能特别适合开发和测试环境，比如快速预览静态网站或测试API调用。

实用场景：前端开发、静态网站预览、本地测试环境、原型开发。

23. 代码片段in JavaDoc：更好的API文档

JDK18引入了@snippet标签，允许在JavaDoc中添加带有语法高亮的代码示例：

/**
 * This class provides utility methods for string operations.
 *
 * <p>Example usage:</p>
 * {@snippet :
 *   String result = StringUtils.capitalize("hello");  // Returns "Hello"
 *   boolean isEmpty = StringUtils.isBlank(" ");       // Returns true
 * }
 */
public class StringUtils {
    // 类实现省略
}

增强的文档还支持高亮、区域标记和错误标记：

/**
 * Example of snippet with highlighting:
 * {@snippet :
 *   // @highlight region="important"
 *   String encoded = Base64.getEncoder().encodeToString(data);
 *   // @end
 *   
 *   // @highlight regex="data" type="bold"
 *   byte[] decoded = Base64.getDecoder().decode(encoded);
 *   
 *   // @replace regex="badPractice()" replacement="goodPractice()" type="error"
 *   result = badPractice();
 * }
 */

实用场景：API文档、开源项目、技术指南、教程编写。

24. 外部函数接口 (Foreign Function & Memory API)

JDK19改进了孵化器中的外部函数接口（在JDK21中正式发布），让Java与本地代码交互更加简单：

// 定义C库函数的接口
import java.lang.foreign.*;
import static java.lang.foreign.ValueLayout.*;

public class LibCDemo {
    public static void main(String[] args) {
        // 获取C标准库的链接器
        Linker linker = Linker.nativeLinker();
        
        // 查找printf函数
        SymbolLookup stdlib = linker.defaultLookup();
        MethodHandle printf = stdlib.find("printf")
            .map(addr -> linker.downcallHandle(
                addr,
                FunctionDescriptor.of(JAVA_INT, ADDRESS),
                Linker.Option.firstVariadicArg(1)
            ))
            .orElseThrow();
        
        // 准备字符串参数
        try (Arena arena = Arena.ofConfined()) {
            MemorySegment cString = arena.allocateUtf8String("Hello from Java! Count: %d\n");
            
            // 调用printf
            try {
                printf.invoke(cString, 42);
            } catch (Throwable e) {
                e.printStackTrace();
            }
        }
    }
}

这个API消除了JNI的大部分复杂性，提供了更安全、更简洁的方式来调用本地代码。

实用场景：与C/C++库集成、系统编程、性能关键应用、多语言项目。

JDK 20-21 现代并发和语言增强

25. 虚拟线程(Virtual Threads)：并发革命

JDK21正式发布了虚拟线程，这是Java并发编程的重大变革：

// 创建和启动单个虚拟线程
Thread.startVirtualThread(() -> {
    System.out.println("Running in virtual thread");
});

// 使用虚拟线程运行多个任务
try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
    // 提交1000个任务，每个在独立的虚拟线程中运行
    for (int i = 0; i < 1000; i++) {
        int taskId = i;
        executor.submit(() -> {
            System.out.println("Task " + taskId + " running on " + Thread.currentThread());
            // 模拟IO操作
            try {
                Thread.sleep(Duration.ofMillis(100));
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
            return taskId;
        });
    }
} // 自动关闭executor

// 以构建器方式创建虚拟线程
ThreadFactory factory = Thread.ofVirtual().name("worker-", 0).factory();
Thread worker = factory.newThread(() -> {
    // 任务代码
});
worker.start();

// 使用虚拟线程改写传统的阻塞式IO代码
void processFile(Path file) throws IOException {
    // 这段代码在虚拟线编程程中运行时不会阻塞平台线程
    try (var reader = Files.newBufferedReader(file)) {
        String line;
        while ((line = reader.readLine()) != null) {
            processLine(line);
        }
    }
}

虚拟线程的主要优势是可以创建数百万个轻量级线程，而不会耗尽系统资源。它们特别适合IO密集型应用，使同步代码可以获得与异步代码相当的扩展性。

实用场景：高并发Web服务器、微服务、数据处理管道、爬虫程序。

26. 结构化并发(Structured Concurrency)

可以管理异步任务的生命周期

JDK21引入了结构化并发API（预览特性），简化了多线程代码的错误处理和资源管理：

// 并行获取用户及其订单
record User(int id, String name) {}
record Order(int id, double amount) {}
record UserWithOrders(User user, List<Order> orders) {}

UserWithOrders getUserWithOrders(int userId) {
    try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
        // 并行执行两个子任务
        Future<User> userFuture = scope.fork(() -> fetchUser(userId));
        Future<List<Order>> ordersFuture = scope.fork(() -> fetchOrders(userId));
        
        // 等待所有任务完成
        scope.join();
        // 检查子任务是否有异常
        scope.throwIfFailed(e -> new RuntimeException("Failed to fetch data", e));
        
        // 获取结果
        return new UserWithOrders(userFuture.resultNow(), ordersFuture.resultNow());
    } catch (Exception e) {
        throw new RuntimeException(e);
    }
}

// 使用结构化并发处理多个API调用
try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
    var weatherFuture = scope.fork(() -> callWeatherAPI());
    var trafficFuture = scope.fork(() -> callTrafficAPI());
    var newsFuture = scope.fork(() -> callNewsAPI());
    
    try {
        scope.join();
        scope.throwIfFailed();
        
        // 所有API调用成功，处理结果
        var dashboard = createDashboard(
            weatherFuture.resultNow(),
            trafficFuture.resultNow(),
            newsFuture.resultNow()
        );
        return dashboard;
    } catch (Exception e) {
        // 有一个API调用失败，所有任务都被取消
        return createFallbackDashboard();
    }
}

结构化并发确保所有子任务在父任务退出前要么完成，要么被取消，避免了资源泄漏和"遗忘"的后台任务。

实用场景：API聚合、微服务通信、并行数据处理、复杂异步工作流。

27. Record模式(Record Patterns)：解构数据更简单

JDK21正式发布的Record模式允许在模式匹配中解构记录：

// 定义一些记录
record Point(int x, int y) {}
record Rectangle(Point topLeft, Point bottomRight) {}
record Circle(Point center, int radius) {}

// 使用传统方式处理记录
Object shape = new Rectangle(new Point(1, 2), new Point(5, 6));
if (shape instanceof Rectangle) {
    Rectangle r = (Rectangle) shape;
    Point topLeft = r.topLeft();
    Point bottomRight = r.bottomRight();
    int width = bottomRight.x() - topLeft.x();
    int height = bottomRight.y() - topLeft.y();
    System.out.println("Rectangle with width " + width + " and height " + height);
}

// 使用Record模式解构
if (shape instanceof Rectangle(Point(var x1, var y1), Point(var x2, var y2))) {
    int width = x2 - x1;
    int height = y2 - y1;
    System.out.println("Rectangle with width " + width + " and height " + height);
}

// 结合switch使用
String getDescription(Object shape) {
    return switch (shape) {
        case Rectangle(Point(var x1, var y1), Point(var x2, var y2)) ->
            "Rectangle from (%d,%d) to (%d,%d)".formatted(x1, y1, x2, y2);
        
        case Circle(Point(var x, var y), var r) ->
            "Circle at (%d,%d) with radius %d".formatted(x, y, r);
        
        default -> "Unknown shape";
    };
}

Record模式与嵌套模式结合使用时特别强大，可以轻松处理复杂的数据结构。

实用场景：数据转换、JSON/XML解析结果处理、领域模型操作、事件处js理。

28. 字符串模板(String Templates)：安全高效的字符串插值

JDK21引入了字符串模板作为预览特性，提供比字符串连接更简洁、更安全的方式：

// 传统方式
String name = "Alice";
int age = 30;
String message = "Hello, " + name + "! Next year, you'll be " + (age + 1) + ".";

// 使用字符串模板
String message = STR."Hello, {name}! Next year, you'll be {age + 1}.";

// 带表达式的模板
String status = "active";
String message = STR."User status: {status.toUpperCase()} (set {LocalDate.now()})";

// 格式化数字
double value = 1234.56789;
String formatted = STR."The value is {value%.2f}";  // "The value is 1234.57"

// 多行JSON
String json = STR."""
    {
      "name": "{name}",
      "age": {age},
      "isAdult": {age >= 18},
      "contacts": [
        {generateContactsJson()}
      ]
    }
    """;

字符串模板不仅语法简洁，还提供了类型安全和对表达式的编译时检查。

实用场景：生成JSON/XML/HTML、日志记录、消息格式化、SQL语句构建。

29. 序列集合 (Sequenced Collections)：统一的集合操作

JDK21引入了SequencedCollection、SequencedSet和SequencedMap接口，为Java集合框架添加了方向性和顺序性操作：

// 序列化集合基本用法
SequencedCollection<String> names = new ArrayList<>(List.of("Alice", "Bob", "Charlie"));

// 获取第一个和最后一个元素
String first = names.getFirst();  // "Alice"
String last = names.getLast();    // "Charlie"

// 添加元素到两端
names.addFirst("Zoe");
names.addLast("David");
System.out.println(names);  // [Zoe, Alice, Bob, Charlie, David]

// 创建反向视图
SequencedCollection<String> reversed = names.reversed();
System.out.println(reversed);  // [David, Charlie, Bob, Alice, Zoe]

// 序列化Map
SequencedMap<String, Integer> scores = new LinkedHashMap<>();
scores.put("Alice", 95);
scores.put("Bob", 85);
scores.put("Charlie", 90);

// 获取第一个和最后一个条目
Map.Entry<String, Integer> firstEntry = scores.firstEntry();  // Alice=95
Map.Entry<String, Integer> lastEntry = scores.lastEntry();    // Charlie=90

// 添加条目到两端
scores.putFirst("Zoe", 100);
scores.putLast("David", 80);

// 获取键或值的序列化视图
SequencedCollection<String> keys = scores.sequencedKeySet();
SequencedCollection<Integer> values = scores.sequencedValues();

这些接口统一了Java集合框架中的顺序操作，使API更加一致。现有的有序集合类如ArrayList、LinkedHashSet和LinkedHashMap都实现了这些新接口。

实用场景：维持插入顺序的集合、FIFO/LIFO队列操作、双向迭代、有序数据处理。

总结

Java语言在保持向后兼容性的同时，不断引入新特性以提高开发效率和代码质量。掌握这些新特性不仅能提高开发效率，还能编写出更加简洁、健壮的代码。

到此这篇关于JDK9到JDK21中值得掌握的29个实用特性分享的文章就介绍到这了,更多相关JDK实用特性内容请搜索编程客栈(www.devze.com)以前的文章或继续浏览下面的相关文章希望大家以后多多支持编程客栈(www.devze.com)！

继续阅读：Java JDK JDK9和JDK21 JDK特性

目录