Java8 Stream

Java 8 API添加了一个新的抽象称为流Stream，可以让你以一种声明的方式处理数据。
Stream 使用一种类似用 SQL 语句从数据库查询数据的直观方式来提供一种对 Java 集合运算和表达的高阶抽象。
Stream API可以极大提高Java程序员的生产力，让程序员写出高效率、干净、简洁的代码。
这种风格将要处理的元素集合看作一种流， 流在管道中传输， 并且可以在管道的节点上进行处理， 比如筛选， 排序，聚合等。
元素流在管道中经过中间操作（intermediate operation）的处理，最后由最终操作(terminal operation)得到前面处理的结果。

什么是 Stream？

Stream（流）是一个来自数据源的元素队列并支持聚合操作

• 元素是特定类型的对象，形成一个队列。 Java中的Stream并不会存储元素，而是按需计算。
• 数据源 流的来源。 可以是集合，数组，I/O channel， 产生器generator 等。
• 聚合操作 类似SQL语句一样的操作， 比如filter, map, reduce, find, match, sorted等。
  和以前的Collection操作不同， Stream操作还有两个基础的特征：
• Pipelining: 中间操作都会返回流对象本身。 这样多个操作可以串联成一个管道， 如同流式风格（fluent style）。 这样做可以对操作进行优化， 比如延迟执行(laziness)和短路( short-circuiting)。
• 内部迭代： 以前对集合遍历都是通过Iterator或者For-Each的方式, 显式的在集合外部进行迭代， 这叫做外部迭代。 Stream提供了内部迭代的方式， 通过访问者模式(Visitor)实现。

创建Stream流

1. Collection 提供了两个方法 stream() 与 parallelStream()

List<String> list = new ArrayList<>(); 
Stream<String> stream = list.stream(); //获取一个顺序流 
Stream<String> parallelStream = list.parallelStream(); //获取一个并行流

2. 数组可以通过Arrays类中的stream(…)方法转换成Stream

String[] arr = new String[]{"a", "b", "c"};
Stream<String> stream = Arrays.stream(arr);

3. 通过 Stream 类中静态方法 of()

Stream也提供了API直接生成一个Stream，这个Stream大概可以理解成一个List。因为内部就是数组实现的。

Stream<Integer> stream2 = Stream.of(1, 2, 3, 4, 5, 6);

4. 创建无限流

Stream的静态方法iterate和generate可以创建无限流，因此需要在适当的时候限制一下流元素的长度。

//迭代
 Stream<Integer> stream = Stream.iterate(0, (x) -> x + 2).limit(5);    
//生成
Stream<Double> stream = Stream.generate(Math::random).limit(5); 

Stream流数据操作

1.Intermediate

Intermediate主要是用来对Stream做出相应转换及限制流，实际上是将源Stream转换为一个新的Stream，以达到需求效果。

1）map操作

将一种类型的值映射为另一种类型的值，可以将 Stream 中的每个值都映射为一个新的值，最终转换为一个新的 Stream 流。

Stream.of("java", "scala", "kotlin").map(String::toUpperCase).collect(Collectors.toList()).forEach(System.out::println);

2）.flatMap操作

和map类似，不同的是其每个元素转换得到的是Stream对象，会把子Stream中的元素压缩到父集合中；

List<Integer> a=new ArrayList<>();
        a.add(1);
        a.add(2);
        List<Integer> b=new ArrayList<>();
        b.add(3);
        b.add(4);
        List<Integer> figures=Stream.of(a,b).flatMap(u->u.stream()).collect(Collectors.toList());
        figures.forEach(f->System.out.println(f));

3）concat操作

concat方法将两个Stream连接在一起，合成一个Stream。若两个输入的Stream都时排序的，则新Stream也是排序的；若输入的Stream中任何一个是并行的，则新的Stream也是并行的。

Stream.concat(Stream.of(1, 2, 3), Stream.of(4, 5))
       .forEach(integer -> System.out.print(integer + "  "));

4）distinct操作

distinct方法以达到去除掉原Stream中重复的元素，生成的新Stream中没有没有重复的元素。

Stream.of(1,2,3,1,2,3)
        .distinct()
        .forEach(System.out::println);

5）filter操作

filter 方法用于通过设置的条件过滤出元素。

Stream.of("java", "scala", "kotlin").filter(value -> value.startsWith("k")).collect(Collectors.toList()).forEach(System.out::println);

6）skip操作

返回一个丢弃原Stream的前N个元素后剩下元素组成的新Stream，如果原Stream中包含的元素个数小于N，那么返回空Stream；

Stream.of(1, 2, 3, 5).skip(2).forEach(System.out::println);

7）peek操作

生成一个包含原Stream的所有元素的新Stream，同时会提供一个消费函数（Consumer实例），新Stream每个元素被消费的时候都会执行给定的消费函数；

Stream.of(2, 3, 4).peek(x -> System.out.print(x - 1)).forEach(System.out::print);

8）sorted操作

sorted 方法用于对流就行排序。

Stream.of(1, 2, 3, 5).sorted().forEach(System.out::println);

2.Terminal

1）collect操作

collect()方法是在原数据集的基础上进行更新，过程中不产生新的数据集。Collectors 类实现了很多归约操作，例如将流转换成集合和聚合元素。Collectors 可用于返回列表或字符串。

Stream.of("java", "scala", "kotlin").collect(Collectors.toList()).forEach(System.out::println);

2）count

count方法将返回Stream中元素的个数。

System.out.print(Stream.of("java", "scala", "kotlin").count());

3）reduce操作

根据一定的规则将Stream中的元素进行计算后返回一个唯一的值。

System.out.println(Stream.of(1, 2, 3, 5).reduce((a, b) -> a + b).get());

4）forEach

forEach方法用于遍历Stream中的所元素，避免了使用for循环，让代码更简洁，逻辑更清晰。

Stream.of("java", "scala", "kotlin").forEach(System.out::println);

5）forEachOrdered

forEachOrdered方法与forEach类似，都是遍历Stream中的所有元素，不同的是，如果该Stream预先设定了顺序，会按照预先设定的顺序执行（Stream是无序的），默认为元素插入的顺序。

Stream.of("java", "scala", "kotlin").forEachOrdered(System.out::println);

6）max/min操作

求最大/最小值

System.out.println(Stream.of(1, 2, 3, 4).max(Integer::compareTo).get());

3.Short-circuiting

1）match操作

Stream 有三个 match 方法，从语义上说：
allMatch：Stream 中全部元素符合传入的 predicate，返回 true
anyMatch：Stream 中只要有一个元素符合传入的 predicate，返回 true
noneMatch：Stream 中没有一个元素符合传入的 predicate，返回 true

System.out.println(Stream.of(1, 2, 3, 5).allMatch(num -> num > 3));
System.out.println(Stream.of(1, 2, 3, 5).anyMatch(num -> num > 3));
System.out.println(Stream.of(1, 2, 3, 5).noneMatch(num -> num > 3));

2) findFirst操作

findFirst用于返回满足条件的第一个元素

System.out.println(Stream.of(1, 2, 3, 5).filter(x->x>3).findFirst());

3) findFirst操作

findFirst用于找到所有匹配的元素，只要在任何片段发现了第一个匹配元素就会结束整个运算。

System.out.println(Stream.of(1, 2, 3, 4, 5,6).filter(x->x>2).findAny());

4）limit操作

limit 方法用于获取指定数量的流。

Stream.of(1, 2, 3, 5).limit(2).forEach(System.out::println);