What Makes Java 25 a Game‑Changer? Explore Its Groundbreaking Features

Official Features

These features are fully stable in Java 25 and can be used safely in production.

Scoped Values

Scoped Values provide a thread‑local‑like mechanism that safely shares immutable data across a thread and its child threads. Unlike ThreadLocal, they automatically clear after the scope ends, avoid memory leaks, and work efficiently with virtual threads.

public class UserService {
    private static final ScopedValue<String> USER_ID = ScopedValue.newInstance();

    public void processRequest(String userId) {
        where(USER_ID, userId).run(this::doWork); // automatic cleanup
    }

    public void doWork() {
        String userId = USER_ID.get();
        System.out.println("Processing user: " + userId);
    }
}

Scoped Values also support returning values via call(), nested scopes, multiple bindings, and integration with structured concurrency.

Module Import Declarations

Module import declarations simplify imports by allowing an entire module to be imported with a single statement, e.g., import module java.base;. This reduces boilerplate but may raise naming‑conflict concerns.

Compact Source Files and Instance Main Method

Java 25 allows a three‑line Hello‑World program without a class declaration:

void main() {
    IO.println("Hello, World!");
}

The new java.lang.IO class provides concise console I/O methods such as print, println, and readln. All standard packages from java.base are automatically imported in compact source files.

Flexible Constructor Bodies

Constructors now have a pre‑amble phase where parameter validation and field initialization can occur before the super‑constructor call, followed by a post‑amble phase after the super call. This eliminates unnecessary work in the parent constructor and prevents premature method calls.

class Employee extends Person {
    String department;

    Employee(String name, int age, String department) {
        if (age < 18 || age > 67) {
            throw new IllegalArgumentException("Age must be 18‑67");
        }
        this.department = department; // pre‑amble
        super(name, age);               // parent constructor
        IO.println("New employee " + name + " joined " + department);
    }
}

Key Derivation Function (KDF) API

The new javax.crypto.KDF class offers deriveKey() and deriveData() methods. Example using HKDF‑SHA256:

// Create HKDF instance
KDF hkdf = KDF.getInstance("HKDF-SHA256");
byte[] ikm = "my-secret-key".getBytes();
byte[] salt = "random-salt".getBytes();
AlgorithmParameterSpec params = HKDFParameterSpec.ofExtract()
    .addIKM(ikm)
    .addSalt(salt)
    .thenExpand("application-context".getBytes(), 32);
SecretKey aesKey = hkdf.deriveKey("AES", params);
byte[] derived = hkdf.deriveData(params);

Compact Object Header

Compact object headers shrink the header size from 16 bytes to 8 bytes on 64‑bit VMs, reducing memory overhead for small objects. The feature is opt‑in because it removes some debugging metadata.

Shenandoah Generational GC

Shenandoah’s generational mode becomes a standard feature, offering ultra‑low pause times while improving throughput for applications with many short‑lived objects. It must be enabled explicitly.

Preview Features (not recommended for production)

Structured Concurrency

Structured concurrency introduces a scoped task API that automatically cancels sibling tasks on failure and cleans up resources when the scope ends.

try (var scope = StructuredTaskScope.open()) {
    var userTask = scope.fork(() -> findUser());
    var orderTask = scope.fork(() -> fetchOrder());
    scope.join();
    return new Response(userTask.get(), orderTask.get());
}

Primitive Pattern Matching

Pattern matching now supports primitive types, allowing bindings such as int i or float f directly in a switch statement.

switch (value) {
    case int i when i > 100 -> "Large int: " + i;
    case int i -> "Small int: " + i;
    case float f -> "Float: " + f;
    case double d -> "Double: " + d;
}

Stable Values

Stable Values provide lazily‑initialized immutable fields. The StableValue wrapper ensures thread‑safe, one‑time initialization while retaining the performance benefits of final fields.

class OrderController {
    private final StableValue<Logger> logger = StableValue.of();

    Logger getLogger() {
        return logger.orElseSet(() -> Logger.create(OrderController.class));
    }
}

Other Features

Removal of 32‑bit x86 Support

Java 25 no longer runs on 32‑bit x86 platforms.

JFR Enhancements

Java Flight Recorder gains more precise CPU measurement, cooperative sampling for safety, and easier production‑time enablement.

Vector API (10th Incubator)

The Vector API adds better math function support via the FFM API, Float16 vectorisation on supported CPUs, and enhanced VectorShuffle interaction with MemorySegment.