/*

 * Copyright (c) 2012, 2016, 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.Arrays;

import java.util.Collection;

import java.util.Comparator;

import java.util.Objects;

import java.util.Optional;

import java.util.Spliterator;

import java.util.Spliterators;

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.Function;

import java.util.function.IntFunction;

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

     */

    <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);

    /**

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

     *

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