Unlock Java 25: Scoped Values, Compact Source Files, and New Constructor Model

Java 25 New Features Overview

Java 25 (released September 16) is a long‑term support release that brings many impactful language and JVM improvements.

Scoped Values

Scoped Values provide a safe, efficient way to share immutable data across threads, solving the memory‑leak and accidental‑modification problems of ThreadLocal. They automatically clean up after the scope ends and work well 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);
    }
    void doWork() {
        String userId = USER_ID.get();
        System.out.println("Processing user: " + userId);
    }
}

Module Import Declarations

Modules can now be imported with a single line, e.g., import module java.base;, simplifying dependency management.

Compact Source Files and New IO Class

Compact source files remove the need for explicit class and public static void main boilerplate. A new java.lang.IO class offers concise console I/O methods like IO.println and IO.readln.

void main() {
    String name = IO.readln("Enter your name: ");
    IO.println("Hello, " + name);
}

Compact Object Header

The object header size is reduced from 16 bytes to 8 bytes on 64‑bit JVMs, lowering memory overhead for small objects.

Shenandoah Generational GC

Shenandoah now supports a generational mode, keeping pause times low while improving throughput for large‑heap applications.

Structured Concurrency

Structured concurrency replaces manual thread management with scopes that automatically cancel sibling tasks on failure and ensure proper resource cleanup.

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

Basic‑Type Pattern Matching

Switch statements can now bind primitive values, enabling concise handling of int, float, and double cases.

switch (value) {
    case int i when i > 100 -> "Large int: " + i;
    case float f -> "Float: " + f;
    // ...
}

Stable Values

Stable Values allow lazy, immutable initialization with the same optimization guarantees as final fields, useful for expensive or rarely used objects.

private final StableValue<Logger> logger = StableValue.of();
Logger getLogger() {
    return logger.orElseSet(() -> Logger.create(OrderController.class));
}

Other Notable Changes

Removal of 32‑bit x86 support.

Enhanced JFR for low‑overhead profiling.

Vector API tenth preview with better math functions and Float16 support.

Overall, Java 25 modernizes the language, improves performance, and offers new developer‑friendly features while maintaining backward compatibility.