Java8 的新特性 – 集合的流式编程
1、集合流的简介
1.1、集合的流式编程的简介
Stream是JDK1.8之后出现的新特性，也是JDK1.8新特性中最值得学习的两种新特性之一。（另外一个是lambda表达式）。
Stream是对集合操作的增强，流不是集合的元素，不是一种数据结构，不负责数据的存储的。流更像是一个迭代器，可以单向的遍历一个集合中的每一个元素，并且不可循环。
注意事项：关于流的操作还可以使用数组，例：
Arrays.stream(list).(...)...
1.2、为什么要使用集合的流式编程
有些时候，对集合中的元素进行操作的时候，需要使用到其他操作的结果。在这个过程中，集合的流式编程可以大幅度的简化代码的数量。将数据源中的数据，读取到一个流中，可以对这个流中的数据进行操作（删除、过滤、映射…）。每次的操作结果也是一个流对象，可以对这个流再进行其他的操作。
1.3、使用流式编程的步骤
通常情况下，对集合中的数据使用流式编程，需要经过以下三步。
1、获取数据源，将数据源中的数据读取到流中。
2、对流中的数据进行各种各样的处理。
3、对流中的数据进行整合处理。
在上述三个过程中，过程2中，有若干方法，可以对流中的数据进行各种各样的操作，并且返回流对象本身，这样的操作，被称为 – 中间操作。过程3中，有若干方法，可以对流中的数据进行各种处理，并关闭流，这样的操作，被称为 – 最终操作。
在中间操作和最终操作中，基本上所有的方法参数都是函数式接口，可以使用lambda表达式来实现。使用集合的流式编程，来简化代码量，是需要对 lambda 表达式做到熟练掌握。
2、数据源的获取
2.1、数据源的简介
数据源，顾名思义，既是流中的数据的来源。是集合的流式编程的第一步，将数据源中的数据读取到流中，进行处理。注意：将数据读取到流中进行处理的时候，与数据源中的数据没有关系。也就是说，中间操作对流中的数据进行处理、过滤、映射、排序…，此时是不会影响数据源中的数据的。
2.2、数据源的获取
这个过程，其实是将一个容器中的数据，读取到一个流中。因此无论什么容器作为数据源，读取到流中的方法返回值一定是一个Stream。
// 1、通过Collection接口中的stream()方法获取数据源为Collection的流
Stream<Integer> stream = list.stream();
// 2、通过Collection接口的parallelStream()方法获取数据源为Collection的流
Stream<Integer> stream = list.parallelStream();
// 3、通过Arrays工具类中的stream()方法获取数据源为数组的流
IntStream stream = Arrays.stream(array);
关于
stream()和parallelStream 他们都是Collection集合获取数据源的方法，不同点在于stream()方法获取的数据源是串行的，parallelStream()获取的数据源是并行的。parallelStream()内部集成了多个线程对流中的数据进行操作，效率更高。
3、最终操作
3.1、最终操作的简介
将流中的数据整合到一起，可以存入一个集合，也可以直接对流中的数据进行遍历、数据统计…，通过最终操作，需要掌握如何从流中提取出来我们想要的信息。
注意事项：最终操作，之所以叫最终操作，是因为，在最终操作执行结束后，会关闭这个流，流中的所有数据都会销毁。如果使用一个已经关闭了的流，会出现异常。
3.2、collect
将流中的数据收集到一起，对这些数据进行一些处理。最常见的处理，就是将流中的数据存入一个集合。collect方法的参数，是一个Collector接口，而且这个接口并不是一个函数式接口。实现这个接口，可以自定义收集的规则。但是，绝大部分情况下，不需要自定义。
直接使用 Collectors 工具类提供的方法即可。
// 1.1、转成 List
List<Integer> result1 = list.stream().collect(Collectors.toList());
System.out.println(result1);
// 1.2、转成 Set
Set<Integer> result2 = list.stream().collect(Collectors.toSet());
System.out.println(result2);
// 1.3、转成 Map，提供两个函数式接口的实现，分别实现键的生成规则和值的生成规则
Map<Integer, Integer> result3 = list.stream().collect(Collectors.toMap(ele -> ele / 10, ele -> ele));
System.out.println(result3);
3.3、reduce
将流中的数据按照一定的规则聚合起来。
// 将流的元素，逐一带入到这个方法中，进行运算
// 最终的运算结果，得到的其实是一个 Optional 类型，需要使用 get() 获取到里面的数据
int result4 = list.stream().reduce((e1, e2) -> e1 + e2).get();
System.out.println(result4);
3.4、count
统计流中的元素数量。
long result5 = list.stream().count();
System.out.println(result5);
3.5、forEach
迭代、遍历流中的数据。
list.stream().forEach(System.out::println);
3.6、max & min
获取流中的最大的元素、最小的元素。
// 获取最大值
Integer result6 = list.stream().max(Integer::compareTo).get();
System.out.println("max is : " + result6);
// 获取最小值
Integer result7 = list.stream().min(Integer::compareTo).get();
System.out.println("min is : " + result7);
3.7、Matching
allMatch: 只有当流中所有的元素，都匹配指定的规则，才会返回 true
anyMatch: 只要流中有任意的数据，满足指定的规则，都会返回 true
noneMatch: 只有当流中的所有的元素，都不满足指定的规则，才会返回true
// 判断流中是否所有的元素都大于 50
boolean result8 = list.stream().allMatch(ele -> ele > 50);
System.out.println(result8);
// 判断流中是否有大于 50 的数据
boolean result9 = list.stream().anyMatch(ele -> ele > 50);
System.out.println(result9);
// 判断流中是否没有奇数
boolean result10 = list.stream().noneMatch(ele -> ele % 2 != 0);
System.out.println(result10);
3.8、find
findFirst: 从流中获取一个元素（一般情况下，是获取的开头的元素）
findAny: 从流中获取一个元素（一般情况下，是获取的开头的元素）
这两个方法，绝大部分情况下，是完全相同的，但是在多线程的环境下，findAny和find返回的结果可能不一样。
Integer result11 = list.parallelStream().findFirst().get();
System.out.println(result11);
Integer result12 = list.parallelStream().findAny().get();
System.out.println(result12);
3.9、summaryStatistics（通常mapToInt配合使用）
根据此方法获取到集合中的最大值，最小值、平均值、数量以及求和等信息。
IntSummaryStatistics statistics = stream.mapToInt(o>o.getAge()).summaryStatistics();
System.out.println("最大年龄: " + statistics.getMax());
System.out.println("最小年龄: " + statistics.getMin());
System.out.println("平均年龄: " + statistics.getAverage());
3.10、最终操作的注意事项
最终操作，会关闭流。如果一个流被关闭了，再去使用这个流，就会出现异常。
// 9、最终操作错误示范
Stream<Integer> stream = list.stream();
long count = stream.count();
stream.forEach(System.out::println);
Exception in thread "main" java.lang.IllegalStateException: stream has already been operated upon or closed
at java.util.stream.AbstractPipeline.sourceStageSpliterator(AbstractPipeline.java:279)
at java.util.stream.ReferencePipeline$Head.forEach(ReferencePipeline.java:580)
at com.qf.cstream.FinalOperationDemo.main(FinalOperationDemo.java:78)
4、中间操作
4.1、中间操作的简介
将数据从数据源中读取到流中，中间操作，就是对流中的数据进行各种各样的操作、处理。中间操作可以连续操作，每一个操作的返回值都是一个Stream对象，可以继续进行其他的操作。直到最终操作。
4.2、filter（一般与limit搭配使用）
条件过滤，仅保留流中满足指定条件的数据，其他不满足的数据都会被删除。
list.stream().filter(ele -> ele.length() > 5).forEach(System.out::println);
4.3、distinct
去重集合中重复的元素。这个方法没有参数。去重的规则与HashSet相同。
list.stream().distinct().forEach(System.out::println);
4.4、sorted
将流中的数据进行排序
// 按照流中的元素对应的类，实现的 Comparable 接口中的方法实现排序
list.stream().sorted().forEach(System.out::println);
// 将流中的数据，按照指定的规则进行排序
list.stream().sorted((e1, e2) -> e1.length() - e2.length()).forEach(System.out::println);
4.5、limit & skip
limit: 限制，截取流中指定数量的元素
skip: 跳过，跳过流中的指定数量的元素
// 跳过开头的指定的元素
list.stream().skip(3).forEach(System.out::println);
// 截取指定数量的元素
list.stream().limit(3).forEach(System.out::println);
// 配合使用，截取部分
list.stream().skip(5).limit(2).forEach(System.out::println);
4.6、map & flatMap
map: 对流中的数据进行映射，用新的数据替换旧的数据。
list.stream().map(ele -> ele + ".txt").forEach(System.out::println);
map最主要，就是来做元素的替换。其实map是一个元素的映射。
flatMap也是元素的映射,使用场合：
常用于map直接映射完成后，流中的数据是一个个的容器，而我们需要对容器中的元素进行处理，此时， 可以使用扁平化映射，将容器中的元素直接存入流中。
flatMap是扁平化映射,一般跟在map映射之后，例：
//统计集合里共有多少不重复字符
long count = Arrays.stream(list).map(list->list.split("")).flatMap(Arrays::stream).dintinct().count();
faltmap映射图示：[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9BweT4f9-1587779824840)(E:\文件夹目录\JAVA\课程基础\3.jpg)]
4.7、mapToInt
将流中的数据替换成int类型，此时得到 IntStream 结果。
double avg = list.stream().mapToInt(Person::getAge).average().getAsDouble();
//.average:求平均
//.sum:求和
//.min:最小值
//.max:最大值
System.out.println(avg);
5、Collectors工具类
Collectors是一个工具类，里面封装了很多方法，可以很方便的获取到一个Collector接口的实现类对象，从而可以使用collect()方法，对流中的数据，进行各种各样的处理、整合。
Collectors.toList() : 将流中的数据，聚合到一个 List 集合中
Collectors.toSet() : 将流中的数据，聚合到一个 Set 集合中
Collectors.toMap() : 将流中的数据，聚合到一个 Map 集合中
maxBy() : 按照指定的规则，找到流中最大的元素，等同于 max
minBy() : 按照指定的规则，找到流中最小的元素，等同于 min
joining() : 将流中的数据拼接成一个字符串，注意：只能操作流中是String的数据
summingInt() : 将流中的数据，映射成 int 类型的数据，并求和
averagingInt() : 将流中的数据，映射成 int 类型的数据，并求平均值
summarizingInt() : 将流中的数据，映射成 int 类型的数据，并获取描述信息
// maxBy: 按照指定的规则，找到流中最大的元素，等同于 max
Student max = list.stream()
.collect(Collectors.maxBy((s1, s2) -> s1.getScore() - s2.getScore()))
.get();
System.out.println(max);
// minBy: 按照指定的规则，找到流中最小的元素，等同于 min
Student min = list.stream()
.collect(Collectors.minBy((s1, s2) -> s1.getScore() - s2.getScore()))
.get();
System.out.println(min);
// 将流中的数据拼接起来,以指定的分隔符进行分隔(3参时,后2个代表添加前缀和尾缀,无参代表直接拼接)
//只有当流中的数据是字符串的时候才能进行拼接
String s3 = list.stream()
.map(Student::getName)
.collect(Collectors.joining(", ", "{", "}"));
System.out.println(s3);
// 将流中的数据，映射成 int 类型的数据，并求和
int sum = list.stream()
.collect(Collectors.summingInt(
非静态时:(lambda表达式)o->o.getScore()
静态方法时:(函数引用)Student::getScore
));
System.out.println(sum);
// 将流中的数据，映射成 int 类型的数据，并求平均值
double average = list.stream()
.collect(Collectors.averagingInt(Student::getScore));
System.out.println(average);
// 将流中的数据，映射成 int 类型的数据，并获取描述信息
IntSummaryStatistics summaryStatistics
= list.stream()
.collect(Collectors.summarizingInt(Student::getScore));
System.out.println(summaryStatistics);
System.out.println(summaryStatistics.getCount());
System.out.println(summaryStatistics.getSum());
System.out.println(summaryStatistics.getMax());
System.out.println(summaryStatistics.getMin());
System.out.println(summaryStatistics.getAverage());
6、综合案例
需求: 一个集合中存储了了若干个Student对象, 要求查询出以下结果:
1. 所有及格的学生信息
2. 所有及格的学生姓名
3. 所有学生的平均成绩
4. 班级的前3名(按照成绩)
5. 班级的3-10名(按照成绩)
6. 所有不不及格的学生平均成绩
7. 将及格的学生, 按照成绩降序输出所有信息
8. 班级学生的总分
public class Student {
private String name;
private int score;
public String getName() {
return name;
}
public int getScore() {
return score;
}
public Student(String name, int score) {
this.name = name;
this.score = score;
}
@Override
public String toString() {
return String.format("姓名: %s, 成绩: %d", name, score);
}
}
