Java im Jahr 2025: Was sich ändert und warum Sie Ihren Code aktualisieren sollten

Java stirbt nicht – es wird wiedergeboren

Jedes Jahr schreibt jemand „Java ist tot“. Und jedes Jahr beweist Java das Gegenteil. Im Jahr 2025 erhält die fast 30 Jahre alte Sprache gleich mehrere grundlegende Updates. Wenn Sie in Java programmieren, aber das letzte Mal vor einem Jahr ins Changelog geschaut haben – sind Sie bereits zurückgefallen. Lassen Sie uns durchgehen, was sich konkret ändern wird und wie diese Änderungen Ihren Code beeinflussen werden.

Ich werde Sie nicht mit trockenen Spezifikationen überladen. Stattdessen – echte Beispiele, die Sie schon heute (na ja, fast) ausführen können. Los geht's.

Virtuelle Threads (Project Loom) – das Ende der Blockade-Ära

Dies ist wohl die größte Änderung. Virtuelle Threads sind leichtgewichtige Threads, die es ermöglichen, asynchronen Code in einem synchronen Stil zu schreiben. Im Jahr 2025 werden sie endlich stabil und für die Produktion empfohlen.

Früher schrieb man so etwas wie:

ExecutorService executor = Executors.newFixedThreadPool(10);\nexecutor.submit(() -> {\n    // blockierender Aufruf\n    String result = restTemplate.getForObject(url, String.class);\n    return result;\n});

Das Problem ist, dass jeder Thread ein schweres Objekt ist. 10 Threads – okay, 10.000 – schon problematisch. Mit virtuellen Threads können Sie Millionen von Threads starten, ohne auf den Speicher achten zu müssen:

try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {\n    for (int i = 0; i < 100_000; i++) {\n        executor.submit(() -> {\n            // das ist jetzt leichtgewichtig\n            String result = restTemplate.getForObject(url, String.class);\n            return result;\n        });\n    }\n}

Der entscheidende Unterschied: Virtuelle Threads sind nicht an OS-Threads gebunden. Wenn ein Thread blockiert (z. B. bei I/O), wechselt die JVM einfach zu einem anderen virtuellen Thread. Keine zusätzlichen Kosten.

Was bedeutet das für Sie? Vergessen Sie komplexe asynchrone Frameworks wie CompletableFuture und reaktive Bibliotheken. Im Jahr 2025 wird standardmäßiger synchroner Code mit virtuellen Threads sowohl schneller als auch einfacher sein.

Wie Sie migrieren

Ersetzen Sie newFixedThreadPool durch newVirtualThreadPerTaskExecutor. Wenn Sie Spring Boot verwenden – aktualisieren Sie auf Version 3.2+, dort gibt es bereits Unterstützung. Stellen Sie nur sicher, dass Ihre Bibliotheken synchronized nicht in kritischen Abschnitten verwenden – das ist der einzige Punkt, an dem virtuelle Threads „stecken bleiben“ können.

Pattern Matching und Switch – Code wird kürzer

Im Jahr 2025 hat Pattern Matching switch und instanceof erreicht. Jetzt können Sie statt einer Reihe von verschachtelten if-else-Anweisungen prägnant und lesbar schreiben.

Früher (alter Stil):

if (obj instanceof String) {\n    String s = (String) obj;\n    System.out.println(s.length());\n} else if (obj instanceof Integer) {\n    Integer i = (Integer) obj;\n    System.out.println(i * 2);\n}

Jetzt (Java 21+):

switch (obj) {\n    case String s -> System.out.println(s.length());\n    case Integer i -> System.out.println(i * 2);\n    case null -> System.out.println("null");\n    default -> System.out.println("unknown");\n}

Beachten Sie case null – das ist eine separate Verbesserung. Früher warf switch eine NullPointerException bei Übergabe von null. Jetzt kann dies explizit behandelt werden.

Eine weitere coole Funktion sind Record Patterns. Wenn Sie einen Record haben:

record Point(int x, int y) {}

Dann können Sie schreiben:

if (obj instanceof Point(int x, int y)) {\n    System.out.println("x=" + x + ", y=" + y);\n}

Ohne überflüssige Typumwandlung. Im Jahr 2025 wird dies Mainstream sein – nutzen Sie es, um den Code sauberer zu machen.

Garbage Collection: ZGC und Generational GC

Im Jahr 2025 ist die Garbage Collection noch schneller geworden. ZGC (Z Garbage Collector) ist jetzt standardmäßig für die meisten Anwendungen aktiviert. Seine