当前位置：首页 > news >正文

JDK 21 的重要特性

news 2025/1/3 11:41:03

JDK 21 是 Java 的长期支持版本（LTS），于 2023 年 9 月发布，包含大量增强功能和改进。以下是 JDK 21 的重要特性、用途以及如何结合 Spring Boot 3 简化开发的解析和案例。

JDK 21 的重要特性

1. 面向对象与函数式结合的语言特性

1.1 Record 的增强

Record 是 Java 14 引入的特性，用于定义不可变数据类。
JDK 21 新增支持：嵌套 Record 的泛型增强。
使用场景：
在复杂对象的操作中，Record 可以减少样板代码。

示例：定义嵌套的不可变结构：

public record User(String name, Address address) {}
public record Address(String city, String street) {}

处理逻辑：

User user = new User("John", new Address("New York", "5th Avenue"));
System.out.println(user.name());       // John
System.out.println(user.address().city()); // New York

1.2 Pattern Matching 的增强

JDK 21 对模式匹配进行了进一步增强，用于 switch 和 instanceof 操作。

示例：模式匹配 switch：

public static String format(Object obj) {return switch (obj) {case Integer i -> "Integer: " + i;case String s -> "String: " + s;case null -> "Null object";default -> "Unknown type";};
}

特点：

简化了类型判断代码。
支持多分支的类型匹配。

1.3 Sealed Classes（密封类）

密封类允许明确指定子类，提升类型安全性，便于模式匹配。

定义密封类：

public sealed interface Shape permits Circle, Rectangle {}public record Circle(double radius) implements Shape {}
public record Rectangle(double width, double height) implements Shape {}

结合模式匹配：

public double area(Shape shape) {return switch (shape) {case Circle c -> Math.PI * c.radius() * c.radius();case Rectangle r -> r.width() * r.height();};
}

2. 新的 API 和工具

2.1 String 的新方法

JDK 21 增加了一些有用的 String 方法。

示例：translateEscapes：

将转义字符翻译为实际字符。

String escaped = "Hello\\nWorld";
System.out.println(escaped.translateEscapes()); 
// 输出：Hello
//       World

示例：formatted 的增强：

用于格式化字符串。

String template = "Hello, %s!";
System.out.println(template.formatted("John")); // Hello, John!

2.2 Collections 新方法

示例：Map.copyOf：

创建不可变的 Map。

Map<String, Integer> scores = Map.of("Alice", 90, "Bob", 85);
Map<String, Integer> copy = Map.copyOf(scores);

示例：List.of 的增强：

快速创建不可变集合。

List<String> names = List.of("Alice", "Bob", "Charlie");

3. 并发编程的新特性

3.1 虚拟线程（Virtual Threads）

JDK 21 引入了虚拟线程，使得创建和管理线程更加轻量化。

传统线程：

Thread thread = new Thread(() -> System.out.println("Hello from thread"));
thread.start();

虚拟线程：

Thread thread = Thread.ofVirtual().start(() -> System.out.println("Hello from virtual thread"));

特点：

启动虚拟线程的成本远低于普通线程。
更适合高并发场景。
结合 Spring Boot 的异步开发
使用虚拟线程改进异步任务的性能：

@RestController
public class TaskController {@GetMapping("/task")public String executeTask() {Thread.ofVirtual().start(() -> {// 模拟长时间任务try {Thread.sleep(1000);System.out.println("Task Completed!");} catch (InterruptedException e) {Thread.currentThread().interrupt();}});return "Task Submitted!";}
}

3.2 Structured Concurrency

结构化并发提供了更高级的并发管理，简化了多任务协作的代码。

示例：并发任务的执行与汇总：

try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {Future<String> task1 = scope.fork(() -> fetchDataFromServiceA());Future<String> task2 = scope.fork(() -> fetchDataFromServiceB());scope.join(); // 等待所有任务完成scope.throwIfFailed(); // 如果有任务失败，抛出异常// 获取结果String result = task1.resultNow() + task2.resultNow();System.out.println(result);
}

特点：

自动管理任务的生命周期。
简化并发代码的异常处理。

4. 高性能改进

4.1 ZGC 和 G1GC 的优化

ZGC（低延迟垃圾收集器）进一步优化，适合低延迟、高吞吐量场景。
G1GC 改进了并行回收性能。

4.2 Records 的性能改进

Record 在序列化和内存布局方面有更好的性能表现，适合数据密集型应用。
结合 Spring Boot 3 的实际案例

1. 数据处理服务

场景：对用户数据进行批量处理和分类。

传统方式：

public Map<String, List<User>> categorizeUsers(List<User> users) {Map<String, List<User>> result = new HashMap<>();for (User user : users) {String category = user.getCategory();result.computeIfAbsent(category, k -> new ArrayList<>()).add(user);}return result;
}

函数式编程 + Stream：

public Map<String, List<User>> categorizeUsers(List<User> users) {return users.stream().collect(Collectors.groupingBy(User::getCategory));
}

2. 使用虚拟线程优化服务调用

场景：同时调用多个远程服务获取数据。

传统线程池：

ExecutorService executor = Executors.newFixedThreadPool(10);
Future<String> responseA = executor.submit(() -> fetchServiceA());
Future<String> responseB = executor.submit(() -> fetchServiceB());

虚拟线程：

try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {Future<String> responseA = scope.fork(() -> fetchServiceA());Future<String> responseB = scope.fork(() -> fetchServiceB());scope.join();return responseA.resultNow() + responseB.resultNow();
}