Java 25 (LTS)

Java 25 (September 2025) ist eine LTS-Version. Zwischen Java 22 und 25 sind wichtige Sprach- und Plattform-Features gereift: von Vorschauen (Preview/Incubator) hin zu finalen Features. Diese Seite fasst die wichtigsten Highlights zusammen und zeigt kurze Beispiele.

• Java 22 (März 2024, Feature Release):
  • Foreign Function & Memory API (FFM) finalisiert
  • String Templates (2. Vorschau)
  • Structured Concurrency (2. Vorschau)
  • Stream Gatherers (Vorschau)
  • Unnamed Patterns & Variables (Vorschau)
  • Launch Multi‑File Source‑Code Programs (bequemer Programmstart)
  • Vector API (weiterer Incubator‑Stand)
• Java 23 (September 2024, Feature Release):
  • Entwurf: weitere Previews/Finalisierungen rund um String Templates, Structured Concurrency, Vector API u.a. – bitte bestätigen.
• Java 24 (März 2025, Feature Release):
  • Entwurf: Konsolidierungen und Performance – bitte bestätigen.
• Java 25 (September 2025, LTS – geplant):
  • Entwurf: Konsolidiertes LTS‑Ziel (Stabilisierung von Previews, Performance/GC) – bitte bestätigen.

Die FFM‑API ist ab Java 22 final. Sie erlaubt typsichere Interop mit nativen Bibliotheken und kontrollierten Off‑Heap‑Speicherzugriff – ohne JNI‑Boilerplate.

Mini‑Beispiel (Speicher allokieren/lesen/schreiben):

import java.lang.foreign.Arena;
import java.lang.foreign.MemorySegment;
import java.lang.foreign.ValueLayout;

class Ffm22FinalDemo {
  public static void main(String[] args) {
    try (Arena arena = Arena.ofConfined()) {
      MemorySegment seg = arena.allocate(ValueLayout.JAVA_INT);
      seg.set(ValueLayout.JAVA_INT, 0, 42);
      int v = seg.get(ValueLayout.JAVA_INT, 0);
      System.out.println(v); // 42
    }
  }
}

Nutzen: weniger JNI, sichere Lebenszyklen, hohe Performance.

String‑Interpolation mit Templates und Prozessoren. In Java 22 weiterhin Preview – Aktivierung über Preview‑Flags.

// Kompilieren/Laufen mit Preview:
// javac --enable-preview --release 22 Demo.java
// java  --enable-preview Demo

import static java.lang.StringTemplate.STR;

class StringTemplates22Demo {
  public static void main(String[] args) {
    int x = 7;
    String s = STR."x = \{x}, x^2 = \{x * x}";
    System.out.println(s);
  }
}

Nutzen: sichere, lesbare Alternative zu Verkettungen und String.format.

Erleichtert die Koordination mehrerer parallel laufender Tasks mit klaren Abbruch‑/Fehlersemantiken.

// Preview-API (Java 22): --enable-preview erforderlich
import java.util.concurrent.Callable;
import java.util.concurrent.StructuredTaskScope;

class StructuredConcurrency22Demo {
  static String fetch() throws Exception {
    try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
      Callable<String> a = () -> expensive("A");
      Callable<String> b = () -> expensive("B");
      var fa = scope.fork(a);
      var fb = scope.fork(b);
      scope.join();
      scope.throwIfFailed();
      return fa.resultNow() + "," + fb.resultNow();
    }
  }

  static String expensive(String id) throws InterruptedException {
    Thread.sleep(50);
    return id;
  }
}

Erweitert die Stream‑Pipeline um flexible „Gatherer“, z. B. für fensternde/akkumulierende Operationen.

// Preview-API: --enable-preview erforderlich
import java.util.stream.Gatherers;
import java.util.stream.Stream;

class GatherersDemo {
  public static void main(String[] args) {
    // laufende Summe als Beispiel
    Stream.of(1, 2, 3, 4)
          .gather(Gatherers.scan((a, b) -> a + b))
          .forEach(System.out::println); // 1, 3, 6, 10
  }
}

Erlaubt das gezielte Weglassen von Namen in Mustern/Bindings mittels _.

record Point(int x, int y) {}

class UnnamedPatternsDemo {
  static String describe(Object o) {
    return switch (o) {
      case Point(int x, _) -> "Point mit x=" + x; // y wird ignoriert
      default -> "?";
    };
  }
}

Ermöglicht, mehrere .java‑Dateien direkt zu starten, ohne vorheriges manuelles Kompilieren/Packaging.

java Main.java util/Helper.java

Die Vektor‑API bleibt im Incubator und ermöglicht portables SIMD. Eignet sich für numerische/ML‑nahe Hot‑Loops.

Inhalte dieses Abschnitts sind als Platzhalter/Entwurf gedacht und sollten nach Bestätigung konkretisiert werden.

• Mögliche Schwerpunkte: weitere Previews/Finalisierungen rund um String Templates, Structured Concurrency, Gatherers/Vector API, Performance‑ und GC‑Verbesserungen.
• Bitte gewünschte JEPs/Themen nennen, die hier konkret dargestellt werden sollen.

• Mögliche Schwerpunkte: Konsolidierung vor LTS, Stabilisierung von APIs, Tooling‑Verbesserungen.
• Bitte konkrete Themen/JEPs nennen.

Java 25 ist die aktuelle LTS‑Version und enthält 18 final veröffentlichte JEPs. Die wichtigsten und für Entwickler besonders relevanten Features sind im Folgenden priorisiert dargestellt.

Pattern Matching unterstützt nun alle primitiven Datentypen (z.B. int, double) in Typmustern und switch‑Expressions. Dadurch entfällt unnötiges Autoboxing und das Pattern‑System wird vollständig konsistent.

Mit import module <Modulname>; können alle exportierten Packages eines Moduls mit einer einzigen Deklaration importiert werden. Dadurch sinkt der Import‑Boilerplate – insbesondere in modularen Anwendungen – deutlich.

Einfachere Single‑File‑Programme ohne öffentliche Klassendeklaration und mit einer nicht‑statischen main‑Methode. Ideal für Skripte, Lernbeispiele und kleine Tools.

Konstruktoren können nun vor super() oder this() einen sogenannten Prolog enthalten – etwa für Validierungen oder frühzeitige Initialisierung von Feldern. Ein großes Qualitäts‑of‑Life‑Feature für saubere Konstruktorlogik.

Ermöglicht gruppierte, sicherere Nebenläufigkeit mit klaren Abbruch‑ und Fehlersemantiken. Insbesondere in Kombination mit virtuellen Threads sinnvoll.

Leichtere und performantere Alternative zu ThreadLocal für kontextbezogene immutable Werte. Ideal für Logging‑Kontexte, Security‑Kontexte oder Request‑Daten.

„Deferred immutability“: Ein Container wird einmalig gesetzt und ist danach unveränderlich. Ermöglicht Lazy‑Initialisierung ohne Verlust von Optimierungsmöglichkeiten.

Datenparallele Operationen, die zur Laufzeit in SIMD‑Instruktionen umgesetzt werden. Für numerische und ML‑nahe Workloads relevant.

Direkte Unterstützung zum Lesen/Schreiben von PEM‑Dateien (-----BEGIN ...-----). Ersetzt viele bisher notwendige Lösungen in Drittbibliotheken.

Standardisierte API für PBKDF2, HKDF, scrypt und ähnliche Verfahren. Vereinheitlicht die sichere Schlüsselableitung in modernen Protokollen.

Optionale Reduktion der Objekt‑Header‑Größe auf 64 Bit. Senkt den Heap‑Verbrauch teils deutlich und verbessert Cache‑Lokalität.

Shenandoah erhält eine produktionsreife Young/Old‑Generation‑Trennung. Verbesserte Durchsatz‑ und Pausenzeiten, analog zu G1/ZGC.

Einfacherer Workflow zum Erstellen eines AOT‑Caches: Profilieren und Kompilieren in einem Schritt.

Verkürzt die JVM‑Aufwärmphase durch Wiederverwendung zuvor gesammelter Profiling‑Daten. Nützlich für Microservices und CLI‑Tools.

Präzises Messen von CPU‑Zeit statt Sampling‑Heuristiken. Liefert exaktere Hotspot‑Analysen.

Stabileres Sampling nur an Safepoints – weniger Verzerrung und weniger Risiko unsicherer Stack‑Zustände.

Gezieltes bytecode‑basiertes Instrumentieren einzelner Methoden zur präzisen Aufruf‑Analyse ohne Codeänderung.

X86‑32‑Support wurde entfernt. Fokus auf moderne 64‑Bit‑JVMs, reduzierter Wartungsaufwand.

Damit steht Java 25 als moderne, konsolidierte LTS‑Version bereit, die sowohl Sprachfeatures als auch Performance, Nebenläufigkeit und Diagnosefähigkeiten deutlich verbessert.

Mit Java 22 wurden zentrale Bausteine wie die FFM‑API produktionsreif. Die folgenden Releases bis Java 25 (LTS) dienen voraussichtlich der Konsolidierung und Abrundung (String Templates, Structured Concurrency, Stream Gatherers, Vektor‑API etc.). Sobald Ihre Wunsch‑Schwerpunkte für 23–25 feststehen, füllen wir die Entwurfsabschnitte mit konkreten, lauffähigen Beispielen und setzen die Seite auf „draft: false“.