What’s New in Java 25? A Deep Dive into Core Features and Performance Boosts

On September 16 2025, Java 25 was officially released as the next long‑term support (LTS) version, supported through 2030 and extended to 2033, marking a major milestone for the Java ecosystem.

Core JEP Overview

JEP 512 : Compact source files and instance main method – Stable

JEP 511 : Module import declarations – Stable

JEP 513 : Flexible constructor bodies – Stable

JEP 507 : Raw type pattern matching – Preview

JEP 505 : Structured concurrency – Preview

JEP 506 : Scoped Values – Stable

JEP 519 : Compact object headers – Stable

JEP 514 : AOT compilation command line simplification – Stable

JEP 515 : AOT ahead‑of‑time compilation analysis – Stable

JEP 521 : Generational Shenandoah GC – Stable

JEP 508 : Vector API – Incubating

JEP 470 : PEM encoding API – Preview

JEP 510 : Key derivation function API – Stable

JEP 509/518/520 : JFR monitoring enhancements – Experimental/Stable

JEP 503 : Removal of 32‑bit x86 support – Removed

Core Language Features

Raw Type Pattern Matching (JEP 507)

Eliminate boxing/unboxing by matching primitive types directly:

Object thing = 42;
if (thing instanceof int i) {
    System.out.println("Raw type detected: " + i);
}
// Supports multiple primitive types
int value = 42;
if (value instanceof byte b) {
    System.out.println("Byte type: " + b);
} else if (value instanceof short s) {
    System.out.println("Short type: " + s);
} else {
    System.out.println("Other type: " + value);
}

Module Import Declarations (JEP 511)

Import an entire module with a single statement, replacing verbose import lists:

// Traditional imports
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;

// Java 25 new way
import module java.sql;

Compact Source Files and Instance Main Method (JEP 512)

Write Java code without a class wrapper, enabling script‑like execution:

void main() {
    System.out.println("Yes, this is valid Java code!");
    System.out.println("Great for quick scripts and demos");
}

Flexible Constructor Rules (JEP 513)

Execute logic before the super() call inside constructors:

public class User {
    private String name;

    public User(String name) {
        validate(name); // Now allowed before super()
        super();
        this.name = name;
    }

    private void validate(String name) {
        if (name == null || name.trim().isEmpty()) {
            throw new IllegalArgumentException("Name cannot be empty");
        }
    }
}

Performance and Sustainability

Compact Object Header (JEP 519)

Memory optimization : Reduces per‑object overhead.

Green computing : Lowers heap usage and energy consumption.

Performance boost : Decreases GC pressure for faster applications.

AOT Compilation and Startup Analysis (JEP 514 & 515)

// Startup time analysis
java -XX:+StartupAnalysis MyApp

Generational Shenandoah GC (JEP 521)

Low latency : Pause times under 10 ms.

High throughput : Suited for large‑memory workloads.

Adaptive : Auto‑tunes based on application characteristics.

Security Enhancements

PEM API (JEP 470)

Simplify certificate and key handling without third‑party libraries:

// Read PEM‑encoded certificate
var certificate = Pem.decodeCertificate(pemString);

// Write PEM‑encoded private key
var privateKey = Pem.decodePrivateKey(keyString);

public class PEMExample {
    public static void main(String[] args) {
        String pem = """
        -----BEGIN PUBLIC KEY-----
        MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDgjDohS0RHP395oJxciVaeks9N
        KNY5m9V1IkBBwYsMGyxskrW5sapgi9qlGSYOma9kkko1xlBs17qG8TTg38faxgGJ
        sLT2BAmdVFwuWdRtzq6ONn2YPHYj5s5pqx6vU5baz58/STQXNIhn21QoPjXgQCnj
        Pp0OxnacWeRSnAIOmQIDAQAB
        -----END PUBLIC KEY-----
        """;
        try {
            var cert = Pem.decodeCertificate(pem);
            System.out.println("Certificate algorithm: " + cert.getPublicKey().getAlgorithm());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

Key Derivation Function API (JEP 510)

Unified KDF interface supporting multiple algorithms:

// PBKDF2 derivation
var key = KDF.PBKDF2.derive(secret, salt, 10000, 256);

// Argon2 derivation
var key2 = KDF.Argon2.derive(secret, salt, 65536, 2, 1, 32);

Advanced Concurrency Features

Scoped Values (JEP 506)

Lightweight ThreadLocal alternative, ideal 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();
        }
    }
}

Structured Concurrency (JEP 505)

Treat related threads as a single unit of work:

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());
        }
    }
}

StableValue API (JEP 502)

Extend Optional semantics to immutable contextual values:

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);
        var cache = StableValue.<String>of();
        String cached = cache.orElseSet(() -> expensiveOperation());
    }
    private static String expensiveOperation() {
        return "Expensive result";
    }
}

JVM Internal Improvements

CPU Time Profiling (JEP 509)

# Precise CPU usage analysis
java -XX:+CPUProfiling MyApp

Cooperative Sampling (JEP 518)

Improved JFR sampling mechanism.

Reduced performance overhead.

More accurate performance data.

Method Tracing (JEP 520)

// No proxy needed, method execution is automatically traced
@TraceMethod
public void criticalMethod() {
    // Method body
}

Vector Computation API (JEP 508)

Java 25 introduces a powerful Vector API leveraging 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));
    }
}

Compilation flags: --enable-preview --add-modules jdk.incubator.vector