Java 25 LTS 核心特性详解：语言改进与性能优化

• 初学者：无需理解类概念 -> 掌握基础后 -> 添加类声明 -> 经验丰富 -> 理解封装 -> 标准 Java 语法
• 快速原型开发：紧凑源文件 -> 逐步演进到标准形式

优势分析：

• 降低学习门槛：初学者无需理解类、静态方法等概念即可开始编程
• 快速原型开发：有经验的开发者可以快速编写测试代码和脚本
• 无缝演进：程序可以逐步从紧凑形式演进到标准形式

1.2 灵活的构造器体（JEP 463）

Java 25 允许在构造器体中，在显式构造器调用（super(...)或 this(...)）之前执行语句。这使得许多构造器的表达更加自然。

传统限制：

public class Parent {
    private final String name;
    private final int age;

    public Parent(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

public class Child extends Parent {
    private final String displayName;

    public Child(String name, int age) {
        // 传统写法：无法在 super() 之前进行初始化计算
        String computedName = name.toUpperCase();
        super(computedName, age); // 编译错误！
        this.displayName = computedName;
    }
}

Java 25 改进：

public class Child extends Parent {
    private final String displayName;

    public Child(String name, int age) {
        // 可以在 super() 之前执行初始化逻辑
        String computedName = name.toUpperCase();
        this.displayName = computedName;
        super(computedName, age);
    }

    // 更复杂的场景
    public Child(String firstName, String lastName, int age) {
        // 可以进行复杂的初始化计算
        String fullName = computeFullName(firstName, lastName);
        this.displayName = fullName;
        // 甚至可以验证参数
        if (age < 0) {
            throw new IllegalArgumentException("年龄不能为负数");
        }
        super(fullName, age);
    }

    private String computeFullName(String first, String last) {
        return (first + " " + last).trim();
    }
}

安全性保证：

• 在显式构造器调用之前的语句不能引用正在构造的对象
• 可以初始化字段和执行其他安全计算
• 字段在调用父类构造器之前完成初始化，提高了安全性

1.3 模块导入声明（JEP 511）

Java 25 引入了模块导入声明，允许简洁地导入模块导出的所有包，大大简化了模块化库的重用。

传统导入方式：

import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.util.HashMap;
import java.util.Set;
import java.util.HashSet;
import java.util.stream.Stream;
import java.util.stream.Collectors;

public class Example {
    // 使用这些类
}

Java 25 模块导入：

import module java.base; // 导入 java.base 模块的所有导出包

public class Example {
    // 可以直接使用 java.base 模块的所有类
    public void process() {
        List<String> list = new ArrayList<>();
        Map<String, Integer> map = new HashMap<>();
        Set<Integer> set = new HashSet<>();
        Stream<String> stream = list.stream();
    }
}

实际应用场景：

import module java.sql;

public class DatabaseExample {
    public void queryDatabase() throws SQLException {
        // 直接使用 java.sql 模块的所有类
        Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/mydb");
        Statement stmt = conn.createStatement();
        ResultSet rs = stmt.executeQuery("SELECT * FROM users");
        while (rs.next()) {
            System.out.println(rs.getString("name"));
        }
    }
}

优势：

• 简化导入语句，减少代码冗余
• 不需要将导入代码放在模块中
• 提高代码可读性

1.4 原语类型模式匹配（第三次预览）

Java 25 进一步增强了模式匹配，允许在所有模式上下文中使用原语类型，并扩展了 instanceof和 switch以支持所有原语类型。

基本用法：

// instanceof 支持所有原语类型
public void processNumber(Object obj) {
    if (obj instanceof int i) {
        System.out.println("整数：" + i);
    } else if (obj instanceof long l) {
        System.out.println("长整数：" + l);
    } else if (obj instanceof double d) {
        System.out.println("双精度：" + d);
    }
}

// switch 支持原语类型
public String getType(Object value) {
    return switch (value) {
        case int i -> "整数类型：" + i;
        case long l -> "长整型：" + l;
        case float f -> "浮点型：" + f;
        case double d -> "双精度型：" + d;
        default -> "其他类型";
    };
}

复杂模式匹配：

// 记录类与原语类型结合
record Point(int x, int y) {}
record Circle(Point center, int radius) {}

public void processShape(Object shape) {
    if (shape instanceof Circle(Point(int x, int y), int radius)) {
        System.out.printf("圆心在 (%d,%d)，半径为%d%n", x, y, radius);
    }
}

// switch 中的守卫条件
public String describeNumber(Object num) {
    return switch (num) {
        case int i when i > 0 -> "正整数：" + i;
        case int i when i < 0 -> "负整数：" + i;
        case int i -> "零";
        case double d when d > 0 -> "正浮点数：" + d;
        default -> "其他数值";
    };
}

二、库层面的重要更新

2.1 结构化并发（第五次预览）

结构化并发将运行在不同线程中的相关任务组视为单个工作单元，从而简化了错误处理和取消操作，提高了可靠性和可观测性。

基本概念：

• 主任务
• 子任务 1, 2, 3
• 结果聚合

代码示例：

import java.util.concurrent.StructuredTaskScope;
import java.util.concurrent.Future;
import java.util.function.Supplier;

public class StructuredConcurrencyExample {
    // 传统方式：手动管理多个线程
    public String fetchUserDataOldWay(String userId) throws Exception {
        ExecutorService executor = Executors.newFixedThreadPool(3);
        try {
            Future<String> userFuture = executor.submit(() -> fetchUser(userId));
            Future<List<Order>> ordersFuture = executor.submit(() -> fetchOrders(userId));
            Future<List<Review>> reviewsFuture = executor.submit(() -> fetchReviews(userId));
            String user = userFuture.get();
            List<Order> orders = ordersFuture.get();
            List<Review> reviews = reviewsFuture.get();
            return combineData(user, orders, reviews);
        } finally {
            executor.shutdown();
        }
    }

    // Java 25 结构化并发方式
    public String fetchUserDataNewWay(String userId) throws Exception {
        try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
            Supplier<String> userTask = scope.fork(() -> fetchUser(userId));
            Supplier<List<Order>> ordersTask = scope.fork(() -> fetchOrders(userId));
            Supplier<List<Review>> reviewsTask = scope.fork(() -> fetchReviews(userId));
            // 等待所有任务完成，任一失败则取消其他任务
            scope.join().throwIfFailed();
            return combineData(userTask.get(), ordersTask.get(), reviewsTask.get());
        }
    }

    private String fetchUser(String userId) {
        return "User: " + userId;
    }

    private List<Order> fetchOrders(String userId) {
        return List.of(new Order("order1"), new Order("order2"));
    }

    private List<Review> fetchReviews(String userId) {
        return List.of(new Review("review1"), new Review("review2"));
    }

    private String combineData(String user, List<Order> orders, List<Review> reviews) {
        return user + ", Orders: " + orders.size() + ", Reviews: " + reviews.size();
    }
}

优势：

• 自动资源管理：使用 try-with-resources 自动管理任务生命周期
• 统一错误处理：任一任务失败自动取消其他任务
• 可观测性：更容易跟踪和调试并发任务
• 取消传播：父任务取消时自动取消子任务

2.2 作用域值（Scoped Values）

作用域值允许方法在其线程内与被调用者共享不可变数据，也可以与子线程共享。相比 ThreadLocal，作用域值更易于理解，空间和时间开销更低。

对比 ThreadLocal：

// 传统 ThreadLocal 方式
public class ThreadLocalExample {
    private static final ThreadLocal<String> CONTEXT = new ThreadLocal<>();

    public void processRequest(String requestId) {
        CONTEXT.set(requestId);
        try {
            process1();
            process2();
        } finally {
            CONTEXT.remove(); // 必须手动清理
        }
    }

    private void process1() {
        String id = CONTEXT.get(); // 需要显式获取
        System.out.println("Process1: " + id);
    }

    private void process2() {
        String id = CONTEXT.get();
        System.out.println("Process2: " + id);
    }
}

// Java 25 作用域值方式
public class ScopedValueExample {
    private static final ScopedValue<String> REQUEST_ID = new ScopedValue<>();

    public void processRequest(String requestId) {
        ScopedValue.where(REQUEST_ID, requestId).run(() -> {
            process1();
            process2();
        }); // 自动清理，无需手动 remove
    }

    private void process1() {
        String id = REQUEST_ID.get(); // 隐式访问
        System.out.println("Process1: " + id);
    }

    private void process2() {
        String id = REQUEST_ID.get();
        System.out.println("Process2: " + id);
    }
}

与虚拟线程结合：

public class VirtualThreadWithScopedValue {
    private static final ScopedValue<String> CONTEXT = new ScopedValue<>();

    public void handleRequest(String requestId) {
        ScopedValue.where(CONTEXT, requestId).run(() -> {
            // 主线程访问
            System.out.println("Main: " + CONTEXT.get());
            // 虚拟线程自动继承作用域值
            Thread.startVirtualThread(() -> {
                System.out.println("Virtual Thread: " + CONTEXT.get());
            });
        });
    }
}

嵌套作用域：

public class NestedScopes {
    private static final ScopedValue<String> LEVEL1 = new ScopedValue<>();
    private static final ScopedValue<String> LEVEL2 = new ScopedValue<>();

    public void nestedExample() {
        ScopedValue.where(LEVEL1, "Outer").run(() -> {
            System.out.println("Level 1: " + LEVEL1.get()); // Outer
            ScopedValue.where(LEVEL1, "Inner").run(() -> {
                System.out.println("Level 1: " + LEVEL1.get()); // Inner
                ScopedValue.where(LEVEL2, "Deep").run(() -> {
                    System.out.println("Level 1: " + LEVEL1.get()); // Inner
                    System.out.println("Level 2: " + LEVEL2.get()); // Deep
                });
            });
            System.out.println("Level 1: " + LEVEL1.get()); // Outer
        });
    }
}

2.3 稳定值（Stable Values，预览）

稳定值 API 引入了保存不可变数据的对象，JVM 将稳定值视为常量，从而实现与声明 final 字段相同的性能优化。相比 final 字段，稳定值在初始化时机上更加灵活。

import java.lang.invoke.MethodHandles;
import java.lang.invoke.VarHandle;

public class StableValueExample {
    // 传统 final 字段：必须在构造器或初始化块中初始化
    private final String fixedValue = "Fixed";

    // 稳定值：可以延迟初始化
    private static final StableValue<String> LAZY_VALUE = StableValue.of(() -> {
        // 复杂的初始化逻辑
        return "Computed: " + System.currentTimeMillis();
    });

    // 使用 VarHandle 创建稳定值
    private static final VarHandle STABLE_HANDLE = MethodHandles.lookup().findVarHandle(StableValueExample.class, "stableField", String.class);
    private volatile String stableField;

    public void demonstrateStableValue() {
        // 获取稳定值
        String value = LAZY_VALUE.get();
        System.out.println("Stable value: " + value);
        // JIT 编译器可以将稳定值优化为常量
        for (int i = 0; i < 1000; i++) {
            processValue(value); // 可能被内联优化
        }
    }

    private void processValue(String value) {
        // 使用稳定值
    }
}

应用场景：

• 延迟初始化的全局配置
• 缓存不可变计算结果
• 优化频繁访问的常量数据

2.4 向量 API（第十次孵化）

向量 API 允许开发者表达向量计算，这些计算在运行时可靠地编译为支持 CPU 上的最优向量指令，从而实现优于等效标量计算的性能。

import jdk.incubator.vector.*;
import java.util.Arrays;

public class VectorAPIExample {
    // 传统标量计算
    public void scalarMultiply(float[] a, float[] b, float[] c) {
        for (int i = 0; i < a.length; i++) {
            c[i] = a[i] * b[i];
        }
    }

    // 使用向量 API
    public void vectorMultiply(float[] a, float[] b, float[] c) {
        int speciesLength = FloatVector.SPECIES_PREFERRED.length();
        int i = 0;
        // 向量化循环
        for (; i < a.length - speciesLength; i += speciesLength) {
            var va = FloatVector.fromArray(FloatVector.SPECIES_PREFERRED, a, i);
            var vb = FloatVector.fromArray(FloatVector.SPECIES_PREFERRED, b, i);
            var vc = va.mul(vb);
            vc.intoArray(c, i);
        }
        // 处理剩余元素
        for (; i < a.length; i++) {
            c[i] = a[i] * b[i];
        }
    }

    // 更复杂的向量运算
    public float[] vectorCompute(float[] data) {
        int length = data.length;
        float[] result = new float[length];
        int speciesLength = FloatVector.SPECIES_PREFERRED.length();
        int i = 0;
        for (; i < length - speciesLength; i += speciesLength) {
            var v = FloatVector.fromArray(FloatVector.SPECIES_PREFERRED, data, i);
            // 复杂运算：每个元素平方后加 1
            var squared = v.mul(v);
            var plusOne = squared.add(1.0f);
            // 求和
            var sum = plusOne.reduceLanes(VectorOperators.ADD);
            // 将结果广播到整个向量
            var broadcast = FloatVector.broadcast(FloatVector.SPECIES_PREFERRED, sum);
            broadcast.intoArray(result, i);
        }
        return result;
    }
}

性能对比：

2.5 密钥派生函数 API（JEP 510）

Java 25 引入了密钥派生函数（KDF）API，这些是从密钥和其他数据派生其他密钥的加密算法。

import javax.crypto.*;
import javax.crypto.spec.*;

public class KDFExample {
    public void deriveKeys() throws Exception {
        // 主密钥
        SecretKey masterKey = generateMasterKey();
        // 派生多个子密钥
        SecretKey encryptionKey = deriveKey(masterKey, "encryption", 256);
        SecretKey authKey = deriveKey(masterKey, "authentication", 256);
        SecretKey hmacKey = deriveKey(masterKey, "hmac", 512);
        System.out.println("Encryption Key: " + encryptionKey.getAlgorithm());
        System.out.println("Auth Key: " + authKey.getAlgorithm());
        System.out.println("HMAC Key: " + hmacKey.getAlgorithm());
    }

    private SecretKey deriveKey(SecretKey masterKey, String purpose, int length) throws Exception {
        // 使用 HKDF (HMAC-based Key Derivation Function)
        KDF kdf = KDF.getInstance("HKDF-SHA256");
        // 配置派生参数
        KDFParameters params = new KDFParameters.Builder()
            .setKey(masterKey)
            .setSalt(purpose.getBytes()) // 使用 purpose 作为盐值
            .setInfo(purpose.getBytes())
            .setLength(length / 8)
            .build();
        // 派生密钥
        return kdf.deriveKey("AES", params);
    }

    private SecretKey generateMasterKey() throws Exception {
        KeyGenerator keyGen = KeyGenerator.getInstance("AES");
        keyGen.init(256);
        return keyGen.generateKey();
    }
}

应用场景：

• 从主密钥派生多个子密钥
• 密钥轮换
• 分层密钥管理
• 安全通信协议

2.6 PEM 编码（预览）

引入了 API，用于将代表加密密钥、证书和证书吊销列表的对象编码为广泛使用的隐私增强邮件（PEM）传输格式，并从该格式解码回对象。

import java.security.cert.*;
import java.security.*;
import java.util.Base64;

public class PEMExample {
    public void encodeKeyToPEM() throws Exception {
        // 生成密钥对
        KeyPairGenerator keyGen = KeyPairGenerator.getInstance("RSA");
        keyGen.initialize(2048);
        KeyPair keyPair = keyGen.generateKeyPair();

        // 编码私钥为 PEM 格式
        PEMEncoder encoder = new PEMEncoder();
        String privateKeyPEM = encoder.encode(keyPair.getPrivate());
        System.out.println("Private Key PEM:\n" + privateKeyPEM);

        // 编码公钥为 PEM 格式
        String publicKeyPEM = encoder.encode(keyPair.getPublic());
        System.out.println("Public Key PEM:\n" + publicKeyPEM);
    }

    public void decodeCertificateFromPEM(String pemCertificate) throws Exception {
        PEMDecoder decoder = new PEMDecoder();
        // 从 PEM 格式解码证书
        Certificate cert = decoder.decodeCertificate(pemCertificate);
        System.out.println("Certificate Subject: " + ((X509Certificate) cert).getSubjectDN());
    }

    public void encodeCertificateToPEM(X509Certificate cert) throws Exception {
        PEMEncoder encoder = new PEMEncoder();
        String pem = encoder.encode(cert);
        System.out.println("Certificate PEM:\n" + pem);
    }
}

三、性能优化

3.1 紧凑对象头（JEP 519）

Java 25 将紧凑对象头从实验特性转为产品特性，显著减少 Java 堆内存占用，并提供潜在的性能提升。

对象头结构对比：

• 传统对象头：Mark Word (8 字节) + Klass Pointer (4/8 字节) = 12-16 字节
• 紧凑对象头：压缩 Mark Word (4 字节) + 压缩 Klass Pointer (4 字节) = 8 字节
• 节省：25-50%

启用紧凑对象头：

# 启用紧凑对象头
java -XX:+UseCompactObjectHeaders MyApp
# 禁用紧凑对象头（默认）
java -XX:-UseCompactObjectHeaders MyApp

内存节省示例：

public class CompactObjectExample {
    // 小对象的内存占用显著减少
    private static class SmallObject {
        int value;
        String name;
    }

    public void memoryComparison() {
        // 创建大量小对象
        List<SmallObject> objects = new ArrayList<>();
        for (int i = 0; i < 1_000_000; i++) {
            objects.add(new SmallObject());
        }
        // 使用紧凑对象头可以节省数 MB 内存
        // 对于 1,000,000 个对象，每个节省 4-8 字节
        // 总共节省 4-8MB 堆内存
    }
}

3.2 AOT 命令行优化（JEP 514）

简化了创建 AOT 缓存所需的命令，这些缓存可以加速 Java 应用的启动。

# 传统方式：复杂的 AOT 编译流程
java -XX:ArchiveClassesAtExit=app.jsa -cp myapp.jar MyApp
java -XX:SharedArchiveFile=app.jsa -cp myapp.jar MyApp

# Java 25 简化方式
java -aot:create -o myapp.aot -cp myapp.jar MyApp
java -aot:use -i myapp.aot -cp myapp.jar MyApp

实际应用：

# 创建 AOT 缓存
java -aot:create -o cache.aot -cp lib/*:myapp.jar com.example.Main
# 使用 AOT 缓存启动
java -aot:use -i cache.aot -cp lib/*:myapp.jar com.example.Main

3.3 AOT 方法性能分析（JEP 515）

通过在 HotSpot JVM 启动时立即可用上一次运行的方法执行配置文件，改善预热时间，使 JIT 编译器能够在应用启动时立即生成本地代码。

# 第一次运行：收集性能分析数据
java -XX:ProfilesAtExit=profile.jfr MyApp
# 第二次运行：使用性能分析数据
java -XX:ProfilesDumpFile=profile.jfr MyApp

效果对比：

• AOT 性能分析启动：预热时间 1-3 秒，加载性能分析后直接 C2 编译至最佳性能
• 传统启动：预热时间 10-30 秒，解释执行 -> C1 编译 -> C2 编译至最佳性能

四、监控与诊断增强

4.1 JFR CPU 时间性能分析（实验性）

增强了 JDK Flight Recorder（JFR），在 Linux 上捕获更准确的 CPU 时间性能分析信息。

# 启用 JFR CPU 时间性能分析
java -XX:StartFlightRecording=filename=recording.jfr,duration=60s,cpu-profiling=true MyApp
# 分析记录
jfr print --events cpu,jdk.CPUInformation recording.jfr

4.2 JFR 协作采样

改进 JFR 在异步采样 Java 线程堆栈时的稳定性，通过仅在安全点遍历调用堆栈，同时最小化安全点偏差。

import jdk.jfr.*;

@Name("custom.event")
@Label("自定义事件")
public class CustomEvent extends Event {
    @Label("消息") String message;
    @Label("持续时间") long duration;
}

public class JFRCooperativeSampling {
    public void recordEvent() {
        CustomEvent event = new CustomEvent();
        event.message = "操作完成";
        event.duration = System.nanoTime();
        event.commit(); // JFR 会协作地采样这个事件
        processWork();
    }

    private void processWork() {
        // 复杂的计算逻辑
    }
}

4.3 JFR 方法计时和跟踪

通过字节码增强扩展 JFR，提供方法计时和跟踪功能。

# 启用方法跟踪
java -XX:StartFlightRecording=method-profiling=true,stack-depth=16 MyApp
# 分析方法执行时间
jfr print --events jdk.ExecutionSample recording.jfr

自定义方法跟踪：

import jdk.jfr.*;

@Name("method.timing")
@Label("方法计时")
public class MethodTimingEvent extends Event {
    @Label("类名") String className;
    @Label("方法名") String methodName;
    @Label("执行时间 (纳秒)") long duration;
}

public class MethodProfiling {
    @StackTrace(false)
    public void profileMethod() {
        long start = System.nanoTime();
        try {
            // 方法逻辑
            doWork();
        } finally {
            long duration = System.nanoTime() - start;
            MethodTimingEvent event = new MethodTimingEvent();
            event.className = this.getClass().getName();
            event.methodName = "profileMethod";
            event.duration = duration;
            event.commit();
        }
    }

    private void doWork() {
        // 实际工作
    }
}

五、其他重要改进

5.1 HttpClient API 增强

添加了限制响应体字节数的功能，提高了安全性。

import java.net.http.*;
import java.net.URI;

public class HttpClientEnhancements {
    public void fetchWithSizeLimit() throws Exception {
        HttpClient client = HttpClient.newHttpClient();
        // 创建限制响应体大小的处理器
        BodyHandler<String> limitedHandler = BodyHandlers.limiting(BodyHandlers.ofString(), 1024 * 1024); // 限制为 1MB
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://api.example.com/data"))
            .build();
        HttpResponse<String> response = client.send(request, limitedHandler);
        // 如果响应超过限制，会抛出 IOException
        System.out.println("Response body length: " + response.body().length());
    }

    public void getConnectionInfo() throws Exception {
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request1 = HttpRequest.newBuilder()
            .uri(URI.create("https://api.example.com/endpoint1"))
            .build();
        HttpRequest request2 = HttpRequest.newBuilder()
            .uri(URI.create("https://api.example.com/endpoint2"))
            .build();
        HttpResponse<String> response1 = client.send(request1, BodyHandlers.ofString());
        HttpResponse<String> response2 = client.send(request2, BodyHandlers.ofString());
        // 检查两个请求是否使用相同的连接
        Object label1 = response1.connectionLabel();
        Object label2 = response2.connectionLabel();
        if (label1.equals(label2)) {
            System.out.println("两个请求使用相同的连接");
        } else {
            System.out.println("两个请求使用不同的连接");
        }
    }
}

5.2 ForkJoinPool 改进

ForkJoinPool 现在实现了 ScheduledExecutorService 接口，提高了延迟任务处理的性能。

import java.util.concurrent.*;

public class ForkJoinPoolImprovements {
    public void scheduleWithForkJoinPool() {
        ForkJoinPool pool = new ForkJoinPool();
        // 使用新的调度功能
        ScheduledFuture<?> future = pool.schedule(() -> {
            System.out.println("延迟任务执行");
        }, 5, TimeUnit.SECONDS);
        // 使用新的 submitWithTimeout 方法
        CompletableFuture<String> result = pool.submitWithTimeout(() -> {
            // 长时间运行的任务
            Thread.sleep(3000);
            return "任务完成";
        }, 2, TimeUnit.SECONDS); // 2 秒超时
        result.exceptionally(ex -> {
            System.out.println("任务超时：" + ex.getMessage());
            return "默认值";
        });
    }
}

5.3 G1 垃圾收集器优化

G1 垃圾收集器进一步减少了记忆集内存开销和暂停时间，通过允许多个区域在混合 GC 期间共享单个内部结构。

优化方案：

• 传统 G1：Region 1, 2, 3, 4 分别对应 G1CardSet 1, 2, 3, 4，内存开销高
• 优化 G1：Region 1, 2, 3, 4 共享 G1CardSet，内存开销低

性能提升：

• 减少混合 GC 的暂停时间
• 降低记忆集内存占用
• 提高内存效率

5.4 新增系统属性

添加了 stdin.encoding 系统属性，用于指定从 System.in 读取字符数据时的推荐字符集。

import java.util.Scanner;

public class EncodingExample {
    public void readUserInput() {
        // 获取 stdin 编码
        String stdinEncoding = System.getProperty("stdin.encoding");
        System.out.println("stdin.encoding: " + stdinEncoding);
        // 使用推荐的编码读取输入
        Scanner scanner = new Scanner(System.in, stdinEncoding);
        System.out.print("请输入：");
        String input = scanner.nextLine();
        System.out.println("输入内容：" + input);
    }
}

六、迁移指南

6.1 从 Java 21 升级到 Java 25

兼容性检查：

# 检查代码兼容性
javac --release 21 -Xlint:unchecked YourClass.java

主要注意事项：

1. 紧凑对象头：默认禁用，建议测试后启用
2. 已移除功能：Graal JIT 编译器已移除
3. 已弃用功能：UseCompressedClassPointers 选项已弃用

6.2 最佳实践

1. 逐步采用新特性：
   • 从紧凑源文件开始，简化小程序开发
   • 在新项目中使用灵活构造器体
   • 考虑使用结构化并发替代传统线程管理
2. 性能优化：
   • 启用紧凑对象头减少内存占用
   • 使用 AOT 缓存加速启动
   • 利用 JFR 增强的监控功能
3. 安全增强：
   • 使用新的 KDF API 进行密钥管理
   • 利用 PEM 编码简化证书处理
   • 使用 HttpClient 的大小限制功能

七、总结

Java 25 作为一个重要的 LTS 版本，带来了诸多令人兴奋的改进：

语言层面：

• 紧凑源文件极大降低了学习门槛
• 灵活构造器体使代码更自然
• 模块导入简化了库的使用
• 原语类型模式匹配增强了类型安全

库层面：

• 结构化并发简化了并发编程
• 作用域值提供了更好的线程间数据共享
• 向量 API 提供了 SIMD 性能优化
• 新的加密 API 增强了安全性

性能层面：

• 紧凑对象头减少内存占用
• AOT 优化加速应用启动
• G1 垃圾收集器进一步优化

监控层面：

• JFR 增强了性能分析能力
• 更准确的 CPU 时间采样
• 方法计时和跟踪功能

Java 25 不仅保持了 Java 的稳定性和向后兼容性，还通过这些新特性为开发者提供了更强大的工具，使得 Java 在现代应用开发中继续保持竞争力。无论是初学者还是经验丰富的开发者，都能从这些改进中受益。