¿Cómo funciona java.util.stream.Stream para procesar colecciones en Java?

Mi código llegó a convertirse en un monstruo. Sí, suena algo exagerado, pero cuando estaba procesando listas interminables en Java, mi código se llenó de bucles y condicionales y, créeme, fue toda una pesadilla. Ya con Java 8 las cosas cambiaron, porque introdujeron java.util.stream.Stream y se volvió mucho más sencillo procesar colecciones de datos de forma concisa. Por eso quiero explicarte cómo funciona y cómo lo puedes usar para procesar colecciones en Java como todo un experto.

¿Qué es java.util.stream.Stream?

java.util.stream.Stream es una API para trabajar con secuencias de elementos de forma declarativa. ¿Qué significa esto? Pues que no manipula cada elemento manualmente con bucles, sino que tú puedes definir qué quieres hacer, y Java se encarga del resto. La verdad es muy útil cuando trabajas con grandes cantidades de datos o cuando buscas escribir código limpio y fácil de mantener con el tiempo.

Es como si estuvieras trabajando en una fábrica de dulces, donde la cinta transportadora (o sea java.util.stream.Stream) lleva cada elemento a través de estaciones donde se realizan operaciones como filtrar, transformar o empaquetar.

Sería algo como esto:

• Stream: Es la cinta transportadora que maneja una secuencia de elementos.
• Operaciones intermedias: Son como las estaciones en la fábrica, donde puedes filtrar, mapear, y transformar los elementos mientras se desplazan. Por ejemplo, añadir relleno o envolver los dulces.
• Operaciones terminales: Son como la estación final en la fábrica, donde obtienes el resultado final, como empaquetar los dulces para la venta.

¿Cómo funciona java.util.stream.Stream? Conoce sus componentes principales

Voy a darte a conocer los componentes principales de esta API para que puedas entender su funcionamiento y ponerlo en práctica después:

Creación del Stream

En caso de que no lo sepas, un Stream se puede crear a partir de cualquier colección o incluso de un array. Los métodos comunes son stream() y Stream.of().

List<String> frutas = List.of("Manzana", "Pera", "Naranja");
Stream<String> streamDeFrutas = frutas.stream();

Operaciones intermedias

Continuando con la analogía que te expliqué al inicio, estas son las estaciones en la cinta transportadora. No modifican los datos originales, sino que crean un nuevo Stream transformado.

Mira las operaciones comunes:

• filter: Filtra elementos basados en una condición.
• map: Transforma cada elemento del Stream.
• sorted: Ordena los elementos según un criterio.

Operaciones terminales

Son el final del viaje (del que te conté antes). Resulta que, estas operaciones consumen el Stream y producen un resultado, como una colección, un cálculo o simplemente un efecto secundario.

• collect: Convierte el Stream en una colección.
• forEach: Aplica una acción a cada elemento.
• reduce: Realiza un cálculo acumulativo.

Ejemplo práctico 1: Filtrar y transformar datos con java.util.stream.Stream

Supongamos que tienes una lista de empleados, y quieres obtener los nombres en mayúsculas de aquellos que ganan más de 50,000:

class Empleado {
    String nombre;
    double salario;

    public Empleado(String nombre, double salario) {
        this.nombre = nombre;
        this.salario = salario;
    }

    public String getNombre() {
        return nombre;
    }

    public double getSalario() {
        return salario;
    }
}

List<Empleado> empleados = List.of(
    new Empleado("Ana", 60000),
    new Empleado("Luis", 40000),
    new Empleado("Sofía", 70000)
);

List<String> nombresFiltrados = empleados.stream()
    .filter(e -> e.getSalario() > 50000)
    .map(Empleado::getNombre)
    .map(String::toUpperCase)
    .collect(Collectors.toList());

System.out.println(nombresFiltrados); // Resultado: [ANA, SOFÍA]

Ejemplo práctico 2: Ordenar y limitar resultados

¿Y si quieres obtener los tres números más altos de una lista ordenada? Con Stream, es pan comido.

List<Integer> numeros = List.of(5, 8, 12, 3, 7, 20, 1);

List<Integer> mayores = numeros.stream()
    .sorted(Comparator.reverseOrder())
    .limit(3)
    .collect(Collectors.toList());

System.out.println(mayores); // Resultado: [20, 12, 8]

Ejemplo práctico 3: Cálculo acumulativo

Algo grandioso es que, Stream también puede simplificar operaciones matemáticas, como sumar los valores de una lista.

List<Integer> valores = List.of(10, 20, 30, 40);

int suma = valores.stream()
    .reduce(0, Integer::sum);

System.out.println(suma); // Resultado: 100

Consejos para trabajar con java.util.stream.Stream en Java

Te dejo algunos consejitos que a mí me resultaron bastante útiles al momento de usar esta API:

1. Evita reutilizar Streams: Una vez consumido un Stream, no puedes usarlo nuevamente. Te recomiendo crear uno nuevo si es necesario.
2. Combina operaciones sabiamente: ¿A qué me refiero? Pues a que no abuses de operaciones intermedias si puedes simplificar el flujo.
3. Prioriza la legibilidad: Aunque Stream es poderoso, un flujo demasiado complejo puede ser difícil de mantener.

Me alegra que ahora sepas que java.util.stream.Stream es grandioso para procesar datos en Java de forma declarativa y eficiente. Ya aprendiste a usarlo, ahora transforma la manera en que escribes código y abordarás tareas complejas con facilidad.

¿Te imaginas aplicando esto en proyectos reales? Si quieres llevar tus habilidades en Java a un nivel profesional, apúntate al Bootcamp de Java Full Stack de KeepCoding. Te enseñaremos más herramientas avanzadas como esta, para que te conviertas en un experto codificador. ¡Empieza hoy y da el primer paso hacia una carrera en IT!