Java seit Java 8: Was hat sich getan? Ein Guide für den Wiedereinstieg

Stand: Februar 2026

Typischer Ausgangspunkt¶

• Java 6 bis 8, Swing für Desktop-GUIs
• Eine einzige JVM/JDK-Quelle: Oracle (damals Sun Microsystems)
• Maven als Build-Tool
• IDE: NetBeans, Eclipse, IntelliJ IDEA

1. Die Java-Landschaft hat sich fundamental verändert¶

1.1 Release-Zyklus¶

Die größte strukturelle Änderung: Java erscheint jetzt alle 6 Monate (März und September). Alle 2 Jahre gibt es ein Long-Term-Support (LTS) Release mit mindestens 3 Jahren Updates.

Ausgangssituation (2014)             Heute (2025/2026)
────────────────                     ──────────────────
Java 8 (LTS, 2014)                   Java 25 (aktuell, LTS, Sep 2025)
Nächste Version: ??? Jahre warten    Neue Version alle 6 Monate
Ein Anbieter: Oracle/Sun             Dutzende JDK-Distributionen
JRE separat installierbar            JRE existiert nicht mehr separat

1.2 Die LTS-Versionen (die wichtigsten Meilensteine)¶

Empfehlung: Java 21 ist das aktuelle LTS und sollte für neue Projekte verwendet werden. Java 8 und 11 sind noch stark in Legacy-Projekten vertreten.

2. JDK-Distributionen: Oracle ist nicht mehr der einzige Anbieter¶

2.1 Was ist passiert?¶

Nach der Übernahme von Sun Microsystems durch Oracle (2010) hat Oracle die Lizenzpolitik mehrfach geändert. Seit 2019 ist das Oracle JDK für kommerzielle Nutzung kostenpflichtig (mit zeitweiligen Lockerungen). Das hat dazu geführt, dass viele alternative JDK-Distributionen entstanden sind — alle basierend auf dem offenen OpenJDK-Quellcode.

2.2 Die wichtigsten JDK-Distributionen¶

2.3 Welche Distribution wählen?¶

Die Empfehlung lautet: Eclipse Temurin (ehemals AdoptOpenJDK). Es ist der De-facto-Standard für OpenJDK-Distributionen, komplett kostenlos, TCK-getestet und wird von allen großen IDEs unterstützt.

Installation über SDKMAN (empfohlen — verwaltet mehrere Java-Versionen):

# SDKMAN installieren
curl -s "https://get.sdkman.io" | bash

# Java 21 (Temurin) installieren
sdk install java 21.0.4-tem

# Zwischen Versionen wechseln
sdk use java 21.0.4-tem
sdk use java 17.0.12-tem

# Alle verfügbaren Distributionen anzeigen
sdk list java

2.4 JRE gibt es nicht mehr¶

Seit Java 11 liefert Oracle keine separate JRE mehr aus. Stattdessen gibt es jlink, ein Tool das eine maßgeschneiderte Runtime nur mit den benötigten Modulen erstellt — deutlich kleiner als eine volle JRE.

3. Die wichtigsten Syntax-Neuerungen (Java 9 bis 21)¶

3.1 Vergleich: Alter vs. neuer Code¶

// ══════════════════════════════════════════════════
// KLASSISCHER STIL (Java 8)
// ══════════════════════════════════════════════════

package com.example;

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;

public class BenutzerService {

    public static void main(String[] args) {
        List<Benutzer> benutzer = new ArrayList<>();
        benutzer.add(new Benutzer("Max", "Müller", 30));
        benutzer.add(new Benutzer("Anna", "Schmidt", 25));

        // Stream API (Java 8)
        List<String> namen = benutzer.stream()
            .filter(b -> b.getAlter() > 20)
            .map(b -> b.getVorname() + " " + b.getNachname())
            .collect(Collectors.toList());

        for (String name : namen) {
            System.out.println(name);
        }
    }
}

class Benutzer {
    private String vorname;
    private String nachname;
    private int alter;

    public Benutzer(String vorname, String nachname, int alter) {
        this.vorname = vorname;
        this.nachname = nachname;
        this.alter = alter;
    }

    public String getVorname() { return vorname; }
    public String getNachname() { return nachname; }
    public int getAlter() { return alter; }

    @Override
    public boolean equals(Object o) { /* 15 Zeilen Boilerplate */ }

    @Override
    public int hashCode() { /* Noch mehr Boilerplate */ }

    @Override
    public String toString() {
        return "Benutzer{vorname='" + vorname + "', nachname='" + nachname
               + "', alter=" + alter + "}";
    }
}


// ══════════════════════════════════════════════════
// MODERNER STIL (Java 21)
// ══════════════════════════════════════════════════

package com.example;

// Record statt Klasse (Java 16) — immutable, equals/hashCode/toString automatisch
record Benutzer(String vorname, String nachname, int alter) {}

class BenutzerService {
    public static void main(String[] args) {
        // List.of() statt new ArrayList<> (Java 9)
        var benutzer = List.of(    // var statt explizitem Typ (Java 10)
            new Benutzer("Max", "Müller", 30),
            new Benutzer("Anna", "Schmidt", 25)
        );

        // .toList() statt .collect(Collectors.toList()) (Java 16)
        var namen = benutzer.stream()
            .filter(b -> b.alter() > 20)    // b.alter() statt b.getAlter()
            .map(b -> b.vorname() + " " + b.nachname())
            .toList();

        namen.forEach(System.out::println);
    }
}

Die ganze Benutzer-Klasse (38 Zeilen) wurde zu einer Zeile. Das ist der größte sichtbare Unterschied.

3.2 Feature-Übersicht nach Version¶

Java 9 (2017) — Das Modulsystem¶

// module-info.java — neues Konzept, nicht rückwärtskompatibel
module com.example.app {
    requires java.net.http;
    exports com.example.api;
}

// Fabrikmethoden für Collections (endlich!)
List<String> list = List.of("a", "b", "c");           // Unveränderlich!
Set<String> set = Set.of("a", "b", "c");
Map<String, Integer> map = Map.of("key", 1, "key2", 2);

// Private Methoden in Interfaces
interface Greeter {
    default void greetAll(List<String> names) {
        names.forEach(this::greet);
    }
    private void greet(String name) {
        System.out.println("Hallo " + name);
    }
}

Das Modulsystem (Project Jigsaw) war die größte strukturelle Änderung seit Java 1.0. In der Praxis nutzen es viele Projekte allerdings nicht aktiv — die meisten Anwendungen laufen weiterhin auf dem unnamed module/Classpath.

Java 10 (2018) — var¶

// Lokale Typinferenz — der Compiler erkennt den Typ automatisch
var benutzer = new Benutzer("Max", "Müller", 30);  // statt Benutzer benutzer = ...
var liste = new ArrayList<String>();                 // statt ArrayList<String> liste = ...
var stream = liste.stream();                         // statt Stream<String> stream = ...

// WICHTIG: var ist KEIN dynamischer Typ wie in JavaScript!
// Der Typ wird zur Compile-Zeit festgelegt, nicht zur Laufzeit.
// var funktioniert NUR für lokale Variablen, nicht für Felder oder Parameter.

Java 11 (2018, LTS) — Neuer HTTP-Client, String-Methoden¶

// Eingebauter HTTP-Client (ersetzt das uralte HttpURLConnection)
var client = HttpClient.newHttpClient();
var request = HttpRequest.newBuilder()
    .uri(URI.create("https://api.example.com/users"))
    .header("Content-Type", "application/json")
    .build();
var response = client.send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

// Neue String-Methoden
"  Hallo  ".strip();          // "Hallo" (wie trim, aber Unicode-aware)
"  ".isBlank();                // true
"Zeile1\nZeile2".lines();     // Stream<String>
"Ha".repeat(3);                // "HaHaHa"

// var in Lambda-Parametern (für Annotationen nützlich)
list.stream()
    .map((@NotNull var s) -> s.toUpperCase())
    .toList();

Java 14 (2020) — Switch Expressions, Helpful NullPointerExceptions¶

// Switch als Expression (gibt einen Wert zurück!)
int numLetters = switch (day) {
    case MONDAY, FRIDAY, SUNDAY -> 6;
    case TUESDAY                -> 7;
    case WEDNESDAY              -> 9;
    default -> {
        String s = day.toString();
        yield s.length();  // yield statt return in Blöcken
    }
};

// Endlich hilfreiche NullPointerExceptions!
// Vorher: "NullPointerException" (wo genau?!)
// Jetzt:  "Cannot invoke String.toLowerCase() because the return
//          value of User.getName() is null"

Java 15 (2020) — Text Blocks¶

// Mehrzeilige Strings (kein "\\n" + Konkatenation mehr nötig)
String json = """
        {
            "name": "Max",
            "alter": 30,
            "stadt": "Berlin"
        }
        """;

String html = """
        <html>
            <body>
                <p>Hallo Welt</p>
            </body>
        </html>
        """;

// Sealed Classes (Preview in Java 15, stabil ab Java 17)
// Beschränken welche Klassen eine Klasse erweitern dürfen (siehe Java 17 für stabile Version)
sealed interface Shape permits Circle, Rectangle, Triangle {}
record Circle(double radius) implements Shape {}
record Rectangle(double width, double height) implements Shape {}
record Triangle(double base, double height) implements Shape {}

Java 16 (2021) — Records, Pattern Matching for instanceof¶

// Records — immutable Datenklassen in einer Zeile
// Erzeugt automatisch: Konstruktor, Getter, equals(), hashCode(), toString()
record Point(int x, int y) {}

var p = new Point(3, 4);
p.x();        // 3 (Achtung: x() statt getX()!)
p.y();        // 4

// Records können auch Validierung haben:
record Alter(int wert) {
    Alter {  // "Compact Constructor"
        if (wert < 0) throw new IllegalArgumentException("Alter darf nicht negativ sein");
    }
}

// Pattern Matching for instanceof (kein Cast mehr nötig!)
// Vorher (Java 8):
if (obj instanceof String) {
    String s = (String) obj;
    System.out.println(s.length());
}

// Jetzt (Java 16+):
if (obj instanceof String s) {
    System.out.println(s.length());  // s ist automatisch gecastet!
}

// Stream.toList() — kein Collectors.toList() mehr nötig
var namen = stream.map(String::toUpperCase).toList();

Java 17 (2021, LTS) — Sealed Classes¶

// Sealed Classes: Der Compiler kennt ALLE möglichen Subtypen
sealed interface Ergebnis permits Erfolg, Fehler {}
record Erfolg(String daten) implements Ergebnis {}
record Fehler(String nachricht) implements Ergebnis {}

// Zusammen mit Pattern Matching wird das sehr mächtig:
String verarbeite(Ergebnis e) {
    return switch (e) {
        case Erfolg(var daten)      -> "OK: " + daten;
        case Fehler(var nachricht)  -> "Fehler: " + nachricht;
        // Kein default nötig — Compiler weiß, dass alle Fälle abgedeckt sind!
    };
}

Java 21 (2023, LTS) — Virtual Threads, Pattern Matching for switch ⭐¶

// ═══ VIRTUAL THREADS — die größte Neuerung seit Lambdas ═══
// Vorher: Ein OS-Thread pro Task (teuer, ~1MB Stack pro Thread)
// Jetzt: Millionen von Virtual Threads möglich

// Einen Virtual Thread starten:
Thread.startVirtualThread(() -> {
    System.out.println("Läuft auf einem virtuellen Thread!");
});

// Mit Executor:
try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
    for (int i = 0; i < 1_000_000; i++) {
        executor.submit(() -> {
            Thread.sleep(Duration.ofSeconds(1));
            return "Fertig";
        });
    }
}
// 1 Million gleichzeitige Tasks — mit klassischen Threads unmöglich!

// In Spring Boot 3.2+ reicht eine Zeile in application.properties:
// spring.threads.virtual.enabled=true
// → Alle Requests laufen automatisch auf Virtual Threads


// ═══ PATTERN MATCHING FOR SWITCH — voll ausgereift ═══
String formatiere(Object obj) {
    return switch (obj) {
        case Integer i when i > 0  -> "Positive Zahl: " + i;
        case Integer i             -> "Negative oder Null: " + i;
        case String s              -> "Text: " + s;
        case null                  -> "null!";
        default                    -> "Unbekannt: " + obj;
    };
}

// ═══ RECORD PATTERNS — Destrukturierung ═══
record Point(int x, int y) {}

// Direkt in Pattern Matching destrukturieren:
if (obj instanceof Point(int x, int y)) {
    System.out.println("x=" + x + ", y=" + y);
}

// ═══ SEQUENCED COLLECTIONS — endlich einheitlicher Zugriff ═══
SequencedCollection<String> list = new ArrayList<>(List.of("A", "B", "C"));
list.getFirst();     // "A"
list.getLast();       // "C"
list.reversed();     // ["C", "B", "A"]

// ═══ UNNAMED VARIABLES — Unterstrich für ungenutzte Variablen ═══
try {
    int i = Integer.parseInt(input);
} catch (NumberFormatException _) {    // _ statt "e" wenn nicht verwendet
    System.out.println("Ungültige Zahl");
}

Virtual Threads sind besonders relevant für hochparallele Serveranwendungen: Spring Boot auf Java 21 mit Virtual Threads kann Hunderttausende gleichzeitiger HTTP-Requests mit minimalem Ressourcenverbrauch bedienen — ähnlich wie Go's Goroutines, aber in Java.

4. GUI-Bibliotheken: Swing ist tot, lang lebe JavaFX¶

4.1 Aktueller Stand¶

4.2 Was ist mit JavaFX passiert?¶

Seit Java 11 ist JavaFX nicht mehr Teil des JDK. Es wurde als eigenständiges Open-Source-Projekt (OpenJFX) ausgegliedert und wird von der Community und Gluon aktiv weiterentwickelt. Das bedeutet:

• JavaFX wird als Maven/Gradle-Dependency eingebunden, statt "einfach vorhanden" zu sein
• JavaFX hat seine eigene Versionierung (aktuell Version 23/24)
• Einzige Ausnahme: BellSoft Liberica JDK enthält JavaFX noch eingebaut

<!-- JavaFX als Maven-Dependency einbinden -->
<dependency>
    <groupId>org.openjfx</groupId>
    <artifactId>javafx-controls</artifactId>
    <version>21.0.2</version>
</dependency>

4.3 Desktop-Anwendungen in Java heute¶

Desktop-Entwicklung mit Java ist deutlich weniger verbreitet als in früheren Jahren. Die meisten Anwendungen sind heute Web-basiert. Die wichtigsten Ausnahmen sind IDEs (IntelliJ, Eclipse, NetBeans) und spezialisierte Unternehmens-Software.

Für neue Desktop-Apps in der JVM-Welt bietet sich Compose Desktop (Kotlin, von JetBrains) als modernster Ansatz an — deklaratives UI ähnlich wie Svelte oder React, aber in Kotlin.

5. Build-Tools: Maven lebt, Gradle holt auf¶

5.1 Maven heute¶

Maven existiert weiterhin und ist nach wie vor das meistverbreitete Build-Tool in der Java-Welt. Die Grundstruktur (pom.xml, Lifecycle, Repositories) hat sich seit Java-8-Zeiten kaum verändert. Wer Maven 3 kennt, kennt es heute noch.

Neuere Entwicklungen:

• Maven 4 ist in Entwicklung (seit Jahren) und soll das POM-Format modernisieren
• Maven Wrapper (mvnw) — ähnlich wie Gradle Wrapper: Die Maven-Version wird im Projekt mitgeliefert, jeder Entwickler nutzt exakt dieselbe Version
• Maven Daemon (mvnd) — hält eine JVM am Laufen für schnellere Builds (inspiriert von Gradle)

# Maven Wrapper generieren (mit dem Maven Wrapper Plugin)
mvn wrapper:wrapper

# Dann statt "mvn" einfach:
./mvnw clean install

5.2 Gradle als Alternative¶

Gradle ist der Herausforderer, der vor allem durch Android-Entwicklung (Google wählte Gradle als Standard-Build-Tool für Android) massiv an Verbreitung gewonnen hat.

// build.gradle.kts (Kotlin DSL) — zum Vergleich mit pom.xml
plugins {
    java
    id("org.springframework.boot") version "3.2.0"
}

dependencies {
    implementation("org.springframework.boot:spring-boot-starter-web")
    implementation("org.postgresql:postgresql:42.7.1")
    testImplementation("org.springframework.boot:spring-boot-starter-test")
}

java {
    toolchain {
        languageVersion = JavaLanguageVersion.of(21)
    }
}

5.3 Empfehlung¶

Bei vorhandenen Maven-Kenntnissen empfiehlt es sich, dabei zu bleiben. Es funktioniert, ist bekannt, und für ein Spring-Boot-Projekt macht es keinen praktischen Unterschied. Gradle lohnt sich vor allem bei sehr großen Multi-Modul-Projekten oder bei Android-Entwicklung.

6. Das Ökosystem: Frameworks und Bibliotheken¶

6.1 Web-Frameworks¶

6.2 Jakarta EE: Der Namens-Wechsel¶

Java EE wurde von Oracle an die Eclipse Foundation übergeben und heißt jetzt Jakarta EE. Die wichtigste praktische Konsequenz: Alle Paketnamen haben sich geändert.

// Vorher (Java EE):
import javax.servlet.http.HttpServlet;
import javax.persistence.Entity;

// Jetzt (Jakarta EE):
import jakarta.servlet.http.HttpServlet;
import jakarta.persistence.Entity;

Das betrifft auch JPA/Hibernate, Servlets, JAX-RS, CDI, usw. Spring Boot 3.x erfordert Jakarta EE — ein Upgrade von Spring Boot 2.x auf 3.x bedeutet also auch diesen Namespace-Wechsel.

6.3 JVM-Sprachen¶

Die JVM ist heute nicht nur für Java da. Mehrere Sprachen laufen auf derselben VM:

Kotlin ist dabei die wichtigste Entwicklung: Es ist praktisch ein "besseres Java" mit Null-Safety, Coroutines, Extension Functions und deutlich weniger Boilerplate. Viele Spring-Boot-Projekte werden heute in Kotlin statt Java geschrieben.

6.4 Wichtige Bibliotheken (was sich geändert hat)¶

7. Garbage Collectors: Neue Generation¶

Die JVM hat heute mehrere hochoptimierte Garbage Collectors:

Der CMS (Concurrent Mark Sweep) und der Parallel GC der früheren Java-Versionen wurden durch G1 ersetzt. ZGC und Shenandoah sind die Zukunft für latenz-sensitive Anwendungen.

8. GraalVM und Native Images¶

Eine der spannendsten Entwicklungen: GraalVM kann Java-Anwendungen in native Binaries kompilieren (Ahead-of-Time-Compilation). Das Ergebnis startet in Millisekunden statt Sekunden und braucht deutlich weniger Speicher.

# Native Image bauen (mit Spring Boot 3 + GraalVM)
./mvnw -Pnative native:compile

# Ergebnis: Eine eigenständige Binary (~50-80 MB)
./target/mein-service    # Startet in ~50ms statt 2-3 Sekunden

Frameworks wie Quarkus und Micronaut sind explizit dafür optimiert. Spring Boot unterstützt Native Images seit Version 3.0, aber mit Einschränkungen (Reflection-basierte Features funktionieren nicht ohne Konfiguration).

9. IDEs für Java heute¶

Die IntelliJ IDEA Community Edition reicht für die meisten Java-Projekte vollkommen aus. Wer Spring Boot intensiv nutzt, profitiert von der Ultimate Edition (Spring-Support, Datenbank-Tools, HTTP-Client). Es gibt eine 30-Tage-Testversion.

10. Zusammenfassung: Was sich geändert hat¶

Die Top-10-Änderungen seit Java 8¶

1. Records (Java 16) — Immutable Datenklassen in einer Zeile
2. var (Java 10) — Lokale Typinferenz
3. Text Blocks (Java 15) — Mehrzeilige Strings mit """
4. Pattern Matching (Java 16/21) — instanceof ohne Cast, switch mit Typen
5. Sealed Classes (Java 17) — Beschränkte Vererbung
6. Switch Expressions (Java 14) — Switch gibt Werte zurück
7. Virtual Threads (Java 21) — Millionen leichtgewichtiger Threads
8. Modulsystem (Java 9) — Existiert, wird aber oft ignoriert
9. Neue Collection-Methoden — List.of(), .toList(), getFirst()/getLast()
10. HTTP-Client (Java 11) — Endlich ein moderner eingebauter HTTP-Client

Was sich NICHT geändert hat¶

• Java ist immer noch statisch typisiert und objektorientiert
• Die JVM ist immer noch die JVM (HotSpot)
• Maven pom.xml sieht noch genauso aus
• Klassen, Interfaces, Vererbung, Generics — alles wie gehabt
• public static void main(String[] args) funktioniert immer noch
• Das Ökosystem ist riesig und rückwärtskompatibel

Die Kurzversion¶

Empfohlene Distribution: Eclipse Temurin Java 21 (über SDKMAN)
Build-Tool:              Maven (bewährt) oder Gradle (für große Projekte)
Framework:               Spring Boot 3.x
IDE:                     IntelliJ IDEA Community (oder Ultimate für Spring-Support)
GUI:                     JavaFX (falls Desktop benötigt wird)
Testing:                 JUnit 5

Anhang: Lernressourcen¶

• "New language features since Java 8 to 21" — Kompakte Übersicht mit Code-Beispielen https://advancedweb.hu/new-language-features-since-java-8-to-21/
• WhichJDK.com — Welche JDK-Distribution soll ich wählen? https://whichjdk.com/
• Baeldung — Das umfassendste Java-Tutorial-Portal https://www.baeldung.com
• Spring Boot Guides — Offizielle Getting-Started-Guides https://spring.io/guides
• JDK Comparison — Detaillierter Vergleich aller JDK-Distributionen https://jdkcomparison.com/
• SDKMAN — Java-Versionsmanager für Linux/macOS https://sdkman.io