Should You Skip Java 24? Key Features and Why Java 25 LTS Is the Real Upgrade

Java 24 was released on March 18, 2025, but its rapid six‑month release cadence makes it easy to overlook.

Java 25, scheduled for September, will be the next LTS (Long‑Term Support) version, meaning experimental features from non‑LTS releases will be stabilized for enterprise use.

New Feature Details

Newbie‑Friendly Syntax

One common complaint about Java is its verbosity, but some argue that verbosity aids maintainability. Java 24 introduces preview syntax that reduces boilerplate, such as allowing a simple System.out.println("Hello, World!") without a full class definition, though this is still a preview feature and may be removed later.

void main() {
    System.out.println("Hello, World!");
}

The new syntax also removes the need for public static void main in simple programs.

Pattern Matching Enhancements (JEP‑488, second preview)

Previously, pattern matching with instanceof and switch only worked with reference types. Java 24 now supports matching on primitive types such as int and double, making code more concise.

Object value = 42;
if (value instanceof Integer i) {
    System.out.println("Integer value: " + i);
}

int value = 42;
if (value instanceof int i && i > 5) {
    System.out.println("Value is an integer greater than 5");
}

double d = 3.14;
switch (d) {
    case 3.14 -> System.out.println("This is π");
    case 2.71 -> System.out.println("This is e");
    default -> System.out.println("Unknown constant");
}

JEP 492: Flexible Constructor Bodies (third preview)

Constructors can now contain logic before calling super() or this(), allowing validation without breaking the parent‑class initialization flow.

class PositiveBigInteger extends BigInteger {
    public PositiveBigInteger(long value) {
        if (value <= 0) {
            throw new IllegalArgumentException("Value must be positive");
        }
        super(String.valueOf(value)); // validate first, then call super()
    }
    public static void main(String[] args) {
        try {
            new PositiveBigInteger(-5);
        } catch (IllegalArgumentException e) {
            System.out.println(e.getMessage());
        }
        System.out.println(new PositiveBigInteger(42));
    }
}

JEP 494: Module Import Declarations (second preview)

A single statement can import all exported packages of a module, simplifying code.

import module java.base; // imports all packages of java.base
class Test {
    void main() {
        List<String> list = new ArrayList<>(); // no separate java.util import needed
        list.add("example");
        System.out.println(list);
    }
}

Conflict resolution is handled by explicitly importing the desired class, e.g., java.sql.Date when both java.util.Date and java.sql.Date are present.

import module java.base; // contains java.util.Date
import module java.sql;   // contains java.sql.Date
import java.sql.Date;    // explicit import resolves conflict
class Test {
    void main() {
        Date date = new Date(System.currentTimeMillis()); // uses java.sql.Date
        System.out.println(date);
    }
}

Library Updates

The Stream API now supports custom intermediate operations, such as windowed grouping and distinct‑by‑length collectors.

// Group elements into fixed windows of size 3
var result = Stream.of(1,2,3,4,5,6,7)
    .gather(Gatherers.windowFixed(3))
    .toList();
System.out.println(result); // [[1,2,3], [4,5,6], [7]]

// Distinct by string length
static <T> Gatherer<T, Set<Integer>, T> distinctByLength() {
    return Gatherer.ofSequential(
        HashSet::new,
        (state, element, downstream) -> {
            int length = element.toString().length();
            if (state.add(length)) downstream.push(element);
            return true;
        }
    );
}
var strings = Stream.of("foo","bar","baz","quux")
    .gather(distinctByLength())
    .toList();
System.out.println(strings); // [foo, quux]

The new java.lang.classfile package provides a standard API for parsing and analyzing Java class files.

byte[] bytes = Files.readAllBytes(Path.of("Target.class"));
ClassModel classModel = ClassFile.of().parse(bytes);
Set<ClassDesc> dependencies = new HashSet<>();
classModel.forEach(element -> {
    if (element instanceof MethodModel method) {
        method.forEach(codeElement -> {
            if (codeElement instanceof FieldInstruction field) {
                dependencies.add(field.owner());
            } else if (codeElement instanceof InvokeInstruction invoke) {
                dependencies.add(invoke.owner());
            }
        });
    }
});
System.out.println(dependencies);

Performance: Java’s Soft Spot

Compared with C/C++, Rust, or Go, Java’s startup time is slower due to the JVM, though runtime performance remains strong. Java 24 includes further optimizations, but for ultra‑low‑latency workloads, other languages may still be preferable.

Security Manager Removed

The long‑standing Security Manager was finally removed in Java 24, reflecting its limited use in modern applications that rely on external security frameworks.

The Real Focus: Java 25 LTS

While Java 24 offers interesting preview features, the decisive change will be the September Java 25 LTS release. Production teams are advised to stay on the current LTS (Java 21) until Java 25 becomes available, at which point the experimental features will be stable and ready for enterprise adoption.