Zum Inhalt springen

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.

  • 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 Optional umgehen, wenn ein Stream vielleicht nichts findet
  • eine Datei mit Files.lines als Stream lesen

Demo-Code: 28-streams

⤓ demo-streams.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 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.

ErsterStream.java
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");
}
}
Terminal-Fenster
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 Quelle

Jeder Stream besteht aus drei Teilen:

  1. Eine Quelle: liste.stream() – oder ein Array mit Arrays.stream(…), eine Datei mit Files.lines(…), ein Zahlenbereich mit IntStream.range(…).
  2. Zwischenschritte, beliebig viele: Jeder nimmt einen Stream und liefert einen neuen. filter lässt durch, was die Bedingung erfüllt. map macht aus jedem Element etwas anderes – hier aus jedem Lauf seinen Namen.
  3. 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.
Bausteine.java
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);
}
}
Terminal-Fenster
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 vor
mit ü? true, alles klein? true
Vereine: 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.

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.

Optionale.java
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
}
}
Terminal-Fenster
gefunden? true
schnellster: Jonas Jung
aus Köln gefunden? false
aus Köln: niemand
Sieger: 2 Jonas Jung LG Nordstadt 0:38:09
  • orElse(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 eine NoSuchElementException. Wer get() schreibt, sollte sich sicher sein – meist ist orElse die 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.

Zahlen.java
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());
}
}
Terminal-Fenster
alle zusammen: 470 Minuten
Durchschnitt: 47,1 Minuten
1 + … + 100 = 5050
gerade bis 20: [2, 4, 6, 8, 10, 12, 14, 16, 18, 20]
  • mapToInt, mapToLong, mapToDouble machen aus einem Stream von Objekten einen Stream von Zahlen. Der kennt sum(), average(), min() und max().
  • average() liefert ein OptionalDouble – denn der Durchschnitt von nichts ist nicht 0, sondern gar nichts.
  • IntStream.rangeClosed(1, 100) liefert die Zahlen von 1 bis 100 – wie unser Bereich aus dem Kapitel über Iteratoren. range ohne Closed lässt die obere Grenze weg.
  • boxed() macht aus den int-Werten wieder Integer-Objekte – nötig, um sie in eine List<Integer> zu sammeln.

Die häufigste Frage an Daten: Wie viele je …? Wie viel je …? Dafür gibt es Collectors.groupingBy:

Gruppieren.java
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));
}
}
Terminal-Fenster
54 verschiedene Wörter, "die": 8
{LG Nordstadt=3, SV Grünau=2, TV Lindental=3}
LG Nordstadt 41,9 min
SV Grünau 52,7 min
TV Lindental 47,4 min

groupingBy bekommt bis zu drei Dinge:

  1. Wonach gruppiert wird – ein Lambda, das für jedes Element den Schlüssel liefert: das Wort selbst, den Verein.
  2. Welche Map entsteht – TreeMap::new für eine sortierte. Ohne diese Angabe gibt es eine HashMap.
  3. 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.

DateiStream.java
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);
}
}
}
Terminal-Fenster
Durchschnitt aller Messwerte: 11,8 °C

Files.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.

Parallel.java
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");
}
}
Terminal-Fenster
8 Prozessorkerne
348513 Primzahlen
nacheinander: 416 ms
348513 Primzahlen
parallel : 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.

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.

Arbeite im Demo-Projekt 28-streams. Schreibe jede Antwort als Stream-Pipeline.

  1. 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}
  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. Ohne if, ohne get().

    Terminal-Fenster
    SV Grünau: Greta Graf in 0:44:02
    TSV Waldheim: niemand am Start
  3. Messwerte: Die Durchschnittstemperatur pro Ort, direkt aus daten\messwerte.csv mit Files.lines.

  4. 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 groupingBy bei leerem Verein einfach einen anderen Schlüssel – mit dem Bedingungsoperator ? : aus Woche 1.
  • schnellsterVon kommt ohne if aus: min liefert ein Optional, map macht daraus einen Text, orElse springt ein, wenn nichts gefunden wurde.
StadtlaufAuswertung.java
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
Terminal-Fenster
Berlin 10,5 °C
Köln 13,2 °C

Wie in der Demo, nur dass groupingBy statt average am Ende steht: Schlüssel ist der Ort (teile[1]), gemittelt wird die Temperatur (teile[2]).

MesswerteJeOrt.java
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
Terminal-Fenster
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.

HaushaltsbuchStream.java
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);
}
}