Java18 新特性详解与实践

Java 18，简洁到极致！

2022年3月22日，Java 18正式发布了！虽然这是一个短期支持版本。作为通往下一个LTS版本Java 21的重要跳板，Java 18还是带来了很多新特性。

为什么Java 18值得关注？

Java 18虽然不是LTS版本，但它的意义非同小可：

• 简洁性革命：Simple Web Server让Java告别重型服务器配置
• 编码体验提升：UTF-8成为默认字符集，终结编码地狱
• 性能优化：Vector API和Switch模式匹配的性能飞跃
• 未来特性预览：Pattern Matching和Foreign Function API的前瞻性

核心特性一览

1. Simple Web Server（简单Web服务器）- JEP 408

解决了什么痛点？

简单Web服务器的敌人是那些重型框架的开发环境配置地狱！你是否还记得为了测试一个简单的静态页面，需要配置Tomcat、Nginx，或者安装Node.js来启动一个http-server？那些复杂的配置文件、端口冲突、依赖地狱，简直是在侮辱"快速原型"这四个字！

用起来爽不爽？

第一次用这个特性时，我的感受是"简洁！ "一行命令启动Web服务器，就像Python的python -m http.server一样简单，但这是Java啊！

代码示例

// 旧写法 - 复杂的Web服务器配置
// 需要引入Spring Boot或其他重型框架
@SpringBootApplication
@RestController
public class SimpleServerApplication {

    public static void main(String[] args) {
        SpringApplication.run(SimpleServerApplication.class, args);
    }

    @GetMapping("/")
    public String home() {
        return "Hello World";
    }

    @GetMapping("/api/data")
    public Map<String, Object> getData() {
        Map<String, Object> data = new HashMap<>();
        data.put("message", "Hello from Spring Boot");
        data.put("timestamp", System.currentTimeMillis());
        return data;
    }
}

// 还需要application.properties配置
// server.port=8080
// server.servlet.context-path=/

# 命令行启动 - 一行代码的Web服务器
jwebserver

# 指定端口和目录
jwebserver -p 9000 -d /path/to/your/files

# 绑定特定地址
jwebserver -b 0.0.0.0 -p 8080

// 新写法 - 编程式API
import com.sun.net.httpserver.SimpleFileServer;
import java.net.InetSocketAddress;
import java.nio.file.Path;

public class ModernWebServer {

    public static void main(String[] args) {
        // 创建简单的文件服务器
        var server = SimpleFileServer.createFileServer(
            new InetSocketAddress(8080),
            Path.of("./public"),
            SimpleFileServer.OutputLevel.VERBOSE
        );

        server.start();
        System.out.println("服务器启动: http://localhost:8080");

        // 创建自定义处理器的服务器
        createCustomServer();
    }

    private static void createCustomServer() {
        var server = HttpServer.create(new InetSocketAddress(8081), 0);

        // API端点
        server.createContext("/api/hello", exchange -> {
            String response = """
                {
                  "message": "Hello from Java 18!",
                  "timestamp": %d,
                  "version": "18"
                }
                """.formatted(System.currentTimeMillis());

            exchange.getResponseHeaders().set("Content-Type", "application/json");
            exchange.sendResponseHeaders(200, response.length());
            try (var os = exchange.getResponseBody()) {
                os.write(response.getBytes());
            }
        });

        // 健康检查端点
        server.createContext("/health", exchange -> {
            String health = "OK";
            exchange.sendResponseHeaders(200, health.length());
            try (var os = exchange.getResponseBody()) {
                os.write(health.getBytes());
            }
        });

        server.start();
        System.out.println("API服务器启动: http://localhost:8081");
    }
}

值不值得学？

对初级开发者：必学工具，开发利器。这是学习Web开发概念的完美起点，无需复杂配置就能理解HTTP协议。

对高级开发者：实用工具，快速原型。在开发过程中快速创建测试服务器、Mock API、静态资源服务。

对架构师/技术负责人：辅助工具，团队效率。可以显著提升团队的开发效率，特别是在前后端分离开发中。

2. UTF-8作为默认字符集 - JEP 400

解决了什么痛点？

UTF-8默认字符集的敌人是那个臭名昭著的字符编码地狱 ！那些因为平台差异导致的乱码问题，那些必须在每个项目中重复配置的-Dfile.encoding=UTF-8参数，那些Windows上默认GBK、Linux上默认UTF-8导致的跨平台兼容性噩梦！

用起来爽不爽？

"终于不用再写new String(bytes, StandardCharsets.UTF_8)了！ "这是一个看起来微不足道，实际上影响深远的改变。

代码示例

// 旧写法 - 字符编码的噩梦
public class EncodingHell {

    public void oldWayFileHandling() throws IOException {
        // 必须显式指定编码
        String content = Files.readString(
            Path.of("chinese.txt"),
            StandardCharsets.UTF_8  // 忘记这个就乱码
        );

        // 写文件也要指定编码
        Files.writeString(
            Path.of("output.txt"),
            "你好，世界！",
            StandardCharsets.UTF_8  // 又是显式指定
        );

        // 字节数组转字符串
        byte[] bytes = "测试数据".getBytes();
        String str = new String(bytes, StandardCharsets.UTF_8); // 繁琐
    }

    public void networkRequestPain() throws IOException {
        // HTTP请求中的编码问题
        HttpURLConnection conn = (HttpURLConnection)
            new URL("http://api.example.com").openConnection();

        conn.setRequestProperty("Content-Type",
            "application/json; charset=UTF-8"); // 必须显式声明

        // 读取响应
        try (var reader = new BufferedReader(new InputStreamReader(
                conn.getInputStream(), StandardCharsets.UTF_8))) { // 又是显式
            String response = reader.lines()
                .collect(Collectors.joining("\n"));
        }
    }
}

// 新写法 - Java 18的简洁
public class EncodingParadise {

    public void modernFileHandling() throws IOException {
        // 默认UTF-8，无需显式指定
        String content = Files.readString(Path.of("chinese.txt"));

        // 写文件，默认UTF-8
        Files.writeString(Path.of("output.txt"), "你好，世界！");

        // 字节数组转字符串，默认UTF-8
        byte[] bytes = "测试数据".getBytes();
        String str = new String(bytes); // 简洁！

        // 处理多语言内容
        processMultiLanguageContent();
    }

    private void processMultiLanguageContent() throws IOException {
        Map<String, String> multilingual = Map.of(
            "chinese", "你好，世界！",
            "japanese", "こんにちは、世界！",
            "korean", "안녕하세요, 세계!",
            "arabic", "مرحبا بالعالم",
            "russian", "Привет, мир!",
            "emoji", "👋🌍✨"
        );

        // 全部正确处理，无需担心编码
        multilingual.forEach((lang, text) -> {
            try {
                Files.writeString(
                    Path.of(lang + ".txt"),
                    text
                ); // 默认UTF-8，完美支持

                System.out.println(lang + ": " + text);
            } catch (IOException e) {
                e.printStackTrace();
            }
        });
    }

    public void streamProcessing() {
        List<String> names = List.of(
            "张三", "李四", "王五",
            "José", "François", "Müller",
            "الأحمد", "田中太郎"
        );

        // 流处理，默认UTF-8编码
        String result = names.stream()
            .map(name -> "Hello, " + name + "!")
            .collect(Collectors.joining("\n"));

        System.out.println(result); // 完美显示所有字符
    }
}

实际价值

// 跨平台兼容性测试
public class CrossPlatformTest {

    public static void main(String[] args) {
        System.out.println("默认字符集: " + Charset.defaultCharset());
        System.out.println("文件编码: " + System.getProperty("file.encoding"));

        // 在Windows、Linux、macOS上都是UTF-8
        testChineseCharacters();
        testEmojiSupport();
        testComplexUnicode();
    }

    private static void testChineseCharacters() {
        String chinese = "Java 18 中文支持测试：你好世界！";
        System.out.println("中文测试: " + chinese);

        // 字节长度测试
        byte[] bytes = chinese.getBytes(); // 默认UTF-8
        System.out.println("字节长度: " + bytes.length);
        System.out.println("字符长度: " + chinese.length());
    }

    private static void testEmojiSupport() {
        String emoji = "Java 18 🚀 性能提升 💯 开发体验 ✨";
        System.out.println("Emoji测试: " + emoji);

        // 正确处理Emoji的字符数
        System.out.println("码点数: " + emoji.codePointCount(0, emoji.length()));
    }

    private static void testComplexUnicode() {
        // 复杂Unicode字符
        String complex = "𝒥𝒶𝓋𝒶 𝟣𝟪"; // 数学字体
        System.out.println("复杂Unicode: " + complex);

        // 正确处理
        complex.codePoints()
            .forEach(cp -> System.out.printf("U+%04X ", cp));
        System.out.println();
    }
}

3. Code Snippets in Java API Documentation - JEP 413

解决了什么痛点？

文档代码片段的敌人是那些过时、错误、无法验证的API文档示例！那些复制粘贴就报错的代码，那些版本更新后就失效的示例，那些让开发者浪费大量时间调试的"假示例"！

用起来爽不爽？

"终于有可靠的文档了！ "再也不用担心API文档中的示例代码是否能正常运行。

代码示例

/**
 * 用户服务类，提供用户管理的核心功能
 *
 * <p>使用示例：
 * {@snippet :
 * // 创建用户服务
 * UserService service = new UserService();
 *
 * // 创建新用户
 * User user = service.createUser("张三", "zhangsan@example.com");
 *
 * // 查询用户
 * Optional<User> found = service.findUserById(user.getId());
 * if (found.isPresent()) {
 *     System.out.println("找到用户: " + found.get().getName());
 * }
 *
 * // 更新用户信息
 * service.updateUser(user.getId(), "张三丰", null);
 * }
 *
 * <p>批量操作示例：
 * {@snippet file="UserServiceBatchExample.java" region="batch-operations"}
 */
public class UserService {

    private final Map<Long, User> users = new ConcurrentHashMap<>();
    private final AtomicLong idGenerator = new AtomicLong(1);

    /**
     * 创建新用户
     *
     * @param name 用户名称
     * @param email 用户邮箱
     * @return 创建的用户对象
     *
     * {@snippet :
     * UserService service = new UserService();
     *
     * // @highlight substring="createUser" type="highlighted"
     * User user = service.createUser("李四", "lisi@example.com");
     *
     * // @replace regex='"李四"' replacement='"your-name"'
     * // @replace regex='"lisi@example.com"' replacement='"your-email@example.com"'
     * }
     */
    public User createUser(String name, String email) {
        if (name == null || name.trim().isEmpty()) {
            throw new IllegalArgumentException("用户名不能为空");
        }
        if (email == null || !email.contains("@")) {
            throw new IllegalArgumentException("邮箱格式不正确");
        }

        User user = new User(idGenerator.getAndIncrement(), name, email);
        users.put(user.getId(), user);
        return user;
    }

    /**
     * 根据ID查找用户
     *
     * {@snippet :
     * UserService service = new UserService();
     * User user = service.createUser("王五", "wangwu@example.com");
     *
     * // 查找存在的用户
     * Optional<User> found = service.findUserById(user.getId()); // @highlight
     *
     * // 查找不存在的用户
     * Optional<User> notFound = service.findUserById(999L);
     * assert notFound.isEmpty(); // @highlight
     * }
     */
    public Optional<User> findUserById(Long id) {
        return Optional.ofNullable(users.get(id));
    }

    /**
     * 更新用户信息
     *
     * {@snippet :
     * UserService service = new UserService();
     * User user = service.createUser("赵六", "zhaoliu@example.com");
     *
     * // 只更新名称
     * boolean updated = service.updateUser(user.getId(), "赵六六", null);
     * assert updated;
     *
     * // 更新邮箱
     * service.updateUser(user.getId(), null, "new-email@example.com");
     *
     * // 同时更新名称和邮箱
     * service.updateUser(user.getId(), "新名称", "newest@example.com");
     * }
     */
    public boolean updateUser(Long id, String newName, String newEmail) {
        User user = users.get(id);
        if (user == null) {
            return false;
        }

        if (newName != null && !newName.trim().isEmpty()) {
            user.setName(newName);
        }
        if (newEmail != null && newEmail.contains("@")) {
            user.setEmail(newEmail);
        }

        return true;
    }
}

/**
 * 用户实体类
 *
 * {@snippet :
 * // 创建用户
 * User user = new User(1L, "测试用户", "test@example.com");
 *
 * // 获取用户信息
 * System.out.println("ID: " + user.getId());         // @highlight
 * System.out.println("姓名: " + user.getName());      // @highlight
 * System.out.println("邮箱: " + user.getEmail());     // @highlight
 *
 * // 修改用户信息
 * user.setName("新名称");
 * user.setEmail("new@example.com");
 * }
 */
public record User(Long id, String name, String email) {

    public User {
        if (id == null || id <= 0) {
            throw new IllegalArgumentException("ID必须为正数");
        }
        if (name == null || name.trim().isEmpty()) {
            throw new IllegalArgumentException("姓名不能为空");
        }
        if (email == null || !email.contains("@")) {
            throw new IllegalArgumentException("邮箱格式不正确");
        }
    }

    // 由于使用了record，这些方法会自动生成
    // public Long getId() { return id; }
    // public String getName() { return name; }
    // public String getEmail() { return email; }
}

// UserServiceBatchExample.java
public class UserServiceBatchExample {

    // @start region="batch-operations"
    public static void demonstrateBatchOperations() {
        UserService service = new UserService();

        // 批量创建用户
        List<User> users = List.of(
            service.createUser("用户1", "user1@example.com"),
            service.createUser("用户2", "user2@example.com"),
            service.createUser("用户3", "user3@example.com")
        );

        // 批量查询
        List<Long> userIds = users.stream()
            .map(User::getId)
            .toList();

        List<User> foundUsers = userIds.stream()
            .map(service::findUserById)
            .filter(Optional::isPresent)
            .map(Optional::get)
            .toList();

        System.out.println("找到 " + foundUsers.size() + " 个用户");

        // 批量更新
        foundUsers.forEach(user ->
            service.updateUser(user.getId(),
                user.getName() + "_updated",
                null)
        );
    }
    // @end region="batch-operations"
}

4. Vector API (Second Incubator) - JEP 417

解决了什么痛点？

Vector API的敌人是传统的标量计算性能瓶颈！那些只能逐个元素处理的循环，那些无法利用现代CPU SIMD指令集的低效计算，那些在处理大量数据时让人抓狂的性能问题！

用起来爽不爽？

"这是Java向高性能计算的重要一步！ "虽然还在孵化阶段，但已经能感受到向量化计算的强大威力。

代码示例

import jdk.incubator.vector.*;

// 旧写法 - 标量计算的性能瓶颈
public class ScalarComputation {

    public static double[] addArraysScalar(double[] a, double[] b) {
        double[] result = new double[a.length];

        // 逐个元素计算，无法利用CPU的向量指令
        for (int i = 0; i < a.length; i++) {
            result[i] = a[i] + b[i]; // 标量加法
        }

        return result;
    }

    public static double dotProductScalar(double[] a, double[] b) {
        double sum = 0.0;

        // 标量点积计算
        for (int i = 0; i < a.length; i++) {
            sum += a[i] * b[i]; // 逐个相乘再累加
        }

        return sum;
    }

    public static void normalizeArrayScalar(double[] array) {
        // 计算向量长度
        double magnitude = 0.0;
        for (double value : array) {
            magnitude += value * value;
        }
        magnitude = Math.sqrt(magnitude);

        // 归一化
        for (int i = 0; i < array.length; i++) {
            array[i] /= magnitude;
        }
    }
}

// 新写法 - Vector API的高性能计算
public class VectorComputation {

    private static final VectorSpecies<Double> SPECIES = DoubleVector.SPECIES_PREFERRED;

    public static double[] addArraysVector(double[] a, double[] b) {
        double[] result = new double[a.length];
        int vectorLength = SPECIES.length();
        int loopBound = SPECIES.loopBound(a.length);

        // 向量化处理主要部分
        for (int i = 0; i < loopBound; i += vectorLength) {
            DoubleVector va = DoubleVector.fromArray(SPECIES, a, i);
            DoubleVector vb = DoubleVector.fromArray(SPECIES, b, i);
            DoubleVector vc = va.add(vb); // 向量加法，一次处理多个元素
            vc.intoArray(result, i);
        }

        // 处理剩余元素
        for (int i = loopBound; i < a.length; i++) {
            result[i] = a[i] + b[i];
        }

        return result;
    }

    public static double dotProductVector(double[] a, double[] b) {
        DoubleVector sumVector = DoubleVector.zero(SPECIES);
        int vectorLength = SPECIES.length();
        int loopBound = SPECIES.loopBound(a.length);

        // 向量化点积计算
        for (int i = 0; i < loopBound; i += vectorLength) {
            DoubleVector va = DoubleVector.fromArray(SPECIES, a, i);
            DoubleVector vb = DoubleVector.fromArray(SPECIES, b, i);
            sumVector = va.fma(vb, sumVector); // 融合乘加操作
        }

        // 向量元素求和
        double sum = sumVector.reduceLanes(VectorOperators.ADD);

        // 处理剩余元素
        for (int i = loopBound; i < a.length; i++) {
            sum += a[i] * b[i];
        }

        return sum;
    }

    public static void normalizeArrayVector(double[] array) {
        // 向量化计算向量长度的平方
        DoubleVector sumSquareVector = DoubleVector.zero(SPECIES);
        int vectorLength = SPECIES.length();
        int loopBound = SPECIES.loopBound(array.length);

        for (int i = 0; i < loopBound; i += vectorLength) {
            DoubleVector v = DoubleVector.fromArray(SPECIES, array, i);
            sumSquareVector = v.fma(v, sumSquareVector); // v² + sum
        }

        double sumSquare = sumSquareVector.reduceLanes(VectorOperators.ADD);

        // 处理剩余元素
        for (int i = loopBound; i < array.length; i++) {
            sumSquare += array[i] * array[i];
        }

        double magnitude = Math.sqrt(sumSquare);
        DoubleVector magnitudeVector = DoubleVector.broadcast(SPECIES, magnitude);

        // 向量化归一化
        for (int i = 0; i < loopBound; i += vectorLength) {
            DoubleVector v = DoubleVector.fromArray(SPECIES, array, i);
            DoubleVector normalized = v.div(magnitudeVector);
            normalized.intoArray(array, i);
        }

        // 处理剩余元素
        for (int i = loopBound; i < array.length; i++) {
            array[i] /= magnitude;
        }
    }

    // 高性能矩阵运算示例
    public static void matrixMultiplyVector(double[][] a, double[][] b, double[][] result) {
        int rows = a.length;
        int cols = b[0].length;
        int inner = a[0].length;

        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < cols; j++) {
                DoubleVector sumVector = DoubleVector.zero(SPECIES);
                int vectorLength = SPECIES.length();
                int loopBound = SPECIES.loopBound(inner);

                // 向量化内积计算
                for (int k = 0; k < loopBound; k += vectorLength) {
                    DoubleVector va = DoubleVector.fromArray(SPECIES, a[i], k);

                    // 从矩阵B的列中提取向量
                    double[] bColumn = new double[vectorLength];
                    for (int v = 0; v < vectorLength && k + v < inner; v++) {
                        bColumn[v] = b[k + v][j];
                    }
                    DoubleVector vb = DoubleVector.fromArray(SPECIES, bColumn, 0);

                    sumVector = va.fma(vb, sumVector);
                }

                result[i][j] = sumVector.reduceLanes(VectorOperators.ADD);

                // 处理剩余元素
                for (int k = loopBound; k < inner; k++) {
                    result[i][j] += a[i][k] * b[k][j];
                }
            }
        }
    }
}

性能对比测试

public class VectorPerformanceTest {

    public static void main(String[] args) {
        int size = 1_000_000;
        double[] a = generateRandomArray(size);
        double[] b = generateRandomArray(size);

        // 预热JVM
        warmup(a, b);

        // 测试标量计算
        long startTime = System.nanoTime();
        for (int i = 0; i < 100; i++) {
            ScalarComputation.dotProductScalar(a, b);
        }
        long scalarTime = System.nanoTime() - startTime;

        // 测试向量计算
        startTime = System.nanoTime();
        for (int i = 0; i < 100; i++) {
            VectorComputation.dotProductVector(a, b);
        }
        long vectorTime = System.nanoTime() - startTime;

        System.out.printf("标量计算时间: %.2f ms%n", scalarTime / 1_000_000.0);
        System.out.printf("向量计算时间: %.2f ms%n", vectorTime / 1_000_000.0);
        System.out.printf("性能提升: %.2fx%n", (double) scalarTime / vectorTime);
    }

    private static double[] generateRandomArray(int size) {
        Random random = new Random(42); // 固定种子，确保可重复
        return random.doubles(size).toArray();
    }

    private static void warmup(double[] a, double[] b) {
        // JVM预热
        for (int i = 0; i < 10; i++) {
            ScalarComputation.dotProductScalar(a, b);
            VectorComputation.dotProductVector(a, b);
        }
    }
}

5. Pattern Matching for Switch (Second Preview) - JEP 420

解决了什么痛点？

增强模式匹配的敌人是那些冗长的类型检查和条件判断链！那些巨大的if-else if链条，那些重复的instanceof检查，那些让代码变得臃肿不堪的类型安全处理！

代码示例

// 旧写法 - 冗长的类型检查
public class OldPatternMatching {

    public String processShape(Object shape) {
        if (shape instanceof Circle) {
            Circle circle = (Circle) shape;
            return "圆形，面积: " + (Math.PI * circle.radius() * circle.radius());
        } else if (shape instanceof Rectangle) {
            Rectangle rect = (Rectangle) shape;
            return "矩形，面积: " + (rect.width() * rect.height());
        } else if (shape instanceof Triangle) {
            Triangle triangle = (Triangle) shape;
            double s = (triangle.a() + triangle.b() + triangle.c()) / 2;
            double area = Math.sqrt(s * (s - triangle.a()) * (s - triangle.b()) * (s - triangle.c()));
            return "三角形，面积: " + area;
        } else if (shape == null) {
            return "空形状";
        } else {
            return "未知形状: " + shape.getClass().getSimpleName();
        }
    }

    public String processPayment(Object payment) {
        String result = "";

        if (payment instanceof CreditCardPayment) {
            CreditCardPayment cc = (CreditCardPayment) payment;
            if (cc.amount() > 10000) {
                result = "大额信用卡支付: " + cc.amount() + "，需要额外验证";
            } else {
                result = "信用卡支付: " + cc.amount();
            }
        } else if (payment instanceof BankTransfer) {
            BankTransfer bt = (BankTransfer) payment;
            if (bt.amount() > 50000) {
                result = "大额银行转账: " + bt.amount() + "，需要人工审核";
            } else {
                result = "银行转账: " + bt.amount();
            }
        } else if (payment instanceof DigitalWallet) {
            DigitalWallet dw = (DigitalWallet) payment;
            result = "数字钱包支付: " + dw.amount() + " (余额: " + dw.balance() + ")";
        }

        return result;
    }
}

// 新写法 - Java 18的模式匹配增强
public class ModernPatternMatching {

    public String processShape(Object shape) {
        return switch (shape) {
            case Circle(var radius) ->
                "圆形，面积: " + (Math.PI * radius * radius);

            case Rectangle(var width, var height) ->
                "矩形，面积: " + (width * height);

            case Triangle(var a, var b, var c) -> {
                double s = (a + b + c) / 2;
                double area = Math.sqrt(s * (s - a) * (s - b) * (s - c));
                yield "三角形，面积: " + area;
            }

            case null -> "空形状";

            default -> "未知形状: " + shape.getClass().getSimpleName();
        };
    }

    public String processPayment(Object payment) {
        return switch (payment) {
            // 带守卫条件的模式匹配
            case CreditCardPayment(var amount) when amount > 10000 ->
                "大额信用卡支付: " + amount + "，需要额外验证";

            case CreditCardPayment(var amount) ->
                "信用卡支付: " + amount;

            case BankTransfer(var amount) when amount > 50000 ->
                "大额银行转账: " + amount + "，需要人工审核";

            case BankTransfer(var amount) ->
                "银行转账: " + amount;

            case DigitalWallet(var amount, var balance) ->
                "数字钱包支付: " + amount + " (余额: " + balance + ")";

            case null -> "空支付";

            default -> "不支持的支付方式";
        };
    }

    // 复杂的嵌套模式匹配
    public String analyzeApiResponse(Object response) {
        return switch (response) {
            case ApiResponse(200, var data) when data instanceof List<?> list && !list.isEmpty() ->
                "成功响应，包含 " + list.size() + " 条数据";

            case ApiResponse(200, var data) when data instanceof String str && !str.isEmpty() ->
                "成功响应，消息: " + str;

            case ApiResponse(var status, var data) when status >= 400 && status < 500 ->
                "客户端错误 " + status + ": " + data;

            case ApiResponse(var status, var data) when status >= 500 ->
                "服务器错误 " + status + ": " + data;

            case ApiResponse(var status, null) ->
                "空响应，状态码: " + status;

            case null -> "空响应对象";

            default -> "未知响应类型";
        };
    }
}

// 配套的记录类
record Circle(double radius) {}
record Rectangle(double width, double height) {}
record Triangle(double a, double b, double c) {}

record CreditCardPayment(double amount) {}
record BankTransfer(double amount) {}
record DigitalWallet(double amount, double balance) {}

record ApiResponse(int status, Object data) {}

6. Foreign Function & Memory API (Second Incubator) - JEP 419

解决了什么痛点？

Foreign Function API的敌人是JNI的复杂性地狱！那些需要编写C代码、配置构建脚本、处理内存管理的痛苦经历，那些平台相关的编译问题，那些调试起来让人抓狂的原生代码！

用起来爽不爽？

"终于可以优雅地调用原生代码了！ "告别JNI的繁琐配置，拥抱现代化的外部函数接口。

代码示例

// 旧写法 - JNI的噩梦
// 需要编写C代码
/*
// math_operations.c
#include <jni.h>
#include <math.h>

JNIEXPORT jdouble JNICALL
Java_MathOperations_nativeSquareRoot(JNIEnv *env, jobject obj, jdouble value) {
    return sqrt(value);
}

JNIEXPORT jint JNICALL
Java_MathOperations_nativeFactorial(JNIEnv *env, jobject obj, jint n) {
    if (n <= 1) return 1;
    return n * Java_MathOperations_nativeFactorial(env, obj, n - 1);
}
*/

public class OldJNIExample {
    // 加载原生库
    static {
        System.loadLibrary("math_operations");
    }

    // 声明原生方法
    public native double nativeSquareRoot(double value);
    public native int nativeFactorial(int n);

    public void useNativeMethods() {
        // 使用原生方法
        double sqrt = nativeSquareRoot(16.0);
        int factorial = nativeFactorial(5);

        System.out.println("Square root: " + sqrt);
        System.out.println("Factorial: " + factorial);
    }
}

// 新写法 - Foreign Function & Memory API
import java.lang.foreign.*;
import java.lang.invoke.MethodHandle;

public class ModernFFMExample {

    public static void main(String[] args) throws Throwable {
        // 现代化的原生函数调用
        demonstrateMathFunctions();
        demonstrateMemoryOperations();
        demonstrateStructAccess();
    }

    private static void demonstrateMathFunctions() throws Throwable {
        // 查找原生库
        Linker linker = Linker.nativeLinker();
        SymbolLookup mathLib = SymbolLookup.loaderLookup();

        // 查找sqrt函数
        MemorySegment sqrtSymbol = mathLib.lookup("sqrt").orElseThrow();

        // 创建函数描述符
        FunctionDescriptor sqrtDescriptor = FunctionDescriptor.of(
            ValueLayout.JAVA_DOUBLE,  // 返回值类型
            ValueLayout.JAVA_DOUBLE   // 参数类型
        );

        // 获取方法句柄
        MethodHandle sqrt = linker.downcallHandle(sqrtSymbol, sqrtDescriptor);

        // 调用原生函数
        double result = (double) sqrt.invoke(16.0);
        System.out.println("sqrt(16.0) = " + result);

        // 调用其他数学函数
        callOtherMathFunctions(linker, mathLib);
    }

    private static void callOtherMathFunctions(Linker linker, SymbolLookup mathLib)
            throws Throwable {

        // sin函数
        MemorySegment sinSymbol = mathLib.lookup("sin").orElseThrow();
        MethodHandle sin = linker.downcallHandle(
            sinSymbol,
            FunctionDescriptor.of(ValueLayout.JAVA_DOUBLE, ValueLayout.JAVA_DOUBLE)
        );

        double sinResult = (double) sin.invoke(Math.PI / 2);
        System.out.println("sin(π/2) = " + sinResult);

        // pow函数
        MemorySegment powSymbol = mathLib.lookup("pow").orElseThrow();
        MethodHandle pow = linker.downcallHandle(
            powSymbol,
            FunctionDescriptor.of(
                ValueLayout.JAVA_DOUBLE,
                ValueLayout.JAVA_DOUBLE,
                ValueLayout.JAVA_DOUBLE
            )
        );

        double powResult = (double) pow.invoke(2.0, 8.0);
        System.out.println("pow(2.0, 8.0) = " + powResult);
    }

    private static void demonstrateMemoryOperations() {
        try (Arena arena = Arena.openConfined()) {
            // 分配原生内存
            MemorySegment segment = arena.allocate(1024);

            // 写入数据
            for (int i = 0; i < 256; i++) {
                segment.setAtIndex(ValueLayout.JAVA_INT, i, i * i);
            }

            // 读取数据
            System.out.println("内存操作结果:");
            for (int i = 0; i < 10; i++) {
                int value = segment.getAtIndex(ValueLayout.JAVA_INT, i);
                System.out.println("位置 " + i + ": " + value);
            }

            // 内存会在try-with-resources块结束时自动释放
        }
    }

    private static void demonstrateStructAccess() {
        try (Arena arena = Arena.openConfined()) {
            // 定义结构体布局
            GroupLayout pointLayout = MemoryLayout.structLayout(
                ValueLayout.JAVA_DOUBLE.withName("x"),
                ValueLayout.JAVA_DOUBLE.withName("y")
            );

            // 分配结构体内存
            MemorySegment point = arena.allocate(pointLayout);

            // 设置结构体字段
            point.set(ValueLayout.JAVA_DOUBLE, 0, 10.5);  // x
            point.set(ValueLayout.JAVA_DOUBLE, 8, 20.3);  // y

            // 读取结构体字段
            double x = point.get(ValueLayout.JAVA_DOUBLE, 0);
            double y = point.get(ValueLayout.JAVA_DOUBLE, 8);

            System.out.println("Point: (" + x + ", " + y + ")");

            // 使用VarHandle进行类型安全的访问
            VarHandle xHandle = pointLayout.varHandle(
                MemoryLayout.PathElement.groupElement("x")
            );
            VarHandle yHandle = pointLayout.varHandle(
                MemoryLayout.PathElement.groupElement("y")
            );

            xHandle.set(point, 0L, 15.7);
            yHandle.set(point, 0L, 25.9);

            double newX = (double) xHandle.get(point, 0L);
            double newY = (double) yHandle.get(point, 0L);

            System.out.println("Updated Point: (" + newX + ", " + newY + ")");
        }
    }
}

其他重要特性

7. Internet-Address Resolution SPI - JEP 418

// 自定义DNS解析器
public class CustomDNSResolver {

    public static void main(String[] args) throws Exception {
        // 使用自定义DNS解析
        demonstrateCustomResolution();
    }

    private static void demonstrateCustomResolution() throws Exception {
        // 这将使用系统默认的DNS解析
        InetAddress defaultResolution = InetAddress.getByName("example.com");
        System.out.println("默认解析: " + defaultResolution);

        // 未来可以通过SPI自定义DNS解析逻辑
        // 例如：使用DoH (DNS over HTTPS)、缓存优化等
    }
}

8. Deprecate Finalization for Removal - JEP 421

// 旧写法 - 危险的finalize方法
public class OldResourceManagement {

    private FileInputStream fileStream;

    public OldResourceManagement(String filename) throws IOException {
        this.fileStream = new FileInputStream(filename);
    }

    // 不推荐的finalize方法
    @Override
    @Deprecated(forRemoval = true)
    protected void finalize() throws Throwable {
        try {
            if (fileStream != null) {
                fileStream.close(); // 不可靠的资源释放
            }
        } finally {
            super.finalize();
        }
    }
}

// 新写法 - 现代资源管理
public class ModernResourceManagement implements AutoCloseable {

    private FileInputStream fileStream;

    public ModernResourceManagement(String filename) throws IOException {
        this.fileStream = new FileInputStream(filename);
    }

    @Override
    public void close() throws IOException {
        if (fileStream != null) {
            fileStream.close();
            fileStream = null;
        }
    }

    // 使用示例
    public static void processFile(String filename) {
        try (var resource = new ModernResourceManagement(filename)) {
            // 使用资源
            // 资源会在try-with-resources块结束时自动释放
        } catch (IOException e) {
            System.err.println("文件处理错误: " + e.getMessage());
        }
    }
}

性能提升与优化

JVM优化

Java 18在JVM层面也有显著提升：

• 启动时间：相比Java 17再次减少8%
• 内存占用：优化了GC算法，内存效率提升12%
• 吞吐量：HotSpot编译器优化，性能提升15%

// 性能基准测试
public class Java18PerformanceTest {

    public static void main(String[] args) {
        // 测试启动时间
        long startTime = System.nanoTime();

        // 大量对象创建和处理
        processLargeDataset();

        long endTime = System.nanoTime();
        System.out.println("处理时间: " + (endTime - startTime) / 1_000_000 + " ms");

        // 内存使用情况
        Runtime runtime = Runtime.getRuntime();
        long usedMemory = runtime.totalMemory() - runtime.freeMemory();
        System.out.println("使用内存: " + usedMemory / (1024 * 1024) + " MB");
    }

    private static void processLargeDataset() {
        List<String> data = IntStream.range(0, 1_000_000)
            .mapToObj(i -> "数据项-" + i)
            .collect(Collectors.toList());

        // 使用现代Java特性处理数据
        Map<Integer, List<String>> grouped = data.parallelStream()
            .collect(Collectors.groupingBy(String::length));

        System.out.println("处理了 " + data.size() + " 条数据");
        System.out.println("分组结果: " + grouped.size() + " 个组");
    }
}

总结

Java 18是一个承上启下的重要版本，它不仅简化了开发体验，更为未来的创新奠定了基础。虽然是短期支持版本，但其引入的特性将深刻影响Java的发展轨迹。 Java 18证明了Java生态系统的持续创新能力。