简介
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;@Overridepublic 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;@Overridepublic 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;}@Overridepublic 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 时并没有生成具体数据，只是产生了一个流，只有在使用时才会有数据
流和集合的区别
- 流并不存储其元素。这些元素可能存储在底层的集合中，或者是按需生成的
- 流的操作不会修改其数据源。例如 filter方法不会从流中移除元素，而是会生成一个新的流，其中不包含被过滤掉的元素
- 流的操作是尽可能惰性执行的。这意味着直至需要其结果时，操作才会执行。例如，如果我们只想查询前5个长单词而不是所有长单词，那么filter方法就会在匹配到第5个单词后停止过滤。因此，我们甚至可以操作无限流（上边的示例就是一个操作无限流的例子）
