1. JDK 8：函数式编程的觉醒 (The Era of Functional)

JDK 8 是 Java 历史上最大的变革之一，引入了函数式编程思想，旨在解决“动词”（行为）无法像“名词”（对象）那样自由传递的问题。

1.1 Lambda 表达式与底层原理

核心痛点：在 JDK 8 之前，为了把代码块作为参数传递（例如点击监听器），我们需要写冗长的匿名内部类。

代码对比：

Java

// JDK 8 之前：匿名内部类
Runnable r1 = new Runnable() {
    @Override
    public void run() {
        System.out.println("Old Way");
    }
};

// JDK 8：Lambda
Runnable r2 = () -> System.out.println("New Way");

深入原理 (Bytecode Level)：

很多人误以为 Lambda 只是匿名内部类的语法糖，其实不是。

• 匿名内部类：编译后会生成一个独立的 .class 文件（如 Main$1.class）。
• Lambda：编译后不会生成单独的类文件。它利用了 JDK 7 引入的字节码指令 invokedynamic。

源码/字节码视角：

当你编写 Lambda 时，编译器会在当前类中生成一个私有的静态方法（包含 Lambda 的逻辑），并在运行时通过 LambdaMetafactory 动态生成调用点（CallSite）。这大大减少了磁盘 IO 和类加载的开销。

1.2 Stream API：内部迭代

核心痛点：传统的 for 循环是“外部迭代”，开发者既要管“做什么”（逻辑），又要管“怎么做”（循环控制）。Stream 实现了“内部迭代”。

代码示例：

Java

List<String> names = Arrays.asList("Java", "Python", "Go");
// 筛选长度大于3的大写名称
List<String> result = names.stream()
    .filter(s -> s.length() > 3) // 中间操作 (Lazy)
    .map(String::toUpperCase)    // 中间操作 (Lazy)
    .collect(Collectors.toList()); // 终端操作 (Trigger)

深度解析：

Stream 的核心机制是 Lazy Evaluation（惰性求值）。

• Head: 数据源。
• Op (中间操作): filter 和 map 不会立即执行，它们只是构建了一个操作管道（Pipeline），本质上是链表结构的 ReferencePipeline。
• Terminal Op (终端操作): 只有调用 collect 或 forEach 时，数据才会真正流过管道。这允许 JVM 进行优化，例如循环合并（Loop Fusion），即只需遍历一次数据即可完成筛选和转换。

---

2. JDK 9 - 11：模块化与语法糖 (System & Syntax)

这一阶段重点在于清理技术债务（模块化）和提升开发者体验（类型推断）。

2.1 JDK 9：模块化系统 (Jigsaw)

核心变革：引入 module-info.java。

原理：解决了 “Classpath Hell”（类路径地狱）和 JDK 自身过于臃肿的问题。它强制规定了模块的可见性。即使是 public 类，如果模块没有 exports，外部也无法访问。这大大提升了封装性。

2.2 JDK 10/11：局部变量类型推断 (var)

特性：允许使用 var 声明局部变量。

代码：

Java

// JDK 10 之前
Map<String, List<User>> userMap = new HashMap<>();

// JDK 10 之后
var userMap = new HashMap<String, List<User>>();

注意：这纯粹是编译时语法糖。编译器在编译阶段通过右边的表达式推断出类型，并写入字节码。运行时完全没有 var 的概念，性能无损耗。

---

3. JDK 12 - 17：数据导向编程 (Data-Oriented Programming)

从 JDK 14 开始（并在 JDK 17 LTS 定型），Java 引入了一系列特性，旨在更好地建模“数据”。

3.1 Records (JDK 14 Preview, JDK 16 正式)

核心痛点：JavaBean 充斥着 getters, setters, equals, hashCode, toString 等样板代码。

代码对比：

Java

// 传统类：几十行代码
// Record：一行搞定
public record User(String name, int age) {}

深层原理：

record 不是简单的语法糖，它是一种语义声明。

1. 不可变性：编译后的类是 final 的，所有字段也是 private final 的。
2. 数据载体：它告诉编译器和阅读者，“这个类的唯一目的就是持有数据”。
3. 源码体现：编译器自动生成规范的 equals 和 hashCode，这避免了手动编写时常见的逻辑错误。

3.2 Sealed Classes (JDK 15 Preview, JDK 17 正式)

核心痛点：在以前，如果你想限制谁可以继承你的类，只能用 final（谁都不能继承）或者包级私有（只有同包能继承）。

新特性：sealed 关键字允许你精确控制继承体系。

Java

public sealed interface Shape permits Circle, Rectangle, Square {}

public final class Circle implements Shape {} // 必须声明为 final, sealed 或 non-sealed

设计哲学：这为代数数据类型 (Algebraic Data Types) 铺平了道路。编译器现在知道 Shape 只有这三种子类，这在做 switch 模式匹配时非常关键（不需要 default 分支）。

3.3 Switch Expressions (JDK 14 正式)

将 Switch 变成表达式（有返回值），并去除了易错的 break。

Java

var type = switch (obj) {
    case Integer i -> "It's an integer";
    case String s  -> "It's a string";
    default        -> "Unknown";
};

---

4. JDK 19 - 21：高并发与模式匹配革命 (Concurrency & Expressiveness)

JDK 21 是继 JDK 8 之后最重要的版本，因为它带来了 Project Loom (虚拟线程)。

4.1 Virtual Threads (虚拟线程) —— JDK 21 核心爆发点

核心痛点：Java 传统的线程（java.lang.Thread）直接包装了操作系统的内核线程（OS Thread）。

• 成本高：一个 OS 线程占用约 1MB 栈内存。
• 上下文切换开销大：在等待 I/O（如数据库查询）时，昂贵的 OS 线程被阻塞，导致资源浪费。这导致了 Reactive 编程（如 WebFlux）的兴起，但 Reactive 代码极其难写、难调试。

虚拟线程解决方案：

虚拟线程是用户态线程（类似于 Go 语言的 Goroutine），由 JVM 调度，而不是 OS 调度。

代码示例：

Java

// 像写同步代码一样写高并发
try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
    IntStream.range(0, 10_000).forEach(i -> {
        executor.submit(() -> {
            // 这里的 Thread.sleep 不会阻塞 OS 线程！
            Thread.sleep(Duration.ofSeconds(1)); 
            return i;
        });
    });
}

深层原理与源码机制：

1. M:N 调度：JVM 维护一个小的 OS 线程池（Carrier Threads，通常等于 CPU 核心数）。成千上万个虚拟线程复用这些 Carrier Threads。
2. Mounting/Unmounting (挂载/卸载)：
   • 当虚拟线程执行 CPU 密集型任务时，它被挂载在 Carrier Thread 上。
   • 当代码调用阻塞操作（如 socket.read() 或 Thread.sleep()）时，JVM 会把该虚拟线程卸载（将其栈帧保存到堆内存中），Carrier Thread 立即去执行其他虚拟线程。
3. 底层改造：JDK 重写了几乎所有的 I/O 库（java.net, java.io），使它们能感知虚拟线程。

意义：你不再需要学习复杂的 WebFlux/Netty 回调地狱。用最简单的 ServerSocket 模式，也能支撑百万级并发。

4.2 Pattern Matching (模式匹配)

JDK 21 完成了 Switch 模式匹配和 Record 模式匹配的融合。

代码示例：

Java

Object obj = new User("Alice", 30);

if (obj instanceof User(String n, int a)) {
    // 直接解构：n="Alice", a=30
    System.out.println(n);
}

// 在 Switch 中极其强大
String result = switch (obj) {
    case User(var n, var a) when a > 18 -> "Adult user: " + n;
    case User(var n, var a)             -> "Minor user: " + n;
    default -> "Not a user";
};

这使得处理复杂数据结构（如 JSON 解析、AST 树遍历）变得异常清晰。

---

5. 总结与技术选型建议

版本区间	核心关键词	关键特性	建议
JDK 8	基石	Lambda, Stream, Optional	许多老旧系统的底线，不再建议新项目使用。
JDK 11	过渡	Modules, HttpClient, var	目前很多企业的主流，但正在逐渐过时。
JDK 17	现代标准	Records, Sealed Classes, GC优化 (ZGC)	当前生产环境的首选推荐。生态支持最完善（Spring Boot 3.0+ 要求）。
JDK 21	未来已来	Virtual Threads, Pattern Matching	高并发场景必选。如果你在做网关、高吞吐服务，升级收益巨大。