Nuevas funciones de Java 8 de Stream API combat
Tabla de contenido
1. Descripción general de la transmisión
3.1 Recorrido y coincidencia (foreach, find, match)
3.3 Agregación (máximo, mínimo, recuento)
3.5 Reducir (reducir). operación map-reduce.
3.6.1 Colección (toList, toSet, toMap)
3.6.2 Estadísticas (recuento, promediación)
3.6.3 Agrupar y particionar (particionar por, agrupar por)
4. Java tiene 4 interfaces funcionales centrales integradas
1. Descripción general de la transmisión
Hay dos actualizaciones más importantes en Java 8. La primera es la expresión Lambda y la otra es la expresión Steam API. Stream es un concepto abstracto clave para procesar colecciones en Java 8. Puede especificar las operaciones que desea realizar en la colección, que pueden ser varias operaciones como buscar, filtrar y mapear datos. El uso de Stream API para operar con datos de recopilación es similar al uso de SQL para realizar consultas a la base de datos. En resumen, la API Stream proporciona un método de procesamiento de datos eficiente y fácil de usar.
Stream Puede ser creado por una matriz o una colección, y hay dos tipos de operaciones en la secuencia:
(1) Operación intermedia: cada operación intermedia devuelve una nueva secuencia y puede haber varias operaciones intermedias.
(2) Operación de terminación: Cada flujo solo se puede terminar una vez y el flujo no se puede usar nuevamente después de la operación de terminación. Terminar la operación producirá un nuevo conjunto o valor.
Además, Stream existen las siguientes características:
(1) Stream no almacena datos, pero calcula datos de acuerdo con reglas específicas y generalmente genera el resultado.
(2) Stream no cambia la fuente de datos y, por lo general, genera un nuevo conjunto o un valor.
(3) Stream tiene características de ejecución retrasada (es decir, operaciones diferidas), y solo cuando se llama a la operación de terminación, se ejecutará una serie de operaciones intermedias en una sola mente.
2. La creación de Stream
StreamPuede ser creado por colección o matriz.
1. java.util.Collection.stream() Crea una transmisión con una colección mediante un método
List<String> list = Arrays.asList("a", "b", "c");
// 创建一个顺序流
Stream<String> stream = list.stream();
// 创建一个并行流
Stream<String> parallelStream = list.parallelStream();2. Cómo usar java.util.Arrays.stream(T[] array)una matriz para crear una secuencia
int[] array={1,3,5,6,8};
IntStream stream = Arrays.stream(array);3. StreamEl método estático utilizado para crear una transmisión:Stream.of()、Stream.iterate()、Stream.generate()
Stream<Integer> stream00 = Stream.of(1, 2, 3);
stream00.forEach(System.out::println); //1 2 3
Stream<Integer> stream11 = Stream.iterate(0, (x) -> x + 2).limit(4);
stream11.forEach(System.out::println); //0 2 4 6
Stream<Double> stream33 = Stream.generate(Math::random).limit(3);
stream33.forEach(System.out::println);// 0.6796156909271994 0.1914314208854283 0.8116932592396652stream Y parallelStream simple de distinguir: streamuna secuencia de convección de flujo por el hilo principal con el fin de realizar operaciones, y parallelStreames una ejecución paralela de flujos paralelos con subprocesos internos de modo de convección de funcionamiento múltiple, pero solo en el flujo de procesamiento de datos en cualquier secuencia. Por ejemplo, al filtrar números impares en la colección, existen diferencias entre los dos. Si la cantidad de datos en el flujo es lo suficientemente grande, el flujo paralelo puede acelerar el procesamiento. Además de crear flujos paralelos directamente, también puede parallel()convertir flujos secuenciales en flujos paralelos:
Optional<Integer> findFirst = list.stream().parallel().filter(x->x>6).findFirst();3. Uso de Stream
Antes de utilizar la corriente, para entender un concepto: Optional .
OptionalUna clase es unnullobjeto contenedor que se puede utilizar . Si el valor existe, elisPresent()método regresarátruey llamar alget()método en este momento devolverá el valor en el objeto. Para obtener una descripción más detallada, consulte: Tutorial para principiantes Clase opcional de Java 8
La clase de empleado utilizada en el caso, esta es la clase de empleado utilizada en el siguiente caso:
public class Person implements Serializable {
private static final long serialVersionUID = 5675706507473016778L;
private String name; // 姓名
private int salary; // 薪资
private int age; // 年龄
private String sex; // 性别
private String area; // 地区
public Person() {
}
public Person(String name, int salary, int age, String sex, String area) {
this.name = name;
this.salary = salary;
this.age = age;
this.sex = sex;
this.area = area;
}
}3.1 Recorrido y coincidencia (foreach, find, match)
StreamTambién admite elementos transversales y coincidentes de colecciones similares, pero Streamlos elementos que Optionalcontiene existen en tipos. StreamEl recorrido, la coincidencia y la búsqueda es muy simple.
List<Integer> list = Arrays.asList(7, 6, 9, 3, 8, 1, 2);
//遍历输出符合条件的元素
list.stream()
.filter(Objects::nonNull)
.filter(x -> x > 6)
.forEach(y -> System.out.print(y + " "));
System.out.println();
System.out.println("===================================");
//匹配第一个
Optional<Integer> findFirst = list.stream()
.filter(Objects::nonNull)
.filter(x -> x > 6)
.findFirst();
System.out.println("匹配第一个值：" + (findFirst.isPresent() ? findFirst.get() : -1));
System.out.println("===================================");
//匹配任意一个
Optional<Integer> findAny = list.stream()
.filter(Objects::nonNull)
.filter(x -> x > 6)
.findAny();
System.out.println("匹配任意一个值：" + (findAny.isPresent() ? findAny.get() : -1));
System.out.println("===================================");
//是否包含符合特定条件的元素
boolean anyMatch = list.stream()
.filter(Objects::nonNull)
.anyMatch(x -> x > 16);
System.out.println("是否存在大于6的值：" + anyMatch);
System.out.println("===================================");
3.2 Filtro
El filtrado consiste en comprobar los elementos de la secuencia Stream de acuerdo con determinadas reglas y extraer los elementos que cumplen las condiciones en la nueva secuencia.
//案例一：筛选出Integer集合中大于7的元素，并打印出来
list.stream()
.filter(Objects::nonNull)
.filter(x -> x > 7)
.forEach(y -> System.out.print(y + " "));
System.out.println();
System.out.println("===================================");
//案例二： 筛选员工中工资高于8000的人，并形成新的集合。 形成新集合依赖collect（收集），后文有详细介绍。
List<Person> personList = Arrays.asList(
new Person("Tom", 8900, 23, "male", "New York"),
new Person("Jack", 7000, 25, "male", "Washington"),
new Person("Lily", 7800, 21, "female", "Washington"),
new Person("Anni", 8200, 24, "female", "New York"),
new Person("Owen", 9500, 25, "male", "New York"),
new Person("Alisa", 7900, 26, "female", "New York"),
null
);
List<String> nameList = personList.stream()
.filter(Objects::nonNull)
.filter(x -> x.getSalary() > 8000)
.map(Person::getName)
.collect(Collectors.toList());
System.out.println("高于8000的员工姓名：" + nameList);
System.out.println("===================================");
3.3 Agregación (máximo, mínimo, recuento)
max, min, count Estas palabras que ellos utilizan en datos estadísticos MySQL. Estos conceptos y su uso también se introducen en la API de flujo de Java, lo que facilita enormemente nuestro trabajo de estadísticas de datos en colecciones y matrices.
//案例一：获取String集合中最长的元素。
List<String> stringList = Arrays.asList("adnm", "admmt", "pot", "xbangd", "weoujgsd");
Optional<String> maxLength = stringList.stream()
.filter(Objects::nonNull)
.max(Comparator.comparing(String::length));
System.out.println("最长的字符串：" + (maxLength.isPresent() ? maxLength.get() + "的长度=" + maxLength.get().length() : -1));
//案例二：获取Integer集合中的最大值。
List<Integer> integers = Arrays.asList(7, 6, 9, 4, 11, 6);
//(1)自然排序
Optional<Integer> maxInteger = integers.stream()
.filter(Objects::nonNull)
.max(Integer::compareTo);
System.out.println("自然排序的最大值：" + (maxInteger.isPresent() ? maxInteger.get() : -1));
//(2)自定义排序
Optional<Integer> maxInteger2 = integers.stream()
.filter(Objects::nonNull)
.max((o1, o2) -> o1 > o2 ? 1 : (o1 < o2 ? -1 : 0));
System.out.println("自定义排序的最大值：" + (maxInteger2.isPresent() ? maxInteger2.get() : -1));
//案例三：获取员工工资最低的人。
Optional<Person> maxSalaryPerson = personList.stream()
.filter(Objects::nonNull)
.min(Comparator.comparing(Person::getSalary));
System.out.println("员工工资最低值：" + maxSalaryPerson.get().getSalary());
//案例四：计算Integer集合中大于6的元素的个数。
List<Integer> integers2 = Arrays.asList(7, 6, 9, 4, 11, 6);
long count = integers2.stream()
.filter(Objects::nonNull)
.filter(x -> x > 6).count();
System.out.println("integers2中大于6的元素个数：" + count);
System.out.println("===================================");
3.4 Mapeo (mapa, flatMap)
El mapeo puede mapear elementos de un flujo a otro flujo de acuerdo con ciertas reglas de mapeo, que se pueden dividir en mapeo de mapa y mapeo de mapa plano.
(1) mapa: recibe una función como parámetro, la función se aplicará a cada elemento y lo mapeará en un nuevo elemento.
(2) flatMap: Reciba una función como parámetro, convierta cada elemento del flujo en otro flujo y luego conecte todos los flujos en un flujo.
//案例一：英文字符串数组的元素全部改为大写。整数数组每个元素+3。
String[] strArr = {"abcd", "bcdd", "defde", "fTr"};
List<String> strList = Arrays.stream(strArr)
.filter(Objects::nonNull)
.map(String::toUpperCase)
.collect(Collectors.toList());
System.out.println("每个元素转为大写：" + strList);
List<Integer> intList = Arrays.asList(1, 3, 5, 7, 9, 11);
List<Integer> intListNew = intList.stream()
.filter(Objects::nonNull)
.map(x -> x + 3)
.collect(Collectors.toList());
System.out.println("每个元素+3后：" + intListNew);
//案例二：将员工的薪资全部增加1000。
//方法1:不改变原来员工集合的方式(不改变数据源)
List<Person> personListNew = personList.stream()
.filter(Objects::nonNull)
.map(person -> {
Person personNew = new Person(person.getName(), 0, 0, null, null);
personNew.setSalary(person.getSalary() + 1000);
return personNew;
}).collect(Collectors.toList());
System.out.println("一次改动前：" + personList.get(0).getName() + "-->" + personList.get(0).getSalary());
System.out.println("一次改动后：" + personListNew.get(0).getName() + "-->" + personListNew.get(0).getSalary());
//方法2:改变原来员工集合的方式(改变了数据源)
List<Person> personListNew2 = personList.stream()
.filter(Objects::nonNull)
.peek(person -> person.setSalary(person.getSalary() + 1000))
.collect(Collectors.toList());
System.out.println("二次改动前：" + personList.get(0).getName() + "-->" + personListNew.get(0).getSalary());
System.out.println("二次改动后：" + personListNew2.get(0).getName() + "-->" + personListNew.get(0).getSalary());
System.out.println("===================================");
List<String> collectTemp = Stream.of("one", "two", "three", "four")
.filter(Objects::nonNull)
.filter(e -> e.length() > 3)
.peek(e -> System.out.println("Filtered value: " + e))
.map(String::toUpperCase)
.peek(e -> System.out.println("Mapped value: " + e))
.collect(Collectors.toList());
System.out.println("peek: " + collectTemp);
System.out.println("===================================");
//案例三：将两个字符数组合并成一个新的字符数组。
List<String> list1 = Arrays.asList("m-k-l-a", "1-3-5-7");
List<String> list1New = list1.stream()
.filter(Objects::nonNull)
.flatMap(s -> Arrays.stream(s.split("-")))
.collect(Collectors.toList());
System.out.println("处理前的集合：" + list1);
System.out.println("处理后的集合：" + list1New);
System.out.println("===================================");
3.5 Reducir (reducir). operación map-reduce.
La reducción, también llamada reducción, es reducir un flujo a un valor, que puede implementar operaciones como la suma, el producto y el valor máximo de un conjunto. En comparación con el método de reducción proporcionado por la propia secuencia, el método de reducción proporcionado por la clase Collectors agrega compatibilidad con la reducción personalizada.
//案例一：求Integer集合的元素之和、乘积、最大值。
List<Integer> integerList = Arrays.asList(1, 3, 2, 8, 11, 4);
//求和方式一
Optional<Integer> sum1 = integerList.stream()
.filter(Objects::nonNull)
.reduce((x, y) -> x + y);
//求和方式二
Optional<Integer> sum2 = integerList.stream()
.filter(Objects::nonNull)
.reduce(Integer::sum);
//求和方式三
Integer sum3 = integerList.stream()
.filter(Objects::nonNull)
.reduce(0, Integer::sum);
System.out.printf("list求和：%d,%d,%d%n", sum1.get(), sum2.get(), sum3);
//求乘积
Optional<Integer> product = integerList.stream()
.filter(Objects::nonNull)
.reduce((x, y) -> x * y);
System.out.printf("list求积：%d%n", product.get());
//求最大值方式1
Integer max1 = integerList.stream()
.filter(Objects::nonNull)
.reduce(1, Integer::max);
//求最大值方式2
Optional<Integer> max2 = integerList.stream()
.filter(Objects::nonNull)
.reduce((x, y) -> x > y ? x : y);
System.out.println("list求和：" + max1 + ", " + max2);
//案例二：求所有员工的工资之和和最高工资。
//求工资之和方式1：
Optional<Integer> sumSalary = personList.stream().filter(Objects::nonNull).map(Person::getSalary).reduce(Integer::sum);
//求工资之和方式2：
Integer sumSalary2 = personList.stream().filter(Objects::nonNull).reduce(0, (sum, p) -> sum += p.getSalary(), (sum11, sum22) -> sum11 + sum22);
//求工资之和方式3：
Integer sumSalary3 = personList.stream().filter(Objects::nonNull).reduce(0, (sum, p) -> sum += p.getSalary(), Integer::sum);
System.out.println("工资之和：" + sumSalary.get() + "," + sumSalary2 + "," + sumSalary3);
//求最高工资方式1：
Optional<Integer> maxSalary = personList.stream().filter(Objects::nonNull).map(Person::getSalary).reduce(Integer::max);
Optional<Integer> minSalary = personList.stream().filter(Objects::nonNull).map(Person::getSalary).reduce(Integer::min);
//求最高工资方式2：
Integer maxSalary2 = personList.stream().filter(Objects::nonNull).reduce(0, (max, p) -> max > p.getSalary() ? max : p.getSalary(), Integer::max);
//求最高工资方式3：
Integer maxSalary3 = personList.stream().filter(Objects::nonNull).reduce(0, (max, p) -> max > p.getSalary() ? max : p.getSalary(), (max11, max22) -> max11 > max22 ? max11 : max22);
System.out.println("最高工资：" + maxSalary.get() + "," + minSalary.get() + "," + maxSalary2 + "," + maxSalary3);
System.out.println("===================================");
3.6 Recoger
collect, Se puede decir que la colección es la parte más versátil y rica en funciones. Para entenderlo literalmente, significa recopilar un flujo y, finalmente, se puede recopilar en un valor o se puede recopilar en una nueva recopilación.
Collect se basa principalmente en métodos estáticos integrados en la clase java.util.stream.Collectors.
3.6.1 Colección (toList, toSet, toMap)
Debido a que la secuencia no almacena datos, una vez que se procesan los datos de la secuencia, los datos de la secuencia deben recopilarse en una nueva colección. toList, toSet y toMap se utilizan con más frecuencia, y hay usos más complejos como toCollection y toConcurrentMap.
List<Integer> list3 = Arrays.asList(1, 6, 3, 4, 6, 7, 9, 6, 20);
List<Integer> listNew = list3.stream()
.filter(Objects::nonNull)
.filter(x -> x % 2 == 0)
.collect(Collectors.toList());
Set<Integer> listSet = list3.stream()
.filter(Objects::nonNull)
.filter(x -> x % 2 == 0)
.collect(Collectors.toSet());
HashSet<Integer> listHashSet = list3.stream()
.filter(Objects::nonNull)
.filter(x -> x % 2 == 0)
.collect(Collectors.toCollection(HashSet::new));
System.out.println("toList: " + listNew + "，toSet: " + listSet + "，listHashSet: " + listHashSet);
Map<String, Person> personMap = personList.stream()
.filter(Objects::nonNull)
.filter(p -> p.getSalary() > 9500)
.collect(Collectors.toMap(Person::getName, p -> p));
System.out.println("toMap: " + personMap);
System.out.println("===================================");
3.6.2 Estadísticas (recuento, promediación)
CollectorsProporciona una serie de métodos estáticos para estadísticas de datos:
-
contar:
count -
averagingIntMedia:averagingLong,,averagingDouble -
Mayor
maxByvalor:,minBy -
summingIntSuma:summingLong,,summingDouble -
Todos los valores estadísticos
summarizingIntanteriormente:summarizingLong,,summarizingDouble
//案例：统计员工人数、平均工资、工资总额、最高工资。
List<Person> personDtoList = Arrays.asList(
new Person("Tom8", 8000, 23, "male", "New York"),
new Person("Jack7", 7000, 25, "male", "Washington"),
new Person("Lily7", 7500, 21, "female", "Washington"),
new Person("Anni9", 9000, 22, "female", "New York"),
new Person("Owen9", 9000, 21, "male", "New York"),
new Person("Alisa10", 10000, 21, "female", "New York"),
null
);
//求员工总数
long countPerson = personDtoList.stream()
.filter(Objects::nonNull)
.count();
//求平均工资
float averagePerson = personDtoList.stream()
.filter(Objects::nonNull)
.collect(Collectors.averagingLong(Person::getSalary)).floatValue();
//求最高工资
OptionalLong maxPerson = personDtoList.stream()
.filter(Objects::nonNull)
.mapToLong(Person::getSalary).max();
//求工资之和
long sumPerson = personDtoList.stream()
.filter(Objects::nonNull)
.mapToLong(Person::getSalary).sum();
//一次性统计上述所有信息
LongSummaryStatistics collect = personDtoList.stream()
.filter(Objects::nonNull)
.collect(Collectors.summarizingLong(Person::getSalary));
System.out.println("员工总数：" + countPerson);
System.out.println("员工平均工资：" + averagePerson);
System.out.println("员工最高工资：" + maxPerson);
System.out.println("员工工资总和：" + sumPerson);
System.out.println("员工工资所有统计：" + collect);
System.out.println("===================================");
3.6.3 Agrupar y particionar (particionar por, agrupar por)
-
Zonificación: La
streamprensa se divide en dos condicionesMap, como el salario de los empleados es superior a 8000 dividido en dos partes. -
Agrupación: divida la colección en varios mapas, como agrupar a los empleados por género. Hay agrupación de un solo nivel y agrupación de varios niveles.
//将员工按薪资是否高于8000分组
Map<Boolean, List<Person>> booleanPersonListMap = personDtoList.stream()
.filter(Objects::nonNull)
.collect(Collectors.partitioningBy(p -> p.getSalary() > 8000));
System.out.println("员工按薪资是否大于8000分组情况：" + booleanPersonListMap);
//将员工按性别分组
Map<String, List<Person>> sexPersonListMap = personDtoList.stream()
.filter(Objects::nonNull)
.collect(Collectors.groupingBy(Person::getSex));
System.out.println("员工按性别分组情况：" + sexPersonListMap);
//将员工先按性别分组，再按地区分组
Map<String, Map<String, List<Person>>> sexMapAreaPersonListMap = personDtoList.stream()
.filter(Objects::nonNull)
.collect(Collectors.groupingBy(Person::getSex, Collectors.groupingBy(Person::getArea)));
System.out.println("员工按性别、地区：" + sexMapAreaPersonListMap);员工按薪资是否大于8000分组情况：{false=[Person{name='Tom8', salary=8000, age=23, sex='male', area='New York'}, Person{name='Jack7', salary=7000, age=25, sex='male', area='Washington'}, Person{name='Lily7', salary=7500, age=21, sex='female', area='Washington'}], true=[Person{name='Anni9', salary=9000, age=22, sex='female', area='New York'}, Person{name='Owen9', salary=9000, age=21, sex='male', area='New York'}, Person{name='Alisa10', salary=10000, age=21, sex='female', area='New York'}]}
员工按性别分组情况：{female=[Person{name='Lily7', salary=7500, age=21, sex='female', area='Washington'}, Person{name='Anni9', salary=9000, age=22, sex='female', area='New York'}, Person{name='Alisa10', salary=10000, age=21, sex='female', area='New York'}], male=[Person{name='Tom8', salary=8000, age=23, sex='male', area='New York'}, Person{name='Jack7', salary=7000, age=25, sex='male', area='Washington'}, Person{name='Owen9', salary=9000, age=21, sex='male', area='New York'}]}
员工按性别、地区：{female={New York=[Person{name='Anni9', salary=9000, age=22, sex='female', area='New York'}, Person{name='Alisa10', salary=10000, age=21, sex='female', area='New York'}], Washington=[Person{name='Lily7', salary=7500, age=21, sex='female', area='Washington'}]}, male={New York=[Person{name='Tom8', salary=8000, age=23, sex='male', area='New York'}, Person{name='Owen9', salary=9000, age=21, sex='male', area='New York'}], Washington=[Person{name='Jack7', salary=7000, age=25, sex='male', area='Washington'}]}}
3.6.4 Unirse
joining Los elementos de la secuencia se pueden concatenar en una cadena con un conector específico (o directamente concatenar si no).
//将员工的姓名连接成字符串
String nameStr = personDtoList.stream()
.filter(Objects::nonNull)
.map(Person::getName)
.collect(Collectors.joining());
//将员工的姓名连接成字符串，用","拼接
String nameStr2 = personDtoList.stream()
.filter(Objects::nonNull)
.map(Person::getName)
.collect(Collectors.joining(","));
System.out.println("拼接后的字符串：nameStr=" + nameStr + "。nameStr2=" + nameStr2);
List<String> strings = Arrays.asList("A", "B", "C");
String string = strings.stream().collect(Collectors.joining("-"));
System.out.println("拼接后的字符串：" + string);
//规约操作
Integer sumC = personDtoList.stream()
.filter(Objects::nonNull)
.map(Person::getSalary)
.reduce(0, (i, j) -> (i + j - 5000));
System.out.println("员工扣税薪资总和：" + sumC);
Optional<Integer> sumC2 = personDtoList.stream()
.filter(Objects::nonNull)
.map(Person::getSalary)
.reduce(Integer::sum);
System.out.println("员工薪资总和：" + (sumC2.isPresent() ? sumC2.get() : 0));
System.out.println("===================================");
3.7 ordenado
operación intermedia clasificada . Hay dos tipos:
-
sorted (): clasificación natural, los elementos de la secuencia deben implementar la interfaz Comparable
-
sorted (Comparator com): clasificación personalizada del clasificador comparador
List<Person> personDtoList2 = Arrays.asList(
new Person("Tom8", 8000, 23, "male", "New York"),
new Person("Lily7", 7000, 21, "female", "Washington"),
new Person("Anni9", 9000, 22, "female", "New York"),
new Person("Owen9", 9000, 21, "male", "New York"),
new Person("Alisa10", 10000, 21, "female", "New York"),
null
);
//案例：将员工按工资由高到低（工资一样则按年龄由大到小）排序
//按工资增序排序
List<String> salaryList = personDtoList2.stream()
.filter(Objects::nonNull)
.sorted(Comparator.comparing(Person::getSalary))
.map(Person::getName)
.collect(Collectors.toList());
System.out.println("按工资自然排序：" + salaryList);
//按工资倒序排序
List<String> salaryList2 = personDtoList2.stream()
.filter(Objects::nonNull)
.sorted(Comparator.comparing(Person::getSalary).reversed())
.map(Person::getName)
.collect(Collectors.toList());
System.out.println("按工资降序排序：" + salaryList2);
//先按工资自定义倒排再按年龄自定义倒排(从大到小)
List<String> salaryList4 = personDtoList2.stream()
.filter(Objects::nonNull)
.sorted((p1, p2) -> p1.getSalary() == p2.getSalary() ? p2.getAge() - p1.getAge() : p2.getSalary() - p1.getSalary())
.map(Person::getName)
.collect(Collectors.toList());
System.out.println("先按工资自定义倒排再按年龄自定义倒排：" + salaryList4);
System.out.println("===================================");
3.8 Extracción y combinación
Las transmisiones también se pueden fusionar, deduplicar, restringir, omitir, etc.
String[] arr1 = {"a", "b", "c", "d"};
String[] arr2 = {"d", "e", "f", "g"};
List<String> collect1 = Stream.of(arr1, arr2)
.filter(Objects::nonNull)
.flatMap(Arrays::stream)
.collect(Collectors.toList());
System.out.println("flatMap合并为一个流，其中的元素就是一个个真实的元素：" + collect1);
Stream<String> stream1 = Stream.of(arr1);
Stream<String> stream2 = Stream.of(arr2);
//concat:合并两个流，去重
List<String> collect2 = Stream.concat(stream1, stream2)
.filter(Objects::nonNull)
.distinct()
.collect(Collectors.toList());
System.out.println("流合并，不去重：" + collect2);
//concat:合并两个流，distinct：去重
List<String> collect3 = Stream.concat(Stream.of(arr1), Stream.of(arr2))
.filter(Objects::nonNull)
.collect(Collectors.toList());
System.out.println("流合并，去重：" + collect3);
//limit：限制从流中获得前n个数据
List<String> collect4 = Stream.concat(Stream.of(arr1), Stream.of(arr2))
.filter(Objects::nonNull)
.distinct()
.limit(3)
.collect(Collectors.toList());
System.out.println("limit：" + collect4);
//skip：跳过前n个数据
List<String> collect5 = Stream.concat(Stream.of(arr1), Stream.of(arr2))
.filter(Objects::nonNull)
.distinct()
.sorted()
.skip(3)
.collect(Collectors.toList());
System.out.println("skip：" + collect5);
4. Java tiene 4 interfaces funcionales centrales integradas
Referencia: https://blog.csdn.net/cmm0401/article/details/109382942
5. Consulte la wiki, gracias
https://blog.csdn.net/mu_wind/article/details/109516995