Java8新特性之Stream

流是一个顺序的数据管道，流的使用包括创建、操作和终止三部分，终止后流就不可再访问。

创建流

1.通过集合创建

Stream<Integer> stream = new ArrayList<Integer>().stream();

2.通过数组创建

// 基本类型有对应的流
IntStream intStream = Arrays.stream(new int[]{1, 2, 3});
// 引用类型用通用流
Stream<Integer> stream = Arrays.stream(new Integer[]{1, 2, 3});

3.通过Stream.of()创建

Stream<Integer> stream = Stream.of(1, 2, 3);

4.通过Stream.iterate()创建，是一个通过初始种子不断扩张的无限流

// 初始种子为1，后续不断+1的无限流
Stream<Integer> stream = Stream.iterate(1, a -> a + 1);

5.通过Stream.generate()方法创建无限流，传入创建方法；

Stream<Integer> stream = Stream.generate(()->1);

中间操作

中间操作的返回结果都是流，所以可以通过fun1().fun2().fun3()的方式进行连续操作。

tip：需要注意的是，中间操作是惰性执行的，只有碰到终止语句时才会执行。

1.limit(n)：截取前n个元素

2.filter(boolean function())：按条件过滤

3.distinct：去重

4.skip：跳过前n个

Stream<Integer> stream = Stream.of(1, 1, 2, 3, 4, 5, 6, 7);
stream.filter(a->a < 5) // 1, 1, 2, 3, 4
        .distinct() // 1, 2, 3, 4
        .limit(3) // 1, 2, 3
        .skip(1) // 2, 3
        .forEach(System.out::println);

5.map(方法)：通过某个方法将流中的元素映射到另一个流中

stream.map(a -> a * 10).forEach(System.out::println);

6.flatmap：每个元素被转化成一个流，所有流被展平，即拼接。

Stream<String> stream = Stream.of("123", "456");
stream.flatMap(s -> Arrays.stream(s.split(""))).forEach(System.out::println);

7.sorted：排序，同普通Collections.sorted()

终止操作

1.forEach()：从头遍历元素

2.allMatch(boolean function())：所有元素满足匹配条件，返回true

3.anyMatch()：任何元素满足匹配条件，返回true

4.noneMatch()：没有元素满足匹配条件，返回true

5.findFirst()：返回一个元素，用Optional封装，没有元素时返回空Optional；

6.findAny()：返回一个元素，串行下一般是第一个元素，并行下不确定会是哪个元素；

7.count、max、min：统计

8.reduce：对流中的元素逐一进行累积操作

Stream<Integer> stream = Stream.generate(()->1).limit(100);
// 从第一个元素开始，进行累加，返回所有元素的和
System.out.println(stream.reduce((a, b)->a + b)); // 100
// 自定义初始值的累积计算
System.out.println(stream.reduce(100, (a, b)->a + b)); // 200
// 前两个参数同上，第三个参数是子任务合并的逻辑，各子任务都会使用定义的第一个参数
System.out.println(stream.parallel().reduce(100, (a, b)->a + b, (c, d)->c + d)); // 结果为100 + 100 * 具体流的数量
System.out.println(stream.parallel().reduce(0, (a, b)->a + b, (c, d)->c + d)); // 结果为100 + 0 * 具体流的数量 = 100

9.Collection：将流转化为集合

List<Integer> list = stream.collect(Collectors.toList());

并行流

并行流采用了fork/Jion框架，将任务分割成子任务，最终将子任务合并