Streams und Collectors.

In Programmieren 1 hast du map, filter und reduce als Lambdas kennengelernt. Die Stream-API ist das volle Werkzeug dahinter: eine Pipeline, die Daten durch mehrere Operationen schickt, lazy ausgewertet, abgeschlossen mit einer terminalen Operation und mächtigen Collectors zum Gruppieren und Aggregieren. In Programmieren 2 (z.B. TU Berlin, Mannheim) ist genau diese Tiefe Klausurstoff.

Was du können musst:

• die Anatomie einer Pipeline: Quelle, intermediate Operationen, terminale Operation
• Lazy Evaluation und Short-Circuit verstehen (warum nichts ohne Terminal-Op läuft)
• Collectors einsetzen: toList, groupingBy, joining, counting
• reduce, flatMap und primitive Streams (IntStream) anwenden
• die typischen Stream-Fallen kennen (Einmal-Nutzung, parallele Seiteneffekte)

Voraussetzung: Lambdas, funktionale Interfaces und Method-References (siehe Topic Lambdas & Higher-Order-Funktionen). Hier geht es um die Stream-API darauf aufbauend, nicht um die Lambda-Syntax selbst.

Die Idee in einem Satz

Ein Stream ist keine Datenstruktur, sondern eine Pipeline: eine Quelle, beliebig viele intermediate Operationen (lazy, geben wieder einen Stream zurück) und genau eine terminale Operation (startet die Verarbeitung und liefert ein Ergebnis).

Anatomie einer Pipeline

List<String> namen = List.of("Anna", "Bob", "Cara");
String ergebnis = namen.stream()          // Quelle
    .filter(s -> s.length() == 4)          // intermediate (lazy)
    .map(String::toUpperCase)              // intermediate (lazy)
    .collect(Collectors.joining(", "));    // terminal (startet alles)
// ergebnis = "ANNA, CARA"

Faustregel zum Erkennen: gibt die Methode einen Stream zurück, ist sie intermediate. Gibt sie etwas anderes zurück (Liste, Zahl, Optional, void), ist sie terminal und beendet die Pipeline.

Lazy Evaluation: ohne Terminal-Op läuft nichts

Die intermediate Operationen bauen nur die Pipeline auf, sie rechnen noch nicht. Erst die terminale Operation zieht die Elemente durch, und zwar Element für Element, nicht Stufe für Stufe. Das erlaubt Short-Circuit: Operationen wie findFirst, anyMatch oder limit stoppen, sobald das Ergebnis feststeht.

Im Stepper siehst du, dass bei findFirst nur das erste passende Element komplett durch die Pipeline läuft, der Rest wird nie angefasst.

Collectors: sammeln, gruppieren, aggregieren

Die terminale Operation collect(...) ist die mächtigste. Sie nimmt einen Collector entgegen, ein Rezept, wie die Elemente zusammengefasst werden:

groupingBy ist der Klausur-Klassiker. Im Stepper siehst du, wie eine Wörter-Liste nach Länge in eine Map gruppiert wird.

reduce, flatMap und primitive Streams

reduce kombiniert alle Elemente zu einem Wert. Mit Startwert (identity) bekommst du den Typ direkt, ohne Startwert ein Optional (der Stream könnte leer sein):

int summe = Stream.of(1, 2, 3, 4).reduce(0, Integer::sum);        // 10
Optional<Integer> max = Stream.of(1, 2, 3).reduce(Integer::max);  // Optional[3]

flatMap glättet verschachtelte Strukturen (Stream von Listen wird ein Stream von Elementen):

List<List<Integer>> verschachtelt = List.of(List.of(1, 2), List.of(3, 4));
List<Integer> flach = verschachtelt.stream()
    .flatMap(List::stream)              // aus Stream<List<Integer>> wird Stream<Integer>
    .toList();                          // [1, 2, 3, 4]

Primitive Streams (IntStream, LongStream, DoubleStream) vermeiden Autoboxing und bieten sum, average, range:

int summe = IntStream.rangeClosed(1, 100).sum();   // 5050

Parallele Streams (stream().parallel()) verteilen die Arbeit auf mehrere Threads, lohnen sich aber nur bei großen, unabhängigen, zustandslosen Operationen, und die Reihenfolge ist dann nicht garantiert.

Klausur-Faustregeln

1. Pipeline = Quelle + intermediate (lazy) + genau eine terminale Op. Ohne terminale Operation passiert gar nichts, der Stream wird nie ausgewertet.

2. Intermediate erkennt man am Rückgabetyp Stream. filter/map/sorted geben einen Stream zurück (verkettbar), collect/count/findFirst liefern ein Ergebnis und beenden die Pipeline.

3. Ein Stream ist einmal nutzbar. Nach der terminalen Operation ist er verbraucht. Erneutes Verwenden wirft IllegalStateException.

4. Reihenfolge der Operationen zählt. filter vor map spart Arbeit (weniger Elemente zu transformieren), sorted ist teuer (braucht den ganzen Stream und ist ein Pipeline-Bremser).

5. groupingBy für Gruppen, toMap für eindeutige Schlüssel. groupingBy ergibt Map<K, List<V>>. toMap wirft bei doppelten Schlüsseln eine Exception, wenn keine merge-Funktion angegeben ist.

6. reduce ohne Startwert gibt Optional. Mit identity (z.B. reduce(0, ...)) bekommst du den Typ direkt; ohne, weil der Stream leer sein könnte, ein Optional.

Häufige Stolpersteine

1. Stream zweimal nutzen. var s = list.stream(); s.count(); s.forEach(...); wirft IllegalStateException: stream has already been operated upon. Pro Stream genau eine terminale Operation.

2. Intermediate ohne Terminal. list.stream().map(x -> teuer(x)); ohne terminale Op tut nichts, weil lazy. Kein Output, kein Seiteneffekt, der map-Code läuft nie.

3. forEach mit collect verwechseln. forEach liefert void (nur Seiteneffekt). Wer ein Ergebnis sammeln will, braucht collect oder reduce, nicht forEach mit manuellem Befüllen einer Liste.

4. toMap mit doppelten Schlüsseln. Ohne merge-Funktion knallt es bei Duplikaten (IllegalStateException: Duplicate key). Lösung: dritter Parameter (a, b) -> a oder groupingBy statt toMap.

5. reduce-Rückgabe falsch erwartet. Ohne identity ist das Ergebnis ein Optional, nicht der Wert direkt. Wer int summe = stream.reduce(Integer::sum) schreibt, bekommt einen Typfehler (es ist Optional<Integer>).

6. Seiteneffekte in parallelen Streams. parallelStream().forEach(e -> liste.add(e)) auf eine normale ArrayList ist eine Race Condition (nicht thread-safe). collect(Collectors.toList()) ist der sichere Weg, parallel-tauglich.

Eine echte Pipeline Schritt für Schritt

Eine Liste von Studierenden mit Noten läuft durch eine typische Klausur-Pipeline: bestandene herausfiltern, nach Note sortieren, die Namen extrahieren und zu einem String zusammenfügen. Beobachte, wie sich die Zwischen-Liste nach jeder Stufe verändert, und dass die Reihenfolge der Operationen das Ergebnis bestimmt.

Klausur-Tipp: Bei "Was gibt diese Pipeline zurück?" gehst du Stufe für Stufe vor und notierst die Zwischen-Liste nach jeder Operation. Achte auf den Rückgabetyp der terminalen Op (List, String, Map, long, Optional), das ist oft die eigentliche Frage.