Zum Inhalt springen

Lambdas

Im letzten Kapitel haben wir anonyme Klassen geschrieben: Eine Klasse und ihr Objekt entstehen in einem Ausdruck, genau dort, wo sie gebraucht werden. Bei Interfaces mit einer Methode geht das noch kürzer – mit einem Lambda.

  • eine anonyme Klasse Schritt für Schritt in ein Lambda umschreiben
  • erklären, was ein funktionales Interface ist
  • Methodenreferenzen wie String::length lesen und schreiben
  • Methoden des JDK benutzen, die ein Lambda erwarten: sort, forEach, removeIf, replaceAll, merge
  • eine eigene Methode schreiben, die ein Lambda als Parameter nimmt

Demo-Code: 27-lambdas

⤓ demo-lambdas.zip herunterladen

Der fertige Stand aus der Vorführung – zum Nachlesen, Ausprobieren und Weiterbauen.

Entpacke die ZIP-Datei nach C:\dev\intellij. In IntelliJ: File → Open… → den Ordner 27-lambdas wählen → OK → Trust Project. IntelliJ erkennt die pom.xml und lädt die Bibliotheken selbst herunter – das dauert beim ersten Mal einen Moment.

Enthält: pom.xml, Sortieren.java, Funktionen.java, Erfassen.java, Aufgaben.java, Texte.java, Lauf.java, Ergebnisse.java

Collections.sort und list.sort(null) sortieren in der natürlichen Ordnung – bei Texten alphabetisch, weil String das Interface Comparable implementiert. Für jede andere Ordnung gibt man sort einen Comparator mit: ein Objekt mit einer einzigen Methode compare(a, b). Sie liefert eine negative Zahl, wenn a vor b gehört, eine positive, wenn danach, und 0, wenn beide gleich sind.

Nach der Länge sortieren – fünfmal dieselbe Sortierung, jedes Mal kürzer geschrieben:

Sortieren.java
package de.drv.lambdas;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
/** Vom Comparator als Klasse bis zum Lambda – fünfmal dieselbe Sortierung. */
public class Sortieren {
/** 1. Eine Klasse, die Comparator implementiert – hier als statische geschachtelte Klasse. */
static class NachLaenge implements Comparator<String> {
@Override
public int compare(String a, String b) {
return Integer.compare(a.length(), b.length());
}
}
/** Jedes Mal dieselbe unsortierte Liste – damit die Ergebnisse vergleichbar sind. */
static List<String> woerter() {
return new ArrayList<>(List.of("Kiwi", "Apfel", "Feige", "Banane", "Ei", "Birne"));
}
public static void main(String[] args) {
List<String> woerter = woerter();
woerter.sort(null); // null heißt: natürliche Ordnung – für String alphabetisch
System.out.println("alphabetisch: " + woerter);
woerter = woerter();
// 1. eigene Klasse
woerter.sort(new NachLaenge());
System.out.println("Klasse: " + woerter);
woerter = woerter();
// 2. anonyme Klasse
woerter.sort(new Comparator<String>() {
@Override
public int compare(String a, String b) {
return Integer.compare(a.length(), b.length());
}
});
System.out.println("anonym: " + woerter);
woerter = woerter();
// 3. Lambda – ausführlich
woerter.sort((String a, String b) -> {
return Integer.compare(a.length(), b.length());
});
System.out.println("Lambda lang: " + woerter);
woerter = woerter();
// 4. Lambda – kurz
woerter.sort((a, b) -> Integer.compare(a.length(), b.length()));
System.out.println("Lambda kurz: " + woerter);
woerter = woerter();
// 5. Comparator.comparing mit einer Methodenreferenz
woerter.sort(Comparator.comparing(String::length));
System.out.println("comparing: " + woerter);
woerter = woerter();
// Mehr Regeln: erst nach Länge, bei gleicher Länge alphabetisch – und das Ganze umgedreht
woerter.sort(Comparator.comparing(String::length).thenComparing(Comparator.naturalOrder()));
System.out.println("Länge, ABC: " + woerter);
woerter = woerter();
woerter.sort(Comparator.comparing(String::length).reversed());
System.out.println("längste vorn: " + woerter);
}
}
Terminal-Fenster
alphabetisch: [Apfel, Banane, Birne, Ei, Feige, Kiwi]
Klasse: [Ei, Kiwi, Apfel, Feige, Birne, Banane]
anonym: [Ei, Kiwi, Apfel, Feige, Birne, Banane]
Lambda lang: [Ei, Kiwi, Apfel, Feige, Birne, Banane]
Lambda kurz: [Ei, Kiwi, Apfel, Feige, Birne, Banane]
comparing: [Ei, Kiwi, Apfel, Feige, Birne, Banane]
Länge, ABC: [Ei, Kiwi, Apfel, Birne, Feige, Banane]
längste vorn: [Banane, Apfel, Feige, Birne, Kiwi, Ei]

Schau dir die anonyme Klasse an und frage: Was davon weiß der Compiler ohnehin?

woerter.sort(new Comparator<String>() {
@Override
public int compare(String a, String b) {
return Integer.compare(a.length(), b.length());
}
});
  • new Comparator<String>() – sort erwartet einen Comparator. Etwas anderes kann hier gar nicht stehen.
  • public int compare – Comparator hat genau eine abstrakte Methode. Welche wir meinen, ist also klar.
  • Übrig bleiben die Parameter und der Rumpf. Dazwischen kommt ein Pfeil:
woerter.sort((String a, String b) -> {
return Integer.compare(a.length(), b.length());
});

Das ist ein Lambda: Parameter, Pfeil, Rumpf. Und es geht noch kürzer:

  • Die Typen der Parameter kennt der Compiler auch – String, weil die Liste aus Strings besteht. Weg damit.
  • Besteht der Rumpf aus einem einzigen Ausdruck, fallen die geschweiften Klammern, das return und das Semikolon weg.
woerter.sort((a, b) -> Integer.compare(a.length(), b.length()));

Ein einzelner Parameter braucht nicht einmal Klammern: wort -> wort.length().

Ein Lambda geht nur dort, wo ein Interface mit genau einer abstrakten Methode erwartet wird – ein funktionales Interface. Daher weiß der Compiler, welche Methode das Lambda implementiert.

  • Comparator hat eine abstrakte Methode, compare. Seine vielen anderen Methoden (reversed, thenComparing …) sind default- oder static-Methoden – die zählen nicht.
  • Iterator hat zwei, hasNext und next. Deshalb mussten wir ihn im letzten Kapitel als Klasse schreiben – als Lambda geht er nicht.
  • Iterable hat wieder nur eine, iterator(). Unser rueckwaerts() aus der letzten Übung hätte also mit einem Lambda beginnen können: return () -> new Iterator<>() { … };

Viele funktionale Interfaces tragen die Annotation @FunctionalInterface. Sie ist nicht nötig, aber der Compiler meldet dann einen Fehler, wenn jemand eine zweite abstrakte Methode hinzufügt.

Fast immer vergleicht ein Comparator zwei Objekte anhand einer Eigenschaft: der Länge, des Namens, der Zeit. Dafür gibt es eine Abkürzung:

woerter.sort(Comparator.comparing(String::length));

Comparator.comparing bekommt gesagt, was verglichen wird, und baut daraus den Comparator. String::length ist eine Methodenreferenz: „die Methode length von String“. Sie bedeutet dasselbe wie das Lambda wort -> wort.length().

Methodenreferenz bedeutet dasselbe wie
String::length wort -> wort.length()
String::toUpperCase wort -> wort.toUpperCase()
System.out::println x -> System.out.println(x)
Integer::sum (a, b) -> Integer.sum(a, b)

thenComparing hängt eine zweite Regel an, für alles, was nach der ersten gleich ist. reversed() dreht die Ordnung um. Die Zeile „Länge, ABC“ zeigt den Unterschied: Birne und Feige sind gleich lang – ohne zweite Regel bleiben sie in der ursprünglichen Reihenfolge, mit ihr stehen sie alphabetisch.

Seit Java 8 haben viele Klassen des JDK Methoden, die ein Lambda nehmen. Die passenden funktionalen Interfaces stehen im Package java.util.function:

Funktionen.java
package de.drv.lambdas;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;
import java.util.function.Function;
import java.util.function.Predicate;
/** Lambdas und Methodenreferenzen an Methoden, die das JDK schon mitbringt. */
public class Funktionen {
public static void main(String[] args) {
List<String> woerter = new ArrayList<>(List.of("Kiwi", "Apfel", "Feige", "Banane", "Ei", "Birne"));
// Consumer: etwas mit jedem Element tun – forEach ist eine default-Methode von Iterable
woerter.forEach(wort -> System.out.print(wort + " "));
System.out.println();
woerter.forEach(System.out::println); // Methodenreferenz: println für jedes Element
// Predicate: eine Bedingung – removeIf entfernt alles, wofür sie wahr ist
woerter.removeIf(wort -> wort.length() < 5);
System.out.println("ab 5 Zeichen: " + woerter);
// Function: aus einem Wert einen anderen machen – replaceAll ersetzt jedes Element
woerter.replaceAll(String::toUpperCase);
System.out.println("groß: " + woerter);
// Lambdas lassen sich in Variablen speichern – ihr Typ ist ein funktionales Interface
Predicate<String> mitE = wort -> wort.contains("E");
Function<String, Integer> laenge = String::length;
System.out.println("BIRNE mit E? " + mitE.test("BIRNE") + ", Länge " + laenge.apply("BIRNE"));
// Zählen mit merge: Gibt es den Schlüssel noch nicht, nimm 1 – sonst alter Wert + 1
Map<Character, Integer> anzahl = new TreeMap<>();
for (char zeichen : "MISSISSIPPI".toCharArray()) {
anzahl.merge(zeichen, 1, Integer::sum);
}
System.out.println(anzahl);
}
}
Terminal-Fenster
Kiwi Apfel Feige Banane Ei Birne
Kiwi
Apfel
Feige
Banane
Ei
Birne
ab 5 Zeichen: [Apfel, Feige, Banane, Birne]
groß: [APFEL, FEIGE, BANANE, BIRNE]
BIRNE mit E? true, Länge 5
{I=4, M=1, P=2, S=4}
Interface Methode nimmt → liefert Beispiel
Consumer<T> accept ein T → nichts forEach(wort -> …)
Predicate<T> test ein T → boolean removeIf(wort -> wort.length() < 5)
Function<T, R> apply ein T → ein R replaceAll(String::toUpperCase)
Supplier<T> get nichts → ein T Werte auf Anfrage erzeugen
Runnable run nichts → nichts Code, der später läuft
  • forEach ist eine default-Methode von Iterable – sie funktioniert also auch mit unserem DynamischesArray aus dem letzten Kapitel.
  • map.merge(schluessel, 1, Integer::sum) ist die kurze Form des Zählens: Gibt es den Schlüssel noch nicht, wird 1 eingetragen – sonst werden alter Wert und 1 mit Integer::sum zusammengezählt. Vergleiche mit getOrDefault im Collection-Kapitel.
  • Ein Lambda lässt sich auch in einer Variablen speichern. Ihr Typ ist ein funktionales Interface – aufgerufen wird es über dessen Methode: test, apply, run.
Erfassen.java
package de.drv.lambdas;
import java.util.ArrayList;
import java.util.List;
/** Ein Lambda darf lokale Variablen benutzen – aber nur, wenn sie sich nicht ändern. */
public class Erfassen {
public static void main(String[] args) {
List<Integer> zahlen = new ArrayList<>(List.of(3, 8, 12, 5, 20, 7));
int grenze = 6; // wird nie geändert: "effectively final"
zahlen.removeIf(zahl -> zahl < grenze);
System.out.println("ab " + grenze + ": " + zahlen);
// int summe = 0;
// zahlen.forEach(zahl -> summe += zahl); – lässt sich nicht übersetzen:
// summe wird geändert und ist deshalb nicht effectively final
int summe = 0;
for (int zahl : zahlen) { // für so etwas ist die Schleife das richtige Werkzeug
summe += zahl;
}
System.out.println("Summe: " + summe);
}
}
Terminal-Fenster
ab 6: [8, 12, 20, 7]
Summe: 47

Ein Lambda darf lokale Variablen der umgebenden Methode benutzen – wie grenze. Aber nur, wenn sie sich nie ändern: Sie müssen effectively final sein. Nimm die Kommentarzeichen vor summe += zahl weg, und IntelliJ meldet: Variable used in lambda expression should be final or effectively final.

Der Grund: Ein Lambda kann später laufen als die Methode, in der es steht – zum Beispiel in einem anderen Thread. Deshalb bekommt es eine Kopie des Werts, und eine Kopie, die sich ändern ließe, wäre eine Falle. Dieselbe Regel gilt übrigens auch für anonyme Klassen. Wer etwas aufsummieren will, nimmt eine Schleife – nicht jedes Problem braucht ein Lambda.

Aufgaben.java
package de.drv.lambdas;
/** Runnable: ein Stück Code ohne Parameter und ohne Ergebnis – zum Ausführen jetzt oder später. */
public class Aufgaben {
public static void main(String[] args) throws InterruptedException {
Runnable gruss = () -> System.out.println("Hallo aus einem Runnable");
gruss.run(); // jetzt, im selben Ablauf
// Ein Thread führt ein Runnable nebenher aus – mehr dazu im Kapitel Parallelität
Thread nebenher = new Thread(() -> System.out.println("Hallo aus " + Thread.currentThread().getName()));
nebenher.setName("Nebenläufer");
nebenher.start();
nebenher.join(); // warten, bis er fertig ist
// Eine Methode, die Code als Parameter nimmt
messe("eine Million Additionen", () -> {
long summe = 0;
for (int i = 0; i < 1_000_000; i++) {
summe += i;
}
System.out.println(" Summe " + summe);
});
}
/** Führt eine Aufgabe aus und sagt, wie lange sie gedauert hat. */
static void messe(String name, Runnable aufgabe) {
long start = System.nanoTime();
aufgabe.run();
long millis = (System.nanoTime() - start) / 1_000_000;
System.out.println(name + ": " + millis + " ms");
}
}
Terminal-Fenster
Hallo aus einem Runnable
Hallo aus Nebenläufer
Summe 499999500000
eine Million Additionen: 2 ms

(Die Millisekunden schwanken von Lauf zu Lauf.)

  • Ein Runnable ist ein Stück Code ohne Parameter und ohne Ergebnis. Es läuft erst, wenn jemand run() aufruft.
  • Ein Thread nimmt ein Runnable und führt es nebenher aus. Wie das genau geht und welche Probleme es mit sich bringt, ist das Thema des nächsten Kapitels.
  • messe ist eine eigene Methode, die Code als Parameter nimmt. Sie weiß nicht, was sie misst – nur, dass es sich ausführen lässt. Genau so sind sort, forEach und removeIf gebaut.

Im Demo-Projekt liegen die Klasse Texte aus dem Collection-Kapitel und die Ergebnisse eines Stadtlaufs: ein Record Lauf mit Startnummer, Name, Verein und Zeit, und Ergebnisse.alle() mit zehn Läufen.

  1. Die häufigsten Wörter: Zähle die Wörter in Texte.JAVA mit merge und gib die zehn häufigsten aus – bei gleicher Anzahl alphabetisch. Das war die offene Frage aus der Textstatistik. Tipp: Eine Map lässt sich nicht sortieren, eine Liste ihrer Einträge schon: new ArrayList<>(anzahl.entrySet()).

    Terminal-Fenster
    1. die 8
    2. und 8
    3. eine 5
    4. für 4
    5. plattform 4
  2. Ranglisten: Gib die Läufe aus

    • als Gesamtwertung nach Zeit – bei gleicher Zeit die kleinere Startnummer zuerst,
    • nach Verein und innerhalb eines Vereins nach Zeit – ohne die Läufer ohne Verein. Nimm dafür removeIf.

    Verwende Comparator.comparing mit Methodenreferenzen wie Lauf::zeit. Vorsicht: Ergebnisse.alle() liefert eine Liste aus List.of – was passiert, wenn du sie direkt sortierst?

  3. Eine eigene Methode mit Lambda: Schreibe auswahl(List<Lauf> laeufe, Predicate<Lauf> bedingung). Sie liefert eine neue Liste mit allen Läufen, für die die Bedingung gilt. Benutze sie für: alle unter 45 Minuten, alle vom TV Lindental, alle mit gerader Startnummer.

  4. Für Schnelle: Im Collection-Kapitel hieß es, get(i) sei bei einer LinkedList langsam. Miss es mit der Methode messe aus Aufgaben: Fülle eine ArrayList und eine LinkedList mit je 50 000 Zahlen und summiere sie mit einer Schleife über get(i). Und zum Vergleich die LinkedList mit for-each.

Lösung

Der Comparator hat zwei Regeln. Für die erste vergleicht er b mit a – andersherum als sonst – und sortiert damit absteigend. Nur wenn beide gleich oft vorkommen, entscheidet das Wort.

Mit Comparator-Methoden ginge es auch ohne geschweifte Klammern – allerdings muss man Java dann beim Typ helfen, und die Zeile wird schwer zu lesen. Das ausgeschriebene Lambda ist hier die klarere Wahl.

Haeufigkeit.java
package de.drv.lambdas;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/** Stufe 1: die zehn häufigsten Wörter – bei gleicher Anzahl alphabetisch. */
public class Haeufigkeit {
public static void main(String[] args) {
Map<String, Integer> anzahl = new HashMap<>();
for (String wort : Texte.JAVA.toLowerCase().split("[^a-zäöüß]+")) {
if (!wort.isEmpty()) {
anzahl.merge(wort, 1, Integer::sum);
}
}
// Eine Map lässt sich nicht sortieren – ihre Einträge in einer Liste schon
List<Map.Entry<String, Integer>> eintraege = new ArrayList<>(anzahl.entrySet());
eintraege.sort((a, b) -> {
int vergleich = Integer.compare(b.getValue(), a.getValue()); // b vor a: absteigend
if (vergleich != 0) {
return vergleich;
}
return a.getKey().compareTo(b.getKey());
});
for (int i = 0; i < Math.min(10, eintraege.size()); i++) {
Map.Entry<String, Integer> eintrag = eintraege.get(i);
System.out.printf("%2d. %-12s %d%n", i + 1, eintrag.getKey(), eintrag.getValue());
}
}
}
Lösung
Terminal-Fenster
Gesamtwertung
1. 2 Jonas Jung LG Nordstadt 0:38:09
2. 9 David Demir 0:39:47
3. 4 Ben Beispiel LG Nordstadt 0:41:55
4. 28 Hasan Hofmann TV Lindental 0:41:55
5. 6 Greta Graf SV Grünau 0:44:02
…
  • Wer Ergebnisse.alle() direkt sortiert, bekommt eine UnsupportedOperationException – List.of ist unveränderlich. Deshalb erst eine Kopie mit new ArrayList<>(…).
  • Ben und Hasan sind gleich schnell. thenComparing(Lauf::startnummer) setzt die 4 vor die 28.
  • auswahl weiß nichts über Zeiten, Vereine oder Startnummern – es ruft nur bedingung.test(lauf) auf. Was geprüft wird, entscheidet der Aufrufer mit seinem Lambda.
Rangliste.java
package de.drv.lambdas;
import java.time.Duration;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.function.Predicate;
/** Stufen 2 und 3: Ranglisten und Auswahlen aus den Ergebnissen des Stadtlaufs. */
public class Rangliste {
public static void main(String[] args) {
// Stufe 2: List.of ist unveränderlich – zum Sortieren eine Kopie
List<Lauf> laeufe = new ArrayList<>(Ergebnisse.alle());
laeufe.sort(Comparator.comparing(Lauf::zeit).thenComparing(Lauf::startnummer));
zeige("Gesamtwertung", laeufe);
laeufe.removeIf(lauf -> lauf.verein().isEmpty());
laeufe.sort(Comparator.comparing(Lauf::verein).thenComparing(Lauf::zeit));
zeige("Nach Verein", laeufe);
// Stufe 3: eine eigene Methode, die eine Bedingung als Parameter nimmt
List<Lauf> alle = Ergebnisse.alle();
zeige("Unter 45 Minuten", auswahl(alle, lauf -> lauf.zeit().compareTo(Duration.ofMinutes(45)) < 0));
zeige("TV Lindental", auswahl(alle, lauf -> lauf.verein().equals("TV Lindental")));
zeige("Gerade Startnummern", auswahl(alle, lauf -> lauf.startnummer() % 2 == 0));
}
/** Alle Läufe, für die die Bedingung gilt – in der ursprünglichen Reihenfolge. */
static List<Lauf> auswahl(List<Lauf> laeufe, Predicate<Lauf> bedingung) {
List<Lauf> treffer = new ArrayList<>();
for (Lauf lauf : laeufe) {
if (bedingung.test(lauf)) {
treffer.add(lauf);
}
}
return treffer;
}
private static void zeige(String titel, List<Lauf> laeufe) {
System.out.println(titel);
for (int i = 0; i < laeufe.size(); i++) {
System.out.printf("%3d. %s%n", i + 1, laeufe.get(i));
}
System.out.println();
}
}
Lösung
Terminal-Fenster
Summe 1249975000
ArrayList get(i): 3 ms
Summe 1249975000
LinkedList get(i): 1206 ms
Summe 1249975000
LinkedList for-each: 2 ms

Bei der LinkedList muss jedes get(i) vom Anfang (oder Ende) der Kette aus zählen – bei 50 000 Elementen sind das insgesamt über eine halbe Milliarde Schritte. Der Iterator dagegen merkt sich, wo er steht, und geht nur einen Schritt weiter. Deshalb ist for-each bei der LinkedList genauso schnell wie bei der ArrayList.

Messung.java
package de.drv.lambdas;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
/** Stufe 4: Wie lange dauert get(i) bei ArrayList und LinkedList? */
public class Messung {
public static void main(String[] args) {
List<Integer> array = new ArrayList<>();
List<Integer> verkettet = new LinkedList<>();
for (int i = 0; i < 50_000; i++) {
array.add(i);
verkettet.add(i);
}
messe("ArrayList get(i)", () -> summiere(array));
messe("LinkedList get(i)", () -> summiere(verkettet));
messe("LinkedList for-each", () -> {
long summe = 0;
for (int zahl : verkettet) {
summe += zahl;
}
System.out.println(" Summe " + summe);
});
}
private static void summiere(List<Integer> zahlen) {
long summe = 0;
for (int i = 0; i < zahlen.size(); i++) {
summe += zahlen.get(i);
}
System.out.println(" Summe " + summe);
}
static void messe(String name, Runnable aufgabe) {
long start = System.nanoTime();
aufgabe.run();
long millis = (System.nanoTime() - start) / 1_000_000;
System.out.println(name + ": " + millis + " ms");
}
}