Java 17 新特性总结

// Java 12-16: features that became standard between Java 11 and Java 17
// Run: java Java12To16Demo.java

import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class Java12To16Demo {

    // record（JEP 395，Java 16）：自动生成构造器、访问器、equals、hashCode、toString
    record Order(String id, int amount) {
        // 用紧凑构造器校验参数
        Order {
            if (amount < 0) throw new IllegalArgumentException("amount < 0");
        }
    }

    record Customer(String name, Address address) {}
    record Address(String city) {}

    public static void main(String[] args) {
        // 文本块（JEP 378，Java 15）
        String json = """
                {
                  "id": "A-1",
                  "amount": 300
                }
                """;
        System.out.print("--- text block ---\n" + json);

        // switch 表达式（JEP 361，Java 14）：可以返回值，不需要 break
        for (int day : new int[] {1, 6, 8}) {
            String type = switch (day) {
                case 1, 2, 3, 4, 5 -> "weekday";
                case 6, 7 -> "weekend";
                default -> {
                    String message = "invalid day " + day;
                    yield message;
                }
            };
            System.out.println("day " + day + " -> " + type);
        }

        // instanceof 模式匹配（JEP 394，Java 16）：不需要强制转换
        Object o = new Order("A-1", 300);
        if (o instanceof Order order && order.amount() > 100) {
            System.out.println("large order: " + order);
        }
        System.out.println("equals by value: " + o.equals(new Order("A-1", 300)));

        // Stream.toList()（Java 16）和 Collectors.teeing（Java 12）
        List<Integer> numbers = Stream.of(3, 1, 4, 1, 5, 9).toList();
        double average = numbers.stream().collect(Collectors.teeing(
                Collectors.summingInt(i -> i), Collectors.counting(), (sum, n) -> (double) sum / n));
        System.out.println("numbers = " + numbers + ", average = " + average);

        // 更易懂的 NullPointerException（JEP 358，Java 14 加入，Java 15 起默认启用）
        Customer customer = new Customer("Alice", null);
        try {
            System.out.println(customer.address().city());
        } catch (NullPointerException e) {
            System.out.println("NPE: " + e.getMessage());
        }
    }
}

--- text block ---
{
  "id": "A-1",
  "amount": 300
}
day 1 -> weekday
day 6 -> weekend
day 8 -> invalid day 8
large order: Order[id=A-1, amount=300]
equals by value: true
numbers = [3, 1, 4, 1, 5, 9], average = 3.8333333333333335
NPE: Cannot invoke "Java12To16Demo$Address.city()" because the return value of "Java12To16Demo$Customer.address()" is null

// JEP 409: Sealed Classes
// Run: java SealedClassesDemo.java

import java.util.Arrays;
import java.util.List;

public class SealedClassesDemo {

    // 只有 permits 里列出的 3 个类型可以继承 Shape
    sealed interface Shape permits Circle, Square, Polygon {}

    // record 隐式为 final
    record Circle(double radius) implements Shape {}

    // final：不再允许继承
    static final class Square implements Shape {
        final double side;
        Square(double side) { this.side = side; }
    }

    // non-sealed：从这里开始，任何类都可以继承
    static non-sealed class Polygon implements Shape {
        final int sides;
        Polygon(int sides) { this.sides = sides; }
    }

    static class Triangle extends Polygon {
        Triangle() { super(3); }
    }

    // 下面这一行会编译失败（Shape 拒绝 permits 以外的类型）
    // record Hexagon() implements Shape {}

    // Java 17 的 switch 还不能写模式（仍是预览），所以用 instanceof 分支
    static double area(Shape shape) {
        if (shape instanceof Circle c) {
            return Math.PI * c.radius() * c.radius();
        } else if (shape instanceof Square s) {
            return s.side * s.side;
        } else if (shape instanceof Polygon p) {
            // 只凭边数算不出面积
            return Double.NaN;
        }
        throw new AssertionError("unreachable: Shape is sealed");
    }

    public static void main(String[] args) {
        // 可以用反射读取“密封”信息（JDK 17 新增的 API）
        System.out.println("Shape.isSealed()          = " + Shape.class.isSealed());
        System.out.println("permitted subclasses      = " + Arrays.stream(Shape.class.getPermittedSubclasses())
                .map(Class::getSimpleName).toList());
        System.out.println("Polygon.isSealed()        = " + Polygon.class.isSealed());
        System.out.println("Circle is a record        = " + Circle.class.isRecord());
        System.out.println();

        for (Shape s : List.of(new Circle(1), new Square(2), new Triangle())) {
            System.out.printf("%-9s area = %.2f%n", s.getClass().getSimpleName(), area(s));
        }
    }
}

// JEP 406: Pattern Matching for switch (preview in Java 17)
// Run: java --enable-preview --source 17 SwitchPatternDemo.java

import java.util.Arrays;

public class SwitchPatternDemo {

    sealed interface Shape permits Circle, Square, Rect {}
    record Circle(double radius) implements Shape {}
    record Square(double side) implements Shape {}
    record Rect(double width, double height) implements Shape {}

    // 以前的写法：一连串 instanceof 的 if-else
    static String formatOld(Object o) {
        if (o instanceof Integer i) {
            return "int " + i;
        } else if (o instanceof Long l) {
            return "long " + l;
        } else if (o instanceof String s) {
            return "String \"" + s + "\"";
        }
        return "other";
    }

    // Java 17（预览）：case 里可以写类型模式，也可以写 case null
    static String formatNew(Object o) {
        return switch (o) {
            case null      -> "null!";
            case Integer i -> "int " + i;
            case Long l    -> "long " + l;
            case String s  -> "String \"" + s + "\"";
            case int[] a   -> "int[] " + Arrays.toString(a);
            default        -> "other";
        };
    }

    // 没有 case null 的 switch 遇到 null 时，和以前一样抛出 NullPointerException
    static String withoutNullCase(Object o) {
        return switch (o) {
            case String s -> "String";
            default       -> "other";
        };
    }

    // 带守卫的模式：Java 17 用 && 加条件（JDK 19 改成了 when）
    static String size(Shape shape) {
        return switch (shape) {
            case Circle c && c.radius() > 10 -> "large circle";
            case Circle c                    -> "small circle";
            case Square s                    -> "square " + s.side();
            case Rect r                      -> "rect " + r.width() + "x" + r.height();
            // Shape 是 sealed 的，所以不需要 default（编译器会检查是否穷尽）
        };
    }

    public static void main(String[] args) {
        Object[] values = {42, 42L, "hello", new int[] {1, 2}, 3.14, null};
        System.out.printf("%-16s | %s%n", "formatNew", "formatOld");
        for (Object v : values) {
            System.out.printf("%-16s | %s%n", formatNew(v), formatOld(v));
        }
        try {
            withoutNullCase(null);
        } catch (NullPointerException e) {
            System.out.println("withoutNullCase(null) -> NullPointerException");
        }
        System.out.println();
        for (Shape s : new Shape[] {new Circle(20), new Circle(1), new Square(2), new Rect(2, 3)}) {
            System.out.println(s + " -> " + size(s));
        }
    }
}

Note: SwitchPatternDemo.java uses preview features of Java SE 17.
Note: Recompile with -Xlint:preview for details.
formatNew        | formatOld
int 42           | int 42
long 42          | long 42
String "hello"   | String "hello"
int[] [1, 2]     | other
other            | other
null!            | other
withoutNullCase(null) -> NullPointerException

Circle[radius=20.0] -> large circle
Circle[radius=1.0] -> small circle
Square[side=2.0] -> square 2.0
Rect[width=2.0, height=3.0] -> rect 2.0x3.0

// JEP 306: Restore Always-Strict Floating-Point Semantics
// Run: java StrictFpDemo.java

public class StrictFpDemo {

    // 在 Java 16 之前，有没有 strictfp 可能会影响中间结果的处理方式
    static strictfp double withStrictfp(double x) {
        return x * 10 / 10;
    }

    // 从 Java 17 开始，即使没有 strictfp，也总是严格按 IEEE 754 计算
    static double withoutStrictfp(double x) {
        return x * 10 / 10;
    }

    public static void main(String[] args) {
        // x * 10 超过了 double 的最大值（约 1.8e308），所以中途就变成 Infinity
        double x = 1e308;
        System.out.println("with strictfp    : " + withStrictfp(x));
        System.out.println("without strictfp : " + withoutStrictfp(x));
        System.out.println("0.1 + 0.2        : " + (0.1 + 0.2));
    }
}

// JEP 356: Enhanced Pseudo-Random Number Generators
// Run: java RandomGeneratorDemo.java

import java.util.Comparator;
import java.util.Random;
import java.util.random.RandomGenerator;
import java.util.random.RandomGenerator.SplittableGenerator;
import java.util.random.RandomGenerator.JumpableGenerator;
import java.util.random.RandomGeneratorFactory;

public class RandomGeneratorDemo {

    public static void main(String[] args) {
        // 可用算法一览（分组、状态位数、特性）
        System.out.println("--- algorithms ---");
        RandomGeneratorFactory.all()
                .sorted(Comparator.comparing(RandomGeneratorFactory<RandomGenerator>::group)
                        .thenComparing(RandomGeneratorFactory::name))
                .forEach(f -> System.out.printf("%-10s %-22s %9s  %s%n", f.group(), f.name(),
                        f.stateBits() == Integer.MAX_VALUE ? "-" : f.stateBits() + " bits",
                        f.isSplittable() ? "splittable" : f.isJumpable() ? "jumpable" : f.isStreamable() ? "streamable" : ""));

        // 已有的类也实现了统一接口 RandomGenerator
        System.out.println();
        System.out.println("--- one interface ---");
        // 第 1 个是以前的 Random，第 2 个按名字选择，第 3 个是默认算法
        RandomGenerator[] generators = {
                new Random(42),
                RandomGenerator.of("L64X128MixRandom"),
                RandomGenerator.getDefault(),
        };
        for (RandomGenerator g : generators) {
            System.out.printf("%-34s nextInt(100) = %d%n", g.getClass().getName(), g.nextInt(100));
        }

        // 种子相同，随机数序列就相同（可复现）
        System.out.println();
        System.out.println("--- seeds ---");
        RandomGeneratorFactory<RandomGenerator> factory = RandomGeneratorFactory.of("Xoshiro256PlusPlus");
        System.out.println("seed 2021 run 1: " + factory.create(2021).ints(5, 0, 100).boxed().toList());
        System.out.println("seed 2021 run 2: " + factory.create(2021).ints(5, 0, 100).boxed().toList());

        // split()：生成统计上相互独立的子生成器（适合并行处理）
        System.out.println();
        System.out.println("--- split / jump ---");
        SplittableGenerator parent = (SplittableGenerator) RandomGeneratorFactory.of("L64X128MixRandom").create(7);
        System.out.println("child 1: " + parent.split().ints(3, 0, 100).boxed().toList());
        System.out.println("child 2: " + parent.split().ints(3, 0, 100).boxed().toList());

        // jump()：把状态一下子推进 2^128 步（得到互不重叠的子序列）
        JumpableGenerator jumpable = (JumpableGenerator) RandomGeneratorFactory.of("Xoshiro256PlusPlus").create(7);
        JumpableGenerator copy = jumpable.copy();
        jumpable.jump();
        System.out.println("before jump: " + copy.nextInt(100) + ", after jump: " + jumpable.nextInt(100)
                + " (jump distance = 2^" + Math.round(Math.log(jumpable.jumpDistance()) / Math.log(2)) + ")");
    }
}

--- algorithms ---
LXM        L128X1024MixRandom     1152 bits  splittable
LXM        L128X128MixRandom       256 bits  splittable
LXM        L128X256MixRandom       384 bits  splittable
LXM        L32X64MixRandom          96 bits  splittable
LXM        L64X1024MixRandom      1088 bits  splittable
LXM        L64X128MixRandom        192 bits  splittable
LXM        L64X128StarStarRandom   192 bits  splittable
LXM        L64X256MixRandom        320 bits  splittable
Legacy     Random                   48 bits  
Legacy     SecureRandom                   -  
Legacy     SplittableRandom         64 bits  splittable
Xoroshiro  Xoroshiro128PlusPlus    128 bits  jumpable
Xoshiro    Xoshiro256PlusPlus      256 bits  jumpable

--- one interface ---
java.util.Random                   nextInt(100) = 30
jdk.random.L64X128MixRandom        nextInt(100) = 61
jdk.random.L32X64MixRandom         nextInt(100) = 72

--- seeds ---
seed 2021 run 1: [83, 80, 16, 88, 25]
seed 2021 run 2: [83, 80, 16, 88, 25]

--- split / jump ---
child 1: [62, 27, 16]
child 2: [38, 52, 12]
before jump: 26, after jump: 73 (jump distance = 2^128)

// JEP 356: Enhanced Pseudo-Random Number Generators - sharing one Random across threads vs split()
// Run: java RandomContentionDemo.java

import java.util.Random;
import java.util.concurrent.ThreadLocalRandom;
import java.util.function.IntFunction;
import java.util.random.RandomGenerator;
import java.util.random.RandomGenerator.SplittableGenerator;
import java.util.random.RandomGeneratorFactory;

public class RandomContentionDemo {

    static final int THREADS = 8;
    static final int PER_THREAD = 2_000_000;
    static volatile long sink;

    // 用 THREADS 个线程，各调用 PER_THREAD 次 nextLong()，返回耗时（ms）
    static long run(IntFunction<RandomGenerator> generatorForThread) throws InterruptedException {
        Thread[] threads = new Thread[THREADS];
        long start = System.nanoTime();
        for (int t = 0; t < THREADS; t++) {
            int id = t;
            threads[t] = new Thread(() -> {
                // 在线程内部获取生成器（为了 ThreadLocalRandom.current()）
                RandomGenerator g = generatorForThread.apply(id);
                long sum = 0;
                for (int i = 0; i < PER_THREAD; i++) sum += g.nextLong();
                sink += sum;
            });
            threads[t].start();
        }
        for (Thread th : threads) th.join();
        return (System.nanoTime() - start) / 1_000_000;
    }

    public static void main(String[] args) throws InterruptedException {
        Random shared = new Random(1);
        SplittableGenerator root = (SplittableGenerator) RandomGeneratorFactory.of("L64X128MixRandom").create(1);
        SplittableGenerator[] children = new SplittableGenerator[THREADS];
        for (int t = 0; t < THREADS; t++) children[t] = root.split();

        System.out.printf("%d threads x %,d nextLong() calls%n%n", THREADS, PER_THREAD);
        // 第 1 轮用于 JIT 预热，只显示之后的 3 轮
        for (int round = 0; round <= 3; round++) {
            // ① 所有线程共享 1 个 Random（争抢内部 AtomicLong 的 CAS）
            long a = run(t -> shared);
            // ② ThreadLocalRandom（每个线程有自己的状态）
            long b = run(t -> ThreadLocalRandom.current());
            // ③ 每个线程用 1 个 split() 出来的 L64X128MixRandom
            long c = run(t -> children[t]);
            if (round > 0) {
                System.out.printf("round %d: shared Random %5d ms | ThreadLocalRandom %4d ms | split() %4d ms%n", round, a, b, c);
            }
        }
    }
}

// JEP 403: Strongly Encapsulate JDK Internals
// Run: java EncapsulationDemo.java

import java.lang.reflect.Field;

public class EncapsulationDemo {

    public static void main(String[] args) throws Exception {
        // ① 通过反射访问 java.lang.String 的私有字段 value
        Field value = String.class.getDeclaredField("value");
        try {
            value.setAccessible(true);
            byte[] bytes = (byte[]) value.get("hello");
            System.out.println("(1) String.value opened: " + bytes.length + " bytes");
        } catch (RuntimeException e) {
            System.out.println("(1) " + e.getClass().getSimpleName() + ": " + e.getMessage());
        }

        // ② JDK 内部包（sun.nio.ch）里的类，同样无法通过反射打开
        try {
            Class<?> util = Class.forName("sun.nio.ch.Util");
            util.getDeclaredMethod("getTemporaryDirectBuffer", int.class).setAccessible(true);
            System.out.println("(2) sun.nio.ch.Util opened");
        } catch (RuntimeException e) {
            System.out.println("(2) " + e.getClass().getSimpleName());
        }

        // ③ sun.misc.Unsafe 在 jdk.unsupported 模块中，Java 17 仍可使用（属于例外）
        Field theUnsafe = Class.forName("sun.misc.Unsafe").getDeclaredField("theUnsafe");
        theUnsafe.setAccessible(true);
        System.out.println("(3) sun.misc.Unsafe: " + theUnsafe.get(null).getClass().getName());

        // ④ java.base 是否向未命名模块 open 了 java.lang 包
        Module base = String.class.getModule();
        System.out.println("(4) java.lang opened to us: " + base.isOpen("java.lang", EncapsulationDemo.class.getModule()));
    }
}

java --add-opens java.base/java.lang=ALL-UNNAMED EncapsulationDemo.java
(1) String.value opened: 5 bytes
(2) InaccessibleObjectException
(3) sun.misc.Unsafe: sun.misc.Unsafe
(4) java.lang opened to us: true
java --illegal-access=permit EncapsulationDemo.java
OpenJDK 64-Bit Server VM warning: Ignoring option --illegal-access=permit; support was removed in 17.0
(1) InaccessibleObjectException: Unable to make field private final byte[] java.lang.String.value accessible: module java.base does not "opens java.lang" to unnamed module @6b1274d2
(2) InaccessibleObjectException
(3) sun.misc.Unsafe: sun.misc.Unsafe
(4) java.lang opened to us: false

// JEP 415: Context-Specific Deserialization Filters
// Run: java DeserializationFilterDemo.java

import java.io.*;
import java.util.ArrayList;
import java.util.function.BinaryOperator;

public class DeserializationFilterDemo {

    record Order(String id, int amount) implements Serializable {}

    // 可能被用于攻击的“意料之外的类”的示例
    static class Gadget implements Serializable {}

    static byte[] serialize(Object o) throws IOException {
        var out = new ByteArrayOutputStream();
        try (var oos = new ObjectOutputStream(out)) {
            oos.writeObject(o);
        }
        return out.toByteArray();
    }

    static Object deserialize(byte[] bytes) throws IOException, ClassNotFoundException {
        try (var ois = new ObjectInputStream(new ByteArrayInputStream(bytes))) {
            return ois.readObject();
        }
    }

    public static void main(String[] args) throws Exception {
        // 整个 JVM 的基本规则：限制嵌套深度和数组长度
        ObjectInputFilter base = ObjectInputFilter.Config.createFilter("maxdepth=10;maxarray=1000");

        // Java 17 新功能：过滤器工厂。为每个流决定“使用哪个过滤器”
        BinaryOperator<ObjectInputFilter> factory = (current, requested) -> {
            if (requested == null) {
                // 创建流时：应用基本规则
                return base;
            }
            // 调用 setObjectInputFilter() 时：合并基本规则和个别规则，都无法判断时拒绝
            return ObjectInputFilter.rejectUndecidedClass(ObjectInputFilter.merge(requested, current));
        };
        ObjectInputFilter.Config.setSerialFilterFactory(factory);

        // 白名单（只允许 DeserializationFilterDemo$Order 和 java.lang 的一部分）
        ObjectInputFilter allowOrders = ObjectInputFilter.Config.createFilter(
                "DeserializationFilterDemo$Order;java.lang.String;java.lang.Number;java.lang.Integer");

        Object[] inputs = {new Order("A-1", 300), new Gadget(), new int[5000]};
        for (Object input : inputs) {
            byte[] bytes = serialize(input);
            try (var ois = new ObjectInputStream(new ByteArrayInputStream(bytes))) {
                ois.setObjectInputFilter(allowOrders);
                Object result = ois.readObject();
                System.out.println("ACCEPTED : " + result);
            } catch (InvalidClassException e) {
                System.out.println("REJECTED : " + input.getClass().getSimpleName() + " (" + e.getMessage() + ")");
            }
        }

        // 即使没有调用 setObjectInputFilter()，基本规则（maxarray=1000）也会生效
        System.out.println();
        for (Object input : new Object[] {new ArrayList<>(java.util.List.of(1, 2, 3)), new int[5000]}) {
            try {
                System.out.println("ACCEPTED : " + input.getClass().getSimpleName() + " -> " + deserialize(serialize(input)).getClass().getSimpleName());
            } catch (InvalidClassException e) {
                System.out.println("REJECTED : " + input.getClass().getSimpleName() + " (" + e.getMessage() + ")");
            }
        }
    }
}

// JEP 412: Foreign Function & Memory API (incubator in Java 17)
// Run: java --add-modules jdk.incubator.foreign --enable-native-access=ALL-UNNAMED ForeignMemoryDemo.java

import java.lang.invoke.MethodHandle;
import java.lang.invoke.MethodType;
import jdk.incubator.foreign.CLinker;
import jdk.incubator.foreign.FunctionDescriptor;
import jdk.incubator.foreign.MemoryAccess;
import jdk.incubator.foreign.MemoryAddress;
import jdk.incubator.foreign.MemorySegment;
import jdk.incubator.foreign.ResourceScope;

public class ForeignMemoryDemo {

    public static void main(String[] args) throws Throwable {
        // ① 不用 JNI，直接调用 C 标准库的 strlen
        MethodHandle strlen = CLinker.getInstance().downcallHandle(
                CLinker.systemLookup().lookup("strlen").orElseThrow(),
                MethodType.methodType(long.class, MemoryAddress.class),
                FunctionDescriptor.of(CLinker.C_LONG, CLinker.C_POINTER));

        // 关闭 ResourceScope 时，在其中分配的本地内存会被一起释放
        try (ResourceScope scope = ResourceScope.newConfinedScope()) {
            MemorySegment cString = CLinker.toCString("Hello, Java 17!", scope);
            long length = (long) strlen.invokeExact(cString.address());
            System.out.println("strlen(\"Hello, Java 17!\") = " + length);

            // ② 在堆外分配 5 个 int 的空间并读写
            MemorySegment ints = MemorySegment.allocateNative(5 * 4, scope);
            for (int i = 0; i < 5; i++) {
                MemoryAccess.setIntAtIndex(ints, i, i * i);
            }
            StringBuilder sb = new StringBuilder();
            for (int i = 0; i < 5; i++) {
                sb.append(MemoryAccess.getIntAtIndex(ints, i)).append(' ');
            }
            System.out.println("off-heap ints = " + sb.toString().trim() + " (" + ints.byteSize() + " bytes)");

            // ③ 越界访问会抛出异常，而不是让 JVM 崩溃
            try {
                MemoryAccess.setIntAtIndex(ints, 5, 25);
            } catch (IndexOutOfBoundsException e) {
                System.out.println("index 5 -> " + e.getClass().getSimpleName());
            }
        }
        System.out.println("scope closed: native memory freed");
    }
}

// JEP 414: Vector API (second incubator in Java 17)
// Run: java --add-modules jdk.incubator.vector VectorApiDemo.java

import jdk.incubator.vector.FloatVector;
import jdk.incubator.vector.VectorOperators;
import jdk.incubator.vector.VectorSpecies;

public class VectorApiDemo {

    static final VectorSpecies<Float> SPECIES = FloatVector.SPECIES_PREFERRED;

    // 用普通循环计算两个数组的点积（a[0]*b[0] + a[1]*b[1] + ...）
    static float scalarDot(float[] a, float[] b) {
        float sum = 0;
        for (int i = 0; i < a.length; i++) {
            sum += a[i] * b[i];
        }
        return sum;
    }

    // 用 Vector API 做同样的计算，每次处理 SPECIES.length() 个元素
    static float vectorDot(float[] a, float[] b) {
        var acc = FloatVector.zero(SPECIES);
        int i = 0;
        int upper = SPECIES.loopBound(a.length);
        for (; i < upper; i += SPECIES.length()) {
            var va = FloatVector.fromArray(SPECIES, a, i);
            var vb = FloatVector.fromArray(SPECIES, b, i);
            // acc += va * vb（乘加运算）
            acc = va.fma(vb, acc);
        }
        float sum = acc.reduceLanes(VectorOperators.ADD);
        // 剩余的元素用普通（标量）方式处理
        for (; i < a.length; i++) {
            sum += a[i] * b[i];
        }
        return sum;
    }

    public static void main(String[] args) {
        System.out.println("species = " + SPECIES + ", lanes per operation = " + SPECIES.length());

        float[] small = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
        System.out.println("dot(small, small): scalar = " + scalarDot(small, small) + ", vector = " + vectorDot(small, small));

        // 对 100 万个元素的点积计算 500 次并比较耗时
        float check = 0;
        float[] a = new float[1_000_000];
        float[] b = new float[1_000_000];
        for (int i = 0; i < a.length; i++) {
            a[i] = (i % 100) / 100f;
            b[i] = (i % 7) / 7f;
        }
        // 计时前先让两个方法都被 JIT 编译（预热）
        float[] tiny = new float[1024];
        for (int r = 0; r < 20_000; r++) {
            check += scalarDot(tiny, tiny) + vectorDot(tiny, tiny);
        }
        for (int round = 1; round <= 3; round++) {
            long t0 = System.nanoTime();
            for (int r = 0; r < 500; r++) check += scalarDot(a, b);
            long t1 = System.nanoTime();
            for (int r = 0; r < 500; r++) check += vectorDot(a, b);
            long t2 = System.nanoTime();
            System.out.printf("round %d: scalar %4d ms | vector %4d ms%n", round, (t1 - t0) / 1_000_000, (t2 - t1) / 1_000_000);
        }
        // 使用计算结果，防止计算被优化掉
        if (check == 42) System.out.println();
    }
}

// JEP 398 / 407 / 410 / 411: deprecations and removals in Java 17
// Run: java RemovalsDemo.java

import java.nio.file.Files;
import java.nio.file.Path;

public class RemovalsDemo {

    static void printDeprecation(String className) {
        try {
            Deprecated d = Class.forName(className).getAnnotation(Deprecated.class);
            if (d == null) {
                System.out.printf("%-34s not deprecated%n", className);
                return;
            }
            System.out.printf("%-34s @Deprecated(since=\"%s\", forRemoval=%s)%n", className, d.since(), d.forRemoval());
        } catch (ClassNotFoundException e) {
            System.out.printf("%-34s ClassNotFoundException%n", className);
        }
    }

    // 使用将要删除的 API 时 javac 会给出 [removal] 警告，这里将其屏蔽
    @SuppressWarnings("removal")
    public static void main(String[] args) {
        // JEP 398：Applet API 被标记为“将要删除”
        printDeprecation("java.applet.Applet");

        // JEP 411：Security Manager 也被标记为“将要删除”
        printDeprecation("java.lang.SecurityManager");

        // JEP 407：RMI Activation 已被删除（java.rmi 的其他功能仍保留）
        printDeprecation("java.rmi.activation.Activatable");
        printDeprecation("java.rmi.Remote");

        // JEP 410：实验性的 AOT 编译器（jaotc）和 Graal JIT 被删除
        Path bin = Path.of(System.getProperty("java.home"), "bin");
        System.out.printf("%-34s %s%n", "bin/jaotc exists", Files.exists(bin.resolve("jaotc")));
        System.out.printf("%-34s %s%n", "module jdk.internal.vm.compiler", ModuleLayer.boot().findModule("jdk.internal.vm.compiler").isPresent());

        // 尝试启用 Security Manager 时会输出警告（标准错误输出）
        System.out.println();
        System.out.flush();
        System.setSecurityManager(new SecurityManager());
        System.out.println("Security Manager installed: " + (System.getSecurityManager() != null));
    }
}

java.applet.Applet                 @Deprecated(since="9", forRemoval=true)
java.lang.SecurityManager          @Deprecated(since="17", forRemoval=true)
java.rmi.activation.Activatable    ClassNotFoundException
java.rmi.Remote                    not deprecated
bin/jaotc exists                   false
module jdk.internal.vm.compiler    false

WARNING: A terminally deprecated method in java.lang.System has been called
WARNING: System::setSecurityManager has been called by RemovalsDemo (file:/path/to/java17/RemovalsDemo.java)
WARNING: Please consider reporting this to the maintainers of RemovalsDemo
WARNING: System::setSecurityManager will be removed in a future release
Security Manager installed: true

// Java 17 APIs outside the JEPs: HexFormat and InstantSource
// Run: java HexFormatDemo.java

import java.nio.charset.StandardCharsets;
import java.time.Clock;
import java.time.Duration;
import java.time.Instant;
import java.time.InstantSource;
import java.util.HexFormat;

public class HexFormatDemo {

    // InstantSource：只提供“当前时刻”的接口（不带时区的 Clock）
    record Token(String value, Instant expiresAt) {
        boolean isExpired(InstantSource time) {
            return time.instant().isAfter(expiresAt);
        }
    }

    public static void main(String[] args) {
        // HexFormat：字节数组和十六进制字符串的相互转换（以前需要自己写或依赖外部库）
        byte[] bytes = "Java17".getBytes(StandardCharsets.UTF_8);
        HexFormat hex = HexFormat.of();
        String encoded = hex.formatHex(bytes);
        System.out.println("formatHex         = " + encoded);
        System.out.println("parseHex          = " + new String(hex.parseHex(encoded), StandardCharsets.UTF_8));
        System.out.println("MAC style         = " + HexFormat.ofDelimiter(":").withUpperCase().formatHex(bytes));
        System.out.println("toHexDigits(255)  = " + hex.toHexDigits((byte) 255));

        // 在测试中可以传入固定时刻的 InstantSource
        Instant t0 = Instant.parse("2026-08-01T00:00:00Z");
        Token token = new Token("abc", t0.plus(Duration.ofMinutes(10)));
        System.out.println();
        System.out.println("expired at +5 min  = " + token.isExpired(InstantSource.fixed(t0.plusSeconds(300))));
        System.out.println("expired at +15 min = " + token.isExpired(InstantSource.fixed(t0.plusSeconds(900))));
        System.out.println("Clock is an InstantSource = " + (Clock.systemUTC() instanceof InstantSource));
    }
}