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.
Was du am Ende kannst
Abschnitt betitelt „Was du am Ende kannst“- eine anonyme Klasse Schritt für Schritt in ein Lambda umschreiben
- erklären, was ein funktionales Interface ist
- Methodenreferenzen wie
String::lengthlesen 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 herunterladenDer 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
Sortieren nach eigenen Regeln
Abschnitt betitelt „Sortieren nach eigenen Regeln“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:
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); }
}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]Von der anonymen Klasse zum Lambda
Abschnitt betitelt „Von der anonymen Klasse zum Lambda“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>()–sorterwartet einenComparator. Etwas anderes kann hier gar nicht stehen.public int compare–Comparatorhat 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
returnund das Semikolon weg.
woerter.sort((a, b) -> Integer.compare(a.length(), b.length()));Ein einzelner Parameter braucht nicht einmal Klammern: wort -> wort.length().
Funktionale Interfaces
Abschnitt betitelt „Funktionale Interfaces“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.
Comparatorhat eine abstrakte Methode,compare. Seine vielen anderen Methoden (reversed,thenComparing…) sind default- oder static-Methoden – die zählen nicht.Iteratorhat zwei,hasNextundnext. Deshalb mussten wir ihn im letzten Kapitel als Klasse schreiben – als Lambda geht er nicht.Iterablehat wieder nur eine,iterator(). Unserrueckwaerts()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.
Comparator.comparing und Methodenreferenzen
Abschnitt betitelt „Comparator.comparing und Methodenreferenzen“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.
Lambdas, die das JDK erwartet
Abschnitt betitelt „Lambdas, die das JDK erwartet“Seit Java 8 haben viele Klassen des JDK Methoden, die ein Lambda nehmen. Die
passenden funktionalen Interfaces stehen im Package java.util.function:
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); }
}Kiwi Apfel Feige Banane Ei BirneKiwiApfelFeigeBananeEiBirneab 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 |
forEachist eine default-Methode vonIterable– sie funktioniert also auch mit unseremDynamischesArrayaus dem letzten Kapitel.map.merge(schluessel, 1, Integer::sum)ist die kurze Form des Zählens: Gibt es den Schlüssel noch nicht, wird1eingetragen – sonst werden alter Wert und1mitInteger::sumzusammengezählt. Vergleiche mitgetOrDefaultim 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.
Lokale Variablen im Lambda
Abschnitt betitelt „Lokale Variablen im Lambda“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); }
}ab 6: [8, 12, 20, 7]Summe: 47Ein 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.
Runnable: Code für später
Abschnitt betitelt „Runnable: Code für später“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"); }
}Hallo aus einem RunnableHallo aus Nebenläufer Summe 499999500000eine Million Additionen: 2 ms(Die Millisekunden schwanken von Lauf zu Lauf.)
- Ein
Runnableist ein Stück Code ohne Parameter und ohne Ergebnis. Es läuft erst, wenn jemandrun()aufruft. - Ein
Threadnimmt einRunnableund führt es nebenher aus. Wie das genau geht und welche Probleme es mit sich bringt, ist das Thema des nächsten Kapitels. messeist eine eigene Methode, die Code als Parameter nimmt. Sie weiß nicht, was sie misst – nur, dass es sich ausführen lässt. Genau so sindsort,forEachundremoveIfgebaut.
Übung: Sortieren, auswählen, messen
Abschnitt betitelt „Übung: Sortieren, auswählen, messen“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.
-
Die häufigsten Wörter: Zähle die Wörter in
Texte.JAVAmitmergeund gib die zehn häufigsten aus – bei gleicher Anzahl alphabetisch. Das war die offene Frage aus der Textstatistik. Tipp: EineMaplässt sich nicht sortieren, eine Liste ihrer Einträge schon:new ArrayList<>(anzahl.entrySet()).Terminal-Fenster 1. die 82. und 83. eine 54. für 45. plattform 4 -
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.comparingmit Methodenreferenzen wieLauf::zeit. Vorsicht:Ergebnisse.alle()liefert eine Liste ausList.of– was passiert, wenn du sie direkt sortierst? -
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. -
Für Schnelle: Im Collection-Kapitel hieß es,
get(i)sei bei einerLinkedListlangsam. Miss es mit der MethodemesseausAufgaben: Fülle eineArrayListund eineLinkedListmit je 50 000 Zahlen und summiere sie mit einer Schleife überget(i). Und zum Vergleich dieLinkedListmit 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.
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
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 eineUnsupportedOperationException–List.ofist unveränderlich. Deshalb erst eine Kopie mitnew ArrayList<>(…). - Ben und Hasan sind gleich schnell.
thenComparing(Lauf::startnummer)setzt die 4 vor die 28. auswahlweiß nichts über Zeiten, Vereine oder Startnummern – es ruft nurbedingung.test(lauf)auf. Was geprüft wird, entscheidet der Aufrufer mit seinem Lambda.
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
Summe 1249975000ArrayList get(i): 3 ms Summe 1249975000LinkedList get(i): 1206 ms Summe 1249975000LinkedList for-each: 2 msBei 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.
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"); }
}