Stream 流式学习

 

什么是流 Stream API

Stream 不是集合元素，它不是数据结构并不保存数据，它是有关算法和计算的，它更像一个高级版本的 Iterator。

原始版本的 Iterator，用户只能显式地一个一个遍历元素并对其执行某些操作；

高级版本的 Stream，用户只要给出需要对其包含的元素执行什么操作，比如 “过滤掉长度大于 10 的字符串”、“获取每个字符串的首字母”等，Stream 会隐式地在内部进行遍历，做出相应的数据转换。

流的构成：

当我们使用一个流的时候，通常包括三个基本步骤：

      获取一个数据源(source) →  数据转换 →  执行操作获取想要的结果。

1. 创建Stream；

2. 转换Stream，每次转换原有Stream对象不改变，返回一个新的Stream对象（**可以有多次转换**）；

3. 对Stream进行聚合（Reduce）操作，获取想要的结果；

每次转换原有的Stream对象不改变，返回一个新的Stream 对象(可以有多次转换)，这样就允许对其操作可以像链条一样排列，变成一个通道。

第一步：获取数据源    创建stream

• Collection接口的stream()或parallelStream()方法
• 静态的Stream.of()、Stream.empty()方法
• Arrays.stream(array, from, to)
• 静态的Stream.generate()方法生成无限流，接受一个不包含引元的函数
• 静态的Stream.iterate()方法生成无限流，接受一个种子值以及一个迭代函数
• Pattern接口的splitAsStream(input)方法
• 静态的Files.lines(path)、Files.lines(path, charSet)方法
• 静态的Stream.concat()方法将两个流连接起来
• 。。。。

第二步： 中间操作（中间操作不会执行任何操作，直到执行了终止操作时，才会一次性执行所有中间操作， 侧面说明了流是惰性的 ）：转换Stream  比如    筛选和过滤     映射

筛选和过滤

• Stream<T> filter(Predicate<? super T> predicate) 

filter() : 接受一个lambda表达式 (自定以过滤条件 ,返回 boolean)，从流中排除某些元素。

• Stream<T> limit(long maxSize)

limit(maxSize)：截取前maxSize元素的流。但已经满足返回添加，可发生短路，不再继续执行流

• Stream<T> skip(long n)

skip(N): 跳过元素，返回一个扔掉了前个元素的流，如流中的元素不满足N 个，则返回一个空流。 与limit() 互补

• Stream<T> distinct() 

distinct()： 筛选去重，通过流所生成元素的  hashCode() 和equals()   去除重复的元素。 需要重写类的 hashCode() 和equals() 方法

映射：

• <R> Stream<R> map(Function<? super T, ? extends R> mapper);

map（）: 接受一个函数 Function   作为参数，该函数会作用到每个元素上，并将其映射称为一个新的元素。然后返回一个Stream<R> （ 接收Lambda  ,将元素转换成其他形式或提取信息）

• <R> Stream<R> flatMap(Function<? super T, ? extends Stream<? extends R>> mapper)

flatmap() :   接受一个函数 Function   作为参数，将流Stream中的每一个值都换成另一个流Stream,然后将所有的流  合并成一个流 ，然后返回一个Stream<R> 

比较map() 和 flatmap方法可以类比  集合中的 add() 和 addAll() 方法。

排序：

• Stream<T> sorted()
  sorted():  自然排序 ，根据Comparable 进行排序。
• Stream<T> sorted(Comparator<? super T> comparator)  
  sorted(Comparator): 根据Comparator  排序，可自定义排序规则

第三步：终结操作

查找元素：

boolean allMatch(Predicate<? super T> predicate)

allMatch(Predicate)：   流中所有的元素都能够满足 定义的断言规则  就会返回true ，若存在一个元素不满足断言规则，则返回false。

boolean anyMatch(Predicate<? super T> predicate)

anyMatch(Predicate)： 流中任何一个元素能够 满足定义的断言规则 就会返回true ，若所有元素都不满足断言规则，则返回false。

boolean noneMatch(Predicate<? super T> predicate) 

noneMatch(Predicate)： 流中所有元素都无法匹配 定义的断言规则 就会返回true，  若存在一个元素满足断言规则，则返回false。

Optional<T> findAny()

findFirst()： 返回第一个元素

Optional<T> findAny()

findAny() ：返回任意元素，随机返回

组函数：

max(Comparator)：返回指定比较规则 的最大值 对应的元素

min(Comparator)：返回 指定比较规则 的最小值 对应的元素

count() ：返回流中元素的个数

归约

T reduce(T identity, BinaryOperator<T> accumulator)     

reduce(a, fun) a为起始值，作为累积器的起点，reduce方法可以将该流中元素反复结合起来，得到一个新值 类型为T ，该值不可能为空，至少也是  起始值a。

Optional<T> reduce(BinaryOperator<T> accumulator)   （可能为空的值需要封装进Optional 中）

reduce(fun) 从流中计算某个值，接受一个二元函数作为累积器，从前两个元素开始持续应用它，累积器的中间结果作为第一个参数，流元素作为第二个参数。

可结合map形成 map-reduce 模式

收集

<R, A> R collect(Collector<? super T, A, R> collector)

collect(Collector) ：将流转换为其他形式，接受一个收集器Collector,用于给stream中的元素做汇总方法

Collector接口中方法的实现决定了如何对流执行收集操作(如：收集到List  set  map),但是Collectors 实用类提供了很多静态方法，可以方便地创建常见收集器的实例，具体方法与实例如下表：

• • Collectors.toList()    收集到list集合中

  • Collectors.toSet()    收集到set 集合中

  • Collectors.toCollection 收集到指定类型的集合中去， 比如收集到HashSet中   HashSet<String> hs=    ObjectStream.collect(Collectors.toCollection(HashSet::new ))

  • Collectors.toMap(fun1, fun2)   /  toConcurrentMap(fun1, fun2)                            两个fun用来产生键和值，若值为元素本身，则fun2为Function.identity()

  • Collectors.toMap(fun1, fun2, fun3) /    toConcurrentMap(fun1, fun2, fun3)       fun3用于解决键冲突，例如(oldValue, newValue) -> oldValue，有冲突时保

  • 还有 计算 平均值 averagingInt/averagingLong/avergingDouble 最大值maxBy  最小值minBy  总和summingInt/sunmmingLong/summingDouble   分组groupingBy   分区 partitioningBy   组函数合辑 summarizingInt

    等等方法

<R> R collect(Supplier<R> supplier, BiConsumer<R, ? super T> accumulator, BiConsumer<R, R> combiner) 

collect(fun1, fun2, fun3)  ：fun1转换流元素；fun2为累积器，将fun1的转换结果累积起来；fun3为组合器，将并行处理过程中累积器的各个结果组合起来 

forEach(fun)   遍历流中的元素
forEachOrdered(fun)  指定遍历的顺序，遍历流中的元素。 可以应用在并行流上以保持元素顺序
toArray()
toArray(T[] :: new)  返回正确的元素类型

---

参考学习：

https://blog.csdn.net/lixiaobuaa/article/details/81099838