Explicación detallada de Java8 Stream y ejemplos de uso de métodos de creación de transmisiones (2)

Este capítulo presenta la operación de creación de Stream: crear una secuencia se refiere al proceso de convertir una colección u otra fuente de datos en un objeto Stream. Normalmente, podemos usar los métodos estáticos de la clase Stream para crear objetos de flujo, como Stream.of(), Collections.stream(), etc. Estos métodos devuelven un objeto Stream que se puede utilizar para realizar diversas operaciones con los datos. A continuación se muestran algunas formas comunes de crear transmisiones. Ejemplo de uso del método de creación de operaciones intermedias y explicación detallada de Java8 Stream (1)

of(T... valores): crea una secuencia que consta de los elementos especificados.

vacío (): crea una secuencia vacía.

generar (Proveedor <T> s): crea una secuencia infinita, cada llamada al método get () generará nuevos datos.

iterar (T semilla, UnaryOperator<T> f): crea una secuencia infinita que aplica la función especificada en cada iteración.

concat(Stream<? extends T> a, Stream<? extends T> b): crea un flujo secuencial que contiene dos flujos, primero el flujo a y luego el flujo b.

builder(): crea un objeto Builder para construir operaciones en cadena.

ofNullable (T t): crea una secuencia que contiene cero o un elemento, el elemento es el objeto especificado (puede ser nulo).

range(int startInclusive, int endExclusive): crea una secuencia de números enteros que comienza en startInclusive (inclusivo) y termina en endExclusive (exclusivo).

rangeClosed(int startInclusive, int endInclusive): crea una secuencia de números enteros que comienza en startInclusive (inclusive) y termina en endInclusive (inclusive).

Introducción detallada al método de Stream para crear una transmisión

de(T... valores)

El método of(T...values) de Stream es un método estático que se utiliza para crear un objeto Stream secuencial que contiene los elementos especificados.

El uso específico es el siguiente:

Llame al método of(T...values) y pase uno o más elementos.

Este método devolverá un objeto Stream que contiene los elementos especificados.

Por ejemplo, el siguiente código demuestra cómo utilizar el método of() para crear un objeto Stream que contenga varios elementos:
Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5);
El código anterior creará un objeto Stream que contiene los números enteros del 1 al 5. Puede utilizar esta secuencia para operaciones posteriores según sea necesario, como filtrado, mapeo, clasificación, etc.

de(Tt)

El método of(T t) de Stream es un método estático que se utiliza para crear un objeto Stream secuencial que contiene un solo elemento.

El uso específico es el siguiente:

Llame al método of(T t) y pase un elemento.

Este método devolverá un objeto Stream que contiene los elementos especificados.

Por ejemplo, el siguiente código demuestra cómo utilizar el método of() para crear un objeto Stream que contenga un solo elemento:
Stream<String> stream = Stream.of("Hello");
El código anterior creará un objeto Stream que contiene la cadena "Hola". Puede utilizar esta secuencia para operaciones posteriores según sea necesario, como filtrado, mapeo, clasificación, etc.

vacío()

empty()El método se utiliza para crear una secuencia vacía que no contiene elementos.

A continuación se muestra un ejemplo de uso:
import java.util.stream.Stream;

public class StreamEmptyExample {
    public static void main(String[] args) {
        Stream<String> emptyStream = Stream.empty();
        System.out.println("Count: " + emptyStream.count()); // 输出 Count: 0
    }
}
El código anterior muestra cómo utilizar empty()el método para crear una secuencia vacía. Llame al método directamente Stream.empty()para obtener una secuencia vacía que no contiene ningún elemento. A continuación, use count()el método para obtener la cantidad de elementos en la secuencia, dado que la secuencia está vacía, el valor de retorno es 0. Finalmente imprímelo.

Tenga en cuenta que, dado que la secuencia no contiene elementos, cualquier operación en ella no tendrá ningún efecto y no generará ninguna excepción.

generar(Proveedor<T> s)

generate()El método es Streamun método estático de la clase que toma una Supplierfunción como argumento para generar la secuencia de elementos. generate()El método generará elementos infinitamente de acuerdo con la lógica de la función generadora, hasta que el usuario alcance o interrumpa el límite superior de la secuencia.

Por ejemplo, supongamos que necesita generar un flujo de números enteros aleatorios, puede utilizar generate()el método:
Random random = new Random();
Stream<Integer> intStream = Stream.generate(() -> random.nextInt(100));
En el código anterior, primero se crea un Randomobjeto para generar números enteros aleatorios, luego Stream.generate()se crea una nueva secuencia a través del método y se pasa una función generadora () -> random.nextInt(100)para generar números enteros aleatorios. Dado que generate()el método no limita la cantidad de elementos, esta secuencia continuará generando números enteros aleatorios hasta que se vea obligada a detenerse.

Cabe señalar que dado que generate()la secuencia generada por el método es infinita, si la secuencia no está limitada, el programa puede caer en un bucle infinito o desbordamiento de memoria y otros problemas. Si necesita convertir la secuencia en una secuencia de longitud finita, puede utilizar limit()el método o takeWhile()método.

Además, dado que generate()el método es estático, se puede llamar desde cualquier lugar para crear una nueva secuencia. Al mismo tiempo, dado que la función generadora no tiene estado, se pueden generar elementos en paralelo para mejorar la eficiencia.

iterar(T semilla, UnaryOperator<T> f)

iterate()El método es Streamun método estático en la clase que toma como parámetros un elemento inicial y una función de operación unaria para generar un flujo de elementos infinitamente consecutivos. iterate()El método toma el elemento inicial como el primer elemento de la secuencia y, en función de este elemento, genera nuevos elementos continuamente a través de la función de operación unaria.

Por ejemplo, supongamos que necesita generar una secuencia que contenga números de Fibonacci, puede usar iterate()el método para lograr:
Stream.iterate(new int[]{0, 1}, arr -> new int[]{arr[1], arr[0] + arr[1]})
      .mapToInt(arr -> arr[0])
      .limit(10)
      .forEach(System.out::println);
En el código anterior, primero se definen un elemento inicial y una función de operación unaria Stream.iterate()a través del método para generar el siguiente elemento de la secuencia de Fibonacci. Luego use el método para convertir cada elemento al primer número de la secuencia de Fibonacci y use el método para limitar el número de elementos a 10. Finalmente, cada elemento se envía a la consola mediante el método.{0, 1}arr -> new int[]{arr[1], arr[0] + arr[1]}mapToInt()limit()forEach()

Cabe señalar que dado que iterate()la secuencia generada por el método es infinita, si la secuencia no está limitada, el programa puede caer en un bucle infinito o desbordamiento de memoria y otros problemas. Si necesita convertir la secuencia en una secuencia de longitud finita, puede utilizar limit()el método o takeWhile()método.

Además, dado que las operaciones unarias no tienen estado, se pueden generar elementos en paralelo para una mayor eficiencia. Al mismo tiempo, dado que iterate()el flujo generado por el método está ordenado, no se recomienda utilizarlo en flujos paralelos.

concat(Flujo<? extiende T> a, Flujo<? extiende T> b)

StreamEl método estático en la interfaz concat(Stream<? extends T> a, Stream<? extends T> b)puede conectar dos transmisiones para formar una nueva transmisión. Esta nueva secuencia contiene todos los elementos de las dos secuencias originales, primero en el orden de la primera secuencia y luego en el orden de la segunda secuencia.

A continuación se muestra un ejemplo de uso:
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class StreamConcatExample {
    public static void main(String[] args) {
        List<String> list1 = Arrays.asList("A", "B", "C");
        List<String> list2 = Arrays.asList("D", "E", "F");

        Stream<String> stream1 = list1.stream();
        Stream<String> stream2 = list2.stream();

        Stream<String> concatStream = Stream.concat(stream1, stream2);

        List<String> result = concatStream.collect(Collectors.toList());

        System.out.println(result); // [A, B, C, D, E, F]
    }
}
El código anterior muestra concat()un ejemplo de cómo concatenar dos listas de cadenas usando el método. Primero, se crean dos listas list1y list2, y luego stream()el método las convierte en secuencias, lo que da como resultado dos secuencias stream1y stream2. Luego, concat(stream1, stream2)conecte las dos secuencias a través del método para obtener una nueva secuencia concatStreamque contenga todos los elementos de las dos secuencias originales. Finalmente, collect(Collectors.toList())los elementos de esta nueva secuencia se recopilan en una lista mediante el método, lo que da como resultado una lista que contiene todos los elementos result.

Cabe señalar que al utilizar concat()este método, es necesario asegurarse de que los tipos de elementos en las dos secuencias sean los mismos. Además, una vez que se ha manipulado una secuencia, como mediante el uso de métodos como filter, mapetc., la secuencia no se puede conectar; de lo contrario, IllegalStateExceptionse generará una excepción.

constructor()

Se utiliza para crear mutables que admitan la adición de elementos Stream.

A continuación se muestra builder()un ejemplo de uso del método:
Stream<String> stream = Stream.<String>builder()
        .add("apple")
        .add("banana")
        .add("orange")
        .build();

stream.forEach(System.out::println);
En el código anterior, primero se crea un objeto Stream.builder()y Stream.Builderluego add()se agregan tres elementos de cadena al objeto con el método. build()Finalmente, se crea un nuevo objeto llamando al método Streamy forEach()sus elementos se generan utilizando el método.

Cabe señalar que, dado que es mutable, el método solo debe usarse para crear objetos Stream.Buildercuando sea necesario . En otros casos, los objetos deben crearse utilizando colecciones o matrices inmutables para evitar problemas de concurrencia.builder()StreamStream

de Nullable(T t)

La clase Stream en Java 8 proporciona el método ofNullable(T t) para crear un objeto de flujo que contiene cero o un elemento. Este método acepta un parámetro t de tipo T, que puede ser cualquier objeto, incluido nulo. Si el parámetro t no es nulo, entonces se creará una secuencia de longitud 1 que contiene el elemento; de lo contrario, se creará una secuencia vacía, es decir, que no contiene elementos.

Este método devuelve un objeto Opcional y el objeto Stream correspondiente se puede obtener llamando a su método stream(). Si el parámetro t no es nulo, el objeto de secuencia contiene exactamente un elemento t; de lo contrario, el objeto de secuencia está vacío.

Por ejemplo, podemos usar el método ofNullable(T t) para determinar si un objeto es nulo y convertirlo en un objeto de flujo. Por ejemplo:
String str = null;
Stream<String> stream = Stream.ofNullable(str);
El código anterior creará una secuencia de objetos de flujo vacía porque str es nulo. Si str no es nulo, se crea un objeto de flujo que contiene los elementos de str.

El método ofNullable(T t) se utiliza generalmente para tratar situaciones similares cuando la fuente de datos está vacía. Por ejemplo, en la informática de transmisión, cuando la fuente de datos está vacía, se requiere un procesamiento especial. En este caso, el método ofNullable() se puede utilizar para convertirlo convenientemente en un objeto de flujo vacío. Al mismo tiempo, este método también se puede utilizar para simplificar algunas operaciones informáticas de flujo. Por ejemplo, cuando se utiliza el método filter() para filtrar valores nulos, se puede utilizar el método ofNullable() para convertir valores nulos en flujos vacíos. objetos antes de filtrar.

En resumen, el método ofNullable(T t) puede convertir convenientemente un objeto en un objeto de flujo que contiene cero o un elemento, que generalmente se usa para manejar casos de valores nulos y simplificar las operaciones de codificación.

rango(int inicioInclusivo, int finExclusivo)

range(int startInclusive, int endExclusive) es un método estático proporcionado por la clase Stream en Java 8, que se utiliza para crear un objeto de secuencia de enteros desde startInclusive (inclusivo) hasta endExclusive (exclusivo). Este método devuelve un objeto de secuencia IntStream y se pueden realizar varias operaciones en la secuencia.

A continuación se muestra un ejemplo que muestra cómo utilizar el método range() para crear una secuencia de números enteros:
IntStream intStream = IntStream.range(1, 10);
intStream.forEach(System.out::print); // 输出：123456789
En el código anterior, utilizamos el método range() para crear un objeto de flujo de secuencia de enteros del 1 al 10 y lo almacenamos en la variable intStream. Luego, llamamos al método forEach() del objeto intStream y usamos la referencia del método System.out::print para generar cada elemento por turno, obteniendo así los resultados de salida del 1 al 9.

Cabe señalar que el objeto de flujo de secuencia de enteros creado utilizando el método range() no contiene el valor final endExclusive, es decir, el intervalo está cerrado por la izquierda y abierto por la derecha. Entonces, en el ejemplo anterior, la salida es del 1 al 9, excluyendo el número 10.

rangoCerrado(int inicioInclusivo, int finalInclusivo)

rangeClosed (int startInclusive, int endInclusive) es un método estático proporcionado por la clase Stream en Java 8, que se utiliza para crear un objeto de secuencia de enteros desde startInclusive (inclusivo) hasta endInclusive (inclusivo). Este método devuelve un objeto de secuencia IntStream y se pueden realizar varias operaciones en la secuencia.

Aquí hay un ejemplo que muestra cómo usar el método rangeClosed() para crear una secuencia de números enteros:
IntStream intStream = IntStream.rangeClosed(1, 10);
intStream.forEach(System.out::print); // 输出：12345678910
En el código anterior, utilizamos el método rangeClosed() para crear un objeto de flujo de secuencia entera del 1 al 10 y lo almacenamos en la variable intStream. Luego, llamamos al método forEach() del objeto intStream y usamos la referencia del método System.out::print para generar cada elemento por turno, obteniendo así los resultados de salida del 1 al 10.

Cabe señalar que el objeto de flujo de secuencia de enteros creado utilizando el método rangeClosed() contiene el valor final endInclusive, es decir, el rango está cerrado a la izquierda y a la derecha. Entonces, en el ejemplo anterior, el resultado es del 1 al 10, incluido el número 10.