6、终止Stream流
1、终止操作
这是Stream操作中的最后一步，终止操作,终止操作会从流的流水线生成结果。其结果可以是任何不是流的值，例如：List，Integer，void
2、查找与匹配
2.1、方法介绍
| 方法名 | 介绍 | 返回类型 |
|---|---|---|
| allMatch | 检查是否匹配所有元素 | boolean |
| anyMatch | 检查是否至少匹配一个元素 | boolean |
| noneMatch | 检查是否没有匹配所有元素 | boolean |
| findFirst | 返回第一个元素 | Optional |
| findAny | 返回当前流中的任意元素 | Optional |
| count | 返回流中元素总个数 | |
| max | 返回流中最大值 | |
| min | 返回流中最小值 |
2.2、代码示例
package java8;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.Optional;
import java.util.stream.Collectors;
/**
* @Description:
* @Date: 2020/7/15 00:04
* @Auther: zhaodi
*/
public class StreamDemo01 {
public static void main(String[] args) {
List<Student> studentList = new ArrayList<>();
studentList.add(new Student(1, "赵迪", 23));
studentList.add(new Student(3, "tom", 25));
studentList.add(new Student(2, "tom", 27));
studentList.add(new Student(2, "rose", 22));
Comparator<Student> comparator = Comparator.comparingInt(Student::getId);
List<Student> list = studentList.stream().sorted(comparator).collect(Collectors.toList());
System.out.println(list);
Boolean success = list.stream().allMatch(x -> x.getId() > 1);
System.out.println(success); // false
Boolean success1 = list.stream().anyMatch(x -> x.getId() > 2);
System.out.println(success1); // true
Boolean success2 = list.stream().noneMatch(x -> x.getId() == 2);
System.out.println(success2);//false
Optional<Student> op = list.stream().sorted(comparator).findFirst();
Student student = op.get();
System.out.println(student);
Optional<Student> optional = list.stream().findAny();
long count = list.stream().count();
System.out.println(count);
Optional<Student> opMax = list.stream().max(comparator);
Optional<Student> opMin = list.stream().min(comparator);
}
}
3、归约（reduce）
3.1、方法介绍
| 方法名 | 介绍 | 返回类型 |
|---|---|---|
| reduce(BinaryOperator b) | 可以将流中元素反复结合起来，得到一个Optional对象 | Option |
| reduce(T iden,BinaryOperator b) | 可以将流中元素反复结合起来，得到一个值 | T |
3.2、代码示例
reduce方法非常的通用，后面介绍的count，sum等都可以使用其实现。reduce方法有三个重载的方法，本文介绍两个最常用的，最后一个留给读者自己学习。先来看reduce方法的第一种形式，其方法定义如下
第一种
Optional<T> reduce(BinaryOperator<T> accumulator);
List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9);
Optional<Integer> optional= list.stream().reduce((x, y) -> x + y);
System.out.println(optional.get()); // 45
- 解释
可以看到reduce方法接受一个函数，这个函数有两个参数，第一个参数是上次函数执行的返回值（也称为中间结果），第二个参数是stream中的元素，这个函数把这两个值相加，得到的和会被赋值给下次执行这个函数的第一个参数。要注意的是：第一次执行的时候第一个参数的值是Stream的第一个元素，第二个参数是Stream的第二个元素。这个方法返回值类型是Optional，这是Java8防止出现NPE的一种可行方法，后面的文章会详细介绍，这里就简单的认为是一个容器，其中可能会包含0个或者1个对象
第二种
T reduce(T identity, BinaryOperator<T> accumulator);
List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9);
Integer sum = list.stream().reduce(0, (x, y) -> x + y);
System.out.println(sum);
- 解释
这个定义上上面已经介绍过的基本一致，不同的是：它允许用户提供一个循环计算的初始值，如果Stream为空，就直接返回该值。而且这个方法不会返回Optional，因为其不会出现null值
如上面代码所示：
如果list集合里面没有一个对象的话，那么第一种写法会报错，第二种结果则是0
备注
map和reduce的连接通常称为map-reduce模式，例如
List<Student> studentList = new ArrayList<>();
studentList.add(new Student(1, "赵迪", 23));
studentList.add(new Student(3, "tom", 25));
studentList.add(new Student(2, "tom", 27));
studentList.add(new Student(2, "rose", 22));
Optional sum = studentList.stream().map(x -> x.getAge()).reduce((x, y) -> x + y);
4、收集（collect）
4.1、方法介绍
| 方法名 | 介绍 | 返回类型 |
|---|---|---|
collect（Collector c） |
将流转换为其它形式。接受一个Collector接口的实现，用于给Stream中元素做汇总方法 |
Collector接口中的方法的实现决定了如何对流执行收集操作（如收集到List、Set、Map）。
但是Collectors实现类提供了很多静态方法，可以方便的创建常见收集器实例，具体方法和实例如下
| 方法名 | 介绍 | 返回类型 |
|---|---|---|
Collectors.toList() |
将流转换为List |
List<T> |
Collectors.toSet() |
将流转换为Set |
Set<T> |
Collectors.toCollection(LinkedList::new) |
将流转换为集合 | |
Collectors.toMap(Student::getName, Student::getAge, (e, r) -> r) |
转为Map，具体见下面代码 | Map<String,Object> |
Collectors.counting() |
统计个数 | Long |
Collectors.averagingDouble(Student::getAge) |
求平均值 | Double |
Collectors.summingInt(Student::getAge) |
求和 | Integer |
Collectors.maxBy(Comparator c) |
最大值 | Optional<T> |
Collectors.minBy(Comparator c) |
最小值 | Optional<T> |
Collectors.groupingBy(Student::getName) |
单个分组 | Map<String,List<T> |
Collectors.partitioningBy(x->x.getAge()>26) |
分区 | Map<Boolean>,List<T> |
Collectors.summarizingDouble(Student::getAge) |
统计分析 | DoubleSummaryStatistics |
4.2、代码示例
package java8;
import java.util.*;
import java.util.stream.Collectors;
/**
* @Description:
* @Date: 2020/7/15 00:04
* @Auther: zhaodi
*/
public class StreamDemo01 {
public static void main(String[] args) {
List<Student> studentList = new ArrayList<>();
studentList.add(new Student(1, "赵迪", 23));
studentList.add(new Student(3, "tom", 25));
studentList.add(new Student(2, "tom", 27));
studentList.add(new Student(2, "rose", 22));
// 转List
List<Student> newList = studentList.stream().filter(x -> x.getAge() > 23).collect(Collectors.toList());
System.out.println(newList); //[Student(id=3, name=tom, age=25), Student(id=2, name=tom, age=27)]
// 转Set
Set<Student> studentSet = studentList.stream().collect(Collectors.toSet());
System.out.println(studentSet);//[Student(id=3, name=tom, age=25), Student(id=2, name=rose, age=22), Student(id=1, name=赵迪, age=23), Student(id=2, name=tom, age=27)]
// 转集合
studentList.stream().collect(Collectors.toCollection(LinkedList::new));
// 转Map(e:旧的key，r：新的key，如果存在key重复，则使用新的key或者旧的key都可以)
Map<String, Object> studentMap = studentList.stream().collect(Collectors.toMap(Student::getName, Student::getAge, (e, r) -> r));
System.out.println(studentMap); // {tom=27, 赵迪=23, rose=22}
// 求个数
Long count = studentList.stream().collect(Collectors.counting());
System.out.println(count);
// 平均值
Double avgAge = studentList.stream().collect(Collectors.averagingDouble(Student::getAge));
System.out.println(avgAge);
// 求和
Integer ageSum = studentList.stream().collect(Collectors.summingInt(Student::getAge));
System.out.println(ageSum);
// 最大值
Comparator<Student> ageComparator = Comparator.comparingInt(Student::getAge);
Optional<Student> maxStu = studentList.stream().collect(Collectors.maxBy(ageComparator));
System.out.println(maxStu.get());
// 最小值
Optional<Integer> min = studentList.stream().map(Student::getAge).collect(Collectors.minBy(Integer::compare));
System.out.println(min.get());
// 单个分组（根据姓名分组）
Map<String, List<Student>> stringListMap = studentList.stream().collect(Collectors.groupingBy(Student::getName));
System.out.println(stringListMap);//{tom=[Student(id=3, name=tom, age=25), Student(id=2, name=tom, age=27)], 赵迪=[Student(id=1, name=赵迪, age=23)], rose=[Student(id=2, name=rose, age=22)]}
// 多级分组(先根据姓名分，在根据年纪分)
Map<String, Map<Object, List<Student>>> map = studentList.stream().collect(Collectors.groupingBy(Student::getName, Collectors.groupingBy((x) -> {
if (x.getAge() > 26) {
return "老年";
} else {
return "青年";
}
})));
System.out.println(map);//{tom={青年=[Student(id=3, name=tom, age=25)], 老年=[Student(id=2, name=tom, age=27)]}, 赵迪={青年=[Student(id=1, name=赵迪, age=23)]}, rose={青年=[Student(id=2, name=rose, age=22)]}}
// 分区(分为两个区，年纪大于26和小于等于26)
Map<Boolean,List<Student>> partitionStudent = studentList.stream().collect(Collectors.partitioningBy(x->x.getAge()>26));
System.out.println(partitionStudent); //{false=[Student(id=1, name=赵迪, age=23), Student(id=3, name=tom, age=25), Student(id=2, name=rose, age=22)], true=[Student(id=2, name=tom, age=27)]}
// 统计分析
DoubleSummaryStatistics dss = studentList.stream().collect(Collectors.summarizingDouble(Student::getAge));
System.out.println(dss.getAverage());
System.out.println(dss.getSum());
System.out.println(dss.getMax());
// 连接
String names = studentList.stream().map(Student::getName).collect(Collectors.joining(","));
System.out.println(names); //赵迪,tom,tom,rose
}
}
一个小小的程序员
