/*

 * Copyright (c) 2012, 2021, Oracle and/or its affiliates. All rights reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the LICENSE file that accompanied this code.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

package java.util.stream;

import java.nio.file.Files;

import java.nio.file.Path;

import java.util.*;

import java.util.concurrent.ConcurrentHashMap;

import java.util.function.BiConsumer;

import java.util.function.BiFunction;

import java.util.function.BinaryOperator;

import java.util.function.Consumer;

import java.util.function.DoubleConsumer;

import java.util.function.Function;

import java.util.function.IntConsumer;

import java.util.function.IntFunction;

import java.util.function.LongConsumer;

import java.util.function.Predicate;

import java.util.function.Supplier;

import java.util.function.ToDoubleFunction;

import java.util.function.ToIntFunction;

import java.util.function.ToLongFunction;

import java.util.function.UnaryOperator;

/**

 * A sequence of elements supporting sequential and parallel aggregate

 * operations.  The following example illustrates an aggregate operation using

 * {@link Stream} and {@link IntStream}:

 *

 * <pre>{@code

 *     int sum = widgets.stream()

 *                      .filter(w -> w.getColor() == RED)

 *                      .mapToInt(w -> w.getWeight())

 *                      .sum();

 * }</pre>

 *

 * In this example, {@code widgets} is a {@code Collection<Widget>}.  We create

 * a stream of {@code Widget} objects via {@link Collection#stream Collection.stream()},

 * filter it to produce a stream containing only the red widgets, and then

 * transform it into a stream of {@code int} values representing the weight of

 * each red widget. Then this stream is summed to produce a total weight.

 *

 * <p>In addition to {@code Stream}, which is a stream of object references,

 * there are primitive specializations for {@link IntStream}, {@link LongStream},

 * and {@link DoubleStream}, all of which are referred to as "streams" and

 * conform to the characteristics and restrictions described here.

 *

 * <p>To perform a computation, stream

 * <a href="package-summary.html#StreamOps">operations</a> are composed into a

 * <em>stream pipeline</em>.  A stream pipeline consists of a source (which

 * might be an array, a collection, a generator function, an I/O channel,

 * etc), zero or more <em>intermediate operations</em> (which transform a

 * stream into another stream, such as {@link Stream#filter(Predicate)}), and a

 * <em>terminal operation</em> (which produces a result or side-effect, such

 * as {@link Stream#count()} or {@link Stream#forEach(Consumer)}).

 * Streams are lazy; computation on the source data is only performed when the

 * terminal operation is initiated, and source elements are consumed only

 * as needed.

 *

 * <p>A stream implementation is permitted significant latitude in optimizing

 * the computation of the result.  For example, a stream implementation is free

 * to elide operations (or entire stages) from a stream pipeline -- and

 * therefore elide invocation of behavioral parameters -- if it can prove that

 * it would not affect the result of the computation.  This means that

 * side-effects of behavioral parameters may not always be executed and should

 * not be relied upon, unless otherwise specified (such as by the terminal

 * operations {@code forEach} and {@code forEachOrdered}). (For a specific

 * example of such an optimization, see the API note documented on the

 * {@link #count} operation.  For more detail, see the

 * <a href="package-summary.html#SideEffects">side-effects</a> section of the

 * stream package documentation.)

 *

 * <p>Collections and streams, while bearing some superficial similarities,

 * have different goals.  Collections are primarily concerned with the efficient

 * management of, and access to, their elements.  By contrast, streams do not

 * provide a means to directly access or manipulate their elements, and are

 * instead concerned with declaratively describing their source and the

 * computational operations which will be performed in aggregate on that source.

 * However, if the provided stream operations do not offer the desired

 * functionality, the {@link #iterator()} and {@link #spliterator()} operations

 * can be used to perform a controlled traversal.

 *

 * <p>A stream pipeline, like the "widgets" example above, can be viewed as

 * a <em>query</em> on the stream source.  Unless the source was explicitly

 * designed for concurrent modification (such as a {@link ConcurrentHashMap}),

 * unpredictable or erroneous behavior may result from modifying the stream

 * source while it is being queried.

 *

 * <p>Most stream operations accept parameters that describe user-specified

 * behavior, such as the lambda expression {@code w -> w.getWeight()} passed to

 * {@code mapToInt} in the example above.  To preserve correct behavior,

 * these <em>behavioral parameters</em>:

 * <ul>

 * <li>must be <a href="package-summary.html#NonInterference">non-interfering</a>

 * (they do not modify the stream source); and</li>

 * <li>in most cases must be <a href="package-summary.html#Statelessness">stateless</a>

 * (their result should not depend on any state that might change during execution

 * of the stream pipeline).</li>

 * </ul>

 *

 * <p>Such parameters are always instances of a

 * <a href="../function/package-summary.html">functional interface</a> such

 * as {@link java.util.function.Function}, and are often lambda expressions or

 * method references.  Unless otherwise specified these parameters must be

 * <em>non-null</em>.

 *

 * <p>A stream should be operated on (invoking an intermediate or terminal stream

 * operation) only once.  This rules out, for example, "forked" streams, where

 * the same source feeds two or more pipelines, or multiple traversals of the

 * same stream.  A stream implementation may throw {@link IllegalStateException}

 * if it detects that the stream is being reused. However, since some stream

 * operations may return their receiver rather than a new stream object, it may

 * not be possible to detect reuse in all cases.

 *

 * <p>Streams have a {@link #close()} method and implement {@link AutoCloseable}.

 * Operating on a stream after it has been closed will throw {@link IllegalStateException}.

 * Most stream instances do not actually need to be closed after use, as they

 * are backed by collections, arrays, or generating functions, which require no

 * special resource management. Generally, only streams whose source is an IO channel,

 * such as those returned by {@link Files#lines(Path)}, will require closing. If a

 * stream does require closing, it must be opened as a resource within a try-with-resources

 * statement or similar control structure to ensure that it is closed promptly after its

 * operations have completed.

 *

 * <p>Stream pipelines may execute either sequentially or in

 * <a href="package-summary.html#Parallelism">parallel</a>.  This

 * execution mode is a property of the stream.  Streams are created

 * with an initial choice of sequential or parallel execution.  (For example,

 * {@link Collection#stream() Collection.stream()} creates a sequential stream,

 * and {@link Collection#parallelStream() Collection.parallelStream()} creates

 * a parallel one.)  This choice of execution mode may be modified by the

 * {@link #sequential()} or {@link #parallel()} methods, and may be queried with

 * the {@link #isParallel()} method.

 *

 * @param <T> the type of the stream elements

 * @since 1.8

 * @see IntStream

 * @see LongStream

 * @see DoubleStream

 * @see <a href="package-summary.html">java.util.stream</a>

 */

public interface Stream<T> extends BaseStream<T, Stream<T>> {

    /**

     * Returns a stream consisting of the elements of this stream that match

     * the given predicate.

     *

     * <p>This is an <a href="package-summary.html#StreamOps">intermediate

     * operation</a>.

     *

     * @param predicate a <a href="package-summary.html#NonInterference">non-interfering</a>,

     *                  <a href="package-summary.html#Statelessness">stateless</a>

     *                  predicate to apply to each element to determine if it

     *                  should be included

     * @return the new stream

     */

    Stream<T> filter(Predicate<? super T> predicate);

    /**

     * Returns a stream consisting of the results of applying the given

     * function to the elements of this stream.

     *

     * <p>This is an <a href="package-summary.html#StreamOps">intermediate

     * operation</a>.

     *

     * @param <R> The element type of the new stream

     * @param mapper a <a href="package-summary.html#NonInterference">non-interfering</a>,

     *               <a href="package-summary.html#Statelessness">stateless</a>

     *               function to apply to each element

     * @return the new stream

     */

    <R> Stream<R> map(Function<? super T, ? extends R> mapper);

    /**

     * Returns an {@code IntStream} consisting of the results of applying the

     * given function to the elements of this stream.

     *

     * <p>This is an <a href="package-summary.html#StreamOps">

     *     intermediate operation</a>.

     *

     * @param mapper a <a href="package-summary.html#NonInterference">non-interfering</a>,

     *               <a href="package-summary.html#Statelessness">stateless</a>

     *               function to apply to each element

     * @return the new stream

     */

    IntStream mapToInt(ToIntFunction<? super T> mapper);

    /**

     * Returns a {@code LongStream} consisting of the results of applying the

     * given function to the elements of this stream.

     *

     * <p>This is an <a href="package-summary.html#StreamOps">intermediate

     * operation</a>.

     *

     * @param mapper a <a href="package-summary.html#NonInterference">non-interfering</a>,

     *               <a href="package-summary.html#Statelessness">stateless</a>

     *               function to apply to each element

     * @return the new stream

     */

    LongStream mapToLong(ToLongFunction<? super T> mapper);

    /**

     * Returns a {@code DoubleStream} consisting of the results of applying the

     * given function to the elements of this stream.

     *

     * <p>This is an <a href="package-summary.html#StreamOps">intermediate

     * operation</a>.

     *

     * @param mapper a <a href="package-summary.html#NonInterference">non-interfering</a>,

     *               <a href="package-summary.html#Statelessness">stateless</a>

     *               function to apply to each element

     * @return the new stream

     */

    DoubleStream mapToDouble(ToDoubleFunction<? super T> mapper);

    /**

     * Returns a stream consisting of the results of replacing each element of

     * this stream with the contents of a mapped stream produced by applying

     * the provided mapping function to each element.  Each mapped stream is

     * {@link java.util.stream.BaseStream#close() closed} after its contents

     * have been placed into this stream.  (If a mapped stream is {@code null}

     * an empty stream is used, instead.)

     *

     * <p>This is an <a href="package-summary.html#StreamOps">intermediate

     * operation</a>.

     *

     * @apiNote

     * The {@code flatMap()} operation has the effect of applying a one-to-many

     * transformation to the elements of the stream, and then flattening the

     * resulting elements into a new stream.

     *

     * <p><b>Examples.</b>

     *

     * <p>If {@code orders} is a stream of purchase orders, and each purchase

     * order contains a collection of line items, then the following produces a

     * stream containing all the line items in all the orders:

     * <pre>{@code

     *     orders.flatMap(order -> order.getLineItems().stream())...

     * }</pre>

     *

     * <p>If {@code path} is the path to a file, then the following produces a

     * stream of the {@code words} contained in that file:

     * <pre>{@code

     *     Stream<String> lines = Files.lines(path, StandardCharsets.UTF_8);

     *     Stream<String> words = lines.flatMap(line -> Stream.of(line.split(" +")));

     * }</pre>

     * The {@code mapper} function passed to {@code flatMap} splits a line,

     * using a simple regular expression, into an array of words, and then

     * creates a stream of words from that array.

     *

     * @param <R> The element type of the new stream

     * @param mapper a <a href="package-summary.html#NonInterference">non-interfering</a>,

     *               <a href="package-summary.html#Statelessness">stateless</a>

     *               function to apply to each element which produces a stream

     *               of new values

     * @return the new stream

     * @see #mapMulti

     */

    <R> Stream<R> flatMap(Function<? super T, ? extends Stream<? extends R>> mapper);

    /**

     * Returns an {@code IntStream} consisting of the results of replacing each

     * element of this stream with the contents of a mapped stream produced by

     * applying the provided mapping function to each element.  Each mapped

     * stream is {@link java.util.stream.BaseStream#close() closed} after its

     * contents have been placed into this stream.  (If a mapped stream is

     * {@code null} an empty stream is used, instead.)

     *

     * <p>This is an <a href="package-summary.html#StreamOps">intermediate

     * operation</a>.

     *

     * @param mapper a <a href="package-summary.html#NonInterference">non-interfering</a>,

     *               <a href="package-summary.html#Statelessness">stateless</a>

     *               function to apply to each element which produces a stream

     *               of new values

     * @return the new stream

     * @see #flatMap(Function)

     */

    IntStream flatMapToInt(Function<? super T, ? extends IntStream> mapper);

    /**

     * Returns an {@code LongStream} consisting of the results of replacing each

     * element of this stream with the contents of a mapped stream produced by

     * applying the provided mapping function to each element.  Each mapped

     * stream is {@link java.util.stream.BaseStream#close() closed} after its

     * contents have been placed into this stream.  (If a mapped stream is

     * {@code null} an empty stream is used, instead.)

     *

     * <p>This is an <a href="package-summary.html#StreamOps">intermediate

     * operation</a>.

     *

     * @param mapper a <a href="package-summary.html#NonInterference">non-interfering</a>,

     *               <a href="package-summary.html#Statelessness">stateless</a>

     *               function to apply to each element which produces a stream

     *               of new values

     * @return the new stream

     * @see #flatMap(Function)

     */

    LongStream flatMapToLong(Function<? super T, ? extends LongStream> mapper);

    /**

     * Returns an {@code DoubleStream} consisting of the results of replacing

     * each element of this stream with the contents of a mapped stream produced

     * by applying the provided mapping function to each element.  Each mapped

     * stream is {@link java.util.stream.BaseStream#close() closed} after its

     * contents have placed been into this stream.  (If a mapped stream is

     * {@code null} an empty stream is used, instead.)

     *

     * <p>This is an <a href="package-summary.html#StreamOps">intermediate

     * operation</a>.

     *

     * @param mapper a <a href="package-summary.html#NonInterference">non-interfering</a>,

     *               <a href="package-summary.html#Statelessness">stateless</a>

     *               function to apply to each element which produces a stream

     *               of new values

     * @return the new stream

     * @see #flatMap(Function)

     */

    DoubleStream flatMapToDouble(Function<? super T, ? extends DoubleStream> mapper);

    // THE EXAMPLES USED IN THE JAVADOC MUST BE IN SYNC WITH THEIR CORRESPONDING

    // TEST IN test/jdk/java/util/stream/examples/JavadocExamples.java.

    /**

     * Returns a stream consisting of the results of replacing each element of

     * this stream with multiple elements, specifically zero or more elements.

     * Replacement is performed by applying the provided mapping function to each

     * element in conjunction with a {@linkplain Consumer consumer} argument

     * that accepts replacement elements. The mapping function calls the consumer

     * zero or more times to provide the replacement elements.

     *

     * <p>This is an <a href="package-summary.html#StreamOps">intermediate

     * operation</a>.

     *

     * <p>If the {@linkplain Consumer consumer} argument is used outside the scope of

     * its application to the mapping function, the results are undefined.

     *

     * @implSpec

     * The default implementation invokes {@link #flatMap flatMap} on this stream,

     * passing a function that behaves as follows. First, it calls the mapper function

     * with a {@code Consumer} that accumulates replacement elements into a newly created

     * internal buffer. When the mapper function returns, it creates a stream from the

     * internal buffer. Finally, it returns this stream to {@code flatMap}.

     *

     * @apiNote

     * This method is similar to {@link #flatMap flatMap} in that it applies a one-to-many

     * transformation to the elements of the stream and flattens the result elements

     * into a new stream. This method is preferable to {@code flatMap} in the following

     * circumstances:

     * <ul>

     * <li>When replacing each stream element with a small (possibly zero) number of

     * elements. Using this method avoids the overhead of creating a new Stream instance

     * for every group of result elements, as required by {@code flatMap}.</li>

     * <li>When it is easier to use an imperative approach for generating result

     * elements than it is to return them in the form of a Stream.</li>

     * </ul>

     *

     * <p>If a lambda expression is provided as the mapper function argument, additional type

     * information may be necessary for proper inference of the element type {@code <R>} of

     * the returned stream. This can be provided in the form of explicit type declarations for

     * the lambda parameters or as an explicit type argument to the {@code mapMulti} call.

     *

     * <p><b>Examples</b>

     *

     * <p>Given a stream of {@code Number} objects, the following

     * produces a list containing only the {@code Integer} objects:

     * <pre>{@code

     *     Stream<Number> numbers = ... ;

     *     List<Integer> integers = numbers.<Integer>mapMulti((number, consumer) -> {

     *             if (number instanceof Integer i)

     *                 consumer.accept(i);

     *         })

     *         .collect(Collectors.toList());

     * }</pre>

     *

     * <p>If we have an {@code Iterable<Object>} and need to recursively expand its elements

     * that are themselves of type {@code Iterable}, we can use {@code mapMulti} as follows:

     * <pre>{@code

     * class C {

     *     static void expandIterable(Object e, Consumer<Object> c) {

     *         if (e instanceof Iterable<?> elements) {

     *             for (Object ie : elements) {

     *                 expandIterable(ie, c);

     *             }

     *         } else if (e != null) {

     *             c.accept(e);

     *         }

     *     }

     *

     *     public static void main(String[] args) {

     *         var nestedList = List.of(1, List.of(2, List.of(3, 4)), 5);

     *         Stream<Object> expandedStream = nestedList.stream().mapMulti(C::expandIterable);

     *     }

     * }

     * }</pre>

     *

     * @param <R> The element type of the new stream

     * @param mapper a <a href="package-summary.html#NonInterference">non-interfering</a>,

     *               <a href="package-summary.html#Statelessness">stateless</a>

     *               function that generates replacement elements

     * @return the new stream

     * @see #flatMap flatMap

     * @since 16

     */

    default <R> Stream<R> mapMulti(BiConsumer<? super T, ? super Consumer<R>> mapper) {

        Objects.requireNonNull(mapper);

        return flatMap(e -> {

            SpinedBuffer<R> buffer = new SpinedBuffer<>();

            mapper.accept(e, buffer);

            return StreamSupport.stream(buffer.spliterator(), false);

        });

    }

    /**

     * Returns an {@code IntStream} consisting of the results of replacing each

     * element of this stream with multiple elements, specifically zero or more

     * elements.

     * Replacement is performed by applying the provided mapping function to each

     * element in conjunction with a {@linkplain IntConsumer consumer} argument

     * that accepts replacement elements. The mapping function calls the consumer

     * zero or more times to provide the replacement elements.

     *

     * <p>This is an <a href="package-summary.html#StreamOps">intermediate

     * operation</a>.

     *

     * <p>If the {@linkplain IntConsumer consumer} argument is used outside the scope of

     * its application to the mapping function, the results are undefined.

     *

     * @implSpec

     * The default implementation invokes {@link #flatMapToInt flatMapToInt} on this stream,

     * passing a function that behaves as follows. First, it calls the mapper function

     * with an {@code IntConsumer} that accumulates replacement elements into a newly created

     * internal buffer. When the mapper function returns, it creates an {@code IntStream} from

     * the internal buffer. Finally, it returns this stream to {@code flatMapToInt}.

     *

     * @param mapper a <a href="package-summary.html#NonInterference">non-interfering</a>,

     *               <a href="package-summary.html#Statelessness">stateless</a>

     *               function that generates replacement elements

     * @return the new stream

     * @see #mapMulti mapMulti

     * @since 16

     */

    default IntStream mapMultiToInt(BiConsumer<? super T, ? super IntConsumer> mapper) {

        Objects.requireNonNull(mapper);

        return flatMapToInt(e -> {

            SpinedBuffer.OfInt buffer = new SpinedBuffer.OfInt();

            mapper.accept(e, buffer);

            return StreamSupport.intStream(buffer.spliterator(), false);

        });

    }

    /**

     * Returns a {@code LongStream} consisting of the results of replacing each

     * element of this stream with multiple elements, specifically zero or more

     * elements.

     * Replacement is performed by applying the provided mapping function to each

     * element in conjunction with a {@linkplain LongConsumer consumer} argument

     * that accepts replacement elements. The mapping function calls the consumer

     * zero or more times to provide the replacement elements.

     *

     * <p>This is an <a href="package-summary.html#StreamOps">intermediate

     * operation</a>.

     *

     * <p>If the {@linkplain LongConsumer consumer} argument is used outside the scope of

     * its application to the mapping function, the results are undefined.

     *

     * @implSpec

     * The default implementation invokes {@link #flatMapToLong flatMapToLong} on this stream,

     * passing a function that behaves as follows. First, it calls the mapper function

     * with a {@code LongConsumer} that accumulates replacement elements into a newly created

     * internal buffer. When the mapper function returns, it creates a {@code LongStream} from

     * the internal buffer. Finally, it returns this stream to {@code flatMapToLong}.

     *

     * @param mapper a <a href="package-summary.html#NonInterference">non-interfering</a>,

     *               <a href="package-summary.html#Statelessness">stateless</a>

     *               function that generates replacement elements

     * @return the new stream

     * @see #mapMulti mapMulti

     * @since 16

     */

    default LongStream mapMultiToLong(BiConsumer<? super T, ? super LongConsumer> mapper) {

        Objects.requireNonNull(mapper);

        return flatMapToLong(e -> {

            SpinedBuffer.OfLong buffer = new SpinedBuffer.OfLong();

            mapper.accept(e, buffer);

            return StreamSupport.longStream(buffer.spliterator(), false);

        });

    }

    /**

     * Returns a {@code DoubleStream} consisting of the results of replacing each

     * element of this stream with multiple elements, specifically zero or more

     * elements.

     * Replacement is performed by applying the provided mapping function to each

     * element in conjunction with a {@linkplain DoubleConsumer consumer} argument

     * that accepts replacement elements. The mapping function calls the consumer

     * zero or more times to provide the replacement elements.

     *

     * <p>This is an <a href="package-summary.html#StreamOps">intermediate

     * operation</a>.

     *

     * <p>If the {@linkplain DoubleConsumer consumer} argument is used outside the scope of

     * its application to the mapping function, the results are undefined.

     *

     * @implSpec

     * The default implementation invokes {@link #flatMapToDouble flatMapToDouble} on this stream,

     * passing a function that behaves as follows. First, it calls the mapper function

     * with an {@code DoubleConsumer} that accumulates replacement elements into a newly created

     * internal buffer. When the mapper function returns, it creates a {@code DoubleStream} from

     * the internal buffer. Finally, it returns this stream to {@code flatMapToDouble}.

     *

     * @param mapper a <a href="package-summary.html#NonInterference">non-interfering</a>,

     *               <a href="package-summary.html#Statelessness">stateless</a>

     *               function that generates replacement elements

     * @return the new stream

     * @see #mapMulti mapMulti

     * @since 16

     */

    default DoubleStream mapMultiToDouble(BiConsumer<? super T, ? super DoubleConsumer> mapper) {

        Objects.requireNonNull(mapper);

        return flatMapToDouble(e -> {

            SpinedBuffer.OfDouble buffer = new SpinedBuffer.OfDouble();

            mapper.accept(e, buffer);

            return StreamSupport.doubleStream(buffer.spliterator(), false);

        });

    }

    /**

     * Returns a stream consisting of the distinct elements (according to

     * {@link Object#equals(Object)}) of this stream.

     *

     * <p>For ordered streams, the selection of distinct elements is stable

     * (for duplicated elements, the element appearing first in the encounter

     * order is preserved.)  For unordered streams, no stability guarantees

     * are made.

     *

     * <p>This is a <a href="package-summary.html#StreamOps">stateful

     * intermediate operation</a>.

     *

     * @apiNote

     * Preserving stability for {@code distinct()} in parallel pipelines is

     * relatively expensive (requires that the operation act as a full barrier,

     * with substantial buffering overhead), and stability is often not needed.

     * Using an unordered stream source (such as {@link #generate(Supplier)})

     * or removing the ordering constraint with {@link #unordered()} may result

     * in significantly more efficient execution for {@code distinct()} in parallel

     * pipelines, if the semantics of your situation permit.  If consistency

     * with encounter order is required, and you are experiencing poor performance

     * or memory utilization with {@code distinct()} in parallel pipelines,

     * switching to sequential execution with {@link #sequential()} may improve

     * performance.

     *

     * @return the new stream

     */

    Stream<T> distinct();

    /**

     * Returns a stream consisting of the elements of this stream, sorted

     * according to natural order.  If the elements of this stream are not

     * {@code Comparable}, a {@code java.lang.ClassCastException} may be thrown

     * when the terminal operation is executed.

     *

     * <p>For ordered streams, the sort is stable.  For unordered streams, no

     * stability guarantees are made.

     *

     * <p>This is a <a href="package-summary.html#StreamOps">stateful

     * intermediate operation</a>.

     *

     * @return the new stream

     */

    Stream<T> sorted();

    /**

     * Returns a stream consisting of the elements of this stream, sorted

     * according to the provided {@code Comparator}.

     *

     * <p>For ordered streams, the sort is stable.  For unordered streams, no

     * stability guarantees are made.

     *

     * <p>This is a <a href="package-summary.html#StreamOps">stateful

     * intermediate operation</a>.

     *

     * @param comparator a <a href="package-summary.html#NonInterference">non-interfering</a>,

     *                   <a href="package-summary.html#Statelessness">stateless</a>

     *                   {@code Comparator} to be used to compare stream elements

     * @return the new stream

     */

    Stream<T> sorted(Comparator<? super T> comparator);

    /**

     * Returns a stream consisting of the elements of this stream, additionally

     * performing the provided action on each element as elements are consumed

     * from the resulting stream.

     *

     * <p>This is an <a href="package-summary.html#StreamOps">intermediate

     * operation</a>.

     *

     * <p>For parallel stream pipelines, the action may be called at

     * whatever time and in whatever thread the element is made available by the

     * upstream operation.  If the action modifies shared state,

     * it is responsible for providing the required synchronization.

     *

     * @apiNote This method exists mainly to support debugging, where you want

     * to see the elements as they flow past a certain point in a pipeline:

     * <pre>{@code

     *     Stream.of("one", "two", "three", "four")

     *         .filter(e -> e.length() > 3)

     *         .peek(e -> System.out.println("Filtered value: " + e))

     *         .map(String::toUpperCase)

     *         .peek(e -> System.out.println("Mapped value: " + e))

     *         .collect(Collectors.toList());

     * }</pre>

     *

     * <p>In cases where the stream implementation is able to optimize away the

     * production of some or all the elements (such as with short-circuiting

     * operations like {@code findFirst}, or in the example described in

     * {@link #count}), the action will not be invoked for those elements.

     *

     * @param action a <a href="package-summary.html#NonInterference">

     *                 non-interfering</a> action to perform on the elements as

     *                 they are consumed from the stream

     * @return the new stream

     */

    Stream<T> peek(Consumer<? super T> action);

    /**

     * Returns a stream consisting of the elements of this stream, truncated

     * to be no longer than {@code maxSize} in length.

     *

     * <p>This is a <a href="package-summary.html#StreamOps">short-circuiting

     * stateful intermediate operation</a>.

     *

     * @apiNote

     * While {@code limit()} is generally a cheap operation on sequential

     * stream pipelines, it can be quite expensive on ordered parallel pipelines,

     * especially for large values of {@code maxSize}, since {@code limit(n)}

     * is constrained to return not just any <em>n</em> elements, but the

     * <em>first n</em> elements in the encounter order.  Using an unordered

     * stream source (such as {@link #generate(Supplier)}) or removing the

     * ordering constraint with {@link #unordered()} may result in significant

     * speedups of {@code limit()} in parallel pipelines, if the semantics of

     * your situation permit.  If consistency with encounter order is required,

     * and you are experiencing poor performance or memory utilization with

     * {@code limit()} in parallel pipelines, switching to sequential execution

     * with {@link #sequential()} may improve performance.

     *

     * @param maxSize the number of elements the stream should be limited to

     * @return the new stream

     * @throws IllegalArgumentException if {@code maxSize} is negative

     */

    Stream<T> limit(long maxSize);

    /**

     * Returns a stream consisting of the remaining elements of this stream

     * after discarding the first {@code n} elements of the stream.

     * If this stream contains fewer than {@code n} elements then an

     * empty stream will be returned.

     *

     * <p>This is a <a href="package-summary.html#StreamOps">stateful

     * intermediate operation</a>.

     *

     * @apiNote

     * While {@code skip()} is generally a cheap operation on sequential

     * stream pipelines, it can be quite expensive on ordered parallel pipelines,

     * especially for large values of {@code n}, since {@code skip(n)}

     * is constrained to skip not just any <em>n</em> elements, but the

     * <em>first n</em> elements in the encounter order.  Using an unordered

     * stream source (such as {@link #generate(Supplier)}) or removing the

     * ordering constraint with {@link #unordered()} may result in significant

     * speedups of {@code skip()} in parallel pipelines, if the semantics of

     * your situation permit.  If consistency with encounter order is required,

     * and you are experiencing poor performance or memory utilization with

     * {@code skip()} in parallel pipelines, switching to sequential execution

     * with {@link #sequential()} may improve performance.

     *

     * @param n the number of leading elements to skip

     * @return the new stream

     * @throws IllegalArgumentException if {@code n} is negative

     */

    Stream<T> skip(long n);

    /**

     * Returns, if this stream is ordered, a stream consisting of the longest

     * prefix of elements taken from this stream that match the given predicate.

     * Otherwise returns, if this stream is unordered, a stream consisting of a

     * subset of elements taken from this stream that match the given predicate.

     *

     * <p>If this stream is ordered then the longest prefix is a contiguous

     * sequence of elements of this stream that match the given predicate.  The

     * first element of the sequence is the first element of this stream, and

     * the element immediately following the last element of the sequence does

     * not match the given predicate.

     *

     * <p>If this stream is unordered, and some (but not all) elements of this

     * stream match the given predicate, then the behavior of this operation is

     * nondeterministic; it is free to take any subset of matching elements

     * (which includes the empty set).

     *

     * <p>Independent of whether this stream is ordered or unordered if all

     * elements of this stream match the given predicate then this operation

     * takes all elements (the result is the same as the input), or if no

     * elements of the stream match the given predicate then no elements are

     * taken (the result is an empty stream).

     *

     * <p>This is a <a href="package-summary.html#StreamOps">short-circuiting

     * stateful intermediate operation</a>.

     *

     * @implSpec

     * The default implementation obtains the {@link #spliterator() spliterator}

     * of this stream, wraps that spliterator so as to support the semantics

     * of this operation on traversal, and returns a new stream associated with

     * the wrapped spliterator.  The returned stream preserves the execution

     * characteristics of this stream (namely parallel or sequential execution

     * as per {@link #isParallel()}) but the wrapped spliterator may choose to

     * not support splitting.  When the returned stream is closed, the close

     * handlers for both the returned and this stream are invoked.

     *

     * @apiNote

     * While {@code takeWhile()} is generally a cheap operation on sequential

     * stream pipelines, it can be quite expensive on ordered parallel

     * pipelines, since the operation is constrained to return not just any

     * valid prefix, but the longest prefix of elements in the encounter order.

     * Using an unordered stream source (such as {@link #generate(Supplier)}) or

     * removing the ordering constraint with {@link #unordered()} may result in

     * significant speedups of {@code takeWhile()} in parallel pipelines, if the

     * semantics of your situation permit.  If consistency with encounter order

     * is required, and you are experiencing poor performance or memory

     * utilization with {@code takeWhile()} in parallel pipelines, switching to

     * sequential execution with {@link #sequential()} may improve performance.

     *

     * @param predicate a <a href="package-summary.html#NonInterference">non-interfering</a>,

     *                  <a href="package-summary.html#Statelessness">stateless</a>

     *                  predicate to apply to elements to determine the longest

     *                  prefix of elements.

     * @return the new stream

     * @since 9

     */

    default Stream<T> takeWhile(Predicate<? super T> predicate) {

        Objects.requireNonNull(predicate);

        // Reuses the unordered spliterator, which, when encounter is present,

        // is safe to use as long as it configured not to split

        return StreamSupport.stream(

                new WhileOps.UnorderedWhileSpliterator.OfRef.Taking<>(spliterator(), true, predicate),

                isParallel()).onClose(this::close);

    }

    /**

     * Returns, if this stream is ordered, a stream consisting of the remaining

     * elements of this stream after dropping the longest prefix of elements

     * that match the given predicate.  Otherwise returns, if this stream is

     * unordered, a stream consisting of the remaining elements of this stream

     * after dropping a subset of elements that match the given predicate.

     *

     * <p>If this stream is ordered then the longest prefix is a contiguous

     * sequence of elements of this stream that match the given predicate.  The

     * first element of the sequence is the first element of this stream, and

     * the element immediately following the last element of the sequence does

     * not match the given predicate.

     *

     * <p>If this stream is unordered, and some (but not all) elements of this

     * stream match the given predicate, then the behavior of this operation is

     * nondeterministic; it is free to drop any subset of matching elements

     * (which includes the empty set).

     *

     * <p>Independent of whether this stream is ordered or unordered if all

     * elements of this stream match the given predicate then this operation

     * drops all elements (the result is an empty stream), or if no elements of

     * the stream match the given predicate then no elements are dropped (the

     * result is the same as the input).

     *

     * <p>This is a <a href="package-summary.html#StreamOps">stateful

     * intermediate operation</a>.

     *

     * @implSpec

     * The default implementation obtains the {@link #spliterator() spliterator}

     * of this stream, wraps that spliterator so as to support the semantics

     * of this operation on traversal, and returns a new stream associated with

     * the wrapped spliterator.  The returned stream preserves the execution

     * characteristics of this stream (namely parallel or sequential execution

     * as per {@link #isParallel()}) but the wrapped spliterator may choose to

     * not support splitting.  When the returned stream is closed, the close

     * handlers for both the returned and this stream are invoked.

     *

     * @apiNote

     * While {@code dropWhile()} is generally a cheap operation on sequential

     * stream pipelines, it can be quite expensive on ordered parallel

     * pipelines, since the operation is constrained to return not just any

     * valid prefix, but the longest prefix of elements in the encounter order.

     * Using an unordered stream source (such as {@link #generate(Supplier)}) or

     * removing the ordering constraint with {@link #unordered()} may result in

     * significant speedups of {@code dropWhile()} in parallel pipelines, if the

     * semantics of your situation permit.  If consistency with encounter order

     * is required, and you are experiencing poor performance or memory

     * utilization with {@code dropWhile()} in parallel pipelines, switching to

     * sequential execution with {@link #sequential()} may improve performance.

     *

     * @param predicate a <a href="package-summary.html#NonInterference">non-interfering</a>,

     *                  <a href="package-summary.html#Statelessness">stateless</a>

     *                  predicate to apply to elements to determine the longest

     *                  prefix of elements.

     * @return the new stream

     * @since 9

     */

    default Stream<T> dropWhile(Predicate<? super T> predicate) {

        Objects.requireNonNull(predicate);

        // Reuses the unordered spliterator, which, when encounter is present,

        // is safe to use as long as it configured not to split

        return StreamSupport.stream(

                new WhileOps.UnorderedWhileSpliterator.OfRef.Dropping<>(spliterator(), true, predicate),

                isParallel()).onClose(this::close);

    }

    /**

     * Performs an action for each element of this stream.

     *

     * <p>This is a <a href="package-summary.html#StreamOps">terminal

     * operation</a>.

     *

     * <p>The behavior of this operation is explicitly nondeterministic.

     * For parallel stream pipelines, this operation does <em>not</em>

     * guarantee to respect the encounter order of the stream, as doing so

     * would sacrifice the benefit of parallelism.  For any given element, the

     * action may be performed at whatever time and in whatever thread the

     * library chooses.  If the action accesses shared state, it is

     * responsible for providing the required synchronization.

     *

     * @param action a <a href="package-summary.html#NonInterference">

     *               non-interfering</a> action to perform on the elements

     */

    void forEach(Consumer<? super T> action);

    /**

     * Performs an action for each element of this stream, in the encounter

     * order of the stream if the stream has a defined encounter order.

     *

     * <p>This is a <a href="package-summary.html#StreamOps">terminal

     * operation</a>.

     *

     * <p>This operation processes the elements one at a time, in encounter

     * order if one exists.  Performing the action for one element

     * <a href="../concurrent/package-summary.html#MemoryVisibility"><i>happens-before</i></a>

     * performing the action for subsequent elements, but for any given element,

     * the action may be performed in whatever thread the library chooses.

     *

     * @param action a <a href="package-summary.html#NonInterference">

     *               non-interfering</a> action to perform on the elements

     * @see #forEach(Consumer)

     */

    void forEachOrdered(Consumer<? super T> action);

    /**

     * Returns an array containing the elements of this stream.

     *

     * <p>This is a <a href="package-summary.html#StreamOps">terminal

     * operation</a>.

     *

     * @return an array, whose {@linkplain Class#getComponentType runtime component

     * type} is {@code Object}, containing the elements of this stream

     */

    Object[] toArray();

    /**

     * Returns an array containing the elements of this stream, using the

     * provided {@code generator} function to allocate the returned array, as

     * well as any additional arrays that might be required for a partitioned

     * execution or for resizing.

     *

     * <p>This is a <a href="package-summary.html#StreamOps">terminal

     * operation</a>.

     *

     * @apiNote

     * The generator function takes an integer, which is the size of the

     * desired array, and produces an array of the desired size.  This can be

     * concisely expressed with an array constructor reference:

     * <pre>{@code

     *     Person[] men = people.stream()

     *                          .filter(p -> p.getGender() == MALE)

     *                          .toArray(Person[]::new);

     * }</pre>

     *

     * @param <A> the component type of the resulting array

     * @param generator a function which produces a new array of the desired

     *                  type and the provided length

     * @return an array containing the elements in this stream

     * @throws ArrayStoreException if the runtime type of any element of this

     *         stream is not assignable to the {@linkplain Class#getComponentType

     *         runtime component type} of the generated array

     */

    <A> A[] toArray(IntFunction<A[]> generator);

    /**

     * Performs a <a href="package-summary.html#Reduction">reduction</a> on the

     * elements of this stream, using the provided identity value and an

     * <a href="package-summary.html#Associativity">associative</a>

     * accumulation function, and returns the reduced value.  This is equivalent

     * to:

     * <pre>{@code

     *     T result = identity;

     *     for (T element : this stream)

     *         result = accumulator.apply(result, element)

     *     return result;

     * }</pre>

     *

     * but is not constrained to execute sequentially.

     *

     * <p>The {@code identity} value must be an identity for the accumulator

     * function. This means that for all {@code t},

     * {@code accumulator.apply(identity, t)} is equal to {@code t}.

     * The {@code accumulator} function must be an

     * <a href="package-summary.html#Associativity">associative</a> function.

     *

     * <p>This is a <a href="package-summary.html#StreamOps">terminal

     * operation</a>.

     *

     * @apiNote Sum, min, max, average, and string concatenation are all special

     * cases of reduction. Summing a stream of numbers can be expressed as:

     *

     * <pre>{@code

     *     Integer sum = integers.reduce(0, (a, b) -> a+b);

     * }</pre>

     *

     * or:

     *

     * <pre>{@code

     *     Integer sum = integers.reduce(0, Integer::sum);

     * }</pre>

     *

     * <p>While this may seem a more roundabout way to perform an aggregation

     * compared to simply mutating a running total in a loop, reduction

     * operations parallelize more gracefully, without needing additional

     * synchronization and with greatly reduced risk of data races.

     *

     * @param identity the identity value for the accumulating function

     * @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 combining two values

     * @return the result of the reduction

     */

    T reduce(T identity, BinaryOperator<T> accumulator);

    /**

     * Performs a <a href="package-summary.html#Reduction">reduction</a> on the

     * elements of this stream, using an

     * <a href="package-summary.html#Associativity">associative</a> accumulation

     * function, and returns an {@code Optional} describing the reduced value,

     * if any. This is equivalent to:

     * <pre>{@code

     *     boolean foundAny = false;

     *     T result = null;

     *     for (T element : this stream) {

     *         if (!foundAny) {

     *             foundAny = true;

     *             result = element;

     *         }

     *         else

     *             result = accumulator.apply(result, element);

     *     }

     *     return foundAny ? Optional.of(result) : Optional.empty();

     * }</pre>

     *

     * but is not constrained to execute sequentially.

     *

     * <p>The {@code accumulator} function must be an

     * <a href="package-summary.html#Associativity">associative</a> function.

     *

     * <p>This is a <a href="package-summary.html#StreamOps">terminal

     * operation</a>.

     *

     * @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 combining two values

     * @return an {@link Optional} describing the result of the reduction

     * @throws NullPointerException if the result of the reduction is null

     * @see #reduce(Object, BinaryOperator)

     * @see #min(Comparator)

     * @see #max(Comparator)

     */

    Optional<T> reduce(BinaryOperator<T> accumulator);

    /**

     * Performs a <a href="package-summary.html#Reduction">reduction</a> on the

     * elements of this stream, using the provided identity, accumulation and

     * combining functions.  This is equivalent to:

     * <pre>{@code

     *     U result = identity;

     *     for (T element : this stream)

     *         result = accumulator.apply(result, element)

     *     return result;

     * }</pre>

     *

     * but is not constrained to execute sequentially.

     *

     * <p>The {@code identity} value must be an identity for the combiner

     * function.  This means that for all {@code u}, {@code combiner(identity, u)}

     * is equal to {@code u}.  Additionally, the {@code combiner} function

     * must be compatible with the {@code accumulator} function; for all

     * {@code u} and {@code t}, the following must hold:

     * <pre>{@code

     *     combiner.apply(u, accumulator.apply(identity, t)) == accumulator.apply(u, t)

     * }</pre>

     *

     * <p>This is a <a href="package-summary.html#StreamOps">terminal

     * operation</a>.

     *

     * @apiNote Many reductions using this form can be represented more simply

     * by an explicit combination of {@code map} and {@code reduce} operations.

     * The {@code accumulator} function acts as a fused mapper and accumulator,

     * which can sometimes be more efficient than separate mapping and reduction,

     * such as when knowing the previously reduced value allows you to avoid

     * some computation.

     *

     * @param <U> The type of the result

     * @param identity the identity value for the combiner function

     * @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

     * @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

     *                    compatible with the accumulator function

     * @return the result of the reduction

     * @see #reduce(BinaryOperator)

     * @see #reduce(Object, BinaryOperator)

     */

    <U> U reduce(U identity,

                 BiFunction<U, ? super T, U> accumulator,

                 BinaryOperator<U> combiner);

    /**

     * Performs a <a href="package-summary.html#MutableReduction">mutable

     * reduction</a> operation on the elements of this stream.  A mutable

     * reduction is one in which the reduced value is a mutable result container,

     * such as an {@code ArrayList}, and elements are incorporated by updating

     * the state of the result rather than by replacing the result.  This

     * produces a result equivalent to:

     * <pre>{@code

     *     R result = supplier.get();

     *     for (T element : this stream)

     *         accumulator.accept(result, element);

     *     return result;

     * }</pre>

     *

     * <p>Like {@link #reduce(Object, BinaryOperator)}, {@code collect} operations

     * can be parallelized without requiring additional synchronization.

     *

     * <p>This is a <a href="package-summary.html#StreamOps">terminal

     * operation</a>.

     *

     * @apiNote There are many existing classes in the JDK whose signatures are

     * well-suited for use with method references as arguments to {@code collect()}.

     * For example, the following will accumulate strings into an {@code ArrayList}:

     * <pre>{@code

     *     List<String> asList = stringStream.collect(ArrayList::new, ArrayList::add,

     *                                                ArrayList::addAll);

     * }</pre>

     *

     * <p>The following will take a stream of strings and concatenates them into a

     * single string:

     * <pre>{@code

     *     String concat = stringStream.collect(StringBuilder::new, StringBuilder::append,

     *                                          StringBuilder::append)

     *                                 .toString();

     * }</pre>

     *

     * @param <R> the type of the mutable result container

     * @param supplier a function that creates a new mutable result container.

     *                 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 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 that accepts two partial result containers

     *                    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

     */

    <R> R collect(Supplier<R> supplier,

                  BiConsumer<R, ? super T> accumulator,

                  BiConsumer<R, R> combiner);

    /**

     * Performs a <a href="package-summary.html#MutableReduction">mutable

     * reduction</a> operation on the elements of this stream using a

     * {@code Collector}.  A {@code Collector}

     * encapsulates the functions used as arguments to

     * {@link #collect(Supplier, BiConsumer, BiConsumer)}, allowing for reuse of

     * collection strategies and composition of collect operations such as

     * multiple-level grouping or partitioning.

     *

     * <p>If the stream is parallel, and the {@code Collector}

     * is {@link Collector.Characteristics#CONCURRENT concurrent}, and

     * either the stream is unordered or the collector is

     * {@link Collector.Characteristics#UNORDERED unordered},

     * then a concurrent reduction will be performed (see {@link Collector} for

     * details on concurrent reduction.)

     *

     * <p>This is a <a href="package-summary.html#StreamOps">terminal

     * operation</a>.

     *

     * <p>When executed in parallel, multiple intermediate results may be

     * instantiated, populated, and merged so as to maintain isolation of

     * mutable data structures.  Therefore, even when executed in parallel

     * with non-thread-safe data structures (such as {@code ArrayList}), no

     * additional synchronization is needed for a parallel reduction.

     *

     * @apiNote

     * The following will accumulate strings into a List:

     * <pre>{@code

     *     List<String> asList = stringStream.collect(Collectors.toList());

     * }</pre>

     *

     * <p>The following will classify {@code Person} objects by city:

     * <pre>{@code

     *     Map<String, List<Person>> peopleByCity

     *         = personStream.collect(Collectors.groupingBy(Person::getCity));

     * }</pre>

     *

     * <p>The following will classify {@code Person} objects by state and city,

     * cascading two {@code Collector}s together:

     * <pre>{@code

     *     Map<String, Map<String, List<Person>>> peopleByStateAndCity

     *         = personStream.collect(Collectors.groupingBy(Person::getState,

     *                                                      Collectors.groupingBy(Person::getCity)));

     * }</pre>

     *

     * @param <R> the type of the result

     * @param <A> the intermediate accumulation type of the {@code Collector}

     * @param collector the {@code Collector} describing the reduction

     * @return the result of the reduction

     * @see #collect(Supplier, BiConsumer, BiConsumer)

     * @see Collectors

     */

    <R, A> R collect(Collector<? super T, A, R> collector);

    /**

     * Accumulates the elements of this stream into a {@code List}. The elements in

     * the list will be in this stream's encounter order, if one exists. The returned List

     * is unmodifiable; calls to any mutator method will always cause

     * {@code UnsupportedOperationException} to be thrown. There are no

     * guarantees on the implementation type or serializability of the returned List.

     *

     * <p>The returned instance may be <a href="{@docRoot}/java.base/java/lang/doc-files/ValueBased.html">value-based</a>.

     * Callers should make no assumptions about the identity of the returned instances.

     * Identity-sensitive operations on these instances (reference equality ({@code ==}),

     * identity hash code, and synchronization) are unreliable and should be avoided.