Java 25 新特性 (LTS)

note

正式版发布时间(GA)： 2025/09/16

官方发布介绍页面：https://openjdk.org/projects/jdk/25/

1. 语言特性与预览

JEP 507：模式、instanceof 和 switch 支持原始类型（第三次预览）

• 允许在所有模式上下文（如 instanceof、switch）中直接使用原始类型（如 int、double、boolean 等），不仅限于引用类型。
• 统一了模式匹配语法，减少装箱/拆箱操作，提升性能和代码可读性。
• 示例：

  public class PatternPrimitiveDemo {
      public static void main(String[] args) {
          Object obj = 42;
          // 1. instanceof 原始类型
          if (obj instanceof int i) {
              System.out.println("是 int 类型，值为：" + i);
          } else {
              System.out.println("不是 int 类型");
          }
          
          // 2. switch 匹配原始类型
          Object value = 3.14;
          switch (value) {
              case int n -> System.out.println("int: " + n);
              case double d -> System.out.println("double: " + d);
              case null -> System.out.println("null");
              default -> System.out.println("其他类型");
          }
          
          // 3. 结合解构与类型判断
          Object[] arr = {1, 2.0, "hello", true};
          for (Object o : arr) {
              switch (o) {
                  case int n -> System.out.println("int: " + n);
                  case double d -> System.out.println("double: " + d);
                  case boolean b -> System.out.println("boolean: " + b);
                  default -> System.out.println("其他类型: " + o);
              }
          }
      }
  }

  // 该示例展示了 instanceof、switch、解构等多种原始类型模式匹配用法。

JEP 513：灵活的构造函数体（最终版）

• 允许在构造函数的 this(...) 或 super(...) 调用前，编写变量声明、前置校验等语句。
• 便于更灵活地初始化对象，提升代码可维护性。
• 示例：

  public class User {
      private final String name;
      private final int age;
      
      public User(String name, int age) {
          // 构造器体前可做参数校验、日志等
          if (name == null || name.isBlank()) {
              throw new IllegalArgumentException("name 不能为空");
          }
          if (age < 0) {
              throw new IllegalArgumentException("age 不能为负数");
          }
          System.out.println("创建用户: " + name + ", age: " + age);
          this.name = name;
          this.age = age;
      }
  }
  
  public class Employee extends User {
      private final String department;
      
      public Employee(String name, int age, String department) {
          // 先做 department 校验，再调用父类构造器
          if (department == null || department.isBlank()) {
              throw new IllegalArgumentException("department 不能为空");
          }
          super(name, age);
          this.department = department;
      }
  }

  // 该示例展示了在 super/this 调用前进行参数校验和日志记录的典型用法。

JEP 511：模块导入声明（最终版）

• 引入 import module 语法，允许在源文件中显式声明依赖的模块。
• 新增 import module xxx;，便于工具链分析依赖关系，提升大型项目的模块管理能力。
• 示例：

  // 声明依赖于 com.example.util 和 com.example.math 两个模块
  import module com.example.util;
  import module com.example.math;
  
  import com.example.util.StringUtils;
  import com.example.math.Calculator;
  
  public class Demo {
      public static void main(String[] args) {
          String s = StringUtils.capitalize("hello");
          int sum = Calculator.add(1, 2);
          System.out.println(s + ", sum=" + sum);
      }
  }

  // 该示例展示了如何在源文件头部声明多个模块依赖，并结合普通 import 使用。

JEP 512：简化 main 方法和紧凑源文件（最终版）

• 允许 Java 程序入口 main 方法省略 String[] args 参数，支持极简单文件程序写法。
• 支持无类声明的顶级 main 入口，适合教学、脚本等场景。
• 示例：

  // 1. 省略参数的 main 方法
  public class Hello {
      public static void main() {
          System.out.println("Hello, Java 25!");
      }
  }
  
  // 2. 顶级 main，无需类声明
  void main() {
      System.out.println("Hello, Java 25! (Top-level main)");
  }

  // 该示例展示了 main 方法参数可选和顶级 main 的两种极简写法。

JEP 502：稳定值（Stable Values，预览）

• 引入 StableValue 类型，允许持有不可变数据，并被 JVM 视为常量，享受与 final 字段类似的性能优化。
• 适合分阶段初始化应用状态，提升启动性能。
• 示例：

  // 假设 StableValue API 如下（实际以官方为准）
  import java.lang.StableValue;
  
  public class StableValueDemo {
      static final StableValue<String> CONFIG = StableValue.create();
      public static void main(String[] args) {
          // 初始化一次
          CONFIG.set("配置项A");
          // 只读访问
          String value = CONFIG.get();
          System.out.println("配置: " + value);
          // 再次 set 会抛异常
          // CONFIG.set("B");
      }
  }

  // 该示例展示了 StableValue 的典型用法：只允许初始化一次，后续只读。

JEP 506：作用域值（正式版）

• 作用域值 API 正式发布，支持线程安全地传递只读数据，替代部分 ThreadLocal 场景。
• 生命周期受控，避免内存泄漏。
• 示例：

  import java.lang.ScopedValue;
  import java.util.concurrent.*;
  
  static final ScopedValue<String> USER = ScopedValue.newInstance();
  
  public class ScopedValueDemo {
      public static void main(String[] args) throws Exception {
          ScopedValue.where(USER, "张三").run(() -> {
              System.out.println("主线程用户: " + USER.get());
              ExecutorService pool = Executors.newSingleThreadExecutor();
              Future<?> f = pool.submit(() -> {
                  System.out.println("子线程用户: " + USER.get());
              });
              f.get();
              pool.shutdown();
          });
      }
  }

  // 该示例展示了作用域值在主线程和子线程中的安全传递。

JEP 505：结构化并发（第五次预览）

• 结构化并发 API 进入第五次预览，进一步简化多线程任务管理和错误处理。
• 新增 StructuredTaskScope，通过静态工厂方法创建，API 更加易用。
• 示例：

  import java.util.concurrent.*;
  
  public class StructuredConcurrencyDemo {
      public static void main(String[] args) throws Exception {
          try (var scope = StructuredTaskScope.ShutdownOnFailure.open()) {
              Future<String> user = scope.fork(() -> findUser());
              Future<Integer> order = scope.fork(() -> findOrder());
              scope.join(); // 等待所有任务完成
              if (user.isDone() && order.isDone()) {
                  System.out.println("用户: " + user.get() + ", 订单: " + order.get());
              }
          }
      }
      static String findUser() { return "张三"; }
      static int findOrder() { return 1001; }
  }

  // 该示例展示了结构化并发下多任务统一管理和结果处理。

2. 性能与运行时

JEP 519：紧凑对象头（正式版）

• HotSpot JVM 对象头从 96/128 位缩减为 64 位，减少堆内存占用，提高数据局部性。
• 该特性在 JDK 24 为实验性，JDK 25 起为正式特性。

 # 启动参数中增加
 -XX:+UseCompactObjectHeaders

更详细的解释请查看：点击下载

JEP 521：分代 Shenandoah 垃圾回收器（正式版）

• Shenandoah GC 的分代模式从实验性转为正式产品特性，提升吞吐量和内存利用率。
• 适合大规模、高并发、低延迟场景。

JEP 514：AOT 命令行参数优化

• 优化 Ahead-of-Time (AOT) 编译相关命令行参数，提升 AOT 使用体验。

JEP 515：AOT 方法级性能分析

• 支持 AOT 编译时对方法级别进行性能分析，提升热点方法识别和优化能力。

JEP 503：移除 32 位 x86 支持

• 移除 JDK 对 32 位 x86 平台的支持，专注于 64 位架构。

3. 标准库与 API

JEP 508：Vector API（第十次孵化）

• 持续孵化的 Vector API，支持高效 SIMD 向量化运算。
• 新增对 Float16 运算的自动向量化，底层实现更易维护。
• 示例：

  import jdk.incubator.vector.FloatVector;
  import jdk.incubator.vector.VectorSpecies;
  
  public class VectorDemo {
      static final VectorSpecies<Float> SPECIES = FloatVector.SPECIES_PREFERRED;
      public static void main(String[] args) {
          float[] a = {1f, 2f, 3f, 4f, 5f, 6f, 7f, 8f};
          float[] b = {8f, 7f, 6f, 5f, 4f, 3f, 2f, 1f};
          float[] c = new float[a.length];
          int i = 0;
          for (; i < SPECIES.length(); i += SPECIES.length()) {
              var va = FloatVector.fromArray(SPECIES, a, i);
              var vb = FloatVector.fromArray(SPECIES, b, i);
              var vc = va.add(vb);
              vc.intoArray(c, i);
          }
          for (; i < a.length; i++) {
              c[i] = a[i] + b[i];
          }
          System.out.println(java.util.Arrays.toString(c)); // 输出: [9.0, 9.0, 9.0, 9.0, 9.0, 9.0, 9.0, 9.0]
      }
  }

  // 该示例展示了如何用 Vector API 实现高效的向量加法。

JEP 510：密钥派生函数 API（正式版）

• 标准化密钥派生函数（KDF）API，支持 PBKDF2、HKDF、Argon2 等主流算法。
• 便于安全地从主密钥派生子密钥，提升密码学操作安全性。
• 示例：

  import javax.crypto.SecretKey;
  import javax.crypto.spec.PBEKeySpec;
  import java.security.spec.KeySpec;
  import java.util.Base64;
  import java.security.SecureRandom;
  import javax.crypto.SecretKeyFactory;
  
  public class KDFDemo {
      public static void main(String[] args) throws Exception {
          String password = "myPassword";
          byte[] salt = new byte[16];
          new SecureRandom().nextBytes(salt);
          int iterations = 65536;
          int keyLength = 256;
          // 使用 PBKDF2WithHmacSHA256 派生密钥
          KeySpec spec = new PBEKeySpec(password.toCharArray(), salt, iterations, keyLength);
          SecretKeyFactory factory = SecretKeyFactory.getInstance("PBKDF2WithHmacSHA256");
          SecretKey key = factory.generateSecret(spec);
          byte[] encoded = key.getEncoded();
          System.out.println("派生密钥: " + Base64.getEncoder().encodeToString(encoded));
      }
  }

  // 该示例展示了如何用标准 KDF API 派生密钥并进行参数配置。

JEP 470：PEM 编码加解密 API（预览）

• 新增 PEM 格式加解密 API，简化密钥、证书等对象的 PEM 编解码。
• 支持 PKCS#8、X.509 等标准格式的互转。
• 示例：

  // 伪代码，实际 API 以官方为准
  import java.nio.file.Files;
  import java.nio.file.Path;
  import java.security.cert.CertificateFactory;
  import java.security.cert.X509Certificate;
  import java.io.InputStream;
  
  public class PemDemo {
      public static void main(String[] args) throws Exception {
          // 读取 PEM 格式证书
          byte[] pemBytes = Files.readAllBytes(Path.of("cert.pem"));
          InputStream in = new java.io.ByteArrayInputStream(pemBytes);
          CertificateFactory cf = CertificateFactory.getInstance("X.509");
          X509Certificate cert = (X509Certificate) cf.generateCertificate(in);
          System.out.println("证书主题: " + cert.getSubjectDN());
          // 写 PEM（实际需用官方 API）
          // Pem.write(cert, Path.of("out.pem"));
      }
  }

  // 该示例展示了 PEM 证书的读取与解析，写入需参考官方 API。

4. 工具链与监控

JEP 509：JFR CPU 时间采样（实验性）

• JDK Flight Recorder (JFR) 新增 CPU 时间采样功能，便于性能分析和故障定位。

JEP 518：JFR 协作采样

• JFR 支持协作采样，提升多线程环境下的性能分析精度。

JEP 520：JFR 方法定时与追踪

• JFR 新增方法级别的定时与追踪功能，便于热点方法定位和性能瓶颈分析。

5. 兼容性、移除与废弃

JEP 503：移除 32 位 x86 支持

• 移除 JDK 对 32 位 x86 平台的支持，专注于 64 位架构。

移除/废弃项

• 移除/废弃部分老旧 API、命令行参数、JNDI 远程代码下载、JMX 早期序列化兼容逻辑等。
• 弃用 jstatd、jrunscript 工具，jdk.jsobject 模块，LockingMode 标志等。

6. 其他重要变更与修复

• String::hashCode 支持常量折叠优化，静态不可变 Map 场景下性能提升明显。
• jar 工具增强，支持 --keep-old-files、--dir 等新选项。
• 虚拟线程调度器监控，新增 MXBean 和 jcmd 命令支持。
• 安全属性文件支持 include 指令，便于分模块管理安全配置。
• TLS/SSL 相关增强，如 TLSv1.3 新会话票据数量可配置、支持模式匹配禁用 Cipher Suite。
• XML/JAXP：内置 W3C DTD/XSD，调整默认限制，增强安全性。
• CLDR 46/时区数据库 2024b，本地化和时区数据全面更新。
• 弃用/移除部分老旧 API 和命令行参数，详见官方文档。

7. 已知问题与修复

• 修复了 lambda 表达式、反射、类加载等相关的若干兼容性和行为问题。
• 修复了 Windows 下 CPU 负载监控、JDK RPM 升级遗留、Socket 连接等问题。
• 详见 JDK 25 Release Notes。

---

本文档为 JDK 25 主要新特性与变更的详细中文说明，便于开发者快速查阅和理解。如需了解更详细的实现细节，请参考官方 JEP 页面和 Release Notes。