一文详细盘点JDK21的新特性

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.TimeUnit;

public class VirtualThreadDemo {
    public static void main(String[] args) throws InterruptedException {
        // 方式1：直接创建（最简单）
        Thread.startVirtualThread(() -> {
            System.out.println("方式1：虚拟线程运行中，线程类型：" + Thread.currentThread().getClass().getSimpleName());
            try {
                TimeUnit.MILLISECONDS.sleep(100); // 模拟I/O操作
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println("方式1：虚拟线程执行完毕");
        });

        // 方式2：通过Thread.Builder构建（可自定义线程名称）
        Thread virtualThread = Thread.ofVirtual()
                .name("virtual-thread-2")
                .unstarted(() -> {
                    System.out.println("方式2：虚拟线程运行中，线程名称：" + Thread.currentThread().getName());
                    try {
                        TimeUnit.MILLISECONDS.sleep(150);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                    System.out.println("方式2：虚拟线程执行完毕");
                });
        virtualThread.start();

        // 方式3：通过线程池创建（推荐，适合批量管理并发任务）
        try (ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor()) {
            for (int i = 0; i < 5; i++) {
                int taskId = i;
                executor.submit(() -> {
                    System.out.println("方式3：虚拟线程任务" + taskId + "运行中，线程ID：" + Thread.currentThread().threadId());
                    try {
                        TimeUnit.MILLISECONDS.sleep(200);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                    System.out.println("方式3：虚拟线程任务" + taskId + "执行完毕");
                });
            }
        } // try-with-resources自动关闭线程池，无需手动shutdown

        // 方式4：通过ThreadFactory创建（灵活定制线程属性）
        ThreadFactory factory = Thread.ofVirtual()
                .name("custom-virtual-thread-", 0) // 名称前缀+自增ID
                .factory();
        Thread customThread = factory.newThread(() -> {
            System.out.println("方式4：自定义虚拟线程运行中，线程名称：" + Thread.currentThread().getName());
            try {
                TimeUnit.MILLISECONDS.sleep(250);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println("方式4：自定义虚拟线程执行完毕");
        });
        customThread.start();

        // 等待所有虚拟线程执行完毕（仅用于演示）
        TimeUnit.SECONDS.sleep(2);
    }
}

// 定义Record类
record Point(int x, int y) {}
record Circle(Point center, int radius) {}

public class RecordPatternDemo {
    public static void main(String[] args) {
        Object obj = new Circle(new Point(3, 4), 5);
        // 嵌套解构Record实例
        if (obj instanceof Circle(Point(int x, int y), int radius)) {
            System.out.printf("圆心坐标：(%d,%d)，半径：%d%n", x, y, radius);
            System.out.printf("圆心到原点距离：%d%n", (int) Math.sqrt(x*x + y*y));
        }
    }
}

public class SwitchPatternDemo {
    public static String formatObj(Object obj) {
        // switch作为表达式，支持多模式分支和守卫子句
        return switch (obj) {
            case null -> "参数为null";
            case Integer i -> STR."整数类型：\{i}";
            case Long l -> STR."长整数类型：\{l}";
            case Double d when d > 0 -> STR."正数小数：\{d}";
            case Double d -> STR."负数小数：\{d}";
            case String s -> STR."字符串类型：\{s}（长度：\{s.length()}）";
            default -> STR."未知类型：\{obj.getClass().getSimpleName()}";
        };
    }

    public static void main(String[] args) {
        System.out.println(formatObj(100));
        System.out.println(formatObj(-3.14));
        System.out.println(formatObj("JDK21"));
        System.out.println(formatObj(null));
    }
}

# 启用分代ZGC
java -XX:+UseZGC -XX:+ZGenerational YourApplication
# 查看GC日志（验证分代回收）
java -XX:+UseZGC -XX:+ZGenerational -XX:+PrintGC -XX:+PrintGCDetails YourApplication

import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.SequencedCollection;
import java.util.SequencedMap;

public class SequencedCollectionDemo {
    public static void main(String[] args) {
        // SequencedCollection示例
        SequencedCollection<String> coll = new LinkedHashSet<>();
        coll.addFirst("JDK21");
        coll.add("新特性");
        coll.addLast("盘点");
        System.out.println("原始集合：" + coll);
        System.out.println("反转集合：" + coll.reversed());
        System.out.println("首元素：" + coll.getFirst());

        // SequencedMap示例
        SequencedMap<Integer, String> map = new LinkedHashMap<>();
        map.put(1, "虚拟线程");
        map.put(2, "分代ZGC");
        map.putLast(3, "序列集合");
        System.out.println("首键值对：" + map.firstEntry());
        System.out.println("尾键值对：" + map.lastEntry());
        System.out.println("反转Map：" + map.reversedMap());
    }
}

public class StringTemplateDemo {
    public static void main(String[] args) {
        String name = "Java开发者";
        int age = 30;
        double pi = 3.1415926;

        // STR处理器：基础插值
        String info = STR."大家好，我是\{name}，今年\{age}岁，π≈\{pi}";
        // FORMAT处理器：格式化
        String formattedPi = FMT."π精确到两位小数：%.2f\{pi}";
        // RAW处理器：原始输出（不插值）
        String raw = RAW."数值：\{pi}";

        System.out.println(info);
        System.out.println(formattedPi);
        System.out.println(raw);
    }
}

import java.lang.foreign.Linker;
import java.lang.foreign.SymbolLookup;
import java.lang.foreign.FunctionDescriptor;
import java.lang.invoke.MethodHandle;

public class ForeignFunctionDemo {
    public static void main(String[] args) throws Throwable {
        // 获取本地链接器
        Linker linker = Linker.nativeLinker();
        // 查找本地库中的strlen函数
        SymbolLookup stdlib = linker.defaultLookup();
        MethodHandle strlen = linker.downcallHandle(
                stdlib.find("strlen").orElseThrow(),
                FunctionDescriptor.of(JAVA_LONG, ADDRESS)
        );

        // 调用本地strlen函数，计算字符串长度
        try (var scope = Arena.ofConfined()) {
            String str = "JDK21 Foreign API";
            long length = (long) strlen.invokeExact(scope.allocateUtf8String(str));
            System.out.println("字符串长度：" + length);
        }
    }
}