jdk-sandbox: comparison jdk/src/java.base/share/classes/java/util/stream/IntStream.java

equal deleted inserted replaced

-:c58794ecca6c
+:46132d430504
 * can be parallelized without requiring additional synchronization.
 *
 * <p>This is a <a href="package-summary.html#StreamOps">terminal
 * operation</a>.
 *
-* @param <R> type of the result
+* @param <R> the type of the mutable result container
-* @param supplier a function that creates a new result container. For a
+* @param supplier a function that creates a new mutable result container.
-*                 parallel execution, this function may be called
+*                 For a parallel execution, this function may be called
 *                 multiple times and must return a fresh value each time.
 * @param accumulator an <a href="package-summary.html#Associativity">associative</a>,
 *                    <a href="package-summary.html#NonInterference">non-interfering</a>,
 *                    <a href="package-summary.html#Statelessness">stateless</a>
-*                    function for incorporating an additional element into a result
+*                    function that must fold an element into a result
+*                    container.
 * @param combiner an <a href="package-summary.html#Associativity">associative</a>,
 *                    <a href="package-summary.html#NonInterference">non-interfering</a>,
 *                    <a href="package-summary.html#Statelessness">stateless</a>
-*                    function for combining two values, which must be
+*                    function that accepts two partial result containers
-*                    compatible with the accumulator function
+*                    and merges them, which must be compatible with the
+*                    accumulator function.  The combiner function must fold
+*                    the elements from the second result container into the
+*                    first result container.
 * @return the result of the reduction
 * @see Stream#collect(Supplier, BiConsumer, BiConsumer)
 */
 <R> R collect(Supplier<R> supplier,
 ObjIntConsumer<R> accumulator,
 *
 * <p>The first element (position {@code 0}) in the {@code IntStream} 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 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 IntStream}
 return StreamSupport.intStream(spliterator, false);
 }
 /**
 * Returns a sequential ordered {@code IntStream} produced by iterative
-* application of a function to an initial element, conditioned on
+* application of the given {@code next} function to an initial element,
-* satisfying the supplied predicate.  The stream terminates as soon as
+* conditioned on satisfying the given {@code hasNext} predicate.  The
-* the predicate returns false.
+* stream terminates as soon as the {@code hasNext} predicate returns false.
 *
-* <p>
+* <p>{@code IntStream.iterate} should produce the same sequence of elements as
-* {@code IntStream.iterate} should produce the same sequence of elements
+* produced by the corresponding for-loop:
-* as produced by the corresponding for-loop:
+* <pre>{@code
-* <pre>{@code
+*     for (int index=seed; hasNext.test(index); index = next.applyAsInt(index)) {
-*     for (int index=seed; predicate.test(index); index = f.applyAsInt(index)) {
 *         ...
 *     }
 * }</pre>
 *
-* <p>
+* <p>The resulting sequence may be empty if the {@code hasNext} predicate
-* The resulting sequence may be empty if the predicate does not hold on
+* does not hold on the seed value.  Otherwise the first element will be the
-* the seed value.  Otherwise the first element will be the supplied seed
+* supplied {@code seed} value, the next element (if present) will be the
-* value, the next element (if present) will be the result of applying the
+* result of applying the {@code next} function to the {@code seed} value,
-* function f to the seed value, and so on iteratively until the predicate
+* and so on iteratively until the {@code hasNext} predicate indicates that
-* indicates that the stream should terminate.
+* 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 seed the initial element
-* @param predicate a predicate to apply to elements to determine when the
+* @param hasNext a predicate to apply to elements to determine when the
-*          stream must terminate.
+*                stream must terminate.
-* @param f a function to be applied to the previous element to produce
+* @param next a function to be applied to the previous element to produce
-*          a new element
+*             a new element
 * @return a new sequential {@code IntStream}
 * @since 9
 */
-public static IntStream iterate(int seed, IntPredicate predicate, IntUnaryOperator f) {
+public static IntStream iterate(int seed, IntPredicate hasNext, IntUnaryOperator next) {
-Objects.requireNonNull(f);
+Objects.requireNonNull(next);
-Objects.requireNonNull(predicate);
+Objects.requireNonNull(hasNext);
 Spliterator.OfInt spliterator = new Spliterators.AbstractIntSpliterator(Long.MAX_VALUE,
 Spliterator.ORDERED | Spliterator.IMMUTABLE | Spliterator.NONNULL) {
 int prev;
 boolean started, finished;
 Objects.requireNonNull(action);
 if (finished)
 return false;
 int t;
 if (started)
-t = f.applyAsInt(prev);
+t = next.applyAsInt(prev);
 else {
 t = seed;
 started = true;
 }
-if (!predicate.test(t)) {
+if (!hasNext.test(t)) {
 finished = true;
 return false;
 }
 action.accept(prev = t);
 return true;
 public void forEachRemaining(IntConsumer action) {
 Objects.requireNonNull(action);
 if (finished)
 return;
 finished = true;
-int t = started ? f.applyAsInt(prev) : seed;
+int t = started ? next.applyAsInt(prev) : seed;
-while (predicate.test(t)) {
+while (hasNext.test(t)) {
 action.accept(t);
-t = f.applyAsInt(t);
+t = next.applyAsInt(t);
 }
 }
 };
 return StreamSupport.intStream(spliterator, false);
 }

changeset 40806	46132d430504
parent 39060	d39deb27f118