Java 25 Unveiled: Key Language, API, and Performance Enhancements

1. Overview

Java 25 is scheduled for release as a new long‑term support (LTS) version in September 2025, bringing comprehensive enhancements to the language, standard library, APIs, and runtime.

This tutorial walks through all new features and changes up to June 2025, with concise code examples and detailed explanations.

2. Language and Compiler Features

Java 25 adds a series of language and compiler improvements aimed at making the language more expressive and concise, benefiting everyday development as well as advanced modular scenarios.

2.1 Pattern Matching for Primitive Types (JEP 507 – Third Preview)

Pattern matching can now handle primitive types in switch and instanceof statements.

static void test(Object obj) {
    if (obj instanceof int i) {
        System.out.println("It's an int: " + i);
    }
}

JEP 507 integrates primitive types into Java’s pattern‑matching system, making such expressions more intuitive and reducing boilerplate code.

2.2 Module Import Declarations (JEP 511 – Preview)

JEP 511 introduces a “module import declaration”, allowing module dependencies to be declared with an import statement, improving readability compared with the traditional requires clause in module‑info.java.

import module java.base;
// ...
public class Main {
    public static void main(String[] args) {
        Date d = new Date();
        System.out.println("Resolved Date: " + d);
    }
}

Ambiguous references can arise when multiple modules export the same type, e.g., java.util.Date vs. java.sql.Date. The compiler reports: error: reference to Date is ambiguous Resolution: explicitly import the required class.

import module java.base;
import module java.sql;
import java.sql.Date;

public class Main {
    public static void main(String[] args) {
        Date d = Date.valueOf("2025-06-15");
        System.out.println("Resolved Date: " + d);
    }
}

Star imports can be replaced by module imports, e.g., import module java.xml; while still cautioning against overuse.

2.3 Compact Source Files (JEP 512) and Instance main Method

Java now supports top‑level instance main methods and compact source files without a class declaration. The following is legal:

void main() {
    System.out.println("Hello from Java 25!");
}

These compact files are ideal for teaching, scripting, and quick prototypes, lowering the entry barrier for new developers.

2.4 Flexible Constructor Bodies (JEP 513 – Final)

JEP 513 allows multiple constructors to delegate common initialization logic to a shared code block, and permits statements before the super(...) or this(...) call.

class Person {
    final int age;
    Person(int age) { this.age = age; }
}

class Employee extends Person {
    final String name;
    Employee(String name, int age) {
        if (age < 18 || age > 67) {
            throw new IllegalArgumentException("Age must be between 18 and 67");
        }
        super(age); // no longer required to be the first statement
        this.name = name;
    }
}

public class Main {
    public static void main(String[] args) {
        var emp = new Employee("Alice", 35);
        System.out.println("Person age set: " + emp.age);
    }
}

Previously, super(...) or this(...) had to be the first statement, often leading to duplicated validation logic.

3. API Enhancements

3.1 Scoped Values (JEP 506 – Final)

JEP 506 provides a lightweight, immutable, thread‑safe alternative to ThreadLocal, designed for virtual threads.

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

public class ScopedUserExample {
    static final ScopedValue<String> USER = ScopedValue.newInstance();
    public static void main(String[] args) {
        try (ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor()) {
            executor.submit(() -> ScopedValue.where(USER, "Alice").run(() -> {
                System.out.println("Thread: " + Thread.currentThread());
                System.out.println("User: " + USER.get());
            }));
            executor.submit(() -> ScopedValue.where(USER, "Bob").run(() -> {
                System.out.println("Thread: " + Thread.currentThread());
                System.out.println("User: " + USER.get());
            }));
            Thread.sleep(200);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}

Scoped values transmit context across call chains efficiently, avoiding the memory‑leak and synchronization overhead of ThreadLocal.

3.2 Structured Concurrency (JEP 505 – Fifth Preview)

JEP 505 treats related threads as a single lifecycle unit. The fifth preview replaces constructors and separate policy methods with the static factory StructuredTaskScope.open() for clearer code.

import java.util.concurrent.StructuredTaskScope;

public class StructuredExample {
    static String fetchUser() {
        try { Thread.sleep(100); } catch (InterruptedException e) { Thread.currentThread().interrupt(); }
        return "Alice";
    }
    static String fetchOrder() {
        try { Thread.sleep(150); } catch (InterruptedException e) { Thread.currentThread().interrupt(); }
        return "Order#42";
    }
    public static void main(String[] args) throws Exception {
        try (var scope = StructuredTaskScope.<String>open()) {
            var userTask = scope.fork(() -> fetchUser());
            var orderTask = scope.fork(() -> fetchOrder());
            scope.join();
            System.out.println(userTask.get() + " - " + orderTask.get());
        }
    }
}

Structured concurrency ensures that related tasks either all complete or are all cancelled, improving reliability and readability.

3.3 Stable Value API (JEP 502 – Preview)

JEP 502 extends the semantics of Optional to provide a context‑stable immutable value.

import java.lang.StableValue;

public class StableExample {
    public static void main(String[] args) {
        var greeting = StableValue.<String>of();
        String message = greeting.orElseSet(() -> "Hello from StableValue!");
        System.out.println(message);
    }
}

Stable values are safe to share across threads or computations, useful for caching, lazy evaluation, or consistent reads within a stable scope.

3.4 PEM Encoding of Cryptographic Objects (JEP 470 – Preview)

JEP 470 adds standard API support for reading and writing PEM‑formatted keys and certificates, eliminating the need for third‑party libraries.

import java.security.KeyFactory;
import java.security.NoSuchAlgorithmException;
import java.security.PublicKey;
import java.security.spec.InvalidKeySpecException;
import java.security.spec.X509EncodedKeySpec;
import java.util.Base64;

public class PEMExample {
    public static void main(String[] args) {
        String pem = """
            -----BEGIN PUBLIC KEY-----
            MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDgjDohS0RHP395oJxciVaeks9N
            KNY5m9V1IkBBwYsMGyxskrW5sapgi9qlGSYOma9kkko1xlBs17qG8TTg38faxgGJ
            sLT2BAmdVFwuWdRtzq6ONn2YPHYj5s5pqx6vU5baz58/STQXNIhn21QoPjXgQCnj
            Pp0OxnacWeRSnAIOmQIDAQAB
            -----END PUBLIC KEY-----
            """;
        try {
            String base64 = pem.replaceAll("-----.*-----", "").replaceAll("\\s", "");
            byte[] keyBytes = Base64.getDecoder().decode(base64);
            X509EncodedKeySpec spec = new X509EncodedKeySpec(keyBytes);
            KeyFactory factory = KeyFactory.getInstance("RSA");
            PublicKey key = factory.generatePublic(spec);
            System.out.println("Loaded key: " + key.getAlgorithm());
        } catch (NoSuchAlgorithmException | InvalidKeySpecException e) {
            e.printStackTrace();
        }
    }
}

This enables direct handling of PEM objects (e.g., X.509 certificates, RSA keys) with the built‑in security API.

3.5 Vector API (JEP 508 – Tenth Incubator)

JEP 508 provides an API for expressing vector computations that reliably compile to optimal hardware SIMD instructions.

import jdk.incubator.vector.*;

public class VectorExample {
    public static void main(String[] args) {
        float[] left = {1f, 2f, 3f, 4f};
        float[] right = {5f, 6f, 7f, 8f};
        FloatVector a = FloatVector.fromArray(FloatVector.SPECIES_128, left, 0);
        FloatVector b = FloatVector.fromArray(FloatVector.SPECIES_128, right, 0);
        FloatVector c = a.add(b);
        float[] result = new float[FloatVector.SPECIES_128.length()];
        c.intoArray(result, 0);
        System.out.println("Vector result: " + java.util.Arrays.toString(result));
    }
}

Enable with --enable-preview --add-modules jdk.incubator.vector. The Vector API lets Java code achieve data‑parallel performance comparable to hand‑optimized native code.

3.6 Key Derivation Function API (JEP 510 – Final)

Java 25 standardizes password‑based key derivation primitives such as PBKDF2 and scrypt, reducing reliance on external libraries.

import javax.crypto.SecretKey;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.PBEKeySpec;

public class KeyDerivationExample {
    public static void main(String[] args) throws Exception {
        char[] password = "hunter2".toCharArray();
        byte[] salt = "somesalt".getBytes();
        PBEKeySpec spec = new PBEKeySpec(password, salt, 65536, 256);
        SecretKeyFactory factory = SecretKeyFactory.getInstance("PBKDF2WithHmacSHA256");
        SecretKey key = factory.generateSecret(spec);
        System.out.println("Derived key format: " + key.getFormat());
    }
}

JEP 510 makes key derivation ready‑to‑use and secure out of the box.

4. Other Changes

4.1 Removal of 32‑bit x86 Port (JEP 503 – Final)

JEP 503 drops support for the traditional 32‑bit x86 architecture from OpenJDK, reducing maintenance burden while retaining full support for 64‑bit x86 and ARM64.

4.2 JFR CPU‑Time Analysis (JEP 509 – Experimental)

JEP 509 adds CPU‑time based analysis to Java Flight Recorder, allowing developers to record and analyze CPU consumption per method or thread.

java 
  -XX:StartFlightRecording=filename=cpu-time.jfr,duration=10s,settings=profile 
  --enable-preview 
  MyApp

The resulting cpu-time.jfr can be examined in JDK Mission Control or VisualVM.

4.3 Command‑Line AOT Tuning (JEP 514 – Final)

JEP 514 improves ergonomics of command‑line options for Ahead‑of‑Time (AOT) compilation, making tools like jaotc and GraalVM native‑image easier to use.

4.4 AOT Method Analysis (JEP 515 – Final)

JEP 515 enables method‑level analysis during AOT compilation, allowing the compiler to make smarter inlining and optimization decisions based on usage frequency.

4.5 JFR Cooperative Sampling (JEP 518 – Experimental)

JEP 518 lets applications suggest safe sampling points to JFR, reducing overhead and improving accuracy while minimizing impact on performance‑critical code.

4.6 Object‑Header Compression (JEP 519 – Experimental)

JEP 519 compresses object headers on 64‑bit architectures, reducing memory footprint for large heaps and microservice workloads.

4.7 JFR Method Timing and Tracing (JEP 520 – Experimental)

JEP 520 enhances JFR with per‑method timing and call‑trace information, enabling finer‑grained performance profiling.

4.8 Generational Shenandoah (JEP 521 – Final)

JEP 521 adds generational support to the Shenandoah garbage collector, optimizing collection for young and long‑lived objects and bringing Shenandoah’s pause‑time characteristics in line with G1 and ZGC.

5. What Developers Need to Know

--enable-preview

: required for all preview features, otherwise compilation fails. --add-modules <name>: needed for incubator modules such as jdk.incubator.vector. --release 25: recommended to target the Java 25 platform during compilation.

Note: Preview and incubator APIs may change or be removed in future releases. Avoid using them in production unless you are prepared to track updates.

Example commands:

# Compile
javac --enable-preview --release 25 --add-modules jdk.incubator.vector MyClass.java

# Run
java --enable-preview --add-modules jdk.incubator.vector MyApp

6. Conclusion

Java 25 continues the evolution toward a modern, high‑performance platform. It refines many preview features, introduces new APIs, and delivers broad optimizations across language syntax, runtime diagnostics, and memory management. As the next LTS release since Java 21, it offers valuable new capabilities that developers should consider adopting.