Staying Ahead: Key Highlights from Java 26

Java 26 is getting closer and is scheduled to be released in March 2026.
You can already access Early Access builds and start experimenting with the new features.

Java 26 will probably not be used by many projects in production, since most vendors will not support it as an LTS release, the next LTS target will be Java 29.

Even so, staying updated with non-LTS releases is important, because it helps you prepare and benefit more when the next LTS becomes available.

Let’s take a look at what’s new in Java 26.

What’s New in Java 26

Java 26 includes the following JEPs:

• JEP 500 – Prepare to Make Final Mean Final

• JEP 504 – Remove the Applet API

• JEP 516 – Ahead-of-Time Object Caching with Any GC

• JEP 517 – HTTP/3 for the HTTP Client API

• JEP 522 – G1 GC: Improve Throughput by Reducing Synchronization

• JEP 524 – PEM Encodings of Cryptographic Objects (Second Preview)

• JEP 525 – Structured Concurrency (Sixth Preview)

• JEP 526 – Lazy Constants (Second Preview)

• JEP 529 – Vector API (Eleventh Incubator)

• JEP 530 – Primitive Types in Patterns, instanceof, and switch (Fourth Preview)

As you can see, Java 26 brings some improvements in garbage collection and performance. The Applet API is finally gone 😢, but we’ll skip that topic for now. Instead, let’s focus on two updates that are especially interesting: JEP 526 and JEP 525.

JEP 526: Lazy Constants (Second Preview)

Lazy Constants allow you to initialize constants only when they are actually used, instead of during class loading. This can help reduce startup time and avoid unnecessary initialization.

public class LazyConstantExample {

    private static final LazyConstant<LazyClass> lazyClass = LazyConstant.of(() -> new LazyClass());

    public static void main(String[] args) {
        System.out.println(”Initialize”);
        lazyClass.get().printClassName();
        System.out.println(”End”);
    }

    private static class LazyClass {

        LazyClass() {
            System.out.println(”LazyClass created”);
        }

        public void printClassName() {
            System.out.println(this.getClass().getName());
        }
    }
}

The output from this class is:

Initialize
LazyClass created
com.bomfim.java26.LazyConstantExample$LazyClass
End

As shown, the class is created only when get() is called.

JEP 525: Structured Concurrency (Sixth Preview)

Structured Concurrency is still evolving, and I wanted to mention it here because I’ve already written about this topic before here:

Structured Concurrency — Joiners

That said, the API has changed a bit in Java 26, and yes, there are breaking changes 😲

But don’t worry, breaking changes are expected for preview features. This is exactly why you should be careful when using them in production.

The changes are not huge, mostly renaming and small adjustments. However if you followed my previous article on Structured Concurrency, that code will no longer work as-is.

Once this feature becomes stable, I’ll share an updated guide showing how to use it properly and how you can take advantage of it.

So feel free to subscribe to stay up to date with the latest Java news.

If you want to access the code, you can check it out here: https://github.com/ThiagoBfim/java-news

For more details about Java 26, I recommend taking a look at the official documentation: https://openjdk.org/projects/jdk/26/