刚刚 Java 25 炸裂发布！让 Java 再次伟大

大家好，我是程序员鱼皮。
刚刚，Java 25 正式发布！这是继 Java 21 之后，又一个 LTS 长期支持版本，也是 Java 开发者们最期待的版本之一。其中有个特性可以说是颠覆了我对 Java 的认知，让 Java 再次伟大！
那么 Java 25 都发布了哪些新特性？有没有必要升级？
一篇文章，带你速通 Java 新特性，学会后又能愉快地和面试官吹牛皮了~

推荐观看视频版：https://bilibili.com/video/BV1b5pCzGEPx

⭐️ 正式特性

这些特性在 Java 25 中正式稳定，可以在生产环境中放心使用。
【实用】Scoped Values 作用域值

如果我问你：怎么在同一个线程内共享数据？
估计你的答案是 ThreadLocal。
但是你有没有想过，ThreadLocal 存在什么问题？
举一个典型的 ThreadLocal 使用场景，在同一个请求内获取用户信息：

1. public class UserService {
2.    private static final ThreadLocal<String> USER_ID = new ThreadLocal<>();
3.    
4.    public void processRequest(String userId) {
5.        USER_ID.set(userId);  // 写入
6.        doWork();
7.        USER_ID.remove();  // 问题：必须手动清理，容易忘记
8.   }
9.    
10.    public void doWork() {
11.        String userId = USER_ID.get();  // 读取
12.        System.out.println("处理用户: " + userId);
13.        // 问题：其他代码可以随意修改
14.        USER_ID.set("被篡改的值");
15.   }
16. }

复制代码

这段简单的代码其实暗藏玄鸡，可以看出 ThreadLocal 的痛点：

• 容易内存泄漏：必须手动调用 remove()
  
• 可以随意修改数据，可能导致不可预期的结果
  

此外，如果想让子线程也共享数据，每个子线程都要复制一份数据。如果你使用的是 Java 21 的虚拟线程，1000 个虚拟线程就要复制1000 次，性能很差。

1. InheritableThreadLocal<String> threadLocal = new InheritableThreadLocal<>();
2. threadLocal.set("用户数据");
3. for (int i = 0; i < 1000; i++) {
4.    Thread.ofVirtual().start(() -> {
5.        String data = threadLocal.get(); // 每个线程都有自己的副本
6.   });
7. }

复制代码

现在 Java 25 的 Scoped Values 特性转正了，能解决 ThreadLocal 的这些问题。
 
什么是 Scoped Values？

Scoped Values 允许方法 在线程内以及子线程间安全高效地共享不可变数据。
和传统的 ThreadLocal 相比，它不仅更安全，而且在虚拟线程环境下的内存开销要小很多。
Scoped Values 和 ThreadLocal 的写法很像：

1. import static java.lang.ScopedValue.where;
2. ​
3. public class UserService {
4.    private static final ScopedValue<String> USER_ID = ScopedValue.newInstance();
5.    
6.    public void processRequest(String userId) {
7.        where(USER_ID, userId)  // 写入并绑定作用域
8.           .run(this::doWork);
9.        // 自动清理，无需 remove()
10.   }
11.    
12.    public void doWork() {
13.        String userId = USER_ID.get();  // 读取
14.        System.out.println("处理用户: " + userId);
15.   }
16. }

复制代码

这段代码中，我们使用 where().run() 自动管理作用域，出了作用域就自动清理，更安全。
而且作用域一旦绑定，值就不能被修改，避免意外的状态变更。
和虚拟线程配合使用时，所有虚拟线程共享同一份数据，内存占用更小：

1. ScopedValue<String> scopedValue = ScopedValue.newInstance();
2. where(scopedValue, "用户数据").run(() -> {
3.    for (int i = 0; i < 1000; i++) {
4.        Thread.ofVirtual().start(() -> {
5.            String data = scopedValue.get(); // 所有线程共享同一份数据
6.       });
7.   }
8. });

复制代码

1.  

复制代码

使用方法

1）支持返回值
除了 run() 方法，还可以使用 call() 方法来处理有返回值的场景：

1. public String processWithResult(String input) {
2.    return where(CONTEXT, input)
3.       .call(() -> {
4.            String processed = doSomeWork();
5.            return "结果: " + processed;
6.       });
7. }

复制代码

 
2）嵌套作用域
支持在已有作用域内建立新的嵌套作用域：

1. void outerMethod() {
2.    where(X, "hello").run(() -> {
3.        System.out.println(X.get());  // 输出 "hello"
4.        where(X, "goodbye").run(() -> {
5.            System.out.println(X.get());  // 输出 "goodbye"
6.       });
7.        System.out.println(X.get());  // 输出 "hello"
8.   });
9. }

复制代码

 
3）多值绑定
可以在一个调用中绑定多个 Scoped Values，或者直接用类封装多个值：

1. where(USER_ID, userId)
2.   .where(REQUEST_ID, requestId)
3.   .where(TENANT_ID, tenantId)
4.   .run(() -> {
5.        processRequest();
6.   });

复制代码

1.  

复制代码

4）和结构化并发配合
Scoped Values 和 Java 结构化并发 API 可以打个配合，子线程自动继承父线程的作用域值：

1. void handleRequest() {
2.    where(USER_ID, getCurrentUserId())
3.       .run(() -> {
4.            try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
5.                var userTask = scope.fork(() -> loadUser());      // 子线程可以访问 USER_ID
6.                var ordersTask = scope.fork(() -> loadOrders());  // 子线程可以访问 USER_ID
7.                scope.join().throwIfFailed();
8.                return new Response(userTask.get(), ordersTask.get());
9.           }
10.       });
11. }

复制代码

不过结构化并发这哥们也挺惨的，过了这么多个版本还没转正。等它转正了，感觉 Java 并发编程的模式也要改变了。
 
使用场景

虽然 Scoped Values 听起来比 ThreadLocal 更高级，但它不能 100% 替代 ThreadLocal。
如果你要在线程中共享不可变数据、尤其是使用了虚拟线程的场景，建议使用 Scoped Values；但如果线程中共享的数据可能需要更新，那么还是使用 ThreadLocal，要根据实际场景选择。
 
【实用】模块导入声明

模块导入声明特性（Module Import Declarations）虽然是首次亮相，但它的设计理念可以追溯到 Java 9 的模块系统。
模块系统允许我们将代码组织成模块，每个模块都有明确的依赖关系和导出接口，让大型应用的架构变得更加清晰和可维护。

模块导入声明是在这个基础上进一步简化开发体验。
以前我们使用多个 Java 标准库的包需要大量的导入语句：

1. import java.util.Map;
2. import java.util.List;
3. import java.util.stream.Collectors;
4. import java.util.stream.Stream;
5. import java.util.function.Function;
6. import java.nio.file.Path;
7. import java.nio.file.Files;
8. import java.time.LocalDateTime;
9. import java.time.format.DateTimeFormatter;
10. // ... 还有更多

复制代码

 
现在可以一行导入整个模块：

1. import module java.base;

复制代码

 
对于聚合模块（比如 java.se），一次导入可以使用大量包：

1. import module java.se;  // 导入 100 多个包
2. ​
3. public class FullFeatureApp {
4.    // 可以使用整个 Java SE 平台的所有公开 API
5. }

复制代码

1.  

复制代码

不过我感觉这个特性会比较有争议，我记得大厂的 Java 规约中是禁止使用通配符 * 方式导入所有类的，可读性差、有命名冲突风险、依赖不明确。
而模块导入的范围更大，类名冲突可能更严重。如果导入多个模块时遇到了同名类，还要再通过具体导入来解决：

1. import module java.base;      // 包括 java.util.List 接口
2. import module java.desktop;   // 包括 java.awt.List 类
3. ​
4. import java.util.List;        // 明确指定使用 util 包的 List

复制代码

所以我可能不会用这个特性，纯个人偏好。
 
【必备】紧凑源文件和实例主方法

这是我最喜欢的特性，直接打破了外界对于 Java 的刻板印象！
之前不是都说 Java 入门比 Python 难么？一个简单的 Hello World 程序就要包含类、public、static、方法参数等概念。
传统的 Hello World 程序：

1. public class HelloWorld {
2.    public static void main(String[] args) {
3.        System.out.println("Hello, World!");
4.   }
5. }

复制代码

用 Python 或者 JavaScript 直接写一行代码就完成了：

1. print("Hello World")

复制代码

在 Java 25 中，Hello World 程序可以直接简写为 3 行代码！

1. void main() {
2.    IO.println("Hello, World!");
3. }

复制代码

这么一看和好多语言都有点像啊。。。安能辨我是 Java？
但是你知道，这 3 含代码的含金量么？你知道 Java 为了支持简写成这 3 行代码付出了多少努力么？

 
新的 IO 类

首先是 Java 25 在 java.lang 包中新增了 IO 类，提供更简单的控制台 I/O 操作：

1. void main() {
2.    String name = IO.readln("请输入您的姓名: ");
3.    IO.print("很高兴认识您，");
4.    IO.println(name);
5. }

复制代码

 
IO 类的主要方法包括：

1. public static void print(Object obj);
2. public static void println(Object obj);
3. public static void println();
4. public static String readln(String prompt);
5. public static String readln();

复制代码

 
自动导入 java.base 模块

在紧凑源文件中，所有 java.base 模块导出的包都会自动导入，就像有这样一行代码：

1. import module java.base;

复制代码

也就是说，你可以直接使用 List、Map、Stream 等常用类：

1. void main() {
2.    var fruits = List.of("苹果", "香蕉", "橙子");
3.    var lengths = fruits.stream()
4.       .collect(Collectors.toMap(
5.            fruit -> fruit,
6.            String::length
7.       ));
8.    IO.println("水果及其长度: " + lengths);
9. }

复制代码

这样一来，Java 对初学者更友好，同时也让有经验的开发者能快速编写脚本和小工具。
我觉得这个特性是让 Java 再次伟大的关键，为什么呢？
Java 的核心竞争优势在于它成熟完善的生态系统，但语法不够简洁；现在 Java 只要持续借鉴其他新兴编程语言的优秀设计和语法特性、给开发者提供平滑的技术升级路径，就还是会有很多开发者继续使用 Java，就不会被别的语言取代。
 
【实用】灵活的构造函数体

这个特性解决的是 Java 自诞生以来就存在的一个限制：构造函数中的 super() 或 this() 调用必须是第一条语句。
这个限制虽然保证了对象初始化的安全性，但可能也会影响我们的编码。
举个例子：

1. class Employee extends Person {
2.    Employee(String name, int age) {
3.        super(name, age);  // 必须是第一条语句
4.        if (age < 18 || age > 67) {
5.            throw new IllegalArgumentException("员工年龄不符要求");
6.       }
7.   }
8. }

复制代码

这种写法的问题是，即使参数不符合要求，也会先调用父类构造函数，做一些可能不必要的工作。
Java 25 打破了这个限制，引入了新的构造函数执行模型，分为两个阶段：

• 序言阶段：构造函数调用之前的代码
  
• 尾声阶段：构造函数调用之后的代码
  

简单来说，允许在构造函数调用之前添加语句！

1. class Employee extends Person {
2.    String department;
3.    
4.    Employee(String name, int age, String department) {
5.        // 序言阶段，可以校验参数
6.        if (age < 18 || age > 67) {
7.            throw new IllegalArgumentException("员工年龄必须在 18-67 之间");
8.       }        
9.        // 可以初始化字段
10.        this.department = department;
11.        // 验证通过后，再调用父类构造函数
12.        super(name, age);
13.        // 尾声阶段，可以干点儿别的事
14.        IO.println("新员工 " + name + " 已加入 " + department + " 部门");
15.   }
16. }

复制代码

怎么样，感觉是不是一直以来背的八股文、做的选择题崩塌了！

此外，这个特性还能防止父类构造函数调用子类未初始化的方法：

1. class Base {
2.    Base() {
3.        this.show();  // 调用可能被重写的方法
4.   }
5.    void show() {
6.        IO.println("Base.show()");
7.   }
8. }
9. ​
10. class Yupi extends Base {
11.    private String message;
12.    
13.    Yupi(String message) {
14.        this.message = message;  // 在 super() 之前初始化
15.        super();
16.   }
17.    
18.    @Override
19.    void show() {
20.        IO.println("消息: " + message);  // message 已经正确初始化了
21.   }
22. }

复制代码

现在，当创建 Yupi 对象时，message 字段会在父类构造函数运行之前就被正确初始化，避免了打印 null 值的问题。
 
限制条件

但是要注意，在序言阶段有一些限制：

• 不能使用 this 引用（除了字段赋值）
  
• 不能调用实例方法
  
• 只能对未初始化的字段进行赋值
  

1. class Example {
2.    int value;
3.    String name = "default";  // 有初始化器
4.    
5.    Example(int val, String nm) {
6.        // ✅ 允许：验证参数
7.        if (val < 0) throw new IllegalArgumentException();
8.       
9.        // ✅ 允许：初始化未初始化的字段
10.        this.value = val;
11.       
12.        // ❌ 不允许：字段已有初始化器
13.        // this.name = nm;
14.       
15.        // ❌ 不允许：调用实例方法
16.        // this.helper();
17.       
18.        super();
19.       
20.        // ✅ 现在可以正常使用 this 了
21.        this.name = nm;
22.        this.helper();
23.   }
24.    
25.    void helper() { /* ... */ }
26. }

复制代码

总之，这个特性让构造函数变得更加灵活和安全，特别适合需要复杂初始化逻辑的场景。
 
【了解】密钥派生函数 API

随着量子计算技术的发展，传统的密码学算法面临威胁，后量子密码学成为必然趋势。
因此 Java 也顺应时代，推出了密钥派生函数（KDF），这是一种从初始密钥材料、盐值等输入生成新密钥的加密算法。
简单来说，你理解为 Java 出了一个新的加密工具类就好了，适用于对密码进行加强、从主密钥派生多个子密钥的场景。
核心是 javax.crypto.KDF 类，提供了两个主要方法：

• deriveKey() 生成 SecretKey 对象
  
• deriveData() 生成字节数组
  

比如使用 HKDF（HMAC-based Key Derivation Function）算法：

1. // 创建 HKDF 实例
2. KDF hkdf = KDF.getInstance("HKDF-SHA256");
3. ​
4. // 准备初始密钥材料和盐值
5. byte[] initialKeyMaterial = "my-secret-key".getBytes();
6. byte[] salt = "random-salt".getBytes();
7. byte[] info = "application-context".getBytes();
8. ​
9. // 创建 HKDF 参数
10. AlgorithmParameterSpec params = HKDFParameterSpec.ofExtract()
11.   .addIKM(initialKeyMaterial)  // 添加初始密钥材料
12.   .addSalt(salt)               // 添加盐值
13.   .thenExpand(info, 32);       // 扩展为 32 字节
14. ​
15. // 派生 AES 密钥
16. SecretKey aesKey = hkdf.deriveKey("AES", params);
17. ​
18. // 或者直接获取字节数据
19. byte[] derivedData = hkdf.deriveData(params);

复制代码

 
【了解】紧凑对象头

了解过 Java 对象结构的同学应该知道，Java 对象除了存储数据外，还要通过 对象头 存储很多额外的信息，比如类型信息、GC 标记、锁状态等元数据。

 
如果程序中要创建大量小对象，可能对象头本身占用的空间都比实际要存储的数据多了！
比如下面这段代码：

1. class Point {
2.    int x, y;  // 实际数据只有 8 字节
3. }
4. ​
5. // 创建一堆 Point 对象
6. List<Point> points = new ArrayList<>();
7. for (int i = 0; i < 10000; i++) {
8.    points.add(new Point(i, i));  // 每个对象实际占用 24 字节！
9. }

复制代码

用来存储传统的对象头在 64 位系统上占 16 字节，对于只有 8 字节数据的 Point 来说，开销确实有点大。
Java 25 将紧凑对象头特性转正，把对象头从 16 字节压缩到 8 字节，减少了小对象的内存开销。

但是，紧凑对象头并不是默认开启的，需要手动指定。毕竟少存了一些信息，必须考虑到兼容性，比如下面这几种情况可能会有问题：

• 使用了 JNI 直接操作对象头的代码
  
• 依赖特定对象头布局的调试工具
  
• 某些第三方性能分析工具
  

 
【了解】Shenandoah 分代收集

对于 Java 这种自动垃圾收集的语言，我们经常遇到这种问题：GC 一运行，应用就卡顿。特别是占用大堆内存的应用，传统的垃圾收集器一跑起来，停顿时间可能多达几百毫秒甚至几秒。
Shenandoah 作为 Java 中延迟最低的垃圾收集器，在 Java 25 中 Shenandoah 的分代模式转为正式特性。
什么是分代垃圾回收呢？
大部分对象都是 “朝生夕死” 的。将堆内存划分为年轻代和老年代两个区域，年轻代的垃圾收集可以更加频繁和高效，因为大部分年轻对象很快就会死亡，收集器可以快速清理掉这些垃圾；而老年代的收集频率相对较低，减少了对长期存活对象的不必要扫描。

经过大量测试，分代 Shenandoah 在保持超低延迟的同时，还能获得更好的吞吐量。对于延迟敏感的应用来说，这个改进还是很实用的。
但是 Shenandoah 并不是默认的垃圾收集器，需要手动指定。而且分代模式也不是 Shenandoah 的默认模式，默认情况下 Shenandoah 还是使用单代模式。
 
预览特性

这些特性仍在预览阶段，可以体验 但不建议在生产环境使用！
【了解】结构化并发

目前我们经常使用 ExecutorService 实现并发，可能会写下面这种代码：

1. // 传统写法
2. Response handle() throws ExecutionException, InterruptedException {
3.    Future<String> user = executor.submit(() -> findUser());
4.    Future<Integer> order = executor.submit(() -> fetchOrder());
5.    
6.    String theUser = user.get();   // 如果这里异常了
7.    int theOrder = order.get();    // 这个任务还在跑，造成线程泄漏！
8.    
9.    return new Response(theUser, theOrder);
10. }

复制代码

上述代码存在一个问题，如果 findUser() 方法失败了，fetchOrder() 还在后台运行，浪费资源。而且如果当前线程被中断，子任务不会自动取消。
 
什么是结构化并发？

结构化并发就是来解决并发编程中 线程泄露和资源管理 问题的。它在 Java 25 中第 5 次预览，API 已经成熟，盲猜下个版本就要转正了。
结构化并发的基本使用方法：

1. Response handle() throws InterruptedException {
2.    // 打开新作用域，打开作用域的线程是作用域的所有者。
3.    try (var scope = StructuredTaskScope.open()) {
4.        // 使用 fork 方法在作用域中开启子任务
5.        var userTask = scope.fork(() -> findUser());
6.        var orderTask = scope.fork(() -> fetchOrder());
7.        // 等待所有子任务完成或失败
8.        scope.join();
9.        return new Response(userTask.get(), orderTask.get());
10.   }
11.    // 作用域结束时，所有子任务自动清理，不会泄漏
12. }

复制代码

这样就解决了几个问题：

• 自动清理：任一任务失败，其他任务自动取消
  
• 异常传播：主线程被中断，子任务也会取消
  
• 资源管理：可以配合 try-with-resources 保证资源释放
  

 
更多用法

Java 25 提供了多种执行策略：

1. // 1. 默认策略：所有任务都要成功
2. try (var scope = StructuredTaskScope.open()) {
3.    // 任一失败就全部取消
4. }
5. ​
6. // 2. 竞速策略：任一成功即可
7. try (var scope = StructuredTaskScope.open(Joiner.anySuccessfulResultOrThrow())) {
8.    var task1 = scope.fork(() -> callService1());
9.    var task2 = scope.fork(() -> callService2());
10.    var task3 = scope.fork(() -> callService3());
11.    
12.    // 谁先成功就用谁的结果，其他任务取消
13.    return scope.join();
14. }
15. ​
16. // 3. 收集所有结果（忽略失败）
17. try (var scope = StructuredTaskScope.open(Joiner.awaitAll())) {
18.    // 等待所有任务完成，不管成功失败
19. }

复制代码

结构化并发搭配虚拟线程，可以轻松处理大量并发：

1. void processLotsOfRequests() throws InterruptedException {
2.    try (var scope = StructuredTaskScope.open()) {
3.        // 创建上万个虚拟线程都没问题
4.        for (int i = 0; i < 10000; i++) {
5.            int requestId = i;
6.            scope.fork(() -> processRequest(requestId));
7.       }
8.        scope.join();  // 等待所有请求处理完成
9.   }
10.    // 自动清理，不用担心线程泄漏
11. }

复制代码

1.  

复制代码

【了解】基本类型模式匹配

之前 Java 优化过很多次模式匹配，可以利用 switch 和 instanceof 快速进行类型检查和转换。
比如：

1. public String processMessage(Object message) {
2.    return switch (message) {
3.        case String text -> "文本消息：" + text;
4.        case Integer number -> "数字消息：" + number;
5.        case List<?> list -> "列表消息，包含 " + list.size() + " 个元素";
6.        case  -> "空消息";
7.        default -> "未知消息类型";
8.   };
9. }

复制代码

但是目前模式匹配只能用于引用类型，如果你想在 switch 中匹配基本类型，只能用常量，不能绑定变量。
支持基本类型模式匹配后，switch 中可以使用基本类型：

1. switch (value) {
2.    case int i when i > 100 -> "大整数: " + i;
3.    case int i -> "小整数: " + i;
4.    case float f -> "浮点数: " + f;
5.    case double d -> "双精度: " + d;
6. }

复制代码

注意这里的 int i，变量 i 绑定了匹配的值，可以直接使用。
而且基本类型模式会检查转换是否安全，这比手动写范围检查方便多了！

1. int largeInt = 1000000;
2. ​
3. // 检查能否安全转换为 byte
4. if (largeInt instanceof byte b) {
5.    IO.println("可以安全转换为 byte: " + b);
6. } else {
7.    IO.println("转换为 byte 会丢失精度");  // 这个会执行
8. }
9. ​
10. // 检查 int 转 float 是否会丢失精度
11. int preciseInt = 16777217;  // 2^24 + 1
12. if (preciseInt instanceof float f) {
13.    IO.println("转换为 float 不会丢失精度");
14. } else {
15.    IO.println("转换为 float 会丢失精度");  // 这个会执行
16. }

复制代码

1.  

复制代码

【了解】Stable Values 稳定值

这个特性对大多数开发者来说应该是没什么用的。
不信我先考考大家：final 字段有什么问题？
答案是必须在构造时初始化。
举个例子：

1. class OrderController {
2.    private final Logger logger = Logger.create(OrderController.class);
3. }

复制代码

这段代码中，logger 必须立刻初始化，如果创建 logger 很耗时，所有实例都要等待，可能影响启动性能。
特别是在对象很多、但不是每个都会用到某个字段的场景下，这种强制初始化就很浪费。
但我又想保证不可变性，怎么办呢？
Stable Values 可以解决上述问题，提供 延迟初始化的不可变性：

1. class OrderController {
2.    private final StableValue<Logger> logger = StableValue.of();
3.    
4.    Logger getLogger() {
5.        // 只在首次使用时初始化，之后直接返回同一个实例
6.        return logger.orElseSet(() -> Logger.create(OrderController.class));
7.   }
8. }

复制代码

说白了其实就是包一层。。。
还有更简洁的写法，可以在声明时指定初始化逻辑：

1. class OrderController {
2.    private final Supplier<Logger> logger =
3.        StableValue.supplier(() -> Logger.create(OrderController.class));
4.    
5.    void logOrder() {
6.        logger.get().info("处理订单");  // 自动延迟初始化
7.   }
8. }

复制代码

还支持集合的延迟初始化：

1. class ConnectionPool {
2.    // 延迟创建连接池，每个连接按需创建
3.    private static final List<Connection> connections =
4.        StableValue.list(POOL_SIZE, index -> createConnection(index));
5.    
6.    public static Connection getConnection(int index) {
7.        return connections.get(index);  // 第一次访问才创建这个连接
8.   }
9. }

复制代码

重点是，Stable Values 底层使用 JVM 的 @Stable 注解，享受和 final 字段一样的优化（比如常量折叠），所以不用担心性能。
这个特性特别适合：

• 创建成本高的对象
  
• 不是每个实例都会用到的字段
  
• 需要延迟初始化但又要保证不可变的场景
  

没记错的话这个特性应该是首次亮相，对于追求性能的开发者来说还是挺实用的。
 
其他特性

【了解】移除 32 位 x86 支持

Java 25 正式移除了对 32 位 x86 架构的支持。
简单来说就是：32 位系统现在用不了 Java 25 了。
不过对绝大多数朋友来说，这个变化应该没啥影响。
 
【了解】JFR 性能分析增强

JFR（Java Flight Recorder）飞行记录器是 JDK 内置的低开销性能监控工具，可以记录程序运行时的详细数据。
它在这个版本获得了几个重要增强，包括更精确地测量 CPU 使用情况、通过协作式采样保证了 JVM 安全性、可以更安全地在生产环境开启分析等。
 
【了解】Vector API（第 10 次孵化）

Vector API 继续孵化，主要改进：

• 更好的数学函数支持：现在通过 FFM API 调用本地数学库，提高可维护性
  
• Float16 支持增强：在支持的 CPU 上可以自动向量化 16 位浮点运算
  
• VectorShuffle 增强：支持与 MemorySegment 交互
  

这个 API 对高性能计算、机器学习等领域很重要，尤其是现在 AI 的发展带火了向量运算。但是我想说真的别再孵化了，等你转正了，黄花菜都凉了。
 
 
以上就是 Java 25 的新特性了，不知道大家有什么想法，可以在评论区留言分享。
我的评价是：虽然 Java 25 在开发体验、性能优化和并发编程方面都有进步，雨露均沾，但是目前对于新项目选择 Java 21 就够了，老项目还是可以继续用 Java 8，真没必要升级到 Java 25。
但是建议大家还是把 Java 8 之后的 Java 新特性都了解一下，拓宽下知识面，面试的时候也能跟面试官多聊几句。我也把免费 Java 教程和 Java 新特性大全都整理到编程导航上了：

免费 Java 教程 + 新特性大全：https://codefather.cn/course/java

如果本期内容有收获，记得点赞关注三连支持，我们下期见。

更多编程学习资源

• Java前端程序员必做项目实战教程+毕设网站
  
• 程序员免费编程学习交流社区（自学必备）
  
• 程序员保姆级求职写简历指南（找工作必备）
  
• 程序员免费面试刷题网站工具（找工作必备）
  
• 最新Java零基础入门学习路线 + Java教程
  
• 最新Python零基础入门学习路线 + Python教程
  
• 最新前端零基础入门学习路线 + 前端教程
  
• 最新数据结构和算法零基础入门学习路线 + 算法教程
  
• 最新C++零基础入门学习路线、C++教程
  
• 最新数据库零基础入门学习路线 + 数据库教程
  
• 最新Redis零基础入门学习路线 + Redis教程
  
• 最新计算机基础入门学习路线 + 计算机基础教程
  
• 最新小程序入门学习路线 + 小程序开发教程
  
• 最新SQL零基础入门学习路线 + SQL教程
  
• 最新Linux零基础入门学习路线 + Linux教程
  
• 最新Git/GitHub零基础入门学习路线 + Git教程
  
• 最新操作系统零基础入门学习路线 + 操作系统教程
  
• 最新计算机网络零基础入门学习路线 + 计算机网络教程
  
• 最新设计模式零基础入门学习路线 + 设计模式教程
  
• 最新软件工程零基础入门学习路线 + 软件工程教程
  

来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！