Tutorial Java: Operaciones finales con Streams: collect()

En el mundo de la programación Java, especialmente en el ámbito de la programación funcional, los streams son una de las principales características utilizadas para manipular datos. En particular, la operación collect() en streams es una operación terminal esencial, utilizada para transformar un stream en otra estructura de datos diferente o una instancia de un tipo de objeto particular.

La operación collect()

La operación collect() es una operación terminal que transforma los elementos de un stream en otra estructura de datos o en una instancia de un tipo de objeto específico.

Un uso común de collect() es convertir un stream a una lista o a un conjunto. Esto se hace mediante el uso de los métodos predefinidos en la interfaz Collectors, como toList() y toSet(), respectivamente.

Aquí hay un ejemplo básico:

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

public class Main {
    public static void main(String[] args) {
        Stream<String> stream = Stream.of("Uno", "Dos", "Tres");
        List<String> list = stream.collect(Collectors.toList());
        System.out.println(list); // Imprime [Uno, Dos, Tres]
    }
}

En este ejemplo, se crea un stream de cadenas de texto y luego se utiliza collect(Collectors.toList()) para convertir el stream en una lista de cadenas.

Sin embargo, collect() es mucho más potente que simplemente convertir un stream en una lista o un conjunto. También puede ser utilizado para convertir un stream en un mapa, concatenar elementos de un stream, calcular el valor promedio de elementos numéricos, y mucho más.

¿Cómo funciona collect()?

El método collect() es una operación de reducción mutable. Lo que esto significa es que puede acumular elementos de un stream en un contenedor mutable, como una colección. La operación collect() toma un argumento de tipo Collector. Los objetos Collector encapsulan las funciones necesarias para realizar la reducción mutable.

La interfaz Collector consta de varios métodos, pero los tres principales son:

• supplier(): Este método debe devolver una función que crea una nueva instancia de la estructura de datos donde se acumularán los elementos.
• accumulator(): Este método debe devolver una función que toma dos argumentos: la estructura de datos que está siendo acumulada y el elemento actual del stream. Esta función debe implementar cómo se agrega el elemento actual a la acumulación.
• combiner(): Este método debe devolver una función que toma dos argumentos: dos estructuras de datos que deben ser combinadas en una. Este método se utiliza en operaciones de streams paralelos para combinar estructuras de datos parciales en una estructura de datos final.

Afortunadamente, no se necesita implementar estos métodos manualmente cada vez que se utiliza collect(). La interfaz Collectors proporciona una serie de métodos predefinidos que se pueden utilizar.

Por ejemplo, Collectors.toList() es un método que devuelve un Collector que acumula los elementos de un stream en una List. Su implementación podría parecer algo como esto:

public static <T> Collector<T, ?, List<T>> toList() {
    return new Collector<T, List<T>, List<T>>() {
        @Override
        public Supplier<List<T>> supplier() {
            return ArrayList::new;
        }

        @Override
        public BiConsumer<List<T>, T> accumulator() {
            return List::add;
        }

        @Override
        public BinaryOperator<List<T>> combiner() {
            return (left, right) -> {
                left.addAll(right);
                return left;
            };
        }

        @Override
        public Function<List<T>, List<T>> finisher() {
            return Function.identity();
        }

        @Override
        public Set<Characteristics> characteristics() {
            return Collections.unmodifiableSet(EnumSet.of(Characteristics.IDENTITY_FINISH));
        }
    };
}

Aquí, supplier() devuelve una función que crea una nueva instancia de ArrayList. accumulator() devuelve una función que agrega un elemento a una List. combiner() devuelve una función que combina dos List en una. finisher() simplemente devuelve la List como está, y characteristics() devuelve un conjunto de Characteristics que indica las características del Collector.

Más ejemplos de uso de collect()

Convirtiendo un stream a un conjunto

Al igual que se puede convertir un stream a una lista con Collectors.toList(), también se puede convertir un stream a un conjunto con Collectors.toSet():

import java.util.stream.Stream;
import java.util.Set;
import java.util.stream.Collectors;

public class Main {
    public static void main(String[] args) {
        Stream<String> stream = Stream.of("Uno", "Dos", "Tres", "Uno");
        Set<String> set = stream.collect(Collectors.toSet());
        System.out.println(set); // Imprime [Uno, Dos, Tres]
    }
}

Aquí, aunque "Uno" se repite en el stream, el resultado es un Set que no contiene elementos duplicados.

Convirtiendo un stream a un mapa

Collectors también proporciona varios métodos para convertir un stream en un Map. Uno de los métodos más simples es toMap(), que toma dos funciones: una para generar las claves del mapa y otra para generar los valores.

Aquí hay un ejemplo que convierte un stream de strings en un mapa donde las claves son las strings y los valores son las longitudes de las strings:

import java.util.stream.Stream;
import java.util.Map;
import java.util.stream.Collectors;

public class Main {
    public static void main(String[] args) {
        Stream<String> stream = Stream.of("Uno", "Dos", "Tres");
        Map<String, Integer> map = stream.collect(Collectors.toMap(
            str -> str,
            str -> str.length()
        ));
        System.out.println(map); // Imprime {Uno=3, Dos=3, Tres=4}
    }
}

Aquí, el primer argumento para toMap() es una función que devuelve la cadena tal cual. El segundo argumento es una función que devuelve la longitud de la cadena. Por lo tanto, se genera un Map donde las claves son las cadenas del stream y los valores son las longitudes de esas cadenas.

Conclusión

La operación collect() es una herramienta poderosa en la programación funcional con Java. Permite transformar los elementos de un stream en otra estructura de datos o en una instancia de un tipo de objeto específico.

Aunque los ejemplos anteriores han demostrado su uso en la conversión de streams a diferentes tipos de colecciones y mapas, collect() es mucho más flexible y puede ser utilizado para muchas otras operaciones, como concatenar elementos, calcular el promedio, y mucho más.

En última instancia, entender collect() y cómo funciona es esencial para aprovechar al máximo las capacidades de los streams en Java.