本文整理了 Java 8 至 Java 24 各版本的新特性，内容包括每个版本的新增功能分类（如语法增强、性能优化、工具支持等）、详细的代码示例，并结合官方文档资料，分析每项特性的应用场景及优缺点。Java 8 发布于 2014 年，此后 Java 进入快速迭代模式，每半年发布一个新版本。一路走来，Java 8 到 Java 24 带来了大量重要的新特性。

好的，以下是你提供的关于Java 6到Java 24的所有版本特性整理，保持了原内容的完整性和结构：

一览图

脑图式内容参考

---

📅 Java 版本演进概览

版本	发布日期	类型	主要改进领域
8	2014 年 3 月	LTS	Lambda、Stream API、默认方法等
9	2017 年 9 月	非 LTS	模块化系统、接口私有方法等
10	2018 年 3 月	非 LTS	var 关键字、集合工厂方法等
11	2018 年 9 月	LTS	HTTP Client、ZGC 等
12	2019 年 3 月	非 LTS	Switch 表达式（预览）、Shenandoah GC
13	2019 年 9 月	非 LTS	文本块（Text Blocks）预览
14	2020 年 3 月	非 LTS	Records、模式匹配（Pattern Matching）
15	2020 年 9 月	非 LTS	Text Blocks 正式发布、ZGC 转正
16	2021 年 3 月	非 LTS	Records 正式发布、Vector API 孵化
17	2021 年 9 月	LTS	Sealed Classes、强封装内部 API
18	2022 年 3 月	非 LTS	UTF-8 默认编码、jwebserver
19	2022 年 9 月	非 LTS	Virtual Threads（预览）
20	2023 年 3 月	非 LTS	Structured Concurrency（孵化）
21	2023 年 9 月	LTS	Virtual Threads 正式发布、Sequenced Collections
22	2024 年 3 月	非 LTS	多文件源码运行、构造函数前语句支持
23	2024 年 9 月	非 LTS	原始类型模式匹配（预览）
24	2025 年 3 月	非 LTS	KDF API、类加载缓存、Stream Gatherer 正式发布

---

🔧 语言与语法增强

✅ Java 8

• Lambda 表达式：简化匿名函数书写。
• 函数式接口：如 Function, Predicate, Consumer。
• 方法引用：Class::method 语法。
• 默认方法和静态方法：接口可以定义实现。
• 重复注解与类型注解：支持多次使用同一注解及在任意类型上标注。

✅ Java 9-10

• 私有接口方法：允许接口中定义私有方法。
• try-with-resources 改进：变量可复用。
• 局部变量类型推断（var）：var list = new ArrayList<String>();
• 集合工厂方法：List.of("a", "b")

✅ Java 11+

• 单文件运行：java Hello.java
• 字符串增强：isBlank(), lines(), repeat(int), strip() 等。
• 文本块（Text Blocks）：多行字符串，""" ... """。
• 记录类（Record）：不可变数据载体，自动生成构造器/equals/hashCode。
• 密封类（Sealed Class）：限制子类继承。
• 模式匹配（instanceof 和 switch）：自动类型转换 + 匹配结构。
• 未命名模式 _：忽略不关心的部分。
• 字符串模板（STR.）：内嵌表达式 ${}。

---

🧠 并发与虚拟线程

✅ Java 19 (Loom)

• 虚拟线程（Virtual Threads）：轻量级线程，由 JVM 管理。
• 结构化并发（Structured Concurrency）：任务并行管理。
• 作用域值（ScopedValue）：替代 ThreadLocal 的更安全上下文传递方式。

✅ Java 21+

• 虚拟线程正式发布：可用于生产环境。
• 非 Pinning 锁机制：虚拟线程在锁等待时释放 OS 线程。

---

📦 JVM 与性能优化

✅ 垃圾回收

• G1 成为默认 GC
• ZGC：低延迟，跨平台支持。
• Shenandoah GC：低延迟垃圾收集器。
• Gen ZGC（Java 24）：分代 ZGC 提升吞吐。

✅ 内存模型与工具

• 元空间（Metaspace）：取代永久代。
• Vector API（孵化）：SIMD 指令支持。
• Foreign Function & Memory API（Panama）：调用本地函数、访问内存。
• 类加载缓存（Java 24）：加速应用启动。

---

🧪 核心库增强

✅ 集合框架

• Stream API：声明式编程风格。
• Optional 类：避免空指针异常。
• Map 增强：computeIfAbsent、merge 等。
• Sequenced Collections（Java 21）：有序集合接口族。

✅ IO 与网络

• Files.readString/writeString：简化文件操作。
• HttpClient（Java 11）：支持 HTTP/2 和 WebSocket。
• Socket API 重构：性能与可维护性提升。

✅ 时间与随机数

• 全新的时间 API（java.time）：线程安全、不变对象。
• 伪随机数生成器（Java 17）：多种算法支持。

---

🛡️ 安全与密码学

• TLS 1.3 支持（Java 11）
• EdDSA 加密算法（Java 15）
• KDF API（Java 24 预览）：统一的密钥派生接口。
• SecurityManager 移除（Java 24）：彻底禁用安全管理器。

---

🧰 工具链与生态

• JShell（Java 9）：交互式 REPL 工具。
• jlink（Java 9）：构建定制运行时镜像。
• jpackage（Java 16）：打包原生安装包。
• JMH（Java 10）：微基准测试框架。
• Markdown JavaDoc（Java 23）：支持 Markdown 编写文档注释。

---

📚 模块化与兼容性

• 模块化系统（Java 9）：Project Jigsaw。
• 多版本 JAR：支持不同 Java 版本共存。
• AppCDS 动态归档（Java 13）：提升启动性能。
• 弃用 Nashorn（Java 15）：推荐使用 GraalJS。

---

📈 总结

方向	演进成果
语言现代化	引入 lambda、record、sealed class、pattern matching 等，代码更简洁易读。
并发模型升级	虚拟线程 + 结构化并发，极大提升高并发处理能力。
性能优化	新一代 GC（ZGC、Shenandoah）、Vector API、FFM API 等底层性能突破。
标准库扩展	Stream API、Optional、HttpClient、Text Blocks 等增强开发者体验。
安全性增强	TLS 1.3、EdDSA、KDF API 提供现代加密能力。
工具链完善	JShell、jpackage、jlink、JMH 等工具助力开发调试与部署。

---

📌 参考文献

• OpenJDK 官方 JEP 列表
• Oracle Blog: Java Language Futures
• JetBrains IDEA 官方文档

---

✅ 建议阅读顺序

1. Java 8 → 11：掌握基础语法、Stream、Optional、HTTP Client。
2. Java 14 → 17：学习 Record、Sealed Class、Pattern Matching。
3. Java 19 → 21：了解 Loom 项目（虚拟线程、结构化并发）。
4. Java 22 → 24：关注流收集器、类文件 API、KDF API 等高级特性。

---

📌 适合人群

• 初学者：建议从 Java 8 入门，逐步过渡到 Java 11。
• 中级开发者：应掌握 Java 14+ 的 record、pattern matching。
• 高级开发者 / 架构师：需深入理解虚拟线程、FFM API、Vector API 等底层机制。

---

---

Java 8 新特性

发行时间：2014 年 3 月

语言特性

1. Lambda 表达式与函数式接口：

   • Java 8 引入了 Lambda 表达式，使我们能够将匿名函数作为一等公民传递和使用。
   • 例如，可以使用 Comparator<String> cmp = (a, b) -> a.length() - b.length(); 来实现字符串长度比较。
   • 这依赖于函数式接口（只含单一抽象方法的接口），如 Comparator 或自定义接口，Lambda 会被推断成该接口的实现。
   • 有了 Lambda，代码变得更加简洁，可读性提高，尤其适用于集合的过滤、映射等操作。

   // 示例：使用 Lambda 表达式对列表进行过滤和映射
   List<String> names = Arrays.asList("Alice", "Bob", "Ann");
   List<String> filtered = names.stream().filter(s -> s.startsWith("A")).map(s -> s.toUpperCase()).collect(Collectors.toList());
   System.out.println(filtered); // 输出: [ALICE, ANN]
   

2. 方法引用：

   • 除了 Lambda，Java 8 还支持方法引用，可以用 Class::method 简洁地引用已有方法或构造器。
   • 例如，names.forEach(System.out::println) 会打印列表中每个元素，相当于对每个元素执行 System.out.println。

3. 接口默认方法和静态方法：

   • 接口现在可以包含带实现的默认方法（default 方法）和静态方法。
   • 这使得在不破坏已有实现类的前提下向接口添加新方法成为可能。
   • 默认方法可被实现类继承或重写；静态方法则只能通过接口名调用，不能被子类重写。

   interface MyInterface {static void staticMethod() {System.out.println("接口静态方法");}default void defaultMethod() {System.out.println("接口默认方法");}void abstractMethod();
   }class MyClass implements MyInterface {@Overridepublic void abstractMethod() { }// 未重写 defaultMethod()，将继承接口的默认实现
   }MyInterface.staticMethod();       // 调用接口静态方法
   new MyClass().defaultMethod();    // 调用接口默认方法，实现类未重写则执行接口中的实现
   

   • 应用场景：默认方法解决了接口演化的问题，比如 Java 8 为 Collection 接口添加了 stream() 默认方法，从而所有实现类无需修改就自动拥有流操作能力。静态方法则方便在接口中组织工具函数。

4. 重复注解（Repeatable Annotation）：

   • 允许在同一声明或类型上多次应用同一个注解类型。
   • Java 8 引入了 @Repeatable 元注解，通过定义“容器注解”类型来实现重复注解支持。
   • 应用场景如定义多个过滤器、多个权限注解等，使代码更直观。

   @Schedule(day="Mon"), @Schedule(day="Tue")
   void scheduledTask() { ... }
   

5. 类型注解：

   • Java 8 扩展了注解使用的场景，注解现在可以加在任何类型使用处（Type Use），如泛型类型参数、强制转换、实现声明等。
   • 结合 JSR 308，可用于开发更强的类型检查工具（如空指针分析）。

核心库新特性

1. Stream API：

   • Java 8 的 Stream API 为集合批量操作提供了声明式、链式的语法。
   • 开发者可以使用类似 SQL 风格的操作（filter, map, reduce 等）来处理数据流。
   • Stream 的操作分为中间操作（惰性求值）和终止操作（触发计算）。

   List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
   int sum = numbers.stream().filter(n -> n % 2 == 1) // 筛选奇数.mapToInt(n -> n * n)    // 平方映射.sum();                  // 终止操作求和
   System.out.println(sum); // 输出: 35（1^2 + 3^2 + 5^2）
   

   • 应用场景：Stream API 大大简化了集合的复杂操作，避免了繁琐的迭代和临时集合管理。例如，可以轻松进行过滤、汇总统计、分组分区等操作。

2. Optional 类：

   • 引入了 java.util.Optional<T>，用于优雅地表示“可能为空”的值。
   • Optional 提供了诸如 isPresent(), ifPresent(), orElse() 等方法，可以替代显式的空检查，减少空指针异常风险。

   public Optional<User> findUser(String name) {User result = ... // 查找用户return Optional.ofNullable(result);
   }// 使用Optional避免显式null判断
   findUser("Alice").ifPresent(user -> System.out.println(user.getId()));
   User user = findUser("Bob").orElse(new User("Bob")); // 未找到则返回默认User
   

   • 应用场景：Optional 常用于方法返回值，表示“可能没有结果”。这比返回 null 更具语义，也迫使调用方处理不存在的情况。

3. 全新的日期时间 API：

   • Java 8 推出了 java.time 包（JSR 310），提供了不变且线程安全的日期时间类，包括 LocalDate, LocalTime, LocalDateTime, ZonedDateTime 等，以及用于周期和持续时间的 Period, Duration。
   • 新的 API 改进了旧版 java.util.Date 和 Calendar 的诸多问题，提供了更加自然的时间操作接口。

   LocalDate today = LocalDate.now();
   LocalDate birthday = LocalDate.of(1990, Month.APRIL, 1);
   Period period = Period.between(birthday, today);
   System.out.printf("年龄: %d 年 %d 月 %d 日%n", period.getYears(), period.getMonths(), period.getDays());
   

   • 应用场景：新日期API提供了清晰的方法来操作日期时间，支持时区、夏令时、安全不变。此外还提供了格式化和解析（DateTimeFormatter），大幅简化日期处理，避免了旧 API 各种不一致和缺陷。

4. 并发增强（CompletableFuture 等）：

   • Java 8 在并发库方面增加了 CompletableFuture，支持以链式回调的方式处理异步结果，实现了Promise模式。
   • 例如可以组合多个异步计算、设置依赖和异常处理。

5. 其它常用库改进：

   • 例如 Map.computeIfAbsent 等函数式风格的方法，方便地对 Map 执行条件更新；Base64 编码解码器（java.util.Base64）也在 Java 8 加入成为标准库。

JVM 与性能优化

1. 永久代移除：

   • Java 8 移除了 HotSpot VM 的永久代（PermGen），取而代之的是元空间（Metaspace）。
   • 元空间在本地内存中分配且按需增长，大幅减少了因固定永久代空间不足导致的 OutOfMemoryError 情况，提高了内存管理的灵活性。

2. 垃圾回收优化：

   • Java 8 中虽然默认垃圾回收器仍是 Parallel GC，但引入了一些改进。
   • 例如引入串行/并行 Full GC 等优化；此外为 G1 垃圾收集器（实验性）打下基础。

3. HashMap 性能改进：

   • 为了应对哈希碰撞，Java 8 改进了 HashMap 和 ConcurrentHashMap 的实现。
   • 当桶中链表长度超过阈值时，将链表转换为红黑树存储，从平均 O(n) 查找降为 O(log n)。

工具和其他

1. Nashorn JavaScript 引擎：

   • Java 8 内置了全新的 JavaScript 引擎 Nashorn，替代了原有的 Rhino 引擎。

2. 增强的注解处理和反射：

   • Java 8 对反射和注解处理也有一些改进。

总结

Java 8 是一个里程碑版本，引入的 Lambda 和 Stream 等特性使 Java 正式进入函数式编程时代。默认方法等特性改善了接口演进能力。核心库的加强和全新时间 API 填补了多年痛点。在性能上，永久代的移除和集合优化提升了稳定性。Java 8 的诸多新功能为之后的 Java 版本奠定了基础，也是目前许多项目仍在使用的版本。

---

Java 9 新特性

发行时间：2017 年 9 月

语言和语法增强

1. 模块化系统（Project Jigsaw）：

   • Java 9 最重要的变化是引入模块化系统。JDK 本身被重组为约 94 个模块，允许按需组合所需模块来构建定制的 Java 运行时（可使用下面提到的 jlink 工具）。
   • 开发者可以通过创建模块描述符 module-info.java 将应用拆分为模块。模块定义了所包含的包以及导出的内容和所需依赖，例如：

   // module-info.java 示例
   module com.example.app {requires com.example.utils;   // 声明依赖模块exports com.example.app.api;  // 导出包供其他模块使用
   }
   

   • 模块系统解决了 classpath 下包命名冲突和封装不严的问题，实现强封装。只有模块导出的包才能被外部访问，未导出的内部实现包将被严格封装。这样提高了代码的可维护性和安全性。

   • 应用场景： 大型应用可以通过模块划分更好地管理依赖关系，同时在部署时使用 jlink 剔除无关模块减小体积。不过模块化也带来了学习曲线，且现有项目迁移需要调整访问限制（可以通过 --add-exports 等选项做兼容）。

2. 接口私有方法：

   • 除了 Java 8 的接口默认方法外，Java 9 支持接口定义私有方法来给多个默认方法复用业务逻辑。这提高了接口内部实现的封装性，避免默认方法之间代码重复。私有接口方法只能在接口内部被默认或静态方法调用，不会暴露给实现类。

3. try-with-resources 改进：

   • try-with-resources 语法在 Java 9 更加方便。现在如果已有实现 AutoCloseable 的资源对象（final或 effectively final），可以直接在 try 语句中使用该变量，而不必再次声明。

   // Java 8 及之前需要在 try 内新声明
   try (BufferedReader br = Files.newBufferedReader(path)) { ... }// Java 9 可以在 try 中直接使用已有的变量 br
   BufferedReader br = Files.newBufferedReader(path);
   try (br) {// 使用 br 读取...
   }
   

   • 这减少了不必要的代码臃肿，让语法更简洁。

核心库增强

1. 集合工厂方法：

   • Java 9 为集合接口添加了方便创建不可变集合的静态工厂方法。例如：List.of(1,2,3), Set.of("a","b"), Map.of("key1","val1","key2","val2") 等，可以快捷地创建包含固定元素的集合。这些集合是不可修改的（修改会抛异常）。

   • 应用场景： 用于快速创建常量集合、简化测试用例数据准备等。

2. Stream API 改进：

   • Java 9 为 Stream 增加了一些实用的新方法，如 takeWhile, dropWhile 和 ofNullable 等。其中 takeWhile(predicate) 会从 Stream 开头起连续获取满足条件的元素，直到遇到不满足条件者停止；dropWhile(predicate) 则丢弃开头连续满足条件的元素。

   • 还有 Stream.iterate 支持提供断言来结束迭代。

   Stream.of(1, 2, 3, 4, 5).takeWhile(n -> n < 4);  // 得到 [1, 2, 3]
   Stream.of(1, 2, 3, 4, 5).dropWhile(n -> n < 4);  // 得到 [4, 5]
   Stream.iterate(1, x -> x + 1).takeWhile(x -> x <= 5).forEach(System.out::println);
   

   • 此外，Optional 也增加了 ifPresentOrElse, or 等方法，提高 Optional 的易用性。这些改进让流操作和 Optional 更加完备，减少手动处理。

3. 进程 API：

   • 新增 ProcessHandle 接口，提供了更现代的进程管理 API。通过 ProcessHandle.current() 可以获取当前进程信息，包括 PID 等；还能列出现有进程，观察进程树关系，设置监听等。

   ProcessHandle self = ProcessHandle.current();
   long pid = self.pid();
   self.info().command().ifPresent(cmd -> System.out.println("命令: " + cmd));
   

   • 这在需要监控或管理操作系统进程的应用中非常有用，如实现自定义的进程守护、获取子进程退出事件等。

4. 响应式流（Reactive Streams）：

   • Java 9 在 java.util.concurrent 下引入了发布-订阅框架：Flow API，包括 Flow.Publisher, Subscriber, Subscription, Processor 四个接口。这实际上与 Reactive Streams 标准兼容，为反应式编程提供背压（backpressure）支持。

   • 虽然Java 9没有提供具体实现，但像 RxJava、Akka Streams 等库可直接与这套接口集成。应用在需要异步数据流且要考虑消费速率的场景。

5. HTTP/2 客户端（孵化）：

   • Java 9 引入了一个新的 HTTP 客户端 API 的孵化版本（位于 jdk.incubator.httpclient 模块），支持 HTTP/2 和 WebSocket。虽然后来在 Java 11 才正式成为标准 API，这里值得一提。这个新客户端支持异步非阻塞调用，比旧的 HttpURLConnection 更易用、性能更佳。

JVM 和性能

1. G1 成为默认 GC：

   • Java 9 将 G1 垃圾收集器设置为默认垃圾回收器，取代了之前的 Parallel Scavenge/Parallel Old 组合。G1（Garbage First）是一种低暂停收集器，擅长处理大堆内存，尽量避免了全堆的长时间停顿。

   • 在 Java 9 中，G1 的 Full GC 仍是单线程的，因此极端情况下可能出现长暂停。对此在 Java 10 又做了并行化改进。

   • 应用场景： 对延迟敏感的服务，可从默认使用 G1 中获益（前提是仔细调优以适应应用负载）。

2. 字符串存储优化：

   • Java 9 引入了 Compact Strings，即在内部用 byte 数组存储字符串字符（Latin-1 和 UTF-16 动态选择），而不再总是用 char 数组。对于只包含 ASCII 的字符串，可节省一半内存。

   • 这个改动对开发者透明，但在字符串处理密集的应用中降低了内存占用，提高了 CPU 缓存利用率。

3. AOT 编译（实验）：

   • 新增了 jaotc 工具，允许将 Java 类提前编译为本地代码（Ahead-Of-Time）。AOT 编译器基于 Graal，可生成本地库，在应用启动时加载，从而加快启动速度。

   • 不过这是实验性功能，实际使用较少，在后续版本中也被移除。场景：需要极致优化启动时间的场合可以探索，但一般而言 JIT 已经足够。

4. VarHandle 和内存栅栏：

   • Java 9 提供了 java.lang.invoke.VarHandle 类，作为对 sun.misc.Unsafe 的更安全替代。VarHandle 可以视作特定变量的引用，支持原子操作和内存可见性控制，比如读取写入内存栅栏（类似于 C++ 中的 std::atomic）。

   • 这为开发并发框架、实现锁自由算法提供了标准化的工具。

5. 多版本 JAR：

   • 支持多版本 JAR 文件，即在一个 JAR 中根据不同 Java 版本包含不同的类实现（通过 META-INF/versions 目录）。运行时将选择匹配当前 JVM 版本的类，实现库对新旧版本的兼容发布。

   • 例如，你可以在 JAR 中同时包含 Java 8 的实现和利用 Java 9 特性的实现。这样第三方库可以渐进地利用新特性，同时不失对旧版本的支持。

工具与其他

1. JShell：

   • Java 9 带来了官方的交互式 REPL 工具 JShell。开发者可以在不创建类和 main 方法的情况下，直接输入 Java 表达式或语句，即时查看执行结果。

   jshell> int x = 5 * 20
   x ==> 100
   jshell> "hello, " + "jshell"
   $2 ==> "hello, jshell"
   

   • JShell 极大地方便了试验性编程和学习。可以用它快速验证一段逻辑、探索 API 用法等，降低了写一个 Hello World 的门槛。对于教学、原型开发非常实用。

2. jlink：

   • Java 9 引入了 jlink 工具，可以根据模块依赖创建自定义的精简运行时镜像。开发者指定应用模块后，jlink 会打包只包含所需模块的最小化 JRE。

   • 这对于发布自包含的 Java 应用很有帮助，特别是在容器、物联网设备上，可减少体积并避免目标环境需要预装完整 JDK。

3. JUnit 5 等生态升级：

   • 随着 Java 9 发布，测试框架 JUnit 也升级到 5，支持 Java 8+ 特性如 Lambda 断言等。这虽不是 JDK 自带，但与语言新特性配套出现，标志着 Java 生态正拥抱新版本。

总结

Java 9 通过模块系统对 Java 平台进行了结构性革新。虽然社区对模块化褒贬不一，但不可否认它提高了代码封装和定制部署能力。除此之外，Java 9 在语法上小幅改进（私有接口方法、钻石操作符支持匿名类等未提及细节），在 API 和工具上为开发者提供了许多便捷，如 JShell、集合工厂等。它为之后的版本铺平了道路，标志着 Java 进入了快速发布的新时代。

---

Java 10 新特性

发行时间：2018 年 3 月

语言特性

1. 局部变量类型推断（var）：

   • Java 10 最引人注目的特性是引入了新的关键字 var，用于局部变量类型推断。开发者在定义局部变量时，可以用 var 代替具体类型，编译器会根据初始化表达式自动推断类型：

   var list = new ArrayList<String>();
   var sum = 0;
   for (var item : list) {// 在循环中，item 的类型也会被推断
   }
   

   • 在上述代码中，编译器会推断出 list 的类型为 ArrayList<String>，sum 的类型为 int。注意：var 不是动态类型或弱类型，Java 类型系统仍是静态的，只是让编译器替我们填写类型。

   • 应用场景：var 可减少样板代码，特别是当类型本身冗长（如泛型嵌套）时。

核心库增强

1. 不可变集合拷贝：

   • 在 Java 9 提供集合工厂方法基础上，Java 10 为集合增加了 List.copyOf, Set.copyOf, Map.copyOf 静态方法。这些方法会返回传入集合的不可变拷贝。

   List<String> src = new ArrayList<>(List.of("a", "b"));
   List<String> copy = List.copyOf(src);
   src.add("c");
   System.out.println(copy); // 输出 [a, b]，copy 不受原列表修改影响
   

   • 应用场景：当需要确保集合不被修改时，可以方便地获取其不可变版本。

2. Optional 增强：

   • Java 10 为 Optional 新增了 orElseThrow() 方法，它等价于 .orElseThrow(NoSuchElementException::new)。此外还引入了 Optional.or(() -> alternativeOptional) 来在当前 Optional 为空时提供另一个 Optional。

3. 并行垃圾回收器接口：

   • 引入 java.lang.ref.Cleaner 提供替代 finalize() 的清理机制。尽管不直接属于核心“库”，但 Java 10 重新整理了垃圾收集器的内部接口，将不同 GC 实现的共性提取出来。

性能和 JVM 改进

1. G1 并行 Full GC：

   • Java 10 通过 JEP 307 实现了 G1 Full GC 并行化。现在当 G1 不得不触发 Full GC 时，会使用多个线程并行标记清除，减少停顿时间。

2. 应用类数据共享（AppCDS）：

   • Java 10 通过 JEP 310 将 CDS 扩展到应用层面，允许应用类也加入共享归档。

3. 线程局部握手（Thread Local Handshake）：

   • Java 10 改进了 JVM 停止线程执行的机制。

4. 备用内存设备上的堆：

   • 允许 JVM 将 Java 堆分配在非主内存设备上（如 NVDIMM 持久内存）。

工具和平台

1. 实验性 Java JIT 编译器 - Graal：

   • Java 10 将基于 Java 实现的 JIT 编译器 Graal 引入为实验性选项。

2. 根证书开源：

   • Oracle 将 JDK 内置的 root CA 证书库开源，替代以前 Oracle JDK 与 OpenJDK 差异的一部分。

总结

虽然 Java 10 属于非 LTS 的短期版本，但引入的 var 关键字极大地简化了日常编码。集合、Optional 的小改进也增强了标准库的便利性。在性能方面，G1 并行 Full GC、AppCDS 都是偏底层却意义重大的优化，让 Java 在大内存和大规模部署场景下表现更好。Java 10 还预示了未来的发展方向，如 Graal 编译器的引入为后续多语言支持铺路。

---

Java 11 新特性

发行时间：2018 年 9 月 25 日 （LTS长期支持版）

语言特性

1. Lambda 参数的局部变量语法：

   • Java 11 允许在 Lambda 表达式的参数中使用局部变量语法，即可以用 var 来声明参数类型。

   Comparator<String> cmp = (var a, var b) -> Integer.compare(a.length(), b.length());
   

   • 这对 Lambda 本身功能没有变化，但允许我们添加参数注解时更方便。

2. 直接启动单文件程序：

   • Java 11 可以直接运行单个 Java 源文件，命令如：java Hello.java。Java 编译器会隐式地先编译这个源文件再执行。

   • 应用场景：这一特性降低了 Java 的入门门槛和使用 Java 编写脚本的成本。

核心库增强

1. 标准化 HTTP 客户端：

   • Java 11 将新 HTTP 客户端 API 正式加入标准库（位于 java.net.http 包）。

   HttpClient client = HttpClient.newHttpClient();
   HttpRequest request = HttpRequest.newBuilder(new URI("https://api.github.com")).header("Accept", "application/json").GET().build();
   HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
   System.out.println(response.body());
   

   • 应用场景：调用 REST 服务、执行 HTTP 请求等在企业开发中很常见，新 API 提高了开发效率。

2. 字符串 API 增强：

   • Java 11 对 String 添加了若干实用方法：
     • isBlank()：判断字符串是否为空白（空串或只含空白字符）。
     • strip()：类似 trim()，但能正确处理 Unicode 空白。
     • repeat(int count)：重复当前字符串 count 次，返回新串。
     • lines()：将字符串按行拆分为一个流（Stream）。

3. TLS 1.3 支持：

   • 实现了 TLS 1.3 协议，将安全套接字协议升级到最新标准。

性能与内存

1. ZGC（可伸缩低延迟 GC）：

   • Java 11 引入了实验性的 Z Garbage Collector (ZGC)。

2. Epsilon GC：

   • 另一个实验性 GC —— Epsilon 也在 Java 11 中提供。

3. 低开销 Heap Profiling：

   • 引入了一种低开销的堆采样机制。

4. Flight Recorder 开源：

   • 商业 JDK 中的 Java Flight Recorder (JFR) 在 Java 11 正式开源纳入 OpenJDK。

总结

作为长期支持版本，Java 11 集大成，巩固了 Java 9 和 10 的变化并提供了一些关键的新功能。HttpClient 的正式加入填补了长期以来标准库缺乏现代 HTTP 客户端的空白。一系列细小的 API 改进提升了日常开发体验。ZGC 等革新的 GC 技术虽然仍是实验性质，但展现了 Java 在大内存低延迟领域的潜力。Java 11 开源了之前商用的 JFR，统一了 Oracle JDK 和 OpenJDK 的差异，这对 Java 生态意义重大。

---

Java 12 新特性

发行时间：2019 年 3 月

语言特性（预览）

1. Switch 表达式（预览）：

   • Java 12 对 switch 进行了增强，推出了 Switch 表达式 作为预览特性。它允许 switch 直接返回值并使用简洁的“箭头语法”或 yield 语句，避免了繁琐的 break。

   int numDays = switch(day) {case MON, FRI, SUN -> 6;case TUE -> 7;case THU, SAT -> 8;case WED -> 9;default -> { System.out.println("Unknown day: " + day); yield 0;}
   };
   

2. Instanceof 模式匹配（预览）：

   • Java 12 引入了模式匹配的 instanceof（同为预览特性）。简化了在进行类型检查后再强制转换的常见模式。

   if (obj instanceof String str) {// 进入此块则自动完成类型转换，可直接使用 strSystem.out.println(str.toUpperCase());
   }
   

核心库增强

1. String 新方法：

   • Java 12 为 String 添加了两个方便的方法：
     • String.indent(int n)：调整字符串每行的缩进。
     • String.transform(Function<String,R> f)：将字符串通过给定的函数转换为另一种对象。

2. Files.mismatch：

   • 在 java.nio.file.Files 中新增了 Files.mismatch(Path, Path) 方法，用于高效比较两个文件的内容是否相同。

3. NumberFormat 压缩数字：

   • java.text.NumberFormat 新增了紧凑数字格式（Compact Number Formatting）。

4. Collector.Teeing：

   • Java 12增加了一个很有用的 Collector：Collectors.teeing，可以让流拆分成两个子流，各自收集后再合并结果。

JVM 与垃圾回收

1. Shenandoah GC：

   • 由 RedHat 开发的低停顿垃圾收集器 Shenandoah 在 Java 12 正式引入（实验性）。

2. G1 优化：

   • Java 12 对默认 GC G1 进行了一些改进。

工具和其他

1. Microbenchmark Harness（试验）：

   • Java 12 引入了一个基于 Java 的微基准测试框架（JEP 230）。

2. JVM 常量 API：

   • 提供了一套新的 java.lang.invoke.ConstantBootstraps API，用于在字节码中加载动态常量（JEP 309）。

总结

Java 12 属于过渡版本，但预示了 Java 语言几个重要演进方向：Switch 表达式和模式匹配都是为了让 Java 语法更简洁、更强大。核心库的小改进（字符串 indent/transform 等）贴近开发者需求，让日常编码更高效。Shenandoah GC 等则体现了 Java 在 GC 领域的持续创新，和 ZGC 一起为低延迟场景提供了解决方案。

---

Java 13 新特性

发行时间：2019 年 9 月

语言特性（预览）

1. 文本块（Text Blocks，预览）：

   • Java 13 引入了文本块作为预览特性。文本块使用三重引号 """ 包围多行字符串文字，支持保持代码中的排版格式，大大简化了多行字符串的书写。

   String json = """{"name": "Alice","age": 25}
   """;
   

2. Switch 表达式第二次预览：

   • Java 13 对上一版的 Switch 表达式进行了改进，主要是引入了 yield 关键字来返回值而不是使用 break。

   String result = switch(day) {case MON, TUE, WED, THU, FRI: yield "Workday";case SAT, SUN: yield "Weekend";default: yield "Invalid";
   };
   

核心库与其他

1. ZGC 改进：

   • Java 13 改善了 ZGC，让其在空闲时能够将未使用的堆内存归还操作系统。

2. Socket API 重构：

   • Java 13 底层重写了传统 Socket 实现，引入 NioSocketImpl 取代旧的 PlainSocketImpl。

3. 动态 CDS 归档：

   • Java 13 延伸了在 Java 10 引入的 AppCDS 功能，加入了动态类数据归档能力。

总结

Java 13 延续了预览新特性的打磨，文本块让多行字符串处理在 Java 中首次变得愉悦；Switch 表达式朝着最终定稿又迈进一步。虽然没有正式定稿的新语法，但这些预览特性在社区中引起了极大兴趣。底层方面，Socket API 的重构和 ZGC 的完善提高了性能和资源利用率。

---

Java 14 新特性

发行时间：2020 年 3 月

JVM 改进

1. 空指针异常详细提示：

   • Java 14 对长期困扰开发者的 NullPointerException 进行了改进。当发生 NPE 时，错误信息现在会指出具体哪个变量为空。

2. Switch 表达式正式推出：

   • 经过两个版本的预览，增强型 switch 在 Java 14 正式成为 Java 语言的一部分。

3. 记录类（预览）：

   • Java 14 引入了一种全新的类型声明：记录类（Record），作为预览特性。

   public record Point(int x, int y) { }
   

4. 文本块（第二次预览）：

   • 文本块在 Java 14 继续预览，引入了新的转义。

5. instanceof 模式匹配（第二次预览）：

   • Java 14 中，instanceof 模式匹配作为预览再次出现。

核心库和工具

1. 移除过时的 CMS GC：

   • 并发标记清除（CMS）垃圾收集器自 Java 9 起弃用后，终于在 Java 14 中移除。

2. ZGC 扩展到 macOS/Windows：

   • Java 14 将 ZGC 从仅支持 Linux 扩展到了 macOS 和 Windows 平台。

3. jpackage 工具（孵化）：

   • 提供了 jpackage 工具的早期版本，可将 Java 应用打包成原生安装包。

总结

Java 14 是一个内容相当丰富的版本。Switch 表达式终于定型、记录类和模式匹配开始崭露头角。这些语言层面的增强让 Java 变得更简洁和富有表达力，逐步摆脱“样板代码多”的诟病。

---

Java 15 新特性

发行时间：2020 年 9 月

核心语言特性

1. 文本块正式发布：

   • 经过两次预览，Text Blocks 在 Java 15 成为正式特性。

2. 密封类（预览）：

   • Java 15 引入了密封类和密封接口（Sealed Classes）作为预览特性。

   public sealed class Person permits Employee, Manager { }
   

3. 隐藏类（Hidden Classes）：

   • Java 15 加入了一种专门面向框架、JVM内部使用的类加载功能：隐藏类。

核心库与安全

1. 新增 CharSequence.isEmpty()：

   • 在 Java 15，CharSequence 接口添加了默认方法 isEmpty()。

2. 增强 TreeMap：

   • Java 15 为 java.util.TreeMap 增补了多个常用方法。

3. 新的数字签名算法 EdDSA：

   • Java 15 实现了 Edwards-Curve 数字签名算法（EdDSA）。

JVM 和性能

1. ZGC 转正：

   • ZGC 在 Java 15 终于结束了实验状态，变为生产可用的垃圾收集器。

2. 弃用 Nashorn：

   • Java 15 正式移除了 Nashorn JavaScript 引擎。

总结

Java 15 虽然是短期版本，但特性相当丰富。文本块在这一版终于尘埃落定，使多行字符串处理不再繁琐。密封类的引入让 Java 的类型系统更加强大，配合记录类、模式匹配，Java 正朝着模式匹配和代数数据类型的方向迈进。

---

Java 16 新特性

发行时间：2021 年 3 月

语言特性

1. Records（记录类）正式发布：

   • Java 16 将记录类从预览转为正式特性。

   public record Point(int x, int y) { }
   

2. 模式匹配的 instanceof 正式发布：

   • Java 16 将前几版预览的 instanceof 模式匹配特性定型发布。

3. 密封类第二次预览：

   • Java 16 再次提供了 sealed classes 的预览。

核心库增强

1. Vector API（孵化）：

   • Java 16 引入了一个全新的孵化模块 —— 向量 API。

2. Foreign Memory Access API（孵化）：

   • Java 16 提供了外部内存访问 API 的第三次孵化。

JDK 内部 API 强封装

1. Java 16 开启了对内部 API 强封装的最后一步。

总结

Java 16 是一个重要的过渡版本。它完成了若干预览特性的正化（Records, 模式匹配）和 JDK 内部重构，使 Java 语言和平台更加现代安全。

---

Java 17 新特性

发行时间：2021 年 9 月 14 日 （LTS长期支持版）

语言特性

1. 密封类（正式）：

   • Sealed Classes 在 Java 17 正式成为语言特性。

2. Switch 模式匹配（预览）：

   • Java 17 提供了 switch 的模式匹配作为预览特性。

核心库增强

1. 伪随机数生成器：

   • Java 17 通过 JEP 356 引入了一系列新的随机数生成器接口和实现。

2. 跨平台渲染管线：

   • 针对 macOS 平台，JEP 382 引入了基于 Metal 的 Java 2D 渲染管线。

3. 弃用安全管理器：

   • Java 17 将安全管理器标记为弃用。

性能与内部

1. 永久性强封装 JDK 内部：
   • Java 17 完成了内部 API 封装的最后工作。

总结

Java 17 是继 Java 11 之后的又一个长期支持版本，也是“现代 Java”功能集的大成者。密封类、Record、Pattern Matching 这些 Java 近年推出的语法糖在此全部稳固下来。

---

Java 18 新特性

发行时间：2022 年 3 月

平台与性能

1. 默认字符集 UTF-8：

   • Java 18 通过 JEP 400 将默认字符集统一为 UTF-8。

2. 简单的 Web 服务器：

   • JDK 18 内置了一个简单的纯 Java 实现 HTTP 文件服务器。

核心类重构

1. MethodHandle 实现：
   • JEP 416 用 Method Handle 重写了 Java 核心反射的部分实现。

新特性和 API

1. 代码段（Snippet）标签 for JavaDoc：

   • JEP 413 为 JavaDoc 文档引入了 <pre><code> 风格的代码片段注释。

2. Vector API 第三次孵化：

   • Java 18 中 Vector API 进入第 3 轮孵化。

3. 互联网地址解析 SPI：

   • JEP 418 引入了一个可插拔的名称解析服务接口。

4. 外部函数 & 内存 API 第二次孵化：

   • Java 18 提供了 Panama 项目 Foreign Function & Memory API 的第二版孵化。

5. Switch 模式匹配第二次预览：

   • Java 18 的 JEP 420 给出了 switch 模式匹配的第二次预览。

6. 弃用终结器 Finalization：

   • Java 18 通过 JEP 421 正式将终结器标记为废弃。

安全与密码

1. 默认禁止弱算法：
   • Java 18 在安全方面也做了一些更新。

总结

Java 18 新特性相对较少，最大的变化对普通开发者来说莫过于默认编码 UTF-8 和内置简易 Web 服务器。Java 18 继续推进 Panama 和 Vector 等，使 Java 在系统编程和高性能计算上更具竞争力。

---

Java 19 新特性

发行时间：2022 年 9 月

并发与虚拟线程

1. 虚拟线程（预览）：

   • Java 19 带来了备受期待的虚拟线程（Virtual Threads）预览（JEP 425）。

2. 结构化并发（孵化）：

   • Java 19 还孵化了结构化并发 API（Structured Concurrency，JEP 428）。

语言和模式匹配

1. 记录模式（预览）：

   • Java 19 引入 Record Patterns 预览（JEP 405）。

2. Switch 模式匹配第三次预览：

   • Java 19 的 switch 模式匹配（JEP 427）进入第 3 轮预览。

外部接口和内存

1. 外部函数 & 内存 API（预览）：
   • Java 19 终于进入预览阶段（JEP 424）。

其他改进

1. 虚拟线程 Pinning 问题优化：

   • Java 19 虚拟线程预览中已经实现了当虚拟线程在 synchronized 块中等待时，不会阻塞底层 OS 线程。

2. Linux/RISC-V 移植：

   • JEP 422 将 OpenJDK 移植到了 Linux/RISC-V 架构上。

总结

Java 19 是一个亮点颇多的版本。虚拟线程的初次亮相标志着 Java 并发模型迎来巨大变革；结构化并发、记录模式等则完善了并发和模式匹配的语法。

---

Java 20 新特性

发行时间：2023 年 3 月

项目 Loom 持续改进

1. 虚拟线程第二次预览：

   • Java 20 再次提供虚拟线程预览（JEP 436）。

2. 结构化并发第二次孵化：

   • Java 20 将结构化并发 API (StructuredTaskScope 等) 进行第二轮孵化（JEP 437）。

3. 作用域值（孵化）：

   • Java 20 引入了 Scoped Values（作用域值）孵化特性（JEP 429）。

模式匹配和类型系统

1. 记录模式第二次预览：

   • Java 20 延续了 Java 19 的记录模式预览（JEP 432）。

2. Switch 模式匹配第四次预览：

   • Java 20 的 switch 模式匹配（JEP 433）进入第 4 次预览。

外部接口

1. 外部函数 & 内存 API 第二次预览：
   • Java 20 将 Java 19 的外部函数/内存 API (Panama) 进行第二次预览（JEP 434）。

总结

Java 20 在功能上和 Java 19 一脉相承，并无全新重量级特性亮相，但却将之前的创新推进到了最后阶段。

---

Java 21 新特性

发行时间：2023 年 9 月 19 日 （LTS长期支持版）

语言特性

1. 字符串模板（预览）：

   • Java 21 引入了字符串模板（String Templates）预览（JEP 430）。

2. 记录模式 & 模式匹配 for switch（正式）：

   • Record Patterns 和 Pattern Matching for switch 在经历多次预览后，终于在 Java 21 正式发布（JEP 440, 441）。

3. 未命名模式和变量（正式）：

   • Java 21 正式引入了未命名模式() 和未命名变量()（JEP 443）。

4. 未命名类和实例 main 方法（预览）：

   • Java 21 提供了一个有趣的预览特性 JEP 445。

并发和虚拟线程

1. 虚拟线程正式发布：

   • Java 21 通过 JEP 444 将虚拟线程 (Virtual Threads) 定稿发布。

2. Sequenced Collections（序列集合）：

   • Java 21 引入了新的集合接口族 Sequenced 集合（JEP 431）。

JVM 和性能

1. 分代 ZGC（实验）：

   • Java 21 将 ZGC 升级为分代式垃圾收集器（Generational ZGC，JEP 439）。

2. 禁用安全管理器：

   • Java 21 完全禁止在启动时开启安全管理器。

3. 类加载和链接缓存（预览）：

   • JEP 483 引入了提前加载和链接的机制。

总结

Java 21 是迄今功能最强大的 Java 版本之一。虚拟线程和结构化并发在并发编程领域给予 Java 巨大能量，模式匹配全面落地使 Java 具备了代数数据类型的便利。

---

Java 22 新特性

发行时间：2024 年 3 月

语言与语法

1. 未命名模式和变量转正：

   • 前文提到的下划线 _ 模式和未命名变量在 Java 22 顺利成为正式特性。

2. 外部函数和内存 API 正式发布：

   • Java 22 通过 JEP 454 将 Foreign Function & Memory API 正式加入标准库。

3. 多文件源代码程序启动：

   • Java 22 引入了多源文件一起运行的功能（JEP 458）。

4. 构造函数中允许语句在 super() 之前（预览）：

   • JEP 447 在 Java 22 作为预览推出了构造方法前置语句功能。

核心库与安全

1. 类文件 API 第二次预览：

   • Java 22 继续预览类文件 API (JEP 456/466)。

2. 流收集器 API（预览）：

   • Java 22 引入了流处理的新机制预览。

总结

Java 22 作为 Java 21 之后的过渡版本，主要工作是巩固和过渡。大量 Java 21 预览的特性在 Java 22 得到正式发布，使得 Java 语言和 API 更加完善。

---

Java 23 新特性

发行时间：2024 年 9 月

语言与语法

1. 原始类型模式（预览）：

   • Java 23 通过 JEP 455 引入了对原始类型的模式匹配预览。

2. 类文件 API 第二次预览：

   • Java 23 继续预览类文件 API (JEP 456/466)。

3. Markdown JavaDoc 正式：

   • Java 23 将 JavaDoc 的 Markdown 支持正式化。

总结

Java 23 是在 LTS (21) 之后，下一次 LTS (25) 之前的第二个常规版本。其主要作用是巩固新功能并继续探索。

---

Java 24 新特性

发行时间：2025 年 3 月

安全与密码学

1. 密钥派生函数 API（预览）：

   • Java 24 引入了 KDF (Key Derivation Function) API 预览（JEP 478）。

2. 完全禁用 Security Manager：

   • Java 24 完全移除了安全管理器的启用可能。

性能与工具

1. 类加载与链接缓存：

   • Java 24 通过 JEP 483 引入了类预加载和链接特性。

2. 类文件 API 正式发布：

   • Java 24 正式推出了类文件 API（JEP 484）。

3. Stream::gather 正式发布：

   • Java 24 通过 JEP 485 增强了 Stream API，引入了 Stream.gather(Gatherer) 方法及 Gatherer 接口。

并发与内部改进

1. 作用域值第四次预览：

   • ScopedValue 在 Java 24 进入第 4 次预览（JEP 487）。

2. 虚拟线程同步无 Pinning：

   • Java 24 的虚拟线程在锁中阻塞时会挂起自己，让出载体线程。

总结

Java 24 作为非 LTS 版本，却引入了史无前例多的新特性。它将过去几年的预览几乎全部定型，并推出了像 KDF API、Scope Values 等值得期待的新预览。

---