New Features in Java 26

1. Introduction

Oracle released Java 26 in March, which offered meaningful features that boost performance, new APIs, and preview features that may become permanent features in future releases. This release primarily focused on improvements in areas like garbage collection, networking, startup performance, cryptography, and other language features.

In this tutorial, we’ll briefly talk about all key features introduced in Java 26.

2. Restricts Reflective Modification of final Fields

We create final variables to ensure developers that their values can’t be changed after initialization. This will help us create immutable objects and help the JVM perform certain optimizations. However, this can be breached using reflections.

There are libraries and frameworks that use reflections to modify final fields after an object has been created. This will invalidate the assumptions made by developers, and JVM optimizations may no longer hold true.

Starting from Java 26, the platform takes another step towards stronger encapsulation and integrity. When code tries to modify a final field using deep reflection, the JVM shows warnings indicating to the developer that the operation relies on a behavior that is being phased out. Even though this is currently not enforced, the direction is clear; future Java releases are expected to impose stronger restrictions.

This will impact certain serialization libraries, dependency injection frameworks, mocking tools, and legacy code that bypasses constructors to populate object state.

Developers should now start to audit and identify reflective writes to final fields and migrate toward supported alternatives such as constructors, builders, factory methods, or records or use framework-provided APIs designed for immutable objects.

3. Removal of Applet API

Applets were historically used to run Java applications in browsers. However, modern browsers don’t support applets due to performance, compatibility, and security concerns. This is considered an outdated technology, and this API has been marked deprecated since Java 9. Developers nowadays use much better alternatives like Swing/JavaFX for UI.

With Java 26, the applet API is no longer existent. This update helps Oracle keep Java streamlined and secured while also reducing the maintenance burden. Its removal will affect only very old legacy applications that still depend on it.

4. Ahead of Time Object Caching with Any GC

Java is known for building distributed cloud-native applications that are frequently deployed, scaled, started, and stopped. Oracle is working towards bringing enhancements that reduce the start-up overhead, which allows applications to reach their peak performance more quickly. In Java 26, Oracle introduced one such enhancement.

Java has Ahead of Time (AOT) object caching, which identifies the objects that are expensive to create during startup and stores them in a cache. When the application starts again, these objects are loaded directly from the cache instead of recreating them, thereby reducing the start-up overhead.

The benefits of Ahead of Time (AOT) are limited to specific GC configurations. However, in Java 26, this feature is available to any garbage collector, including low-latency collectors such as Z Garbage Collector (ZGC).

This enhancement allows developers to take advantage of AOT object caching without giving up their preferred garbage collector.

5. HTTP/3 for the HTTP Client API

Network resilience and latency are key factors for applications that communicate heavily over the network, like microservices, real-time applications, and cloud-native services. With Java 26, the HTTP Client API now supports HTTP/3, which is the latest version of the HTTP protocol.

While HTTP/1.1 and HTTP/2 were built on top of TCP, HTTP/3 uses the QUIC transport protocol, which runs on UDP and addresses some of the limitations of the TCP protocol. With TCP, a packet loss can delay all streams that are sharing the same connection, while QUIC allows streams to progress independently. QUIC achieves this by combining both transport and security handshakes to reduce the number of network round trips required before data starts flowing.

Another practical advantage is automatic protocol negotiation. If the target server supports HTTP/3, the client can use it. If not, it can seamlessly fall back to HTTP/2 or HTTP/1.1, ensuring compatibility with existing infrastructure.

With the introduction of HTTP/3, applications can now experience reduced latency and improved responsiveness. This is especially useful for real-time and cloud-native applications.

Let’s now take a look at a quick example:

@Test
void givenHttp3Client_whenSendingARequest_thenShouldReceiveSuccessfulResponse()
    throws IOException, InterruptedException {

    HttpClient client = HttpClient.newBuilder()
      .version(HttpClient.Version.HTTP_3)
      .build();

    HttpRequest request = HttpRequest.newBuilder()
      .uri(URI.create("https://example.com"))
      .GET()
      .build();

    HttpResponse<String> response =
      client.send(request, HttpResponse.BodyHandlers.ofString());

    assertEquals(200, response.statusCode());
}

To use HTTP/3, we configure the HttpClient by specifying HttpClient.Version.HTTP_3 while building the client. We then create a simple GET request to https://example.com and send it synchronously using the send() method. Finally, we verify that the request completes successfully by asserting that the response status code is 200.

It’s worth noting that configuring the client for HTTP/3 doesn’t guarantee that the connection will use HTTP/3. If the target server doesn’t support HTTP/3, the client automatically falls back to an earlier HTTP version (HTTP/2 or HTTP/1.1), while still completing the request successfully.

6. G1 Garbage Collector Throughput Improvements

For quite some time, the Garbage First (G1) garbage collector has been Java’s default garbage collector. It offers an impressive blend of throughput, memory, and predictability of pause times.

A typical modern Java application will constantly create or update object references. G1 is responsible for tracking object reference changes to perform garbage collection. Ultimately, there is some overhead in this tracking, particularly in applications with high allocation rates or frequent object updates.

With Java 26, G1 now has a set of internal changes that improve the throughput of an application. One such change is reducing the need for mutator application threads and garbage collection (GC) threads to synchronize when tracking the changes of which object references have been changed.  Because of these improvements, application threads will synchronously wait less time related to GC and more time performing application logic.

7. PEM Encodings of Cryptographic Objects (Second Preview)

Applications that deal with security often need to handle certificates, public and private keys, and certificate chains. Cryptographic objects are usually stored and transmitted using PEM (Privacy Enhanced Mail). PEM is a text-based format that allows binary security data to be formatted in a compact manner.

Java developers have historically been required to deploy third-party libraries or write code of their own to read and write PEM files. This has made security-related applications both complex and cumbersome due to additional dependencies and code that serves little or no purpose.

Java 26 introduces the second preview of a newly proposed API to PEM format cryptographic objects that adds the capability to Java SE. Using the proposed API brings the capability to Java developers to read and write certificates and keys using the standard Java SDK instead of using libraries.

The proposed API enhances Java’s capability to integrate with standard security protocols and infrastructure. It also simplifies the management of certificates and keys. In addition, the API reduces the time and effort to write custom code for applications. Even if it is still a preview, it provides a more consistent and pragmatic approach to Java security.

8. Structured Concurrency (Sixth Preview)

Structured concurrency adds to Project Loom’s collection of tools to simplify concurrent programming in Java by proposing that multiple related tasks be treated as a unit of work, rather than requiring developers to manage multiple threads separately.

In traditional concurrent code, coordinating threads, handling failures, and cleaning up resources can become complex. Structured concurrency allows related tasks to run within the defined scope, and if one task fails, other related tasks will be cancelled automatically. This helps prevent wasted work.

Java 26 includes the sixth preview of Structured Concurrency, bringing further refinements based on real-world usage and community feedback as the feature moves closer to becoming a permanent part of the platform in the future.

9. Lazy Constants (Second Preview)

In a normal scenario, class constants are created when the class gets loaded, even though the application never uses them. This contributes to increased startup time and creation of unnecessary objects.

To address this, developers used to introduce their own code to create constants only when they were actually needed. Often this code is complex, less readable, and harder to maintain.

With lazy constants, this mechanism is now built in. Developers can now reap the benefits of lazy loading without having to introduce complex code. By creating objects only when they are first used, applications can now start faster and use fewer resources. Java 26 includes the second preview of this feature.

10. Vector API (Eleventh Incubator)

Vector API in Java 26 is an incubator feature, which allows developers to take advantage of SIMD (Single Instruction, Multiple Data).

Normally, a processor performs an operation on one value at a time. With SIMD, the same operation can be performed on multiple values at once. This helps applications achieve performance closer to native code while remaining portable across different CPU architectures.

This will significantly improve the performance for computation-heavy workloads such as scientific computing, data analytics, image processing, machine learning, and financial calculations.

11. Primitive Types in Patterns, instanceof, and switch (Fourth Preview)

Pattern matching makes code easier to read and reduces the need for manual type checks and casting. In previous releases, this is only supported for reference types.

However, with Java 26, this is also included for primitive types like int, long, float, and double. This allows developers to work with primitive values more naturally in pattern matching constructs, including switch statements and other pattern-based control flow.

12. Conclusion

We’ve seen various improvements and new features introduced in Java 26. While they are a mix of permanent and preview features, it’s evident that the Java community is moving towards making Java ideal for modern-day enterprise application development.

The source code for the examples can be found over on GitHub.