El uso de flujo de Java

Arroyo

generación de flujo

Generado por colección

List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6);
Stream<Integer> stream = list .stream();

generado por valor

Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5, 6);

generado por archivo

Stream<String> lines = Files.lines(Paths.get("data.txt"), Charset.defaultCharset());

Generado por función

• iterador

        /** 
         * 该方法通过迭代器生成无限流，需要limit方法进行截断
         * iterate: 内为迭代方法，即生成流的规则
         * limit: 参数为生成的数量
         */
        Stream<Integer> stream = Stream.iterate(0, n -> n + 2).limit(5);

• generador

        /**
         * 该方法通过迭代器生成无限流，需要limit方法进行截断
         * generate: 内为生成器方法，即生成流的规则
         * limit: 参数为生成的数量
         */
        Stream<Double> stream = Stream.generate(Math::random).limit(5);

tipo de flujo

Stream, IntStream, DoubleStream, LongStream, los cuatro tipos de flujos se heredan de BaseStream, donde Stream representa el tipo de flujo de referencia, y los cuatro tipos se pueden convertir mediante mapToObj, mapToInt, mapToDouble, mapToLong.

tipo de operación

• Operación intermedia

Una secuencia puede ir seguida de cero o más operaciones intermedias. Su propósito es principalmente abrir la secuencia, realizar algún nivel de mapeo/filtrado de datos y luego devolver una nueva secuencia para que la use la próxima operación. Este tipo de operación es inerte. El simple hecho de llamar a este tipo de método en realidad no inicia el recorrido de la transmisión. El recorrido real debe esperar hasta la operación del terminal. Las operaciones intermedias comunes incluyen filtro, mapa, etc., que se presentarán a continuación.

• operación terminal

Un flujo tiene y solo puede tener una operación de terminal. Cuando se ejecuta esta operación, el flujo se cierra y no se puede operar más. Por lo tanto, un flujo solo se puede atravesar una vez. Si desea atravesarlo, debe generar el transmitir a través de los datos de origen. La ejecución de la operación de terminal en realidad iniciará el recorrido de la secuencia.

método

filtrar

• filtrar
• El parámetro es una condición y devuelve todos los elementos donde la condición es verdadera
• Operación intermedia

        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6);
        Stream stream = list.stream().filter(i -> i > 3);
        stream.forEach(System.out::println);

resultado

4
5
6

Process finished with exit code 0

distinto

• Deduplicación
• Operación intermedia

        List<Integer> list = Arrays.asList(1, 1, 2, 3, 3, 4);
        Stream stream = list.stream().distinct();
        stream.forEach(System.out::println);

resultado

1
2
3
4

ordenado

• para ordenar
• Operación intermedia

        List<String> list = Arrays.asList("java", "python", "go");
        Stream stream;
        //自然升序
        stream = list.stream().sorted();
        stream.forEach(System.out::println);
        System.out.println("====================");

        //自然降序
        stream = list.stream().sorted(Comparator.reverseOrder());
        stream.forEach(System.out::println);
        System.out.println("====================");

        //对象升序
        stream = list.stream().sorted(Comparator.comparing(String::length));
        stream.forEach(System.out::println);
        System.out.println("====================");

        //对象降序
        stream = list.stream().sorted(Comparator.comparing(String::length).reversed());
        stream.forEach(System.out::println);
        System.out.println("====================");

        //自定义排序规则
        stream = list.stream().sorted(Comparator.comparing(s -> s.charAt(1)));
        stream.forEach(System.out::println);
        System.out.println("====================");

        //多规则排序
        stream = list.stream().sorted(Comparator.comparing(String::length).thenComparing(String::hashCode));
        stream.forEach(System.out::println);

resultado

go
java
python
====================
python
java
go
====================
go
java
python
====================
python
java
go
====================
java
go
python
====================
go
java
python

problemaMientras

• retención de ciclo
• Mantenga todos los elementos antes del primer elemento que no cumpla la condición, por lo que si la condición en el ejemplo se cambia a i>4, no se mantendrá ningún elemento y la devolución estará vacía.
• Operación intermedia

        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
        Stream<Integer> stream = list.stream().takeWhile(i -> (i < 4));
        stream.forEach(System.out::println);

resultado

1
2
3

soltar mientras

• descarte del ciclo
• Descarte todos los elementos antes del primer elemento que no cumpla la condición, por lo que si la condición en el ejemplo se cambia a i>4, no se descartará ningún elemento y el retorno es de 1 a 5
• Operación intermedia

        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
        Stream<Integer> stream = list.stream().dropWhile(i -> (i < 4));
        stream.forEach(System.out::println);

resultado

4
5

ojeada

• atravesar
• peek es una operación intermedia, y forEach es una operación terminal. La única diferencia entre las dos es que peek se usa a menudo para ayudar a la modulación.
• Operación intermedia

        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
        list.stream()
                .peek(System.out::println)
                .dropWhile(i -> (i < 4))
                .forEach(System.out::println);

resultado

1
2
3
4
4
5
5

límite

• intercepción frontal
• El parámetro es el número de elementos a devolver.
• Operación intermedia

        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6);
        Stream stream = list.stream().limit(3);
        stream.forEach(System.out::println);

resultado

1
2
3

saltar

• Después de la intercepción
• El parámetro es el número de elementos a saltar.
• Operación intermedia

        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6);
        Stream stream = list.stream().skip(2);
        stream.forEach(System.out::println);

resultado

3
4
5
6

mapa

• mapa
• Asigna un elemento a otro elemento a través del método en el argumento
• Operación intermedia

        List<String> list = Arrays.asList("java", "python", "go");
        Stream stream = list.stream().map(String::length);
        stream.forEach(System.out::println);

resultado

4
6
2

mapa plano

• flujo plano
• Convierta cada valor en un flujo, lo que puede entenderse como convertir una estructura de varias capas en un flujo de una sola capa.
• Operación intermedia

        /**
         * 经过map之后的类型为 Stream<String[]>,可以认为是两层结构
         * 经过flatMap后将map结果的流转换成扁平的单层流
         */
        List<String> list = Arrays.asList("java 17", "python 3.9", "go 1.18");
        Stream stream = list.stream()
                .map(w -> w.split(" "))
                .flatMap(Arrays::stream);
        stream.forEach(System.out::println);

resultado

java
17
python
3.9
go
1.18

todos los partidos

• coincide con todos los elementos
• El valor devuelto es booleano, si el parámetro es verdadero para todos los elementos, devuelve verdadero, de lo contrario, devuelve falso; el significado es opuesto a noneMatch
• Operación intermedia

        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
        if (list.stream().allMatch(i -> i > 4)) {
    
    
            System.out.println("所有元素值都大于4");
        } else {
    
    
            System.out.println("不是所有元素值都大于4");
        }

resultado

不是所有元素值都大于4

cualquier partido

• coincide con uno de los elementos
• El valor devuelto es booleano, si el parámetro es verdadero para cualquier elemento, devuelve verdadero, de lo contrario, devuelve falso
• Operación intermedia

        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
        if (list.stream().anyMatch(i -> i > 4)) {
    
    
            System.out.println("存在大于4的元素");
        } else {
    
    
            System.out.println("不存在大于4的元素");
        }

resultado

存在大于4的元素

ningunaCoincidencia

• todos los elementos no coinciden
• El valor devuelto es booleano, si el parámetro es falso para todos los elementos, devuelve verdadero, de lo contrario, devuelve falso; el significado opuesto de allMatch
• Operación intermedia

        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
        if (list.stream().noneMatch(i -> i > 4)) {
    
    
            System.out.println("不存在大于4的元素");
        } else {
    
    
            System.out.println("存在大于4的元素");
        }

resultado

存在大于4的元素

contar

• Número de elementos estadísticos
• Devuelve el número de elementos en la secuencia y el valor devuelto es largo
• operación terminal

        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
        long count = list.stream().count();
        System.out.println(count);

resultado

5

encontrarprimero

• encuentra el primero
• Devuelve el primer elemento, generalmente usado con filtro, devuelve el primer elemento que cumple la condición de filtro y el tipo de devolución es Opcional
• operación terminal

        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
        Optional result = list.stream().filter(i -> i > 3).findFirst();
        System.out.println(result.orElse(-1));

resultado

4

encontrar cualquier

• encontrar uno al azar
• Devuelve un elemento aleatorio, normalmente se usa con filtro, devuelve un elemento aleatorio que cumple la condición de filtro, el tipo de devolución es Opcional, en el caso de menos datos y serie, generalmente devuelve el primero, que es consistente con la devolución de findFirst; si los datos son relativamente pequeños Cuando son múltiples o paralelos, los elementos devueltos son aleatorios y findAny es más eficiente que findFirst
• operación terminal

        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
        Optional result = list.stream().filter(i -> i > 3).findAny();
        System.out.println(result.orElse(-1));

resultado

4

reducir

• Cálculo de reducción (en realidad, no sé traducirlo bien)
• El primer parámetro es el valor inicial, y el segundo parámetro es la operación, que es equivalente a agregar el valor inicial a la cabeza de la secuencia, y luego llamar al método del segundo parámetro continuamente.Es mejor entender la operación de acumulación y multiplicación
• operación terminal

        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
        int sum = list.stream()
                .reduce(0, Integer::sum);
        int product = list.stream()
                .reduce(1, (a, b)->a * b);
        System.out.println(sum);
        System.out.println(product);

resultado

15
120

máximo

• valor máximo
• Devuelve el elemento más grande, el parámetro es el método de comparación, generalmente el método de comparación
• operación terminal

        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
        Optional<Integer> max = list.stream()
                .max(Integer::compareTo);
        System.out.println(max.orElse(-1));

resultado

5

min

• valor mínimo
• Devuelve el elemento más pequeño, el parámetro es el método de comparación, generalmente el método de comparación
• operación terminal

        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
        Optional<Integer> min = list.stream()
                .min(Integer::compareTo);
        System.out.println(min.orElse(-1));

resultado

1

para cada

• atravesar
• operación terminal

        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
        list.forEach(System.out::println);

resultado

1
2
3
4
5

recolectar

• colección de devolución
• operación terminal

        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
        List<Integer> intList = list.stream()
                .collect(Collectors.toList());

A través del método Collectors.toXXX(), se puede convertir a otros tipos de colección, como:

toList: convertir a lista

toSet: convertir a Set

toMap: convertir a Mapa

unión

• puntadas
• Une los elementos por parámetros
• recoger la operación

        List<String> list = Arrays.asList("java 17", "python 3.9", "go 1.18");
        String str = list.stream()
                .collect(Collectors.joining(";"));
        System.out.println(str);

resultado

java 17;python 3.9;go 1.18

agrupar por

• grupo
• Agrupe los elementos de acuerdo con las reglas de los parámetros, los métodos de agrupación se pueden anidar y personalizar
• recoger la operación

        //单层分组
        List<String> list = Arrays.asList("java", "python", "go", "delphi", "groovy", "perl");
        Map<Integer, List<String>> map = list.stream()
                .collect(Collectors.groupingBy(String::length));
        System.out.println(map);
        System.out.println("===================");

//        //两层分组，二层为自定义条件
        Map<Integer, Map<String, List<String>>> map2 = list.stream()
                .collect(Collectors.groupingBy(String::length,
                        Collectors.groupingBy(s -> s.charAt(0) + "")));
        System.out.println(map2);

resultado

{
    
    2=[go], 4=[java, perl], 6=[python, delphi, groovy]}
===================
{
    
    2={
    
    g=[go]}, 4={
    
    p=[perl], j=[java]}, 6={
    
    p=[python], d=[delphi], g=[groovy]}}

particiónPor

• grupo
• Los parámetros se devuelven como booleanos, agrupados según el valor booleano y se pueden dividir en dos grupos como máximo
• recoger la operación

        List<String> list = Arrays.asList("java", "python", "go", "delphi", "groovy", "perl");
        Map<Boolean, List<String>> map = list.stream()
                .collect(Collectors.partitioningBy(s -> s.length() > 4));
        System.out.println(map);

resultado

{
    
    false=[java, go, perl], true=[python, delphi, groovy]}