Wat is de Stream API?

Question

Accepted Answer

De **Stream API** (Java 8+) maakt **functionele-stijl** verwerking van collecties mogelijk — filteren, transformeren en aggregeren van gegevens via een pijplijn van bewerkingen, declaratief uitgedrukt (*wat* doen) in plaats van expliciete lussen (*hoe*). ## Waarom het belangrijk is ```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 ``` De stream-versie drukt de intentie duidelijk uit als een keten van bewerkingen, zonder handmatige lus of accumulator. ## Pipeline structuur ```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 ``` **Intermediate** bewerkingen (filter, map, sorted, distinct) zijn **lazy** — ze bouwen de pijplijn op maar voeren niet uit totdat een **terminal** bewerking (collect, forEach, reduce, count) dit triggert. ## Veelvoorkomende bewerkingen ```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 — vouwen tot een enkele waarde ```java int total = nums.stream().reduce(0, (a, b) -> a + b); // sum via reduction ``` ## Parallelle streams ```java list.parallelStream().filter(...).collect(...); // process across multiple cores // ⚠️ use only for large data + independent/stateless operations; measure first ``` ## Waarom het belangrijk is De Stream API transformeerde hoe Java gegevens verwerkt — vervangen van uitgebreide, foutgevoelige lussen door beknopte, leesbare, declaratieve pijplijnen voor filteren, mapping, sorteren, groeperen en aggregeren. Het wordt veel gebruikt in modern Java voor gegevensmanipulatie, maakt de bedoeling van code duidelijker en integreert met lambdas en methoderefenties voor een functionele stijl. Inzicht in het lazy intermediate / eager terminal model, veelvoorkomende bewerkingen (filter/map/collect/reduce/groupingBy) en de optie van parallelle streams (met hun voorbehouden) is essentieel voor het schrijven van idiomatisch modern Java. Streams zijn zowel een productiviteitsboost als een veel voorkomend interview-onderwerp, wat vloeiendheid met huidige Java-praktijken weerspiegelt.