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) final
  • Unnamed Patterns & Variables (Preview, in 22 auf dem Weg zur Finalisierung)
  • Stream Gatherers (Preview)
  • Structured Concurrency (2. Preview)
  • Launch Multi-File Source-Code Programs
  • String Templates (2. Preview – später zurückgezogen)
• Java 23 (September 2024, Feature Release):
  • Markdown in JavaDoc (final)
  • String Templates zurückgezogen
  • Stream Gatherers (2. Preview), Modul-Import (Preview), Primitive Types in Patterns (Preview)
• Java 24 (März 2025, Feature Release):
  • Stream Gatherers und Class-File API (final)
  • Virtual Threads ohne Pinning, Security Manager dauerhaft deaktiviert
  • Scoped Values / Structured Concurrency weiter Preview
• Java 25 (September 2025, LTS):
  • Scoped Values, Module Import, Compact Source Files, Flexible Constructor Bodies (final)
  • Structured Concurrency weiter Preview; Primitive Types in Patterns weiter Preview

Die FFM-API ist ab Java 22 final. Sie erlaubt typsicheren Zugriff auf native Bibliotheken und Off-Heap-Speicher – ohne JNI-Boilerplate.

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
    }
  }
}

Erweitert die Stream-Pipeline um flexible Gatherer, etwa für laufende Summen. In Java 22 Preview, final in Java 24.

// In Java 22: --enable-preview
import java.util.stream.Gatherers;
import java.util.stream.Stream;

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

Namen in Mustern dürfen mit _ weggelassen werden.

record Point(int x, int y) {}

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

Mehrere .java-Dateien lassen sich direkt starten, ohne vorheriges Packaging:

java Main.java util/Helper.java

In Java 22 waren String Templates noch Preview. Vor JDK 23 wurde das Feature entfernt. In aktuellen JDKs gibt es sie nicht. Interpolation bleibt bei Konkatenation, formatted() oder String.format.

Structured Concurrency blieb in 22 Preview und ist auch in Java 25 noch Preview.

Wichtige Punkte gegenüber 22:

• Markdown in JavaDoc (JEP 467, final): Dokumentationskommentare dürfen Markdown verwenden.
• String Templates zurückgezogen: kein Preview mehr, auch nicht mit --enable-preview.
• Stream Gatherers: 2. Preview (final dann in 24).
• Module Import Declarations: Preview (import module …).
• Primitive Types in Patterns: Preview.
• ZGC: generationaler Modus als Default.

Konsolidierung vor der LTS:

• Stream Gatherers und Class-File API sind final.
• Virtual Threads ohne Pinning (JEP 491): synchronized pinnt virtuelle Threads in den üblichen Fällen nicht mehr.
• Security Manager dauerhaft deaktiviert (JEP 486).
• Scoped Values und Structured Concurrency bleiben Preview.
• Weitere Themen: AOT Class Loading & Linking, Compact Object Headers (experimentell), Entfernen des Windows-32-Bit-x86-Ports.

Java 25 ist die aktuelle LTS-Version. Das Release enthält 18 JEPs; davon sind mehrere weiterhin Preview, Incubator oder experimentell – nicht alle 18 sind finale Sprachfeatures.

Pattern Matching unterstützt primitive Typen (int, double, …) in Typmustern und switch. Das bleibt in 25 Preview.

Mit import module <Modulname>; werden alle exportierten Packages eines Moduls importiert.

Einfachere Einzeldatei-Programme ohne öffentliche Klassendeklaration und mit einer nicht-statischen main-Methode. Nützlich für Skripte und kleine Beispiele.

Konstruktoren dürfen vor super() oder this() Validierung und Feldinitialisierung ausführen.

Gruppierte Nebenläufigkeit mit klaren Abbruch- und Fehlersemantiken. Besonders zusammen mit virtuellen Threads sinnvoll – in 25 noch Preview.

Leichtere Alternative zu ThreadLocal für kontextbezogene unveränderliche Werte (Logging, Security, Request-Daten).

Ein Container wird einmal gesetzt und ist danach unveränderlich. Ermöglicht Lazy-Initialisierung ohne den Optimierer auszuschließen.

Datenparallele Operationen, die zur Laufzeit in SIMD-Instruktionen umgesetzt werden.

Lesen und Schreiben von PEM-Dateien (-----BEGIN ...-----) ohne Drittbibliothek.

Standardisierte API für Verfahren wie PBKDF2 und HKDF.

Optionale Reduktion der Objekt-Header-Größe. Senkt den Heap-Verbrauch und verbessert die Cache-Lokalität.

Shenandoah mit Young/Old-Trennung.

Einfacherer AOT-Cache und kürzere Aufwärmphase durch wiederverwendete Profiling-Daten.

JFR erhält präziseres CPU-Time-Profiling (experimentell), Cooperative Sampling sowie Method Timing & Tracing.

Der 32-Bit-x86-Port ist entfernt. Fokus liegt auf 64-Bit-JVMs.

Mit Java 22 wurde die FFM-API produktionsreif. Java 23 zog String Templates zurück und lieferte Markdown in JavaDoc. Java 24 finalisierte Stream Gatherers und die Class-File API. Java 25 als aktuelle LTS konsolidiert Scoped Values, Module-Imports, kompakte Quelldateien und Flexible Constructor Bodies. Structured Concurrency bleibt Preview. Für neue Projekte ist Java 25 die naheliegende LTS; Java 21 bleibt eine weit verbreitete Vorgänger-LTS.