从 8 到 25，Java 改了什么、为什么改

是什么

lambda 是一段能当参数传的代码；Stream 是对一批数据的流水线操作：过滤、转换、排序、汇总，一步接一步写下去。

以前

传个行为要写匿名内部类；集合处理全靠手写循环

List<String> adults = users.stream()
    .filter(u -> u.getAge() >= 18)      // lambda：判断条件当参数传进去
    .map(User::getName)                 // 方法引用，等价于 u -> u.getName()
    .sorted()
    .collect(Collectors.toList());

是什么

让编译器按等号右边推断局部变量的类型。变量仍然是静态类型，只是不用你手写。

以前

Map<String, List<Order>> m = new HashMap<>() 类型写两遍

var map = new HashMap<String, List<Order>>();   // 类型就是 HashMap<String, List<Order>>
for (var e : map.entrySet()) { ... }
// var x;           编译不过：必须有初始值
// var n = null;    编译不过：推断不出类型
// 字段、方法参数、返回值都不能用 var

是什么

NullPointerException 的消息里直接写出是哪个表达式为 null，不用再一段段加日志猜。

以前

a.b().c().d() 报 NPE，不知道哪个是 null

String city = order.getUser().getAddress().getCity();
// 以前：java.lang.NullPointerException
// 现在：Cannot invoke "Address.getCity()" because
//       the return value of "User.getAddress()" is null

是什么

switch 可以当表达式返回一个值；case X -> 只执行这一个分支，不会穿透到下一个。

以前

忘写 break 就穿透到下一个 case；switch 不能返回值

int days = switch (month) {
    case FEBRUARY -> 28;
    case APRIL, JUNE, SEPTEMBER, NOVEMBER -> 30;
    default -> {
        log.debug("31 天");
        yield 31;                  // 分支里写多行时，用 yield 返回值
    }
};

是什么

用三个双引号包起来的多行字符串，换行和引号原样保留，公共的缩进会自动去掉。

以前

多行 SQL、JSON 要拼字符串、加 \n 和转义

String sql = """
    SELECT id, name
    FROM orders
    WHERE status = ?
    """;                           // 结束的 """ 放在哪一列，决定去掉多少缩进
String json = """
    {"name": "%s"}
    """.formatted(name);

是什么

一种专门装数据的类：声明一行字段，编译器自动生成构造器、访问器、equals、hashCode、toString。字段都是 final，对象不可变。

以前

数据类要手写或靠 Lombok 生成 equals、hashCode、toString

record Point(int x, int y) {
    Point {                                    // 紧凑构造器：只写校验
        if (x < 0) throw new IllegalArgumentException("x < 0");
    }
}
var p = new Point(1, 2);
p.x();                                 // 访问器叫 x()，不是 getX()
p.equals(new Point(1, 2));             // true

是什么

instanceof 判断成功时，顺便声明一个已经转好类型的变量。

以前

if (o instanceof A) { A a = (A) o; … } 判断完还要强转

if (obj instanceof String s && !s.isEmpty()) {
    System.out.println(s.length());    // s 已经是 String，不用强转
}

是什么

在类或接口上列出“只允许这几个子类”。别人不能再随便继承，编译器也就知道一共有几种情况。

以前

没法规定“这个接口只有这几种实现”

public sealed interface Shape permits Circle, Square {}
public record Circle(double r) implements Shape {}
public record Square(double side) implements Shape {}
// 子类必须是 final、sealed 或 non-sealed 三者之一；record 默认就是 final

是什么

switch 的 case 可以写类型、可以把 record 拆开取字段、可以加 when 条件；对 sealed 类型，漏掉一种情况就编译不过。

以前

按类型分支要写一串 if-else instanceof，漏一种没人提醒

double area(Shape s) {
    return switch (s) {
        case Circle(double r) -> Math.PI * r * r;     // 拆开 record 直接拿字段
        case Square(double side) -> side * side;
    };                                                // 不用 default
}
String desc = switch (obj) {
    case null -> "空";                                // switch 也能处理 null 了
    case Integer i when i > 0 -> "正整数";
    case Integer i -> "整数";
    default -> "其他";
};

是什么

用下划线 _ 表示“这个变量我不用”，不用再硬起一个名字。

以前

catch (Exception e)、解构时用不到的变量也得起名

try { return Integer.parseInt(s); }
catch (NumberFormatException _) { return 0; }

map.computeIfAbsent(key, _ -> new ArrayList<>());
if (obj instanceof Point(var x, _)) { ... }      // 只关心 x

是什么

javadoc 可以用 /// 开头直接写 Markdown，不用再写 HTML 标签。

以前

javadoc 里要手写 HTML 标签

/// 计算订单总价。
///
/// - 单位是**分**
/// - 优惠见 [Order#discount()]
long total(Order order) { ... }

是什么

构造器里，super(…) 或 this(…) 之前可以先写语句，比如校验参数；只是这时还不能使用 this。

以前

super(…) 必须是第一句，参数校验只能塞进静态辅助方法

class PositiveRange extends Range {
    PositiveRange(int lo, int hi) {
        if (lo < 0) throw new IllegalArgumentException("lo < 0");   // 25：先校验
        super(lo, hi);                                                // 再调父类构造器
    }
}

是什么

写小程序可以不声明类、不写 static，直接一个 void main()；import module 一行导入一个模块导出的所有包。

以前

写个几行的小工具也要 public class、public static void main(String[] args) 和一串 import

// Hello.java，直接 java Hello.java 运行
void main() {
    IO.println(List.of("a", "b"));    // 紧凑源文件自动导入 java.base 模块
}

// 普通类里：
import module java.sql;               // 等于导入 java.sql 模块导出的所有包

是什么

一套新的日期时间 API：日期、时间、带时区的时间、时长分开建模，对象都不可变、线程安全。

以前

Date 可变、SimpleDateFormat 线程不安全、月份从 0 开始

LocalDate d = LocalDate.of(2026, 11, 7);                  // 月份从 1 开始
LocalDateTime t = LocalDateTime.now().plusDays(3);
static final DateTimeFormatter FMT = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm");
String s = t.format(FMT);                                  // 格式器线程安全，可以做常量
Duration cost = Duration.between(start, Instant.now());

是什么

一个“可能有值、也可能没有”的盒子，用来做返回值，提醒调用方处理“没有”的情况。

以前

方法返回 null 表示“没有”，调用方忘了判断就 NPE

Optional<User> u = userRepo.findById(id);
String name = u.map(User::getName).orElse("匿名");
User must = u.orElseThrow(() -> new NotFoundException(id));
// 不建议用作字段和方法参数

是什么

一行创建不可变集合。创建后不能增删，也不允许 null 元素。

以前

Collections.unmodifiableList(Arrays.asList(…))

var ids = List.of(1, 2, 3);           // ids.add(4) 抛 UnsupportedOperationException
var m = Map.of("a", 1, "b", 2);       // 最多 10 对，再多用 Map.ofEntries
var copy = List.copyOf(mutableList);  // 10 起：拿一份不可变副本
// List.of(1, null) 抛 NullPointerException

是什么

JDK 自带的 HTTP 客户端，支持 HTTP/2（26 起还支持 HTTP/3）、同步和异步调用。

以前

HttpURLConnection 难用、不支持 HTTP/2，只好引 Apache HttpClient

var client = HttpClient.newBuilder()
        .connectTimeout(Duration.ofSeconds(2)).build();      // 客户端全局复用一个
var req = HttpRequest.newBuilder(URI.create("https://example.com/api"))
        .timeout(Duration.ofSeconds(3)).GET().build();
HttpResponse<String> resp = client.send(req, HttpResponse.BodyHandlers.ofString());
client.sendAsync(req, HttpResponse.BodyHandlers.ofString())
      .thenApply(HttpResponse::body);                      // 异步版本

是什么

String 补了几个天天要用的方法，以前多半靠 Apache Commons 或 Guava。

以前

判空白、去空白、重复、按行拆分都要靠工具类

"  ".isBlank();          // true：只有空白字符
" a ".strip();          // "a"：和 trim 不同，能识别全角空格等 Unicode 空白
"ab".repeat(3);         // "ababab"
text.lines().count();   // 按行拆成 Stream

是什么

Stream 直接收集成一个不可修改的 List。

以前

.collect(Collectors.toList())

List<String> names = users.stream().map(User::getName).toList();
// 和 collect(Collectors.toList()) 的区别：返回的 List 不能 add / remove

是什么

给“有顺序”的集合（List、Deque、LinkedHashSet、LinkedHashMap 等）一套统一的首尾操作。

以前

取最后一个元素：List 要 get(size()-1)，Deque 有 getLast，LinkedHashSet 没办法

List<Integer> list = new ArrayList<>(List.of(1, 2, 3));
list.getFirst();        // 1
list.getLast();         // 3，以前要 list.get(list.size() - 1)
list.reversed();        // 反序视图 [3, 2, 1]
linkedHashSet.getLast();                 // 以前只能遍历到最后
linkedHashMap.firstEntry();              // SequencedMap：首尾的键值对

是什么

Foreign Function & Memory API：不写 C 代码，直接从 Java 调本地库的函数，并安全地分配、释放堆外内存。

以前

调本地库要写 JNI 的 C 胶水代码，堆外内存只能靠 ByteBuffer 或 Unsafe

Linker linker = Linker.nativeLinker();
MethodHandle strlen = linker.downcallHandle(
        linker.defaultLookup().find("strlen").orElseThrow(),
        FunctionDescriptor.of(ValueLayout.JAVA_LONG, ValueLayout.ADDRESS));
try (Arena arena = Arena.ofConfined()) {
    MemorySegment s = arena.allocateFrom("Hello");   // 堆外内存，离开 try 自动释放
    long len = (long) strlen.invokeExact(s);         // 5
}

是什么

gather(…) 是可以自定义的中间操作。JDK 先内置了分批、滑动窗口、累加这几种常用的。

以前

Stream 的中间操作就那几个，按 100 个一批、滑动窗口只能自己写循环或 Collector

Stream.of(1, 2, 3, 4, 5).gather(Gatherers.windowFixed(2)).toList();
// [[1, 2], [3, 4], [5]]          每 2 个一批
Stream.of(1, 2, 3, 4).gather(Gatherers.windowSliding(2)).toList();
// [[1, 2], [2, 3], [3, 4]]       滑动窗口
Stream.of(1, 2, 3).gather(Gatherers.scan(() -> 0, Integer::sum)).toList();
// [1, 3, 6]                      逐个累加

是什么

JDK 自带的读、写、改 class 文件的 API（包名 java.lang.classfile），给字节码框架用，业务代码一般用不到。

以前

框架各自带一份 ASM，JDK 一升 class 文件版本号，旧 ASM 就读不了

ClassModel cm = ClassFile.of().parse(Files.readAllBytes(Path.of("Foo.class")));
for (MethodModel m : cm.methods()) {
    System.out.println(m.methodName().stringValue());   // 列出所有方法名
}

是什么

新的公钥算法 ML-KEM、ML-DSA（24）能抵抗量子计算机；KDF API（25）用来从一个主密钥派生出多把密钥。

以前

现有的公钥算法将来可能被量子计算机破解

KeyPairGenerator g = KeyPairGenerator.getInstance("ML-KEM");   // 24
KeyPair kp = g.generateKeyPair();

KDF hkdf = KDF.getInstance("HKDF-SHA256");                       // 25
SecretKey key = hkdf.deriveKey("AES",
        HKDFParameterSpec.ofExtract().addIKM(ikm).addSalt(salt).thenExpand(info, 32));

是什么

一个“将来会有结果”的对象，可以在结果出来后接着处理、和别的结果合并、统一处理异常，不用阻塞等。

以前

Future.get() 只能阻塞等，没法组合

var user = CompletableFuture.supplyAsync(() -> userApi.get(id), pool);
var orders = CompletableFuture.supplyAsync(() -> orderApi.list(id), pool);
CompletableFuture<Page> page = user
        .thenCombine(orders, Page::new)        // 两个都回来再合并
        .orTimeout(2, TimeUnit.SECONDS)        // 9 起有超时
        .exceptionally(e -> Page.empty());     // 出错给个兜底

是什么

由 JVM 调度的轻量线程，创建几百万个也没问题；遇到阻塞 IO 时自动让出底层的平台线程。写法和普通线程一样。

以前

一个请求占一个平台线程，线程贵，并发上不去；改响应式又难写难调

Thread.startVirtualThread(() -> handle(request));

try (var exec = Executors.newVirtualThreadPerTaskExecutor()) {   // 每个任务一个虚拟线程
    for (var id : ids) exec.submit(() -> callApi(id));
}                                                                 // 退出时等任务做完

// Spring Boot 3.2+：spring.threads.virtual.enabled=true

是什么

虚拟线程在 synchronized 块里阻塞时，也能从载体线程上卸下来。不用改代码，升到 24 以上就生效。

以前

21 里虚拟线程在 synchronized 中阻塞会占住载体线程，高峰时可能全卡住

synchronized (lock) {
    rs = stmt.executeQuery();   // 21：阻塞时钉住载体线程；24 起会被卸载
}
// 在 21 上排查钉住：-Djdk.tracePinnedThreads=full，或 JFR 事件 jdk.VirtualThreadPinned

是什么

在一段作用域里绑定一个只读的值，调用链上任何地方都能读到；离开作用域自动失效。用来代替 ThreadLocal 传请求上下文。

以前

ThreadLocal 谁都能改、要记得 remove；百万虚拟线程各存一份，子线程继承还要整份复制

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

ScopedValue.where(TENANT, "t-1").run(() -> service.handle());

// 调用链任意深处：
String t = TENANT.get();        // "t-1"；不在 run 里会抛 NoSuchElementException
TENANT.isBound();               // 先判断有没有绑定

是什么

把一组并发子任务当成一个整体：一起开始、一起结束，一个失败其余自动取消。25 还是预览，要加 --enable-preview，每个版本的 API 都可能变。

以前

并发起几个子任务，一个失败了其余的没人取消，线程转储里也看不出父子关系

// 25 的预览写法
try (var scope = StructuredTaskScope.open()) {
    var user = scope.fork(() -> findUser(id));
    var orders = scope.fork(() -> findOrders(id));
    scope.join();              // 任一失败：其余自动取消，join 抛异常
    return new Page(user.get(), orders.get());
}

是什么

类的元数据（类名、方法、字段等）放在本地内存里的元空间，取代了以前在堆里、大小固定的永久代。

以前

永久代大小难估，动不动 OutOfMemoryError: PermGen space

-XX:MaxMetaspaceSize=256m      # 默认不设上限，类加载泄漏时建议设一个
-XX:MaxPermSize=256m           # 8 起无效，只打警告，可以删了

是什么

G1 把堆切成很多小块（Region），每次挑垃圾最多的几块回收，尽量满足设定的停顿目标。

以前

8 默认 Parallel GC，吞吐高但大堆停顿长

-XX:+UseG1GC                  # 9 起不写也是它
-XX:MaxGCPauseMillis=200      # 停顿目标，默认 200 ms
-Xlog:gc*:file=gc.log:time,uptime   # 9 起的统一 GC 日志

是什么

String 内部的数组按内容选编码：全是拉丁字符时每个字符 1 字节，有中文等字符时 2 字节。对代码透明。

以前

String 内部是 char[]，每个字符 2 字节，而多数字符串只有拉丁字符

// 不用改代码，自动生效
-XX:-CompactStrings            # 需要时可以关掉，一般不用

是什么

JVM 读取容器（cgroup）的 CPU 和内存限制，按容器的规格而不是宿主机的规格来算默认堆大小和线程数。

以前

JVM 在 Docker 里按宿主机的内存和 CPU 算堆大小和线程数，容易被杀

-XX:MaxRAMPercentage=75.0      # 堆最多占容器内存的 75%，比写死 -Xmx 灵活
-XX:ActiveProcessorCount=2      # 需要时手动指定 JVM 看到的 CPU 数

是什么

把类加载、解析好的数据存成归档文件，下次启动直接映射进内存，省掉重复的解析和校验。

以前

每次启动都重新解析、校验同样的类

# 13 起：跑一次，退出时生成归档
java -XX:ArchiveClassesAtExit=app.jsa -jar app.jar
# 之后启动带上它
java -XX:SharedArchiveFile=app.jsa -jar app.jar

是什么

CMS 是一个以低停顿为目标、但不整理内存的老 GC，14 起从 JDK 里删除。

以前

CMS 不整理内存，碎片多了退化成长时间 Full GC，维护成本高

# 8 上的老参数，15 起会让 JVM 起不来：
# -XX:+UseConcMarkSweepGC -XX:CMSInitiatingOccupancyFraction=70
# 删掉，用默认的 G1；对停顿要求极高的再试 ZGC

是什么

ZGC 几乎所有回收工作都和业务线程并发进行，停顿通常不到 1 毫秒；分代版把新对象和老对象分开回收，吞吐更好。

以前

堆越大，停顿越长

-XX:+UseZGC                     # 15 起可用于生产
-XX:+UseZGC -XX:+ZGenerational  # 21 要用分代版得这样写
-Xmx16g                         # ZGC 主要靠堆大小调，堆要给够

是什么

从 23 起 ZGC 默认就是分代的，24 起不分代的模式被删掉，只剩一种 ZGC。

以前

同时维护两种 ZGC

-XX:+UseZGC                     # 23 起直接就是分代的
# -XX:-ZGenerational            24 起只打警告并被忽略

是什么

先用典型流量“训练”跑一次，把加载、链接好的类和方法的运行画像存成缓存文件，之后启动直接用，启动和预热都更快。

以前

Spring Boot 这类应用启动要加载、链接几千个类，刚启动还要慢慢预热

# 25：一步完成训练并生成缓存（JEP 514）
java -XX:AOTCacheOutput=app.aot -jar app.jar     # 跑一遍典型请求后退出
java -XX:AOTCache=app.aot -jar app.jar           # 之后带着缓存启动
# 24 要分 -XX:AOTMode=record 和 -XX:AOTMode=create 两步

是什么

把每个对象的对象头从通常的 12 字节压到 8 字节，小对象越多，省下的堆越多。

以前

64 位 JVM 上对象头通常 12 字节，小对象里头的占比很大

-XX:+UseCompactObjectHeaders    # 25 要手动打开
-XX:-UseCompactObjectHeaders    # 27 起默认打开，需要时用这个关掉

是什么

Shenandoah 是另一种低停顿 GC（Oracle 自家构建不带，Temurin 等发行版带）；25 起它的分代模式也转为正式特性。

以前

Shenandoah 只有不分代模式

-XX:+UseShenandoahGC -XX:ShenandoahGCMode=generational

是什么

模块是比包大一级的单元：在 module-info.java 里声明依赖哪些模块、对外公开哪些包，没公开的包别的模块用不了。

以前

JDK 是一整块 rt.jar，sun.* 内部类被到处直接用，JDK 想改内部都怕打坏别人

// module-info.java
module com.shop.order {
    requires java.sql;
    exports com.shop.order.api;      // 只有这个包对外可见
}
// 大多数 Spring Boot 应用不写 module-info，跑在“未命名模块”里，照样能用

jlink --add-modules java.base,java.sql --output myjre   # 裁出一个小运行时

是什么

JAXB、JAX-WS、javax.annotation 等原本属于 Java EE 的模块，11 起不再随 JDK 提供，要自己加依赖。

以前

JAXB、JAX-WS 等属于 Java EE，跟着 JDK 发版太慢

<dependency>
    <groupId>jakarta.xml.bind</groupId>
    <artifactId>jakarta.xml.bind-api</artifactId>
</dependency>
<dependency>
    <groupId>org.glassfish.jaxb</groupId>
    <artifactId>jaxb-runtime</artifactId>
</dependency>

是什么

JDK 内置的 JavaScript 引擎 Nashorn 在 15 被删除，需要的话改用独立发布的版本。

以前

内置 JavaScript 引擎跟不上 JS 标准，维护成本高

<dependency>
    <groupId>org.openjdk.nashorn</groupId>
    <artifactId>nashorn-core</artifactId>
</dependency>
// 用法不变：new ScriptEngineManager().getEngineByName("nashorn")

是什么

JDK 内部的包默认不再对反射开放：不能再用 setAccessible(true) 去改 JDK 类的私有字段。

以前

框架靠反射随便改 JDK 内部字段，JDK 一改实现就崩

# 过渡期：只对某个包放开
--add-opens java.base/java.lang=ALL-UNNAMED
# 先用 jdeps 找出谁在用 JDK 内部 API
jdeps --jdk-internals app.jar

是什么

SecurityManager 是早年为 Applet 设计的沙箱机制，17 标记为将要删除。

以前

很少有人用，却拖累 JDK 每处权限检查的维护

// 17：调用时打警告
System.setSecurityManager(new MySecurityManager());
// 18～23：默认抛异常，-Djava.security.manager=allow 还能打开
// 24 起：永远抛 UnsupportedOperationException

是什么

不指定编码的 API（FileReader、String.getBytes() 等）默认一律用 UTF-8，不再跟操作系统走。

以前

不写编码时用操作系统默认编码，同一个程序在中文 Windows 和 Linux 上结果不同

new FileReader(file);                            // 8：系统默认编码；18 起：UTF-8
new FileReader(file, StandardCharsets.UTF_8);    // 11 起有这个构造器，显式写最稳
Files.readString(path);                          // 11 起，本来就是 UTF-8
// 需要旧行为：-Dfile.encoding=COMPAT

是什么

运行中通过 attach 往 JVM 里加载 agent 会打警告，将来会默认禁止；启动时用 -javaagent 加载的不受影响。

以前

运行中随时能往 JVM 里注入代码改行为

-javaagent:/opt/apm/agent.jar        # APM 推荐这样在启动时加载
-XX:+EnableDynamicAgentLoading       # 需要 Arthas 临时 attach 的服务，启动时加这个

是什么

21、22 预览过的字符串模板 STR."…" 在 23 被撤回，以后可能换一种设计再来。

以前

21、22 预览的 STR."…" 设计有争议

// 21、22 的预览写法，23 起编译不过：
// String s = STR."Hello \{name}";
String s = "Hello %s".formatted(name);   // 15 起就有的替代写法

是什么

javac 不再自动执行类路径上找到的注解处理器（Lombok、MapStruct 等），要在构建里显式声明。

以前

类路径上任何 jar 里的注解处理器都会被 javac 自动执行，是供应链风险

javac -proc:full ...              # 临时恢复旧行为
# 推荐：Maven 的 maven-compiler-plugin 里配 annotationProcessorPaths（见 ⑤ 的 pom）

是什么

sun.misc.Unsafe 的内存访问方法和 JNI 都会打警告，将来默认禁止；替代品是 VarHandle 和 FFM。

以前

库直接用 sun.misc.Unsafe 读写内存、用 JNI 调本地代码，一出错整个 JVM 崩

// 以前：UNSAFE.compareAndSwapInt(this, STATE_OFFSET, 0, 1);
// 现在用 VarHandle（在 static 块里初始化，findVarHandle 会抛受检异常）：
static final VarHandle STATE;   // = MethodHandles.lookup().findVarHandle(Task.class, "state", int.class)
STATE.compareAndSet(this, 0, 1);

--enable-native-access=ALL-UNNAMED            # 用 JNI 的程序启动时加上，消掉警告

是什么

24 起 SecurityManager 彻底无法启用，所有相关的权限检查都不再生效。

以前

17 弃用后，18～23 还能用 -Djava.security.manager=allow 打开

System.setSecurityManager(sm);   // 24 起总是抛 UnsupportedOperationException
// 隔离不可信代码：改用独立进程、容器或操作系统权限