¿Qué es la Stream API?

Question

Accepted Answer

La **Stream API** (Java 8+) habilita el procesamiento de colecciones en **estilo funcional** — filtrando, transformando y agregando datos a través de un pipeline de operaciones, expresado declarativamente (*qué* hacer) en lugar de con bucles explícitos (*cómo*). ## Estilo imperativo vs Stream ```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 ``` La versión de stream expresa la intención claramente como una cadena de operaciones, sin bucle manual ni acumulador. ## La estructura del pipeline ```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 ``` Las operaciones **intermedias** (filter, map, sorted, distinct) son **perezosas** — construyen el pipeline pero no se ejecutan hasta que una operación **terminal** (collect, forEach, reduce, count) lo desencadena. ## Operaciones comunes ```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 — plegar a un solo valor ```java int total = nums.stream().reduce(0, (a, b) -> a + b); // sum via reduction ``` ## Streams paralelos ```java list.parallelStream().filter(...).collect(...); // process across multiple cores // ⚠️ use only for large data + independent/stateless operations; measure first ``` ## Por qué es importante La Stream API transformó cómo Java procesa datos — reemplazando bucles verbosos y propensos a errores con pipelines concisos, legibles y declarativos para filtrado, mapeo, ordenamiento, agrupación y agregación. Se utiliza ampliamente en Java moderno para manipulación de datos, hace la intención del código más clara e integra lambdas y referencias de método para un estilo funcional. Comprender el modelo perezoso intermedio / terminal entusiasta, operaciones comunes (filter/map/collect/reduce/groupingBy) y la opción de streams paralelos (con sus advertencias) es esencial para escribir Java moderno idiomático. Los streams son tanto un aumento de productividad como un tema frecuente en entrevistas, reflejando fluidez con las prácticas actuales de Java.