https://delors.github.io/prog-adv-java-streams/folien.de.rst.html
https://delors.github.io/prog-adv-java-streams/folien.de.rst.html.pdf
Die Folien wurden insbesondere basierend auf der offiziellen Java Dokumentation (JavaDoc 24 und JEPs), sowie basierend auf der Scala (2.13 bzw. 3) Documentation erstellt. Die Folien bzgl. der konkreten Java Streams API (Deepdive) basieren auf Folien von Th. Letschert
Bei der Erstellung der Folien wurden KI Assistenten unterstützend eingesetzt. Dies erfolgte insbesondere, um effizient Grafiken zu generieren, die sich leicht in die Folien integrieren lassen, oder um sich Übersichtstabellen generieren zu lassen. Weiterhin wurde KI zur allgemeinen Qualitätssicherung eingesetzt. Alle Inhalte, die in diesem Rahmen von der KI (zusäztlich) vorgeschlagen wurden, wurden überprüft.
Es wurde keine KI verwendet für den Aufbau, die Struktur und insbesondere die Auswahl der grundlegenden Inhalte.
Konzept
Beschreibung
Beispiel
Lambda-Ausdruck
Eine anonyme Funktion, die als Wert übergeben werden kann. Syntax:
(Parameter) -> Ausdruck
(Parameter) -> { Anweisungen; }
(x, y) -> x + y
x -> x * x
() -> 42
(a, b) -> { int s = a + b; return s * 2; }Methoden-Referenz
Kurzschreibweise für Lambdas, die lediglich eine bestehende Methode aufrufen. Varianten:
statisch:
Klasse::methodeauf Instanz:
objekt::methodeauf Typ:
Klasse::instanzMethodeKonstruktor:
Klasse::new
Integer::parseInt
System.out::println
String::length
ArrayList::newFunktionales Interface
Ein Interface mit genau einer abstrakten Methode (SAM — Single Abstract Method). Kann mit
@FunctionalInterfaceannotiert werden und ermöglicht die Verwendung von Lambda-Ausdrücken.@FunctionalInterface interface MyFunc { int apply(int a, int b); }
Predicate<T>Funktionales Interface: Prüft eine Bedingung auf einem Wert und gibt
booleanzurück.
Predicate<Integer> isEven = x -> x % 2 == 0;
Function<T,R>Funktionales Interface: Bildet einen Wert vom Typ
Tauf einen Wert vom TypRab.
Function<String,Integer> len = String::length;
Consumer<T>Funktionales Interface: Konsumiert einen Wert, gibt nichts zurück (
void).
Consumer<String> printer = System.out::println;
Supplier<T>Funktionales Interface: Liefert einen Wert ohne Eingabe.
Supplier<Double> random = Math::random;
BinaryOperator<T>Funktionales Interface: Verknüpft zwei Werte desselben Typs zu einem Ergebnis.
BinaryOperator<String> wrap = (a, b) -> b + a + b;
Comparator<T>Funktionales Interface für den Vergleich von zwei Objekten; gibt einen
int-Wert zurück.
Comparator<String> byLen = (a, b) -> a.length() - b.length();
Comparator.comparing(String::length)Funktionen höherer Ordnung
Funktionen, die andere Funktionen als Parameter nehmen oder als Ergebnis zurückgeben. Grundlage aller Stream-Operationen.
stream.filter(x -> x > 0).map(x -> x * 2)Closure
Ein Lambda-Ausdruck, der auf Variablen aus dem umgebenden Kontext zugreift. Diese Variablen müssen
finaloder effektiv final sein.final int factor = 10; Stream.of(3,4,3). map(x -> x * factor). toList();
Optional<T>Ein Container, der einen Wert enthalten kann oder leer ist. Ersetzt die Verwendung von
null.
Optional.of(42)
Optional.empty()
Bei der Datenverarbeitung von:
großen Datenmengen,
die nicht (ohne weiteres) in den Speicher passen oder
bei denen es keinen Sinn macht diese vorab vollständig in den Speicher zu laden, da immer nur ein kleiner Abschnitt analysiert werden muss
Daten, die kontinuierlich verarbeitet werden müssen
Parallele Verarbeitung und effiziente Nutzung von modernen CPU-Architekturen
Insbesondere die korrekte und effiziente Nutzung mehrere Threads ist häufig schwierig. Die Verwendung von (soweit möglich) „transparent“ parallelisierten Streams ist dabei sehr hilfreich.
(Z. B. mit Java Parallel Streams oder .par in Scala ist eine weitgehend transparente Parallelisierung möglich.)
Entwicklung von Software nahe am Domänenmodell, um die korrekte Implementierung zu unterstützen.
Das Vorgehen wird detailliert durch konkrete Anweisungen beschrieben, die genau vorgeben welche einzelnen Schritte von dem Computer ausgeführt werden sollen, um das Ziel zu erreichen.
Viele gängige general-purpose Programmiersprachen (C, C++, Rust, Java, Go, JavaScript, Python) sind im Kern imperative Programmiersprachen.
Das Ziel ist es auszudrücken was erreicht werden soll, ohne das wie genau anzugeben.
(Prominentes Beispiel für eine deklarative Programmiersprache: SQL als Datenbankabfragesprache.)
Streams[1] sind umgeformte Sammlungen, die durch die Umformung für funktional-orientierte Massen-Operationen geeignet sind.
Streams erlauben die „korrekte, effiziente, lesbare (domänennahe)“ Verarbeitung von Daten mit Hilfe von Konzepten und Ideen aus der funktionalen und deklarativen Programmierung.
Es ist möglich als terminale Operation einen Iterator bzw. Spliterator zu erzeugen. In diesen beiden Fällen erfolgt die Evaluation der Pipeline nicht vollständig (d.h. nicht eager sondern lazy). Es wird somit nur so viel ausgewertet, wie für die Erzeugung des Iterator/Spliterator notwendig ist. Das hat zur Folge, dass die Elemente des Streams erst dann verarbeitet werden, wenn sie tatsächlich über den Iterator/Spliterator angefordert werden.
Die Verwendung dieser beiden Methoden führt zu einem Bruch des deklarativen Pipeline-Modells, der in den allermeisten Fällen vermieden werden kann. Häufig nur noch im Zusammenhang mit Legacy-APIs relevant, die mit Iterator/Spliterator arbeiten.
Transformieren die Elemente jeweils völlig unabhängig von allen anderen.
Transformieren die Elemente abhängig von anderen.
Operation |
Stateless / Stateful |
Speicherbedarf |
Parallelisierbar |
Short-circuiting |
|---|---|---|---|---|
filter |
Stateless |
Konstant |
Trivial |
Nein |
map |
Stateless |
Konstant |
Trivial |
Nein |
flatMap |
Stateless |
Konstant |
Trivial |
Nein |
mapMulti |
Stateless |
Konstant |
Trivial |
Nein |
peek |
Stateless |
Konstant |
Trivial |
Nein |
sorted |
Stateful |
O(n) |
Eingeschränkt |
Nein |
distinct |
Stateful |
O(n) |
Eingeschränkt |
Nein |
limit |
Stateful |
Konstant |
Eingeschränkt |
Ja |
skip |
Stateful |
Konstant |
Eingeschränkt |
Nein |
takeWhile |
Stateful |
Konstant |
Eingeschränkt |
Ja |
dropWhile |
Stateful |
Konstant |
Eingeschränkt |
Nein |
gather |
Konfigurierbar |
Konfigurierbar |
Konfigurierbar |
Konfigurierbar |
Stream<T> ist der Typ der Streams mit Objekten vom Typ T
Streams mit primitiven Daten:
IntStream
LongStream
DoubleStream
Diese Streams mit primitiven Daten arbeiten in vielen Fällen effizienter jedoch sind manche Operationen nur auf Object-Streams erlaubt. „Primitive“ Streams können mit der Methode boxed in Object-Streams umgewandelt werden.
Statische Methoden in Arrays
Die Klasse java.util.Arrays hat mehrere überladene statische stream-Methoden, mit denen Arrays in Ströme umgewandelt werden können.
Die Streams können Objekte oder primitive Daten enthalten.
Statische Methoden in Stream
Das Interface java.util.stream.Stream enthält mehrere statische Methoden mit denen Streams erzeugt werden können.
Für die Klassen der Streams mit primitiven Werten (z.B. java.util.stream.IntStream) gibt es äquivalente Methoden.
Mit of werden die übergebenen Wert in einen Stream gepackt.
Mit iterate und generate hat man eine einfache Möglichkeit unendliche Ströme zu erzeugen.
Statische range-Methoden in IntStream und LongStream
Die Interfaces java.util.stream.IntStream und java.util.stream.LongStream enthalten jeweils zwei statische range-Methoden mit denen Streams erzeugt werden können.
Nicht-statische Methoden der Collection-API
Das Interface java.util.Collection enthält die Methode stream mit der die jeweilige Kollektion in einen Stream umgewandelt werden kann.
Zustandslose Verarbeitungsoperationen
map(Function<? super T,? extends R> mapper): Transformiert jedes Element in ein anderes.
filter(Predicate<? super T> predicate): Filtert Elemente heraus.
flatMap(Function<? super T,? extends Stream<? extends R>> mapper): Transformiert jedes Element in einen Stream und fügt die Streams zusammen.
Zustandsbehaftete Verarbeitungsoperationen
distinct(): Entfernt Duplikate.
sorted(): Sortiert die Elemente.
sorted(Comparator<? super T> comparator): Sortiert die Elemente mit einem gegebenen Comparator.
limit(long maxSize): Begrenzt die Anzahl der Elemente.
skip(long n): Überspringt die ersten n Elemente.
Verarbeitungsoperationen
Eine terminale Operation hat im Gegensatz zu den Verarbeitungsoperationen keinen Stream als Ergebnis.
Terminale Operationen ohne Ergebnis
forEach(Consumer<? super T> action)
Wendet die übergebene Aktion auf alle Elemente des Streams an.
Terminale Operationen mit Ergebnis
Operationen mit Array-Ergebnis: Stream => Array
Operationen die den Stream in ein äquivalentes Array umwandeln.
Operationen mit Kollektions-Ergebnis: Stream => Kollektion
Operationen die den Stream in eine äquivalente Kollektion umwandeln.
Operationen mit Einzel-Ergebnis: Aggregierende Operationen
Operationen die den Stream zu einem einzigen Wert verarbeiten.
Terminale Operationen mit Kollektions-Ergebnis
Die Methode collect erzeugt eine Kollektion aus den Elementen des Streams.
IntStream und andere Streams mit primitiven Daten haben keine entsprechende Operation.
Das Argument von collect ist ein java.util.stream.Collector. Die Erzeugung einer Kollektion ist damit Sonderfall einer aggregierenden Operation.
Für die Erzeugung einer Kollektion verwendet man typischerweise einen vordefinierten Collector aus der Klasse java.util.stream.Collectors.
Einfache Kollektionserzeuger in Collectors sind:
toList()
toSet()
toCollection(Supplier<C> collectionFactory)
In Collectors finden sich Kollektoren mit denen Maps erzeugt werden können, die eine Gruppierung bzw. eine Partitionierung der Stream-Elemente darstellen:
static <T,K> Collector<T,?,Map<K,List<T>>> groupingBy(Function<? super T,? extends K> classifier)
Gruppiert die Elemente entsprechend einer Klassifizierungsfunktion.
static <T> Collector<T,?,Map<Boolean,List<T>>> partitioningBy(Predicate<? super T> predicate)
Partitioniert die Elemente entsprechend einem Prädikat.
Das Interface Stream bzw. die Interfaces für Ströme primitiver Daten (IntStream, etc.) bieten einige einfache aggregierende Funktionen für Standardoperationen auf allen Elementen des Stroms.
Das Interface Stream bieten einige einfache aggregierende Funktionen für den Test aller Elemente des Stroms mit einem übergebenen Prädikat.
Das Interface Stream bietet die Funktionen findFirst und findAny für die „Suche“ nach dem ersten bzw. irgendeinem Element in einem Stream.
Das Interface Stream bietet die Funktion
Optional<T> reduce(BinaryOperator<T> accumulator)
mit der eine Funktion auf jedes Element und das bisherige Zwischenergebnis angewendet werden kann.
Falls der erste Wert nicht der Startwert sein soll, verwendet man:
Optional<T> reduce(T identity, BinaryOperator<T> accumulator)
Es gibt einen Kollektor mit dem String-Elemente zu einem String konkateniert werden können:
static Collector<CharSequence,?,String> joining(CharSequence delimiter)
Ausgewählte Eigenschaften des Basisinterface aller Streams
Parallele und sequentielle Streams.
1package java.util.stream;23public interface BaseStream<T, S extends BaseStream<T,S>> {4/** Closes the stream, releasing any resources associated with it. */5void close();67/** Returns an equivalent stream that is parallel. */8S parallel();9/** Returns an equivalent stream that is sequential. */10S sequential();11}
13public interface Stream<T> extends BaseStream<T, Stream<T>> {14// ...15}
Die Interfacedefintion (BaseStream<T, S extends BaseStream<T,S>>) ist eine Anwendung des CRTP; d. h. des Curiously Recurring Template Patterns. Bei diesem Idiom haben wir eine Klasse X, die von einer generischen Klasse oder einem generischen Interface S abgeleitet wird, wobei die ableitende Klasse X sich selber als Typparameter verwendet. Dies erlaubt die Definition einer Fluent-API, bei der Methoden, die in der Basisklasse definiert sind, den abgeleiteten Typ zurückgeben.
Erzeugen von eigenen Streams mittels StreamSupport
Die Implementierung des Interfaces Stream<T> ist ggf. sehr aufwändig. Alternativ kann die Klasse StreamSupport verwendet werden, um auf einem Spliterator basierende Streams zu erzeugen.
1package java.util.stream;23public final class StreamSupport {45/** Creates a new sequential or parallel Stream from a Spliterator. */6static <T> Stream<T> stream(Spliterator<T> spliterator, boolean parallel);78// ...9}
Streams und Lambda Ausdrücke
1void main() {2List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "Diana", "Eve");3List<Integer> grades = Arrays.asList(85, 42, 91, 67, 55);45// TODO 1: Using a lambda, filter the grades list to only keep grades >= 606// and print the passing grades.7// Hint: Use stream(), filter(), and forEach().8910// TODO 2: Create a Predicate<Integer> lambda called `isExcellent`11// that returns true if a grade is 90 or above. Then print all excellent grades.121314// TODO 3: Create a Function<Integer, String> lambda called `toLetterGrade`15// that converts a numeric grade to a letter:16// 90+ → "A"; 75+ → "B" ; 60+ → "C"; below 60 → "F"17// Then print each grade alongside its letter grade.181920// TODO 4: Using a lambda, calculate and print the average of all grades.21// Hint: Use stream() and mapToInt().22}
Java Streams
Schreiben Sie eine Methode int sumOfSquares(int[] a) die die Elemente des Arrays quadriert und dann die Summe berechnet.
Schreiben Sie eine Methode int sumOfSquaresEven(int[] a) die die Elemente des Arrays quadriert, und dann die Summe berechnet für alle Elemente die gerade sind.
Schreiben Sie eine Methode, die eine Liste von Strings (List<String>) in eine flache Liste von Zeichen (List<Integer>) umwandelt.
Schreiben Sie eine Methode, die die Zahlen von 1 bis Integer.MAX_VALUE addiert. Nutzen Sie IntStream.range() um die Zahlen zu iterieren. Messen Sie die Ausführungsdauer für die sequentielle und parallele Ausführung (siehe Anhang für eine entsprechende Methode zur Zeitmessung.)
Um die Ausführungsdauer Ihrer Methode zu messen, können Sie folgenden Methode verwenden:
1void time(Runnable r) {2final var startTime = System.nanoTime();3r.run();4final var endTime = System.nanoTime();5System.out.println("elapsed time: "+(endTime - startTime));6}
Ein Aufruf der Methode time könnte dann so aussehen:
1 time(() -> System.out.println(sumOfSquares(new int[]{1,2,3,4,5,6,7,8,9,0})));
Lösung mit standard Stream Primitiven (≤ Java 24)
Benötigte Imports
1import static java.util.Comparator.comparingDouble;2import static java.util.function.Predicate.not;3import static java.util.stream.Collectors.groupingBy;4import static java.util.stream.Collectors.minBy;
Geschäftslogik
1List<Student> empfehlungenS = alleStudierenden.stream()2.filter(not(Student::hatStipendium))3.collect(groupingBy(Student::studiengang,4minBy(comparingDouble(Student::schnitt))))5.values().stream().flatMap(Optional::stream)6.sorted(comparingDouble(Student::schnitt))7.toList();
Im Folgenden verwenden wir die Begriffe Custom Intermediate Operations und Stream Gatherers faktisch synonym.
TODODODODODO
Custom Intermediate Operation/Custom Gatherer
1static <T, K> Gatherer<T, ?, T> reducePerGroup(2Function<T, K> grouping, BinaryOperator<T> reducer) {3return Gatherer.ofSequential(4HashMap<K, T>::new,5(map, element, downstream) -> {6map.merge(grouping.apply(element), element, reducer);7return true;8},9(map, downstream) -> map.values().forEach(downstream::push)10); }
1List<Student> empfehlungenG = alleStudierenden.stream()2.filter(not(Student::hatStipendium))3.gather(reducePerGroup(4Student::studiengang,5BinaryOperator.minBy(comparingDouble(Student::schnitt))))6.sorted(comparingDouble(Student::schnitt))7.toList();
benötigte Imports
1import static java.util.Comparator.comparingDouble;2import static java.util.function.Predicate.not;3import static java.util.stream.Collectors.groupingBy;4import static java.util.stream.Collectors.minBy;
Als allgemeine Faustregel gilt, dass Geschwindigkeitssteigerungen in der Regel dann spürbar sind, wenn die Sammlung groß ist, typischerweise mehrere tausend Elemente umfasst.[2]
(Java) Streams unterstützen die effiziente, korrekte Verarbeitung von (Massen-)Daten durch die Anwendung von funktionalen und deklarativen Konzepten mit dem Ziel einer möglichst geringen Repräsentationslücke (Low representational gap).
Java Streams |
Scala Collections |
|
|---|---|---|
Pipeline-Modell |
Deklarativ, verkettet |
Deklarativ, verkettet |
Funktionen als Parameter |
Lambdas, Method References |
Funktionsliterale, Platzhalter _ |
Quelle unveränderlich |
Ja |
Ja |
Streams = Collections? |
Nein — separates Konzept, explizites .stream() / .toList() |
Ja — Operationen direkt auf Collections |
Auswertung |
Lazy (erst bei Terminal Op) |
Eager (sofort); LazyList als Opt-in |
Erweiterbarkeit |
Collectors seit Java 8, Gatherers seit Java 24 |
'„Nicht nötig“ — umfangreiche Standardbibliothek' |
Parallelisierung |
Tief integriert (.parallelStream()) |
Separate Bibliothek (.par) seit Scala 2.13 |
Scala verfolgt einen anderen Designansatz: Collections sind die Pipeline. Es gibt keine Trennung zwischen Datenstruktur und Transformations-API. Das macht den Einstieg einfacher und den Code kürzer, bedeutet aber auch, dass Laziness explizit gewählt werden muss.
Javas Trennung in Collection und Stream ist verboseer, ermöglicht dafür aber Lazy Evaluation als Standard und eine tief integrierte Parallelisierung.
Java (mit Gatherer)
1alleStudierenden.stream()2.filter(not(Student::hatStipendium))3.gather(reducePerGroup(4Student::studiengang,5BinaryOperator.minBy(6comparingDouble(7Student::schnitt))))8.sorted(comparingDouble(9Student::schnitt))10.toList();
Scala
1alleStudierenden2.filterNot(_.hatStipendium)3.groupBy(_.studiengang)4.values5.map(_.minBy(_.schnitt))6.toList7.sortBy(_.schnitt)