Java 25: Die wichtigsten Features seit Version 21

Seit September 2025 gibt es das neue Java 25 LTS-Release. Neben den typischen Performance-Verbesserungen und Ressourcen-Optimierungen fallen vor allem die Vereinfachungen für Java-Neulinge auf. Mehr dazu in diesem Artikel.

Java 25 Features

Als neues LTS-Release bringt Java 25 einige Neuerungen im Vergleich zu Java 21 mit. Unter der Haube wurde viel optimiert, das Web-EntwicklerInnen bei der täglichen Arbeit eventuell gar nicht bemerken. Das sind zum Beispiel Optimierungen bei den Garbage-Kollektoren, der Support-Stop für 32 Bit Rechner oder mehr Unterstützung für die AOT-Kompilierung. In diesem Artikel fokussiere ich mich auf Änderungen, die auffallen. Alles Weitere findet ihr im Detail hier: https://openjdk.org/projects/jdk/25/

Rückblick Java 21 Features

Performance Tuning durch Versionsupdate

Java 25 ist performanter als Java 21. Ich teste es mit einer kleinen, produktiven Spring Boot Webanwendung. Dazu starte ich die Anwendung 10 Mal mit Java 21 und 10 Mal mit Java 25. Dabei protokolliere ich die Startzeiten, wie Spring Boot sie loggt.
  • Java 21
    • Schnellste Zeit: 2,976 Sekunden
    • Langsamste Zeit: 3,376 Sekunden
    • Durchschnitt: 3,087 Sekunden
  • Java 25
    • Schnellste Zeit: 2,537 Sekunden
    • Langsamste Zeit: 2,760 Sekunden
    • Durchschnitt: 2,653 Sekunden
In diesem einfachen Performancetest ist Java 25 circa 14% schneller als Java 21. Im Vergleich zu älteren Versionen, wie Java 17 oder 11 wäre die Performance-Steigerung noch deutlicher.

Module Import

In Java 25 wurde der Modul-Import eingeführt. Vorher konnte man einzelne Klassen, Konstanten oder Pakete importieren, mit JEP 511 können ganze Module importiert werden:
import module java.base;

public class Java25 {

    static void jep511_ModuleImport() {
        for (var item : List.of("1", 0))
            jep456_UnnamedVariable(item);
    }
    ...
}
Der vorherige Code-Ausschnitt benutzt die Klasse List innerhalb der Klasse Java25. Statt einem Einzelklassen-Import (import java.util.List;) wird sie zusammen mit den anderen Klassen des java.base-Moduls importiert.

Keine Klasse und vereinfachte main-Methode

Java 25 lernt sich leichter für Neulinge, weil:
  • die main-Methode kein "public static" und kein "String[] args" mehr benötigt.
  • keine Klasse mehr für die main-Methode braucht.
  • die Klassen des java.base-Moduls (hier ArrayList und IO) automatisch importiert sind. Wäre die main-Methode in einer Klasse, so müssten wir die Klasse ArrayList importieren.
Hier der Inhalt einer kompletten Java-Datei, welche die neue Klasse IO verwendet, um mit der Konsole zu interagieren:

void main() {
    var list = new ArrayList<String>();
    while (list.size() < 2) {
        IO.print("Enter max 2 items in Console: ");
        list.add(IO.readln());
    }
    IO.println("Java 25 items are " + list);
}
(Mehr dazu in JEP 512.)

Unbenannte Variablen

JEP 456 führt unbenannte Variablen in Java 22 ein. Bisher brauchte jede Variable einen Namen, auch wenn wir sie nicht benutzt haben. Nun können wir ungenutzte Variablen einfach mit Unterstrich _ benennen. Im folgenden Beispiel verwende ich unbenannte Variablen für eine Exception und einen String, die im Code ignoriert werden:

static void jep456_UnnamedVariable(Object obj) {
    try {
        switch (obj) {
            case String _ -> IO.println("Any Text.");
            case Integer number -> IO.println(10 / number);
            default -> IO.println("Unknown type");
        }
    } catch (Exception _) {
        IO.println("Exception caught without caring about details.");
    }
}

Kommentare in Markdown

Seit Java 23 wird Markdown als Format für Kommentare unterstützt. Dazu muss jede Kommentarzeile mit /// starten. Das sieht dann so aus:
/// # JEP 467
/// Java supports comments in Markdown format.
/// Other Java 25 JEPs in this class are:
/// * JEP 511
/// * JEP 456
public class Java25 {
    ...

Flexible Konstruktor-Bodies

JEP 513 lockert die Regel für Code im Konstruktor. Vor Java 25 durfte vor einem this(...) oder super(...) Konstruktoraufruf kein anderer Code stehen. Durch den flexiblen Konstruktor-Body ist dies nun erlaubt:
public class Java25 {

    Java25() {
        IO.println("Code before super() is allowed with JEP 513.");
        super();
        IO.println("Code after super() was allowed before.");
    }
    ...

Stream Gatherers

Gatherers (JEP 485) bereichern die Stream-Verarbeitung seit Java 24. Dazu hat die Stream API eine neue Methode gather, die Elemente im Stream sammelt. gather ist eine intermediate Operation, so dass der Stream nach gather weiter verarbeitet werden kann. Die Grundlagen zu Streams findet ihr hier.

Gatherer ist ein neues Interface, durch dessen Implementierung wir mit der gather Methode one-to-one, one-to-many, many-to-one und many-to-many Mappings im Stream durchführen können. Im folgenden zeige ich 5 Implementierungen, die Teil von Java 25 sind.

fold

Ein many-to-one Mapping im Stream.
List<Integer> numbers = List.of(1, 2, 3, 4, 5);

// Prints 15 (Stream has only 1 element after gather)
numbers.stream()
        .gather(Gatherers.fold(() -> 0, Integer::sum))
        .forEach(IO::println);

scan

scan nimmt den aktuellen und den vorherigen Wert und wendet eine BiFunction an, um den aktuellen Wert zu ändern.
// Result: [1, 3, 6, 10, 15]
numbers.stream()
        .gather(Gatherers.scan(() -> 0, (previous, current) -> previous + current))
        .toList();
windowFixed

Sammelt jedes Element in gleichgroßen Unterlisten.
// Result: [[1, 2], [3, 4], [5]]
List<List<Integer>> windows = numbers.stream()
        .gather(Gatherers.windowFixed(2))
        .toList();
slidingWindow

Ähnlich wie windowFixed nur mit Überlagerungen der Elemente in den gesammelten Unterlisten.
// Result: [[1, 2], [2, 3], [3, 4], [4, 5]]
List<List<Integer>> slidingWindows = numbers.stream()
        .gather(Gatherers. windowSliding(2))
        .toList();

mapConcurrent

Parallele Ausführung des Mappings im Gatherer, dabei wird die Ordnung des Streams erhalten.
// Result: true - proves that order was kept, 
// because each sliding window has a difference of 1.
IntStream.range(0, 10000)
        .boxed()
        .gather(Gatherers.mapConcurrent(100, x -> x + 1))
        .gather(Gatherers.windowSliding(2))
        .allMatch(pair -> pair.getLast() - pair.getFirst() == 1);

Scoped Values

Scoped Values JEP 506 sind eine Modernisierung von ThreadLocal. Mit ScopedValue definieren wir Objekte, die nur im Rahmen definierter Threads sichtbar sind. Im folgenden Beispiel startet die main-Methode einen Thread. Im Thread wird nur die Methode printScopedValue ausgeführt. Diese Methode greift per get() auf das Integer-Objekt innerhalb des Scopes zu, welches mit ScopedValue.where für die Ausführung des Threads gesetzt wurde.

private static final ScopedValue<Integer> X = ScopedValue.newInstance();

private static void printScopedValue() {
    IO.println("Instead of method-parameter a scoped value is used: " + X.get());
}

void main() {
    ScopedValue.where(X, 666).run(() -> printScopedValue());
    IO.println("Is scoped value bound in main thread: " + X.isBound());
    ...
}
Das Beispiel zeigt 2 Vorteile von ScopedValues:
  1. Werte im Scope des Threads müssen nicht per Methoden-Parameter übergeben werden. Bei einem Wert ist das sicherlich kein Problem, ab 3 Parametern ist es aus Clean Code Sicht problematisch. Mit ScopedValue machen wir beliebig viele Objekte durch mehrfache where-Aufrufe in einem Thread verfügbar.
  2. Außerhalb des Scopes sind die Werte nicht mehr verfügbar und werden so auch nicht unnötig lang im Speicher gehalten. Deshalb liefert X.isBound() im obigen Beispiel den Wert false. Ein Aufruf von X.get() liefert nur innerhalb des Thread den Wert 666. Außerhalb des Scopes (z.B. in der main-Methode) wirft es eine NoSuchElementException.
Hier ein weiteres Beispiel zur Veranschaulichung der NoSuchElementException. Im 2. Aufruf von thread.run() wird diese Exception geworfen, weil Y nur beim ersten Thread-Aufruf (.run(thread)) einen Wert im Scope hat.
private void scopedValueExample2() {
    ScopedValue<String> Y = ScopedValue.newInstance();

    Runnable thread = () -> {
        try {
            IO.println("Print scoped value: " + Y.get());
        } catch (NoSuchElementException _) {
            IO.println("Scoped value was not bound to this thread.");
        }
    };

    ScopedValue.where(Y, "12345").run(thread);
    thread.run();
    IO.println("Is scoped value bound in main thread: " + Y.isBound());
}

Fazit

Meine Java 25 Highlights sind Unbenannte Variablen, Gatherers und die Performance-Tunings, weil ich von diesen 3 Features im Berufsalltag am meisten profitieren werde. 

Die Vereinfachungen um die main-Methode kommen Java-Neulingen mit Sicherheit zugute. Einsteiger in die Programmierung können sich so besser auf das Wesentliche konzentrieren. Sie lernen zuerst Schleifen, Variablen und if-Statements lernen, bevor sie mit Klassen und statischem Code "kämpfen" müssen.

Das Update unserer Spring Boot Anwendung von Java 21 auf Java 25 verlief problemlos. Wir mussten nur die Java-Version in der Maven-Konfiguration anpassen.

Den kompletten Code zu diesem Artikel gibt es hier:
https://github.com/elmar-brauch/java25
Standort: 64 Darmstadt, Deutschland

Beliebte Posts aus diesem Blog

CronJobs mit Spring

Bild
Mit Spring können zeitgesteuerte Aufgaben in Java Code integriert werden. CronJobs wie wir sie in Linux kennen, definieren wir mit Spring einfach per Annotation. In diesem Artikel zeige ich wie das geht und wie Spring die CronJobs entsprechend unserer Definition ausführt. Was ist ein CronJob? Unter CronJob verstehen wir die zeitlich gesteuerte Ausführung eines Kommandos zur Erledigung einer Aufgabe bzw. eines Jobs. Das Kommando wird durch einen bestimmten Zeitpunkt oder eine zeitliche Bedingung angestoßen. Typische Beispiele für durch CronJobs gestartete Aufgaben sind: Regelmäßiges Aufräumen der Datenbank - z. B. um veraltete Daten zu löschen oder DSGVO konform persönliche Daten nach einer definierten Zeit zu löschen. Wöchentlicher Versand von Newslettern oder Werbung per Email Nächtliche Datenbank-Backups Monatliches Erstellen von Rechnungen (z.B. Telefon-Rechnung) Das Betriebssystem Linux bietet crontab zum Erstellen von CronJobs an. Mit crontab könnten wir eine Spring Anwendung star...
Mehr anzeigen

Kernkonzepte von Spring: Beans und Dependency Injection

Bild
In diesem Blog-Post besprechen wir die Basics von Spring: Spring Beans und wie man diese miteinander vernetzt bzw. referenziert (Dependency Injection). Den kompletten Code zu diesem Blog-Post findet ihr in GitHub: https://github.com/elmar-brauch/beans Spring Bean Spring Beans sind Java Objekte, die durch den Spring IoC Container instanziiert und verwaltet werden. Der IoC (Inversion of Control) Container erstellt Beans anhand einer Bean Definition, die der Entwickler in Form von Annotationen oder xml Konfiguration bereitstellt. IoC ist ein Umsetzungsparadigma und bedeutet Steuerungsumkehr. Im Kontext des Spring Frameworks versteht man darunter, dass das Framework die Erstellung des Objektnetzes (Beans) anstelle des Entwicklers übernimmt.   In vorherigen Blog-Artikel haben wir bereits Projekte mit Spring Boot aufgesetzt, siehe z.B.  microservices-mit-spring-boot-erstellen.html . In diesen Projekten verwendeten wir die Annotation  @SpringBootApplication , welche eine Ag...
Mehr anzeigen

OpenID Connect mit Spring Boot 3

Bild
Authentifizierung mit OpenID Connect geht einfach dank Spring Boot. Wir bauen den Login Deiner Web-Anwendung mit dem Autorisierungsserver Deiner Firma. Wie wir dazu OpenID Connect mit Spring Boot 3 konfigurieren, zeige ich in diesem Blog-Artikel. OpenID Connect - Authorization Code Prozess OpenID Connect ist ein Single Sign-On Login-Verfahren. Zur Umsetzung komplexer Anwendungsfälle verwenden größere Firmen meist verteilte Systeme. Damit der Benutzer z. B. beim Online-Shopping den Systemwechsel von Produktseiten zum Einkaufswagen und zur Kasse nicht wahrnimmt, loggt er sich mittels Single Sign-On nur einmal ein. Die beteiligten Systeme authentifizieren den eingeloggten Benutzer anhand seiner Single Sign-On Session. Detaillierte Informationen über OpenID Connect und Single Sign-On findet ihr hier . In diesem Artikel fokussiere ich mich auf das Anwendungs-System, welches zur Benutzer-Authentifizierung den firmeneigenen OpenID Identity Provider verwendet. Bevor wir uns die Implementierung...
Mehr anzeigen