个人理解:Stream API 非常强大! 在Java8之后.对数据的操作非常的方便,操作数据就好像写SQL语句.

使用Stream API 需要了解到一下几点

* Stream API 在流的传输过程中,做一些流水线式的处理,产生一个新流
* Stream自己不会存储元素
* Stream不会改变源对象,返回一个持有结果的新流
* Stream操作是延时执行的

使用Stream API 需要三个步骤

  1. 创建Stream 
  2. 做一些流水线式的中间操作  
  3. 终止操作

一. 下面介绍第一步,怎样创建一个Stream流

  • 可以通过集合任意的方法 stream()或parallelStream()
  List<Student> list = new ArrayList<>();
  Stream<Student> stream1 = list.stream();
  • 通过Arrays类的静态方法 stream() 获取数组流
  Student[] students = new Student[10];
  Stream<Student> stream2 = Arrays.stream(students);
  • 通过Stream类的静态方法of(),此方法为可变参数
  Stream<Integer> stream3 = Stream.of(1,2,3,4);
  • 通过Stream.iterate来创建无限流
  Stream<Integer> stream4 = Stream.iterate(0, (x) -> ++x);
  stream4.limit(20)
         .forEach(System.out::println);
  • 通过Stream.generate来创建无限流
  Stream<Integer> stream5 = Stream.generate(() -> (int)(Math.random()*100));
  stream5.limit(10)
         .forEach(System.out::println);

二. 第二步,流水线式的中间操作

注意: 中间操作不执行任何操作,在终止操作的时候一次性执行全部操作,叫做"惰性求值"或"延迟加载"  

首先我们进行一些数据准备,之后我们直接操作students流,以便看出效果

public List<Student> students = Arrays.asList(
          new Student("莫提",20,"男"),
          new Student("moti",18,"男"),
          new Student("John",23,"男"),
          new Student("麦克",19,"女"),
          new Student("肉丝",19,"女"),
          new Student("肉丝",19,"女"),
          new Student("肉丝",19,"女"),
          new Student("肉丝",19,"女"),
          new Student("肉丝",19,"女"),
          new Student("肉丝",19,"女"),
          new Student("肉丝",19,"女"),
          new Student("肉丝",19,"女"),
          new Student("露丝",19,"女")
          );

中间操作—-筛选和切片

  • filter -> 接收 Lambda,从流中排出某些元素
  • limit -> 截断流,让元素不超过指定数量(当数量够的时候就不再进行迭代操作)
  • skip -> 跳过指定数目个元素,正好和limit方法互补
  • distinct-> 去除重复元素,根据hashCode和equals方法,要求元素类必须重写这两个方法
@Test
public void Test2() {
  students.stream().filter((x) -> x.getAge() > 18)
                   .distinct()
                   .limit(2)
                   .forEach(System.out::println);//内部迭代,由 Stream API完成
}

中间操作—-映射

  • map:接收Lambda,将元素转换成其他形式或提取信息.接收一个函数作为参数,该函数会被应用到每一个元素上并将其映射为一个新元素.
  • flagMap: 接收一个函数作为参数,将流中的每一个值都转换为一个流,最后将所有流拼接成一个流
两者的区别就相当于 list中的
                    add()        -> 什么都能加,可以出现嵌套集合                    例如:{1,2,{3,4}}

                    addAll()    -> 如果参数是一个集合,那么将集合中的元素加到里面    例如:{1,2,3,4} 

演示map的用法 将list中的字符串转换为大写字母

List<String> list = Arrays.asList("a","bb","ccc","dddd","eeeee");
  list.stream()
      .map((str) -> str.toUpperCase())
      .forEach(System.out::println);
效果如下:
  A
  BB
  CCC
  DDDD
  EEEEE 

接下来我们新建一个工具方法,以便对比map和flagMap的用法

/**
*     将一个字符串切割成单个字符
* @param str
* @return 由单个字符组成的Stream流
*/
public static Stream<Character> filterCharacter(String str){
  List<Character> list = new ArrayList<>();
  for (Character character : str.toCharArray()) {
      list.add(character);
  }
  return list.stream();
}

演示map的用法,将list中的字符串全部切割成单个字符

list.stream()
  .map(Stream_Learn::filterCharacter)
  .forEach((s) -> {
      s.forEach(System.out::println);
  });

注意:这种情况下:流中流,所以forEach的时候也要嵌套的forEach

下面演示flagMap的用法:避免流中流

    list.stream()
        .flatMap(Stream_Learn::filterCharacter)
        .forEach(System.out::println);

两者的效果是一样的:

            a
            b
            b
            c
            c
            c
            d
            d
            d
            d
            e
            e
            e
            e
            e 
中间操作—-排序
  • sorted() 自然排序
  • sorted(Comparator com) 定制排序
 @Test
 public void Test4() {
     List<Integer> list = Arrays.asList(1,3,5,2,4,7,6);
     //将list排序
     list.stream()
         .sorted()        
         .forEach(System.out::println);
     //先按年龄对students进行排序,年龄一样再按姓名排序
     students.stream()
             .sorted((x,y) -> {
                 if(x.getAge()==y.getAge()) {
                     return x.getName().compareTo(y.getName());
                 }else {
                     return String.valueOf(x.getAge()).compareTo(String.valueOf(y.getAge()));
                 }
             })
             .forEach(System.out::println);
 }

三.  最后一步,终止操作终止操作—-查找与匹配

终止操作—-查找与匹配
  • allMatch -> 检查是否匹配到所有元素
  • anyMatch -> 检查是否匹配到一个元素
  • noneMatch -> 检查是否没有匹配所有元素
  • findFirst -> 返回第一个元素
  • findAny -> 返回当前流中任意元素
  • count -> 返回流中的总个数
  • max -> 返回流中的最大值
  • min -> 返回六中的最小值
boolean b1 = students.stream()        
                 .allMatch((stu) -> {
                     return "莫提".equals(stu.getName());
                  }); 
System.out.println("是否所有学生都叫莫提"+b1);//返回值为false
boolean b2 = students.stream()        
                 .anyMatch((stu) -> {
                     return "莫提".equals(stu.getName());
                 }); 
System.out.println("是否有的学生都叫莫提"+b2);//结果为true
boolean b3 = students.stream()        
                 .noneMatch((stu) -> {
                     return "莫提".equals(stu.getName());
                 }); 
System.out.println("是不是没有人叫莫提"+b3);//结果为false,双重否定表肯定

Optional集合解决空指针异常,如果流中得到的结果为空,则就用替补元素 -> orElse(替补元素)方法

    //获得第一个学生
    Optional<Student> op1 =  students.stream()
                                    .findFirst();
    op1.orElse(new Student("替补学生",30,"女"));
    System.out.println(op1.get());
    Optional<Student> op2 =  students.parallelStream()//获得并行流
                                    .findAny();
    op2.orElse(new Student("替补学生",30,"女"));
    System.out.println(op2.get());
    Long count = students.stream()
                        .count();
    System.out.println("流中的个数:"+count);
    //获得年龄最大的学生
    Optional<Student> stu = students.stream()
                                    .max((x,y) -> 
    Integer.compare(x.getAge(), y.getAge()));
    System.out.println(stu.get());
    //获得年龄最小的学生
    Optional<Student> stu1 = students.stream()
                                    .min((x,y) -> 
    Integer.compare(x.getAge(), y.getAge()));
    System.out.println(stu1.get());
    //获得最小的年龄
    Optional<Integer> minAge = students.stream()
                                        .map(Student::getAge)
                                        .min(Integer::compare);
    System.out.println("最小年龄:"+minAge.get());
终止操作—-归约

reduce ( T identity,BinaryOperator) / reduce(BinaryOPerator) —-可以将流中元素反复结合起来,得到一个值

  @Test
  public void Test6() {
      //获得list的总和
      List<Integer> list = Arrays.asList(1,2,3,4,5,6,7,8,9,10);
      Integer sum = list.stream()
                      .reduce(0, (x,y) -> x+y);
      System.out.println(sum);
      //获得学生的总年龄
       Optional<Integer> sumAge  = students.stream()
                                           .map(Student::getAge)            //map-reduce模式
                                           .reduce(Integer::sum);
       System.out.println("学生总年龄:"+sumAge.get());
  }
终止操作—-收集

collect—将流转换为其他形式.接收一个Collector接口实现,用于给Stream中元素做汇总的方法
注意: collect方法要与Collectors类配合使用

1.将学生的姓名从students集合中提取出来,并放入一个新的集合中

  //提取到List中
  List<String> namesList = students.stream()
                                  .map(Student::getName)
                                  .collect(Collectors.toList());
  System.out.println(namesList);
  //提取到Set中
  Set<String> namesSet = students.stream()
                                  .map(Student::getName)
                                  .collect(Collectors.toSet());
  System.out.println(namesSet);
  //提取到任何一个集合中(这里以HashSet为例)
  HashSet<String> hs = students.stream()
                                  .map(Student::getName)
                                  .collect(Collectors.toCollection(HashSet::new));
  System.out.println(hs);

2.获得一些常用的数据(总数,最大值,最小值,平均值….)

方法一:

  Long count = students.stream()
                      .collect(Collectors.counting());
  System.out.println("总数:"+count);
  Integer sumAge = students.stream()
                          .collect(Collectors.summingInt(Student::getAge));
  System.out.println("年龄总和:"+sumAge);
  Double avgAge = students.stream()
                          .collect(Collectors.averagingDouble(Student::getAge));
  System.out.println("年龄的平均值:"+avgAge);
  Optional<Student> stu =  students.stream()
                                  .collect(Collectors.maxBy((x,y)-> Integer.compare(x.getAge(), y.getAge())));
  System.out.println("最大年龄的学生:"+stu.get());
  Optional<Student> stu1 =  students.stream()
                                  .collect(Collectors.minBy((x,y)-> Integer.compare(x.getAge(), y.getAge())));
  System.out.println("最小年龄的学生:"+stu1.get());

方法二:

  DoubleSummaryStatistics dss = students.stream()
                                      .collect(Collectors.summarizingDouble(Student::getAge));
  System.out.println("年龄的平均值"+dss.getAverage());
  System.out.println("总人数"+dss.getCount());
  System.out.println("年龄的最大值"+dss.getMax());
  System.out.println("年龄的最小值"+dss.getMin());
  System.out.println("年龄的总和"+dss.getSum());

3. 分组和多级分组以及分区

//根据性别分组
  Map<String, List<Student>> sexGroup = students.stream()
                                              .collect(Collectors.groupingBy(Student::getSex));
  System.out.println(sexGroup); 

结果如下:
          {
          女=[Student [name=麦克, age=19, sex=女], Student [name=肉丝, age=19, sex=女], Student [name=肉丝, age=19, sex=女], Student [name=肉丝, age=19, sex=女], Student [name=肉丝, age=19, sex=女], Student [name=肉丝, age=19, sex=女], Student [name=肉丝, age=19, sex=女], Student [name=肉丝, age=19, sex=女], Student [name=肉丝, age=19, sex=女], Student [name=露丝, age=19, sex=女]], 
          男=[Student [name=莫提, age=20, sex=男], Student [name=moti, age=18, sex=男], Student [name=John, age=23, sex=男]]
          } 
//多级分组,先按照性别分组,再按照年龄分组
Map<String, Map<Integer, List<Student>>> duoGroup =    students.stream()
                                                          .collect(Collectors.groupingBy(Student::getSex, Collectors.groupingBy(Student::getAge)));
System.out.println(duoGroup); 

结果如下:
      {
      女={
          19=[Student [name=麦克, age=19, sex=女], Student [name=肉丝, age=19, sex=女], Student [name=肉丝, age=19, sex=女], Student [name=肉丝, age=19, sex=女], Student [name=肉丝, age=19, sex=女], Student [name=肉丝, age=19, sex=女], Student [name=肉丝, age=19, sex=女], Student [name=肉丝, age=19, sex=女], Student [name=肉丝, age=19, sex=女], Student [name=露丝, age=19, sex=女]]
          }, 
      男={
          18=[Student [name=moti, age=18, sex=男]], 
          20=[Student [name=莫提, age=20, sex=男]], 
          23=[Student [name=John, age=23, sex=男]]
          }
      } 
//通过分区,将男女分开
  Map<Boolean, List<Student>> boolgroup = students.stream()
                                                  .collect(Collectors.partitioningBy((s) -> "男".equals(s.getSex())));
  System.out.println(boolgroup); 

结果如下:
  {
      false=[Student [name=麦克, age=19, sex=女], Student [name=肉丝, age=19, sex=女], Student [name=肉丝, age=19, sex=女], Student [name=肉丝, age=19, sex=女], Student [name=肉丝, age=19, sex=女], Student [name=肉丝, age=19, sex=女], Student [name=肉丝, age=19, sex=女], Student [name=肉丝, age=19, sex=女], Student [name=肉丝, age=19, sex=女], Student [name=露丝, age=19, sex=女]], 
      true=[Student [name=莫提, age=20, sex=男], Student [name=moti, age=18, sex=男], Student [name=John, age=23, sex=男]]
  } 

最后还有个字符键拼接的小操作

  String names = students.stream()
                          .map(Student::getName)
                          .collect(Collectors.joining(",","#","#"));//也可以不加参数
  System.out.println(names); 

效果如下:
      #莫提,moti,John,麦克,肉丝,肉丝,肉丝,肉丝,肉丝,肉丝,肉丝,肉丝,露丝# 
最后修改日期:2020-07-13

作者

留言

撰写回覆或留言

发布留言必须填写的电子邮件地址不会公开。