JDK 8 到 JDK 21 新特性知识要点

整合时间：2026/8/6

LTS 版本：Java 8（2014）、Java 11（2018）、Java 17（2021）、Java 21（2023）

发布节奏：6个月一个功能版，3年一个LTS版

文章目录

[JDK 8 到 JDK 21 新特性知识要点](#JDK 8 到 JDK 21 新特性知识要点)
- 核心知识点速查表
- [一、JDK 8（2014，LTS）--- 函数式编程革命](#一、JDK 8（2014，LTS）— 函数式编程革命)
- - [1. Lambda 表达式](#1. Lambda 表达式)
  - [2. Stream API](#2. Stream API)
  - [3. Optional 类](#3. Optional 类)
  - [4. 新日期时间 API（java.time）](#4. 新日期时间 API（java.time）)
  - [5. 接口默认方法与静态方法](#5. 接口默认方法与静态方法)
- [二、JDK 9（2017）--- 模块化系统](#二、JDK 9（2017）— 模块化系统)
- - [1. 模块化系统（JPMS）](#1. 模块化系统（JPMS）)
  - [2. 集合工厂方法](#2. 集合工厂方法)
  - [3. JShell](#3. JShell)
- [三、JDK 10（2018）--- var 类型推断](#三、JDK 10（2018）— var 类型推断)
- - [1. 局部变量类型推断](#1. 局部变量类型推断)
- [四、JDK 11（2018，LTS）--- 现代化基础](#四、JDK 11（2018，LTS）— 现代化基础)
- - [1. HTTP Client（标准化）](#1. HTTP Client（标准化）)
  - [2. 字符串新方法](#2. 字符串新方法)
  - [3. 单文件源码运行](#3. 单文件源码运行)
  - [4. ZGC（低延迟垃圾收集器）](#4. ZGC（低延迟垃圾收集器）)
- [五、JDK 12-13（2019）--- Switch 与文本块](#五、JDK 12-13（2019）— Switch 与文本块)
- - [1. Switch 表达式](#1. Switch 表达式)
  - [2. 文本块](#2. 文本块)
- [六、JDK 14-16（2020-2021）--- Record 与模式匹配](#六、JDK 14-16（2020-2021）— Record 与模式匹配)
- - [1. Record 类](#1. Record 类)
  - [2. instanceof 模式匹配](#2. instanceof 模式匹配)
  - [3. 更有用的 NullPointerException](#3. 更有用的 NullPointerException)
- [七、JDK 17（2021，LTS）--- 密封类与模式匹配](#七、JDK 17（2021，LTS）— 密封类与模式匹配)
- - [1. 密封类（Sealed Classes）](#1. 密封类（Sealed Classes）)
  - [2. 模式匹配 Switch](#2. 模式匹配 Switch)
- [八、JDK 18（2022）--- UTF-8 默认](#八、JDK 18（2022）— UTF-8 默认)
- - [1. UTF-8 成为默认字符集](#1. UTF-8 成为默认字符集)
  - [2. jwebserver](#2. jwebserver)
- [九、JDK 19-21（2022-2023）--- 虚拟线程革命](#九、JDK 19-21（2022-2023）— 虚拟线程革命)
- - [1. 虚拟线程（Virtual Threads）](#1. 虚拟线程（Virtual Threads）)
  - [2. Record 模式](#2. Record 模式)
  - [3. 序列集合（Sequenced Collections）](#3. 序列集合（Sequenced Collections）)
  - [4. 结构化并发](#4. 结构化并发)
  - [5. 作用域值（Scoped Values）](#5. 作用域值（Scoped Values）)
- 升级建议
- - 升级路径
  - 升级检查清单
  - 性能提升预期
  - [LTS 支持周期](#LTS 支持周期)
- 快速参考卡片
- - 虚拟线程使用场景
  - [Record 使用注意](#Record 使用注意)
  - 模式匹配优势

核心知识点速查表

版本	核心特性	重要性	状态
JDK 8	Lambda、Stream、Optional、java.time	⭐⭐⭐⭐⭐	LTS
JDK 9	模块化系统(JPMS)、JShell	⭐⭐⭐
JDK 10	var 局部变量推断	⭐⭐
JDK 11	HTTP Client、字符串增强、ZGC	⭐⭐⭐⭐	LTS
JDK 12	Switch 表达式（预览）	⭐⭐⭐
JDK 13	文本块（预览）	⭐⭐⭐
JDK 14	Record、instanceof 模式匹配（预览）	⭐⭐⭐⭐
JDK 15	密封类（预览）	⭐⭐⭐
JDK 16	Record/instanceof 正式版	⭐⭐⭐
JDK 17	密封类正式版、模式匹配 Switch	⭐⭐⭐⭐	LTS
JDK 18	UTF-8 默认、jwebserver	⭐⭐
JDK 19	虚拟线程（预览）	⭐⭐⭐⭐⭐
JDK 20	预览特性迭代	⭐⭐
JDK 21	虚拟线程正式版、序列集合、分代ZGC	⭐⭐⭐⭐⭐	LTS

一、JDK 8（2014，LTS）--- 函数式编程革命

1. Lambda 表达式

要点：函数作为一等公民，配合函数式接口使用，代码量减少60%+

java 复制代码

// 传统匿名类 vs Lambda
Runnable r1 = new Runnable() {
    @Override
    public void run() {
        System.out.println("Hello");
    }
};
Runnable r2 = () -> System.out.println("Hello");

// 带参数的 Lambda
List<String> list = Arrays.asList("a", "ab", "abc");
list.sort((s1, s2) -> s1.length() - s2.length());

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

2. Stream API

要点：声明式集合操作，支持惰性求值和并行流

java 复制代码

List<String> result = list.stream()
    .filter(s -> s.length() > 2)    // 中间操作
    .map(String::toUpperCase)        // 中间操作
    .collect(Collectors.toList());   // 终止操作

// 并行流
list.parallelStream().forEach(...);

3. Optional 类

要点：避免 NullPointerException，优雅处理空值

java 复制代码

Optional<String> opt = Optional.ofNullable(getValue());
opt.ifPresent(System.out::println);
String result = opt.orElse("默认值");

// 链式调用
String city = Optional.ofNullable(user)
    .map(User::getAddress)
    .map(Address::getCity)
    .orElse("Unknown");

4. 新日期时间 API（java.time）

要点：线程安全、不可变，替代 Date/Calendar

java 复制代码

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

// 格式化
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm");
String str = now.format(formatter);

5. 接口默认方法与静态方法

要点：便于接口演进，不破坏现有实现

java 复制代码

interface MyInterface {
    default void defaultMethod() {
        System.out.println("默认实现");
    }
    static void staticMethod() {
        System.out.println("静态方法");
    }
}

二、JDK 9（2017）--- 模块化系统

1. 模块化系统（JPMS）

要点：解决"类路径地狱"，强封装和显式依赖

java 复制代码

// module-info.java
module com.example.service {
    requires java.base;
    requires com.example.api;
    exports com.example.service;
    opens com.example.service.internal;
}

2. 集合工厂方法

要点：创建不可变集合的简洁方式

java 复制代码

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

3. JShell

要点：REPL 工具，快速验证代码片段

bash 复制代码

jshell
jshell> int sum = 1 + 2
sum ==> 3

三、JDK 10（2018）--- var 类型推断

1. 局部变量类型推断

要点：编译器推断类型，仅用于局部变量

java 复制代码

var list = new ArrayList<String>();  // 推断为 ArrayList<String>
var str = "Hello";                    // 推断为 String

// 注意：必须初始化，不能用于字段、方法参数
// var x;  // 编译错误

四、JDK 11（2018，LTS）--- 现代化基础

1. HTTP Client（标准化）

要点：支持 HTTP/2、同步/异步调用

java 复制代码

HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("https://api.example.com/data"))
    .timeout(Duration.ofSeconds(10))
    .GET()
    .build();

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

// 异步
client.sendAsync(request, HttpResponse.BodyHandlers.ofString())
    .thenApply(HttpResponse::body)
    .join();

2. 字符串新方法

要点：isBlank()、lines()、strip()、repeat()

java 复制代码

String str = "  Hello  ";
str.isBlank();      // false
str.strip();        // "Hello"
str.repeat(3);      // "HelloHelloHello"
str.lines().forEach(System.out::println);

3. 单文件源码运行

要点：可直接运行 .java 文件，无需显式编译

bash 复制代码

java HelloWorld.java

4. ZGC（低延迟垃圾收集器）

要点：亚毫秒级 GC 停顿

五、JDK 12-13（2019）--- Switch 与文本块

1. Switch 表达式

要点：Switch 作为表达式，使用 -> 无需 break

java 复制代码

String result = switch (day) {
    case MONDAY, FRIDAY -> "工作日";
    case SATURDAY, SUNDAY -> "周末";
    default -> "未知";
};

// yield 返回值
String result = switch (day) {
    case MONDAY -> "工作日";
    default -> {
        yield "未知";
    }
};

2. 文本块

要点：三引号定义多行字符串

java 复制代码

String json = """
    {
      "name": "John",
      "age": 30
    }
    """;

String sql = """
    SELECT id, name
    FROM users
    WHERE age > 18
    """;

六、JDK 14-16（2020-2021）--- Record 与模式匹配

1. Record 类

要点：透明数据载体，自动生成构造器、equals、hashCode、toString

java 复制代码

record Point(int x, int y) {}

var p = new Point(3, 5);
System.out.println(p.x());     // 3
System.out.println(p);         // Point[x=3, y=5]

// 带方法的 Record
record Point(int x, int y) {
    public double distance() {
        return Math.sqrt(x * x + y * y);
    }
}

2. instanceof 模式匹配

要点：判断同时完成类型转换和变量绑定

java 复制代码

// 传统写法
if (obj instanceof String) {
    String s = (String) obj;
    System.out.println(s.length());
}

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

// 与条件结合
if (obj instanceof String s && s.length() > 5) {
    System.out.println(s.substring(0, 5));
}

3. 更有用的 NullPointerException

要点：明确指出哪个变量为 null

java 复制代码

// Java 14+: NullPointerException: Cannot invoke "a.b()" because "a" is null
a.b().c();

七、JDK 17（2021，LTS）--- 密封类与模式匹配

1. 密封类（Sealed Classes）

要点：限制继承范围，精确控制类型边界

java 复制代码

sealed class Shape permits Circle, Rectangle, Triangle {}
final class Circle extends Shape {}
final class Rectangle extends Shape {}
non-sealed class Triangle extends Shape {}  // 允许任意继承

2. 模式匹配 Switch

要点：Switch 支持类型模式匹配

java 复制代码

String formatted = switch (obj) {
    case Integer i -> String.format("int %d", i);
    case Long l -> String.format("long %d", l);
    case Double d -> String.format("double %f", d);
    case String s -> String.format("String %s", s);
    case null -> "null";
    default -> obj.toString();
};

八、JDK 18（2022）--- UTF-8 默认

1. UTF-8 成为默认字符集

要点：标准 Java API 默认使用 UTF-8

java 复制代码

// 无需再指定 Charset
new InputStreamReader(inputStream);  // 默认 UTF-8

2. jwebserver

要点：简单的静态文件服务器

bash 复制代码

jwebserver -p 8080 -d ./static

九、JDK 19-21（2022-2023）--- 虚拟线程革命

1. 虚拟线程（Virtual Threads）

要点：JVM 管理的轻量级线程（~4KB），M:N 调度，百万级并发

java 复制代码

// 方式一：直接创建
Thread.startVirtualThread(() -> {
    System.out.println("Virtual thread running");
});

// 方式二：虚拟线程池（推荐）
try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
    for (int i = 0; i < 100_000; i++) {
        executor.submit(() -> {
            Thread.sleep(Duration.ofSeconds(1));
            return i;
        });
    }
}

// 方式三：Thread.Builder
Thread thread = Thread.ofVirtual()
    .name("vt-1")
    .start(() -> System.out.println("Hello"));

生产注意：JDK 21 中 synchronized 块内的 I/O 会导致 pinning，建议改用 ReentrantLock。

2. Record 模式

要点：解构 Record 对象

java 复制代码

record Point(int x, int y) {}
record Line(Point start, Point end) {}

if (obj instanceof Line(Point(var x1, var y1), Point(var x2, var y2))) {
    System.out.println("起点: (" + x1 + "," + y1 + ")");
}

// Switch 中解构（守卫模式）
String result = switch (point) {
    case Point(int x, 0) -> "On x-axis at " + x;
    case Point(0, int y) -> "On y-axis at " + y;
    case Point(int x, int y) when x == y -> "On diagonal";
    case Point(int x, int y) -> "At (" + x + "," + y + ")";
};

3. 序列集合（Sequenced Collections）

要点：统一有序集合的首尾操作

java 复制代码

SequencedCollection<String> list = new ArrayList<>(List.of("a", "b", "c"));
String first = list.getFirst();   // "a"
String last = list.getLast();     // "c"
list.addFirst("z");               // [z, a, b, c]
list.addLast("d");                // [z, a, b, c, d]

SequencedMap<String, Integer> map = new LinkedHashMap<>();
Map.Entry<String, Integer> firstEntry = map.firstEntry();
Map.Entry<String, Integer> lastEntry = map.lastEntry();

4. 结构化并发

要点：绑定并发子任务的生命周期到代码块

java 复制代码

try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
    Future<String> user = scope.fork(() -> fetchUser());
    Future<Integer> order = scope.fork(() -> fetchOrder());
    
    scope.join();            // 等待所有子任务
    scope.throwIfFailed();   // 任一失败则抛出异常
    
    System.out.println("User: " + user.resultNow());
}

5. 作用域值（Scoped Values）

要点：线程间共享不可变数据，替代 ThreadLocal

java 复制代码

private static final ScopedValue<String> USER_ID = ScopedValue.newInstance();

ScopedValue.where(USER_ID, "user-123")
    .run(() -> {
        System.out.println(USER_ID.get());  // "user-123"
    });

升级建议

升级路径

当前版本	推荐目标	核心收益	迁移成本
JDK 8	JDK 17	Record、密封类、模式匹配、ZGC	中
JDK 8	JDK 21	虚拟线程、序列集合、分代ZGC	中高
JDK 11	JDK 17	语法现代化、GC 性能提升	低
JDK 17	JDK 21	虚拟线程（高并发质变）	低

升级检查清单

bash 复制代码

# 1. 检查内部 API 依赖
jdeps --jdk-internals your-app.jar

# 2. 关键替换项
sun.misc.BASE64Encoder → java.util.Base64
sun.misc.Unsafe → 寻找替代方案
Nashorn → GraalVM JS（JDK 15+ 已移除）

# 3. 兼容性参数（如需）
--add-opens java.base/java.lang=ALL-UNNAMED

性能提升预期

代码量：平均减少 30% 以上
GC 停顿：从数百毫秒降至亚毫秒级
峰值吞吐：同硬件下提升最高可达 40%
并发能力：虚拟线程支持百万级并发

LTS 支持周期

JDK 8：已终止免费更新
JDK 11：支持至 2026 年
JDK 17：支持至 2029 年
JDK 21：支持至 2031 年

快速参考卡片

虚拟线程使用场景

✅ I/O 密集型任务（数据库、HTTP 调用）

✅ 大量并发请求处理

❌ CPU 密集型计算（用 ForkJoinPool）

Record 使用注意

✅ 不可变数据载体

✅ 短生命周期对象

❌ 需要可变字段的场景

模式匹配优势

✅ 减少类型转换代码

✅ 编译器穷举检查

✅ 配合密封类实现完整覆盖