What's New in Java 25

// JEP 512: Compact Source Files and Instance Main Methods
// Run: java CompactSourceDemo.java

// No class declaration, no public static, no String[] args. Classes from java.base need no import

final List<String> fruits = List.of("apple", "banana", "cherry");

String shout(String s) {
    return s.toUpperCase() + "!";
}

void main() {
    // IO.println is a short form of System.out.println (java.lang.IO, added in JDK 25)
    IO.println("Hello, Java 25!");
    for (String f : fruits) {
        IO.println(shout(f));
    }

    // List, Map, Collectors and so on come from the automatic import of the java.base module
    Map<Integer, List<String>> byLength = fruits.stream().collect(Collectors.groupingBy(String::length));
    IO.println("by length: " + byLength);

    // Behind the scenes, the compiler creates an implicit class
    IO.println("class name: " + getClass().getName());
}

// JEP 511: Module Import Declarations
// Run: java ModuleImportDemo.java

// Import every package that a module exports, in one line
import module java.base;      // java.util, java.util.stream, java.time, java.nio.file ...
import module java.net.http;  // java.net.http

// java.desktop also has java.awt.List, which makes List ambiguous. A single-type import wins, so this resolves it
import module java.desktop;
import java.util.List;

public class ModuleImportDemo {

    public static void main(String[] args) {
        // Classes from java.util, java.time and java.net.http, with no single-type imports
        List<String> names = Stream.of("b", "a", "c").sorted().toList();
        LocalDate date = LocalDate.of(2025, 9, 16);
        HttpClient.Version version = HttpClient.Version.HTTP_2;
        System.out.println("names   = " + names);
        System.out.println("JDK 25  = " + date + " (" + date.getDayOfWeek() + ")");
        System.out.println("version = " + version);

        // Classes from java.desktop work too (except List)
        Point p = new Point(3, 4);
        System.out.println("point   = " + p.x + "," + p.y + " (distance " + p.distance(0, 0) + ")");
        System.out.println("List is " + List.class.getName());
    }
}

// JEP 513: Flexible Constructor Bodies
// Run: java FlexibleConstructorDemo.java

public class FlexibleConstructorDemo {

    static class Shape {
        Shape() {
            // Call an overridden method from the parent constructor (a classic pitfall)
            System.out.println("  Shape(): " + describe());
        }
        String describe() { return "shape"; }
    }

    // Before: super() had to come first, and fields could only be assigned after it
    static class OldCircle extends Shape {
        private final double radius;
        OldCircle(double radius) {
            super();
            this.radius = radius;
        }
        @Override String describe() { return "circle r=" + radius; }
    }

    // JDK 25: validate arguments and initialize fields before super()
    static class NewCircle extends Shape {
        private final double radius;
        NewCircle(double radius) {
            if (radius <= 0) {
                throw new IllegalArgumentException("radius must be positive: " + radius);
            }
            this.radius = radius;
            super();
        }
        @Override String describe() { return "circle r=" + radius; }
    }

    // Compute the value for the parent before super() (previously this needed a static helper)
    static class Base {
        final String id;
        Base(String id) { this.id = id; }
    }
    static class User extends Base {
        User(String email) {
            String normalized = email.trim().toLowerCase();
            if (!normalized.contains("@")) {
                throw new IllegalArgumentException("not an email: " + email);
            }
            super(normalized);
        }
    }

    public static void main(String[] args) {
        System.out.println("new OldCircle(2):");
        new OldCircle(2);
        System.out.println("new NewCircle(2):");
        new NewCircle(2);

        try {
            new NewCircle(-1);
        } catch (IllegalArgumentException e) {
            System.out.println("new NewCircle(-1): " + e.getMessage());
        }
        System.out.println("new User(\"  Alice@Example.COM \").id = " + new User("  Alice@Example.COM ").id);
    }
}

// JEP 507: Primitive Types in Patterns, instanceof, and switch (third preview in JDK 25)
// Run: java --enable-preview PrimitivePatternsDemo.java

public class PrimitivePatternsDemo {

    // instanceof int: checks whether the value converts to int without losing information
    static String fitsInInt(long value) {
        if (value instanceof int i) {
            return value + " fits in int: " + i;
        }
        return value + " does not fit in int";
    }

    // Same for double: it matches int if it has no fraction and is in range
    static String classify(double d) {
        return switch (d) {
            case int i -> "integral " + i;
            case float f -> "fits in float " + f;
            case double x -> "needs double " + x;
        };
    }

    // Combine primitive type patterns with when guards in a switch
    static String httpStatus(int code) {
        return switch (code) {
            case 200 -> "OK";
            case 404 -> "Not Found";
            case int c when c >= 500 -> "server error " + c;
            case int c -> "other " + c;
        };
    }

    // boolean, long and others can now be switch selectors
    static String onOff(boolean b) {
        return switch (b) {
            case true -> "ON";
            case false -> "OFF";
        };
    }

    public static void main(String[] args) {
        System.out.println(fitsInInt(42L));
        System.out.println(fitsInInt(10_000_000_000L));
        System.out.println(classify(3.0));
        System.out.println(classify(0.5));
        System.out.println(classify(0.1));
        System.out.println(httpStatus(200) + " / " + httpStatus(503) + " / " + httpStatus(302));
        System.out.println(onOff(true) + " / " + onOff(false));

        // A plain cast silently corrupts the value
        System.out.println("(int) 10_000_000_000L = " + (int) 10_000_000_000L);
    }
}

// JEP 506: Scoped Values
// Run: java ScopedValueDemo.java

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

public class ScopedValueDemo {

    record User(String name, String role) {}

    // Share "the user of this request" without passing it as an argument
    static final ScopedValue<User> CURRENT_USER = ScopedValue.newInstance();
    static final ThreadLocal<User> TL_USER = new ThreadLocal<>();

    static void controller() {
        service();
    }

    static void service() {
        // Read the value deep in the call chain
        User u = CURRENT_USER.get();
        System.out.println("  service: user=" + u.name() + ", role=" + u.role());
    }

    public static void main(String[] args) throws Exception {
        // (1) The value is visible only inside where(...).run(...)
        System.out.println("(1) bind and read");
        ScopedValue.where(CURRENT_USER, new User("alice", "admin")).run(ScopedValueDemo::controller);
        System.out.println("  after run: isBound=" + CURRENT_USER.isBound());

        // (2) Rebind temporarily in a nested scope; the old value comes back on exit
        System.out.println("(2) nested rebinding");
        ScopedValue.where(CURRENT_USER, new User("alice", "admin")).run(() -> {
            ScopedValue.where(CURRENT_USER, new User("guest", "viewer")).run(ScopedValueDemo::service);
            service();
        });

        // (3) call() returns a value
        String greeting = ScopedValue.where(CURRENT_USER, new User("bob", "user"))
                .call(() -> "hello, " + CURRENT_USER.get().name());
        System.out.println("(3) call() -> " + greeting);

        // (4) If you forget remove(), a ThreadLocal leaks into the next task on a pooled thread
        System.out.println("(4) ThreadLocal vs ScopedValue on a pooled thread");
        try (ExecutorService pool = Executors.newSingleThreadExecutor()) {
            pool.submit(() -> TL_USER.set(new User("carol", "admin"))).get();
            pool.submit(() -> System.out.println("  next task sees ThreadLocal: " + TL_USER.get())).get();
            pool.submit(() -> ScopedValue.where(CURRENT_USER, new User("carol", "admin")).run(() -> {})).get();
            pool.submit(() -> System.out.println("  next task sees ScopedValue: "
                    + (CURRENT_USER.isBound() ? CURRENT_USER.get() : "(unbound)"))).get();
        }

        // (5) get() outside a binding throws
        try {
            CURRENT_USER.get();
        } catch (java.util.NoSuchElementException e) {
            System.out.println("(5) get() outside: " + e.getClass().getSimpleName());
        }
    }
}

(1) bind and read
  service: user=alice, role=admin
  after run: isBound=false
(2) nested rebinding
  service: user=guest, role=viewer
  service: user=alice, role=admin
(3) call() -> hello, bob
(4) ThreadLocal vs ScopedValue on a pooled thread
  next task sees ThreadLocal: User[name=carol, role=admin]
  next task sees ScopedValue: (unbound)
(5) get() outside: NoSuchElementException

// JEP 505: Structured Concurrency (fifth preview in JDK 25)
// Run: java --enable-preview StructuredConcurrencyDemo.java

import java.time.Duration;
import java.util.List;
import java.util.concurrent.StructuredTaskScope;
import java.util.concurrent.StructuredTaskScope.Joiner;
import java.util.concurrent.StructuredTaskScope.Subtask;

public class StructuredConcurrencyDemo {

    static long t0;

    static void log(String message) {
        System.out.printf("%5d ms  %s%n", (System.nanoTime() - t0) / 1_000_000, message);
    }

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

    // A task that takes ms milliseconds; it logs when interrupted
    static String work(String name, long ms, boolean fail) throws InterruptedException {
        try {
            Thread.sleep(ms);
        } catch (InterruptedException e) {
            log(name + ": interrupted");
            throw e;
        }
        if (fail) {
            log(name + ": failed");
            throw new IllegalStateException(name + " failed");
        }
        log(name + ": done");
        return name;
    }

    public static void main(String[] args) throws Exception {
        // (1) The default joiner waits for all to succeed and interrupts the rest on the first failure
        System.out.println("=== 1. open(): one subtask fails ===");
        t0 = System.nanoTime();
        try (var scope = StructuredTaskScope.open()) {
            Subtask<String> user = scope.fork(() -> work("findUser", 100, true));
            Subtask<String> order = scope.fork(() -> work("fetchOrder", 1000, false));
            scope.join();
            log("never reached: " + user.get() + order.get());
        } catch (StructuredTaskScope.FailedException e) {
            log("caller: " + e.getCause().getMessage());
        }

        // (2) Use only the first successful result (racing mirror servers, for example)
        System.out.println("=== 2. anySuccessfulResultOrThrow() ===");
        t0 = System.nanoTime();
        try (var scope = StructuredTaskScope.open(Joiner.<String>anySuccessfulResultOrThrow())) {
            scope.fork(() -> work("mirror A", 300, false));
            scope.fork(() -> work("mirror B", 100, false));
            scope.fork(() -> work("mirror C", 50, true));
            log("result: " + scope.join());
        }

        // (3) Receive every result at once
        System.out.println("=== 3. allSuccessfulOrThrow() ===");
        t0 = System.nanoTime();
        try (var scope = StructuredTaskScope.open(Joiner.<String>allSuccessfulOrThrow())) {
            for (String s : List.of("price", "stock", "review")) {
                scope.fork(() -> work(s, 100, false));
            }
            List<String> results = scope.join().map(Subtask::get).toList();
            log("results: " + results);
        }

        // (4) Set a timeout for the whole scope
        System.out.println("=== 4. withTimeout(250 ms) ===");
        t0 = System.nanoTime();
        try (var scope = StructuredTaskScope.open(Joiner.<String>allSuccessfulOrThrow(),
                cf -> cf.withTimeout(Duration.ofMillis(250)))) {
            scope.fork(() -> work("fast", 100, false));
            scope.fork(() -> work("slow", 1000, false));
            scope.join();
        } catch (StructuredTaskScope.TimeoutException e) {
            log("caller: TimeoutException");
        }

        // (5) Forked subtasks inherit ScopedValue bindings
        System.out.println("=== 5. ScopedValue inheritance ===");
        t0 = System.nanoTime();
        ScopedValue.where(REQUEST_ID, "req-42").call(() -> {
            try (var scope = StructuredTaskScope.open()) {
                Subtask<String> a = scope.fork(() -> "subtask A sees " + REQUEST_ID.get());
                Subtask<String> b = scope.fork(() -> "subtask B sees " + REQUEST_ID.get());
                scope.join();
                log(a.get());
                log(b.get());
            }
            return null;
        });
    }
}

=== 1. open(): one subtask fails ===
  110 ms  findUser: failed
  120 ms  fetchOrder: interrupted
  120 ms  caller: findUser failed
=== 2. anySuccessfulResultOrThrow() ===
   58 ms  mirror C: failed
  108 ms  mirror B: done
  108 ms  mirror A: interrupted
  108 ms  result: mirror B
=== 3. allSuccessfulOrThrow() ===
  104 ms  stock: done
  104 ms  price: done
  105 ms  review: done
  107 ms  results: [price, stock, review]
=== 4. withTimeout(250 ms) ===
  107 ms  fast: done
  255 ms  slow: interrupted
  255 ms  caller: TimeoutException
=== 5. ScopedValue inheritance ===
    1 ms  subtask A sees req-42
    2 ms  subtask B sees req-42

// JEP 502: Stable Values (preview in JDK 25)
// Run: java --enable-preview StableValueDemo.java

import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.function.Supplier;

public class StableValueDemo {

    static final AtomicInteger CREATED = new AtomicInteger();

    static class Settings {
        Settings() {
            // Pretend this is expensive (100 ms)
            CREATED.incrementAndGet();
            sleep(100);
        }
    }

    // A value that can be set only once; the JIT can treat it as a constant, like a final field
    static final StableValue<Settings> SETTINGS = StableValue.of();

    static Settings settings() {
        // Initialize if not set yet; even with many threads calling at once, it runs only once
        return SETTINGS.orElseSet(Settings::new);
    }

    // The same idea as a Supplier
    static final Supplier<String> GREETING = StableValue.supplier(() -> {
        System.out.println("  computing greeting...");
        return "hello";
    });

    // A list whose elements are initialized lazily, one by one
    static final List<Integer> SQUARES = StableValue.list(10, i -> {
        System.out.println("  computing square of " + i);
        return i * i;
    });

    static void sleep(long ms) {
        try {
            Thread.sleep(ms);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }

    public static void main(String[] args) throws Exception {
        System.out.println("(1) 8 threads call settings() at the same time");
        Thread[] threads = new Thread[8];
        for (int i = 0; i < threads.length; i++) {
            threads[i] = Thread.ofVirtual().start(StableValueDemo::settings);
        }
        for (Thread t : threads) t.join();
        System.out.println("  Settings created " + CREATED.get() + " time(s), isSet=" + SETTINGS.isSet());

        System.out.println("(2) supplier");
        System.out.println("  " + GREETING.get() + " / " + GREETING.get());

        System.out.println("(3) list");
        System.out.println("  SQUARES.get(3) = " + SQUARES.get(3));
        System.out.println("  SQUARES.get(3) = " + SQUARES.get(3));
        System.out.println("  SQUARES.get(7) = " + SQUARES.get(7));

        // A second set fails
        System.out.println("(4) trySet on a set value -> " + SETTINGS.trySet(new Settings()));
    }
}

(1) 8 threads call settings() at the same time
  Settings created 1 time(s), isSet=true
(2) supplier
  computing greeting...
  hello / hello
(3) list
  computing square of 3
  SQUARES.get(3) = 9
  SQUARES.get(3) = 9
  computing square of 7
  SQUARES.get(7) = 49
(4) trySet on a set value -> false

// JEP 510: Key Derivation Function API
// Run: java KdfDemo.java

import java.nio.charset.StandardCharsets;
import java.util.HexFormat;
import javax.crypto.KDF;
import javax.crypto.SecretKey;
import javax.crypto.spec.HKDFParameterSpec;
import javax.crypto.spec.SecretKeySpec;

public class KdfDemo {

    public static void main(String[] args) throws Exception {
        // The "input keying material", e.g. from a key exchange (random in real use)
        byte[] ikm = HexFormat.of().parseHex("0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b");
        byte[] salt = HexFormat.of().parseHex("000102030405060708090a0b0c");

        KDF hkdf = KDF.getInstance("HKDF-SHA256");

        // Derive separate keys from the same secret, one per purpose (info)
        for (String purpose : new String[] {"encryption", "mac"}) {
            var params = HKDFParameterSpec.ofExtract()
                    .addIKM(new SecretKeySpec(ikm, "Generic"))
                    .addSalt(salt)
                    .thenExpand(purpose.getBytes(StandardCharsets.UTF_8), 32);
            SecretKey key = hkdf.deriveKey(purpose.equals("mac") ? "HmacSHA256" : "AES", params);
            System.out.printf("%-10s -> %s (%s, %d bytes)%n", purpose,
                    HexFormat.of().formatHex(key.getEncoded()), key.getAlgorithm(), key.getEncoded().length);
        }

        // The same input as RFC 5869 test case 1: check that the OKM matches the spec
        byte[] info = HexFormat.of().parseHex("f0f1f2f3f4f5f6f7f8f9");
        byte[] okm = hkdf.deriveData(HKDFParameterSpec.ofExtract()
                .addIKM(new SecretKeySpec(ikm, "Generic")).addSalt(salt).thenExpand(info, 42));
        String expected = "3cb25f25faacd57a90434f64d0362f2a2d2d0a90cf1a5a4c5db02d56ecc4c5bf34007208d5b887185865";
        System.out.println("RFC 5869 test case 1 matches: " + HexFormat.of().formatHex(okm).equals(expected));
    }
}

// JEP 470: PEM Encodings of Cryptographic Objects (preview in JDK 25)
// Run: java --enable-preview PemDemo.java

import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.PEMDecoder;
import java.security.PEMEncoder;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.util.Arrays;

public class PemDemo {

    public static void main(String[] args) throws Exception {
        KeyPair pair = KeyPairGenerator.getInstance("Ed25519").generateKeyPair();

        // Turn a public key into a PEM string (previously you assembled Base64 and the BEGIN/END lines yourself)
        String publicPem = PEMEncoder.of().encodeToString(pair.getPublic());
        System.out.print(publicPem);

        // Turn the PEM string back into a key object
        PublicKey decoded = PEMDecoder.of().decode(publicPem, PublicKey.class);
        System.out.println("decoded: " + decoded.getAlgorithm() + ", equal = "
                + Arrays.equals(decoded.getEncoded(), pair.getPublic().getEncoded()));

        // A private key can be encrypted with a password before encoding
        char[] password = "correct horse battery staple".toCharArray();
        String encryptedPem = PEMEncoder.of().withEncryption(password).encodeToString(pair.getPrivate());
        System.out.println(encryptedPem.lines().findFirst().orElseThrow() + " ... ("
                + encryptedPem.lines().count() + " lines)");
        PrivateKey privateKey = PEMDecoder.of().withDecryption(password).decode(encryptedPem, PrivateKey.class);
        System.out.println("decrypted: " + privateKey.getAlgorithm() + ", equal = "
                + Arrays.equals(privateKey.getEncoded(), pair.getPrivate().getEncoded()));
    }
}

// JEP 508: Vector API (tenth incubator in JDK 25)
// 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;

    // Compute the dot product of two arrays (a[0]*b[0] + a[1]*b[1] + ...) with a plain loop
    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;
    }

    // The same computation with the Vector API, SPECIES.length() elements at a time
    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 (fused multiply-add)
            acc = va.fma(vb, acc);
        }
        float sum = acc.reduceLanes(VectorOperators.ADD);
        // Handle the remaining elements one by one (scalar)
        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));

        // Time 500 dot products of 1,000,000 elements
        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;
        }
        // Let the JIT compile both methods before timing (warm-up)
        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);
        }
        // Use the result so the computation is not optimized away
        if (check == 42) System.out.println();
    }
}

// JEP 519: Compact Object Headers
// Run: java -Xmx2g CompactHeadersDemo.java
// Run: java -Xmx2g -XX:+UseCompactObjectHeaders CompactHeadersDemo.java

import java.lang.management.ManagementFactory;

public class CompactHeadersDemo {

    // A small object with just two ints
    record Point(int x, int y) {}

    static final int COUNT = 10_000_000;

    static long usedHeap() {
        for (int i = 0; i < 3; i++) System.gc();
        Runtime rt = Runtime.getRuntime();
        return rt.totalMemory() - rt.freeMemory();
    }

    public static void main(String[] args) {
        boolean compact = ManagementFactory.getRuntimeMXBean().getInputArguments().contains("-XX:+UseCompactObjectHeaders");
        System.out.println("UseCompactObjectHeaders = " + compact);

        long before = usedHeap();
        Point[] points = new Point[COUNT];
        for (int i = 0; i < COUNT; i++) {
            points[i] = new Point(i, -i);
        }
        long after = usedHeap();

        // Subtract the array itself (4 bytes per reference x 10 million) to get the size per Point
        long arrayBytes = 4L * COUNT;
        double perObject = (double) (after - before - arrayBytes) / COUNT;
        System.out.printf("%,d Points: %,d MB on the heap, %.1f bytes per Point%n",
                COUNT, (after - before) / 1024 / 1024, perObject);
        System.out.println("check: " + points[COUNT - 1].y());
    }
}

// JEP 514: Ahead-of-Time Command-Line Ergonomics / JEP 515: Ahead-of-Time Method Profiling
// Run: javac -d out AotCacheDemo.java && jar --create --file app.jar -C out .
// Run: java -cp app.jar AotCacheDemo
// Run: java -XX:AOTCacheOutput=app.aot -cp app.jar AotCacheDemo
// Run: java -XX:AOTCache=app.aot -cp app.jar AotCacheDemo

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.time.Duration;
import java.time.Instant;
import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.concurrent.Executors;
import java.util.regex.Pattern;
import java.util.stream.Collectors;

public class AotCacheDemo {

    record Order(String id, LocalDate date, String category, int amount) {}

    static final String CSV = """
            A-1,2025-09-16,book,1200
            A-2,2025-09-16,food,800
            A-3,2025-09-17,book,2400
            A-4,2025-09-18,toy,1500
            """;

    public static void main(String[] args) throws Exception {
        // A tiny "app": parse CSV, aggregate, format dates, build an HTTP request, use virtual threads
        Pattern comma = Pattern.compile(",");
        List<Order> orders = CSV.lines()
                .map(comma::split)
                .map(f -> new Order(f[0], LocalDate.parse(f[1]), f[2], Integer.parseInt(f[3])))
                .toList();
        Map<String, Integer> byCategory = orders.stream()
                .collect(Collectors.groupingBy(Order::category, java.util.TreeMap::new, Collectors.summingInt(Order::amount)));

        HttpRequest request = HttpRequest.newBuilder(URI.create("https://example.com/report"))
                .timeout(Duration.ofSeconds(5))
                .POST(HttpRequest.BodyPublishers.ofString(byCategory.toString()))
                .build();
        HttpClient client = HttpClient.newBuilder().connectTimeout(Duration.ofSeconds(2)).build();

        int total;
        try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
            total = executor.submit(() -> orders.stream().mapToInt(Order::amount).sum()).get();
        }

        String first = orders.getFirst().date().format(DateTimeFormatter.ofPattern("yyyy/MM/dd (EEE)", Locale.US));
        System.out.println(byCategory + " total=" + total + " first=" + first + " " + request.method()
                + " " + client.version());

        // Time from the start of the JVM process to this point
        Instant start = ProcessHandle.current().info().startInstant().orElseThrow();
        System.out.println("finished " + Duration.between(start, Instant.now()).toMillis() + " ms after the JVM started");
    }
}

javac -d out AotCacheDemo.java && jar --create --file app.jar -C out .
java -cp app.jar AotCacheDemo
{book=3600, food=800, toy=1500} total=5900 first=2025/09/16 (Tue) POST HTTP_2
finished 245 ms after the JVM started
java -XX:AOTCacheOutput=app.aot -cp app.jar AotCacheDemo
{book=3600, food=800, toy=1500} total=5900 first=2025/09/16 (Tue) POST HTTP_2
finished 338 ms after the JVM started
[0.377s][warning][aot] Skipping jdk/internal/event/Event: Not in loaded state
[0.377s][warning][aot] Skipping jdk/internal/event/Event: JFR event class
... (8 more [warning][aot] lines about JFR event classes)
Temporary AOTConfiguration recorded: app.aot.config
Launching child process /path/to/jdk-25/bin/java to assemble AOT cache app.aot using configuration app.aot.config
Picked up JAVA_TOOL_OPTIONS: -Djava.class.path=app.jar -XX:AOTCacheOutput=app.aot -XX:AOTConfiguration=app.aot.config -XX:AOTMode=create
Reading AOTConfiguration app.aot.config and writing AOTCache app.aot
AOTCache creation is complete: app.aot 22265856 bytes
Removed temporary AOT configuration file app.aot.config
java -XX:AOTCache=app.aot -cp app.jar AotCacheDemo
{book=3600, food=800, toy=1500} total=5900 first=2025/09/16 (Tue) POST HTTP_2
finished 202 ms after the JVM started

// JEP 521: Generational Shenandoah
// Run: java -XX:+UseShenandoahGC -XX:ShenandoahGCMode=generational -Xmx2g GenerationalShenandoahDemo.java
// Run: java -XX:+UseShenandoahGC -Xmx2g GenerationalShenandoahDemo.java

import java.lang.management.GarbageCollectorMXBean;
import java.lang.management.ManagementFactory;
import java.util.ArrayList;
import java.util.List;

public class GenerationalShenandoahDemo {

    public static void main(String[] args) {
        // Keep only the latest 50,000 objects (short-lived ones that soon become garbage)
        byte[][] recent = new byte[50_000][];
        // First create about 600 MB of data that lives until the end (think of a cache)
        List<byte[]> longLived = new ArrayList<>();
        for (int i = 0; i < 600_000; i++) {
            longLived.add(new byte[1024]);
        }
        long start = System.nanoTime();

        for (int i = 0; i < 30_000_000; i++) {
            recent[i % recent.length] = new byte[1024];
        }

        System.out.printf("allocated ~%d GB, long-lived %,d, elapsed %,d ms%n",
                30_000_000L * 1024 / 1024 / 1024 / 1024, longLived.size(), (System.nanoTime() - start) / 1_000_000);
        for (GarbageCollectorMXBean gc : ManagementFactory.getGarbageCollectorMXBeans()) {
            System.out.printf("  %-20s count %4d, total %,6d ms%n", gc.getName(), gc.getCollectionCount(), gc.getCollectionTime());
        }
    }
}

// JEP 520: JFR Method Timing & Tracing
// Run: java '-XX:StartFlightRecording:method-timing=MethodTimingDemo::parse;java.lang.Integer::parseInt,filename=timing.jfr' MethodTimingDemo.java
// Run: jfr view method-timing timing.jfr

import java.util.ArrayList;
import java.util.List;

public class MethodTimingDemo {

    // The method we want to time; the code itself contains no timing logic at all
    static List<Integer> parse(String csv) {
        List<Integer> values = new ArrayList<>();
        for (String s : csv.split(",")) {
            values.add(Integer.parseInt(s.trim()));
        }
        return values;
    }

    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < 1_000; i++) {
            sb.append(i).append(", ");
        }
        sb.append(1_000);
        String csv = sb.toString();

        long sum = 0;
        for (int i = 0; i < 2_000; i++) {
            sum += parse(csv).size();
        }
        System.out.println("parsed " + sum + " values");
    }
}

java '-XX:StartFlightRecording:method-timing=MethodTimingDemo::parse;java.lang.Integer::parseInt,filename=timing.jfr' MethodTimingDemo.java
[0.373s][info][jfr,startup] Started recording 1. No limit specified, using maxsize=250MB as default.
[0.373s][info][jfr,startup] 
[0.373s][info][jfr,startup] Use jcmd 42053 JFR.dump name=1 to copy recording data to file.
parsed 2002000 values
jfr view method-timing timing.jfr

                                               Method Timing

Timed Method                                            Invocations Minimum Time Average Time Maximum Time
------------------------------------------------------- ----------- ------------ ------------ ------------
MethodTimingDemo.parse(String)                                2,000  0.078100 ms  0.124000 ms  5.410000 ms
java.lang.Integer.parseInt(CharSequence, int, int, int)           3  0.000334 ms  0.002850 ms  0.006960 ms
java.lang.Integer.parseInt(String)                        2,002,001  0.000041 ms  0.000061 ms  0.098300 ms
java.lang.Integer.parseInt(String, int)                   2,002,007  0.000019 ms  0.000019 ms  0.057200 ms