Categoría: Stream

Antes de Java 8, los desarrolladores a menudo pensaban en diferentes formas de escribir un contador para contar algo, por ejemplo, contar la frecuencia de palabras.

En Java 8, puede escribir un contador en dos líneas simples. Además, puede aprovechar la computación paralela.

Aquí está el contador de Java 8:

package com.programcreek.java8;
 
import java.util.stream.Collectors;
import java.util.stream.Stream;
import java.util.Map;
 
public class Java8Counter {
	public static void main(String[] args) {
		String[] arr = {"program", "creek", "program", "creek", "java", "web", "program"};
		Stream<String> stream = Stream.of(arr).parallel();
		Map<String, Long> counter = stream.collect(Collectors.groupingBy(String::toString, Collectors.counting()));
		System.out.println(counter.get("creek"));
	}
}

La definición de flujo en Java 8 es «una secuencia de elementos de una fuente que admite operaciones agregadas». Los flujos consumen desde una fuente como colecciones, matrices o recursos de E / S. Los flujos admiten las operaciones comunes de los lenguajes de programación funcionales, como mapear, filtrar, reducir, buscar, ordenar, etc.

Un ejemplo motivacional

Es fácil encadenar varios métodos que aceptan la expresión lambda como parámetro. Un cálculo complejo antes de Java 8 se puede escribir en muchas menos líneas.

Aquí hay un muy buen ejemplo motivacional de Java doc.[1]:

int sum = components.stream()
                      .filter(c -> c.getColor() == RED)
                      .mapToInt(c -> c.getWeight())
                      .sum();

En este ejemplo usamos componentes, una colección, como fuente para el flujo, y luego realice una operación de filtro-mapa-reducción en el flujo para obtener la suma de los pesos de los widgets rojos.

Transmisión frente a colección

Las corrientes pueden parecer similares a las colecciones, pero son conceptos muy diferentes. Cuando trabaja con grandes conjuntos de datos, es posible que no desee procesar todo el conjunto de datos como una colección. Hay una metáfora muy buena al comparar la diferencia entre Colección y Stream. [5]. Considere una película almacenada en un DVD en lugar de transmitida a través de Internet. Una película se puede ver como un conjunto de bytes. El DVD se puede ver como una colección de bytes porque contiene todos los elementos de datos. Al ver la película a través de Internet, la película se puede ver como un flujo de bytes. El reproductor de transmisión de video solo necesita tener unos pocos bytes antes de donde el usuario está mirando. De esta manera, el reproductor de video puede comenzar a mostrar la película desde el principio de la transmisión antes de que la mayoría de los datos de la transmisión se hayan calculado siquiera.

La diferencia entre Stream y Collection se puede detallar de la siguiente manera:

1. Una secuencia proporciona una interfaz para un conjunto secuenciado de valores de un tipo de elemento específico. Sin embargo, a diferencia de las colecciones, las transmisiones en realidad no almacenan elementos. Los elementos se calculan bajo demanda. Los flujos se pueden ver como colecciones construidas de forma perezosa, cuyos valores se calculan cuando se necesitan.
2. Las operaciones de transmisión no cambian su fuente. En cambio, devuelven nuevos flujos que almacenan el resultado.
3. Posiblemente ilimitado. Las colecciones tienen un tamaño finito, pero las transmisiones no. Las operaciones de cortocircuito como limit (n) o findFirst () pueden permitir que los cálculos en flujos infinitos se completen en un tiempo finito.
4. Consumible. Durante la vida útil de una transmisión, los elementos de la transmisión solo se visitan una vez. Si desea volver a visitar el mismo elemento en la transmisión, deberá volver a generar una nueva transmisión en función de la fuente.

Operaciones intermedias frente a operaciones de terminal

Las operaciones intermedias transforman un flujo en otro, mientras que las operaciones terminales producen un resultado. Cuando se ejecuta una operación de terminal en una secuencia, la secuencia ya no se puede utilizar.

Por ejemplo, en el siguiente código:

list.stream().filter(s -> s.length() > 2).count();

filter () es una operación intermedia y count () es una operación terminal. Cuando se llama a count (), ya no podemos usar la secuencia.

Las operaciones intermedias de uso frecuente incluyen: filtro, mapa, diferenciado, ordenado, salto, límite, mapa plano

Las operaciones de la terminal de uso frecuente incluyen:

1. forEach, toArray, recopilar, reducir, contar, min, max
2. findFirst, findAny, anyMatch, allMatch, noneMatch

Referencias:
1. Documento Java de Stream
2. Mónada en programación funcional
3. Procesamiento de datos con secuencias de Java SE 8, parte 1
4. paquete java.util.stream
5. Java 8 Lambdas en acción, por Raoul-Gabriel Urma, Mario Fusco y Alan Mycroft

1. De matrices

String[] arr = { "program", "creek", "program", "creek", "java", "web",
		"program" };
stream = Stream.of(arr);

stream = Stream.of("program", "creek", "program", "creek", "java",
		"web", "program");

String[] stringArr = {"a", "b", "c", "d"};
Stream<String> stream = Arrays.stream(stringArr);

2. De colecciones

// from collection
List<String> list = new ArrayList<String>();
list.add("java");
list.add("php");
list.add("python");
stream = list.stream();

3. Utilice Stream.generate ()

// generate()
Stream<String> stream = Stream.generate(() -> "test").limit(10);
String[] strArr = stream.toArray(String[]::new);
System.out.println(Arrays.toString(strArr));

4. Utilice Stream.iterate ()

// iterate()
Stream<BigInteger> bigIntStream = Stream.iterate(BigInteger.ZERO, n -> n.add(BigInteger.ONE)).limit(10);
BigInteger[] bigIntArr = bigIntStream.toArray(BigInteger[]::new);
System.out.println(Arrays.toString(bigIntArr));

5. De API populares

// stream method from APIs
String sentence = "Program creek is a Java site.";
Stream<String> wordStream = Pattern.compile("W").splitAsStream(sentence);
String[] wordArr = wordStream.toArray(String[]::new);
System.out.println(Arrays.toString(wordArr));

El método map () es una operación intermedia. Devuelve una secuencia que consta de los resultados de aplicar la función dada a cada elemento de la secuencia.

El siguiente código devuelve un flujo de enteros, que son el resultado de aplicar el método String.length ().

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Stream;
 
 
public class Java8Map {
 
	public static void main(String[] args) {
		List<String> list = new ArrayList<String>();
		list.add("java");
		list.add("php");
		list.add("python");
 
		//map function
		Stream<Integer> stream = list.stream().map(p -> p.length());
 
		Integer[] lengthArr = stream.toArray(Integer[]:: new);
 
		for(int a: lengthArr){
			System.out.println(a);
		}
	}
}

El método filter () es una operación intermedia. Devuelve una secuencia que consta de los elementos de esta secuencia que coinciden con la condición dada.

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Stream;
 
 
public class Java8Filter<T> {
 
	public static void main(String[] args) {
		List<String> list = new ArrayList<String>();
		list.add("java");
		list.add("php");
		list.add("python");
		list.add("lisp");
		list.add("c++");
 
		//filter function
		Stream<String> stream = list.stream().filter(p -> p.length() > 3);
		String[] arr = stream.toArray(String[]::new);
 
		System.out.println(Arrays.toString(arr));
	}
}

La API de Java 8 Stream contiene un conjunto de operaciones de terminal (como promedio, suma, mínimo, máximo y recuento) que devuelven un valor al combinar los elementos de un flujo. Estas operaciones de terminal se denominan operaciones de reducción. Además de esas operaciones de terminal, el JDK también proporciona el método de reducción de propósito general: reduce(), que describe esta publicación.

1. Un ejemplo simple de Stream.reduce ()

Suponiendo que tengamos un flujo de palabras como el siguiente:

List<String> list = new ArrayList<String>();
list.add("java");
list.add("php");
list.add("python");
list.add("perl");
list.add("c");
list.add("lisp");
list.add("c#");
Stream<String> wordStream = list.stream();

Podemos usar el siguiente código para obtener la suma de la longitud de las cadenas en la lista:

int s = wordStream.map(s -> s.length())
		.mapToInt(Integer::new)
		.sum();
 
System.out.println(s);

También podemos usar el método Stream.reduce (), que es un método más general:

Stream<Integer> lengthStream = wordStream.map(s -> s.length());
Optional<Integer> sum = lengthStream.reduce((x, y) -> x + y);
sum.ifPresent(System.out::println);

Stream.reduce () toma la entrada como una función acumuladora que toma dos parámetros: un resultado parcial de la reducción (en este caso, la suma de todos los enteros procesados ​​hasta ahora) y el siguiente elemento del flujo (en este caso, un entero ). Devuelve un nuevo resultado parcial. En este caso, la función de acumulador es una expresión lambda que suma dos valores enteros y devuelve un valor entero.

En lugar de usar la expresión lambda, también puede usar:

Optional<Integer> sum = lengthStream.reduce(Integer::sum);

2. Proporcionar valor de identificación

En el ejemplo anterior, el método reduce () devuelve un Opcional. Podemos evitar el tipo opcional, dándole un valor inicial 0:

Stream<Integer> lengthStream = wordStream.map(s -> s.length());
int sum = lengthStream.reduce(0, (x, y) -> x + y);
System.out.println(sum);

El valor inicial debe ser un valor para la función de reducción. Para todo t, reduce (identidad, t) y reduce

Además, también podemos escribir el método reduce () como el siguiente:

int s = wordStream.reduce(0, (x, y) -> x + y.length(), (x, y) -> x + y);
System.out.println(s);

Los tres parámetros son identificador, reductor y combinador.
– identidad – valor de identidad para la función de combinación
– reductor – función para combinar dos resultados
– combinador – función para agregar un elemento adicional a un resultado.

Referencia:
1. Stream.reduce ()

En lugar de reducir un flujo a un valor, también podemos recopilar los resultados. Podemos recopilar resultados en una matriz, un conjunto / lista o un mapa utilizando el método Stream.collect ().

1. Recopile los resultados de la transmisión en una matriz

List<String> list = new ArrayList<String>();
list.add("java");
list.add("php");
list.add("python");
Stream<String> wordStream = list.stream();
 
Stream<Integer> lengthStream = wordStream.map(s -> s.length());
Integer[] lenArr = lengthStream.toArray(Integer[]::new);
System.out.println(Arrays.toString(lenArr));

* Tenga en cuenta que toArray () es una operación de terminal. Después de que se invoca toArray (), la secuencia ya no está disponible para su uso.

2. Recopile los resultados de la transmisión en una lista / conjunto

Recopile resultados para enumerarlos usando Collectors.toList().

List<Integer> intList= lengthStream.collect(Collectors.toList());

Recopile resultados para enumerarlos usando Collectors.toSet().

Set<Integer> intSet= lengthStream.collect(Collectors.toSet());

También podemos especificar el tipo de conjunto a usar así:

TreeSet<Integer> intSet= lengthStream.collect(Collectors.toCollection(TreeSet::new));

3. Recopile los resultados de la transmisión en el mapa

List<String> list = new ArrayList<String>();
list.add("java");
list.add("php");
list.add("python");
Stream<String> wordStream = list.stream();
 
// to map
Map<String, Integer> map = wordStream.collect(Collectors.toMap(Function.identity(), s->s.length()));
System.out.println(map);

Producción:

{python=6, java=4, php=3}