Was ist die Stream API?

Question

Accepted Answer

Die **Stream API** (Java 8+) ermöglicht **funktionale** Verarbeitung von Sammlungen — Filtern, Transformieren und Aggregieren von Daten durch eine Pipeline von Operationen, ausgedrückt deklarativ (*was* zu tun ist) statt mit expliziten Schleifen (*wie*). ## Imperativer vs Stream-Stil ```java // ❌ imperative — explicit loop, mutable accumulator List result = new ArrayList<>(); for (Person p : people) { if (p.getAge() >= 18) { result.add(p.getName().toUpperCase()); } } // ✅ stream — declarative pipeline, reads like a description of the transformation List result = people.stream() .filter(p -> p.getAge() >= 18) // keep adults .map(p -> p.getName().toUpperCase()) // extract + transform names .collect(Collectors.toList()); // gather into a list ``` Die Stream-Version drückt die Absicht klar als Kette von Operationen aus, ohne manuelle Schleife oder Akkumulator. ## Die Pipeline-Struktur ```text Source → Intermediate operations (lazy) → Terminal operation (triggers execution) ``` ```java stream() // source .filter(...) .map(...) // intermediate — lazy, return a new stream, chainable .collect(...) // terminal — produces a result, RUNS the pipeline ``` **Zwischenoperationen** (filter, map, sorted, distinct) sind **lazy** — sie bauen die Pipeline auf, führen aber nicht aus, bis eine **Terminal**-Operation (collect, forEach, reduce, count) diese auslöst. ## Häufige Operationen ```java list.stream() .filter(x -> x > 0) // keep matching .map(x -> x * 2) // transform each .sorted() // sort .distinct() // remove duplicates .limit(10) // take first 10 .collect(Collectors.toList()); // aggregations int sum = nums.stream().mapToInt(Integer::intValue).sum(); long count = list.stream().filter(...).count(); Optional first = people.stream().filter(...).findFirst(); boolean any = list.stream().anyMatch(x -> x > 100); // grouping (very powerful) Map> byCity = people.stream().collect(Collectors.groupingBy(Person::getCity)); ``` ## reduce — zu einem Wert falten ```java int total = nums.stream().reduce(0, (a, b) -> a + b); // sum via reduction ``` ## Parallele Streams ```java list.parallelStream().filter(...).collect(...); // process across multiple cores // ⚠️ use only for large data + independent/stateless operations; measure first ``` ## Warum es wichtig ist Die Stream API hat die Java-Datenverarbeitung transformiert — ersetzt umständliche, fehleranfällige Schleifen durch prägnante, lesbare, deklarative Pipelines zum Filtern, Abbilden, Sortieren, Gruppieren und Aggregieren. Sie wird in modernem Java stark für Datenmanipulation verwendet, macht die Absicht des Codes klarer und integriert sich mit Lambdas und Methodenreferenzen für einen funktionalen Stil. Das Verständnis des lazy Intermediate-/eager Terminal-Modells, häufiger Operationen (filter/map/collect/reduce/groupingBy) und der Option paralleler Streams (mit ihren Einschränkungen) ist essentiell für idiomatisches modernes Java. Streams sind sowohl ein Produktivitätsgewinn als auch häufiges Interviewthema und spiegeln Vertrautheit mit aktuellen Java-Praktiken wider.