JDK 版本特性演进总结

Java 从 1996 年诞生至今，已经走过了近 30 年。从最初的 Oak 语言到现在的现代化语言，Java 经历了无数次的进化。

我刚学 Java 的时候是 JDK 6，那时候觉得已经很好了。后来 JDK 8 引入了 Lambda，改变了整个 Java 的编程风格。再后来 JDK 21 的虚拟线程，更是并发编程的重大革命。

今天我们就来回顾一下 JDK 8 到 JDK 21 的重要特性。

一、JDK 8（2014年3月）——革命性的版本

1.1 Lambda 表达式

// 以前：匿名内部类
list.forEach(new Consumer<String>() {
    @Override
    public void accept(String s) {
        System.out.println(s);
    }
});

// 现在：Lambda
list.forEach(s -> System.out.println(s));

// 或者方法引用
list.forEach(System.out::println);

1.2 Stream API

List<Integer> result = list.stream()
    .filter(x -> x > 0)
    .map(x -> x * 2)
    .sorted()
    .collect(Collectors.toList());

1.3 Optional

Optional<User> user = userService.findById(1L);
String city = user
    .map(User::getAddress)
    .flatMap(Address::getCity)
    .orElse("未知");

1.4 新日期时间 API

LocalDate today = LocalDate.now();
LocalDateTime now = LocalDateTime.now();
ZonedDateTime zoned = ZonedDateTime.now(ZoneId.of("Asia/Shanghai"));

1.5 接口默认方法

public interface List<E> {
    default void sort(Comparator<? super E> c) {
        Collections.sort(this, c);
    }
}

1.6 其他重要特性

Nashorn JavaScript 引擎
Base64 编解码
ConcurrentHashMap 增强
Permutation/Combination API

二、JDK 9（2017年9月）——模块化时代

2.1 模块化系统（JPMS）

// module-info.java
module com.myapp {
    requires java.sql;
    requires transitive org.springframework.core;
    
    exports com.myapp.service;
    exports com.myapp.controller;
}

2.2 私有接口方法

public interface MyInterface {
    default void method1() {
        helper();  // 调用私有方法
    }
    
    private void helper() {
        // 私有实现
    }
}

2.3 响应式流（Reactive Streams）

public interface Publisher<T> {
    void subscribe(Subscriber<? super T> s);
}

public interface Subscriber<T> {
    void onSubscribe(Subscription s);
    void onNext(T t);
    void onError(Throwable t);
    void onComplete();
}

2.4 HTTP/2 Client

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

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

2.5 其他特性

JShell（REPL）
改进的 Stream API
Diamond Operator 扩展
@Deprecated 增强

三、JDK 10（2018年3月）——var 类型推断

3.1 局部变量类型推断

// 以前
String name = "张三";
HashMap<String, Integer> map = new HashMap<>();

// 现在：var
var name = "张三";
var map = new HashMap<String, Integer>();

3.2 其他特性

G1 成为默认 GC
Application Class-Data Sharing
线程本地握手
增强的垃圾回收接口

四、JDK 11（2018年9月）——LTS 版本

4.1 Lambda 参数的 var

// JDK 10: var 不支持 Lambda 参数
// JDK 11: 支持
list.forEach((var x) -> System.out.println(x));

4.2 ZGC（实验性）

# 启动参数
java -XX:+UnlockExperimentalVMOptions -XX:+UseZGC MyApp

4.3 HTTP Client（标准）

HttpClient client = HttpClient.newHttpClient();
// 现在是标准 API 了

4.4 其他特性

删除 Java EE 和 CORBA 模块
String 新增方法：isBlank(), lines(), strip(), repeat()
Files 新增方法：readString(), writeString()
启动单文件程序：java Hello.java

五、JDK 12-16——快速迭代期

5.1 JDK 12：Switch 表达式（预览）

// Switch 表达式
int result = switch (day) {
    case MONDAY, FRIDAY, SUNDAY -> 6;
    case TUESDAY -> 7;
    case THURSDAY, SATURDAY -> 8;
    case WEDNESDAY -> 9;
    default -> 0;
};

5.2 JDK 13：文本块（预览）

// 预览特性
String json = """
            {
                "name": "张三"
            }
            """;

5.3 JDK 14：Record（预览）

// 预览特性
public record Point(int x, int y) {}

5.4 JDK 15：密封类（预览）

// 预览特性
sealed interface Shape permits Circle, Rectangle { }

5.5 JDK 16：Record（第二预览）、模式匹配

// instanceof 模式匹配
if (obj instanceof String s) {
    System.out.println(s.length());
}

六、JDK 17（2021年9月）——LTS 版本

6.1 密封类（正式）

sealed interface Payment permits AliPay, WechatPay, CreditCard { }

6.2 文本块（正式）

String json = """
            {
                "name": "张三"
            }
            """;

6.3 Record（正式）

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

6.4 其他特性

移除 Applet API
增强的伪随机数生成器
新加密算法支持
Sealed Classes（正式）

七、JDK 18-20——预览特性积累

7.1 JDK 18：JEP 400（UTF-8 默认）

默认字符集改为 UTF-8。

7.2 JDK 19：虚拟线程（预览）

// 预览特性
try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
    executor.submit(() -> { /* ... */ });
}

7.3 JDK 20：结构化并发（预览）

// 预览特性
try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
    scope.fork(() -> task1());
    scope.fork(() -> task2());
    scope.join();
}

八、JDK 21（2023年9月）——LTS 版本

8.1 虚拟线程（正式）

// 正式特性
try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
    executor.submit(() -> { /* ... */ });
}

8.2 结构化并发（正式）

try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
    Future<String> f1 = scope.fork(() -> call1());
    Future<String> f2 = scope.fork(() -> call2());
    scope.join();
    scope.throwIfFailed();
}

8.3 Record 模式（正式）

if (obj instanceof Point(int x, int y)) {
    System.out.println(x + y);
}

8.4 Switch 模式匹配（正式）

String describe(Object obj) {
    return switch (obj) {
        case Integer i when i > 0 -> "Positive " + i;
        case String s -> "String: " + s;
        case null -> "null";
        default -> "Other";
    };
}

8.5 String Templates（预览）

// 预览特性
String name = "张三";
String greeting = STR."Hello \{name}!";

九、JDK 22-23——持续进化

9.1 JDK 22 特性

unnamed Variables & Patterns
String Templates（第二预览）
Stream Gatherers（预览）
Implicitly Declared Classes and Instance Main Methods

9.2 JDK 23 特性

Stream Gatherers（第二预览）
String Templates（第三预览）
改进的 Javadoc 注解

十、【直观类比】

【直观类比】

Java 版本演进就像一棵树：

JDK 8: 发芽 —— Lambda 让 Java 焕发新生
  │
JDK 9-10: 生根 —— 模块化让 Java 更强壮
  │
JDK 11-17: 开花 —— Preview 机制让特性稳妥
  │
JDK 21: 结果 —— 虚拟线程+结构化并发，Java 并发新纪元

十一、学习路线建议

11.1 必须掌握（JDK 8+）

特性	优先级
Lambda/Stream	必须
Optional	必须
新日期时间 API	必须
接口默认方法	必须

11.2 进阶特性（JDK 11+）

特性	优先级
var 类型推断	推荐
HTTP Client	推荐
集合新方法	推荐

11.3 新特性（JDK 17+）

特性	优先级
Record	推荐
Sealed Class	推荐
模式匹配	了解
虚拟线程	重点关注

十二、面试追问链

第一层：JDK 8 特性

面试官问："JDK 8 有哪些重要特性？"

Lambda 表达式、Stream API、Optional、新日期时间 API、接口默认方法。其中 Lambda 和 Stream 是最重要的，改变了 Java 的编程风格。

第二层：版本演进

面试官追问："JDK 8 之后，你用过哪些新特性？"

可以提到 Record、Sealed Class、虚拟线程等。根据实际经验回答。

第三层：预览特性

面试官问："什么是预览特性？"

预览特性是正式发布前的试验版本，可能会在后续版本中修改或删除。目的是收集反馈，保证正式版本的稳定性。

【学习小结】

JDK 8：Lambda、Stream、Optional、新日期 API
JDK 9：模块化、响应式流、私有接口方法
JDK 10：var 类型推断
JDK 11：Lambda 参数 var、ZGC（实验）
JDK 12-16：Switch 表达式、Record、密封类预览
JDK 17：LTS，密封类、Record、文本块正式
JDK 21：LTS，虚拟线程、结构化并发正式
预览特性 → 正式特性是 Java 的标准演进路径

#JDK 版本特性演进总结

#一、JDK 8（2014年3月）——革命性的版本

#1.1 Lambda 表达式

#1.2 Stream API

#1.3 Optional

#1.4 新日期时间 API

#1.5 接口默认方法

#1.6 其他重要特性

#二、JDK 9（2017年9月）——模块化时代

#2.1 模块化系统（JPMS）

#2.2 私有接口方法

#2.3 响应式流（Reactive Streams）

#2.4 HTTP/2 Client

#2.5 其他特性

#三、JDK 10（2018年3月）——var 类型推断

#3.1 局部变量类型推断

#3.2 其他特性

#四、JDK 11（2018年9月）——LTS 版本

#4.1 Lambda 参数的 var

#4.2 ZGC（实验性）

#4.3 HTTP Client（标准）

#4.4 其他特性

#五、JDK 12-16——快速迭代期

#5.1 JDK 12：Switch 表达式（预览）

#5.2 JDK 13：文本块（预览）

#5.3 JDK 14：Record（预览）

#5.4 JDK 15：密封类（预览）

#5.5 JDK 16：Record（第二预览）、模式匹配

#六、JDK 17（2021年9月）——LTS 版本

#6.1 密封类（正式）

#6.2 文本块（正式）

#6.3 Record（正式）

#6.4 其他特性

#七、JDK 18-20——预览特性积累

#7.1 JDK 18：JEP 400（UTF-8 默认）

#7.2 JDK 19：虚拟线程（预览）

#7.3 JDK 20：结构化并发（预览）

#八、JDK 21（2023年9月）——LTS 版本

#8.1 虚拟线程（正式）

#8.2 结构化并发（正式）

#8.3 Record 模式（正式）

#8.4 Switch 模式匹配（正式）

#8.5 String Templates（预览）

#九、JDK 22-23——持续进化

#9.1 JDK 22 特性

#9.2 JDK 23 特性

#十、【直观类比】

#十一、学习路线建议

#11.1 必须掌握（JDK 8+）

#11.2 进阶特性（JDK 11+）

#11.3 新特性（JDK 17+）

#十二、面试追问链

#第一层：JDK 8 特性

#第二层：版本演进

#第三层：预览特性