Java 25 Features

// A compact source file: no class, no static, no String[] args.
// All of java.base is imported automatically, and IO prints text.

void main() {
    String name = "Asha";
    IO.println("Hello, " + name + "!");

    List<String> topics = List.of("Records", "Patterns", "Virtual threads");
    for (String topic : topics) {
        IO.println("- " + topic);
    }
    IO.println("Topics: " + topics.size());
}

$ java HelloCompact.java
Hello, Asha!
- Records
- Patterns
- Virtual threads
Topics: 3

public class FlexibleConstructorDemo {
    static class Employee {
        final String name;

        Employee(String name) {
            this.name = name;
            describe(); // calls the subclass version
        }

        void describe() {
            System.out.println("Employee " + name);
        }
    }

    static class Manager extends Employee {
        final int reports;

        Manager(String name, int reports) {
            // Java 25: code before super(...) to validate and prepare
            if (reports < 0) {
                throw new IllegalArgumentException("reports < 0");
            }
            String cleanName = name.strip();
            // Fields can be set before super(), so describe() sees them
            this.reports = reports;
            super(cleanName);
        }

        @Override
        void describe() {
            // Before Java 25, reports would still be 0 here
            System.out.println("Manager " + name + " with "
                    + reports + " reports");
        }
    }

    public static void main(String[] args) {
        new Employee("Ravi");
        new Manager("  Asha  ", 5);
        try {
            new Manager("Meera", -1);
        } catch (IllegalArgumentException e) {
            // Rejected before the Employee constructor ever ran
            System.out.println("Rejected: " + e.getMessage());
        }
    }
}

Employee Ravi
Manager Asha with 5 reports
Rejected: reports < 0

import java.util.List;
import java.util.Map;

public class UnnamedDemo {
    record Order(String id, String item, int qty) { }

    public static void main(String[] args) {
        List<Order> orders = List.of(
                new Order("A1", "Book", 2), new Order("A2", "Pen", 5));

        // _ in a record pattern: ignore components you don't need
        int total = 0;
        for (Order order : orders) {
            if (order instanceof Order(_, _, int qty)) {
                total += qty;
            }
        }
        System.out.println("Total quantity: " + total);

        // _ for a variable that is never used
        int count = 0;
        for (Order _ : orders) {
            count++;
        }
        System.out.println("Orders: " + count);

        // _ for an unused exception and lambda parameter
        String input = "12x";
        try {
            Integer.parseInt(input);
        } catch (NumberFormatException _) {
            System.out.println("Not a number: " + input);
        }
        Map<String, Integer> stock = Map.of("Book", 3);
        stock.forEach((_, qty) -> System.out.println("In stock: " + qty));
    }
}

Total quantity: 7
Orders: 2
Not a number: 12x
In stock: 3

import java.lang.foreign.Arena;
import java.lang.foreign.FunctionDescriptor;
import java.lang.foreign.Linker;
import java.lang.foreign.MemorySegment;
import java.lang.foreign.ValueLayout;
import java.lang.invoke.MethodHandle;

public class FfmDemo {
    public static void main(String[] args) throws Throwable {
        // Find the C function strlen in the standard C library
        Linker linker = Linker.nativeLinker();
        MethodHandle strlen = linker.downcallHandle(
                linker.defaultLookup().find("strlen").orElseThrow(),
                FunctionDescriptor.of(ValueLayout.JAVA_LONG,
                        ValueLayout.ADDRESS));

        // An arena frees its native memory when it is closed
        try (Arena arena = Arena.ofConfined()) {
            MemorySegment text = arena.allocateFrom("Hello from Java 25");
            long length = (long) strlen.invokeExact(text);
            System.out.println("strlen() returned " + length);

            // Off-heap memory without Unsafe or JNI
            MemorySegment numbers = arena.allocate(ValueLayout.JAVA_INT, 5);
            for (int i = 0; i < 5; i++) {
                numbers.setAtIndex(ValueLayout.JAVA_INT, i, i * i);
            }
            System.out.print("off-heap ints   :");
            for (int i = 0; i < 5; i++) {
                System.out.print(" "
                        + numbers.getAtIndex(ValueLayout.JAVA_INT, i));
            }
            System.out.println();
        }
    }
}

strlen() returned 18
off-heap ints   : 0 1 4 9 16

# Compact object headers (JEP 519): smaller objects, less heap
java -XX:+UseCompactObjectHeaders -jar app.jar

# AOT cache in one step (JEP 514/515): faster startup and warm-up
java -XX:AOTCacheOutput=app.aot -jar app.jar   # training run
java -XX:AOTCache=app.aot -jar app.jar         # production run

# Generational Shenandoah is now a product feature (JEP 521)
java -XX:+UseShenandoahGC -XX:ShenandoahGCMode=generational App

# JFR: CPU-time profiling (Linux, experimental) and method timing
java -XX:StartFlightRecording:jdk.CPUTimeSample#enabled=true App

# Security: Key Derivation Function API (JEP 510), and since
# Java 24 quantum-resistant ML-KEM and ML-DSA algorithms
# Removed: 32-bit x86 port; Security Manager is permanently disabled