Streams
Viele Schleifen stellen eine Frage an eine Sammlung: Wer war unter 45 Minuten? Wie viele Wörter kommen vor? Was ist der Durchschnitt? Ein Stream beantwortet solche Fragen als Kette von Schritten – und jeder Schritt bekommt ein Lambda, wie wir sie im letzten Kapitel geschrieben haben.
Was du am Ende kannst
Abschnitt betitelt „Was du am Ende kannst“- eine Schleife in eine Stream-Pipeline umschreiben – und entscheiden, wann die Schleife besser bleibt
- die wichtigsten Schritte benutzen:
filter,map,sorted,distinct,limit - Ergebnisse einsammeln:
toList,count,joining,groupingBy - mit
Optionalumgehen, wenn ein Stream vielleicht nichts findet - eine Datei mit
Files.linesals Stream lesen
Demo-Code: 28-streams
⤓ demo-streams.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 28-streams 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, ErsterStream.java, Bausteine.java, Optionale.java, Zahlen.java, Gruppieren.java, DateiStream.java, Parallel.java, Lauf.java, Ergebnisse.java, Texte.java, messwerte.csv, ausgaben.csv
Im Demo-Projekt liegen bekannte Daten: der Stadtlauf aus dem Kapitel Lambdas, der Text der Textstatistik und die beiden CSV-Dateien aus dem Kapitel Ströme und Ressourcen.
Von der Schleife zum Stream
Abschnitt betitelt „Von der Schleife zum Stream“package de.drv.streams;
import java.time.Duration;import java.util.ArrayList;import java.util.List;
/** Dieselbe Frage zweimal beantwortet: mit einer Schleife und mit einem Stream. */public class ErsterStream {
public static void main(String[] args) { List<Lauf> laeufe = Ergebnisse.alle(); Duration grenze = Duration.ofMinutes(45);
// Mit einer Schleife: Wer war unter 45 Minuten? Die Namen, alphabetisch. List<String> namen = new ArrayList<>(); for (Lauf lauf : laeufe) { if (lauf.zeit().compareTo(grenze) < 0) { namen.add(lauf.name()); } } namen.sort(null); System.out.println("Schleife: " + namen);
// Mit einem Stream: Quelle → Zwischenschritte → Abschluss List<String> auchNamen = laeufe.stream() // Quelle .filter(lauf -> lauf.zeit().compareTo(grenze) < 0) // nur, was passt .map(Lauf::name) // aus jedem Lauf sein Name .sorted() // sortieren .toList(); // Abschluss: eine Liste System.out.println("Stream: " + auchNamen);
// Die Quelle bleibt, wie sie war System.out.println(laeufe.size() + " Läufe in der Quelle"); }
}Schleife: [Ben Beispiel, David Demir, Greta Graf, Hasan Hofmann, Jonas Jung]Stream: [Ben Beispiel, David Demir, Greta Graf, Hasan Hofmann, Jonas Jung]10 Läufe in der QuelleJeder Stream besteht aus drei Teilen:
- Eine Quelle:
liste.stream()– oder ein Array mitArrays.stream(…), eine Datei mitFiles.lines(…), ein Zahlenbereich mitIntStream.range(…). - Zwischenschritte, beliebig viele: Jeder nimmt einen Stream und liefert
einen neuen.
filterlässt durch, was die Bedingung erfüllt.mapmacht aus jedem Element etwas anderes – hier aus jedemLaufseinen Namen. - Ein Abschluss: Er sammelt das Ergebnis ein – hier mit
toList()in eine Liste. Erst der Abschluss setzt die Kette in Gang.
Drei Dinge unterscheiden einen Stream von einer Sammlung:
- Ein Stream speichert nichts. Er ist eine Rechenvorschrift, durch die die Elemente der Quelle fließen.
- Er ändert die Quelle nicht. Die Liste hat danach noch alle zehn Läufe.
- Er lässt sich nur einmal benutzen. Nach dem Abschluss ist er verbraucht –
für die nächste Frage holt man mit
stream()einen neuen.
Die wichtigsten Bausteine
Abschnitt betitelt „Die wichtigsten Bausteine“package de.drv.streams;
import java.util.Arrays;import java.util.Comparator;import java.util.List;import java.util.stream.Collectors;
/** Die wichtigsten Zwischenschritte und Abschlüsse. */public class Bausteine {
public static void main(String[] args) { List<String> woerter = Arrays.asList(Texte.JAVA.toLowerCase().split("[^a-zäöüß]+"));
// Zwischenschritte: filter, map, distinct, sorted, limit List<String> lange = woerter.stream() .filter(wort -> wort.length() > 8) .distinct() .sorted(Comparator.comparing(String::length).reversed()) .limit(5) .toList(); System.out.println("die längsten: " + lange);
List<Integer> laengen = woerter.stream() .filter(wort -> !wort.isEmpty()) .map(String::length) .limit(8) .toList(); System.out.println("Längen der ersten acht: " + laengen);
// Abschlüsse: count, anyMatch, allMatch, joining long mitJava = woerter.stream().filter(wort -> wort.equals("java")).count(); System.out.println("\"java\" kommt " + mitJava + "-mal vor");
boolean umlaut = woerter.stream().anyMatch(wort -> wort.contains("ü")); boolean klein = woerter.stream().allMatch(wort -> wort.equals(wort.toLowerCase())); System.out.println("mit ü? " + umlaut + ", alles klein? " + klein);
String vereine = Ergebnisse.alle().stream() .map(Lauf::verein) .filter(verein -> !verein.isEmpty()) .distinct() .sorted() .collect(Collectors.joining(", ", "Vereine: ", ".")); System.out.println(vereine); }
}die längsten: [programmiersprache, reihenfolge, bibliothek, sammlungen, plattform]Längen der ersten acht: [4, 3, 4, 18, 3, 4, 3, 4]"java" kommt 3-mal vormit ü? true, alles klein? trueVereine: LG Nordstadt, SV Grünau, TV Lindental.| Zwischenschritt | macht | bekommt |
|---|---|---|
filter(…) |
lässt nur durch, was die Bedingung erfüllt | ein Predicate |
map(…) |
macht aus jedem Element ein anderes | eine Function |
sorted(), sorted(…) |
sortiert – natürlich oder mit einem Comparator |
nichts oder einen Comparator |
distinct() |
lässt jedes Element nur einmal durch | – |
limit(n), skip(n) |
nur die ersten n – oder alle außer den ersten n | eine Zahl |
| Abschluss | liefert |
|---|---|
toList() |
eine Liste (seit Java 16; sie ist unveränderlich wie List.of) |
count() |
die Anzahl als long |
anyMatch(…), allMatch(…), noneMatch(…) |
true oder false |
forEach(…) |
nichts – macht etwas mit jedem Element |
collect(Collectors.joining(", ")) |
alle Elemente als ein Text, mit Trenner |
min(…), max(…), findFirst() |
ein Optional – siehe unten |
anyMatch hört übrigens auf, sobald es das erste passende Element gefunden
hat – genau wie eine Schleife mit return true.
Optional: wenn vielleicht nichts da ist
Abschnitt betitelt „Optional: wenn vielleicht nichts da ist“Was ist das Minimum einer leeren Liste? Was findet findFirst, wenn kein Element
passt? Statt null liefert ein Stream ein Optional – eine Hülle, die
entweder einen Wert enthält oder leer ist.
package de.drv.streams;
import java.util.Comparator;import java.util.List;import java.util.Optional;
/** Was liefert ein Stream, wenn er nichts findet? Ein leeres Optional. */public class Optionale {
public static void main(String[] args) { List<Lauf> laeufe = Ergebnisse.alle();
Optional<Lauf> schnellster = laeufe.stream().min(Comparator.comparing(Lauf::zeit)); System.out.println("gefunden? " + schnellster.isPresent()); System.out.println("schnellster: " + schnellster.get().name());
Optional<Lauf> ausKoeln = laeufe.stream() .filter(lauf -> lauf.verein().equals("1. FC Köln")) .findFirst(); System.out.println("aus Köln gefunden? " + ausKoeln.isPresent());
// Statt get(): sagen, was passieren soll, wenn nichts da ist String name = ausKoeln.map(Lauf::name).orElse("niemand"); System.out.println("aus Köln: " + name);
ausKoeln.ifPresent(lauf -> System.out.println("Das erscheint nur, wenn es einen gibt.")); schnellster.ifPresent(lauf -> System.out.println("Sieger: " + lauf));
// ausKoeln.get() – wirft eine NoSuchElementException: No value present }
}gefunden? trueschnellster: Jonas Jungaus Köln gefunden? falseaus Köln: niemandSieger: 2 Jonas Jung LG Nordstadt 0:38:09orElse(ersatz)liefert den Wert – oder den Ersatz, wenn das Optional leer ist.map(…)gibt es auch bei Optional: Ist ein Wert da, wird er umgewandelt, sonst bleibt es leer.ifPresent(…)führt ein Lambda nur aus, wenn ein Wert da ist.get()auf einem leeren Optional wirft eineNoSuchElementException. Werget()schreibt, sollte sich sicher sein – meist istorElsedie bessere Wahl.
Der Vorteil gegenüber null: Der Typ Optional<Lauf> sagt schon, dass
vielleicht nichts da ist. Bei einem Lauf, der null sein könnte, merkt man
das erst an der NullPointerException.
package de.drv.streams;
import java.util.List;import java.util.OptionalDouble;import java.util.stream.IntStream;
/** Streams aus Zahlen: Summe, Durchschnitt, Bereiche. */public class Zahlen {
public static void main(String[] args) { List<Lauf> laeufe = Ergebnisse.alle();
// mapToInt macht aus einem Stream von Objekten einen Stream von int-Werten int sekunden = laeufe.stream().mapToInt(lauf -> (int) lauf.zeit().toSeconds()).sum(); System.out.println("alle zusammen: " + sekunden / 60 + " Minuten");
OptionalDouble schnitt = laeufe.stream().mapToLong(lauf -> lauf.zeit().toSeconds()).average(); System.out.printf("Durchschnitt: %.1f Minuten%n", schnitt.orElse(0) / 60);
// IntStream.rangeClosed – wie unser Bereich aus dem Kapitel über Iteratoren System.out.println("1 + … + 100 = " + IntStream.rangeClosed(1, 100).sum()); System.out.println("gerade bis 20: " + IntStream.rangeClosed(1, 20).filter(n -> n % 2 == 0).boxed().toList()); }
}alle zusammen: 470 MinutenDurchschnitt: 47,1 Minuten1 + … + 100 = 5050gerade bis 20: [2, 4, 6, 8, 10, 12, 14, 16, 18, 20]mapToInt,mapToLong,mapToDoublemachen aus einem Stream von Objekten einen Stream von Zahlen. Der kenntsum(),average(),min()undmax().average()liefert einOptionalDouble– denn der Durchschnitt von nichts ist nicht 0, sondern gar nichts.IntStream.rangeClosed(1, 100)liefert die Zahlen von 1 bis 100 – wie unserBereichaus dem Kapitel über Iteratoren.rangeohneClosedlässt die obere Grenze weg.boxed()macht aus denint-Werten wiederInteger-Objekte – nötig, um sie in eineList<Integer>zu sammeln.
Gruppieren
Abschnitt betitelt „Gruppieren“Die häufigste Frage an Daten: Wie viele je …? Wie viel je …? Dafür gibt es
Collectors.groupingBy:
package de.drv.streams;
import java.util.Arrays;import java.util.Map;import java.util.TreeMap;import java.util.stream.Collectors;
/** groupingBy: aus einem Stream eine Map – zum Zählen, Summieren, Mitteln. */public class Gruppieren {
public static void main(String[] args) { // Die Textstatistik aus dem Collection-Kapitel in einem Ausdruck Map<String, Long> haeufigkeit = Arrays.stream(Texte.JAVA.toLowerCase().split("[^a-zäöüß]+")) .filter(wort -> !wort.isEmpty()) .collect(Collectors.groupingBy(wort -> wort, TreeMap::new, Collectors.counting())); System.out.println(haeufigkeit.size() + " verschiedene Wörter, \"die\": " + haeufigkeit.get("die"));
// Läufer pro Verein Map<String, Long> proVerein = Ergebnisse.alle().stream() .filter(lauf -> !lauf.verein().isEmpty()) .collect(Collectors.groupingBy(Lauf::verein, TreeMap::new, Collectors.counting())); System.out.println(proVerein);
// Durchschnittszeit pro Verein, in Minuten Map<String, Double> schnitt = Ergebnisse.alle().stream() .filter(lauf -> !lauf.verein().isEmpty()) .collect(Collectors.groupingBy(Lauf::verein, TreeMap::new, Collectors.averagingDouble(lauf -> lauf.zeit().toSeconds() / 60.0))); schnitt.forEach((verein, minuten) -> System.out.printf("%-13s %5.1f min%n", verein, minuten)); }
}54 verschiedene Wörter, "die": 8{LG Nordstadt=3, SV Grünau=2, TV Lindental=3}LG Nordstadt 41,9 minSV Grünau 52,7 minTV Lindental 47,4 mingroupingBy bekommt bis zu drei Dinge:
- Wonach gruppiert wird – ein Lambda, das für jedes Element den Schlüssel liefert: das Wort selbst, den Verein.
- Welche Map entsteht –
TreeMap::newfür eine sortierte. Ohne diese Angabe gibt es eineHashMap. - Was pro Gruppe ausgerechnet wird –
Collectors.counting()zählt,averagingDouble(…)mittelt,summingDouble(…)summiert. Ohne diese Angabe gibt es pro Schlüssel eine Liste der Elemente.
Die Textstatistik aus dem Collection-Kapitel – Wörter zählen – ist damit ein
Ausdruck. map.forEach((schluessel, wert) -> …) läuft über alle Einträge einer
Map: ein Lambda mit zwei Parametern.
Streams aus Dateien
Abschnitt betitelt „Streams aus Dateien“package de.drv.streams;
import java.io.IOException;import java.nio.file.Files;import java.nio.file.Path;import java.util.stream.Stream;
/** Files.lines: eine Datei als Stream von Zeilen – auch er muss geschlossen werden. */public class DateiStream {
public static void main(String[] args) throws IOException { try (Stream<String> zeilen = Files.lines(Path.of("daten", "messwerte.csv"))) { double schnitt = zeilen .skip(1) // die Kopfzeile .map(zeile -> zeile.split(";")) .mapToDouble(teile -> Double.parseDouble(teile[2])) .average() .orElse(Double.NaN); System.out.printf("Durchschnitt aller Messwerte: %.1f °C%n", schnitt); } }
}Durchschnitt aller Messwerte: 11,8 °CFiles.lines liefert die Zeilen einer Datei als Stream – Zeile für Zeile, wie
der BufferedReader, also auch für riesige Dateien. Jeder Stream ist
AutoCloseable – wirklich schließen muss man aber nur einen, hinter dem eine
geöffnete Datei steckt. Deshalb gehört Files.lines in ein try-with-resources,
ein Stream aus einer Liste dagegen nicht.
Ausblick: parallel
Abschnitt betitelt „Ausblick: parallel“package de.drv.streams;
import java.util.stream.IntStream;
/** Ausblick: derselbe Stream, auf alle Prozessorkerne verteilt. */public class Parallel {
public static void main(String[] args) { System.out.println(Runtime.getRuntime().availableProcessors() + " Prozessorkerne"); messe("nacheinander", () -> System.out.println(" " + zaehlePrimzahlen(false) + " Primzahlen")); messe("parallel ", () -> System.out.println(" " + zaehlePrimzahlen(true) + " Primzahlen")); }
/** Wie viele Primzahlen gibt es unter fünf Millionen? */ static long zaehlePrimzahlen(boolean parallel) { IntStream zahlen = IntStream.range(2, 5_000_000); if (parallel) { zahlen = zahlen.parallel(); } return zahlen.filter(Parallel::istPrimzahl).count(); }
static boolean istPrimzahl(int zahl) { for (int teiler = 2; (long) teiler * teiler <= zahl; teiler++) { if (zahl % teiler == 0) { return false; } } return true; }
static void messe(String name, Runnable aufgabe) { long start = System.nanoTime(); aufgabe.run(); System.out.println(name + ": " + (System.nanoTime() - start) / 1_000_000 + " ms"); }
}8 Prozessorkerne 348513 Primzahlennacheinander: 416 ms 348513 Primzahlenparallel : 100 ms(Kerne und Millisekunden hängen vom Rechner ab.)
Ein parallel() in der Kette – und Java verteilt die Arbeit auf alle
Prozessorkerne. Das klingt nach einem Geschenk, hat aber Bedingungen:
- Es lohnt sich nur bei viel Arbeit pro Element oder sehr vielen Elementen. Bei zehn Läufen ist ein paralleler Stream langsamer – das Verteilen kostet mehr, als es bringt.
- Die Lambdas dürfen nichts Gemeinsames verändern – keine Liste von außen füllen, keinen Zähler hochzählen. Sonst laufen mehrere Kerne gleichzeitig darauf los, und das Ergebnis ist Zufall. Warum das so ist, gehört zum Thema Parallelität.
Stream oder Schleife?
Abschnitt betitelt „Stream oder Schleife?“Ein Stream ersetzt keine Schleife – er ersetzt eine Rechnung. Er passt, wenn eine Frage an Daten gestellt wird: auswählen, umwandeln, sortieren, zählen, zusammenfassen. Eine Schleife bleibt besser, wenn …
- mehrere Dinge gleichzeitig mitgezählt werden – dann bräuchte man mehrere Streams oder schwer lesbare Collectors,
- etwas geändert wird, das außerhalb liegt – Lambdas dürfen lokale Variablen ja nicht ändern,
- die Kette so lang wird, dass man sie nicht mehr auf einen Blick versteht.
Faustregel: Lässt sich die Pipeline vorlesen – „von allen Läufen die unter 45 Minuten, davon die Namen, sortiert“ –, ist sie richtig. Muss man über sie nachdenken, ist die Schleife die bessere Wahl.
Übung: Fragen an bekannte Daten
Abschnitt betitelt „Übung: Fragen an bekannte Daten“Arbeite im Demo-Projekt 28-streams. Schreibe jede Antwort als Stream-Pipeline.
-
Stadtlauf:
- Die Namen aller Läufer unter 45 Minuten – alphabetisch, als ein Text, durch Komma getrennt.
- Wie viele Läufer hat jeder Verein? Die Läufer ohne Verein zählen als „vereinslos“.
Terminal-Fenster Unter 45 Minuten: Ben Beispiel, David Demir, Greta Graf, Hasan Hofmann, Jonas Jung{LG Nordstadt=3, SV Grünau=2, TV Lindental=3, vereinslos=2} -
Optional: Schreibe eine Methode
schnellsterVon(laeufe, verein), die Name und Zeit des schnellsten Läufers eines Vereins liefert – oder „niemand am Start“, wenn der Verein keinen Läufer hat. Ohneif, ohneget().Terminal-Fenster SV Grünau: Greta Graf in 0:44:02TSV Waldheim: niemand am Start -
Messwerte: Die Durchschnittstemperatur pro Ort, direkt aus
daten\messwerte.csvmitFiles.lines. -
Für Schnelle: Das Haushaltsbuch aus dem Kapitel Ströme und Ressourcen als Pipeline: Summe je Kategorie aus
daten\ausgaben.csv, sortiert, mit Gesamtsumme. Die beiden fehlerhaften Zeilen sollen herausgefiltert werden. Lege deine Schleifenlösung von damals daneben – welche liest sich besser? Und was kann die Schleife, was die Pipeline nicht kann?
Lösung
- Für „vereinslos“ liefert das Lambda in
groupingBybei leerem Verein einfach einen anderen Schlüssel – mit dem Bedingungsoperator? :aus Woche 1. schnellsterVonkommt ohneifaus:minliefert einOptional,mapmacht daraus einen Text,orElsespringt ein, wenn nichts gefunden wurde.
package de.drv.streams;
import java.time.Duration;import java.util.Comparator;import java.util.List;import java.util.Map;import java.util.TreeMap;import java.util.stream.Collectors;
/** Stufen 1 und 2: Fragen an die Ergebnisse des Stadtlaufs. */public class StadtlaufAuswertung {
public static void main(String[] args) { List<Lauf> laeufe = Ergebnisse.alle();
// Stufe 1: die Namen aller unter 45 Minuten, alphabetisch, als ein Text String schnelle = laeufe.stream() .filter(lauf -> lauf.zeit().compareTo(Duration.ofMinutes(45)) < 0) .map(Lauf::name) .sorted() .collect(Collectors.joining(", ")); System.out.println("Unter 45 Minuten: " + schnelle);
// Stufe 1: Läufer pro Verein – ohne Verein als "vereinslos" Map<String, Long> proVerein = laeufe.stream() .collect(Collectors.groupingBy( lauf -> lauf.verein().isEmpty() ? "vereinslos" : lauf.verein(), TreeMap::new, Collectors.counting())); System.out.println(proVerein);
// Stufe 2: der schnellste eines Vereins – vielleicht gibt es keinen System.out.println("SV Grünau: " + schnellsterVon(laeufe, "SV Grünau")); System.out.println("TSV Waldheim: " + schnellsterVon(laeufe, "TSV Waldheim")); }
static String schnellsterVon(List<Lauf> laeufe, String verein) { return laeufe.stream() .filter(lauf -> lauf.verein().equals(verein)) .min(Comparator.comparing(Lauf::zeit)) .map(lauf -> lauf.name() + " in " + lauf.zeitText()) .orElse("niemand am Start"); }
}Lösung
Berlin 10,5 °CKöln 13,2 °CWie in der Demo, nur dass groupingBy statt average am Ende steht: Schlüssel
ist der Ort (teile[1]), gemittelt wird die Temperatur (teile[2]).
package de.drv.streams;
import java.io.IOException;import java.nio.file.Files;import java.nio.file.Path;import java.util.Map;import java.util.TreeMap;import java.util.stream.Collectors;import java.util.stream.Stream;
/** Stufe 3: Durchschnittstemperatur pro Ort, direkt aus der Datei. */public class MesswerteJeOrt {
public static void main(String[] args) throws IOException { Map<String, Double> schnitt; try (Stream<String> zeilen = Files.lines(Path.of("daten", "messwerte.csv"))) { schnitt = zeilen .skip(1) .map(zeile -> zeile.split(";")) .collect(Collectors.groupingBy(teile -> teile[1], TreeMap::new, Collectors.averagingDouble(teile -> Double.parseDouble(teile[2])))); } schnitt.forEach((ort, grad) -> System.out.printf("%-8s %5.1f °C%n", ort, grad)); }
}Lösung
Fahrtkosten 62,40 €Freizeit 56,40 €Lebensmittel 151,28 €Miete 650,00 €Versicherung 23,80 €Gesamt 943,88 €Dieselben Summen wie die Schleifenlösung. Die fehlerhaften Zeilen fallen im
filter heraus: genau drei Felder, und der Betrag passt zum Muster
\d+(\.\d+)? – Ziffern, optional ein Punkt und weitere Ziffern.
Was die Pipeline nicht kann: die fehlerhaften Zeilen mit ihrer Zeilennummer melden. Dafür müsste ein Lambda nebenbei mitzählen und etwas ausgeben – genau das, wofür die Schleife das bessere Werkzeug ist.
package de.drv.streams;
import java.io.IOException;import java.nio.file.Files;import java.nio.file.Path;import java.util.Map;import java.util.TreeMap;import java.util.stream.Collectors;import java.util.stream.Stream;
/** Stufe 4: das Haushaltsbuch aus dem Kapitel Ströme und Ressourcen – als Stream. */public class HaushaltsbuchStream {
public static void main(String[] args) throws IOException { Map<String, Double> summen; try (Stream<String> zeilen = Files.lines(Path.of("daten", "ausgaben.csv"))) { summen = zeilen .skip(1) .map(zeile -> zeile.split(";")) .filter(teile -> teile.length == 3 && teile[2].matches("\\d+(\\.\\d+)?")) .collect(Collectors.groupingBy(teile -> teile[1], TreeMap::new, Collectors.summingDouble(teile -> Double.parseDouble(teile[2])))); } summen.forEach((kategorie, summe) -> System.out.printf("%-15s %10.2f €%n", kategorie, summe)); double gesamt = summen.values().stream().mapToDouble(Double::doubleValue).sum(); System.out.printf("%-15s %10.2f €%n", "Gesamt", gesamt); }
}