跳至主要內容

Java22新特性教程 - 2024最新Java特性完整指南

Java突击队大约 18 分钟

Java22新特性教程 - 2024最新Java特性完整指南

目录

  1. Java22简介
  2. 环境搭建
  3. 未命名变量和模式
  4. 字符串模板（预览）
  5. 结构化并发（预览）
  6. 作用域值（预览）
  7. 外部函数和内存API
  8. Stream Gatherers（预览）
  9. 类文件API（预览）
  10. 未命名类和实例main方法（预览）
  11. 构造函数前语句（预览）
  12. G1垃圾收集器区域固定
  13. 向量API（第七孵化版）
  14. 启动多个源文件程序
  15. 实际应用案例
  16. 总结与最佳实践

点击这里👇🏻获取：100万QPS短链系统、复杂的商城微服务系统、智能翻译助手AI Agent、SaaS点餐系统、刷题吧小程序、商城系统、秒杀系统、AI项目、代码生成神器、苏三demo项目等 8 个项目的：项目源代码、开发教程和技术答疑

1. Java22简介

Java 22于2024年3月19日正式发布，是Oracle的长期支持（LTS）版本Java 21之后的第一个非LTS版本。Java 22引入了多项新特性和改进，进一步提升了Java语言的表达能力和开发效率。

主要特性列表：

  • ✅ 未命名变量和模式（JEP 456）：使用下划线表示未使用的变量和模式

  • ✅ 字符串模板（JEP 459）：更安全和灵活的字符串插值

  • ✅ 结构化并发（JEP 462）：简化并发编程模型

  • ✅ 作用域值（JEP 464）：线程本地存储的现代化替代方案

  • ✅ 外部函数和内存API（JEP 454）：与本地代码交互的标准化API

  • ✅ Stream Gatherers（JEP 461）：增强Stream API的灵活性

  • ✅ 类文件API（JEP 457）：解析、生成和转换类文件的API

  • ✅ 未命名类和实例main方法（JEP 463）：简化小型程序开发

  • ✅ 构造函数前语句（JEP 447）：在super()/this()前执行语句

  • ✅ G1区域固定（JEP 423）：减少GC暂停时间

  • ✅ 向量API（JEP 460）：利用SIMD指令提升性能

  • ✅ 启动多个源文件程序（JEP 458）：直接运行多个源文件

  • 最新特性：了解Java语言的最新发展方向

  • 提升效率：新特性可以大幅提升开发效率

  • 性能优化：向量API、G1优化等提升应用性能

  • 现代化编程：支持更现代的编程范式

  • 面试加分：掌握最新特性在面试中更有优势

  • LTS版本：Java 22不是LTS版本，Java 21是当前LTS版本

  • 预览特性：部分特性仍处于预览阶段，可能在未来版本中调整

  • 孵化特性：部分特性处于孵化阶段，API可能变化

2. 环境搭建

Windows系统

  1. 访问Oracle官网：https://www.oracle.com/java/technologies/downloads/#java22
  2. 选择Windows版本下载
  3. 运行安装程序，按照提示完成安装
  4. 记住安装路径（默认：C:\Program Files\Java\jdk-22）

macOS系统

方式1：使用Homebrew（推荐）

brew install openjdk@22

方式2：手动下载

  1. 访问Oracle或Adoptium官网下载macOS版本
  2. 安装后配置环境变量

Linux系统

# Ubuntu/Debian
sudo apt update
sudo apt install openjdk-22-jdk

# CentOS/RHEL
sudo yum install java-22-openjdk-devel

Windows

  1. 右键"此电脑" → "属性" → "高级系统设置" → "环境变量"
  2. 新建系统变量：
    • 变量名：JAVA_HOME
    • 变量值：C:\Program Files\Java\jdk-22
  3. 编辑Path变量，添加：%JAVA_HOME%\bin

macOS/Linux

编辑 ~/.zshrc 或 ~/.bash_profile：

export JAVA_HOME=$(/usr/libexec/java_home -v 22)
export PATH=$JAVA_HOME/bin:$PATH

然后执行：

source ~/.zshrc
java -version
# 应该显示：openjdk version "22" 或 java version "22"

javac -version
# 应该显示：javac 22

IntelliJ IDEA

  1. File → Project Structure → Project
  2. 设置Project SDK为JDK 22
  3. 设置Language level为22

Eclipse

  1. Window → Preferences → Java → Installed JREs
  2. 添加JDK 22
  3. 在项目属性中设置Java Build Path使用JDK 22

3. 未命名变量和模式

Java 22引入了未命名变量和模式（JEP 456），允许使用下划线 _ 来表示未使用的变量或模式组件，提高代码可读性。

基本用法

// 传统方式：必须命名未使用的变量
try {
    int result = processData();
} catch (Exception e) {
    // e未使用，但仍需命名
    logError();
}

// Java 22方式：使用下划线
try {
    int result = processData();
} catch (Exception _) {
    // 使用下划线表示未使用的异常变量
    logError();
}

实际应用示例

示例1：增强for循环

List<String> names = List.of("Alice", "Bob", "Charlie");

// 传统方式
int count = 0;
for (String name : names) {
    count++; // name未使用
}

// Java 22方式
int count2 = 0;
for (String _ : names) {
    count2++;
}

示例2：Lambda表达式

Map<String, Integer> map = Map.of("a", 1, "b", 2, "c", 3);

// 只遍历键，不使用值
map.forEach((key, _) -> System.out.println("Key: " + key));

// 只遍历值，不使用键
map.forEach((_, value) -> System.out.println("Value: " + value));

示例3：try-with-resources

// 资源未使用但需要关闭
try (var _ = acquireResource()) {
    doSomething();
}

示例4：赋值语句

// 忽略返回值
int _ = computeExpensiveOperation();
doSomethingElse();

记录模式匹配

record Point(int x, int y, int z) {}

Point p = new Point(10, 20, 30);

// 传统方式：必须命名所有组件
if (p instanceof Point(int x, int y, int z)) {
    System.out.println("X: " + x + ", Y: " + y);
    // z未使用
}

// Java 22方式：使用下划线
if (p instanceof Point(int x, int y, int _)) {
    System.out.println("X: " + x + ", Y: " + y);
}

嵌套模式匹配

record Rectangle(Point topLeft, Point bottomRight) {}

Rectangle rect = new Rectangle(
    new Point(0, 0, 0),
    new Point(100, 100, 0)
);

// 只匹配需要的部分
if (rect instanceof Rectangle(Point(int x, int y, _), Point(int x2, int y2, _))) {
    System.out.println("Top-left: (" + x + ", " + y + ")");
    System.out.println("Bottom-right: (" + x2 + ", " + y2 + ")");
}

switch表达式中的模式

Object obj = new Point(10, 20, 30);

String result = switch (obj) {
    case Point(int x, int y, int _) -> "Point at (" + x + ", " + y + ")";
    case String s -> "String: " + s;
    case Integer _ -> "Integer (value ignored)";
    default -> "Unknown";
};
  1. 不能读取：未命名变量不能读取，只能写入
  2. 不能重复使用：同一作用域中可以有多个未命名变量
  3. 类型推断：未命名变量仍然参与类型推断
// 错误示例：不能读取未命名变量
int _ = 10;
System.out.println(_); // 编译错误！

// 正确示例：可以有多个未命名变量
int _ = 10;
String _ = "hello"; // 允许，因为未命名变量不冲突
  • ✅ 在catch块中使用未命名变量
  • ✅ 在Lambda表达式中忽略不需要的参数
  • ✅ 在模式匹配中忽略不需要的组件
  • ❌ 不要过度使用，保持代码可读性

4. 字符串模板（预览）

字符串模板（String Templates，JEP 459）是Java 22的预览特性，提供了更安全和灵活的字符串插值功能，避免了传统字符串拼接的问题。

STR模板处理器

import static java.lang.StringTemplate.STR;

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 30 years old.

基本语法规则

  • 模板以 STR. 开头
  • 使用 \{expression} 进行插值
  • 表达式可以是任何Java表达式

示例1：简单插值

import static java.lang.StringTemplate.STR;

String firstName = "John";
String lastName = "Doe";
String fullName = STR."\{firstName} \{lastName}";
System.out.println(fullName); // John Doe

示例2：表达式计算

import static java.lang.StringTemplate.STR;

int a = 10;
int b = 20;
String result = STR."Sum: \{a + b}";
System.out.println(result); // Sum: 30

示例3：方法调用

import static java.lang.StringTemplate.STR;

String name = "Alice";
String greeting = STR."Hello, \{name.toUpperCase()}!";
System.out.println(greeting); // Hello, ALICE!

示例4：多行字符串

import static java.lang.StringTemplate.STR;

String name = "Bob";
int score = 95;
String report = STR."""
    Student Report
    ==============
    Name: \{name}
    Score: \{score}
    Grade: \{score >= 90 ? "A" : "B"}
    """;
System.out.println(report);

示例5：SQL查询构建

import static java.lang.StringTemplate.STR;

String tableName = "users";
String column = "name";
String value = "Alice";

String sql = STR."SELECT * FROM \{tableName} WHERE \{column} = '\{value}'";
System.out.println(sql);
// 输出: SELECT * FROM users WHERE name = 'Alice'
import java.lang.StringTemplate.Processor;

// 自定义模板处理器
Processor<String, RuntimeException> UPPER = (StringTemplate st) -> {
    StringBuilder sb = new StringBuilder();
    List<String> fragments = st.fragments();
    List<Object> values = st.values();
    
    for (int i = 0; i < fragments.size(); i++) {
        sb.append(fragments.get(i));
        if (i < values.size()) {
            sb.append(values.get(i).toString().toUpperCase());
        }
    }
    return sb.toString();
};

// 使用自定义处理器
String result = UPPER."hello \{name}";
System.out.println(result); // hello ALICE
  1. 安全性：自动转义，防止注入攻击
  2. 可读性：比字符串拼接更清晰
  3. 性能：编译时优化
  4. 灵活性：支持自定义处理器

编译和运行需要启用预览特性：

# 编译
javac --enable-preview --release 22 Main.java

# 运行
java --enable-preview Main

5. 结构化并发（预览）

结构化并发（Structured Concurrency，JEP 462）是Java 22的预览特性，提供了一种更安全、更易理解的并发编程模型，确保任务的生命周期与代码结构一致。

结构化并发的核心思想：

  • 任务的生命周期与代码块绑定
  • 自动管理任务取消和异常处理
  • 避免线程泄漏和资源泄漏

基本用法

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

try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
    Future<String> task1 = scope.fork(() -> fetchUserData("user1"));
    Future<String> task2 = scope.fork(() -> fetchUserData("user2"));
    
    scope.join(); // 等待所有任务完成
    
    String result1 = task1.resultNow();
    String result2 = task2.resultNow();
    
    System.out.println(result1);
    System.out.println(result2);
} catch (Exception e) {
    // 自动处理异常和取消
    e.printStackTrace();
}

ShutdownOnFailure策略

// 任何一个任务失败，立即取消其他任务
try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
    Future<String> task1 = scope.fork(() -> {
        Thread.sleep(1000);
        return "Task 1";
    });
    
    Future<String> task2 = scope.fork(() -> {
        throw new RuntimeException("Task failed");
    });
    
    scope.join();
    scope.throwIfFailed(); // 如果有失败，抛出异常
} catch (Exception e) {
    System.out.println("Task failed: " + e.getMessage());
}

ShutdownOnSuccess策略

// 任何一个任务成功，立即取消其他任务
try (var scope = new StructuredTaskScope.ShutdownOnSuccess<String>()) {
    Future<String> task1 = scope.fork(() -> {
        Thread.sleep(2000);
        return "Task 1";
    });
    
    Future<String> task2 = scope.fork(() -> {
        Thread.sleep(500);
        return "Task 2"; // 这个先完成
    });
    
    scope.join();
    String result = scope.result(); // 返回第一个成功的结果
    System.out.println(result); // Task 2
}

示例1：并行调用多个API

record ApiResponse(String data) {}

try (var scope = new StructuredTaskScope.ShutdownOnSuccess<ApiResponse>()) {
    Future<ApiResponse> api1 = scope.fork(() -> callApi1());
    Future<ApiResponse> api2 = scope.fork(() -> callApi2());
    Future<ApiResponse> api3 = scope.fork(() -> callApi3());
    
    scope.join();
    ApiResponse result = scope.result();
    return result.data();
} catch (Exception e) {
    throw new RuntimeException("All APIs failed", e);
}

示例2：并行处理数据

List<String> data = List.of("data1", "data2", "data3", "data4");

try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
    List<Future<String>> futures = data.stream()
        .map(item -> scope.fork(() -> processItem(item)))
        .toList();
    
    scope.join();
    scope.throwIfFailed();
    
    List<String> results = futures.stream()
        .map(Future::resultNow)
        .toList();
    
    return results;
}

示例3：超时控制

try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
    Future<String> task = scope.fork(() -> longRunningTask());
    
    scope.joinUntil(Instant.now().plusSeconds(5)); // 5秒超时
    
    if (task.state() == Future.State.SUCCESS) {
        return task.resultNow();
    } else {
        throw new TimeoutException("Task timeout");
    }
}
  1. 自动资源管理：任务自动取消和清理
  2. 异常传播：异常自动传播到父作用域
  3. 避免泄漏：防止线程和资源泄漏
  4. 代码清晰：代码结构反映并发结构

6. 作用域值（预览）

作用域值（Scoped Values，JEP 464）是Java 22的预览特性，提供了一种在同一线程内传递不可变数据的机制，是ThreadLocal的现代化替代方案。

ThreadLocal的问题：

  • 可变性：可以随时修改
  • 继承问题：子线程无法继承
  • 内存泄漏风险：容易导致内存泄漏

作用域值的优势：

  • 不可变性：值一旦设置就不能修改
  • 结构化：与代码作用域绑定
  • 性能更好：比ThreadLocal更高效

创建和作用域值

import jdk.incubator.concurrent.ScopedValue;

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

// 设置和使用
ScopedValue.runWhere(USERNAME, "Alice", () -> {
    String username = USERNAME.get();
    System.out.println("Current user: " + username); // Alice
});

嵌套作用域

private static final ScopedValue<String> USERNAME = ScopedValue.newInstance();
private static final ScopedValue<String> ROLE = ScopedValue.newInstance();

ScopedValue.runWhere(USERNAME, "Alice", () -> {
    System.out.println("Outer: " + USERNAME.get()); // Alice
    
    ScopedValue.runWhere(ROLE, "Admin", () -> {
        System.out.println("Inner: " + USERNAME.get()); // Alice (继承)
        System.out.println("Role: " + ROLE.get()); // Admin
    });
    
    // ROLE在这里不可访问
    // System.out.println(ROLE.get()); // 错误！
});

示例1：用户上下文传递

public class UserContext {
    private static final ScopedValue<String> USERNAME = ScopedValue.newInstance();
    private static final ScopedValue<Integer> USER_ID = ScopedValue.newInstance();
    
    public static void setUser(String username, int userId) {
        ScopedValue.runWhere(USERNAME, username, () -> {
            ScopedValue.runWhere(USER_ID, userId, () -> {
                processRequest();
            });
        });
    }
    
    private static void processRequest() {
        String username = USERNAME.get();
        int userId = USER_ID.get();
        System.out.println("Processing request for user: " + username + " (ID: " + userId + ")");
    }
}

示例2：与结构化并发结合

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

ScopedValue.runWhere(REQUEST_ID, generateRequestId(), () -> {
    try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
        Future<String> task1 = scope.fork(() -> {
            String id = REQUEST_ID.get(); // 可以访问
            return processTask1(id);
        });
        
        Future<String> task2 = scope.fork(() -> {
            String id = REQUEST_ID.get(); // 可以访问
            return processTask2(id);
        });
        
        scope.join();
    }
});

示例3：配置传递

record Config(String databaseUrl, int timeout) {}

private static final ScopedValue<Config> CONFIG = ScopedValue.newInstance();

public void executeWithConfig(Config config) {
    ScopedValue.runWhere(CONFIG, config, () -> {
        connectToDatabase();
        executeQuery();
    });
}

private void connectToDatabase() {
    Config config = CONFIG.get();
    System.out.println("Connecting to: " + config.databaseUrl());
}

private void executeQuery() {
    Config config = CONFIG.get();
    System.out.println("Timeout: " + config.timeout());
}
  1. 不可变性：值不能修改，更安全
  2. 结构化：与代码作用域绑定
  3. 性能：比ThreadLocal更高效
  4. 清晰性：明确的作用域边界

7. 外部函数和内存API

外部函数和内存API（Foreign Function & Memory API，JEP 454）提供了与本地代码交互的标准化API，替代了不安全的JNI。

调用C函数

import java.lang.foreign.*;
import java.lang.invoke.MethodHandle;

// 查找C标准库函数
Linker linker = Linker.nativeLinker();
SymbolLookup stdlib = linker.defaultLookup();

// 查找printf函数
MemorySegment printfAddr = stdlib.find("printf").orElseThrow();

// 定义函数签名
FunctionDescriptor printfDesc = FunctionDescriptor.of(
    ValueLayout.JAVA_INT,  // 返回值类型
    ValueLayout.ADDRESS    // 参数类型（字符串）
);

// 创建方法句柄
MethodHandle printf = linker.downcallHandle(printfAddr, printfDesc);

// 调用函数
try (Arena arena = Arena.ofConfined()) {
    MemorySegment cString = arena.allocateUtf8String("Hello from C!\n");
    int result = (int) printf.invoke(cString);
    System.out.println("printf returned: " + result);
}

内存分配

import java.lang.foreign.*;

// 使用Arena管理内存
try (Arena arena = Arena.ofConfined()) {
    // 分配内存
    MemorySegment segment = arena.allocate(100);
    
    // 写入数据
    segment.set(ValueLayout.JAVA_INT, 0, 42);
    
    // 读取数据
    int value = segment.get(ValueLayout.JAVA_INT, 0);
    System.out.println("Value: " + value); // 42
}

示例1：调用数学库函数

Linker linker = Linker.nativeLinker();
SymbolLookup mathLib = linker.defaultLookup();

MemorySegment sqrtAddr = mathLib.find("sqrt").orElseThrow();
FunctionDescriptor sqrtDesc = FunctionDescriptor.of(
    ValueLayout.JAVA_DOUBLE,
    ValueLayout.JAVA_DOUBLE
);

MethodHandle sqrt = linker.downcallHandle(sqrtAddr, sqrtDesc);

double result = (double) sqrt.invoke(16.0);
System.out.println("sqrt(16) = " + result); // 4.0

8. Stream Gatherers（预览）

Stream Gatherers（JEP 461）是Java 22的预览特性，提供了更灵活的流操作，允许自定义流元素的收集和转换逻辑。

使用gather方法

import java.util.stream.*;

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

// 使用gather进行自定义操作
List<Integer> result = numbers.stream()
    .gather(Gatherers.windowFixed(3))
    .flatMap(List::stream)
    .toList();

System.out.println(result);

windowFixed - 固定窗口

List<Integer> numbers = List.of(1, 2, 3, 4, 5);

List<List<Integer>> windows = numbers.stream()
    .gather(Gatherers.windowFixed(2))
    .toList();

// 结果: [[1, 2], [3, 4], [5]]

windowSliding - 滑动窗口

List<Integer> numbers = List.of(1, 2, 3, 4, 5);

List<List<Integer>> windows = numbers.stream()
    .gather(Gatherers.windowSliding(3))
    .toList();

// 结果: [[1, 2, 3], [2, 3, 4], [3, 4, 5]]

fold - 折叠操作

List<Integer> numbers = List.of(1, 2, 3, 4, 5);

List<Integer> folded = numbers.stream()
    .gather(Gatherers.fold(() -> 0, Integer::sum))
    .toList();

// 结果: [1, 3, 6, 10, 15] (累积和)
import java.util.stream.Gatherer;

// 自定义Gatherer：只保留满足条件的元素
Gatherer<Integer, ?, Integer> filterEven = new Gatherer<>() {
    @Override
    public Integrator<Integer, Integer, Integer> integrator() {
        return (state, element, downstream) -> {
            if (element % 2 == 0) {
                return downstream.push(element);
            }
            return true;
        };
    }
};

List<Integer> numbers = List.of(1, 2, 3, 4, 5, 6);
List<Integer> evens = numbers.stream()
    .gather(filterEven)
    .toList();

// 结果: [2, 4, 6]

9. 类文件API（预览）

类文件API（Class-File API，JEP 457）提供了用于解析、生成和转换Java类文件的API，方便工具和框架的开发。

解析类文件

import java.lang.classfile.*;
import java.nio.file.Files;
import java.nio.file.Path;

Path classFile = Path.of("Example.class");
byte[] bytes = Files.readAllBytes(classFile);

ClassModel classModel = ClassFile.of().parse(bytes);

// 获取类名
String className = classModel.thisClass().asInternalName();
System.out.println("Class name: " + className);

// 遍历方法
classModel.methods().forEach(method -> {
    System.out.println("Method: " + method.methodName().stringValue());
});

生成类文件

import java.lang.classfile.*;

byte[] bytes = ClassFile.of().build(ClassDesc.of("Hello"), classBuilder -> {
    classBuilder.withMethod("main", MethodTypeDesc.of(CD_void, CD_String.arrayType()),
        ClassFile.ACC_PUBLIC | ClassFile.ACC_STATIC, methodBuilder -> {
            methodBuilder.withCode(codeBuilder -> {
                codeBuilder.getstatic(ClassDesc.of("java.lang.System"), "out",
                    ClassDesc.of("java.io.PrintStream"));
                codeBuilder.ldc("Hello, World!");
                codeBuilder.invokevirtual(ClassDesc.of("java.io.PrintStream"), "println",
                    MethodTypeDesc.of(CD_void, CD_String));
                codeBuilder.return_();
            });
        });
});

10. 未命名类和实例main方法（预览）

未命名类和实例main方法（JEP 463）允许在未命名的类中定义main方法，简化小型程序的开发。

最简单的Java程序

// Hello.java - 不需要public class声明
void main() {
    System.out.println("Hello, World!");
}

编译和运行：

javac --enable-preview --release 22 Hello.java
java --enable-preview Hello

带参数的main方法

void main(String[] args) {
    if (args.length > 0) {
        System.out.println("Hello, " + args[0] + "!");
    } else {
        System.out.println("Hello, World!");
    }
}

实例main方法

// 实例main方法，不需要static
void main() {
    Greeter greeter = new Greeter();
    greeter.greet("World");
}

class Greeter {
    void greet(String name) {
        System.out.println("Hello, " + name + "!");
    }
}
  • ✅ 小型脚本和工具
  • ✅ 学习和教学示例
  • ✅ 快速原型开发
  • ❌ 大型项目仍应使用标准类结构

11. 构造函数前语句（预览）

构造函数前语句（JEP 447）允许在调用super()或this()之前执行语句，提供了更大的灵活性。

传统限制

// Java 22之前：必须在第一行调用super()或this()
public class Child extends Parent {
    public Child(int value) {
        super(value); // 必须在第一行
        // 其他初始化代码
    }
}

Java 22方式

public class Parent {
    public Parent(int value) {
        System.out.println("Parent constructor: " + value);
    }
}

public class Child extends Parent {
    public Child(int value) {
        // 现在可以在super()之前执行语句
        int computedValue = computeValue(value);
        super(computedValue);
        System.out.println("Child constructor");
    }
    
    private int computeValue(int value) {
        return value * 2;
    }
}
  1. 不能访问this：在super()调用前不能访问this
  2. 不能访问实例字段：只能访问静态字段和方法
  3. 必须调用super()或this()：最终必须调用其中一个
public class Child extends Parent {
    private int field;
    
    public Child() {
        // 错误：不能访问实例字段
        // int x = this.field;
        
        // 正确：可以访问静态成员
        int y = staticMethod();
        
        super(y);
        
        // 现在可以访问实例成员
        this.field = 10;
    }
    
    private static int staticMethod() {
        return 42;
    }
}

12. G1垃圾收集器区域固定

G1区域固定（JEP 423）是G1垃圾收集器的改进，允许固定某些内存区域，减少GC暂停时间。

启用G1和区域固定

java -XX:+UseG1GC -XX:+G1RegionPinning YourApplication

在代码中固定区域

import jdk.internal.vm.annotation.RegionPinned;

@RegionPinned
public class CriticalData {
    private byte[] data;
    
    public CriticalData(int size) {
        this.data = new byte[size];
    }
}
  • 实时应用
  • 低延迟要求
  • 关键数据结构需要避免GC影响

13. 向量API（第七孵化版）

向量API（JEP 460）提供了用于向量计算的API，利用SIMD指令提高性能。

import jdk.incubator.vector.*;

float[] a = {1.0f, 2.0f, 3.0f, 4.0f};
float[] b = {5.0f, 6.0f, 7.0f, 8.0f};
float[] c = new float[4];

VectorSpecies<Float> species = FloatVector.SPECIES_128;
FloatVector va = FloatVector.fromArray(species, a, 0);
FloatVector vb = FloatVector.fromArray(species, b, 0);
FloatVector vc = va.add(vb);
vc.intoArray(c, 0);

// 结果: [6.0, 8.0, 10.0, 12.0]

向量API可以利用CPU的SIMD指令，大幅提升数值计算性能，特别适合：

  • 科学计算
  • 图像处理
  • 机器学习
  • 大数据处理

14. 启动多个源文件程序

Java 22（JEP 458）允许直接运行多个源文件，无需先编译。

基本用法

# 运行多个源文件
java Main.java Helper.java Util.java

示例

Main.java:

void main() {
    Helper helper = new Helper();
    helper.doSomething();
}

Helper.java:

class Helper {
    void doSomething() {
        System.out.println("Helper is working");
    }
}

运行：

java Main.java Helper.java
  • 小型项目
  • 快速原型
  • 教学示例
  • 脚本开发

15. 实际应用案例

import java.util.concurrent.StructuredTaskScope;
import jdk.incubator.concurrent.ScopedValue;

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

public Response handleRequest(Request request) {
    return ScopedValue.runWhere(REQUEST_ID, generateId(), () -> {
        try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
            Future<User> userFuture = scope.fork(() -> fetchUser(request.userId()));
            Future<Config> configFuture = scope.fork(() -> fetchConfig());
            
            scope.join();
            scope.throwIfFailed();
            
            User user = userFuture.resultNow();
            Config config = configFuture.resultNow();
            
            return processRequest(user, config);
        }
    });
}
import static java.lang.StringTemplate.STR;

List<Record> records = fetchRecords();

String report = records.stream()
    .filter(r -> r.status().equals("active"))
    .map(r -> STR."\{r.name()}: \{r.value()}")
    .collect(Collectors.joining("\n"));

System.out.println(report);
record AppConfig(String dbUrl, int timeout) {}

private static final ScopedValue<AppConfig> CONFIG = ScopedValue.newInstance();

public void executeWithConfig(AppConfig config) {
    ScopedValue.runWhere(CONFIG, config, () -> {
        connectDatabase();
        executeOperations();
    });
}

16. 总结与最佳实践

  • ✅ 未命名变量和模式：提高代码可读性
  • ✅ 字符串模板：更安全的字符串插值
  • ✅ 结构化并发：简化并发编程
  • ✅ 作用域值：现代化的线程本地存储
  • ✅ 外部函数API：与本地代码交互
  • ✅ Stream Gatherers：增强流处理能力

  1. 预览特性：谨慎使用预览特性，API可能变化

  2. 性能考虑：向量API和G1优化可以提升性能

  3. 代码清晰：使用新特性提高代码可读性

  4. 渐进采用：逐步采用新特性，不要一次性全部使用

  5. 实践为主：多写代码练习

  6. 理解原理：理解每个特性的设计思想

  7. 关注更新：关注Java新版本的发展

  8. 社区参与：参与Java社区讨论

  • ⚠️ 部分特性是预览版，可能在未来版本中调整
  • ⚠️ 需要启用预览特性才能使用
  • ⚠️ 生产环境谨慎使用预览特性
  • ✅ LTS版本（Java 21）更适合生产环境

结语

Java 22带来了许多令人兴奋的新特性，进一步提升了Java语言的表达能力和开发效率。通过本教程的学习，相信你已经掌握了Java 22的核心特性。

记住：

  • 多实践：理论结合实践，多写代码
  • 理解设计：理解每个特性的设计思想
  • 关注稳定：生产环境优先使用稳定特性
  • 持续学习：关注Java语言的发展

祝你学习愉快，编程顺利！ 🚀

本教程由Java突击队学习社区编写，如有问题欢迎反馈。

一个可以快速提升Java技术的神奇网站
Copyright © 2025 Java突击队