Java 21 in der Praxis: Die Features, die Ihren Code verändern

Java 21: Das wichtigste LTS-Release seit Jahren

Java 21 ist nicht einfach ein weiteres Update — es ist das umfangreichste LTS-Release seit Java 11. Mit Virtual Threads, ausgereiftem Pattern Matching und Records wird Java zu einer deutlich moderneren Sprache. Hier sind die Features, die im Projektalltag den größten Unterschied machen.

1. Virtual Threads (Project Loom)

Das wahrscheinlich wichtigste Feature: Leichtgewichtige Threads, die von der JVM verwaltet werden.

Vorher: Platform Threads

// Jeder Thread = ein OS-Thread (~1 MB Stack)
// Bei 10.000 gleichzeitigen Requests: 10 GB RAM nur für Threads
ExecutorService executor = Executors.newFixedThreadPool(200);

Nachher: Virtual Threads

// Millionen gleichzeitiger Threads möglich
ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor();

// Oder direkt
Thread.startVirtualThread(() -> {
    var result = httpClient.send(request, BodyHandlers.ofString());
    // Blocking ist OK — der Virtual Thread wird geparkt, nicht der OS-Thread
});

Wann einsetzen: Bei I/O-lastigen Anwendungen (REST-APIs, Datenbankzugriffe, HTTP-Clients). Nicht relevant für CPU-intensive Berechnungen.

Quarkus und Spring Boot unterstützen Virtual Threads bereits — oft reicht eine Konfigurationsänderung.

2. Pattern Matching for switch

Typprüfungen und Casts in einem Schritt — deutlich lesbarer als verschachtelte instanceof-Ketten.

Vorher:

if (shape instanceof Circle c) {
    return c.radius()  c.radius()  Math.PI;
} else if (shape instanceof Rectangle r) {
    return r.width() * r.height();
} else {
    throw new IllegalArgumentException("Unknown shape");
}

Nachher:

return switch (shape) {
    case Circle c    -> c.radius()  c.radius()  Math.PI;
    case Rectangle r -> r.width() * r.height();
    default          -> throw new IllegalArgumentException("Unknown shape");
};

In Kombination mit Sealed Classes prüft der Compiler Vollständigkeit — kein default nötig:

sealed interface Shape permits Circle, Rectangle {}
record Circle(double radius) implements Shape {}
record Rectangle(double width, double height) implements Shape {}

// Compiler weiß: alle Fälle abgedeckt
double area = switch (shape) {
    case Circle c    -> c.radius()  c.radius()  Math.PI;
    case Rectangle r -> r.width() * r.height();
};

3. Records für DTOs und Value Objects

Records eliminieren Boilerplate für unveränderliche Datenobjekte:

// Statt 50 Zeilen mit Konstruktor, Getter, equals, hashCode, toString:
record KundeDto(String name, String email, LocalDate registriert) {}

// Verwendung
var kunde = new KundeDto("Max Mustermann", "[email protected]", LocalDate.now());
System.out.println(kunde.name()); // Accessor ohne "get"

Ideal für: JPA-Projektionen, REST-Request/Response-Objekte, Event-Payloads.

4. Sequenced Collections

Endlich eine einheitliche API für den Zugriff auf erstes und letztes Element:

// Vorher: Inkonsistent
list.get(0);                    // List
set.iterator().next();          // SortedSet
deque.getFirst();               // Deque

// Nachher: Einheitlich
collection.getFirst();
collection.getLast();
collection.reversed();

5. String Templates (Preview)

Interpolation direkt in Java — kein String.format oder +-Verkettung mehr:

// Preview in Java 21, stabil erwartet in Java 23+
String html = STR."""
    <h1>\{kunde.name()}</h1>
    <p>Registriert seit \{kunde.registriert()}</p>
    """;

Migration von Java 11/17 auf 21

Die Migration ist in den meisten Fällen unkompliziert:

1. Build-Tool aktualisieren: Maven Compiler Plugin auf Java 21
2. Dependencies prüfen: Die meisten Libraries unterstützen Java 21
3. Deprecated APIs ersetzen: SecurityManager ist deprecated
4. Schrittweise Features einführen: Records und Pattern Matching zuerst, Virtual Threads nach Lasttests

<properties>
    <maven.compiler.source>21</maven.compiler.source>
    <maven.compiler.target>21</maven.compiler.target>
</properties>

Fazit

Java 21 macht die Sprache kompakter, ausdrucksstärker und leistungsfähiger. Virtual Threads allein rechtfertigen die Migration — sie beseitigen das größte Skalierungsproblem von Java-Anwendungen ohne Code-Änderungen.

Wenn Sie noch auf Java 11 oder 17 sind: Die Migration auf 21 lohnt sich. In unseren Schulungen zeigen wir, wie Sie die neuen Features praxisnah in bestehende Projekte integrieren.