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核心技术卷二