本文主要是介绍JDK9到JDK21中值得掌握的29个实用特性分享，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！
《JDK9到JDK21中值得掌握的29个实用特性分享》Java的演进节奏从JDK9开始显著加快,每半年一个新版本的发布节奏为Java带来了大量的新特性,本文整理了29个JDK9到JDK21中值得掌握的...
Java的演进节奏从JDK9开始显著加快，每半年一个新版本的发布节奏为Java带来了大量的新特性。
其中包括令人瞩目的虚拟线程、记录类型等"明星特性"，也有很多不太引人注意但同样实用的小功能。
本文整理了29个JDK9到JDK21中值得掌握的实用特性，帮助你编写更简洁、高效、安全的Java代码。
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::procChina编程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.chinasem.cnf模式匹配：类型检查与转换合二为一
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实用特性内容请搜索China编程(www.chinasem.cn)以前的文章或继续浏览下面的相关文章希望大家以后多多支持China编程(www.chinasem.cn)！
这篇关于JDK9到JDK21中值得掌握的29个实用特性分享的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！
