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 {

    // Shape を継承できるのは permits に書いた 3 つだけ
    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 のウォームアップなので、2 回目以降の 3 回を表示する
        for (int round = 0; round <= 3; round++) {
            // ① 1 つの Random を全スレッドで共有（内部の AtomicLong を CAS で奪い合う）
            long a = run(t -> shared);
            // ② ThreadLocalRandom（スレッドごとの状態）
            long b = run(t -> ThreadLocalRandom.current());
            // ③ split() した L64X128MixRandom をスレッドごとに 1 つ
            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 の private フィールド 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 が java.lang パッケージを無名モジュールに open しているか
        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 {
        // ① C 標準ライブラリの strlen を JNI なしで呼ぶ
        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);

            // ② ヒープ外（オフヒープ）に int を 5 個分確保して読み書きする
            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;

    // 2 つの配列の内積（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：バイト列と 16 進文字列の相互変換（これまでは自作するか外部ライブラリが必要だった）
        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));
    }
}