Conceptos básicos de Java: flujo de flujo

(1) Descripción general de la transmisión:

1. ¿Qué es Corriente?

• API para operaciones simplificadas de recopilación y matriz. Combinado con expresiones lambda.
• Un medio para facilitar la operación de colecciones/matrices (las colecciones/matrices son el propósito del desarrollo).

 2. Experimente el papel de Stream:

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

/**
 * 体验stream流作用
 */
public class StreamDemo01 {
    public static void main(String[] args) {
        //需求：找到名字是小开头的，且长度为3的元素
        List<String> names = new ArrayList<>();
        Collections.addAll(names,"小小","小心心","小星星","大大");
        System.out.println(names);

        //1.遍历查找：
        //1.1从集合中找出小开头的元素放到新集合
        List<String> xiaoList = new ArrayList<>();
        for (String name : names) {
            if (name.startsWith("小")){
                xiaoList.add(name);
            }
        }
        //1.2从小开头的名字集合中找到长度为3的元素放到新集合
        List<String> xiaoThreeList = new ArrayList<>();
        for (String s : xiaoList) {
            if (s.length() == 3){
                xiaoThreeList.add(s);
            }
        }
        System.out.println(xiaoThreeList);

        //2.使用stream流方法     filter:进行过滤     forEach:对每个元素进行输出
        names.stream().filter(s -> s.startsWith("小")).filter(s -> s.length() == 3).forEach(s -> System.out.println(s));
    }
}

3. Corriente de pensamiento:

• Primero obtenga el flujo Stream de la colección o matriz. (Como una cinta transportadora, filtro y filtro una y otra vez, y luego salida)
• Ponle el elemento.
• Luego use esta API optimizada para manipular elementos de manera conveniente. 

(2) Adquisición de Stream:

El primer paso para que Stream opere una colección o matriz es obtener primero el flujo de Stream, y luego se puede usar la función de flujo.

1. Tres tipos de métodos Stream:

• Obtener el flujo de Stream:
  • Cree una canalización y coloque los datos en la canalización listos para funcionar.
• Método intermedio:
  • operaciones en el oleoducto. Después de completar una operación, se pueden continuar otras operaciones.
• Método de terminación:
  • Un flujo solo puede tener un método final, que es la última operación en la canalización.

2. La forma en que la colección obtiene el Stream:

• Las secuencias se pueden generar utilizando el método predeterminado stream() en la interfaz de la colección.

nombre	ilustrar
secuencia predeterminada<E> secuencia()	Obtener el Stream del objeto de colección actual

3. La forma de obtener el Stream de la matriz:

nombre	ilustrar
public static <T> Stream<T> stream(T[] array)	Obtener el Stream de la matriz actual
public static<T> Stream<T> of(T... valores)	Obtener el Stream de la matriz actual/datos variables

import java.util.*;
import java.util.stream.Stream;

/**
 * 获取Stream流
 */
public class StreamDemo02 {
    public static void main(String[] args) {
        //1.集合获取Stream流
        //1.1Collection集合获取流
        Collection<String> list = new ArrayList<>();
        Stream<String> s = list.stream();

        //1.2Map集合获取流
        Map<String,Integer> maps = new HashMap<>();
        //对键获取流
        Stream<String> keyStream = maps.keySet().stream();
        //对值获取流
        Stream<Integer> valueStream = maps.values().stream();
        //键值对流 entrySet()==>将Map转Set
        Stream<Map.Entry<String,Integer>> kvStream = maps.entrySet().stream();

        //2.数组获取流
        String[] names = {"大大","小小","青青","晨晨"};
        Stream<String> arrStream = Arrays.stream(names);//方式1
        Stream<String> arrStream01 = Stream.of(names);//方式2

    }
}

4. API de Stream de uso común (método de operación intermedia)

• El método intermedio también se denomina método no terminal. Una vez que se completa la llamada, se devuelve un nuevo Stream y se puede usar de forma continua, lo que admite la programación en cadena.
• Los datos en colecciones y matrices no se pueden modificar directamente en Stream.

nombre	ilustrar
Filtro Stream<T> (predicado <? super T> predicado)	Se utiliza para filtrar los datos en la transmisión.
Límite de flujo <T> (tamaño máximo largo)	Consigue los primeros elementos
Stream<T> skip(long n)	salta los primeros elementos
Flujo<T> distinto()	Elimine elementos duplicados en la transmisión, según (hashCode y métodos equals)
static <T> Stream<T> concat(Stream a,Stream b)	Combinar dos secuencias a y b en una secuencia

import java.util.ArrayList;
import java.util.List;
import java.util.function.Consumer;
import java.util.function.Predicate;
import java.util.stream.Stream;

/**
 * Stream流常用的API
 */
public class StreamDemo03 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("大大");
        list.add("小小");
        list.add("小青青");
        list.add("小晨晨");

        //找出集合元素以小开头的元素
        //1. 用于对流中的数据进行过滤 Stream<T> filter(Predicate<? super T> predicate)
//        list.stream().filter(new Predicate<String>() {
//            @Override
//            public boolean test(String s) {
//                return s.startsWith("小");
//            }
//        });

        //简化1
//
//        list.stream().filter( s -> s.startsWith("小")).forEach(new Consumer<String>() {
//            @Override
//            public void accept(String s) {
//                System.out.println(s);
//            }
//        });

        //简化2
        list.stream().filter( s -> s.startsWith("小")).forEach( s -> System.out.println(s));

        //统计集合元素长度等于3的个数
        long size = list.stream().filter(s -> s.length() == 3).count();
        System.out.println(size);

        //2.获取前几个元素 Stream<T> limit(long maxSize)
        //list.stream().filter(s -> s.startsWith("小")).limit(2).forEach(s -> System.out.println(s));
        //简化
        list.stream().filter(s -> s.startsWith("小")).limit(2).forEach(System.out::println);

        //3.跳过前几个元素  Stream<T> skip(long n)
        list.stream().filter(s -> s.startsWith("小")).skip(2).forEach(System.out::println);

        //4.map加工方法：第一个参数是原材料，第二个参数是加工后的结果
        //给集合元素前面加一个，我的
        list.stream().map(s -> "我的" + s).forEach(System.out::println);

        //5.合并a和b两个流为一个流    static <T> Stream<T> concat(Stream a,Stream b)
        Stream<String> s1 = list.stream().filter(s -> s.startsWith("小"));
        Stream<Integer> s2 = Stream.of(1,2);
        Stream<Object> s3 = Stream.concat(s1,s2);
        s3.forEach(System.out::println);
    }
}

5. El último método de operación común de Stream:

• El último método de operación, la transmisión no se puede usar después de que se complete la llamada, porque la transmisión no se devolverá

nombre	ilustrar
void forEach (acción del consumidor)	realiza una operación transversal en cada elemento de este flujo
cuenta larga()	devuelve el número de elementos en esta secuencia

(3) Colección de secuencias: 

1. El significado de coleccionar Stream:

• El significado de recopilar el flujo de Stream es transferir los datos de resultados después de la operación de flujo de Stream de vuelta a la colección o matriz.

2. Método de recopilación de secuencias:

nombre	ilustrar
R recoger (coleccionista de coleccionista)	Comience a recopilar Streams y especifique recopiladores

La clase de herramienta Collectors proporciona métodos de recopilación específicos:

nombre	ilustrar
public static <T> Collector toList()	Recopilar los elementos en la colección List
public static <T> Collector toSet()	Recoge los elementos en la colección Set
Collector toMap estático público (Mapeador de teclas de función, Mapeador de valores de función)	Recoge los elementos en la colección de mapas.

================================================== =