Explore Java 25: New Language, Compiler, and API Features with Real Code Samples

1. Introduction

Java 25, the next long‑term‑support version, is scheduled for official release in September 2025 and brings comprehensive upgrades to the language, standard library, APIs, and runtime.

The article walks through all new features and changes, offering runnable code examples to illustrate the core highlights.

2. New Features

2.1 Language and Compiler Features

Pattern matching with primitive types (JEP 507 – third preview) Pattern matching now supports primitive types directly in switch and instanceof statements.

public class PrimitiveTypePattern {
  public static void main(String[] args) {
    Object obj = 666;
    if (obj instanceof int i) {
      System.out.println("是int类型, 值: " + i);
    }
  }
}

Compile with:

javac -source 25 --enable-preview -Xlint:preview *.java

Run:

java --enable-preview PrimitiveTypePattern
是int类型, 值: 666

Module import declarations (JEP 511 – preview) Allows import module statements at the top of a file to declare module dependencies, simplifying module‑centric code.

import module java.base;

public class ModuleImportDeclare {
  public static void main(String[] args) {
    Date d = new Date();
    System.out.println("当前日期: " + d);
  }
}

If ambiguous imports cause a compilation error, resolve it by explicitly importing the desired class:

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

public class ModuleImportDeclare {
  public static void main(String[] args) {
    Date d = new Date();
    System.out.println("当前日期: " + d);
  }
}

Compact source files and instance main methods (JEP 512) Java 25 permits top‑level instance main methods and source files without an explicit class.

public class CompactSourceFiles {
  void main() {
    System.out.println("Spring Boot3实战案例200讲!");
  }
}

Run with:

java --enable-preview CompactSourceFiles
Spring Boot3实战案例200讲!

Flexible constructor bodies (JEP 513 – final) Multiple constructors can delegate to a shared initialization block, removing the requirement that super() be the first statement.

public class FlexibleConstructorBodies {
  static class Person {
    final int age;
    Person(int age) { this.age = age; }
  }
  static class Employee extends Person {
    final String name;
    Employee(String name, int age) {
      if (age < 1 || age > 130) {
        throw new IllegalArgumentException("年龄错误");
      }
      super(age);
      this.name = name;
    }
  }
  public static void main(String[] args) {
    var emp = new Employee("Pack", 30);
    System.out.printf("年龄: %d%n", emp.age);
  }
}

Run:

java --enable-preview FlexibleConstructorBodies
年龄: 30

2.2 API Enhancements

Scoped Values (JEP 506 – final) 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 ScopedValueTest {
  static final ScopedValue<String> USER = ScopedValue.newInstance();
  public static void main(String[] args) {
    try (ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor()) {
      executor.submit(() -> ScopedValue.where(USER, "Pack").run(() -> {
        System.out.println("Thread: " + Thread.currentThread());
        System.out.println("User: " + USER.get());
      }));
      executor.submit(() -> ScopedValue.where(USER, "Xg").run(() -> {
        System.out.println("Thread: " + Thread.currentThread());
        System.out.println("User: " + USER.get());
      }));
      Thread.sleep(200);
    } catch (InterruptedException e) { Thread.currentThread().interrupt(); }
  }
}

Run:

Thread: VirtualThread[#29]/runnable@ForkJoinPool-1-worker-2
User: Xg
Thread: VirtualThread[#27]/runnable@ForkJoinPool-1-worker-1
User: Pack

Structured Concurrency (JEP 505 – fifth preview) Provides a unified lifecycle for related threads via StructuredTaskScope .

import java.util.concurrent.StructuredTaskScope;

public class StructuredTest {
  static String fetchUser() throws InterruptedException { Thread.sleep(100); return "Pack"; }
  static String fetchOrder() throws InterruptedException { Thread.sleep(150); return "Order#SK-0001"; }
  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());
    }
  }
}

Run: Pack - Order#SK-0001 Stable Value API (JEP 502 – preview) Immutable values that can be lazily initialized, similar to Optional but for any context.

public class StableTest {
  public static void main(String[] args) {
    var st = StableValue.<String>of();
    String message = st.orElseSet(() -> { System.out.println("初始化数据"); return "Spring Boot3实战案例200讲"; });
    System.out.println(message);
    message = st.orElseSet(() -> { System.out.println("初始化数据"); return "Spring Boot3实战案例200讲"; });
    System.out.println(message);
  }
}

Run:

初始化数据
Spring Boot3实战案例200讲
Spring Boot3实战案例200讲

PEM encoding support for cryptographic objects (JEP 470 – preview) Standard API to read/write PEM‑formatted keys and certificates.

public class PEMTest {
  public static void main(String[] args) {
    String pem = """
      -----BEGIN PUBLIC KEY-----
      MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAvEKLPQPR63+Q/RhfBHTs
      ...
      -----END PUBLIC KEY-----
    """;
    try {
      String base64 = pem.replaceAll("-----.*-----", "").replaceAll("\\s", "");
      byte[] keyBytes = java.util.Base64.getDecoder().decode(base64);
      var spec = new java.security.spec.X509EncodedKeySpec(keyBytes);
      var factory = java.security.KeyFactory.getInstance("RSA");
      var key = factory.generatePublic(spec);
      System.out.println("Algorithm: " + key.getAlgorithm());
    } catch (Exception e) { e.printStackTrace(); }
  }
}

Run: Algorithm: RSA Vector API (JEP 508 – tenth incubator) Expresses data‑parallel computations that compile to optimized 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("Result: " + java.util.Arrays.toString(result));
  }
}

Compile and run with preview and module flags:

javac -source 25 --enable-preview --add-modules jdk.incubator.vector VectorTest.java
java --enable-preview --add-modules jdk.incubator.vector VectorTest
Result: [6.0, 8.0, 10.0, 12.0]

Key Derivation Function API (JEP 510) Standardized API for password‑based key derivation (PBKDF2, scrypt, etc.).

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();
    var spec = new PBEKeySpec(password, salt, 65536, 256);
    var factory = SecretKeyFactory.getInstance("PBKDF2WithHmacSHA256");
    SecretKey key = factory.generateSecret(spec);
    System.out.printf("Derived key format: %s%n", key.getFormat());
  }
}

Run:

Derived key format: RAW

3. Conclusion

The article provides a complete preview‑ready walkthrough of Java 25’s language, compiler, and API enhancements, enabling developers to experiment with pattern matching on primitives, module import declarations, compact source files, flexible constructors, scoped values, structured concurrency, stable values, PEM support, vector computations, and password‑based key derivation.