Java/Java SE 24: What's New, Release History & EOL Status

What Is New in Java 24

Java 24 is a standard-term support release delivering language enhancements, performance upgrades, and new APIs. It builds on the foundation laid by previous versions with incremental but impactful changes.

What are the key language changes in Java 24?

The headline language feature is JEP 447: Statements before super(). This allows constructors to execute code before an explicit constructor invocation, offering more flexibility in object initialization. It simplifies tasks like validating arguments or preparing helper data before the superclass constructor runs.

String Templates (JEP 459) enter their second preview. This feature enables string interpolation with template expressions, making complex string composition safer and more readable. In practice, this reduces the need for verbose concatenation or using StringBuilder for complex strings.

Example: Statements before super()

public class Subclass extends Superclass {
    private final int value;

    public Subclass(int input) {
        // Can now perform logic before calling super()
        if (input <= 0) {
            throw new IllegalArgumentException("Must be positive");
        }
        int processedValue = process(input);
        super(processedValue); // Explicit constructor call
        this.value = processedValue;
    }
    private int process(int x) { return x * 2; }
}

Which core library APIs got new methods?

Several core classes received useful new methods. The Class class now has getPermittedSubclasses() for inspecting sealed hierarchies. The Stream API gained mapMultiToInt, mapMultiToLong, and mapMultiToDouble methods for flat-mapping operations to primitive streams efficiently.

Collection utilities were enhanced with new static methods for creating unmodifiable collections from array arguments directly. These additions reduce boilerplate code for common tasks like creating fixed-size sets or lists from a set of elements.

Example: New Stream methods

List<String> list = Arrays.asList("1", "2", "three");
// Using new mapMultiToInt method
IntStream intStream = list.stream()
    .mapMultiToInt((s, consumer) -> {
        try {
            consumer.accept(Integer.parseInt(s));
        } catch (NumberFormatException ignored) {}
    });
intStream.forEach(System.out::println); // Outputs: 1, 2

What security improvements were made?

Java 24 enhances the SunPKCS11 provider with support for SHA-3 based signatures (SHA3-224, SHA3-256, SHA3-384, SHA3-512), aligning with modern cryptographic standards. TLS connections now offer more granular control over signature schemes through new system properties.

The KeyStore API improvements include better handling of secret keys, making it easier to manage sensitive data securely. These changes matter because they keep Java current with evolving security requirements and algorithms.

How does garbage collection performance improve?

The G1 garbage collector now better handles region pinning, which reduces latency spikes during operations that require memory pinning like JNI critical sections. This results in more consistent performance for applications using native libraries.

ZGC introduces parallel pre-touch functionality, speeding up heap initialization on large memory systems. For memory-intensive applications, this can significantly reduce startup time when using large heaps.

What tools and packaging changes should developers know?

The jpackage tool received updates for macOS, including better handling of file associations and runtime compression. jshell now supports additional feedback modes and has improved completion functionality for a smoother developer experience.

These tooling improvements make it easier to create native packages and experiment with code snippets. For desktop application developers, the jpackage enhancements are particularly valuable for distribution.