Java 8 之 Stream 的创建

Stream

Java 8 中新增的特性旨在帮助程序员写出更好的代码，其中对核心类库的改进主要包括集合类的 API 和 新引入的流(Stream)。Stream 使程序员可以站在更高的抽象层次上对集合进行操作。

---

Stream 实现机制

外部迭代

Java 8 之前，如果要操作一个集合中的元素，就需要遍历集合中元素

        List<Integer> list = new ArrayList<>(Arrays.asList(1, 2, 3));
        int count = 0;
        for (Integer integer : list) {
            if (integer > 1) {
                count++;
            }
        }

这个代码得到了 list 中的大于 1 的元素的个数，其中使用了 foreach 语法进行了遍历，而 foreach 语法是利用了 Iterator 对象来控制的迭代过程，很明显这个是一个外部迭代，只是进行了封装了一层而已。

内部迭代

把上面的代码用流实现

        long count = Stream.of(1, 2, 3)
                .filter(integer -> integer > 1)
                .count();

Stream.of(1,2,3) 把 List 转化为了 Stream，然后在 Stream 的内部进行过滤(filter()) 和 求和(count()) 操作，这样就把外部迭代转化为了内部迭代。

Stream 特性

lazy

Stream 是惰性的(lazy)，就如同 RxJava 中的 lazy Observable 一样。

        Stream<Integer> integerStream = Stream.of(1, 2, 3);
        Stream<Integer> filterStream = integerStream.filter(integer -> {
            Log.d(TAG, "integer = " + integer);
            return integer > 1;
        });

如果运行这段代码，不会有任何 Log 出现，那么 Stream.filter() 有什么作用呢？ Stream.filter() 就如同设计模式中的装饰模式一样，它只是对 Stream 进行装饰，这里的装饰指的就是过滤。

像 Steam.filter() 把一个 Stream 转化为另外一个 Stream 的方法，我称之为 过渡操作符（intermediate operations）。
而如果想要 Stream 运作起来，需要 Steam 中的 终止操作符( terminal operation )，例如 Stream.count();

        Stream<Integer> integerStream = Stream.of(1, 2, 3);
        Stream<Integer> filterStream = integerStream.filter(integer -> {
            Log.d(TAG, "integer = " + integer);
            return integer > 1;
        });
        long count = filterStream.count();

运行这段代码就可以看到 Log 的出现。

一次性

Stream 只能在操作符( Stream 的方法）上执行一次，例如

        Stream<Integer> integerStream = Stream.of(1, 2, 3);
        integerStream.map(integer -> "s");
        integerStream.filter(integer -> integer > 1);

虽然 map 和 filter 都是过渡操作符，但是运行程序后，会报错

java.lang.IllegalStateException: stream has already been operated upon or closed

所以一个流只能执行一次操作。

流的有序性

Stream 如同 RxJava 的 Observable 一样，发射的元素都是有序的

        List<Integer> collect = Stream.of(1, 2, 3, 4, 5)
                .map(integer -> {
                    Log.d(TAG, "step1: " + integer);
                    return integer;
                })
                .map(integer -> {
                    Log.d(TAG, "step2: " + integer);
                    return integer;
                })
                .collect(Collectors.toList());

因为有 及早求值方法 Stream.collect()，所以可以看到 Log 信息

D/david: step1: 1
D/david: step2: 1
D/david: step1: 2
D/david: step2: 2
D/david: step1: 3
D/david: step2: 3
D/david: step1: 4
D/david: step2: 4
D/david: step1: 5
D/david: step2: 5

Log 中很有规律，元素 1 先走完两个 map，然后才是元素 2 走完两个 map，然后是元素 3,4,5。这就如同排队买票一样，只有前面一个人买完了票，后面一个人才能来买票。这就是流的顺序性。

可关闭性

Stream 有一个 close() 方法，并且实现了 AutoCloaseable 接口。但是几乎所有的 Stream 都不需要在使用后关闭。一般来说，只有 Stream 来源于 IO 管道的，需要手动关闭。

顺序执行和并行执行

Stream 可以顺序执行，也可以并行执行。
Stream 也可以由创建的方式来决定顺序执行还是并行执行。例如，list.stream() 创建一个顺序执行的 Stream，而 list.parallelStream() 创建一个并行执行的 Stream。 然而执行的方式是可以通过 Stream.parallel() 和 Stream.sequential() 来改变的。
既然可以改变流的执行方法，自然也可以查询流的执行方式，Stream.isParallel() 方法查询是否并行的流。

---

创建 Stream

Stream.of()

    public static<T> Stream<T> of(T... values) {
        return Arrays.stream(values);
    }

Stream.of() 以类型为 T 的可变长数组 values 作为参数，创建 Stream 对象，例如

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

其中需要注意的是，传入 Stream.of() 参数的类型决定了 Stream 的泛型。那么如果把 List< Integer > 作为参数传入，返回的 Stream 就是 Stream< List< Integer > >

        List<Integer> list = new ArrayList<>(Arrays.asList(1, 2, 3));
        Stream<List<Integer>> listStream = Stream.of(list);

Stream.generate()

Stream.generate(Supplier s) 生成一个无线的流

        Stream<Integer> integerStream = Stream.generate(new Supplier<Integer>() {
            int i = 0;

            @Override
            public Integer get() {
                return i++;
            }
        });

如果我们用一个 Stream 的 终止操作符 就可以看到无限个元素，例如用 Stream.forEach()

        Stream.generate(new Supplier<Integer>() {
            int i = 0;

            @Override
            public Integer get() {
                return i++;
            }
        }).forEach(integer -> Log.d(TAG, "integer = " + integer));

运行后，就可以看到茫茫多的 Log 信息。

在实际中可能只需要这个无限流中的前10，那么可以用 Stream.limite(10) 来限制流中元素的个数

        Stream.generate(new Supplier<Integer>() {
            int i = 0;

            @Override
            public Integer get() {
                return i++;
            }
        }).limit(10).forEach(integer -> Log.d(TAG, "integer = " + integer));

再运行代码，就只能看到前10个元素了。

Stream.iterate()

Stream.iterate() 方法用代码比较好解释，这个方法生成的流的关键代码是 Iterator 中的 next() 方法

    public static<T> Stream<T> iterate(final T seed, final UnaryOperator<T> f) {
        // ...
        final Iterator<T> iterator = new Iterator<T>() {
            @SuppressWarnings("unchecked")
            T t = (T) Streams.NONE;

            @Override
            public boolean hasNext() {
                return true;
            }

            @Override
            public T next() {
                // 生成 Stream 中的元素
                return t = (t == Streams.NONE) ? seed : f.apply(t);
            }
        };
        // 用 iterator 创建 Stream
        // ...
    }

Stream.iterate() 产生的 Stream 的第一个元素是 seed, 后续的元素是 f(seed), f(f(seed)), f(f(f(seed))) … , 例如

        Stream.iterate(1, integer -> ++integer)
                .limit(3)
                .forEach(integer -> Log.d(TAG, "integer = " + integer));

产生的结果就是1,2,3 ，也就是对应的 1 , f(1), f(f(1))。

Stream.Builder.build()

以 Builder 模式创建 Stream

        Stream.Builder<String> builder = Stream.builder();
        builder.add("hello");
        builder.accept("world");
        Stream<String> stream = builder.build();
        stream.forEach(s -> Log.d(TAG, "s = " + s));

add() 和 accept() 从实现上是等效的，只不过 add() 是 default 方法。

Stream.concat()

Stream.concat(Stream< ? extends T > a, Stream< ? extends T > b)，把 Stream b 连接到 Stream a 之后，a 和 b 中元素的顺序不变。

Stream.empty()

创建一个空的 Stream，目前我还不知道这个到底怎么用。

集合创建Stream

        List<Integer> list = Arrays.asList(1, 2, 3);
        Stream<Integer> stream = list.stream();

数组创建Stream

        int[] ints = new int[]{1, 3, 4};
        IntStream stream1 = Arrays.stream(ints);

map 类不能创建 Stream，为何？ 因为 map 类有 key 和 value 两个值，除非把 key, value 转化为一个对象