AbstractStreamEx (StreamEx 0.6.5 API)

Object
- AbstractStreamEx<T,S>

Type Parameters:

T - the type of the stream elements

S - the type of of the stream extending AbstractStreamEx

All Implemented Interfaces:

AutoCloseable, Iterable<T>, BaseStream<T,Stream<T>>, Stream<T>

Direct Known Subclasses:

EntryStream, StreamEx
```
public abstract class AbstractStreamEx<T,S extends AbstractStreamEx<T,S>>
extends Object
implements Stream<T>, Iterable<T>
```
Base class providing common functionality for StreamEx and EntryStream.

Author:

Tagir Valeev

Nested Class Summary
- Nested classes/interfaces inherited from interface Stream
 Stream.Builder<T>

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`boolean`	`allMatch(Predicate<? super T> predicate)` Returns whether all elements of this stream match the provided predicate.
`boolean`	`anyMatch(Predicate<? super T> predicate)` Returns whether any elements of this stream match the provided predicate.
`S`	`append(Stream<? extends T> other)` Creates a lazily concatenated stream whose elements are all the elements of this stream followed by all the elements of the other stream.
`<U> U`	`chain(Function<? super S,U> mapper)` Applies the supplied function to this stream and returns the result of the function.
`void`	`close()` Closes this stream, causing all close handlers for this stream pipeline to be called.
`<R,A> R`	`collect(Collector<? super T,A,R> collector)` Performs a mutable reduction operation on the elements of this stream using a `Collector`.
`<R> R`	`collect(Supplier<R> supplier, BiConsumer<R,? super T> accumulator, BiConsumer<R,R> combiner)` Performs a mutable reduction operation on the elements of this stream.
`long`	`count()` Returns the count of elements in this stream.
`S`	`distinct()` Returns a stream consisting of the distinct elements (according to `Object.equals(Object)`) of this stream.
`S`	`distinct(Function<? super T,?> keyExtractor)` Returns a stream consisting of the distinct elements of this stream (according to object equality of the results of applying the given function).
`S`	`dropWhile(Predicate<? super T> predicate)` Returns a stream consisting of all elements from this stream starting from the first element which does not match the given predicate.
`S`	`filter(Predicate<? super T> predicate)` Returns a stream consisting of the elements of this stream that match the given predicate.
`Optional<T>`	`findAny()` Returns an `Optional` describing some element of the stream, or an empty `Optional` if the stream is empty.
`Optional<T>`	`findAny(Predicate<? super T> predicate)` Returns an `Optional` describing some element of the stream, which matches given predicate, or an empty `Optional` if there's no matching element.
`Optional<T>`	`findFirst()` Returns an `Optional` describing the first element of this stream, or an empty `Optional` if the stream is empty.
`Optional<T>`	`findFirst(Predicate<? super T> predicate)` Returns an `Optional` describing the first element of this stream, which matches given predicate, or an empty `Optional` if there's no matching element.
`<R> StreamEx<R>`	`flatArray(Function<? super T,? extends R[]> mapper)` Returns a stream consisting of the results of replacing each element of this stream with the contents of a mapped array produced by applying the provided mapping function to each element.
`<R> StreamEx<R>`	`flatCollection(Function<? super T,? extends Collection<? extends R>> mapper)` Returns a stream consisting of the results of replacing each element of this stream with the contents of a mapped collection produced by applying the provided mapping function to each element.
`<R> StreamEx<R>`	`flatMap(Function<? super T,? extends Stream<? extends R>> 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.
`DoubleStreamEx`	`flatMapToDouble(Function<? super T,? extends DoubleStream> mapper)` Returns an `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.
`IntStreamEx`	`flatMapToInt(Function<? super T,? extends IntStream> mapper)` Returns an `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.
`LongStreamEx`	`flatMapToLong(Function<? super T,? extends LongStream> mapper)` Returns an `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.
`Optional<T>`	`foldLeft(BinaryOperator<T> accumulator)` Folds the elements of this stream using the provided accumulation function, going left to right.
`<U> U`	`foldLeft(U seed, BiFunction<U,? super T,U> accumulator)` Folds the elements of this stream using the provided seed object and accumulation function, going left to right.
`Optional<T>`	`foldRight(BinaryOperator<T> accumulator)` Folds the elements of this stream using the provided accumulation function, going right to left.
`<U> U`	`foldRight(U seed, BiFunction<? super T,U,U> accumulator)` Folds the elements of this stream using the provided seed object and accumulation function, going right to left.
`void`	`forEach(Consumer<? super T> action)` Performs an action for each element of this stream.
`void`	`forEachOrdered(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.
`OptionalLong`	`indexOf(Predicate<? super T> predicate)` Returns an `OptionalLong` describing the zero-based index of the first element of this stream, which matches given predicate, or an empty `OptionalLong` if there's no matching element.
`OptionalLong`	`indexOf(T element)` Returns an `OptionalLong` describing the zero-based index of the first element of this stream, which equals to the given element, or an empty `OptionalLong` if there's no matching element.
`boolean`	`isParallel()` Returns whether this stream, if a terminal operation were to be executed, would execute in parallel.
`Iterator<T>`	`iterator()` Returns an iterator for the elements of this stream.
`S`	`limit(long maxSize)` Returns a stream consisting of the elements of this stream, truncated to be no longer than `maxSize` in length.
`<R> StreamEx<R>`	`map(Function<? super T,? extends R> mapper)` Returns a stream consisting of the results of applying the given function to the elements of this stream.
`DoubleStreamEx`	`mapToDouble(ToDoubleFunction<? super T> mapper)` Returns a `DoubleStream` consisting of the results of applying the given function to the elements of this stream.
`IntStreamEx`	`mapToInt(ToIntFunction<? super T> mapper)` Returns an `IntStream` consisting of the results of applying the given function to the elements of this stream.
`LongStreamEx`	`mapToLong(ToLongFunction<? super T> mapper)` Returns a `LongStream` consisting of the results of applying the given function to the elements of this stream.
`Optional<T>`	`max(Comparator<? super T> comparator)` Returns the maximum element of this stream according to the provided `Comparator`.
`<V extends Comparable<? super V>> Optional<T>`	`maxBy(Function<? super T,? extends V> keyExtractor)` Returns the maximum element of this stream according to the natural order of the keys extracted by provided function.
`Optional<T>`	`maxByDouble(ToDoubleFunction<? super T> keyExtractor)` Returns the maximum element of this stream according to the double values extracted by provided function.
`Optional<T>`	`maxByInt(ToIntFunction<? super T> keyExtractor)` Returns the maximum element of this stream according to the int values extracted by provided function.
`Optional<T>`	`maxByLong(ToLongFunction<? super T> keyExtractor)` Returns the maximum element of this stream according to the long values extracted by provided function.
`Optional<T>`	`min(Comparator<? super T> comparator)` Returns the minimum element of this stream according to the provided `Comparator`.
`<V extends Comparable<? super V>> Optional<T>`	`minBy(Function<? super T,? extends V> keyExtractor)` Returns the minimum element of this stream according to the natural order of the keys extracted by provided function.
`Optional<T>`	`minByDouble(ToDoubleFunction<? super T> keyExtractor)` Returns the minimum element of this stream according to the double values extracted by provided function.
`Optional<T>`	`minByInt(ToIntFunction<? super T> keyExtractor)` Returns the minimum element of this stream according to the int values extracted by provided function.
`Optional<T>`	`minByLong(ToLongFunction<? super T> keyExtractor)` Returns the minimum element of this stream according to the long values extracted by provided function.
`boolean`	`noneMatch(Predicate<? super T> predicate)` Returns whether no elements of this stream match the provided predicate.
`S`	`nonNull()` Returns a stream consisting of the elements of this stream that aren't null.
`S`	`onClose(Runnable closeHandler)` Returns an equivalent stream with an additional close handler.
`S`	`parallel()` Returns an equivalent stream that is parallel.
`S`	`parallel(ForkJoinPool fjp)` Returns an equivalent stream that is parallel and bound to the supplied `ForkJoinPool`.
`S`	`peek(Consumer<? super T> action)` 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.
`S`	`prefix(BinaryOperator<T> op)` Returns a stream containing cumulative results of applying the accumulation function going left to right.
`S`	`prepend(Stream<? extends T> other)` Creates a lazily concatenated stream whose elements are all the elements of the other stream followed by all the elements of this stream.
`Optional<T>`	`reduce(BinaryOperator<T> accumulator)` Performs a reduction on the elements of this stream, using an associative accumulation function, and returns an `Optional` describing the reduced value, if any.
`T`	`reduce(T identity, BinaryOperator<T> accumulator)` Performs a reduction on the elements of this stream, using the provided identity value and an associative accumulation function, and returns the reduced value.
`<U> U`	`reduce(U identity, BiFunction<U,? super T,U> accumulator, BinaryOperator<U> combiner)` Performs a reduction on the elements of this stream, using the provided identity, accumulation and combining functions.
`S`	`remove(Predicate<? super T> predicate)` Returns a stream consisting of the elements of this stream that don't match the given predicate.
`S`	`reverseSorted(Comparator<? super T> comparator)` Returns a stream consisting of the elements of this stream, sorted in descending order according to the provided `Comparator`.
`List<T>`	`scanLeft(BinaryOperator<T> accumulator)` Produces a list containing cumulative results of applying the accumulation function going left to right.
`<U> List<U>`	`scanLeft(U seed, BiFunction<U,? super T,U> accumulator)` Produces a list containing cumulative results of applying the accumulation function going left to right using given seed value.
`List<T>`	`scanRight(BinaryOperator<T> accumulator)` Produces a collection containing cumulative results of applying the accumulation function going right to left.
`<U> List<U>`	`scanRight(U seed, BiFunction<? super T,U,U> accumulator)` Produces a list containing cumulative results of applying the accumulation function going right to left using given seed value.
`S`	`sequential()` Returns an equivalent stream that is sequential.
`S`	`skip(long n)` Returns a stream consisting of the remaining elements of this stream after discarding the first `n` elements of the stream.
`S`	`skipOrdered(long n)` Returns a stream consisting of the remaining elements of this stream after discarding the first `n` elements of the stream even if the stream is unordered.
`S`	`sorted()` Returns a stream consisting of the elements of this stream, sorted according to natural order.
`S`	`sorted(Comparator<? super T> comparator)` Returns a stream consisting of the elements of this stream, sorted according to the provided `Comparator`.
`<V extends Comparable<? super V>> S`	`sortedBy(Function<? super T,? extends V> keyExtractor)` Returns a stream consisting of the elements of this stream, sorted according to the natural order of the keys extracted by provided function.
`S`	`sortedByDouble(ToDoubleFunction<? super T> keyExtractor)` Returns a stream consisting of the elements of this stream, sorted according to the double values extracted by provided function.
`S`	`sortedByInt(ToIntFunction<? super T> keyExtractor)` Returns a stream consisting of the elements of this stream, sorted according to the int values extracted by provided function.
`S`	`sortedByLong(ToLongFunction<? super T> keyExtractor)` Returns a stream consisting of the elements of this stream, sorted according to the long values extracted by provided function.
`SPLTR`	`spliterator()` Returns a spliterator for the elements of this stream.
`S`	`takeWhile(Predicate<? super T> predicate)` Returns a stream consisting of all elements from this stream until the first element which does not match the given predicate is found.
`S`	`takeWhileInclusive(Predicate<? super T> predicate)` Returns a stream consisting of all elements from this stream until the first element which does not match the given predicate is found (including the first mismatching element).
`Object[]`	`toArray()` Returns an array containing the elements of this stream.
`<A> A[]`	`toArray(IntFunction<A[]> generator)` Returns an array containing the elements of this stream, using the provided `generator` function to allocate the returned array, as well as any additional arrays that might be required for a partitioned execution or for resizing.
`<C extends Collection<T>> C`	`toCollection(Supplier<C> collectionFactory)` Returns a `Collection` containing the elements of this stream.
`List<T>`	`toImmutableList()` Returns an immutable `List` containing the elements of this stream.
`Set<T>`	`toImmutableSet()` Returns an immutable `Set` containing the elements of this stream.
`List<T>`	`toList()` Returns a `List` containing the elements of this stream.
`<R> R`	`toListAndThen(Function<? super List<T>,R> finisher)` Creates a `List` containing the elements of this stream, then performs finishing transformation and returns its result.
`Set<T>`	`toSet()` Returns a `Set` containing the elements of this stream.
`<R> R`	`toSetAndThen(Function<? super Set<T>,R> finisher)` Creates a `Set` containing the elements of this stream, then performs finishing transformation and returns its result.
`S`	`unordered()` Returns an equivalent stream that is unordered.

Methods inherited from class Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface Stream
builder, concat, empty, generate, iterate, of, of

Methods inherited from interface BaseStream
close, isParallel, spliterator

Methods inherited from interface Iterable
spliterator

- Method Detail
 - iterator
```
public Iterator<T> iterator()
```
 Description copied from interface: java.util.stream.BaseStream
 
 Returns an iterator for the elements of this stream.
 This is a terminal operation.
 
 Specified by:
 
 iterator in interface Iterable<T>
 
 Specified by:
 
 iterator in interface BaseStream<T,Stream<T>>
 
 Returns:
 
 the element iterator for this stream
 - sequential
```
public S sequential()
```
 Description copied from interface: java.util.stream.BaseStream
 
 Returns an equivalent stream that is sequential. May return itself, either because the stream was already sequential, or because the underlying stream state was modified to be sequential.
 This is an intermediate operation.
 
 Specified by:
 
 sequential in interface BaseStream<T,Stream<T>>
 
 Returns:
 
 a sequential stream
 - parallel
```
public S parallel()
```
 Returns an equivalent stream that is parallel. May return itself, either because the stream was already parallel, or because the underlying stream state was modified to be parallel.
 This is an intermediate operation.
 If this stream was created using parallel(ForkJoinPool), the new stream forgets about supplied custom ForkJoinPool and its terminal operation will be executed in common pool.
 
 Specified by:
 
 parallel in interface BaseStream<T,Stream<T>>
 
 Returns:
 
 a parallel stream
 - parallel
```
public S parallel(ForkJoinPool fjp)
```
 Returns an equivalent stream that is parallel and bound to the supplied ForkJoinPool.
 This is an intermediate operation.
 The terminal operation of this stream or any derived stream (except the streams created via parallel() or sequential() methods) will be executed inside the supplied ForkJoinPool. If current thread does not belong to that pool, it will wait till calculation finishes.
 
 Parameters:
 
 fjp - a ForkJoinPool to submit the stream operation to.
 
 Returns:
 
 a parallel stream bound to the supplied ForkJoinPool
 - unordered
```
public S unordered()
```
 Description copied from interface: java.util.stream.BaseStream
 
 Returns an equivalent stream that is unordered. May return itself, either because the stream was already unordered, or because the underlying stream state was modified to be unordered.
 This is an intermediate operation.
 
 Specified by:
 
 unordered in interface BaseStream<T,Stream<T>>
 
 Returns:
 
 an unordered stream
 - onClose
```
public S onClose(Runnable closeHandler)
```
 Description copied from interface: java.util.stream.BaseStream
 
 Returns an equivalent stream with an additional close handler. Close handlers are run when the BaseStream.close() method is called on the stream, and are executed in the order they were added. All close handlers are run, even if earlier close handlers throw exceptions. If any close handler throws an exception, the first exception thrown will be relayed to the caller of close(), with any remaining exceptions added to that exception as suppressed exceptions (unless one of the remaining exceptions is the same exception as the first exception, since an exception cannot suppress itself.) May return itself.
 This is an intermediate operation.
 
 Specified by:
 
 onClose in interface BaseStream<T,Stream<T>>
 
 Parameters:
 
 closeHandler - A task to execute when the stream is closed
 
 Returns:
 
 a stream with a handler that is run if the stream is closed
 - filter
```
public S filter(Predicate<? super T> predicate)
```
 Description copied from interface: java.util.stream.Stream
 
 Returns a stream consisting of the elements of this stream that match the given predicate.
 This is an intermediate operation.
 
 Specified by:
 
 filter in interface Stream<T>
 
 Parameters:
 
 predicate - a non-interfering, stateless predicate to apply to each element to determine if it should be included
 
 Returns:
 
 the new stream
 - flatMap
```
public <R> StreamEx<R> flatMap(Function<? super T,? extends Stream<? extends R>> mapper)
```
 Description copied from interface: java.util.stream.Stream
 
 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 closed after its contents have been placed into this stream. (If a mapped stream is null an empty stream is used, instead.)
 This is an intermediate operation.
 
 Specified by:
 
 flatMap in interface Stream<T>
 
 Type Parameters:
 
 R - The element type of the new stream
 
 Parameters:
 
 mapper - a non-interfering, stateless function to apply to each element which produces a stream of new values
 
 Returns:
 
 the new stream
 - map
```
public <R> StreamEx<R> map(Function<? super T,? extends R> mapper)
```
 Description copied from interface: java.util.stream.Stream
 
 Returns a stream consisting of the results of applying the given function to the elements of this stream.
 This is an intermediate operation.
 
 Specified by:
 
 map in interface Stream<T>
 
 Type Parameters:
 
 R - The element type of the new stream
 
 Parameters:
 
 mapper - a non-interfering, stateless function to apply to each element
 
 Returns:
 
 the new stream
 - mapToInt
```
public IntStreamEx mapToInt(ToIntFunction<? super T> mapper)
```
 Description copied from interface: java.util.stream.Stream
 
 Returns an IntStream consisting of the results of applying the given function to the elements of this stream.
 This is an intermediate operation.
 
 Specified by:
 
 mapToInt in interface Stream<T>
 
 Parameters:
 
 mapper - a non-interfering, stateless function to apply to each element
 
 Returns:
 
 the new stream
 - mapToLong
```
public LongStreamEx mapToLong(ToLongFunction<? super T> mapper)
```
 Description copied from interface: java.util.stream.Stream
 
 Returns a LongStream consisting of the results of applying the given function to the elements of this stream.
 This is an intermediate operation.
 
 Specified by:
 
 mapToLong in interface Stream<T>
 
 Parameters:
 
 mapper - a non-interfering, stateless function to apply to each element
 
 Returns:
 
 the new stream
 - mapToDouble
```
public DoubleStreamEx mapToDouble(ToDoubleFunction<? super T> mapper)
```
 Description copied from interface: java.util.stream.Stream
 
 Returns a DoubleStream consisting of the results of applying the given function to the elements of this stream.
 This is an intermediate operation.
 
 Specified by:
 
 mapToDouble in interface Stream<T>
 
 Parameters:
 
 mapper - a non-interfering, stateless function to apply to each element
 
 Returns:
 
 the new stream
 - flatMapToInt
```
public IntStreamEx flatMapToInt(Function<? super T,? extends IntStream> mapper)
```
 Description copied from interface: java.util.stream.Stream
 
 Returns an 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 closed after its contents have been placed into this stream. (If a mapped stream is null an empty stream is used, instead.)
 This is an intermediate operation.
 
 Specified by:
 
 flatMapToInt in interface Stream<T>
 
 Parameters:
 
 mapper - a non-interfering, stateless function to apply to each element which produces a stream of new values
 
 Returns:
 
 the new stream
 
 See Also:
 
 Stream.flatMap(Function)
 - flatMapToLong
```
public LongStreamEx flatMapToLong(Function<? super T,? extends LongStream> mapper)
```
 Description copied from interface: java.util.stream.Stream
 
 Returns an 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 closed after its contents have been placed into this stream. (If a mapped stream is null an empty stream is used, instead.)
 This is an intermediate operation.
 
 Specified by:
 
 flatMapToLong in interface Stream<T>
 
 Parameters:
 
 mapper - a non-interfering, stateless function to apply to each element which produces a stream of new values
 
 Returns:
 
 the new stream
 
 See Also:
 
 Stream.flatMap(Function)
 - flatMapToDouble
```
public DoubleStreamEx flatMapToDouble(Function<? super T,? extends DoubleStream> mapper)
```
 Description copied from interface: java.util.stream.Stream
 
 Returns an 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 closed after its contents have placed been into this stream. (If a mapped stream is null an empty stream is used, instead.)
 This is an intermediate operation.
 
 Specified by:
 
 flatMapToDouble in interface Stream<T>
 
 Parameters:
 
 mapper - a non-interfering, stateless function to apply to each element which produces a stream of new values
 
 Returns:
 
 the new stream
 
 See Also:
 
 Stream.flatMap(Function)
 - distinct
```
public S distinct()
```
 Description copied from interface: java.util.stream.Stream
 
 Returns a stream consisting of the distinct elements (according to Object.equals(Object)) of this stream.
 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.
 This is a stateful intermediate operation.
 
 Specified by:
 
 distinct in interface Stream<T>
 
 Returns:
 
 the new stream
 - distinct
```
public S distinct(Function<? super T,?> keyExtractor)
```
 Returns a stream consisting of the distinct elements of this stream (according to object equality of the results of applying the given function).
 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.
 This is a stateful intermediate operation.
 
 Parameters:
 
 keyExtractor - a non-interfering, stateless function which classifies input elements.
 
 Returns:
 
 the new stream
 
 Since:
 
 0.3.8
 - sorted
```
public S sorted()
```
 Description copied from interface: java.util.stream.Stream
 
 Returns a stream consisting of the elements of this stream, sorted according to natural order. If the elements of this stream are not Comparable, a java.lang.ClassCastException may be thrown when the terminal operation is executed.
 For ordered streams, the sort is stable. For unordered streams, no stability guarantees are made.
 This is a stateful intermediate operation.
 
 Specified by:
 
 sorted in interface Stream<T>
 
 Returns:
 
 the new stream
 - sorted
```
public S sorted(Comparator<? super T> comparator)
```
 Description copied from interface: java.util.stream.Stream
 
 Returns a stream consisting of the elements of this stream, sorted according to the provided Comparator.
 For ordered streams, the sort is stable. For unordered streams, no stability guarantees are made.
 This is a stateful intermediate operation.
 
 Specified by:
 
 sorted in interface Stream<T>
 
 Parameters:
 
 comparator - a non-interfering, stateless Comparator to be used to compare stream elements
 
 Returns:
 
 the new stream
 - peek
```
public S peek(Consumer<? super T> action)
```
 Description copied from interface: java.util.stream.Stream
 
 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.
 This is an intermediate operation.
 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.
 
 Specified by:
 
 peek in interface Stream<T>
 
 Parameters:
 
 action - a non-interfering action to perform on the elements as they are consumed from the stream
 
 Returns:
 
 the new stream
 - limit
```
public S limit(long maxSize)
```
 Description copied from interface: java.util.stream.Stream
 
 Returns a stream consisting of the elements of this stream, truncated to be no longer than maxSize in length.
 This is a short-circuiting stateful intermediate operation.
 
 Specified by:
 
 limit in interface Stream<T>
 
 Parameters:
 
 maxSize - the number of elements the stream should be limited to
 
 Returns:
 
 the new stream
 - skip
```
public S skip(long n)
```
 Description copied from interface: java.util.stream.Stream
 
 Returns a stream consisting of the remaining elements of this stream after discarding the first n elements of the stream. If this stream contains fewer than n elements then an empty stream will be returned.
 This is a stateful intermediate operation.
 
 Specified by:
 
 skip in interface Stream<T>
 
 Parameters:
 
 n - the number of leading elements to skip
 
 Returns:
 
 the new stream
 - forEach
```
public void forEach(Consumer<? super T> action)
```
 Description copied from interface: java.util.stream.Stream
 
 Performs an action for each element of this stream.
 This is a terminal operation.
 The behavior of this operation is explicitly nondeterministic. For parallel stream pipelines, this operation does not 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.
 
 Specified by:
 
 forEach in interface Iterable<T>
 
 Specified by:
 
 forEach in interface Stream<T>
 
 Parameters:
 
 action - a non-interfering action to perform on the elements
 - forEachOrdered
```
public void forEachOrdered(Consumer<? super T> action)
```
 Description copied from interface: java.util.stream.Stream
 
 Performs an action for each element of this stream, in the encounter order of the stream if the stream has a defined encounter order.
 This is a terminal operation.
 This operation processes the elements one at a time, in encounter order if one exists. Performing the action for one element happens-before performing the action for subsequent elements, but for any given element, the action may be performed in whatever thread the library chooses.
 
 Specified by:
 
 forEachOrdered in interface Stream<T>
 
 Parameters:
 
 action - a non-interfering action to perform on the elements
 
 See Also:
 
 Stream.forEach(Consumer)
 - toArray
```
public Object[] toArray()
```
 Description copied from interface: java.util.stream.Stream
 
 Returns an array containing the elements of this stream.
 This is a terminal operation.
 
 Specified by:
 
 toArray in interface Stream<T>
 
 Returns:
 
 an array containing the elements of this stream
 - toArray
```
public <A> A[] toArray(IntFunction<A[]> generator)
```
 Description copied from interface: java.util.stream.Stream
 
 Returns an array containing the elements of this stream, using the provided generator function to allocate the returned array, as well as any additional arrays that might be required for a partitioned execution or for resizing.
 This is a terminal operation.
 
 Specified by:
 
 toArray in interface Stream<T>
 
 Type Parameters:
 
 A - the element type of the resulting array
 
 Parameters:
 
 generator - a function which produces a new array of the desired type and the provided length
 
 Returns:
 
 an array containing the elements in this stream
 - reduce
```
public T reduce(T identity,
 BinaryOperator<T> accumulator)
```
 Description copied from interface: java.util.stream.Stream
 Performs a reduction on the elements of this stream, using the provided identity value and an associative accumulation function, and returns the reduced value. This is equivalent to:
```
 T result = identity;
 for (T element : this stream)
 result = accumulator.apply(result, element)
 return result;
 
```
 but is not constrained to execute sequentially.
 The identity value must be an identity for the accumulator function. This means that for all t, accumulator.apply(identity, t) is equal to t. The accumulator function must be an associative function.
 This is a terminal operation.
 Specified by:
 
 reduce in interface Stream<T>
 
 Parameters:
 
 identity - the identity value for the accumulating function
 
 accumulator - an associative, non-interfering, stateless function for combining two values
 
 Returns:
 
 the result of the reduction
 - reduce
```
public Optional<T> reduce(BinaryOperator<T> accumulator)
```
 Description copied from interface: java.util.stream.Stream
 Performs a reduction on the elements of this stream, using an associative accumulation function, and returns an Optional describing the reduced value, if any. This is equivalent to:
```
 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();
 
```
 but is not constrained to execute sequentially.
 The accumulator function must be an associative function.
 This is a terminal operation.
 Specified by:
 
 reduce in interface Stream<T>
 
 Parameters:
 
 accumulator - an associative, non-interfering, stateless function for combining two values
 
 Returns:
 
 an Optional describing the result of the reduction
 
 See Also:
 
 Stream.reduce(Object, BinaryOperator), Stream.min(Comparator), Stream.max(Comparator)
 - reduce
```
public  U reduce(U identity,
 BiFunction<U,? super T,U> accumulator,
 BinaryOperator combiner)
```
 Description copied from interface: java.util.stream.Stream
 Performs a reduction on the elements of this stream, using the provided identity, accumulation and combining functions. This is equivalent to:
```
 U result = identity;
 for (T element : this stream)
 result = accumulator.apply(result, element)
 return result;
 
```
 but is not constrained to execute sequentially.
 The identity value must be an identity for the combiner function. This means that for all u, combiner(identity, u) is equal to u. Additionally, the combiner function must be compatible with the accumulator function; for all u and t, the following must hold:
```
 combiner.apply(u, accumulator.apply(identity, t)) == accumulator.apply(u, t)
 
```
 This is a terminal operation.
 Specified by:
 
 reduce in interface Stream<T>
 
 Type Parameters:
 
 U - The type of the result
 
 Parameters:
 
 identity - the identity value for the combiner function
 
 accumulator - an associative, non-interfering, stateless function for incorporating an additional element into a result
 
 combiner - an associative, non-interfering, stateless function for combining two values, which must be compatible with the accumulator function
 
 Returns:
 
 the result of the reduction
 
 See Also:
 
 Stream.reduce(BinaryOperator), Stream.reduce(Object, BinaryOperator)
 - collect
```
public <R> R collect(Supplier<R> supplier,
 BiConsumer<R,? super T> accumulator,
 BiConsumer<R,R> combiner)
```
 Description copied from interface: java.util.stream.Stream
 Performs a mutable reduction 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 ArrayList, and elements are incorporated by updating the state of the result rather than by replacing the result. This produces a result equivalent to:
```
 R result = supplier.get();
 for (T element : this stream)
 accumulator.accept(result, element);
 return result;
 
```
 Like Stream.reduce(Object, BinaryOperator), collect operations can be parallelized without requiring additional synchronization.
 This is a terminal operation.
 Specified by:
 
 collect in interface Stream<T>
 
 Type Parameters:
 
 R - type of the result
 
 Parameters:
 
 supplier - a function that creates a new result container. For a parallel execution, this function may be called multiple times and must return a fresh value each time.
 
 accumulator - an associative, non-interfering, stateless function for incorporating an additional element into a result
 
 combiner - an associative, non-interfering, stateless function for combining two values, which must be compatible with the accumulator function
 
 Returns:
 
 the result of the reduction
 - collect
```
public <R,A> R collect(Collector<? super T,A,R> collector)
```
 Performs a mutable reduction operation on the elements of this stream using a Collector. A Collector encapsulates the functions used as arguments to Stream.collect(Supplier, BiConsumer, BiConsumer), allowing for reuse of collection strategies and composition of collect operations such as multiple-level grouping or partitioning.
 If the stream is parallel, and the Collector is concurrent, and either the stream is unordered or the collector is unordered, then a concurrent reduction will be performed (see Collector for details on concurrent reduction.)
 This is a terminal operation.
 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 ArrayList), no additional synchronization is needed for a parallel reduction.
 If special short-circuiting collector is passed, this operation becomes short-circuiting as well.
 
 Specified by:
 
 collect in interface Stream<T>
 
 Type Parameters:
 
 R - the type of the result
 
 A - the intermediate accumulation type of the Collector
 
 Parameters:
 
 collector - the Collector describing the reduction
 
 Returns:
 
 the result of the reduction
 
 See Also:
 
 Stream.collect(Supplier, BiConsumer, BiConsumer), Collectors
 - min
```
public Optional<T> min(Comparator<? super T> comparator)
```
 Description copied from interface: java.util.stream.Stream
 
 Returns the minimum element of this stream according to the provided Comparator. This is a special case of a reduction.
 This is a terminal operation.
 
 Specified by:
 
 min in interface Stream<T>
 
 Parameters:
 
 comparator - a non-interfering, stateless Comparator to compare elements of this stream
 
 Returns:
 
 an Optional describing the minimum element of this stream, or an empty Optional if the stream is empty
 - max
```
public Optional<T> max(Comparator<? super T> comparator)
```
 Description copied from interface: java.util.stream.Stream
 
 Returns the maximum element of this stream according to the provided Comparator. This is a special case of a reduction.
 This is a terminal operation.
 
 Specified by:
 
 max in interface Stream<T>
 
 Parameters:
 
 comparator - a non-interfering, stateless Comparator to compare elements of this stream
 
 Returns:
 
 an Optional describing the maximum element of this stream, or an empty Optional if the stream is empty
 - count
```
public long count()
```
 Description copied from interface: java.util.stream.Stream
 Returns the count of elements in this stream. This is a special case of a reduction and is equivalent to:
```
 return mapToLong(e -> 1L).sum();
 
```
 This is a terminal operation.
 Specified by:
 
 count in interface Stream<T>
 
 Returns:
 
 the count of elements in this stream
 - anyMatch
```
public boolean anyMatch(Predicate<? super T> predicate)
```
 Description copied from interface: java.util.stream.Stream
 
 Returns whether any elements of this stream match the provided predicate. May not evaluate the predicate on all elements if not necessary for determining the result. If the stream is empty then false is returned and the predicate is not evaluated.
 This is a short-circuiting terminal operation.
 
 Specified by:
 
 anyMatch in interface Stream<T>
 
 Parameters:
 
 predicate - a non-interfering, stateless predicate to apply to elements of this stream
 
 Returns:
 
 true if any elements of the stream match the provided predicate, otherwise false
 - allMatch
```
public boolean allMatch(Predicate<? super T> predicate)
```
 Description copied from interface: java.util.stream.Stream
 
 Returns whether all elements of this stream match the provided predicate. May not evaluate the predicate on all elements if not necessary for determining the result. If the stream is empty then true is returned and the predicate is not evaluated.
 This is a short-circuiting terminal operation.
 
 Specified by:
 
 allMatch in interface Stream<T>
 
 Parameters:
 
 predicate - a non-interfering, stateless predicate to apply to elements of this stream
 
 Returns:
 
 true if either all elements of the stream match the provided predicate or the stream is empty, otherwise false
 - noneMatch
```
public boolean noneMatch(Predicate<? super T> predicate)
```
 Description copied from interface: java.util.stream.Stream
 
 Returns whether no elements of this stream match the provided predicate. May not evaluate the predicate on all elements if not necessary for determining the result. If the stream is empty then true is returned and the predicate is not evaluated.
 This is a short-circuiting terminal operation.
 
 Specified by:
 
 noneMatch in interface Stream<T>
 
 Parameters:
 
 predicate - a non-interfering, stateless predicate to apply to elements of this stream
 
 Returns:
 
 true if either no elements of the stream match the provided predicate or the stream is empty, otherwise false
 - findFirst
```
public Optional<T> findFirst()
```
 Description copied from interface: java.util.stream.Stream
 
 Returns an Optional describing the first element of this stream, or an empty Optional if the stream is empty. If the stream has no encounter order, then any element may be returned.
 This is a short-circuiting terminal operation.
 
 Specified by:
 
 findFirst in interface Stream<T>
 
 Returns:
 
 an Optional describing the first element of this stream, or an empty Optional if the stream is empty
 - findAny
```
public Optional<T> findAny()
```
 Description copied from interface: java.util.stream.Stream
 
 Returns an Optional describing some element of the stream, or an empty Optional if the stream is empty.
 This is a short-circuiting terminal operation.
 The behavior of this operation is explicitly nondeterministic; it is free to select any element in the stream. This is to allow for maximal performance in parallel operations; the cost is that multiple invocations on the same source may not return the same result. (If a stable result is desired, use Stream.findFirst() instead.)
 
 Specified by:
 
 findAny in interface Stream<T>
 
 Returns:
 
 an Optional describing some element of this stream, or an empty Optional if the stream is empty
 
 See Also:
 
 Stream.findFirst()
 - indexOf
```
public OptionalLong indexOf(T element)
```
 Returns an OptionalLong describing the zero-based index of the first element of this stream, which equals to the given element, or an empty OptionalLong if there's no matching element.
 This is a short-circuiting terminal operation.
 
 Parameters:
 
 element - an element to look for
 
 Returns:
 
 an OptionalLong describing the index of the first matching element of this stream, or an empty OptionalLong if there's no matching element.
 
 Since:
 
 0.4.0
 
 See Also:
 
 indexOf(Predicate)
 - indexOf
```
public OptionalLong indexOf(Predicate<? super T> predicate)
```
 Returns an OptionalLong describing the zero-based index of the first element of this stream, which matches given predicate, or an empty OptionalLong if there's no matching element.
 This is a short-circuiting terminal operation.
 
 Parameters:
 
 predicate - a non-interfering , stateless predicate which returned value should match
 
 Returns:
 
 an OptionalLong describing the index of the first matching element of this stream, or an empty OptionalLong if there's no matching element.
 
 Since:
 
 0.4.0
 
 See Also:
 
 findFirst(Predicate), indexOf(Object)
 - flatCollection
```
public <R> StreamEx<R> flatCollection(Function<? super T,? extends Collection<? extends R>> mapper)
```
 Returns a stream consisting of the results of replacing each element of this stream with the contents of a mapped collection produced by applying the provided mapping function to each element. (If a mapped collection is null nothing is added for given element to the resulting stream.)
 This is an intermediate operation.
 The flatCollection() 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.
 
 Type Parameters:
 
 R - The element type of the new stream
 
 Parameters:
 
 mapper - a non-interfering , stateless function to apply to each element which produces a Collection of new values
 
 Returns:
 
 the new stream
 - flatArray
```
public <R> StreamEx<R> flatArray(Function<? super T,? extends R[]> mapper)
```
 Returns a stream consisting of the results of replacing each element of this stream with the contents of a mapped array produced by applying the provided mapping function to each element. (If a mapped array is null nothing is added for given element to the resulting stream.)
 This is an intermediate operation.
 The flatArray() 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.
 
 Type Parameters:
 
 R - The element type of the new stream
 
 Parameters:
 
 mapper - a non-interfering , stateless function to apply to each element which produces an array of new values
 
 Returns:
 
 the new stream
 
 Since:
 
 0.6.5
 - remove
```
public S remove(Predicate<? super T> predicate)
```
 Returns a stream consisting of the elements of this stream that don't match the given predicate.
 This is an intermediate operation.
 
 Parameters:
 
 predicate - a non-interfering , stateless predicate to apply to each element to determine if it should be excluded
 
 Returns:
 
 the new stream
 - nonNull
```
public S nonNull()
```
 Returns a stream consisting of the elements of this stream that aren't null.
 This is an intermediate operation.
 
 Returns:
 
 the new stream
 - findAny
```
public Optional<T> findAny(Predicate<? super T> predicate)
```
 Returns an Optional describing some element of the stream, which matches given predicate, or an empty Optional if there's no matching element.
 This is a short-circuiting terminal operation.
 The behavior of this operation is explicitly nondeterministic; it is free to select any element in the stream. This is to allow for maximal performance in parallel operations; the cost is that multiple invocations on the same source may not return the same result. (If a stable result is desired, use findFirst(Predicate) instead.)
 
 Parameters:
 
 predicate - a non-interfering , stateless predicate which returned value should match
 
 Returns:
 
 an Optional describing some matching element of this stream, or an empty Optional if there's no matching element
 
 Throws:
 
 NullPointerException - if the element selected is null
 
 See Also:
 
 findAny(), findFirst(Predicate)
 - findFirst
```
public Optional<T> findFirst(Predicate<? super T> predicate)
```
 Returns an Optional describing the first element of this stream, which matches given predicate, or an empty Optional if there's no matching element.
 This is a short-circuiting terminal operation.
 
 Parameters:
 
 predicate - a non-interfering , stateless predicate which returned value should match
 
 Returns:
 
 an Optional describing the first matching element of this stream, or an empty Optional if there's no matching element
 
 Throws:
 
 NullPointerException - if the element selected is null
 
 See Also:
 
 findFirst()
 - reverseSorted
```
public S reverseSorted(Comparator<? super T> comparator)
```
 Returns a stream consisting of the elements of this stream, sorted in descending order according to the provided Comparator.
 For ordered streams, the sort is stable. For unordered streams, no stability guarantees are made.
 This is a stateful intermediate operation.
 
 Parameters:
 
 comparator - a non-interfering , stateless Comparator to be used to compare stream elements
 
 Returns:
 
 the new stream
 - sortedBy
```
public <V extends Comparable<? super V>> S sortedBy(Function<? super T,? extends V> keyExtractor)
```
 Returns a stream consisting of the elements of this stream, sorted according to the natural order of the keys extracted by provided function.
 For ordered streams, the sort is stable. For unordered streams, no stability guarantees are made.
 This is a stateful intermediate operation.
 
 Type Parameters:
 
 V - the type of the Comparable sort key
 
 Parameters:
 
 keyExtractor - a non-interfering , stateless function to be used to extract sorting keys
 
 Returns:
 
 the new stream
 - sortedByInt
```
public S sortedByInt(ToIntFunction<? super T> keyExtractor)
```
 Returns a stream consisting of the elements of this stream, sorted according to the int values extracted by provided function.
 For ordered streams, the sort is stable. For unordered streams, no stability guarantees are made.
 This is a stateful intermediate operation.
 
 Parameters:
 
 keyExtractor - a non-interfering , stateless function to be used to extract sorting keys
 
 Returns:
 
 the new stream
 - sortedByLong
```
public S sortedByLong(ToLongFunction<? super T> keyExtractor)
```
 Returns a stream consisting of the elements of this stream, sorted according to the long values extracted by provided function.
 For ordered streams, the sort is stable. For unordered streams, no stability guarantees are made.
 This is a stateful intermediate operation.
 
 Parameters:
 
 keyExtractor - a non-interfering , stateless function to be used to extract sorting keys
 
 Returns:
 
 the new stream
 - sortedByDouble
```
public S sortedByDouble(ToDoubleFunction<? super T> keyExtractor)
```
 Returns a stream consisting of the elements of this stream, sorted according to the double values extracted by provided function.
 For ordered streams, the sort is stable. For unordered streams, no stability guarantees are made.
 This is a stateful intermediate operation.
 
 Parameters:
 
 keyExtractor - a non-interfering , stateless function to be used to extract sorting keys
 
 Returns:
 
 the new stream
 - minBy
```
public <V extends Comparable<? super V>> Optional<T> minBy(Function<? super T,? extends V> keyExtractor)
```
 Returns the minimum element of this stream according to the natural order of the keys extracted by provided function. This is a special case of a reduction.
 This is a terminal operation.
 This method is equivalent to min(Comparator.comparing(keyExtractor)), but may work faster as keyExtractor function is applied only once per each input element.
 
 Type Parameters:
 
 V - the type of the comparable keys
 
 Parameters:
 
 keyExtractor - a non-interfering , stateless function to extract the comparable keys from this stream elements
 
 Returns:
 
 an Optional describing the minimum element of this stream, or an empty Optional if the stream is empty
 
 Throws:
 
 NullPointerException - if the minimum element is null
 - minByInt
```
public Optional<T> minByInt(ToIntFunction<? super T> keyExtractor)
```
 Returns the minimum element of this stream according to the int values extracted by provided function. This is a special case of a reduction.
 This is a terminal operation.
 This method is equivalent to min(Comparator.comparingInt(keyExtractor)), but may work faster as keyExtractor function is applied only once per each input element.
 
 Parameters:
 
 keyExtractor - a non-interfering , stateless function to extract the int keys from this stream elements
 
 Returns:
 
 an Optional describing the minimum element of this stream, or an empty Optional if the stream is empty
 
 Throws:
 
 NullPointerException - if the minimum element is null
 - minByLong
```
public Optional<T> minByLong(ToLongFunction<? super T> keyExtractor)
```
 Returns the minimum element of this stream according to the long values extracted by provided function. This is a special case of a reduction.
 This is a terminal operation.
 This method is equivalent to min(Comparator.comparingLong(keyExtractor)), but may work faster as keyExtractor function is applied only once per each input element.
 
 Parameters:
 
 keyExtractor - a non-interfering , stateless function to extract the long keys from this stream elements
 
 Returns:
 
 an Optional describing the minimum element of this stream, or an empty Optional if the stream is empty
 
 Throws:
 
 NullPointerException - if the minimum element is null
 - minByDouble
```
public Optional<T> minByDouble(ToDoubleFunction<? super T> keyExtractor)
```
 Returns the minimum element of this stream according to the double values extracted by provided function. This is a special case of a reduction.
 This is a terminal operation.
 This method is equivalent to min(Comparator.comparingDouble(keyExtractor)), but may work faster as keyExtractor function is applied only once per each input element.
 
 Parameters:
 
 keyExtractor - a non-interfering , stateless function to extract the double keys from this stream elements
 
 Returns:
 
 an Optional describing the minimum element of this stream, or an empty Optional if the stream is empty
 
 Throws:
 
 NullPointerException - if the minimum element is null
 - maxBy
```
public <V extends Comparable<? super V>> Optional<T> maxBy(Function<? super T,? extends V> keyExtractor)
```
 Returns the maximum element of this stream according to the natural order of the keys extracted by provided function. This is a special case of a reduction.
 This is a terminal operation.
 This method is equivalent to min(Comparator.comparing(keyExtractor)), but may work faster as keyExtractor function is applied only once per each input element.
 
 Type Parameters:
 
 V - the type of the comparable keys
 
 Parameters:
 
 keyExtractor - a non-interfering , stateless function to extract the comparable keys from this stream elements
 
 Returns:
 
 an Optional describing the maximum element of this stream, or an empty Optional if the stream is empty
 
 Throws:
 
 NullPointerException - if the maximum element is null
 - maxByInt
```
public Optional<T> maxByInt(ToIntFunction<? super T> keyExtractor)
```
 Returns the maximum element of this stream according to the int values extracted by provided function. This is a special case of a reduction.
 This is a terminal operation.
 This method is equivalent to min(Comparator.comparingInt(keyExtractor)), but may work faster as keyExtractor function is applied only once per each input element.
 
 Parameters:
 
 keyExtractor - a non-interfering , stateless function to extract the int keys from this stream elements
 
 Returns:
 
 an Optional describing the maximum element of this stream, or an empty Optional if the stream is empty
 
 Throws:
 
 NullPointerException - if the maximum element is null
 - maxByLong
```
public Optional<T> maxByLong(ToLongFunction<? super T> keyExtractor)
```
 Returns the maximum element of this stream according to the long values extracted by provided function. This is a special case of a reduction.
 This is a terminal operation.
 This method is equivalent to min(Comparator.comparingLong(keyExtractor)), but may work faster as keyExtractor function is applied only once per each input element.
 
 Parameters:
 
 keyExtractor - a non-interfering , stateless function to extract the long keys from this stream elements
 
 Returns:
 
 an Optional describing the maximum element of this stream, or an empty Optional if the stream is empty
 
 Throws:
 
 NullPointerException - if the maximum element is null
 - maxByDouble
```
public Optional<T> maxByDouble(ToDoubleFunction<? super T> keyExtractor)
```
 Returns the maximum element of this stream according to the double values extracted by provided function. This is a special case of a reduction.
 This is a terminal operation.
 This method is equivalent to min(Comparator.comparingDouble(keyExtractor)), but may work faster as keyExtractor function is applied only once per each input element.
 
 Parameters:
 
 keyExtractor - a non-interfering , stateless function to extract the double keys from this stream elements
 
 Returns:
 
 an Optional describing the maximum element of this stream, or an empty Optional if the stream is empty
 
 Throws:
 
 NullPointerException - if the maximum element is null
 - append
```
public S append(Stream<? extends T> other)
```
 Creates a lazily concatenated stream whose elements are all the elements of this stream followed by all the elements of the other stream. The resulting stream is ordered if both of the input streams are ordered, and parallel if either of the input streams is parallel. When the resulting stream is closed, the close handlers for both input streams are invoked.
 This is a quasi-intermediate operation with tail-stream optimization.
 May return this if the supplied stream is known to be empty.
 
 Parameters:
 
 other - the other stream
 
 Returns:
 
 this stream appended by the other stream
 
 See Also:
 
 Stream.concat(Stream, Stream)
 - prepend
```
public S prepend(Stream<? extends T> other)
```
 Creates a lazily concatenated stream whose elements are all the elements of the other stream followed by all the elements of this stream. The resulting stream is ordered if both of the input streams are ordered, and parallel if either of the input streams is parallel. When the resulting stream is closed, the close handlers for both input streams are invoked.
 This is a quasi-intermediate operation with tail-stream optimization.
 May return this if the supplied stream is known to be empty.
 
 Parameters:
 
 other - the other stream
 
 Returns:
 
 this stream prepended by the other stream
 
 See Also:
 
 Stream.concat(Stream, Stream)
 - toList
```
public List<T> toList()
```
 Returns a List containing the elements of this stream. The returned List is guaranteed to be mutable, but there are no guarantees on the type, serializability, or thread-safety; if more control over the returned List is required, use toCollection(Supplier).
 This is a terminal operation.
 
 Returns:
 
 a List containing the elements of this stream
 
 See Also:
 
 Collectors.toList(), toImmutableList()
 - toImmutableList
```
public List<T> toImmutableList()
```
 Returns an immutable List containing the elements of this stream. There's no guarantees on exact type of the returned List. The returned List is guaranteed to be serializable if all its elements are serializable.
 This is a terminal operation.
 
 Returns:
 
 a List containing the elements of this stream
 
 Since:
 
 0.6.3
 
 See Also:
 
 toList()
 - toListAndThen
```
public <R> R toListAndThen(Function<? super List<T>,R> finisher)
```
 Creates a List containing the elements of this stream, then performs finishing transformation and returns its result. There are no guarantees on the type, serializability or thread-safety of the List created.
 This is a terminal operation.
 
 Type Parameters:
 
 R - the type of the result
 
 Parameters:
 
 finisher - a function to be applied to the intermediate list
 
 Returns:
 
 result of applying the finisher transformation to the list of the stream elements.
 
 Since:
 
 0.2.3
 
 See Also:
 
 toList()
 - toSet
```
public Set<T> toSet()
```
 Returns a Set containing the elements of this stream. The returned Set is guaranteed to be mutable, but there are no guarantees on the type, serializability, or thread-safety; if more control over the returned Set is required, use toCollection(Supplier).
 This is a terminal operation.
 
 Returns:
 
 a Set containing the elements of this stream
 
 See Also:
 
 Collectors.toSet()
 - toImmutableSet
```
public Set<T> toImmutableSet()
```
 Returns an immutable Set containing the elements of this stream. There's no guarantees on exact type of the returned Set. In particular, no specific element order in the resulting set is guaranteed. The returned Set is guaranteed to be serializable if all its elements are serializable.
 This is a terminal operation.
 
 Returns:
 
 a Set containing the elements of this stream
 
 Since:
 
 0.6.3
 
 See Also:
 
 toSet()
 - toSetAndThen
```
public <R> R toSetAndThen(Function<? super Set<T>,R> finisher)
```
 Creates a Set containing the elements of this stream, then performs finishing transformation and returns its result. There are no guarantees on the type, serializability or thread-safety of the Set created.
 This is a terminal operation.
 
 Type Parameters:
 
 R - the result type
 
 Parameters:
 
 finisher - a function to be applied to the intermediate Set
 
 Returns:
 
 result of applying the finisher transformation to the Set of the stream elements.
 
 Since:
 
 0.2.3
 
 See Also:
 
 toSet()
 - toCollection
```
public <C extends Collection<T>> C toCollection(Supplier<C> collectionFactory)
```
 Returns a Collection containing the elements of this stream. The Collection is created by the provided factory.
 This is a terminal operation.
 
 Type Parameters:
 
 C - the type of the resulting Collection
 
 Parameters:
 
 collectionFactory - a Supplier which returns a new, empty Collection of the appropriate type
 
 Returns:
 
 a Collection containing the elements of this stream
 
 See Also:
 
 Collectors.toCollection(Supplier)
 - foldLeft
```
public  U foldLeft(U seed,
 BiFunction<U,? super T,U> accumulator)
```
 Folds the elements of this stream using the provided seed object and accumulation function, going left to right. This is equivalent to:
```
 
 U result = seed;
 for (T element : this stream)
 result = accumulator.apply(result, element)
 return result;
 
 
```
 This is a terminal operation.
 This method cannot take all the advantages of parallel streams as it must process elements strictly left to right. If your accumulator function is associative and you can provide a combiner function, consider using reduce(Object, BiFunction, BinaryOperator) method.
 For parallel stream it's not guaranteed that accumulator will always be executed in the same thread.
 Type Parameters:
 
 U - The type of the result
 
 Parameters:
 
 seed - the starting value
 
 accumulator - a non-interfering , stateless function for incorporating an additional element into a result
 
 Returns:
 
 the result of the folding
 
 Since:
 
 0.2.0
 
 See Also:
 
 foldRight(Object, BiFunction), reduce(Object, BinaryOperator), reduce(Object, BiFunction, BinaryOperator)
 - foldLeft
```
public Optional<T> foldLeft(BinaryOperator<T> accumulator)
```
 Folds the elements of this stream using the provided accumulation function, going left to right. This is equivalent to:
```
 
 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();
 
 
```
 This is a terminal operation.
 This method cannot take all the advantages of parallel streams as it must process elements strictly left to right. If your accumulator function is associative, consider using reduce(BinaryOperator) method.
 For parallel stream it's not guaranteed that accumulator will always be executed in the same thread.
 Parameters:
 
 accumulator - a non-interfering , stateless function for incorporating an additional element into a result
 
 Returns:
 
 the result of the folding
 
 Since:
 
 0.4.0
 
 See Also:
 
 foldLeft(Object, BiFunction), foldRight(BinaryOperator), reduce(BinaryOperator)
 - foldRight
```
public  U foldRight(U seed,
 BiFunction<? super T,U,U> accumulator)
```
 Folds the elements of this stream using the provided seed object and accumulation function, going right to left.
 This is a terminal operation.
 As this method must process elements strictly right to left, it cannot start processing till all the previous stream stages complete. Also it requires intermediate memory to store the whole content of the stream as the stream natural order is left to right. If your accumulator function is associative and you can provide a combiner function, consider using reduce(Object, BiFunction, BinaryOperator) method.
 For parallel stream it's not guaranteed that accumulator will always be executed in the same thread.
 
 Type Parameters:
 
 U - The type of the result
 
 Parameters:
 
 seed - the starting value
 
 accumulator - a non-interfering , stateless function for incorporating an additional element into a result
 
 Returns:
 
 the result of the folding
 
 Since:
 
 0.2.2
 
 See Also:
 
 foldLeft(Object, BiFunction), reduce(Object, BinaryOperator), reduce(Object, BiFunction, BinaryOperator)
 - foldRight
```
public Optional<T> foldRight(BinaryOperator<T> accumulator)
```
 Folds the elements of this stream using the provided accumulation function, going right to left.
 This is a terminal operation.
 As this method must process elements strictly right to left, it cannot start processing till all the previous stream stages complete. Also it requires intermediate memory to store the whole content of the stream as the stream natural order is left to right. If your accumulator function is associative, consider using reduce(BinaryOperator) method.
 For parallel stream it's not guaranteed that accumulator will always be executed in the same thread.
 
 Parameters:
 
 accumulator - a non-interfering , stateless function for incorporating an additional element into a result
 
 Returns:
 
 the result of the folding
 
 Since:
 
 0.4.0
 
 See Also:
 
 foldRight(Object, BiFunction), foldLeft(BinaryOperator), reduce(BinaryOperator)
 - scanLeft
```
public  List scanLeft(U seed,
 BiFunction<U,? super T,U> accumulator)
```
 Produces a list containing cumulative results of applying the accumulation function going left to right using given seed value.
 This is a terminal operation.
 The resulting List is guaranteed to be mutable.
 For parallel stream it's not guaranteed that accumulator will always be executed in the same thread.
 This method cannot take all the advantages of parallel streams as it must process elements strictly left to right.
 
 Type Parameters:
 
 U - The type of the result
 
 Parameters:
 
 seed - the starting value
 
 accumulator - a non-interfering , stateless function for incorporating an additional element into a result
 
 Returns:
 
 the List where the first element is the seed and every successor element is the result of applying accumulator function to the previous list element and the corresponding stream element. The resulting list is one element longer than this stream.
 
 Since:
 
 0.2.1
 
 See Also:
 
 foldLeft(Object, BiFunction), scanRight(Object, BiFunction)
 - scanLeft
```
public List<T> scanLeft(BinaryOperator<T> accumulator)
```
 Produces a list containing cumulative results of applying the accumulation function going left to right.
 This is a terminal operation.
 The resulting List is guaranteed to be mutable.
 For parallel stream it's not guaranteed that accumulator will always be executed in the same thread.
 This method cannot take all the advantages of parallel streams as it must process elements strictly left to right.
 
 Parameters:
 
 accumulator - a non-interfering , stateless function for incorporating an additional element into a result
 
 Returns:
 
 the List where the first element is the first element of this stream and every successor element is the result of applying accumulator function to the previous list element and the corresponding stream element. The resulting list has the same size as this stream.
 
 Since:
 
 0.4.0
 
 See Also:
 
 foldLeft(BinaryOperator), scanRight(BinaryOperator), prefix(BinaryOperator)
 - scanRight
```
public  List scanRight(U seed,
 BiFunction<? super T,U,U> accumulator)
```
 Produces a list containing cumulative results of applying the accumulation function going right to left using given seed value.
 This is a terminal operation.
 The resulting List is guaranteed to be mutable.
 For parallel stream it's not guaranteed that accumulator will always be executed in the same thread.
 This method cannot take all the advantages of parallel streams as it must process elements strictly right to left.
 
 Type Parameters:
 
 U - The type of the result
 
 Parameters:
 
 seed - the starting value
 
 accumulator - a non-interfering , stateless function for incorporating an additional element into a result
 
 Returns:
 
 the List where the last element is the seed and every predecessor element is the result of applying accumulator function to the corresponding stream element and the next list element. The resulting list is one element longer than this stream.
 
 Since:
 
 0.2.2
 
 See Also:
 
 scanLeft(Object, BiFunction), foldRight(Object, BiFunction)
 - scanRight
```
public List<T> scanRight(BinaryOperator<T> accumulator)
```
 Produces a collection containing cumulative results of applying the accumulation function going right to left.
 This is a terminal operation.
 The result List is guaranteed to be mutable.
 For parallel stream it's not guaranteed that accumulator will always be executed in the same thread.
 This method cannot take all the advantages of parallel streams as it must process elements strictly right to left.
 
 Parameters:
 
 accumulator - a non-interfering , stateless function for incorporating an additional element into a result
 
 Returns:
 
 the List where the last element is the last element of this stream and every predecessor element is the result of applying accumulator function to the corresponding stream element and the next list element. The resulting list is one element longer than this stream.
 
 Since:
 
 0.4.0
 
 See Also:
 
 scanLeft(BinaryOperator), foldRight(BinaryOperator)
 - skipOrdered
```
public S skipOrdered(long n)
```
 Returns a stream consisting of the remaining elements of this stream after discarding the first n elements of the stream even if the stream is unordered. If this stream contains fewer than n elements then an empty stream will be returned.
 This is a stateful quasi-intermediate operation. Unlike skip(long) it skips the first elements even if the stream is unordered. The main purpose of this method is to workaround the problem of skipping the first elements from non-sized source with further parallel processing and unordered terminal operation (such as forEach(Consumer)). For example, StreamEx.ofLines(br).skip(1).parallel().toSet() will skip arbitrary line, but StreamEx.ofLines(br).skipOrdered(1).parallel().toSet() will skip the first one. This problem was fixed in OracleJDK 8u60.
 Also it behaves much better with infinite streams processed in parallel.
 For sequential streams this method behaves exactly like skip(long).
 
 Parameters:
 
 n - the number of leading elements to skip
 
 Returns:
 
 the new stream
 
 Throws:
 
 IllegalArgumentException - if n is negative
 
 Since:
 
 0.3.2
 
 See Also:
 
 skip(long)
 - takeWhile
```
public S takeWhile(Predicate<? super T> predicate)
```
 Returns a stream consisting of all elements from this stream until the first element which does not match the given predicate is found.
 This is a short-circuiting stateful operation. It can be either intermediate or quasi-intermediate. When using with JDK 1.9 or higher it calls the corresponding JDK 1.9 implementation. When using with JDK 1.8 it uses own implementation.
 While this operation is quite cheap for sequential stream, it can be quite expensive on parallel pipelines. Using unordered source or making it explicitly unordered with unordered() call may improve the parallel processing performance if semantics permit.
 
 Parameters:
 
 predicate - a non-interfering, stateless predicate to apply to elements.
 
 Returns:
 
 the new stream.
 
 Since:
 
 0.3.6
 
 See Also:
 
 takeWhileInclusive(Predicate), dropWhile(Predicate)
 - takeWhileInclusive
```
public S takeWhileInclusive(Predicate<? super T> predicate)
```
 Returns a stream consisting of all elements from this stream until the first element which does not match the given predicate is found (including the first mismatching element).
 This is a quasi-intermediate operation.
 While this operation is quite cheap for sequential stream, it can be quite expensive on parallel pipelines. Using unordered source or making it explicitly unordered with unordered() call may improve the parallel processing performance if semantics permit.
 
 Parameters:
 
 predicate - a non-interfering, stateless predicate to apply to elements.
 
 Returns:
 
 the new stream.
 
 Since:
 
 0.5.5
 
 See Also:
 
 takeWhile(Predicate)
 - dropWhile
```
public S dropWhile(Predicate<? super T> predicate)
```
 Returns a stream consisting of all elements from this stream starting from the first element which does not match the given predicate. If the predicate is true for all stream elements, an empty stream is returned.
 This is a stateful operation. It can be either intermediate or quasi-intermediate. When using with JDK 1.9 or higher it calls the corresponding JDK 1.9 implementation. When using with JDK 1.8 it uses own implementation.
 While this operation is quite cheap for sequential stream, it can be quite expensive on parallel pipelines. Using unordered source or making it explicitly unordered with unordered() call may improve the parallel processing performance if semantics permit.
 
 Parameters:
 
 predicate - a non-interfering, stateless predicate to apply to elements.
 
 Returns:
 
 the new stream.
 
 Since:
 
 0.3.6
 - prefix
```
public S prefix(BinaryOperator<T> op)
```
 Returns a stream containing cumulative results of applying the accumulation function going left to right.
 This is a stateful quasi-intermediate operation.
 This operation resembles scanLeft(BinaryOperator), but unlike scanLeft this operation is intermediate and accumulation function must be associative.
 This method cannot take all the advantages of parallel streams as it must process elements strictly left to right. Using an unordered source or removing the ordering constraint with unordered() may improve the parallel processing speed.
 
 Parameters:
 
 op - an associative, non-interfering , stateless function for computing the next element based on the previous one
 
 Returns:
 
 the new stream.
 
 Since:
 
 0.6.1
 
 See Also:
 
 scanLeft(BinaryOperator)
 - chain
```
public  U chain(Function<? super S,U> mapper)
```
 Applies the supplied function to this stream and returns the result of the function.
 This method can be used to add more functionality in the fluent style. For example, consider user-defined static method batches(stream, n) which breaks the stream into batches of given length. Normally you would write batches(StreamEx.of(input).map(...), 10).filter(...). Using the chain() method you can write in more fluent manner: StreamEx.of(input).map(...).chain(s -> batches(s, 10)).filter(...).
 You could even go further and define a method which returns a function like <T> UnaryOperator<StreamEx<T>> batches(int n) and use it like this: StreamEx.of(input).map(...).chain(batches(10)).filter(...).
 
 Type Parameters:
 
 U - the type of the function result.
 
 Parameters:
 
 mapper - function to invoke.
 
 Returns:
 
 the result of the function invocation.
 - spliterator
```
public SPLTR spliterator()
```
 Description copied from interface: java.util.stream.BaseStream
 
 Returns a spliterator for the elements of this stream.
 This is a terminal operation.
 
 Specified by:
 
 spliterator in interface BaseStream<T,S extends BaseStream<T,S>>
 
 Returns:
 
 the element spliterator for this stream
 - isParallel
```
public boolean isParallel()
```
 Description copied from interface: java.util.stream.BaseStream
 
 Returns whether this stream, if a terminal operation were to be executed, would execute in parallel. Calling this method after invoking an terminal stream operation method may yield unpredictable results.
 
 Specified by:
 
 isParallel in interface BaseStream<T,S extends BaseStream<T,S>>
 
 Returns:
 
 true if this stream would execute in parallel if executed
 - close
```
public void close()
```
 Description copied from interface: java.util.stream.BaseStream
 
 Closes this stream, causing all close handlers for this stream pipeline to be called.
 
 Specified by:
 
 close in interface AutoCloseable
 
 Specified by:
 
 close in interface BaseStream<T,S extends BaseStream<T,S>>
 
 See Also:
 
 AutoCloseable.close()

Class AbstractStreamEx<T,S extends AbstractStreamEx<T,S>>

Nested Class Summary

Nested classes/interfaces inherited from interface Stream

Method Summary

Methods inherited from class Object

Methods inherited from interface Stream

Methods inherited from interface BaseStream

Methods inherited from interface Iterable

Method Detail

iterator

sequential

parallel

parallel

unordered

onClose

filter

flatMap

map

mapToInt

mapToLong

mapToDouble

flatMapToInt

flatMapToLong

flatMapToDouble

distinct

distinct

sorted

sorted

peek

limit

skip

forEach

forEachOrdered

toArray

toArray

reduce

reduce

reduce

collect

collect

min

max

count

anyMatch

allMatch

noneMatch

findFirst

findAny

indexOf

indexOf

flatCollection

flatArray

remove

nonNull

findAny

findFirst

reverseSorted

sortedBy

sortedByInt

sortedByLong

sortedByDouble

minBy

minByInt

minByLong

minByDouble

maxBy

maxByInt

maxByLong

maxByDouble

append

prepend

toList

toImmutableList

toListAndThen

toSet

toImmutableSet

toSetAndThen

toCollection

foldLeft

foldLeft