java8流库之Stream.iterate

简介

java.util.stream.Stream 下共有两个 iterate

• iterate(T seed, final UnaryOperator<T> f)
• iterate(T seed, Predicate<? super T> hasNext, UnaryOperator<T> f)

该方法产生一个无限流，它的元素包含seed，在seed上调用f产生的值、在前一个元素上调用f产生的值，等等。

第一个方法会产生一个无限流，而第二个方法的流会在碰到第一个不满足hasNext谓词的元素时终止

两个参数

/**
 * Returns an infinite sequential ordered {@code Stream} produced by iterative
 * application of a function {@code f} to an initial element {@code seed},
 * producing a {@code Stream} consisting of {@code seed}, {@code f(seed)},
 * {@code f(f(seed))}, etc.
 *
 * <p>The first element (position {@code 0}) in the {@code Stream} will be
 * the provided {@code seed}.  For {@code n > 0}, the element at position
 * {@code n}, will be the result of applying the function {@code f} to the
 * element at position {@code n - 1}.
 *
 * <p>The action of applying {@code f} for one element
 * <a href="../concurrent/package-summary.html#MemoryVisibility"><i>happens-before</i></a>
 * the action of applying {@code f} for subsequent elements.  For any given
 * element the action may be performed in whatever thread the library
 * chooses.
 *
 * @param <T> the type of stream elements
 * @param seed the initial element
 * @param f a function to be applied to the previous element to produce
 *          a new element
 * @return a new sequential {@code Stream}
 */
public static<T> Stream<T> iterate(final T seed, final UnaryOperator<T> f) {
    Objects.requireNonNull(f);
    Spliterator<T> spliterator = new Spliterators.AbstractSpliterator<>(Long.MAX_VALUE,
                                                                        Spliterator.ORDERED | Spliterator.IMMUTABLE) {
        T prev;
        boolean started;

        @Override
        public boolean tryAdvance(Consumer<? super T> action) {
            Objects.requireNonNull(action);
            T t;
            if (started)
                t = f.apply(prev);
            else {
                t = seed;
                started = true;
            }
            action.accept(prev = t);
            return true;
        }
    };
    return StreamSupport.stream(spliterator, false);
}

三个参数

/**
 * Returns a sequential ordered {@code Stream} produced by iterative
 * application of the given {@code next} function to an initial element,
 * conditioned on satisfying the given {@code hasNext} predicate.  The
 * stream terminates as soon as the {@code hasNext} predicate returns false.
 *
 * <p>{@code Stream.iterate} should produce the same sequence of elements as
 * produced by the corresponding for-loop:
 * <pre>{@code
 *     for (T index=seed; hasNext.test(index); index = next.apply(index)) {
 *         ...
 *     }
 * }</pre>
 *
 * <p>The resulting sequence may be empty if the {@code hasNext} predicate
 * does not hold on the seed value.  Otherwise the first element will be the
 * supplied {@code seed} value, the next element (if present) will be the
 * result of applying the {@code next} function to the {@code seed} value,
 * and so on iteratively until the {@code hasNext} predicate indicates that
 * the stream should terminate.
 *
 * <p>The action of applying the {@code hasNext} predicate to an element
 * <a href="../concurrent/package-summary.html#MemoryVisibility"><i>happens-before</i></a>
 * the action of applying the {@code next} function to that element.  The
 * action of applying the {@code next} function for one element
 * <i>happens-before</i> the action of applying the {@code hasNext}
 * predicate for subsequent elements.  For any given element an action may
 * be performed in whatever thread the library chooses.
 *
 * @param <T> the type of stream elements
 * @param seed the initial element
 * @param hasNext a predicate to apply to elements to determine when the
 *                stream must terminate.
 * @param next a function to be applied to the previous element to produce
 *             a new element
 * @return a new sequential {@code Stream}
 * @since 9
 */
public static<T> Stream<T> iterate(T seed, Predicate<? super T> hasNext, UnaryOperator<T> next) {
    Objects.requireNonNull(next);
    Objects.requireNonNull(hasNext);
    Spliterator<T> spliterator = new Spliterators.AbstractSpliterator<>(Long.MAX_VALUE,
           Spliterator.ORDERED | Spliterator.IMMUTABLE) {
        T prev;
        boolean started, finished;

        @Override
        public boolean tryAdvance(Consumer<? super T> action) {
            Objects.requireNonNull(action);
            if (finished)
                return false;
            T t;
            if (started)
                t = next.apply(prev);
            else {
                t = seed;
                started = true;
            }
            if (!hasNext.test(t)) {
                prev = null;
                finished = true;
                return false;
            }
            action.accept(prev = t);
            return true;
        }

        @Override
        public void forEachRemaining(Consumer<? super T> action) {
            Objects.requireNonNull(action);
            if (finished)
                return;
            finished = true;
            T t = started ? next.apply(prev) : seed;
            prev = null;
            while (hasNext.test(t)) {
                action.accept(t);
                t = next.apply(t);
            }
        }
    };
    return StreamSupport.stream(spliterator, false);
}

示例

public static  void main(String args[]) throws IOException {
    Stream<BigInteger> integers = Stream.iterate(BigInteger.ONE, n -> n.add(BigInteger.ONE));
    show("integers", integers);
    System.out.println("end");

}

public static <T> void show(String title, Stream<T> stream) {
    final int SIZE = 10;
    List<T> firstElements = stream.limit(SIZE + 1).collect(Collectors.toList());
    System.out.println(title + ":");

    for (int i = 0; i < firstElements.size(); i++) {
        if (i > 0) System.out.println(",");
        if (i < SIZE) System.out.println(firstElements.get(i));
        else System.out.println("……");
    }
    System.out.println();
}

在执行 Stream.iterate 时并没有生成具体数据，只是产生了一个流，只有在使用时才会有数据

流和集合的区别

1. 流并不存储其元素。这些元素可能存储在底层的集合中，或者是按需生成的
2. 流的操作不会修改其数据源。例如 filter方法不会从流中移除元素，而是会生成一个新的流，其中不包含被过滤掉的元素
3. 流的操作是尽可能惰性执行的。这意味着直至需要其结果时，操作才会执行。例如，如果我们只想查询前5个长单词而不是所有长单词，那么filter方法就会在匹配到第5个单词后停止过滤。因此，我们甚至可以操作无限流（上边的示例就是一个操作无限流的例子）