Java 11 (LTS)

Java 11 wurde im September 2018 veröffentlicht und ist eine LTS-Version (Long-Term Support). Es war die erste LTS-Version nach dem neuen sechsmonatigen Release-Zyklus, den Oracle mit Java 9 eingeführt hatte. Viele Unternehmen sind von Java 8 direkt auf Java 11 umgestiegen.

• Einführung des Modul-Systems (Project Jigsaw)
• JShell (interaktive Konsole)
• JLink zur Erstellung modularer Laufzeitumgebungen
• Verbesserungen an Streams und Optional

• var für lokale Variablen (type inference)
• G1 Garbage Collector als Standard
• Application Class-Data Sharing (AppCDS)

• Neues HttpClient API (final)
• Unterstützung für var in Lambda-Parametern
• Entfernen veralteter Module (z.B. JavaFX, WebStart)
• Flight Recorder und Mission Control
• String-Methoden: isBlank(), lines(), strip(), repeat()
• Files.readString() / writeString() Methoden
• Lokale Variable Syntax für Lambda-Parameter (var)

Mit Java 9 wurde das Java Platform Module System (JPMS) eingeführt – eines der größten strukturellen Updates seit der Einführung von Java. Ziel war es, das Java-SE-API selbst in klar getrennte Module zu organisieren und Java-Anwendungen besser strukturierbar, wartbarer und sicherer zu machen.

Ein Modul ist eine benannte, in sich geschlossene Code-Einheit mit klar definierten Abhängigkeiten und Exporten. Es besteht typischerweise aus:

• einem eigenen Namensraum
• explizit deklarierten Abhängigkeiten auf andere Module
• einer Liste öffentlich zugänglicher Pakete
• einer Datei module-info.java

• Kapselung: Nur explizit exportierte Pakete sind von außen sichtbar.
• Klare Abhängigkeiten: Jede Abhängigkeit muss explizit benannt werden.
• Sicherer Betrieb: Ungewollter Zugriff auf interne APIs wird verhindert.
• Bessere Wartbarkeit: Anwendungen sind modularer und leichter zu verstehen.
• Erstellung maßgeschneiderter Laufzeitumgebungen mit jlink.

Dies ist die zentrale Datei eines Moduls. Ein Beispiel:

module com.example.meinmodul {
  requires java.sql;
  exports com.example.api;
}

• module gibt den Namen des Moduls an.
• requires deklariert Abhängigkeiten zu anderen Modulen.
• exports macht bestimmte Pakete für andere Module sichtbar.

Es können auch weitere Schlüsselwörter verwendet werden:

• opens für Reflection-Zugriff (z. B. für Frameworks wie Jackson)
• uses und provides für ServiceLoader-Mechanismen

Das Modulsystem ist vor allem für große Anwendungen, Framework-Entwickler und Bibliotheksautoren von Interesse. Für kleine Anwendungen kann es auch weggelassen werden – die module-info.java ist optional.

Mit Java 9 wurde JShell eingeführt – ein interaktives Tool, das es ermöglicht, Java-Code direkt in der Konsole auszuführen, ohne eine komplette Klasse oder Methode definieren zu müssen. Es ist besonders nützlich zum Experimentieren mit neuen APIs, zum Testen von Snippets oder zum Lehren und Lernen von Java.

• Kein Boilerplate-Code notwendig
• Sofortiges Feedback bei Codeausführung
• Ideal zum Testen kleiner Ausdrucksformen oder API-Features
• Unterstützt Imports, Methoden, Variablen, Klassen usw.

1. Starte JShell im Terminal:

   jshell
   

2. Im JShell-Prompt kannst du direkt loslegen:

   System.out.println("Hallo JShell!");
   

   Ausgabe:

   Hallo JShell!
   

3. Du kannst auch Variablen und Methoden definieren:

   int verdoppeln(int x) { return x * 2; }
   verdoppeln(21)
   

   Ausgabe:

   $2 ==> 42
   

JShell ist standardmäßig im bin-Verzeichnis des JDK enthalten und funktioniert mit jeder Java-Version ab 9.

Mit Java 9 wurde JLink eingeführt – ein Tool, das es ermöglicht, maßgeschneiderte Java-Laufzeitumgebungen zu erstellen, die nur die tatsächlich benötigten Module enthalten.

• Kleinere Distributionsgröße (nur benötigte Module)
• Schnellere Startzeit
• Bessere Kontrolle über die enthaltene Laufzeitumgebung

• Die Anwendung muss modularisiert sein (also eine module-info.java besitzen).
• Nur Module aus dem eigenen Code und dem JDK können eingebunden werden (keine automatischen Module aus JARs ohne Modulbeschreibung).

jlink \
  --module-path $JAVA_HOME/jmods:mods \
  --add-modules com.example.meinmodul \
  --output meine-runtime

Dies erstellt eine lauffähige Java-Umgebung im Ordner meine-runtime, die nur das Modul com.example.meinmodul und dessen Abhängigkeiten enthält.

JLink eignet sich hervorragend für Embedded-Systeme, Docker-Container oder jede Anwendung, bei der Größe und Startzeit eine Rolle spielen.

Application Class-Data Sharing (AppCDS) wurde in Java 10 verbessert und in Java 11 weiter vereinfacht. Die Technik dient dazu, die Startzeit von Java-Anwendungen zu verkürzen und den Speicherverbrauch zu reduzieren, indem häufig genutzte Klassendaten in einem gemeinsamen Archiv vorgeladen werden.

• Schnellere Startzeiten
• Geringerer Speicherbedarf bei mehreren JVM-Prozessen
• Kann auch für eigene Anwendungen genutzt werden (nicht nur das JDK selbst)

Beim ersten Lauf wird ein sogenanntes Klassendaten-Archiv (CDS-Archiv) erstellt. Dieses enthält Metadaten über geladene Klassen. Beim nächsten Start kann die JVM diese Daten direkt aus dem Archiv laden – ohne erneute Initialisierung.

1. JAR-Datei ausführen und Klassenliste erzeugen:

java -Xshare:off -XX:DumpLoadedClassList=classes.lst -jar meine-app.jar

2. CDS-Archiv erzeugen:

java -Xshare:dump -XX:SharedClassListFile=classes.lst \
     -XX:SharedArchiveFile=app-cds.jsa \
     -cp meine-app.jar

3. Anwendung mit CDS starten:

java -Xshare:on -XX:SharedArchiveFile=app-cds.jsa -jar meine-app.jar

Hinweis: Die Klassenpfade und VM-Optionen müssen bei Dump und Nutzung exakt übereinstimmen.

AppCDS ist besonders hilfreich in Container-Umgebungen oder bei wiederholt gestarteten Microservices.

Mit Java 11 wurde der neue HttpClient als offizielle API eingeführt. Bereits in Java 9 als Preview eingeführt, ersetzt er nun dauerhaft die veraltete HttpURLConnection.

• Moderne, einfache API für HTTP 1.1 und HTTP/2
• Unterstützung für synchronen und asynchronen Zugriff (über CompletableFuture)
• Unterstützung für WebSockets
• Besser lesbare und wartbare Syntax

HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("https://api.example.com"))
    .build();

HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

client.sendAsync(request, HttpResponse.BodyHandlers.ofString())
    .thenApply(HttpResponse::body)
    .thenAccept(System.out::println);

Der neue HttpClient ist Teil des Pakets java.net.http und bietet eine moderne Alternative für REST-Aufrufe und Netzwerkkommunikation in Java-Projekten.

Mit Java 11 wurden mehrere Module entfernt, die in früheren Versionen (ab Java 9) bereits als “deprecated for removal” markiert waren. Ziel war es, die Java-Plattform zu verschlanken und Altlasten zu beseitigen.

Diese Module waren ursprünglich Teil des Java-EE-Stacks, der nun eigenständig und außerhalb des JDK weiterentwickelt wird (z. B. unter Jakarta EE).

• Anwendungen, die diese APIs benötigen, müssen externe Bibliotheken einbinden.
• Maven/Gradle-Dependency-Management ist dafür der empfohlene Weg.
• Alternativ kann eine ältere JDK-Version oder ein vollständig eigenständiger Stack verwendet werden.

Durch das Entfernen dieser Module wird das JDK schlanker und sicherer – insbesondere für Cloud- und Container-Umgebungen.

Java 11 hat mehrere nützliche Methoden zur String-Klasse hinzugefügt, die die tägliche Arbeit mit Zeichenketten erleichtern:

Prüft, ob der String leer ist oder nur aus Leerzeichen besteht.

System.out.println("  ".isBlank()); // true

Gibt einen Stream der Zeilen des Strings zurück (bei \n getrennt).

String mehrzeilig = "Zeile 1\nZeile 2\nZeile 3";
mehrzeilig.lines().forEach(System.out::println);

Entfernen Leerzeichen (Unicode-aware) vom Anfang und/oder Ende eines Strings. Im Gegensatz zu trim() arbeiten diese Methoden korrekt mit Unicode-Whitespace.

System.out.println("  Text  ".strip());        // "Text"
System.out.println("  Text  ".stripLeading()); // "Text  "
System.out.println("  Text  ".stripTrailing()); // "  Text"

Wiederholt den String mehrfach.

System.out.println("abc".repeat(3)); // "abcabcabc"

Diese Erweiterungen machen viele typische String-Operationen klarer und effizienter.