Tutorial Java: Creación de Streams

Los "Streams" en Java SE son una característica introducida en Java 8 y se enmarcan dentro del paradigma de la programación funcional. Son una nueva abstracción que permite trabajar con datos de una manera más declarativa. Están diseñados para procesar grandes cantidades de datos de manera eficiente, incluso aprovechando la arquitectura multi-core de los modernos sistemas de cómputo.

En términos sencillos, un Stream en Java es una secuencia de datos. Un Stream toma una colección de datos como entrada y permite realizar operaciones en dichos datos, como transformaciones y agregaciones. Los Streams son "lazy", es decir, no se ejecutan hasta que se necesita el resultado. Esto permite que las operaciones de Stream sean muy eficientes, ya que no se realizan cálculos innecesarios.

A continuación, se presentará cómo crear y utilizar Streams en Java SE. Para comenzar, es importante entender cómo se crean los Streams.

Creación de Streams

La creación de un Stream se puede realizar de varias maneras. La más común es a partir de una colección de datos. Todas las clases que implementan la interfaz java.util.Collection, como ArrayList, HashSet y LinkedList, tienen un método stream() que permite crear un Stream.

Aquí se muestra un ejemplo de cómo crear un Stream a partir de una lista:

List<String> list = Arrays.asList("a", "b", "c");
Stream<String> stream = list.stream();

Se puede también crear un Stream a partir de un array utilizando el método Stream.of(T... values):

String[] array = {"a", "b", "c"};
Stream<String> stream = Stream.of(array);

Incluso, se puede crear un Stream de valores individuales:

Stream<String> stream = Stream.of("a", "b", "c");

También existen maneras de crear Streams infinitos. Por ejemplo, el método Stream.iterate() crea un Stream infinito basado en una función generadora. A continuación se presenta un ejemplo de un Stream que genera números pares:

Stream<Integer> stream = Stream.iterate(0, n -> n + 2);

Otro método para crear un Stream infinito es Stream.generate(), que toma un objeto Supplier y genera un Stream infinito de elementos. Por ejemplo, el siguiente código crea un Stream infinito de números aleatorios:

Stream<Double> stream = Stream.generate(Math::random);

Es importante destacar que los Streams infinitos deben usarse con precaución, ya que operaciones como count(), collect() o forEach() generarán un bucle infinito. Por este motivo, se debe utilizar el método limit() para limitar la cantidad de elementos que se procesarán:

Stream<Integer> stream = Stream.iterate(0, n -> n + 2).limit(10);

El código anterior genera un Stream de los primeros 10 números pares.

Operaciones con Streams

Una vez creado un Stream, se pueden realizar varias operaciones sobre él. Las operaciones de Stream se clasifican en dos categorías: operaciones intermedias y operaciones finales.

Las operaciones intermedias, como filter(), map(), flatMap() y sorted(), transforman un Stream en otro Stream. Son "lazy", lo que significa que no se ejecutan hasta que se invoca una operación final. Además, las operaciones intermedias se pueden encadenar.

Las operaciones finales, como collect(), forEach(), reduce(), count(), min(), max() y los métodos de coincidencia, producen un resultado o un efecto secundario. Una vez que se invoca una operación final, el Stream se consume y ya no se puede utilizar más.

Aquí se muestran algunos ejemplos de operaciones con Streams.

Operaciones Intermedias

1. filter(): Toma un Predicate como argumento y devuelve un Stream que incluye solo los elementos que cumplen con el predicado.

Stream<String> stream = Stream.of("a", "b", "c", "d");
Stream<String> longWords = stream.filter(w -> w.length() > 1);

2. map(): Toma una Function como argumento y transforma los elementos del Stream aplicando la función a cada elemento.

Stream<String> stream = Stream.of("a", "b", "c", "d");
Stream<String> upperCaseWords = stream.map(String::toUpperCase);

3. flatMap(): Se usa para aplanar una estructura de datos. Toma una Function que devuelve un Stream para cada elemento y luego combina todos los Streams en uno solo.

List<String> words = Arrays.asList("Hello", "World");
Stream<String> letters = words.stream().flatMap(word -> Stream.of(word.split("")));

4. sorted(): Produce un Stream que está ordenado de acuerdo con su orden natural o un Comparator proporcionado.

Stream<String> stream = Stream.of("c", "a", "b", "d");
Stream<String> sortedStream = stream.sorted();

5. distinct(): Devuelve un Stream con elementos únicos (elimina duplicados).

Stream<String> stream = Stream.of("a", "b", "c", "a", "b");
Stream<String> distinctStream = stream.distinct();

Operaciones Finales

1. forEach(): Toma un Consumer y aplica la operación a cada elemento del Stream.

Stream<String> stream = Stream.of("a", "b", "c", "d");
stream.forEach(System.out::println);

2. collect(): Es una operación muy versátil que transforma los elementos del Stream en una estructura de datos diferente.

Stream<String> stream = Stream.of("a", "b", "c", "d");
List<String> list = stream.collect(Collectors.toList());

3. reduce(): Reduce los elementos del Stream a un solo valor. Toma un valor inicial y una función binaria y produce un resultado opcional.

Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5);
Optional<Integer> sum = stream.reduce(Integer::sum);

4. count(): Devuelve la cantidad de elementos en el Stream.

Stream<String> stream = Stream.of("a", "b", "c", "d");
long count = stream.count();

5. min() y max(): Devuelven el elemento mínimo y máximo del Stream, respectivamente, según un Comparator proporcionado.

Stream<String> stream = Stream.of("a", "b", "c", "d");
Optional<String> min = stream.min(Comparator.naturalOrder());

6. Métodos de coincidencia: anyMatch(), allMatch() y noneMatch(): Estos métodos toman un Predicate y devuelven un booleano. anyMatch() devuelve verdadero si cualquier elemento del Stream coincide con el predicado. allMatch() devuelve verdadero si todos los elementos del Stream coinciden con el predicado. noneMatch() devuelve verdadero si ningún elemento del Stream coincide con el predicado.

Stream<String> stream = Stream.of("a", "b", "c", "d");
boolean anyMatch = stream.anyMatch("a"::equals);

API Optional

Finalmente, es importante mencionar la API Optional que fue introducida en Java 8 junto con los Streams. Optional es una envoltura que puede contener o no un valor. Se utiliza para representar valores opcionales que pueden ser ausentes. Muchas operaciones de Stream, como min(), max() y reduce(), devuelven un Optional.

Por ejemplo, la operación max() en el siguiente código devuelve un Optional:

Stream<String> stream = Stream.of("a", "b", "c", "d");
Optional<String> max = stream.max(Comparator.naturalOrder());

Para obtener el valor de un Optional, se puede utilizar el método get(). Sin embargo, este método lanza una excepción si el Optional está vacío. Por lo tanto, es recomendable utilizar el método isPresent() para comprobar si el Optional contiene un valor antes de llamar a get():

if (max.isPresent()) {
    System.out.println(max.get());
}

Además, se pueden encadenar métodos como orElse(), orElseGet(), y orElseThrow() para proporcionar alternativas o lanzar excepciones cuando el Optional está vacío.

En conclusión, los Streams en Java SE son una herramienta poderosa para el procesamiento de datos y la programación funcional. Permiten al programador escribir código más declarativo y legible, lo cual puede ayudar a reducir los errores y mejorar la productividad. Aunque se necesita un tiempo para familiarizarse con los conceptos de los Streams y la programación funcional, el esfuerzo vale la pena por los beneficios que aportan.