What’s New in Java 24? Explore 8 Game‑Changing Preview Features

1. Introduction

On March 18, 2025, Oracle released Java 24 (JDK 24), bringing productivity, performance, stability, security improvements, including enhanced language features, AI integration, quantum‑resistant encryption, and better cloud readiness.

2. New Features

2.1 Pattern Matching with Primitive Types, instanceof and switch

Allows direct use of primitive types in pattern matching, simplifying AI inference or high‑performance code.

<code>public class Demo01 {
    public static void main(String[] args) {
        Object obj = 42;
        if (obj instanceof int value) {
            System.out.printf("Basic type match: %d%n", value);
        }
    }
}
// Output: Basic type match: 42
</code>

Compile with:

<code>javac --enable-preview -source 24 *.java
</code>

Run with:

<code>java --enable-preview Demo01
</code>

2.2 Flexible Constructor Bodies

Introduces explicit prologue and epilogue phases in constructors, allowing safe initialization before and after super‑constructor calls.

<code>public class Demo02 {
    private final int x;
    public Demo02(int x) {
        System.out.println("Prologue: before super");
        this.x = x;
        super(); // implicit if omitted
        System.out.println("Epilogue: after super");
    }
}
</code>

2.3 Module Import Declarations

Enables importing an entire module’s exported packages with a single declaration.

<code>import module java.sql;
</code>

2.4 Single‑File Source and Main Method

Allows writing a “hello world” program without a class declaration.

<code>void main() {
    System.out.println("Pack, Java 24!");
}
</code>

Run with:

<code>java --enable-preview Demo03
// Output: Pack, Java 24!
</code>

2.5 Stream Collectors

Stream pipelines now support custom intermediate operations for grouping or transforming data beyond standard collectors.

<code>import java.util.stream.*;
public class Demo04 {
    public static void main(String[] args) {
        var result = Stream.of("xg","java","pack","xxgg")
                           .gather(Gatherers.windowFixed(2))
                           .toList();
        System.out.println(result);
    }
}
// Output: [[xg, java], [pack, xxgg]]
</code>

2.6 Vector API

The incubating Vector API provides high‑performance vector computations useful for AI, scientific computing, and data analysis.

<code>import jdk.incubator.vector.*;
import java.util.*;
public class Demo05 {
    public static void main(String[] args) {
        FloatVector a = FloatVector.fromArray(FloatVector.SPECIES_64,
            new float[]{1.0f,2.0f,3.0f,4.0f}, 0);
        FloatVector b = FloatVector.fromArray(FloatVector.SPECIES_64,
            new float[]{5.0f,6.0f,7.0f,8.0f}, 0);
        FloatVector sum = a.add(b);
        float[] p = new float[4];
        sum.intoArray(p,0);
        System.out.println(Arrays.toString(p));
    }
}
</code>

Compile with:

<code>javac --enable-preview --add-modules jdk.incubator.vector -source 24 *.java
</code>

Run with:

<code>java --enable-preview --add-modules jdk.incubator.vector Demo05
// Output: [6.0, 8.0, 0.0, 0.0]
</code>

2.7 Scoped Values

Provides a thread‑safe, immutable data‑sharing mechanism that is simpler and more efficient than ThreadLocal.

<code>public class Demo06 {
    public static final ScopedValue<String> sv = ScopedValue.newInstance();
    public static void main(String[] args) {
        ScopedValue.where(sv, "xxxooo").run(Demo06::processRequest);
    }
    static void processRequest() {
        System.out.println(sv.get());
    }
}
</code>

Run:

<code>java --enable-preview Demo06
// Output: xxxooo
</code>

2.8 Structured Concurrency

Introduces an API that treats a group of tasks as a single unit, simplifying error handling and cancellation.

<code>public class Demo07 {
    public static void main(String[] args) throws Exception {
        try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
            Subtask<String> f1 = scope.fork(() -> process("Task1"));
            Subtask<String> f2 = scope.fork(() -> process("Task2"));
            scope.join();
            System.out.println("Results: " + f1.get() + ", " + f2.get());
        }
    }
    static String process(String task) {
        return task + ", execution completed";
    }
}
</code>

Run:

<code>java --enable-preview Demo07
// Output: Results: Task1, execution completed, Task2, execution completed
</code>

For detailed specifications, see the linked JEPs:

https://openjdk.org/jeps/488

https://openjdk.org/jeps/492

https://openjdk.org/jeps/494

https://openjdk.org/jeps/495

https://openjdk.org/jeps/485

https://openjdk.org/jeps/489

https://openjdk.org/jeps/487

https://openjdk.org/jeps/499

Note: The current projects still primarily use Java 8.