stream笔记

1、创建流stream

1.1、 Stream 的操作三个步骤

1.2、 stream中间操作

1.2.1 、 limit、skip、distinct
1.2.2、 map and flatMap
1.2.3、 sort 自然排序和定制排序

1.3、 add and andAll difference:

1.4、终止操作

1.4.1、 allmatch、anyMatch、noneMatch、max、min
1.4.2、 reduce
1.4.3 、 collect

1、创建流stream：

流(Stream) 到底是什么呢？
是数据渠道，用于操作数据源（集合、数组等）所生成的元素序列。
“ 集合讲的是数据，流讲的是计算！ ”
注意：
①Stream 自己不会存储元素。
②Stream 不会改变源对象。相反，他们会返回一个持有结果的新Stream。
③Stream 操作是延迟执行的。这意味着他们会等到需要结果的时候才执行。

1.1 Stream 的操作三个步骤

创建建 Stream
一个数据源（如：集合、数组），获取一个流
中间操作
一个中间操作链，对数据源的数据进行处理
终止操作( ( 终端操作) )
一个终止操作，执行中间操作链，并产生结果

在这里插入图片描述

default Stream stream()	List list = new ArrayList<>(); Stream stream = list.stream(); //获取一个顺序流	返回一个顺序流

default Stream parallelStream()	Stream parallelStream = list.parallelStream(); //获取一个并行流	返回一个并行流
	Integer[] nums = new Integer[10]; Stream stream1 = Arrays.stream(nums);	通过 Arrays 中的 stream() 获取一个数组流
	//迭代 Stream stream3 = Stream.iterate(0, (x) -> x + 2).limit(10); stream3.forEach(System.out::println);	创建无限流
	Stream stream4 = Stream.generate(Math::random).limit(2);	生成

        //下面两个遍历一样
        stream4.forEach(System.out::println);
//        stream4.forEach(s->{
//            System.out.println(s);
//        });

1.2：stream中间操作

filter	接收 Lambda ，从流中排除某些元素。
limit	截断流，使其元素不超过给定数量。
skip(n)	跳过元素，返回一个扔掉了前 n 个元素的流。若流中元素不足 n 个，则返回一个空流。与 limit(n) 互补
distinct	筛选，通过流所生成元素的 hashCode() 和 equals() 去除重复元素
map	接收 Lambda ，将元素转换成其他形式或提取信息。接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素。
flatMap	接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流，流中流
sorted()	自然排序 comparable
sorted(Comparator com)	定制排序

1.2.1 limit、skip、distinct、

public class Employee {
    private int id;
    private String name;
    private int age;
    private Double salary;

}
List<Employee> emps = Arrays.asList(
        new Employee(102, "李四", 59, 6666.66),
        new Employee(101, "张三", 18, 9999.99),
        new Employee(103, "王五", 28, 3333.33),
        new Employee(104, "赵六", 8, 7777.77),
        new Employee(104, "赵六", 8, 7777.77),
        new Employee(104, "赵六", 8, 7777.77),
        new Employee(105, "田七", 38, 5555.55)
);

    //内部迭代：迭代操作 Stream API 内部完成（filter  过滤时需要迭代一下）
    @Test
    public void test2() {
        //所有的中间操作不会做任何的处理
        Stream<Employee> stream = emps.stream()
                //断言，传入参数，返回布尔值
                .filter((e) -> {
                    System.out.println("测试中间操作");
                    return e.getAge() <= 35;
                });

        //只有当做终止操作时，所有的中间操作会一次性的全部执行，称为“惰性求值”
        stream.forEach(System.out::println);
    }

    //外部迭代
    @Test
    public void test3() {
        Iterator<Employee> it = emps.iterator();

        while (it.hasNext()) {
            System.out.println(it.next());
        }
    }


    //找到三个之后就不往下找了。提高效率
    @Test
    public void test4() {
        emps.stream()
                .filter((e) -> {
                    System.out.println("短路！"); // &&  ||
                    return e.getSalary() >= 5000;
                }).limit(3)
                .forEach(System.out::println);
    }


    //大于5000的前两个跳过，也就是不取
    @Test
    public void test5() {
        emps.parallelStream()
                .filter((e) -> e.getSalary() >= 5000)
                .skip(2)
                .forEach(System.out::println);
    }


    //去重。如果是对象，hashcode和equals  进行比较，所以要去重。  lambda 已经重写的了去重操作
    @Test
    public void test6() {
        emps.stream()
                .distinct()
                .forEach(System.out::println);
    }

1.2.2 map and flatMap:

   @Test
      public void test7() {
          Stream<String> str = emps.stream()
                  .map((e) -> e.getName());
  
          System.out.println("-------------------------------------------");
  
          List<String> strList = Arrays.asList("aaa", "bbb", "ccc", "ddd", "eee");
  
          Stream<String> stream = strList.stream()
                  .map(String::toUpperCase);
  
          stream.forEach(System.out::println);
  
          //TODO：下面两种一样的。内部迭代
  //        emps.stream().map(Employee::getName).forEach(System.out::println);
          emps.stream().map(s -> s.getName()).forEach(System.out::println);
  
  
          Stream<Stream<Character>> stream2 = strList.stream()
                  .map(TestStreamApI::filterCharacter);
  
          stream2.forEach((sm) -> {
              sm.forEach(System.out::println);
          });
  
          System.out.println("---------------------------------------------");
  
          Stream<Character> stream3 = strList.stream()
                  .flatMap(TestStreamApI::filterCharacter);
  
          stream3.forEach(System.out::println);
  
  
          System.out.println("----------------------------------------------");
          //解决结果两次for循环
          strList.stream().flatMap(item -> Arrays.stream(item.split(" "))).forEach(System.out::println);
  
      }
  
      public static Stream<Character> filterCharacter(String str) {
          List<Character> list = new ArrayList<>();
  
          for (Character ch : str.toCharArray()) {
              list.add(ch);
          }
  
          return list.stream();
      }

1.2.3 sort 自然排序和定制排序：

public class Employee {
    private int id;
    private String name;
    private int age;
    private Double salary;

}

  @Test
    public void test9() {
        emps.stream()
                .map(Employee::getName)
                .sorted()
                .forEach(System.out::println);

        System.out.println("------------------------------------");

        emps.stream()
                .sorted((x, y) -> {
                    if (x.getAge() == y.getAge()) {
                        //两种排序方式
                        return x.getName().compareTo(y.getName());
                    } else {
                        return Integer.compare(x.getAge(), y.getAge());
                    }
                }).forEach(System.out::println);

        System.out.println("---------------------------------------------");
        List<String> list1 = Arrays.asList("zzzzzz", "aaaa", "bbbb", "cccc", "ddddd", "eeeee");
        list1.stream().sorted().forEach(System.out::println);

    }

1.3add and andAll difference:

add 和addall 区别：

1、add 是把集合添加进去，addAll 是把集合中的元素添加进去

 @Test
    public void test8() {
        List<String> list1 = Arrays.asList("aaaa", "bbbb", "cccc", "ddddd", "eeeee");
        List list2 = new ArrayList<>();
        list2.add(1111);
        list2.add(2222);

        list2.add(list1);

        System.out.println(list2);
//[1111, 2222, [aaaa, bbbb, cccc, ddddd, eeeee]]
        System.out.println("================================");

        list2.addAll(list1);
        System.out.println(list2);
        //addall  是把集合中的元素取出来添加list1中。  里面的[aaaa, bbbb, cccc, ddddd, eeeee]   是上面添加的
        //[1111, 2222, [aaaa, bbbb, cccc, ddddd, eeeee], aaaa, bbbb, cccc, ddddd, eeeee]

    }

1.4 终止操作

anyMatch	检查是否至少匹配一个元素
noneMatch	检查是否没有匹配的元素
findFirst	返回第一个元素
findAny	返回当前流中的任意元素
count	返回流中元素的总个数
max	返回流中最大值	Optional max = emps.stream().map(Employee::getSalary).max((v1,v2)->Double.compare(v1,v2)); .max(Double::compare); .max((v1,v2)->v1.compareTo(v2));
min	返回流中最小值
reduce	归约。可以将流中元素反复结合起来，得到一个值。
collect	将流转换为其他形式。接收一个 Collector接口的实现，用于给Stream中元素做汇总的方法	.collect(Collectors.toList());.collect(Collectors.toSet()); 放到hashset中：： .collect(Collectors.toCollection(HashSet::new)); .collect(Collectors.maxBy(Double::compare)); 总薪水： .collect(Collectors.summingDouble(Employee::getSalary)); 平均值： .collect(Collectors.averagingDouble(Employee::getSalary)); 总数： .collect(Collectors.counting()); 计算薪水总函数（最大值，最小值、平均值、数量）:.collect(Collectors.summarizingDouble(Employee::getSalary)); 分组：.collect(Collectors.groupingBy(Employee1::getStatus)); 多级分组：Collectors.groupingBy(Employee1::getStatus, Collectors.groupingBy(）。分区：.collect(Collectors.partitioningBy((e) -> e.getSalary() >= 5000)); joining： .collect(Collectors.joining(“,”, “----”, “----”));

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Employee1 {
    private int id;
    private String name;
    private int age;
    private double salary;
    private Status status;

    public enum Status {
        FREE, BUSY, VOCATION;
    }
}

List<Employee1> empss = Arrays.asList(
        new Employee1(102, "李四", 59, 6666.66, Employee1.Status.BUSY),
        new Employee1(101, "张三", 18, 9999.99, Employee1.Status.FREE),
        new Employee1(103, "王五", 28, 3333.33, Employee1.Status.VOCATION),
        new Employee1(104, "赵六", 8, 7777.77, Employee1.Status.BUSY),
        new Employee1(104, "赵六", 8, 7777.77, Employee1.Status.FREE),
        new Employee1(104, "赵六", 8, 7777.77, Employee1.Status.FREE),
        new Employee1(105, "田七", 38, 5555.55, Employee1.Status.BUSY)
);

1.4.1allmatch、anyMatch、noneMatch、max、min

 @Test
    public void test10() {
        //返回false ,并不是匹配所有元素
        boolean bl = empss.stream()
                .allMatch((e) -> e.getStatus().equals(Employee1.Status.BUSY));
        System.out.println(bl);

//true,有这个样的元素
        boolean bl1 = empss.stream()
                .anyMatch((e) -> e.getStatus().equals(Employee1.Status.BUSY));

        System.out.println(bl1);

        //没有匹配元素 false
        boolean bl2 = empss.stream()
                .noneMatch((e) -> e.getStatus().equals(Employee1.Status.BUSY));
        System.out.println(bl2);

//得到最大值
        Optional<Double> max = emps.stream().map(Employee::getSalary)
//                .max(Double::compare);
        .max((v1,v2)->Double.compare(v1,v2));
      // .max((v1,v2)->v1.compareTo(v2));  
      System.out.println(max.get());

//得到最小值，的成员
        Optional<Employee> min = emps.stream().min((v1, v2) -> Double.compare(v1.getSalary(), v2.getSalary()));
        System.out.println(min.get());

//得到薪水的最小值，把薪水通过map映射出来
        Optional<Double> min1 = emps.stream().map(item -> item.getSalary()).min(Double::compare);
        System.out.println(min1.get());
    }

1.4.2reduce

  @Test
    public void test20() {
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

        /**
         * x=0,y=1,x=x+y=1
         * x=1 y=2 x=x+y=3
         * ...........
         */
        Integer sum = list.stream()
                .reduce(0, (x, y) -> x + y);
        System.out.println(sum);


        System.out.println("----------------------------------------");

        Optional<Double> op = emps.stream()
                .map(Employee::getSalary)
                .reduce(Double::sum);
        System.out.println(op.get());


        System.out.println("====");
        double identity = 0.0;
        double d = emps.stream().map(Employee::getSalary)
                .reduce(identity, (x, y) -> x + y);
        System.out.println(d);

        //为什么这个是optional  因为可能为空，而上面那个为什么不是？因为有初始值，所以即使你传入的为null，但结果也不会为空。
        Optional<Double> reduce = emps1.stream().map(Employee::getSalary).filter(item -> {
                    System.out.println("item" + item);
                    boolean equals = item == null;
                    return !equals;
                })
                .reduce(Double::sum);
        //如果上面为null的话，下面可以使用这个变成null。如果有值还会删除你的结果的。
        System.out.println(reduce.orElse(null));

/**
 * itemnull
 * itemnull
 * null
 */
    }

1.4.3 collect

 @Test
    public void test21() {
//        把名字收集到list中去
        List<String> list = emps.stream()
                .map(Employee::getName)
                .collect(Collectors.toList());

        list.forEach(System.out::println);

        System.out.println("----------------------------------");
//        把名字收集到set中去
        Set<String> set = emps.stream()
                .map(Employee::getName)
                .collect(Collectors.toSet());

        set.forEach(System.out::println);

        System.out.println("----------------------------------");

        //把名字放到hashset中去
        HashSet<String> hs = emps.stream()
                .map(Employee::getName)
                .collect(Collectors.toCollection(HashSet::new));
        hs.forEach(System.out::println);
    }


    @Test
    public void test22() {

        Optional<Double> max = emps.stream()
                .map(Employee::getSalary)
                .collect(Collectors.maxBy(Double::compare));
        //如果上面为空的话就为null，不为空就为  计算的值
        /**
         * 结果
         * 9999.99
         * 9999.99
         */
        System.out.println(max.orElse(null));
        System.out.println(max.get());


        Optional<Employee> op = emps.stream()
                .collect(Collectors.minBy((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary())));

        System.out.println(op.get());


        //总薪水
        Double sum = emps.stream()
                .collect(Collectors.summingDouble(Employee::getSalary));
        System.out.println(sum);


        //平均值
        Double avg = emps.stream()
                .collect(Collectors.averagingDouble(Employee::getSalary));
        System.out.println(avg);

        //总数
        Long count = emps.stream()
                .collect(Collectors.counting());

        System.out.println(count);

        System.out.println("--------------------------------------------");

        DoubleSummaryStatistics dss = emps.stream()
                .collect(Collectors.summarizingDouble(Employee::getSalary));

        System.out.println(dss.getMax());
    }


 //计算薪水总和,里面能得到一系列的东西。总函数的形式
    @Test
    public void test28() {

        DoubleSummaryStatistics statistics = emps.stream()
                .collect(Collectors.summarizingDouble(Employee::getSalary));
        System.out.println(statistics.getMax());
        System.out.println(statistics.getAverage());
        System.out.println(statistics.getCount()
        );
        System.out.println(statistics.getMin());
        System.out.println(statistics.getSum());


        IntSummaryStatistics summaryStatistics = emps.stream().collect(Collectors.summarizingInt(Employee::getAge));

//        Collectors.summarizingDouble(Employee::getSalary);
//        System.out.println(sum.get());
    }

 //分组
    @Test
    public void test23() {
        Map<Employee1.Status, List<Employee1>> map = empss.stream()
                .collect(Collectors.groupingBy(Employee1::getStatus));
        System.out.println(map);

//        遍历hashmap
        map.forEach((key, value) -> {
            System.out.println("key" + key + "======value" + value);
        });
    }


    //多级分组
    @Test
    public void test27() {
        Map<Employee1.Status, Map<String, List<Employee1>>> map = empss.stream()
                .collect(Collectors.groupingBy(Employee1::getStatus, Collectors.groupingBy((e) -> {
                    if (((Employee1) e).getAge() >= 60) {
                        return "老年";
                    } else if (((Employee1) e).getAge() >= 35) {
                        return "中年";
                    } else {
                        return "成年";
                    }

                })));

        System.out.println(map);
    }


    //分区
    @Test
    public void test24() {
        Map<Boolean, List<Employee>> map = emps.stream()
                .collect(Collectors.partitioningBy((e) -> e.getSalary() >= 5000));
        System.out.println(map);
    }

    //收集名字，分割，添加前后缀
    @Test
    public void test25() {
        String str = emps.stream()
                .map(Employee::getName)
                .collect(Collectors.joining(",", "----", "----"));

        System.out.println(str);
    }

    //计算薪水总和。
    @Test
    public void test26() {
        Optional<Double> sum = emps.stream()
                .map(Employee::getSalary)
                .collect(Collectors.reducing(Double::sum));
        //结果保存小数点后保存两位
        System.out.println(sum.get().floatValue());
    }


    //计算薪水总和,里面能得到一系列的东西。总函数的形式
    @Test
    public void test28() {

        DoubleSummaryStatistics statistics = emps.stream()
                .collect(Collectors.summarizingDouble(Employee::getSalary));
        System.out.println(statistics.getMax());
        System.out.println(statistics.getAverage());
        System.out.println(statistics.getCount()
        );
        System.out.println(statistics.getMin());
        System.out.println(statistics.getSum());


        IntSummaryStatistics summaryStatistics = emps.stream().collect(Collectors.summarizingInt(Employee::getAge));

//        Collectors.summarizingDouble(Employee::getSalary);
//        System.out.println(sum.get());
    }

1.4.5 将名字拼接起来

@Test
public void test29(){
    String collect = emps.stream().map(Employee::getName)
            .distinct()
            .sorted()
            .collect(Collectors.joining(" "));
    System.out.println(collect);
}
//第二种方法：

  //使用计算的形式,如果没有起始值，不知道加起来的值是字符串还是什么。如果没有起始值需要强制转换一下
        String reduce1 = emps.stream().map(Employee::getName).distinct().sorted()
                .reduce("", String::concat);
        System.out.println(reduce1);



结果 张三李四王五田七赵六