Java Tip 26: Stream API

La Stream API de Java sirve para procesar colecciones de datos de forma declarativa y funcional, evitando bucles explícitos y haciendo el código más legible, conciso y fácil de paralelizar.

• Los Streams representan una secuencia de elementos sobre la cual se pueden aplicar operaciones como filtrar, transformar, ordenar o reducir.
• No almacenan datos: simplemente transportan valores desde una fuente (colección, arreglo, I/O, etc.) a través de una pipeline de operaciones. 
•  Permiten escribir código más expresivo y funcional, similar a otros lenguajes modernos.

Operaciones principales

Los Streams se dividen en dos tipos de operaciones:

Intermedias (devuelven otro Stream):

• filter() → filtra elementos según una condición. 
•  map() → transforma cada elemento. 
•  sorted() → ordena los elementos.

Terminales (devuelven un resultado):

• collect() → convierte el Stream en una colección. 
•  forEach() → recorre los elementos. 
•  reduce() → combina todos los elementos en un único valor.

Veamos unos ejemplos.

Ejemplo 1. Filtrar números pares.

StreamEjemplo.java

import java.util.Arrays;
import java.util.List;

public class StreamEjemplo {
    public static void main(String[] args) {
        List<Integer> numeros = Arrays.asList(1, 2, 3, 4, 5, 6);

        numeros.stream()
               .filter(n -> n % 2 == 0)   // solo pares
               .forEach(System.out::println);
    }
}

Ejemplo 2. Transformar cadenas a mayúsculas.

StreamEjemplo.java

import java.util.Arrays;
import java.util.List;

public class StreamEjemplo {
    public static void main(String[] args) {
        List<String> nombres = Arrays.asList("cerrejo", "java", "stream");

        nombres.stream()
               .map(String::toUpperCase)   // transforma
               .forEach(System.out::println);
    }
}

Ejemplo 3. Sumar todos los números.

StreamEjemplo.java

import java.util.Arrays;
import java.util.List;

public class StreamEjemplo {
    public static void main(String[] args) {
        List<Integer> numeros = Arrays.asList(1, 2, 3, 4, 5);

        int suma = numeros.stream()
                          .reduce(0, Integer::sum); // acumulador
        System.out.println("Suma: " + suma);
    }
}

Podemos ver que logramos un código más conciso usando filter en vez de ciclos for. Además de tener mejor legibilidad. Lo que hace que sea más mantenible. Veamos ejemplos con collect.

Ejemplo 4. Convertir lista.

EjemploCollect.java

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class EjemploCollect {
    public static void main(String[] args) {
        List<String> nombres = Arrays.asList("Ana", "Pedro", "Juan", "Ana");

        // Filtrar y recolectar en una nueva lista
        List<String> filtrados = nombres.stream()
                                        .filter(n -> n.startsWith("A"))
                                        .collect(Collectors.toList());

        System.out.println(filtrados);
    }
}

Ejemplo 5. Convertir a conjunto (sin duplicados).

EjemploCollect.java

import java.util.Arrays;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;

public class EjemploCollect {
    public static void main(String[] args) {
        List<String> nombres = Arrays.asList("Ana", "Pedro", "Juan", "Ana");

        Set<String> unicos = nombres.stream()
                                    .collect(Collectors.toSet());

        System.out.println(unicos);
    }
}

Ejemplo 6. Agrupar por primera letra.

EjemploCollect.java

import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

public class EjemploCollect {
    public static void main(String[] args) {
        List<String> nombres = Arrays.asList("Ana", "Pedro", "Juan", "Pablo");

        Map<Character, List<String>> agrupados = nombres.stream()
            .collect(Collectors.groupingBy(n -> n.charAt(0)));

        System.out.println(agrupados);
    }
}

Como podemos ver:

• collect(Collectors.toList()) → crea una lista. 
•  collect(Collectors.toSet()) → crea un conjunto sin duplicados. 
•  collect(Collectors.groupingBy(...)) → agrupa elementos en un Map.

En conclusión: La Stream API te permite procesar colecciones de manera elegante y eficiente, reemplazando bucles tradicionales por operaciones declarativas y funcionales.

Enlaces:

https://www.arquitecturajava.com/java-stream/
https://www.oracle.com/latam/technical-resources/articles/java/expresiones-lambda-api-stream-java-part2.html