jdk1.8新特性——Stream（流）的终止操作（收集的示例演示）

Posted 2021-09-14 小志的博客

目录

• • 一、Stream（流）的理解
  • 二、Stream（流）是什么
  • 三、Stream（流）的注意事项
  • 四、Stream API 的操作步骤
  • • 1、创建 Stream
    • 2、中间操作 Stream
    • 3、终止Stream
    • 4、Stream API 的操作步骤图解
  • 五、Stream（流）的终止操作语法
  • • 1、收集
  • 六、Stream（流）的终止操作（收集的示例演示）
  • • 1、创建Student实体类，用于演示
    • 2、收集的示例演示

一、Stream（流）的理解

• Stream是Java8中处理集合的关键抽象概念，它可以指定你希望对集合进行的操作，可以执行非常复杂的查找、过滤和映射数据等操作。
• 使用Stream API对集合数据进行操作，类似于使用SQL执行的数据库查询。
• 使用Stream API 来并行执行操作。
• Stream API提供了一种高效且易于使用的处理数据的方式。

二、Stream（流）是什么

• Stream（流）是数据渠道，用于操作数据源（集合、数组等）所生成的元素序列。
• 集合关注的是数据，流关注的是计算。

三、Stream（流）的注意事项

• Stream自己不会存储元素。
• Stream不会改变源对象。相反，他们会返回一个持有结果的新Stream。
• Stream操作时延迟执行。这意味着他们会等到需要结果的时候才执行。

四、Stream API 的操作步骤

1、创建 Stream

• 一个数据源（如：集合、数组），获取一个流。

2、中间操作 Stream

• 一个中间操作链，对数据源的数据进行处理。
• 多个中间操作可以连接起来形成一个流水线，除非流水线上触发终止操作，否则中间操作不会执行任何的处理，而在终止操作时一次性全部处理，称为“惰性求值”。

3、终止Stream

• 一个终止操作，执行中间操作链，并产生结果。
• 终端操作会从流的流水线生成结果。其结果可以是任何不是流的值，例如：List、Integer，甚至是 void 。

4、Stream API 的操作步骤图解

五、Stream（流）的终止操作语法

1、收集

方法	描述
collect(Collector c)	将流转换为其他形式。接收一个 Collector接口的实现，用于给Stream中元素做汇总的方法

• collect方法中的参数Collector 接口中方法的实现决定了如何对流执行收集操作(如收集到 List、Set、Map)。但是 Collectors 实用类提供了很多静态方法，可以方便地创建常见收集器实例，具体方法与实例如下表：

序号	方法	返回类型	作用
1	toList	List< T>	把流中元素收集到List
2	toSet	Set< T>	把流中元素收集到Set
3	toCollection	Collection< T>	把流中元素收集到创建的集合
4	counting	Long	计算流中元素的个数
5	summingInt	Integer	对流中元素的整数属性求和
6	averagingInt	Double	计算流中元素Integer属性的平均值
7	summarizingInt	IntSummaryStatistics	收集流中Integer属性的统计值。如：平均值
8	joining	String	连接流中每个字符串
9	maxBy	Optional	根据比较器选择最大值
10	minBy	Optional	根据比较器选择最小值
11	reducing	归约产生的类型	从一个作为累加器的初始值开始，利用BinaryOperator与流中元素逐个结合，从而归约成单个值
12	collectingAndThen	转换函数返回的类型	包裹另一个收集器，对其结果转换函数
13	groupingBy	Map<K, List< T>>	根据某属性值对流分组，属性为K，结果为V
14	partitioningBy	Map<Boolean, List< T>>	根据true或false进行分区

六、Stream（流）的终止操作（收集的示例演示）

1、创建Student实体类，用于演示

package com.xz.springboot_java8.dya8.entity;
public class Student {
    private int id;//id
    private String name;//姓名
    private int age;//年龄
    private Score score;//成绩（优秀、良好、及格）

    public enum Score{
        EXCELLENT,
        GOOD,
        PASS
    }

    public Student(int id, String name, int age, Score score) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.score = score;
    }
	//getter、setter、toString方法此处省略
	.......
}

2、收集的示例演示

• 代码如下

  package com.xz.springboot_java8.dya8;
  
  import com.xz.springboot_java8.dya8.entity.Student;
  
  import java.util.*;
  import java.util.stream.Collectors;
  
  /**
   * @description:  终止操作
   *                  collect(Collector c)
   *                  将流转换为其他形式。接收一个 Collector接口的实现，用于给Stream中元素做汇总的方法
   * @author: xz
   */
  public class Test3 {
      public static void main(String[] args) {
          List<Student> studentsList = Arrays.asList(
                  new Student(1, "李四", 20,Student.Score.EXCELLENT),
                  new Student(2, "张三", 19,Student.Score.GOOD ),
                  new Student(2, "王五", 24,Student.Score.PASS),
                  new Student(4, "赵六", 23, Student.Score.GOOD),
                  new Student(4, "xz", 21, Student.Score.PASS )
          );
  
          getCollect(studentsList);
      }
  
      public static void getCollect(List<Student> studentsList){
          //1、toList演示： 获取所有学生的姓名并把流中元素收集到List集合中返回
          List<String> list = studentsList.stream()
                  .map(Student::getName)
                  .collect(Collectors.toList());
          list.forEach(System.out::println);
          System.out.println("--------------------");
  
  
          //2、toSet演示： 获取所有学生的姓名并把流中元素收集到Set集合中返回
          Set<String> set = studentsList.stream()
                  .map(Student::getName)
                  .collect(Collectors.toSet());
          set.forEach(System.out::println);
          System.out.println("======================");
  
  
          //3、toCollection演示：  获取所有学生的姓名并把流中元素收集到创建的集合中返回
          HashSet<String> hashSet = studentsList.stream()
                  .map(Student::getName)
                  .collect(Collectors.toCollection(HashSet::new));
          hashSet.forEach(System.out::println);
  
          //4、counting演示：  获取所有学生的总人数
          Long sum = studentsList.stream()
                  .collect(Collectors.counting());
          System.out.println("4、获取所有学生的总人数——"+sum);
  
          //5、summingInt演示：  获取所有学生id的总和
          Integer sum1 = studentsList.stream()
                  .collect(Collectors.summingInt(Student::getId));
          System.out.println("5、获取所有学生id的总和——"+sum1);
  
          //6、averagingInt演示：  获取所有学生年龄的平均值
          Double avgAge = studentsList.stream()
                  .collect(Collectors.averagingInt(Student::getAge));
          System.out.println("6、获取所有学生年龄的平均值——"+avgAge);
  
          //8、joining演示：  获取所有学生的名称并用逗号分隔
          String strName = studentsList.stream()
                  .map(Student::getName)
                  .collect(Collectors.joining(","));
          System.out.println("8、获取所有学生的名称并用逗号分隔——"+strName);
  
          //9、maxBy演示：  获取所有学生年龄的最大值的学生信息
          Optional<Student> opt = studentsList.stream()
                  .collect(Collectors.maxBy((s1, s2) -> Integer.compare(s1.getAge(), s2.getAge())));
          System.out.println("9、获取所有学生年龄的最大值的学生信息——"+opt.get());
  
          //10、minBy演示：  获取所有学生年龄的最小值
          Optional<Integer> opt2 = studentsList.stream()
                  .map(Student::getAge)
                  .collect(Collectors.minBy(Integer::compare));
          System.out.println("10、获取所有学生年龄的最小值——"+opt2.get());
  
          //13、groupingBy演示：  根据所有学生的成绩进行分组
          Map<Student.Score, List<Student>> map = studentsList.stream()
                  .collect(Collectors.groupingBy(Student::getScore));
          Iterator<Map.Entry<Student.Score, List<Student>>> it = map.entrySet().iterator();
          System.out.println("13、根据所有学生的成绩进行分组===============");
          while(it.hasNext()){
              Map.Entry<Student.Score, List<Student>> entry = it.next();
              System.out.println(entry.getKey() + "----" + entry.getValue());
          }
  
          //13、groupingBy多级分组演示：  根据所有学生的成绩及id进行多级分组
          Map<Student.Score, Map<Integer, List<Student>>> map1 = studentsList.stream()
                  .collect(Collectors.groupingBy(Student::getScore, Collectors.groupingBy(Student::getId)));
          System.out.println("13、根据所有学生的成绩及id进行多级分组===============");
          Iterator<Map.Entry<Student.Score, Map<Integer, List<Student>>>> iterator = map1.entrySet().iterator();
          while(iterator.hasNext()){
              Map.Entry<Student.Score, Map<Integer, List<Student>>> entry = iterator.next();
              System.out.println(entry.getKey() + "----" + entry.getValue());
          }
  
  
          //14、partitioningBy分区演示：  根据所有学生的年龄>20的进行分区
          Map<Boolean, List<Student>> map2 = studentsList.stream()
                  .collect(Collectors.partitioningBy((s) -> s.getAge() > 20));
          System.out.println("13、根据所有学生的年龄>20的进行分区===============");
          Iterator<Map.Entry<Boolean, List<Student>>> iterator1 = map2.entrySet().iterator();
          while(iterator1.hasNext()){
              Map.Entry<Boolean, List<Student>> next = iterator1.next();
              System.out.println(next.getKey()+"======"+next.getValue());
          }
      }
  }
  

• 输出结果如下