What is the Stream API?

Question

Accepted Answer

The **Stream API** (Java 8+) enables **functional-style** processing of collections — filtering, transforming, and aggregating data through a pipeline of operations, expressed declaratively (*what* to do) rather than with explicit loops (*how*). ## Imperative vs Stream style ```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 ``` The stream version expresses intent clearly as a chain of operations, with no manual loop or accumulator. ## The pipeline structure ```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** operations (filter, map, sorted, distinct) are **lazy** — they build up the pipeline but don't execute until a **terminal** operation (collect, forEach, reduce, count) triggers it. ## Common operations ```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 — fold to a single value ```java int total = nums.stream().reduce(0, (a, b) -> a + b); // sum via reduction ``` ## Parallel streams ```java list.parallelStream().filter(...).collect(...); // process across multiple cores // ⚠️ use only for large data + independent/stateless operations; measure first ``` ## Why it matters The Stream API transformed how Java processes data — replacing verbose, error-prone loops with concise, readable, declarative pipelines for filtering, mapping, sorting, grouping, and aggregating. It's used heavily in modern Java for data manipulation, makes code's intent clearer, and integrates with lambdas and method references for a functional style. Understanding the lazy intermediate / eager terminal model, common operations (filter/map/collect/reduce/groupingBy), and the option of parallel streams (with their caveats) is essential for writing idiomatic modern Java. Streams are both a productivity boost and a frequent interview topic, reflecting fluency with current Java practices.