Java Stream从精通到陌生

1.Stream是什么，为什么用它

Stream 是数据渠道，用于操作数据源生成的元素序列，集合讲的是数据，流讲的是计算，就像粮食加工厂一样 粮食就是集合，加工厂就是Stream，对粮食进行一系列的操作。
用来以 做什么而非怎么做 的方式来处理集合
举一个梨子
现在有一个集合

  List<String> strings = Arrays.asList("王1福", "王2福", "王3福", "小王8");

里面混入了一个奇怪的小王8，我想知道里面除了小王8的个数
以前的我

        int count = 0;
        for (String string : strings) {
            if (!string.equals("小王8")) {
                count++;
            }

        }
        System.out.println(count);

会了Stream的我

        long count = strings.stream().filter((x) -> !x.equals("小王8")).count();
        System.out.println(count);

有人肯定会说笨b你都说混入一个奇怪的小王8了你直接获取个数减1不就行了！
我：？？？？
那我现在要给他们排序然后输出
以前的我

        Collections.sort(strings);
        for (String string : strings) {
            System.out.println(string);
        }

会了Stream的我

 strings.stream().sorted(String::compareTo).forEach(System.out::println);

有人肯定会说这不差不多吗？感觉没啥区别啊

那我现在要 取前3个，跳过第一个，然后排序，然后遍历输出
以前的我

不想写

会了Stream的我

strings.stream().limit(3).skip(1).sorted(String::compareTo).forEach(System.out::println);

这时候又有人说了：你说了这么多，我不想学啊

2.Stream怎么用

首先你需要了解Lambda表达式 请看这里Lambda入门
Stream 有三个阶段 1.创建流 2.中间操作，可多步骤 3.终止操作，从而产生结果

流表面上和集合很相似，都可以让我们，转换和获取数据，但是他们中间存在很明显的差异
1.流不存储元素。
2.流的操作不好修改数据源，在我一开始的例子中Collections.sort就修改了数据源
3.流的操作都是惰性的

2.1创建流

1.集合创建流
Collection接口的stream

   List<String> strings = Arrays.asList("王1福", "王2福", "王3福", "小王8"); 
   Stream<String> stream = strings.stream();

2.数组创建流
Arrays.stream()

        String [] strings1={"王1福", "王2福", "王3福", "小王8"};
        Stream<String> stream1 = Arrays.stream(strings1);

3.直接创建

   public static<T> Stream<T> of(T... values) {
        return Arrays.stream(values);
    }
   Stream<Object> empty = Stream.empty();
   Stream<Integer> integerStream = Stream.of(1, 2, 3);
  Stream<Integer> iterate = Stream.iterate(0, (x) -> ++x);

2.2中间操作

2.2.1筛选与切片

    filter：过滤流中的某些元素，保留符合表达式的结果
    limit(n)：获取n个元素
    skip(n)：跳过n元素，配合limit(n)可实现分页
    distinct：通过流中元素的 hashCode() 和 equals() 去除重复元素
    takeWhile： 使用一个断言作为参数，返回给定 Stream 的子集直到断言语句第一次返回 false。如果第一个值不满足断言条件，将返回一个空的 Stream。
    dropWhile:  使用一个断言作为参数， 丢弃给定 Stream 的子集直到断言语句第一次返回 false。如果第一个值不满足断言条件，将返回全部。

        Stream.of(1,2,3).takeWhile((entry)-> entry<3).forEach(System.out::println);//输出： 1  2
        Stream.of(1,2,3).dropWhile((entry)-> entry<2).forEach(System.out::println);//输出： 2  3

2.2.2映射

    map：将元素转换成其他形式或提取信息，将其映射成新的元素，将流添加进流中  与list的add

        List<String> strings = Arrays.asList("a", "b", "c", "d");
        Stream<String> stream = strings.stream();
        stream.map(String::toUpperCase).forEach(System.out::print);//ABCD

map 是的结果是包含了应用该函数后所以产生的所有结果的流，如果它返回的不是一个值而是一个流

    @Test
    public void one() {
        //List<String> strings = Arrays.asList("王1福", "王2福", "王3福", "小王8");
        List<String> strings = Arrays.asList("aaa", "bbbb", "cbbb", "dbbb");
        Stream<String> stream = strings.stream();
        Stream<Stream<String>> streamStream = stream.map(this::letters);
        streamStream.forEach((x) -> {
            x.forEach(System.out::print);
            System.out.println();
        });
    }


    Stream<String> letters(String s) {
        ArrayList<String> result = new ArrayList<>();
        for (int i = 0; i < s.length(); i++) {
            result.add(s.substring(i, i + 1));
        }
        return result.stream();
    }

输出

aaa
bbbb
cbbb
dbbb

    flatMap：接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流。

    @Test
    public void one() {
        //List<String> strings = Arrays.asList("王1福", "王2福", "王3福", "小王8");
        List<String> strings = Arrays.asList("aaa", "bbbb", "cbbb", "dbbb");
        Stream<String> stream = strings.stream();
  
        Stream<String> stringStream = stream.flatMap(this::letters);
        stringStream.forEach(System.out::print);//aaabbbbcbbbdbbb
    }

注意：一个流终止后就不能用了 否则会报IllegalStateException

//流已被操作或关闭
java.lang.IllegalStateException: stream has already been operated upon or closed

JDK 16 新增 Stream.mapMult

    mapMulti与map的区别
    map的映射关系是一对一，即读取一个数据，处理完后，返回一个新数据。
    mapMulti的映射关系是一对多，即读取一个数据，处理完后，可以返回多个新数据。

List<Integer> integers = numbers.<Integer>mapMulti((number, consumer) -> {
                  if (number instanceof Integer i)
                      consumer.accept(i);
             })
              .collect(Collectors.toList());

2.2.3排序

    sorted()：返回由此流的元素组成的流，根据自然顺序排序
    sorted(Comparator com)：定制排序，根据提供的 Comparator进行排序。 

        List<String> strings = Arrays.asList("a", "d", "b", "c");
        //dcba
        strings.stream().sorted((a1, a2) -> a2.compareTo(a1)).forEach(System.out::print);
        //等同于上面
        strings.stream().sorted(Comparator.reverseOrder()).forEach(System.out::print);
        
        //abcd
        strings.stream().sorted((a1, a2) -> a1.compareTo(a2)).forEach(System.out::print);
        //等同于上面
        strings.stream().sorted(Comparator.naturalOrder()).forEach(System.out::print);


//多字段排序 reverse 降序
 list.stream().sorted(Comparator.comparing(类::属性一).reversed().thenComparing(类::属性二));//先以属性一升序,升序结果进行属性一降序,再进行属性二升序
list.stream().sorted(Comparator.comparing(类::属性一,Comparator.reverseOrder()).thenComparing(类::属性二));//先以属性一降序,再进行属性二升序

引用：https://www.cnblogs.com/kuanglongblogs/p/11230250.html

2.3结束操作

2.3.1 查找与匹配

    allMatch：是否匹配所有的元素
    noneMatch：一个匹配的元素都没有
    anyMatch：至少匹配一个元素
    findFirst：返回流中第一个元素
    findAny：返回流中的任意元素
    count：返回流中元素的总个数
    max：返回流中元素最大值
    min：返回流中元素最小值

2.3.2 归约

    reduce ：可以将流中元素反复结合起来 得到一个值

        List<Integer> strings = Arrays.asList(1, 2, 3, 4);
        //起始值
        int loadVar=0;
        Integer reduce = strings.stream().reduce(loadVar, (x, y) -> x + y);

2.3.3 遍历

    forEachOrdered ：按顺序遍历
    forEach：并发遍历

2.3.4 收集

    collect：收集然后将其转换为其他形式，用于汇总操作

常用的一些操作

        List<Integer> strings = Arrays.asList(1, 2, 3, 4);

        // IntStream 转化为list  需要boxed() 因为List不能使用基本类型，需要对其包装
        IntStream.range(0,10).boxed().collect(Collectors.toList());
        
        //总数 4
        Long collect = strings.stream().collect(Collectors.counting());
       

        //int相加 其他类型也有  10
        Integer collect1 = strings.stream().collect(Collectors.summingInt(x -> x));
      

        //转成集合  [1, 2, 3, 4]
        List<Integer> toList = strings.stream().collect(Collectors.toList());
    
        //转成map {1=1, 2=2, 3=3, 4=4}
        Map<Integer, Integer> collect3 = strings.stream().collect(Collectors.toMap((x) -> x, (x) -> x));
      

        //分组 {1=[1], 2=[2], 3=[3], 4=[4]}
        Map<Integer, List<Integer>> collect2 = strings.stream().collect(Collectors.groupingBy(x -> x));
        //分区  {false=[1, 2], true=[3, 4]}
        Map<Boolean, List<Integer>> collect4 = strings.stream().collect(Collectors.partitioningBy((x) -> x > 2));
      


        collect2.forEach((key, val) -> System.out.println(key + "--" + val));
     

2.4并行流

一个内容分成多个数据块，并用多个线程分别处理每个数据块
parallel 转换为 并行流
.sequential 转化为顺序流

        Instant now = Instant.now();

        long reduce = LongStream.range(0, 1000000000).parallel().reduce(0, (x, y) -> x + y);
        Instant end = Instant.now();

        System.out.println("消耗时间"+ Duration.between(now,end).toMillis() +"值"+reduce);

并行流试用的场景
1.Stream.interate 返回的结果不行
2.数据量很大时，不然没有意义
3.流的操作不应该阻塞
只有对已经存在内存中的数据执行大量计算时，才应该使用并行流

注意：因为并行流是使用多线程 在使用时应该注意线程安全问题
比如内部操作一个外部声明的list 应转换为 线程安全的list

Collections.synchronizedList(new ArrayList<>());

2.5 常用操作

2.5.1 取交集，差集，并集

        ArrayList<String> strings1 = new ArrayList<String>();
        strings1.add("1");
        strings1.add("2");
        strings1.add("3");

        ArrayList<String> strings2 = new ArrayList<>();
        strings2.add("3");
        strings2.add("4");
        strings2.add("5");

        //交集
        System.out.println("交集");
        List<String>  intersection = strings1.stream().filter(s ->
                strings2.contains(s)
        ).collect(Collectors.toList());
         intersection.stream().forEach(System.out::print);

        System.out.println("\n差集");
        //差集
        List<String> subtraction = strings1.stream().filter(s ->
                !strings2.contains(s)
        ).collect(Collectors.toList());

        subtraction.stream().forEach(System.out::print);
        System.out.println("\n并集");

        //并集
        ArrayList<String> strings3 = new ArrayList<>();
        strings3.addAll(strings1);
        strings3.addAll(strings2);
        List<String> union  = strings3.stream().distinct().collect(Collectors.toList());
        union .stream().forEach(System.out::print);

输出

交集
3
差集
12
并集
12345

2.5.2 Stream 实现For循环

        int size=8;
        Stream<Integer> iterate = Stream.iterate(0,i -> ++i);
        iterate.limit(size).forEach(System.out::println);

输出

0
1
2
3
4
5
6
7

2.5.3合并数组

Stream.concat(list1.stream(), list2.stream()).collect(Collectors.toList())
Stream.of(list1, list2).flatMap(x -> x.stream()).collect(Collectors.toList())

List的addAll也可以

 ArrayList<RetrieveVO> list = new ArrayList<>(retrieveCmdList.size() + retrieveShortcutCmdList.size());
        list.addAll(retrieveCmdList);
        list.addAll(retrieveShortcutCmdList);

参考
https://www.bilibili.com/video/BV1gJ41137p2?p=21
Java核心技术卷二