从 JDK 1.0 到 JDK 26：Java 各版本主要新特性全景梳理

欢迎你来读这篇博客，这篇博客主要是关于 JDK 各版本主要新特性。

Java 已经不是当年那个只会写企业后台的“老干部语言”了。它从 Applet、AWT、JDBC、RMI 时代一路走到 Lambda、模块化、Record、Pattern
Matching、Virtual Threads、Foreign Function & Memory API、AOT、ZGC、Shenandoah、HTTP/3。每一个版本背后，其实都在回答一个问题：

Java 如何在保持兼容性的前提下，继续适应云原生、高并发、低延迟、现代语言表达力和大规模工程治理？

本文会按照版本时间线梳理 JDK 1.0 到 JDK 26 的主要新特性，并重点解释 Java 8 之后对日常开发影响最大的变化。

序言

如果你是 Java 后端开发者，通常最熟悉的是 Java 8、Java 11、Java 17、Java 21，最近也会开始听到 Java 25、Java 26。

但很多人对版本演进的理解是碎片化的：

• Java 8：Lambda、Stream。
• Java 11：LTS，好像移除了 Java EE。
• Java 17：LTS，Record、sealed class。
• Java 21：虚拟线程。
• Java 25：新的 LTS。
• Java 26：还没怎么用，先围观。

这种理解能应付面试，但不够指导真实项目升级。真正要理解 JDK 版本，最好从四条主线看：

1. 语言表达力：Lambda、var、record、sealed class、pattern matching、switch 增强。
2. 标准库能力：Stream、Date-Time API、HTTP Client、Sequenced Collections、FFM API。
3. JVM 与 GC：G1、ZGC、Shenandoah、Metaspace、CDS、AOT、Compact Object Headers。
4. 工程化与运行时治理：模块化、JShell、jlink、JFR、jpackage、虚拟线程、结构化并发。

Java 的演进不是“语法糖堆叠”，而是从语言、JVM、标准库、工具链四个层面持续减负。

---

正文

一、JDK 版本演进总览

Java 版本大致可以分成几个时代：

阶段	代表版本	关键词
早期基础设施时代	JDK 1.0 ~ JDK 1.4	Applet、AWT、JDBC、RMI、Collections、NIO、Logging
泛型与并发基础时代	Java 5 ~ Java 7	泛型、注解、枚举、并发包、NIO.2、try-with-resources
函数式与现代集合处理时代	Java 8	Lambda、Stream、Optional、Date-Time API
模块化与快速发布时代	Java 9 ~ Java 11	JPMS、JShell、HTTP Client、JFR、六个月发布节奏
现代语言增强时代	Java 12 ~ Java 17	switch 表达式、record、sealed class、pattern matching
云原生与高并发时代	Java 18 ~ Java 21	UTF-8 默认、虚拟线程、结构化并发、Generational ZGC
新 LTS 与运行时优化时代	Java 22 ~ Java 26	FFM API、Stream Gatherers、Scoped Values、AOT、HTTP/3、Compact Object Headers

---

二、JDK 1.0 到 JDK 1.4：Java 平台基础成型

1. JDK 1.0：Java 正式诞生

JDK 1.0 是 Java 的起点，主要奠定了 Java 最核心的理念：

• 一次编写，到处运行。
• 面向对象语言。
• 字节码 + 虚拟机执行。
• 自动垃圾回收。
• 标准类库。
• Applet、AWT、网络编程、I/O、线程模型。

虽然今天 Applet 已经成为历史，但当时它确实是 Java 流行的重要原因。只能说，Applet 是 Java 的青春期，冲动但有时代意义。

2. JDK 1.1：企业级能力开始出现

JDK 1.1 引入了很多后来长期存在的基础能力：

• 内部类。
• 反射机制。
• JDBC。
• RMI。
• JavaBeans。
• JAR 文件格式。
• 新 AWT 事件模型。

其中 JDBC、反射、RMI 对后来的企业开发影响很大。反射更是 Spring、Hibernate、MyBatis 等框架的底层基建之一。

3. J2SE 1.2：Java 2 平台

JDK 1.2 是非常重要的版本，Java 开始进入 Java 2 时代，主要特性包括：

• Collections Framework 集合框架。
• Swing。
• Java 2D。
• 新安全模型。
• strictfp 关键字。
• 更完整的标准类库。

集合框架的出现极大提升了 Java 编程体验。List、Set、Map、ArrayList、HashMap、HashSet 等类型从此成为 Java 开发的日常工具。

4. J2SE 1.3：HotSpot 逐渐成熟

JDK 1.3 更偏向平台成熟与性能改进，代表性内容包括：

• HotSpot JVM 成为重要运行时基础。
• JNDI、RMI 等企业能力增强。
• Java Sound。
• JPDA 调试架构增强。
• 运行时性能优化。

这个阶段 Java 开始从“浏览器里的 Applet”逐渐走向更严肃的服务器端和企业级应用。

5. J2SE 1.4：工程化能力增强

JDK 1.4 引入了很多今天仍然常见的能力：

• assert 断言。
• 正则表达式。
• NIO。
• Logging API。
• XML 处理。
• 异常链。
• Preferences API。
• IPv6 支持。

其中 NIO 是非常关键的更新。它为后来的高性能网络框架提供了基础，例如 Netty、Tomcat NIO、Jetty 等都离不开这一类能力。

---

三、Java 5 到 Java 7：泛型、注解、并发与语法增强

Java 5：现代 Java 语法的第一次大爆发

Java 5 是一个里程碑版本。今天很多 Java 基础语法，都是从 Java 5 开始的。

主要新特性：

• 泛型。
• 增强 for 循环。
• 自动装箱与拆箱。
• 枚举。
• 可变参数。
• 静态导入。
• 注解。
• java.util.concurrent 并发包。
• Scanner、Formatter。
• JMX 增强。

1. 泛型

泛型让集合不再需要频繁强转：

List<String> names = new ArrayList<>();
names.add("Mario");

String name = names.get(0);

在没有泛型之前，集合里放的是 Object，取出来需要强制类型转换，既麻烦又容易出错。

2. 注解

注解的出现非常重要。后来 Spring、Spring Boot、JUnit、MyBatis、Lombok、MapStruct 等框架都大量依赖注解。

@Override
public String toString() {
    return "hello";
}

再往后看，Java 生态几乎变成了“注解驱动开发”。没有注解，Spring Boot 的开发体验会直接倒退十年。

3. 并发包

Java 5 引入 java.util.concurrent，这是 Java 并发编程的核心基础：

• ExecutorService
• ThreadPoolExecutor
• Future
• Callable
• CountDownLatch
• CyclicBarrier
• Semaphore
• ConcurrentHashMap
• BlockingQueue
• AtomicInteger

这套并发工具直到今天仍然是 Java 后端开发的必修课。

---

Java 6：平台稳定与企业开发增强

Java 6 的语法层面变化不算激进，但平台能力明显增强。

主要新特性：

• 脚本语言支持。
• Compiler API。
• JDBC 4.0。
• Web Services 支持增强。
• JConsole、JMX、监控能力增强。
• 性能优化。
• 桌面能力增强。

Java 6 是很多传统企业项目长期停留的版本。它的价值不在“语法新”，而在“平台稳”。

---

Java 7：Project Coin、NIO.2 与 invokedynamic

Java 7 是 Java 8 之前的最后一个重要铺垫版本。

主要新特性：

• try-with-resources。
• switch 支持 String。
• 菱形语法。
• 多异常捕获。
• 数字字面量下划线。
• 二进制字面量。
• NIO.2。
• Fork/Join 框架。
• invokedynamic。

1. try-with-resources

以前关闭资源经常写一大堆 finally，Java 7 之后可以这样写：

try (BufferedReader reader = new BufferedReader(new FileReader("demo.txt"))) {
    String line = reader.readLine();
}

实现了 AutoCloseable 的资源会自动关闭，代码更短，也更安全。

2. Fork/Join

Fork/Join 用于拆分任务、并行执行、合并结果：

ForkJoinPool pool = new ForkJoinPool();

后来的并行流底层也借鉴了这类并行计算模型。

3. invokedynamic

invokedynamic 对普通业务开发者不太直观，但它非常重要。它为 JVM 支持动态语言、Lambda 表达式等能力打下基础。

也就是说，Java 8 的 Lambda 背后其实有 Java 7 的铺路。

---

四、Java 8：函数式编程时代

Java 8 是 Java 历史上最重要的版本之一。很多公司至今仍有大量 Java 8 项目。

主要新特性：

• Lambda 表达式。
• 方法引用。
• Stream API。
• 默认方法。
• Optional。
• 新 Date-Time API。
• CompletableFuture。
• Nashorn JavaScript 引擎。
• Base64 API。
• 移除永久代，改为 Metaspace。

1. Lambda 表达式

Java 8 之前：

list.sort(new Comparator<User>() {
    @Override
    public int compare(User a, User b) {
        return a.getAge() - b.getAge();
    }
});

Java 8 之后：

list.sort((a, b) -> a.getAge() - b.getAge());

Lambda 不是单纯少写几行代码，它改变了 Java 对行为参数化的表达方式。

2. Stream API

Stream 让集合处理更声明式：

List<String> names = users.stream()
        .filter(user -> user.getAge() >= 18)
        .map(User::getName)
        .distinct()
        .sorted()
        .collect(Collectors.toList());

这段代码表达的是“我要什么”，而不是“每一步怎么循环”。

3. Optional

Optional 用来表达“这个值可能不存在”：

Optional<User> userOpt = userRepository.findById(id);

userOpt.ifPresent(user -> System.out.println(user.getName()));

不过要注意，Optional 不建议滥用于实体字段、DTO 字段和方法参数。它更适合作为返回值表达空值语义。

4. Date-Time API

Java 8 的 java.time 是对旧版 Date、Calendar 的重大替代：

LocalDate date = LocalDate.now();
LocalDateTime time = LocalDateTime.now();
ZonedDateTime zonedTime = ZonedDateTime.now();

它不可变、线程安全、语义清晰，强烈建议新项目优先使用。

5. Metaspace 替代永久代

Java 8 移除了永久代，使用 Metaspace 存放类元数据。
这对 JVM 调优也有影响，以前常见的 PermGen space 问题逐渐变成了 Metaspace 相关问题。

---

五、Java 9：模块化时代

Java 9 是一个工程结构层面的重大版本。

主要新特性：

• JPMS 模块系统。
• JShell。
• jlink。
• 集合工厂方法。
• Stream API 增强。
• Optional 增强。
• Process API 增强。
• G1 成为默认 GC。
• 统一 JVM 日志。
• Multi-Release JAR。
• --release 编译参数。

1. JPMS 模块系统

模块系统通过 module-info.java 显式声明模块依赖：

module com.example.demo {
    requires java.sql;
    exports com.example.demo.api;
}

它的目标是解决大型应用中的依赖边界、封装性和 JDK 自身模块化问题。

不过在普通 Spring Boot 项目中，JPMS 使用并不算普遍。原因也很现实：Java 生态已有 Maven、Gradle、Spring 的依赖管理体系，很多业务项目并不急着模块化。

2. JShell

JShell 是 Java 的交互式 REPL：

jshell
jshell> System.out.println("hello");

它适合快速验证 API、语法和小片段代码。以前 Java 写个测试还要建类、写 main 方法，现在可以直接试。

3. jlink

jlink 可以基于模块裁剪运行时镜像，让 Java 应用带着定制化 JRE 发布。

这对容器镜像体积、运行环境控制有意义。

4. 集合工厂方法

Java 9 可以更方便创建不可变集合：

List<String> list = List.of("a", "b", "c");
Set<String> set = Set.of("x", "y");
Map<String, Integer> map = Map.of("a", 1, "b", 2);

---

六、Java 10 到 Java 11：快速发布与新 LTS

Java 10：局部变量类型推断

Java 10 最大的语言特性是 var：

var name = "Mario";
var users = new ArrayList<User>();

var 只用于局部变量，不能用于字段、方法参数、方法返回值。

合理使用 var 可以减少样板代码，但滥用会降低可读性。比如下面这种就不推荐：

var result = service.execute();

如果看不出 result 是什么类型，就别硬用。代码不是猜谜游戏，队友也不是福尔摩斯。

Java 10 还有：

• G1 并行 Full GC。
• Application CDS。
• 线程局部握手。
• Root Certificates。
• 基于时间的版本号模型。

---

Java 11：重要 LTS 版本

Java 11 是 Java 8 之后第一个被大量企业采用的 LTS 版本。

主要新特性：

• 标准化 HTTP Client。
• Flight Recorder。
• TLS 1.3。
• 单文件源码运行。
• Lambda 参数支持 var。
• Epsilon GC。
• ZGC 实验版。
• 移除 Java EE 和 CORBA 模块。
• 废弃 Nashorn。
• 废弃 Pack200。

1. HTTP Client

Java 11 标准化了新的 HTTP Client：

HttpClient client = HttpClient.newHttpClient();

HttpRequest request = HttpRequest.newBuilder()
        .uri(URI.create("https://example.com"))
        .GET()
        .build();

HttpResponse<String> response = client.send(
        request,
        HttpResponse.BodyHandlers.ofString()
);

相比早期的 HttpURLConnection，新的 HTTP Client API 更现代，也支持异步调用。

2. 单文件源码运行

Java 11 可以直接运行单个 .java 文件：

java Hello.java

这对脚本、小工具、教学代码很方便。

3. 移除 Java EE / CORBA 模块

Java 11 移除了部分历史包，例如：

• JAXB
• JAX-WS
• CORBA
• Java Activation Framework

很多老项目从 Java 8 升级到 Java 11 时会遇到编译问题，通常需要显式添加相关依赖。

---

七、Java 12 到 Java 17：现代语法逐步成型

Java 12

主要新特性：

• switch 表达式预览。
• Shenandoah GC 实验版。
• JVM Constants API。
• 默认 CDS Archives。
• G1 改进。

switch 表达式让 switch 可以返回值：

String type = switch (code) {
    case 1 -> "新增";
    case 2 -> "修改";
    case 3 -> "删除";
    default -> "未知";
};

---

Java 13

主要新特性：

• Text Blocks 预览。
• switch 表达式继续预览。
• Dynamic CDS Archives。
• ZGC 释放未使用内存。
• Socket API 重实现。

Text Blocks 用于多行字符串：

String json = """
        {
          "name": "Mario",
          "age": 18
        }
        """;

---

Java 14

主要新特性：

• switch 表达式正式转正。
• Record 预览。
• pattern matching for instanceof 预览。
• Helpful NullPointerExceptions。
• JFR Event Streaming。
• 移除 CMS GC。
• 移除 Pack200。

Helpful NullPointerExceptions

以前 NPE 经常只告诉你空了，但不告诉你谁空了。Java 14 后，错误信息更清晰：

user.getAddress().getCity()

如果 address 是 null，JVM 可以指出具体是 getAddress() 返回了 null。
这对排查线上问题很有帮助。

---

Java 15

主要新特性：

• Text Blocks 正式转正。
• Sealed Classes 预览。
• Hidden Classes。
• Record 第二次预览。
• ZGC 转正。
• Shenandoah 转正。
• 移除 Nashorn。
• 移除 Solaris 和 SPARC 支持。

Text Blocks 正式稳定后，写 SQL、JSON、HTML 模板更舒服：

String sql = """
        SELECT id, name, age
        FROM user
        WHERE deleted = 0
        """;

---

Java 16

主要新特性：

• Record 正式转正。
• pattern matching for instanceof 正式转正。
• jpackage。
• Vector API 孵化。
• Unix-Domain Socket Channels。
• 强封装 JDK 内部 API。
• Elastic Metaspace。

1. Record

Record 非常适合表达不可变数据载体：

public record UserDTO(Long id, String name, Integer age) {
}

编译器会自动生成：

• 构造方法。
• getter 风格访问器。
• equals
• hashCode
• toString

Record 适合 DTO、查询结果、值对象，但不适合复杂实体模型。
比如 JPA Entity 通常不建议直接用 record。

2. instanceof 模式匹配

以前：

if (obj instanceof String) {
    String s = (String) obj;
    System.out.println(s.length());
}

现在：

if (obj instanceof String s) {
    System.out.println(s.length());
}

减少强转，代码更自然。

---

Java 17：重要 LTS 版本

Java 17 是目前大量企业项目正在迁移或已经使用的 LTS 版本。

主要新特性：

• Sealed Classes 正式转正。
• pattern matching for switch 预览。
• 强封装 JDK 内部 API。
• 新伪随机数生成器 API。
• macOS/AArch64 支持增强。
• 废弃 Applet API。
• 废弃 Security Manager。
• Foreign Function & Memory API 孵化。
• Vector API 第二轮孵化。

1. Sealed Classes

Sealed Classes 可以限制一个类只能被哪些类继承：

public sealed interface Payment
        permits AlipayPayment, WechatPayment, BankCardPayment {
}

public final class AlipayPayment implements Payment {
}

public final class WechatPayment implements Payment {
}

public final class BankCardPayment implements Payment {
}

它非常适合表达有限状态、有限类型层级，例如：

• 支付方式。
• 订单状态。
• 规则结果。
• AST 语法树节点。
• 领域模型中的有限分支。

2. Java 17 的工程价值

如果项目还停留在 Java 8，Java 17 是一个非常值得考虑的升级目标。原因是：

• LTS 支持周期长。
• 生态成熟。
• Spring Boot 3 要求 Java 17 起步。
• JVM 性能和 GC 能力明显增强。
• 现代语法足够丰富，但没有过于激进。

---

八、Java 18 到 Java 21：虚拟线程时代到来

Java 18

主要新特性：

• UTF-8 成为默认字符集。
• Simple Web Server。
• JavaDoc 支持代码片段。
• 核心反射基于 Method Handles 重实现。
• Finalization 废弃。
• Vector API 继续孵化。
• FFM API 继续孵化。

UTF-8 默认

这是一个非常实用的变化。
以前不同操作系统默认字符集可能不一致，导致中文乱码、文件编码问题。Java 18 后默认使用 UTF-8，跨平台行为更统一。

---

Java 19

主要新特性：

• Virtual Threads 预览。
• Structured Concurrency 孵化。
• Record Patterns 预览。
• Pattern Matching for switch 继续预览。
• Foreign Function & Memory API 预览。
• Linux/RISC-V 移植。
• Vector API 继续孵化。

Java 19 开始，Project Loom 的成果正式进入大众视野。

---

Java 20

主要新特性：

• Virtual Threads 第二次预览。
• Scoped Values 孵化。
• Structured Concurrency 第二次孵化。
• Record Patterns 第二次预览。
• Pattern Matching for switch 继续预览。
• FFM API 第二次预览。
• Vector API 继续孵化。

Java 20 更像是 Java 21 的前奏，很多重量级特性都在继续打磨。

---

Java 21：新时代 LTS

Java 21 是非常重要的 LTS 版本，也是近几年最值得关注的 Java 版本之一。

主要新特性：

• Virtual Threads 正式转正。
• Record Patterns 正式转正。
• Pattern Matching for switch 正式转正。
• Sequenced Collections。
• Generational ZGC。
• String Templates 预览。
• Unnamed Patterns and Variables 预览。
• Scoped Values 预览。
• Structured Concurrency 预览。
• Key Encapsulation Mechanism API。
• Vector API 继续孵化。

1. Virtual Threads 虚拟线程

虚拟线程是 Java 21 最核心的特性之一。

传统平台线程比较重，大量线程会带来内存和调度成本。虚拟线程则是由 JVM 管理的轻量级线程，可以用更低成本支撑大量并发任务。

示例：

try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
    executor.submit(() -> {
        System.out.println("hello virtual thread");
    });
}

虚拟线程的意义不是让 CPU 密集型任务变快，而是让阻塞式 I/O 场景下的高并发模型更简单。

适合场景：

• Web 请求处理。
• RPC 调用。
• 数据库访问。
• 文件 I/O。
• 外部接口调用。
• 大量阻塞等待任务。

不适合误解：

• 虚拟线程不是替代所有线程池。
• 虚拟线程不是让 CPU 计算自动变快。
• 虚拟线程不是让烂 SQL 变快。
• 虚拟线程不是魔法棒，不要看到新东西就往生产乱怼。

2. Sequenced Collections

Java 21 引入有序集合统一接口：

• SequencedCollection
• SequencedSet
• SequencedMap

它统一了“第一个元素、最后一个元素、反向视图”等操作。

例如：

var list = new ArrayList<String>();
list.add("a");
list.add("b");

String first = list.getFirst();
String last = list.getLast();

这让一些集合操作更统一，也减少了不同集合 API 的割裂感。

3. Pattern Matching for switch

Java 21 中，switch 模式匹配正式稳定：

static String format(Object obj) {
    return switch (obj) {
        case Integer i -> "int: " + i;
        case Long l -> "long: " + l;
        case String s -> "string: " + s;
        case null -> "null";
        default -> "unknown";
    };
}

这让 Java 在处理复杂类型分支时更优雅，尤其适合和 sealed class 搭配使用。

4. Record Patterns

Record Patterns 可以解构 record：

record Point(int x, int y) {}

static void print(Object obj) {
    if (obj instanceof Point(int x, int y)) {
        System.out.println(x + "," + y);
    }
}

这类能力让 Java 的模式匹配体系逐渐完整。

---

九、Java 22 到 Java 26：新 LTS 前后的运行时与工程增强

Java 22

主要新特性：

• Foreign Function & Memory API 正式转正。
• Unnamed Variables and Patterns 正式转正。
• Class-File API 预览。
• Stream Gatherers 预览。
• 多文件源码程序启动。
• G1 Region Pinning。
• Statements before super 预览。
• String Templates 第二次预览。
• Scoped Values 第二次预览。
• Structured Concurrency 第二次预览。

Foreign Function & Memory API

FFM API 用于替代部分 JNI 场景，让 Java 更安全、更现代地访问外部函数和堆外内存。

它适合：

• 调用 C 库。
• 高性能本地计算。
• 与系统底层能力交互。
• 替代复杂 JNI 代码。

对普通业务开发者来说，它不一定天天用，但对中间件、数据库驱动、向量计算、AI 推理、系统编程很重要。

---

Java 23

主要新特性：

• Markdown Documentation Comments。
• Generational ZGC 成为默认 ZGC 模式。
• Module Import Declarations 预览。
• Primitive Types in Patterns 预览。
• Class-File API 第二次预览。
• Stream Gatherers 第二次预览。
• 弃用 Unsafe 内存访问方法。
• Flexible Constructor Bodies 第二次预览。

Markdown 文档注释

JavaDoc 支持 Markdown 风格注释，写文档更舒服。

以前写复杂 JavaDoc 很容易变成 HTML 手搓现场，像在用键盘织毛衣。Markdown 支持后，可读性明显提升。

---

Java 24

主要新特性：

• Class-File API 正式转正。
• Stream Gatherers 正式转正。
• AOT Class Loading & Linking。
• Compact Object Headers 实验。
• Key Derivation Function API 预览。
• 后量子加密算法支持。
• Security Manager 被永久禁用。
• Prepare to Restrict JNI。
• ZGC 移除非分代模式。
• 虚拟线程同步优化，减少 pinning 问题。
• Module Import Declarations 第二次预览。
• Simple Source Files / Instance Main Methods 继续预览。

Stream Gatherers

Stream Gatherers 用于增强 Stream 的中间操作表达力。
原来的 Stream API 对一些复杂窗口、分组、滑动处理不够自然，Gatherers 就是为这类场景补充能力。

AOT Class Loading & Linking

AOT 类加载与链接主要用于改善启动速度和预热表现。
这对云原生、Serverless、短生命周期应用比较有意义。

---

Java 25：新的 LTS 版本

Java 25 是 Java 21 之后的新 LTS 版本。

主要新特性：

• Scoped Values 正式转正。
• Compact Source Files and Instance Main Methods。
• Module Import Declarations。
• Flexible Constructor Bodies。
• Compact Object Headers。
• Generational Shenandoah。
• Key Derivation Function API。
• PEM Encodings 预览。
• Stable Values 预览。
• Structured Concurrency 继续预览。
• Primitive Types in Patterns 继续预览。
• Vector API 继续孵化。
• JFR CPU-Time Profiling。
• JFR Method Timing & Tracing。
• AOT Method Profiling。
• AOT Command-Line Ergonomics。
• 移除 32-bit x86 端口。

1. Scoped Values

Scoped Values 可以理解为一种更安全、更可控的上下文传递机制，适合替代部分 ThreadLocal 场景。

传统 ThreadLocal 的问题：

• 生命周期不清晰。
• 容易忘记清理。
• 在线程池复用下可能产生脏数据。
• 与虚拟线程、结构化并发结合时需要更现代的上下文模型。

Scoped Values 更强调“作用域内有效”，用完即走，减少上下文泄漏风险。

2. Compact Object Headers

Compact Object Headers 的目标是减少对象头大小，从而降低内存占用。
Java 应用里对象数量往往非常庞大，对象头变小会影响整体内存密度。

这对大对象图、高并发服务、缓存型应用尤其有价值。

3. Java 25 的升级意义

Java 25 的定位非常关键：

• 它是新的 LTS。
• 它继承了 Java 21 的虚拟线程、模式匹配、现代集合能力。
• 它继续强化 AOT、JFR、GC、内存布局。
• 它更适合作为未来几年新项目的基准版本。

如果你现在是 Java 8 / 11 / 17 项目，未来可以重点关注 Java 21 和 Java 25 两条升级路线。

---

Java 26：继续增强运行时、网络与未来限制

Java 26 是 2026 年发布的 Feature Release。

主要新特性：

• HTTP/3 for HTTP Client API。
• AOT Object Caching with Any GC。
• G1 GC 吞吐优化。
• 移除 Applet API。
• Prepare to Make Final Mean Final。
• PEM Encodings 第二次预览。
• Structured Concurrency 第六次预览。
• Lazy Constants 第二次预览。
• Vector API 第十一次孵化。
• Primitive Types in Patterns 第四次预览。

1. HTTP/3 for HTTP Client API

Java 标准 HTTP Client 开始支持 HTTP/3。
HTTP/3 基于 QUIC，对连接建立、弱网表现、队头阻塞问题有改善空间。

这说明 Java 标准库也在继续跟进现代网络协议。

2. AOT Object Caching with Any GC

AOT Object Caching 的目标是把部分启动阶段会构建的对象提前缓存，从而改善启动和预热。

更关键的是，它开始支持任意 GC，而不是只绑定某个特定垃圾收集器。

3. G1 GC 吞吐优化

G1 是很多服务端应用的默认选择。Java 26 继续优化 G1 的吞吐表现，尤其关注同步和屏障相关开销。

4. Final 字段限制准备

Java 26 开始对通过深反射修改 final 字段的行为给出警告，并为未来更严格限制做准备。

这对一些依赖反射黑科技的框架、序列化库、测试工具有影响。
如果项目里大量通过反射改 final 字段，后续升级需要提前排查。

5. Applet API 移除

Applet 曾经是 Java 早期的重要组成部分，但现在已经彻底过时。
Java 26 移除 Applet API，算是给这段历史正式画上句号。

---

十、按版本快速对照表

版本	发布时间阶段	核心关键词	主要特性
JDK 1.0	1996	Java 起点	JVM、字节码、Applet、AWT、I/O、线程、网络
JDK 1.1	1997	企业基础	内部类、反射、JDBC、RMI、JavaBeans、JAR
J2SE 1.2	1998	Java 2	Collections、Swing、Java 2D、安全模型
J2SE 1.3	2000	平台成熟	HotSpot、JPDA、JNDI、RMI 增强
J2SE 1.4	2002	工程增强	assert、正则、NIO、Logging、XML、异常链
Java 5	2004	现代语法	泛型、注解、枚举、自动装箱、增强 for、并发包
Java 6	2006	平台稳定	脚本 API、Compiler API、JDBC 4.0、监控增强
Java 7	2011	语法补强	try-with-resources、switch String、NIO.2、Fork/Join、invokedynamic
Java 8	2014	函数式	Lambda、Stream、Optional、Date-Time API、CompletableFuture、Metaspace
Java 9	2017	模块化	JPMS、JShell、jlink、G1 默认、集合工厂方法
Java 10	2018	快速发布	var、G1 Full GC 并行、AppCDS、时间版本模型
Java 11	2018	LTS	HTTP Client、JFR、TLS 1.3、单文件运行、移除 Java EE/CORBA
Java 12	2019	小步快跑	switch 表达式预览、Shenandoah 实验、G1 改进
Java 13	2019	文本增强	Text Blocks 预览、Dynamic CDS、ZGC 释放内存
Java 14	2020	语法增强	switch 转正、Record 预览、Helpful NPE、JFR Streaming
Java 15	2020	GC 转正	Text Blocks 转正、ZGC/Shenandoah 转正、Sealed Classes 预览
Java 16	2021	数据建模	Record 转正、instanceof 模式匹配转正、jpackage
Java 17	2021	LTS	Sealed Classes 转正、强封装、模式匹配继续推进
Java 18	2022	编码统一	UTF-8 默认、Simple Web Server、Finalization 废弃
Java 19	2022	Loom 预览	Virtual Threads 预览、Structured Concurrency 孵化
Java 20	2023	Loom/Panama 打磨	虚拟线程二次预览、Scoped Values、FFM 继续预览
Java 21	2023	LTS / 虚拟线程	Virtual Threads 转正、Sequenced Collections、Record Patterns、Pattern Switch
Java 22	2024	FFM 转正	FFM API、Unnamed Variables、Stream Gatherers 预览
Java 23	2024	文档与 GC	Markdown JavaDoc、Generational ZGC 默认、Module Import 预览
Java 24	2025	AOT 与 Stream	Class-File API、Stream Gatherers、AOT 类加载、量子安全算法
Java 25	2025	LTS	Scoped Values、Compact Object Headers、Generational Shenandoah、AOT/JFR 增强
Java 26	2026	网络与运行时	HTTP/3、AOT Object Caching、G1 吞吐优化、Applet API 移除

---

十一、企业项目应该怎么选 JDK 版本？

1. 还在 Java 8 的项目

Java 8 的生态很稳，但问题也明显：

• 语言特性落后。
• GC 和 JVM 优化吃不到。
• 新框架支持逐渐减少。
• Spring Boot 3 不支持 Java 8。
• 很多安全与性能能力需要升级才能使用。

如果是老系统，建议至少规划到 Java 17。
如果周期允许，可以进一步评估 Java 21。

2. Java 11 项目

Java 11 是一个不错的过渡版本，但从今天看，它的现代特性仍然不足。

建议升级方向：

• 稳妥路线：Java 11 -> Java 17。
• 前瞻路线：Java 11 -> Java 21。
• 新项目路线：直接评估 Java 21 或 Java 25。

3. Java 17 项目

Java 17 是当前企业落地非常成熟的版本，适合大部分 Spring Boot 3 项目。

是否升级 Java 21，主要看：

• 是否需要虚拟线程。
• 是否希望使用更完整的模式匹配。
• 是否有更高并发 I/O 场景。
• 是否能接受依赖库升级成本。

4. Java 21 项目

Java 21 是非常值得长期使用的版本，尤其适合：

• 高并发 Web 服务。
• RPC 服务。
• 大量外部 I/O 调用服务。
• Spring Boot 3.2+ 之后的现代项目。
• 希望使用虚拟线程的项目。

5. Java 25 项目

Java 25 是新的 LTS，适合新项目提前布局。
但在企业生产中，通常建议观察框架、依赖、中间件、监控工具、APM、IDE、构建插件的支持情况。

如果你的公司技术栈比较稳健，Java 21 仍然是更现实的基线。
如果你是新项目、基础设施可控、团队愿意跟进新版本，Java 25 值得关注。

---

十二、升级 JDK 时重点关注什么？

1. 依赖兼容性

升级 JDK 不是只改一个版本号。你需要检查：

• Spring Boot 版本。
• Maven / Gradle 插件。
• Lombok。
• MapStruct。
• MyBatis。
• Netty。
• 数据库驱动。
• 日志框架。
• APM Agent。
• 字节码增强工具。
• 测试框架。

尤其是用了反射、Unsafe、动态代理、字节码增强的库，更需要注意。

2. JVM 参数变化

很多老参数在新版本中已经废弃或移除，比如：

• PermGen 相关参数。
• CMS GC 相关参数。
• Pack200 相关工具。
• 一些非法反射放行参数。
• 老旧 GC 组合参数。

升级前要检查启动脚本，别让 JVM 参数成为启动失败的第一块香蕉皮。

3. GC 行为变化

不同版本默认 GC 和 GC 行为会变化。常见选择：

• Java 8：Parallel GC、CMS、G1。
• Java 9+：G1 成为默认 GC。
• Java 11+：ZGC 开始出现。
• Java 15+：ZGC、Shenandoah 转正。
• Java 21+：Generational ZGC。
• Java 25+：Generational Shenandoah。

对于低延迟系统，要重点压测 GC 行为。
对于普通业务系统，G1 通常是一个稳妥选择。

4. 反射与 JDK 内部 API

Java 9 之后模块化和强封装不断推进。
如果项目依赖 sun.misc.Unsafe、JDK 内部包、深反射访问私有字段，升级时很可能遇到警告或失败。

建议：

• 尽量使用标准 API。
• 升级依赖库版本。
• 减少非法反射。
• 谨慎使用 --add-opens，不要把它当长期方案。

5. Preview / Incubator 特性不要乱上生产

Preview 和 Incubator 特性适合学习、实验、技术验证，但不建议作为核心生产代码基础。

原因很简单：

• 语法可能变化。
• API 可能变化。
• 后续版本可能调整甚至移除。
• 团队维护成本更高。

新东西很好，但生产环境不是游乐场。技术可以浪，事故不行。

---

十三、几个最值得重点掌握的现代 Java 特性

1. Lambda + Stream

这是 Java 8 之后最基础的现代编程能力。

适合：

• 集合过滤。
• 映射转换。
• 分组统计。
• 聚合计算。
• 简化策略传入。

但不要为了 Stream 而 Stream。
复杂业务逻辑硬塞进一条 Stream，最后会变成“函数式毛线团”。

2. Record

适合 DTO、VO、值对象、查询结果。

public record OrderSummary(
        Long orderId,
        BigDecimal amount,
        String status
) {
}

不适合：

• 复杂领域实体。
• 需要大量可变状态的对象。
• JPA Entity。
• 需要无参构造和 setter 的老框架模型。

3. Sealed Class + Pattern Matching

适合表达有限类型分支。

sealed interface Result permits Success, Failure {
}

record Success(String data) implements Result {
}

record Failure(String message) implements Result {
}

static String handle(Result result) {
    return switch (result) {
        case Success success -> success.data();
        case Failure failure -> failure.message();
    };
}

这套组合非常适合写清晰的领域模型。

4. Virtual Threads

适合高并发阻塞 I/O 场景。

try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
    for (int i = 0; i < 10000; i++) {
        executor.submit(() -> callRemoteApi());
    }
}

但要注意：

• 数据库连接池仍然有限。
• 下游服务仍然有限。
• CPU 核数仍然有限。
• 限流、熔断、超时仍然必须做。

虚拟线程能降低线程成本，但不能降低业务系统的复杂性。

5. JFR

JFR 是 Java 自带的性能诊断工具，非常适合线上排查：

• CPU 热点。
• 对象分配。
• 锁竞争。
• GC 情况。
• 线程状态。
• I/O 行为。

如果你还只会看日志排性能问题，那就像拿手电筒找太阳，有点努力，但方向不太对。

---

十四、总结

JDK 版本演进可以浓缩成几句话：

1. Java 5 奠定现代 Java 语法基础：泛型、注解、枚举、并发包。
2. Java 8 引入函数式编程范式：Lambda、Stream、Optional、Date-Time API。
3. Java 9 引入模块化，Java 进入更现代的工程治理时代。
4. Java 11 是 Java 8 后的重要 LTS，适合传统项目升级过渡。
5. Java 17 是 Spring Boot 3 时代的重要基线。
6. Java 21 带来虚拟线程，是高并发 Java 服务的重要转折点。
7. Java 25 是新的 LTS，继续强化运行时、内存、AOT、JFR 和现代语言能力。
8. Java 26 继续推进 HTTP/3、AOT Object Caching、G1 优化和未来更严格的运行时约束。

如果从工程实践角度给建议：

• 老项目：优先从 Java 8 / 11 升级到 Java 17。
• 新项目：优先考虑 Java 21。
• 前瞻项目：关注 Java 25。
• 实验探索：可以跟进 Java 26 的新特性。
• 生产环境：少碰 Preview / Incubator，除非你真的知道自己在做什么。

Java 的优势从来不是“最潮”，而是“稳定、兼容、生态强、持续进化”。
它的升级路线不像跑车炸街，更像一辆不断换新发动机和底盘的重型卡车：看起来稳，跑起来也真能拉活。

---

参考资料

• OpenJDK JDK Project Pages
• OpenJDK JEP Index
• Oracle Java SE Documentation
• Oracle Java SE Support Roadmap
• Java Version Almanac
• JDK Enhancement Proposals

启示录

富贵岂由人，时会高志须酬。

能成功于千载者，必以近察远。