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() 去除重复元素

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

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);

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 收集

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

常用的一些操作

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

        //总数 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.流的操作不应该阻塞
只有对已经存在内存中的数据执行大量计算时，才应该使用并行流

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