Java22新特性深度解析：简化编程的优雅进化

发表于2025-03-28|更新于2026-03-31

|浏览量:

Java 22于2024年3月发布，作为非LTS版本继续推动Java语言的现代化。本文将深入解析字符串模板标准化、隐式类、未命名变量等重磅特性，并通过详细代码示例展示如何简化日常开发。

Java 22版本概览

Java 22于2024年3月19日正式发布，是Java 21后的又一个重要版本。虽然不是LTS版本，但它带来了许多影响深远的特性，特别是针对简化编程和提升开发体验的设计。

主要特性一览

字符串模板标准化：从预览特性变为正式特性
隐式类和实例main方法：简化Java入门学习曲线
未命名变量和模式：减少样板代码
语句之前允许var：更灵活的局部变量类型推断
流收集器的增强：更强大的数据流处理能力
作用域值：为虚拟线程提供更好的上下文传递
结构化并发：简化的并发编程模型
外部函数和内存API增强：更好的本地代码互操作
向量API增强：更强的SIMD计算支持

字符串模板：从预览到标准化

模板处理器的基础概念

// Java 22：字符串模板正式特性
public class StringTemplateExample {

    // 基础模板使用
    public void basicTemplates() {
        String name = "Alice";
        int age = 30;

        // 使用STR处理器进行字符串插值
        String message = STR."Hello, \{name}! You are \{age} years old.";
        System.out.println(message); // 输出: Hello, Alice! You are \{age} years old.
    }

    // 多行字符串模板
    public void multilineTemplates() {
        String title = "Employee Report";
        List<String> items = List.of("John", "Jane", "Bob");

        String report = STR."""
            \{title}
            ===========

            Employees:
            \{items.stream().map(item -> STR."  - \{item}").collect(Collectors.joining("\n"))}

            Total: \{items.size()} employees
            """;

        System.out.println(report);
    }
}

自定义模板处理器

// 定义自定义模板处理器
public class CustomTemplateProcessor {

    // SQL查询模板处理器 - 防止SQL注入
    public static final TemplateProcessor<String, RuntimeException> SQL = template -> {
        StringBuilder result = new StringBuilder();
        List<Object> fragments = template.fragments();
        List<String> values = template.values();

        for (int i = 0; i < fragments.size(); i++) {
            result.append(fragments.get(i));
            if (i < values.size()) {
                // 对值进行SQL转义处理
                result.append(escapeSqlValue(values.get(i)));
            }
        }

        return result.toString();
    };

    private static String escapeSqlValue(Object value) {
        if (value == null) return "NULL";
        String str = value.toString();
        // 简单的SQL转义（实际使用时应该使用PreparedStatement）
        return "'" + str.replace("'", "''") + "'";
    }

    // 使用示例
    public void demonstrateSqlTemplate() {
        String tableName = "users";
        String columnName = "name";
        String searchValue = "O'Reilly"; // 包含单引号的值

        String query = SQL."""
            SELECT * FROM \{tableName}
            WHERE \{columnName} = \{searchValue}
            """;

        System.out.println("Generated SQL: " + query);
        // 输出: SELECT * FROM users WHERE name = 'O''Reilly'
    }
}

HTML模板处理器的实现

// HTML转义模板处理器
public class HtmlTemplateProcessor {

    public static final TemplateProcessor<String, RuntimeException> HTML = template -> {
        StringBuilder result = new StringBuilder();
        List<String> fragments = template.fragments();
        List<Object> values = template.values();

        for (int i = 0; i < fragments.size(); i++) {
            result.append(fragments.get(i));
            if (i < values.size()) {
                result.append(escapeHtml(values.get(i)));
            }
        }

        return result.toString();
    };

    private static String escapeHtml(Object value) {
        if (value == null) return "";
        String str = value.toString();
        return str.replace("&", "&amp;")
                 .replace("<", "&lt;")
                 .replace(">", "&gt;")
                 .replace("\"", "&quot;")
                 .replace("'", "&#x27;");
    }

    // 使用示例
    public void demonstrateHtmlTemplate() {
        String userName = "<script>alert('xss')</script>";
        String userEmail = "user@example.com";

        String html = HTML."""
            <div class="user-card">
                <h2>Welcome, \{userName}!</h2>
                <p>Email: \{userEmail}</p>
                <p>Current time: \{LocalDateTime.now()}</p>
            </div>
            """;

        System.out.println("Generated HTML: " + html);
        // 脚本标签会被正确转义
    }
}

隐式类：简化Java入门

传统Java类的复杂性

// 传统Java类 - 对初学者不友好
public class TraditionalHelloWorld {

    // 必须声明为public
    // 类名必须与文件名相同
    // 需要main方法签名
    public static void main(String[] args) {
        System.out.println("Hello, World!");
    }
}

隐式类的优雅解决方案

// Java 22：隐式类 - 极简入门体验
class HelloWorld {
    // 不再需要public static void main(String[] args)
    // 直接写方法体即可
    void main() {
        System.out.println("Hello, World!");
    }
}

// 或者更简单的方式
class SimpleHello {
    // 甚至可以省略方法名
    {
        System.out.println("Hello from instance initializer!");
    }
}

隐式类的编译和运行

// 编译时自动生成的标准main方法
public class ImplicitClassDemo {

    // Java 22编译器会自动将以下代码转换为标准形式：
    // public static void main(String[] args)

    void main() {
        System.out.println("This is an implicit main method");
        demonstrateFeatures();
    }

    // 实例方法
    private void demonstrateFeatures() {
        // 1. 字符串模板
        String greeting = STR."Hello from Java \{Runtime.version()}";

        // 2. 记录类
        record Person(String name, int age) {}
        var person = new Person("Alice", 30);

        // 3. Switch表达式
        String description = switch (person.age() / 10) {
            case 2 -> "Young adult";
            case 3 -> "Adult";
            default -> "Other";
        };

        System.out.println(STR."\{greeting}\n\{description}");
    }
}

未命名变量和模式：减少样板代码

传统模式匹配的冗余

// Java 21：传统模式匹配仍需要命名变量
public class TraditionalPatternMatching {

    public void processData(Object data) {
        if (data instanceof Point(var x, var y)) {
            // 即使不使用x和y，也必须命名它们
            System.out.println("Processing point");
        }

        if (data instanceof List<?> list && !list.isEmpty()) {
            // 不关心第一个元素，只关心列表非空
            Object first = list.get(0); // 必须赋值给变量
            System.out.println("List has elements");
        }
    }
}

未命名变量的简化写法

// Java 22：使用未命名变量(_)简化代码
public class UnnamedVariablesExample {

    public void processData(Object data) {
        // 使用未命名变量忽略不需要的值
        if (data instanceof Point(var x, _)) { // 忽略y坐标
            System.out.println(STR."Processing point with x=\{x}");
        }

        if (data instanceof Point(_, var y)) { // 忽略x坐标
            System.out.println(STR."Processing point with y=\{y}");
        }

        // 在流操作中使用
        List<String> names = List.of("Alice", "Bob", "Charlie");
        names.stream()
             .filter(_ -> true) // 忽略过滤条件，直接处理所有元素
             .forEach(name -> System.out.println("Processing: " + name));
    }

    // 未命名模式在switch中的应用
    public String describeShape(Object shape) {
        return switch (shape) {
            case Point(var x, _) when x > 0 -> "Point in positive x-axis";
            case Point(_, var y) when y > 0 -> "Point in positive y-axis";
            case Point(_, _) -> "Point in other quadrants";
            case Circle(var radius, _) -> STR."Circle with radius \{radius}"; // 忽略圆心坐标
            default -> "Unknown shape";
        };
    }
}

实际应用场景

// 异常处理中的未命名变量
public class ExceptionHandlingExample {

    public void processFile(String filePath) {
        try (var reader = new BufferedReader(new FileReader(filePath))) {
            String line;
            while ((line = reader.readLine()) != null) {
                // 使用未命名变量忽略异常参数
                processLine(line).ifFailure(_ -> logError("Failed to process line: " + line));
            }
        } catch (IOException _) { // 忽略具体的异常对象
            System.err.println("Error reading file: " + filePath);
        }
    }

    // 在try-with-resources中使用
    public void copyFile(String source, String dest) {
        try (var in = new FileInputStream(source);
             var out = new FileOutputStream(dest)) {

            // 忽略返回值
            in.transferTo(out); // 方法返回long，但我们不关心具体值

        } catch (IOException _) { // 忽略异常详情
            System.err.println("Failed to copy file");
        }
    }
}

语句之前允许使用var：更灵活的类型推断

传统var使用的限制

// Java 10引入var，但有使用限制
public class TraditionalVarUsage {

    public void demonstrateVarLimitations() {
        // var可以在方法内部使用
        var list = new ArrayList<String>();

        // 但不能在类级别使用
        // var instanceVar; // 编译错误

        // 也不能在方法参数中使用
        // public void method(var param) { } // 编译错误

        // 更不能在构造函数中使用super()之前
        // public MyClass(var value) {
        //     super(processValue(value)); // 编译错误：var不能在super()前使用
        // }
    }
}

Java 22的增强：语句之前的var使用

// Java 22：var可以在更多地方使用
public class EnhancedVarUsage {

    // 1. 在构造函数中的super()之前使用
    public class ProcessedData extends BaseData {
        public ProcessedData(String rawData) {
            // 现在可以在super()之前使用var
            var processed = processRawData(rawData);
            var validated = validateData(processed);

            super(validated); // 使用处理后的数据
        }
    }

    // 2. 在方法中的复杂计算
    public void complexCalculation() {
        // 在return语句之前使用var
        var intermediate = performFirstStep();
        var refined = refineResult(intermediate);

        if (refined.isValid()) {
            var finalResult = finalizeResult(refined);
            return finalResult;
        } else {
            var fallback = createFallback();
            return fallback;
        }
    }

    // 3. 在异常处理中的使用
    public void exceptionHandling() {
        try {
            var result = riskyOperation();

            if (result.needsProcessing()) {
                var processed = processResult(result);
                saveToDatabase(processed);
            }

        } catch (Exception e) {
            var errorInfo = extractErrorInfo(e);
            var fallback = createFallbackValue(errorInfo);
            handleError(fallback);
        }
    }
}

流收集器的增强：Gatherers API

传统流操作的复杂性

// Java 21：复杂的流操作
public class TraditionalStreamOperations {

    public void demonstrateComplexStreams() {
        List<Integer> numbers = List.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

        // 窗口操作 - 需要复杂的实现
        List<List<Integer>> windows = new ArrayList<>();
        for (int i = 0; i < numbers.size() - 2; i++) {
            windows.add(List.of(numbers.get(i), numbers.get(i + 1), numbers.get(i + 2)));
        }

        // 或者使用更复杂的collectors
        List<List<Integer>> windows2 = numbers.stream()
            .collect(() -> new ArrayList<List<Integer>>(),
                    (lists, num) -> {
                        // 复杂的窗口逻辑
                        if (lists.isEmpty() || lists.get(lists.size() - 1).size() == 3) {
                            lists.add(new ArrayList<>());
                        }
                        lists.get(lists.size() - 1).add(num);
                    },
                    (left, right) -> left.addAll(right));
    }
}

Gatherers API的优雅解决方案

// Java 22：使用Gatherers进行流操作
public class GatherersExample {

    public void demonstrateGatherers() {
        List<Integer> numbers = List.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

        // 1. 固定大小的窗口
        List<List<Integer>> windows = numbers.stream()
            .gather(Gatherers.windowFixed(3)) // 每3个元素为一组
            .toList();

        System.out.println("Windows: " + windows);
        // 输出: [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

        // 2. 滑动窗口
        List<List<Integer>> slidingWindows = numbers.stream()
            .gather(Gatherers.windowSliding(3)) // 滑动窗口，大小为3
            .toList();

        System.out.println("Sliding windows: " + slidingWindows);
        // 输出: [[1, 2, 3], [2, 3, 4], [3, 4, 5], [4, 5, 6], [5, 6, 7], [6, 7, 8], [7, 8, 9], [8, 9, 10]]

        // 3. 折叠操作
        List<Integer> folded = numbers.stream()
            .gather(Gatherers.fold(() -> 0, (acc, elem) -> acc + elem)) // 累加
            .toList();

        // 4. 去重
        List<Integer> deduplicated = List.of(1, 2, 2, 3, 3, 3, 4, 5, 5).stream()
            .gather(Gatherers.distinctBy(Object::hashCode)) // 自定义去重逻辑
            .toList();
    }

    // 自定义Gatherer
    public void customGatherer() {
        List<String> words = List.of("hello", "world", "java", "programming");

        // 创建自定义的映射和过滤Gatherer
        Gatherer<String, ?, String> upperCaseFilter = Gatherer.of(
            // 初始化状态
            () -> null,
            // 累积器函数
            (state, element, downstream) -> {
                String upper = element.toUpperCase();
                if (upper.length() > 4) { // 只保留长度大于4的单词
                    downstream.push(upper);
                }
                return true; // 继续处理
            }
        );

        List<String> result = words.stream()
            .gather(upperCaseFilter)
            .toList();

        System.out.println("Filtered uppercase: " + result);
        // 输出: [HELLO, WORLD, PROGRAMMING]
    }
}

作用域值：为虚拟线程优化的上下文传递

传统ThreadLocal的问题

// ThreadLocal在虚拟线程中的问题
public class ThreadLocalIssues {

    private static final ThreadLocal<String> USER_CONTEXT = new ThreadLocal<>();
    private static final ThreadLocal<String> REQUEST_ID = new ThreadLocal<>();

    public void demonstrateThreadLocalProblems() {
        // 在虚拟线程中，ThreadLocal可能导致内存泄漏
        // 因为虚拟线程可能会被频繁创建和销毁
        USER_CONTEXT.set("user123");
        REQUEST_ID.set("req456");

        // 异步操作
        CompletableFuture.runAsync(() -> {
            // 在新的虚拟线程中，ThreadLocal值可能丢失
            String user = USER_CONTEXT.get(); // 可能为null
            String requestId = REQUEST_ID.get(); // 可能为null

            processRequest(user, requestId);
        });
    }

    private void processRequest(String user, String requestId) {
        System.out.println(STR."Processing request \{requestId} for user \{user}");
    }
}

作用域值的解决方案

// Java 22：使用作用域值
public class ScopedValuesExample {

    // 定义作用域值
    private static final ScopedValue<String> USER_CONTEXT = ScopedValue.newInstance();
    private static final ScopedValue<String> REQUEST_ID = ScopedValue.newInstance();

    public void demonstrateScopedValues() {
        // 设置作用域值
        ScopedValue.where(USER_CONTEXT, "user123")
                   .where(REQUEST_ID, "req456")
                   .run(() -> {
                       // 在作用域内，值 guaranteed 不为null
                       processRequest();
                   });
    }

    private void processRequest() {
        String user = USER_CONTEXT.get();
        String requestId = REQUEST_ID.get();

        System.out.println(STR."Processing request \{requestId} for user \{user}");

        // 子操作自动继承作用域值
        performSubOperation();
    }

    private void performSubOperation() {
        // 子方法中仍然可以访问到作用域值
        String user = USER_CONTEXT.get();
        String requestId = REQUEST_ID.get();

        System.out.println(STR."Sub-operation for user \{user}");
    }

    // 异步操作中的作用域值传递
    public void demonstrateAsyncScopedValues() {
        ScopedValue.where(USER_CONTEXT, "user123")
                   .where(REQUEST_ID, "req456")
                   .run(() -> {
                       // 使用虚拟线程池
                       try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
                           executor.submit(() -> {
                               // 作用域值会自动传递到新的虚拟线程
                               String user = USER_CONTEXT.get();
                               String requestId = REQUEST_ID.get();

                               System.out.println(STR."Async operation: \{requestId} for \{user}");
                           });
                       }
                   });
    }
}

结构化并发：简化的并发编程

传统异步编程的复杂性

// 传统异步编程的复杂性
public class TraditionalAsyncProcessing {

    private final ExecutorService executor = Executors.newCachedThreadPool();

    public CompletableFuture<String> processUserData(String userId) {
        return CompletableFuture.supplyAsync(() -> getUserData(userId), executor)
            .thenCompose(userData ->
                CompletableFuture.allOf(
                    CompletableFuture.supplyAsync(() -> processProfile(userData), executor),
                    CompletableFuture.supplyAsync(() -> processPreferences(userData), executor),
                    CompletableFuture.supplyAsync(() -> processHistory(userData), executor)
                ).thenApply(v -> combineResults())
            );
    }

    // 错误处理复杂
    public void demonstrateErrorHandling() {
        processUserData("user123")
            .whenComplete((result, throwable) -> {
                if (throwable != null) {
                    // 错误处理逻辑
                    handleError(throwable);
                } else {
                    // 成功处理逻辑
                    handleSuccess(result);
                }
            });
    }
}

结构化并发的优雅解决方案

// Java 22：结构化并发（预览特性）
public class StructuredConcurrencyExample {

    public String processUserData(String userId) throws ExecutionException, InterruptedException {
        try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {

            // 启动子任务
            var profileTask = scope.fork(() -> getUserData(userId).thenApply(this::processProfile));
            var preferencesTask = scope.fork(() -> getUserData(userId).thenApply(this::processPreferences));
            var historyTask = scope.fork(() -> getUserData(userId).thenApply(this::processHistory));

            // 等待所有任务完成
            scope.join(); // 如果有任务失败，会自动取消其他任务

            // 获取结果
            var profile = profileTask.get();
            var preferences = preferencesTask.get();
            var history = historyTask.get();

            return combineResults(profile, preferences, history);

        } catch (ExecutionException e) {
            // 结构化错误处理
            System.err.println("Task execution failed: " + e.getMessage());
            throw e;
        }
    }

    // 更简单的并行处理
    public List<String> processBatch(List<String> items) throws InterruptedException {
        try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {

            // 为每个项目启动任务
            List<StructuredTaskScope.Subtask<String>> tasks = items.stream()
                .map(item -> scope.fork(() -> processItem(item)))
                .toList();

            scope.join();

            // 收集所有结果
            return tasks.stream()
                .map(StructuredTaskScope.Subtask::get)
                .toList();
        }
    }
}

相对Java 21的主要改动

1. 字符串模板的标准化

改动：从预览特性变为正式特性
影响：开发者可以放心在生产环境中使用
兼容性：语法保持不变，只是状态改变

2. 学习曲线的简化

改动：引入隐式类和实例main方法
影响：大幅降低Java入门难度
目标群体：初学者和教育场景

3. 语法灵活性的提升

改动：允许var在更多上下文中使用，未命名变量的引入
影响：减少样板代码，提高代码简洁性
受益者：所有Java开发者

4. 并发编程的增强

改动：作用域值和结构化并发的引入
影响：解决虚拟线程中的上下文传递问题
优势：更好的资源管理和错误处理

5. 流API的扩展

改动：Gatherers API的引入
影响：提供更强大和灵活的流操作
应用场景：复杂的数据处理管道

Java 22的优势与设计哲学

1. 简化编程体验

Java 22的设计哲学是让编程变得更简单、更直观：

// 对比：从复杂到简单
// Java 21的写法
public void oldWay() {
    String name = "Alice";
    String result = "Hello, " + name + "!";
    System.out.println(result);
}

// Java 22的写法
public void newWay() {
    String name = "Alice";
    String result = STR."Hello, \{name}!";
    System.out.println(result);
}

2. 性能和资源管理

作用域值：解决虚拟线程中的内存泄漏问题
结构化并发：更好的资源清理和错误传播
向量API增强：利用CPU的SIMD指令提升性能

3. 向后兼容性保证

Java 22保持了极佳的向后兼容性：

现有代码无需修改即可运行
新特性都是可选的增强
渐进式的采用策略

4. 教育和入门友好

// 传统Hello World
public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello, World!");
    }
}

// Java 22的隐式类写法
class Hello {
    void main() {
        System.out.println("Hello, World!");
    }
}

迁移策略与最佳实践

1. 渐进式采用新特性

// 第一阶段：保持现有代码不变
public class MigrationStrategy {

    // 原有代码继续使用传统方式
    public String oldStyleFormatting(String name, int age) {
        return "User: " + name + ", Age: " + age;
    }

    // 新代码可以使用字符串模板
    public String newStyleFormatting(String name, int age) {
        return STR."User: \{name}, Age: \{age}";
    }

    // 对于模式匹配，逐步引入未命名变量
    public void processData(Object data) {
        if (data instanceof Point p) {
            // 第一阶段：使用传统方式
            System.out.println("Point: " + p.x() + ", " + p.y());
        }

        if (data instanceof Point(var x, _)) {
            // 第二阶段：使用未命名变量
            System.out.println("Point x-coordinate: " + x);
        }
    }
}

2. 作用域值的正确使用

// 正确使用作用域值的模式
public class ScopedValueBestPractices {

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

    public void handleRequest(HttpRequest request) {
        String requestId = generateRequestId();
        String userId = extractUserId(request);

        // 正确的方式：在作用域中设置值并执行操作
        ScopedValue.where(REQUEST_ID, requestId)
                   .where(USER_ID, userId)
                   .run(() -> processRequest(request));
    }

    private void processRequest(HttpRequest request) {
        // 在作用域内安全地访问值
        String requestId = REQUEST_ID.get();
        String userId = USER_ID.get();

        // 记录请求开始
        logRequestStart(requestId, userId);

        try {
            // 执行业务逻辑
            performBusinessLogic();

            // 子操作会自动继承作用域值
            performSubOperations();

        } finally {
            // 记录请求结束
            logRequestEnd(requestId);
        }
    }
}

3. 错误处理和资源管理

// 使用结构化并发进行错误处理
public class StructuredConcurrencyBestPractices {

    public Result<String, Exception> processWithStructuredConcurrency(String input) {
        try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {

            // 启动多个相关的子任务
            var validationTask = scope.fork(() -> validateInput(input));
            var processingTask = scope.fork(() -> processData(input));
            var enrichmentTask = scope.fork(() -> enrichData(input));

            // 等待所有任务完成或第一个失败
            scope.join();

            // 如果到达这里，所有任务都成功了
            var validation = validationTask.get();
            var processing = processingTask.get();
            var enrichment = enrichmentTask.get();

            return Result.success(combineResults(validation, processing, enrichment));

        } catch (ExecutionException e) {
            // 结构化的错误处理
            return Result.failure((Exception) e.getCause());
        } catch (InterruptedException e) {
            // 处理中断
            Thread.currentThread().interrupt();
            return Result.failure(e);
        }
    }
}

总结与展望

Java 22作为Java 21后的重要版本，带来了以下核心价值：

技术进步

简化编程体验：字符串模板标准化、隐式类、未命名变量等特性大幅降低代码复杂性
并发编程增强：作用域值和结构化并发解决虚拟线程中的实际问题
流操作扩展：Gatherers API提供更强大和灵活的数据处理能力
学习曲线优化：隐式类和实例main方法让Java入门变得更加友好

开发体验改善

代码简洁性：同样的功能需要更少的代码
类型安全性：编译时错误检查更加严格
资源管理：更好的内存和并发资源管理
错误处理：结构化并发提供更清晰的错误传播

生态系统影响

教育友好：降低Java学习门槛，吸引更多开发者
生产就绪：字符串模板等特性从预览到正式，为生产环境使用奠定基础
框架适配：新特性为Spring、Quarkus等框架提供更好的支持
工具完善：IDE和构建工具对新特性的支持逐渐完善

未来展望

Java 22展示了Java语言持续进化的方向：

简化语法：让Java代码更加简洁和表达力强
提升性能：通过更好的并发支持和底层优化
改善体验：无论是初学者还是资深开发者都能从中受益
保持兼容：在创新的同时保持向后兼容性

对于开发者而言，Java 22提供了现代化编程的工具和理念：

字符串模板让字符串处理更加安全和简洁
作用域值解决虚拟线程中的实际问题
结构化并发让并发编程更加可控
隐式类让Java入门变得更加容易

建议开发者积极尝试Java 22的新特性，在保证系统稳定的前提下，逐步采用这些能够显著改善开发体验的新功能。

参考资料

文章作者: Foam🍅

文章链接: https://foamtomato.github.io/2025/03/28/0.6.12-Java22%E6%96%B0%E7%89%B9%E6%80%A7%E6%B7%B1%E5%BA%A6%E8%A7%A3%E6%9E%90%EF%BC%9A%E7%AE%80%E5%8C%96%E7%BC%96%E7%A8%8B%E7%9A%84%E4%BC%98%E9%9B%85%E8%BF%9B%E5%8C%96/

Java 最佳实践 Java22 字符串模板隐式类未命名变量流收集器作用域值结构化并发外部函数API 向量API 性能优化代码简化新特性现代化编程