Stream (stream 1.2.2 API)

java.lang.Object
- com.annimon.stream.Stream<T>

Type Parameters:

T - the type of the stream elements

All Implemented Interfaces:

java.io.Closeable, java.lang.AutoCloseable
```
public class Stream<T>
extends java.lang.Object
implements java.io.Closeable
```
A sequence of elements supporting aggregate operations.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`boolean`	`allMatch(Predicate<? super T> predicate)` Tests whether all elements match the given predicate.
`boolean`	`anyMatch(Predicate<? super T> predicate)` Tests whether any elements match the given predicate.
`Stream<T>`	`append(Stream<? extends T> stream)` Appends given `Stream` to current and returns a new stream.
`<K> Stream<java.util.List<T>>`	`chunkBy(Function<? super T,? extends K> classifier)` Partitions `Stream` into `List`s according to the given classifier function.
`void`	`close()` Causes close handler to be invoked if it exists.
`<R,A> R`	`collect(Collector<? super T,A,R> collector)` Collects elements with `collector` that encapsulates supplier, accumulator and combiner functions.
`<R> R`	`collect(Supplier<R> supplier, BiConsumer<R,? super T> accumulator)` Collects elements to `supplier` provided container by applying the given accumulation function.
`static <T> Stream<T>`	`concat(java.util.Iterator<? extends T> iterator1, java.util.Iterator<? extends T> iterator2)` Concatenates two iterators to a stream.
`static <T> Stream<T>`	`concat(java.util.Iterator<? extends T> iterator1, java.util.Iterator<? extends T> iterator2, java.util.Iterator<? extends T>... rest)` Concatenates three or more iterators to a stream.
`static <T> Stream<T>`	`concat(java.util.List<? extends Stream<? extends T>> streams)` Lazily concatenates a `List` of streams.
`static <T> Stream<T>`	`concat(Stream<? extends T> stream1, Stream<? extends T> stream2)` Lazily concatenates two streams.
`long`	`count()` Returns the count of elements in this stream.
`<R> R`	`custom(Function<Stream<T>,R> function)` Applies custom operator on stream.
`Stream<T>`	`distinct()` Returns `Stream` with distinct elements (as determined by `hashCode` and `equals` methods).
`<K> Stream<T>`	`distinctBy(Function<? super T,? extends K> classifier)` Returns `Stream` with distinct elements (as determined by `hashCode` and `equals` methods) according to the given classifier function.
`Stream<T>`	`dropWhile(Predicate<? super T> predicate)` Drops elements while the predicate is true, then returns the rest.
`Stream<T>`	`dropWhileIndexed(IndexedPredicate<? super T> predicate)` Drops elements while the `IndexedPredicate` is true, then returns the rest.
`Stream<T>`	`dropWhileIndexed(int from, int step, IndexedPredicate<? super T> predicate)` Drops elements while the `IndexedPredicate` is true, then returns the rest.
`static <T> Stream<T>`	`empty()` Returns an empty stream.
`Stream<T>`	`equalsOnly(T object)` Returns `Stream` with elements that is equality of `object` only.
`Stream<T>`	`filter(Predicate<? super T> predicate)` Returns `Stream` with elements that satisfy the given predicate.
`Stream<T>`	`filterIndexed(IndexedPredicate<? super T> predicate)` Returns a `Stream` with elements that satisfy the given `IndexedPredicate`.
`Stream<T>`	`filterIndexed(int from, int step, IndexedPredicate<? super T> predicate)` Returns a `Stream` with elements that satisfy the given `IndexedPredicate`.
`Stream<T>`	`filterNot(Predicate<? super T> predicate)` Returns `Stream` with elements that does not satisfy the given predicate.
`Optional<T>`	`findFirst()` Returns the first element wrapped by `Optional` class.
`T`	`findFirstOrElse(T other)` Returns the first element if stream is not empty, otherwise returns `other`.
`Optional<IntPair<T>>`	`findIndexed(IndexedPredicate<? super T> predicate)` Finds the first element and its index that matches the given predicate.
`Optional<IntPair<T>>`	`findIndexed(int from, int step, IndexedPredicate<? super T> predicate)` Finds the first element and its index that matches the given predicate.
`Optional<T>`	`findLast()` Returns the last element wrapped by `Optional` class.
`Optional<T>`	`findSingle()` Returns the single element wrapped by `Optional` class.
`<R> Stream<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.
`DoubleStream`	`flatMapToDouble(Function<? super T,? extends DoubleStream> 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.
`IntStream`	`flatMapToInt(Function<? super T,? extends IntStream> 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.
`LongStream`	`flatMapToLong(Function<? super T,? extends LongStream> 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.
`void`	`forEach(Consumer<? super T> action)` Performs the given action on each element.
`void`	`forEachIndexed(IndexedConsumer<? super T> action)` Performs the given indexed action on each element.
`void`	`forEachIndexed(int from, int step, IndexedConsumer<? super T> action)` Performs the given indexed action on each element.
`static <T> Stream<T>`	`generate(Supplier<T> supplier)` Creates a `Stream` by elements that generated by `Supplier`.
`<K> Stream<java.util.Map.Entry<K,java.util.List<T>>>`	`groupBy(Function<? super T,? extends K> classifier)` Partitions `Stream` into `Map` entries according to the given classifier function.
`Stream<IntPair<T>>`	`indexed()` Returns `Stream` with indexed elements.
`Stream<IntPair<T>>`	`indexed(int from, int step)` Returns `Stream` with indexed elements.
`static <T> Stream<T>`	`iterate(T seed, Predicate<? super T> predicate, UnaryOperator<T> op)` Creates a `Stream` by iterative application `UnaryOperator` function to an initial element `seed`, conditioned on satisfying the supplied predicate.
`static <T> Stream<T>`	`iterate(T seed, UnaryOperator<T> op)` Creates a `Stream` by iterative application `UnaryOperator` function to an initial element `seed`.
`java.util.Iterator<? extends T>`	`iterator()` Returns internal stream iterator.
`Stream<T>`	`limit(long maxSize)` Returns `Stream` with first `maxSize` elements.
`<R> Stream<R>`	`map(Function<? super T,? extends R> mapper)` Returns `Stream` with elements that obtained by applying the given function.
`<R> Stream<R>`	`mapIndexed(IndexedFunction<? super T,? extends R> mapper)` Returns a `Stream` with elements that obtained by applying the given `IndexedFunction`.
`<R> Stream<R>`	`mapIndexed(int from, int step, IndexedFunction<? super T,? extends R> mapper)` Returns a `Stream` with elements that obtained by applying the given `IndexedFunction`.
`<R> Stream<R>`	`mapMulti(BiConsumer<? super T,? super Consumer<R>> mapper)` Returns a stream consisting of the results of replacing each element of this stream with zero or more elements, that passed to the provided consumer function.
`DoubleStream`	`mapMultiToDouble(BiConsumer<? super T,? super DoubleConsumer> mapper)` Returns a stream consisting of the results of replacing each element of this stream with zero or more elements, that passed to the provided consumer function.
`IntStream`	`mapMultiToInt(BiConsumer<? super T,? super IntConsumer> mapper)` Returns a stream consisting of the results of replacing each element of this stream with zero or more elements, that passed to the provided consumer function.
`LongStream`	`mapMultiToLong(BiConsumer<? super T,? super LongConsumer> mapper)` Returns a stream consisting of the results of replacing each element of this stream with zero or more elements, that passed to the provided consumer function.
`DoubleStream`	`mapToDouble(ToDoubleFunction<? super T> mapper)` Returns `DoubleStream` with elements that obtained by applying the given function.
`IntStream`	`mapToInt(ToIntFunction<? super T> mapper)` Returns `IntStream` with elements that obtained by applying the given function.
`LongStream`	`mapToLong(ToLongFunction<? super T> mapper)` Returns `LongStream` with elements that obtained by applying the given function.
`Optional<T>`	`max(java.util.Comparator<? super T> comparator)` Finds the maximum element according to the given comparator.
`static <T> Stream<T>`	`merge(java.util.Iterator<? extends T> iterator1, java.util.Iterator<? extends T> iterator2, BiFunction<? super T,? super T,ObjMerge.MergeResult> selector)` Merges elements of two iterators according to the supplied selector function.
`static <T> Stream<T>`	`merge(Stream<? extends T> stream1, Stream<? extends T> stream2, BiFunction<? super T,? super T,ObjMerge.MergeResult> selector)` Merges elements of two streams according to the supplied selector function.
`Optional<T>`	`min(java.util.Comparator<? super T> comparator)` Finds the minimum element according to the given comparator.
`boolean`	`noneMatch(Predicate<? super T> predicate)` Tests whether no elements match the given predicate.
`Stream<T>`	`nullsOnly()` Returns `Stream` with elements that is null only.
`static <T> Stream<T>`	`of(java.lang.Iterable<? extends T> iterable)` Creates a `Stream` from any class that implements `Iterable` interface.
`static <T> Stream<T>`	`of(java.util.Iterator<? extends T> iterator)` Creates a `Stream` from any class that implements `Iterator` interface.
`static <K,V> Stream<java.util.Map.Entry<K,V>>`	`of(java.util.Map<K,V> map)` Creates a `Stream` from `Map` entries.
`static <T> Stream<T>`	`of(T... elements)` Creates a `Stream` from the specified values.
`static <T> Stream<T>`	`ofNullable(java.lang.Iterable<? extends T> iterable)` If specified iterable is null, returns an empty `Stream`, otherwise returns a `Stream` containing elements of this iterable.
`static <T> Stream<T>`	`ofNullable(java.util.Iterator<? extends T> iterator)` If specified iterator is null, returns an empty `Stream`, otherwise returns a `Stream` containing entries of this iterator.
`static <K,V> Stream<java.util.Map.Entry<K,V>>`	`ofNullable(java.util.Map<K,V> map)` If specified map is null, returns an empty `Stream`, otherwise returns a `Stream` containing entries of this map.
`static <T> Stream<T>`	`ofNullable(T element)` If specified element is null, returns an empty `Stream`, otherwise returns a `Stream` containing a single element.
`static <T> Stream<T>`	`ofNullable(T[] array)` If specified array is null, returns an empty `Stream`, otherwise returns a `Stream` containing elements of this array.
`Stream<T>`	`onClose(java.lang.Runnable closeHandler)` Adds close handler to the current stream.
`Stream<T>`	`peek(Consumer<? super T> action)` Performs provided action on each element.
`Stream<T>`	`prepend(Stream<? extends T> stream)` Prepends given `Stream` to current and returns a new stream.
`static Stream<java.lang.Integer>`	`range(int from, int to)` Creates a `Stream<Integer>` from not closed range (from `from` inclusive to `to` exclusive and incremental step `1`).
`static Stream<java.lang.Long>`	`range(long from, long to)` Creates a `Stream<Long>` from not closed range (from `from` inclusive to `to` exclusive and incremental step `1`).
`static Stream<java.lang.Integer>`	`rangeClosed(int from, int to)` Creates a `Stream<Integer>` from closed range (from `from` inclusive to `to` inclusive and incremental step `1`).
`static Stream<java.lang.Long>`	`rangeClosed(long from, long to)` Creates a `Stream<Long>` from closed range (from `from` inclusive to `to` inclusive and incremental step `1`).
`Optional<T>`	`reduce(BiFunction<T,T,T> accumulator)` Reduces the elements using provided associative accumulation function.
`<R> R`	`reduce(R identity, BiFunction<? super R,? super T,? extends R> accumulator)` Reduces the elements using provided identity value and the associative accumulation function.
`<R> R`	`reduceIndexed(int from, int step, R identity, IndexedBiFunction<? super R,? super T,? extends R> accumulator)` Reduces the elements using provided identity value and the associative accumulation indexed function.
`<R> R`	`reduceIndexed(R identity, IndexedBiFunction<? super R,? super T,? extends R> accumulator)` Reduces the elements using provided identity value and the associative accumulation indexed function.
`Stream<T>`	`sample(int stepWidth)` Samples the `Stream` by emitting every n-th element.
`Stream<T>`	`scan(BiFunction<T,T,T> accumulator)` Returns a `Stream` produced by iterative application of a accumulation function to reduction value and next element of the current stream.
`<R> Stream<R>`	`scan(R identity, BiFunction<? super R,? super T,? extends R> accumulator)` Returns a `Stream` produced by iterative application of a accumulation function to an initial element `identity` and next element of the current stream.
`<TT> Stream<TT>`	`select(java.lang.Class<TT> clazz)` Returns a stream consisting of the elements of this stream which are instances of given class.
`T`	`single()` Returns the single element of stream.
`Stream<T>`	`skip(long n)` Skips first `n` elements and returns `Stream` with remaining elements.
`Stream<java.util.List<T>>`	`slidingWindow(int windowSize)` Partitions `Stream` into `List`s of fixed size by sliding over the elements of the stream.
`Stream<java.util.List<T>>`	`slidingWindow(int windowSize, int stepWidth)` Partitions `Stream` into `List`s of fixed size by sliding over the elements of the stream.
`<R extends java.lang.Comparable<? super R>> Stream<T>`	`sortBy(Function<? super T,? extends R> f)` Returns `Stream` with sorted elements (as determinated by `Comparable` interface).
`Stream<T>`	`sorted()` Returns `Stream` with sorted elements (as determinated by `Comparable` interface).
`Stream<T>`	`sorted(java.util.Comparator<? super T> comparator)` Returns `Stream` with sorted elements (as determinated by provided `Comparator`).
`Stream<T>`	`takeUntil(Predicate<? super T> stopPredicate)` Takes elements while the predicate returns `false`.
`Stream<T>`	`takeUntilIndexed(IndexedPredicate<? super T> stopPredicate)` Takes elements while the `IndexedPredicate` returns `false`.
`Stream<T>`	`takeUntilIndexed(int from, int step, IndexedPredicate<? super T> stopPredicate)` Takes elements while the `IndexedPredicate` returns `false`.
`Stream<T>`	`takeWhile(Predicate<? super T> predicate)` Takes elements while the predicate returns `true`.
`Stream<T>`	`takeWhileIndexed(IndexedPredicate<? super T> predicate)` Takes elements while the `IndexedPredicate` returns `true`.
`Stream<T>`	`takeWhileIndexed(int from, int step, IndexedPredicate<? super T> predicate)` Takes elements while the `IndexedPredicate` returns `true`.
`java.lang.Object[]`	`toArray()` Collects elements to an array.
`<R> R[]`	`toArray(IntFunction<R[]> generator)` Collects elements to an array, the `generator` constructor of provided.
`java.util.List<T>`	`toList()` Collects elements to a new `List`.
`Stream<T>`	`withoutNulls()` Returns `Stream` without null elements.
`static <F,S,R> Stream<R>`	`zip(java.util.Iterator<? extends F> iterator1, java.util.Iterator<? extends S> iterator2, BiFunction<? super F,? super S,? extends R> combiner)` Combines two iterators to a stream by applying specified combiner function to each element at same position.
`static <F,S,R> Stream<R>`	`zip(Stream<? extends F> stream1, Stream<? extends S> stream2, BiFunction<? super F,? super S,? extends R> combiner)` Combines two streams by applying specified combiner function to each element at same position.

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

- Method Detail
  - empty
```
@NotNull
public static <T> Stream<T> empty()
```
    Returns an empty stream.
    
    Type Parameters:
    
    T - the type of the stream elements
    
    Returns:
    
    the new empty stream
  - of
```
@NotNull
public static <K,V> Stream<java.util.Map.Entry<K,V>> of(@NotNull
                                                                 java.util.Map<K,V> map)
```
    Creates a Stream from Map entries.
    
    Type Parameters:
    
    K - the type of map keys
    
    V - the type of map values
    
    Parameters:
    
    map - the map with elements to be passed to stream
    
    Returns:
    
    the new stream
    
    Throws:
    
    java.lang.NullPointerException - if map is null
  - of
```
@NotNull
public static <T> Stream<T> of(@NotNull
                                        java.util.Iterator<? extends T> iterator)
```
    Creates a Stream from any class that implements Iterator interface.
    
    Type Parameters:
    
    T - the type of the stream elements
    
    Parameters:
    
    iterator - the iterator with elements to be passed to stream
    
    Returns:
    
    the new stream
    
    Throws:
    
    java.lang.NullPointerException - if iterator is null
  - of
```
@NotNull
public static <T> Stream<T> of(@NotNull
                                        java.lang.Iterable<? extends T> iterable)
```
    Creates a Stream from any class that implements Iterable interface.
    
    Type Parameters:
    
    T - the type of the stream elements
    
    Parameters:
    
    iterable - the Iterable with elements to be passed to stream
    
    Returns:
    
    the new stream
    
    Throws:
    
    java.lang.NullPointerException - if iterable is null
  - of
```
@NotNull
public static <T> Stream<T> of(@NotNull
                                        T... elements)
```
    Creates a Stream from the specified values.
    
    Type Parameters:
    
    T - the type of the stream elements
    
    Parameters:
    
    elements - the elements to be passed to stream
    
    Returns:
    
    the new stream
    
    Throws:
    
    java.lang.NullPointerException - if elements is null
  - ofNullable
```
@NotNull
public static <T> Stream<T> ofNullable(@Nullable
                                                T element)
```
    If specified element is null, returns an empty Stream, otherwise returns a Stream containing a single element.
    
    Type Parameters:
    
    T - the type of the stream element
    
    Parameters:
    
    element - the element to be passed to stream if it is non-null
    
    Returns:
    
    the new stream
    
    Since:
    
    1.1.5
  - ofNullable
```
@NotNull
public static <T> Stream<T> ofNullable(@Nullable
                                                T[] array)
```
    If specified array is null, returns an empty Stream, otherwise returns a Stream containing elements of this array.
    
    Type Parameters:
    
    T - the type of the stream elements
    
    Parameters:
    
    array - the array whose elements to be passed to stream
    
    Returns:
    
    the new stream
    
    Since:
    
    1.1.9
  - ofNullable
```
@NotNull
public static <K,V> Stream<java.util.Map.Entry<K,V>> ofNullable(@Nullable
                                                                         java.util.Map<K,V> map)
```
    If specified map is null, returns an empty Stream, otherwise returns a Stream containing entries of this map.
    
    Type Parameters:
    
    K - the type of map keys
    
    V - the type of map values
    
    Parameters:
    
    map - the map with elements to be passed to stream
    
    Returns:
    
    the new stream
    
    Since:
    
    1.1.9
  - ofNullable
```
@NotNull
public static <T> Stream<T> ofNullable(@Nullable
                                                java.util.Iterator<? extends T> iterator)
```
    If specified iterator is null, returns an empty Stream, otherwise returns a Stream containing entries of this iterator.
    
    Type Parameters:
    
    T - the type of the stream elements
    
    Parameters:
    
    iterator - the iterator with elements to be passed to stream
    
    Returns:
    
    the new stream
    
    Since:
    
    1.1.9
  - ofNullable
```
@NotNull
public static <T> Stream<T> ofNullable(@Nullable
                                                java.lang.Iterable<? extends T> iterable)
```
    If specified iterable is null, returns an empty Stream, otherwise returns a Stream containing elements of this iterable.
    
    Type Parameters:
    
    T - the type of the stream elements
    
    Parameters:
    
    iterable - the Iterable with elements to be passed to stream
    
    Returns:
    
    the new stream
    
    Since:
    
    1.1.5
  - range
```
@NotNull
public static Stream<java.lang.Integer> range(int from,
                                                       int to)
```
    Creates a Stream<Integer> from not closed range (from from inclusive to to exclusive and incremental step 1).
    
    Parameters:
    
    from - the initial value (inclusive)
    
    to - the upper bound (exclusive)
    
    Returns:
    
    the new stream
    
    See Also:
    
    IntStream.range(int, int)
  - range
```
@NotNull
public static Stream<java.lang.Long> range(long from,
                                                    long to)
```
    Creates a Stream<Long> from not closed range (from from inclusive to to exclusive and incremental step 1).
    
    Parameters:
    
    from - the initial value (inclusive)
    
    to - the upper bound (exclusive)
    
    Returns:
    
    the new stream
  - rangeClosed
```
@NotNull
public static Stream<java.lang.Integer> rangeClosed(int from,
                                                             int to)
```
    Creates a Stream<Integer> from closed range (from from inclusive to to inclusive and incremental step 1).
    
    Parameters:
    
    from - the initial value (inclusive)
    
    to - the upper bound (inclusive)
    
    Returns:
    
    the new stream
    
    See Also:
    
    IntStream.rangeClosed(int, int)
  - rangeClosed
```
@NotNull
public static Stream<java.lang.Long> rangeClosed(long from,
                                                          long to)
```
    Creates a Stream<Long> from closed range (from from inclusive to to inclusive and incremental step 1).
    
    Parameters:
    
    from - the initial value (inclusive)
    
    to - the upper bound (inclusive)
    
    Returns:
    
    the new stream
  - generate
```
@NotNull
public static <T> Stream<T> generate(@NotNull
                                              Supplier<T> supplier)
```
    Creates a Stream by elements that generated by Supplier.
    
    Type Parameters:
    
    T - the type of the stream elements
    
    Parameters:
    
    supplier - the Supplier of generated elements
    
    Returns:
    
    the new stream
    
    Throws:
    
    java.lang.NullPointerException - if supplier is null
  - iterate
```
@NotNull
public static <T> Stream<T> iterate(@Nullable
                                             T seed,
                                             @NotNull
                                             UnaryOperator<T> op)
```
    Creates a Stream by iterative application UnaryOperator function to an initial element seed. Produces Stream consisting of seed, op(seed), op(op(seed)), etc.
    Example:
```
 seed: 1
 op: (a) -> a + 5
 result: [1, 6, 11, 16, ...]
 
```
    Type Parameters:
    
    T - the type of the stream elements
    
    Parameters:
    
    seed - the initial value
    
    op - operator to produce new element by previous one
    
    Returns:
    
    the new stream
    
    Throws:
    
    java.lang.NullPointerException - if op is null
  - iterate
```
@NotNull
public static <T> Stream<T> iterate(@Nullable
                                             T seed,
                                             @NotNull
                                             Predicate<? super T> predicate,
                                             @NotNull
                                             UnaryOperator<T> op)
```
    Creates a Stream by iterative application UnaryOperator function to an initial element seed, conditioned on satisfying the supplied predicate.
    Example:
```
 seed: 0
 predicate: (a) -> a < 20
 op: (a) -> a + 5
 result: [0, 5, 10, 15]
 
```
    Type Parameters:
    
    T - the type of the stream elements
    
    Parameters:
    
    seed - the initial value
    
    predicate - a predicate to determine when the stream must terminate
    
    op - operator to produce new element by previous one
    
    Returns:
    
    the new stream
    
    Throws:
    
    java.lang.NullPointerException - if op is null
    
    Since:
    
    1.1.5
  - concat
```
@NotNull
public static <T> Stream<T> concat(@NotNull
                                            Stream<? extends T> stream1,
                                            @NotNull
                                            Stream<? extends T> stream2)
```
    Lazily concatenates two streams.
    Example:
```
 stream 1: [1, 2, 3, 4]
 stream 2: [5, 6]
 result:   [1, 2, 3, 4, 5, 6]
 
```
    Type Parameters:
    
    T - The type of stream elements
    
    Parameters:
    
    stream1 - the first stream
    
    stream2 - the second stream
    
    Returns:
    
    the new concatenated stream
    
    Throws:
    
    java.lang.NullPointerException - if stream1 or stream2 is null
  - concat
```
@NotNull
public static <T> Stream<T> concat(@NotNull
                                            java.util.List<? extends Stream<? extends T>> streams)
```
    Lazily concatenates a List of streams.
    Example:
```
 stream 1: [1, 2, 3, 4]
 stream 2: [5, 6]
 stream 3: [7]
 stream 4: [8, 9, 10]
 result:   [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
 
```
    Type Parameters:
    
    T - The type of stream elements
    
    Parameters:
    
    streams - the list of streams
    
    Returns:
    
    the new concatenated stream
    
    Throws:
    
    java.lang.NullPointerException - if streams is null
    
    Since:
    
    1.2.2
  - concat
```
@NotNull
public static <T> Stream<T> concat(@NotNull
                                            java.util.Iterator<? extends T> iterator1,
                                            @NotNull
                                            java.util.Iterator<? extends T> iterator2)
```
    Concatenates two iterators to a stream.
    Example:
```
 iterator 1: [1, 2, 3, 4]
 iterator 2: [5, 6]
 result:     [1, 2, 3, 4, 5, 6]
 
```
    Type Parameters:
    
    T - The type of iterator elements
    
    Parameters:
    
    iterator1 - the first iterator
    
    iterator2 - the second iterator
    
    Returns:
    
    the new stream
    
    Throws:
    
    java.lang.NullPointerException - if iterator1 or iterator2 is null
    
    Since:
    
    1.1.9
  - concat
```
@NotNull
public static <T> Stream<T> concat(@NotNull
                                            java.util.Iterator<? extends T> iterator1,
                                            @NotNull
                                            java.util.Iterator<? extends T> iterator2,
                                            @NotNull
                                            java.util.Iterator<? extends T>... rest)
```
    Concatenates three or more iterators to a stream.
    Example:
```
 iterator 1: [1, 2, 3, 4]
 iterator 2: [5, 6]
 iterator 3: [7]
 iterator 4: [8, 9, 10]
 result:     [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
 
```
    Type Parameters:
    
    T - The type of iterator elements
    
    Parameters:
    
    iterator1 - the first iterator
    
    iterator2 - the second iterator
    
    rest - the rest iterators
    
    Returns:
    
    the new concatenated stream
    
    Throws:
    
    java.lang.NullPointerException - if iterator1 or iterator2 or rest is null
    
    Since:
    
    1.2.2
  - zip
```
@NotNull
public static <F,S,R> Stream<R> zip(@NotNull
                                             Stream<? extends F> stream1,
                                             @NotNull
                                             Stream<? extends S> stream2,
                                             @NotNull
                                             BiFunction<? super F,? super S,? extends R> combiner)
```
    Combines two streams by applying specified combiner function to each element at same position.
    Example:
```
 combiner: (a, b) -> a + b
 stream 1: [1, 2, 3, 4]
 stream 2: [5, 6, 7, 8]
 result:   [6, 8, 10, 12]
 
```
    Type Parameters:
    
    F - the type of first stream elements
    
    S - the type of second stream elements
    
    R - the type of elements in resulting stream
    
    Parameters:
    
    stream1 - the first stream
    
    stream2 - the second stream
    
    combiner - the combiner function used to apply to each element
    
    Returns:
    
    the new stream
    
    Throws:
    
    java.lang.NullPointerException - if stream1 or stream2 is null
  - zip
```
@NotNull
public static <F,S,R> Stream<R> zip(@NotNull
                                             java.util.Iterator<? extends F> iterator1,
                                             @NotNull
                                             java.util.Iterator<? extends S> iterator2,
                                             @NotNull
                                             BiFunction<? super F,? super S,? extends R> combiner)
```
    Combines two iterators to a stream by applying specified combiner function to each element at same position.
    Example:
```
 combiner: (a, b) -> a + b
 stream 1: [1, 2, 3, 4]
 stream 2: [5, 6, 7, 8]
 result:   [6, 8, 10, 12]
 
```
    Type Parameters:
    
    F - the type of first iterator elements
    
    S - the type of second iterator elements
    
    R - the type of elements in resulting stream
    
    Parameters:
    
    iterator1 - the first iterator
    
    iterator2 - the second iterator
    
    combiner - the combiner function used to apply to each element
    
    Returns:
    
    the new stream
    
    Throws:
    
    java.lang.NullPointerException - if iterator1 or iterator2 is null
    
    Since:
    
    1.1.2
  - merge
```
@NotNull
public static <T> Stream<T> merge(@NotNull
                                           Stream<? extends T> stream1,
                                           @NotNull
                                           Stream<? extends T> stream2,
                                           @NotNull
                                           BiFunction<? super T,? super T,ObjMerge.MergeResult> selector)
```
    Merges elements of two streams according to the supplied selector function.
    Example 1 — Merge two sorted streams:
```
 stream1: [1, 3, 8, 10]
 stream2: [2, 5, 6, 12]
 selector: (a, b) -> a < b ? TAKE_FIRST : TAKE_SECOND
 result: [1, 2, 3, 5, 6, 8, 10, 12]
 
```
    Example 2 — Concat two streams:
```
 stream1: [0, 3, 1]
 stream2: [2, 5, 6, 1]
 selector: (a, b) -> TAKE_SECOND
 result: [2, 5, 6, 1, 0, 3, 1]
 
```
    Type Parameters:
    
    T - the type of the elements
    
    Parameters:
    
    stream1 - the first stream
    
    stream2 - the second stream
    
    selector - the selector function used to choose elements
    
    Returns:
    
    the new stream
    
    Throws:
    
    java.lang.NullPointerException - if stream1 or stream2 is null
    
    Since:
    
    1.1.9
  - merge
```
public static <T> Stream<T> merge(@NotNull
                                  java.util.Iterator<? extends T> iterator1,
                                  @NotNull
                                  java.util.Iterator<? extends T> iterator2,
                                  @NotNull
                                  BiFunction<? super T,? super T,ObjMerge.MergeResult> selector)
```
    Merges elements of two iterators according to the supplied selector function.
    Example 1 — Merge two sorted iterators:
```
 iterator1: [1, 3, 8, 10]
 iterator2: [2, 5, 6, 12]
 selector: (a, b) -> a < b ? TAKE_FIRST : TAKE_SECOND
 result: [1, 2, 3, 5, 6, 8, 10, 12]
 
```
    Example 2 — Concat two iterators:
```
 iterator1: [0, 3, 1]
 iterator2: [2, 5, 6, 1]
 selector: (a, b) -> TAKE_SECOND
 result: [2, 5, 6, 1, 0, 3, 1]
 
```
    Type Parameters:
    
    T - the type of the elements
    
    Parameters:
    
    iterator1 - the first iterator
    
    iterator2 - the second iterator
    
    selector - the selector function used to choose elements
    
    Returns:
    
    the new stream
    
    Throws:
    
    java.lang.NullPointerException - if iterator1 or iterator2 is null
    
    Since:
    
    1.1.9
  - iterator
```
public java.util.Iterator<? extends T> iterator()
```
    Returns internal stream iterator.
    
    Returns:
    
    internal stream iterator
  - custom
```
@Nullable
public <R> R custom(@NotNull
                              Function<Stream<T>,R> function)
```
    Applies custom operator on stream. Transforming function can return Stream for intermediate operations, or any value for terminal operation.
    Operator examples:
```
     // Intermediate operator
     public class Reverse<T> implements Function<Stream<T>, Stream<T>> {
         @Override
         public Stream<T> apply(Stream<T> stream) {
             final Iterator<? extends T> iterator = stream.iterator();
             final ArrayDeque<T> deque = new ArrayDeque<T>();
             while (iterator.hasNext()) {
                 deque.addFirst(iterator.next());
             }
             return Stream.of(deque.iterator());
         }
     }

     // Intermediate operator based on existing stream operators
     public class SkipAndLimit<T> implements UnaryOperator<Stream<T>> {

         private final int skip, limit;

         public SkipAndLimit(int skip, int limit) {
             this.skip = skip;
             this.limit = limit;
         }

         @Override
         public Stream<T> apply(Stream<T> stream) {
             return stream.skip(skip).limit(limit);
         }
     }

     // Terminal operator
     public class Sum implements Function<Stream<Integer>, Integer> {
         @Override
         public Integer apply(Stream<Integer> stream) {
             return stream.reduce(0, new BinaryOperator<Integer>() {
                 @Override
                 public Integer apply(Integer value1, Integer value2) {
                     return value1 + value2;
                 }
             });
         }
     }
 
```
    Type Parameters:
    
    R - the type of the result
    
    Parameters:
    
    function - a transforming function
    
    Returns:
    
    a result of the transforming function
    
    Throws:
    
    java.lang.NullPointerException - if function is null
  - prepend
```
@NotNull
public Stream<T> prepend(@NotNull
                                  Stream<? extends T> stream)
```
    Prepends given Stream to current and returns a new stream. This is similar to Stream.concat(stream, this)
    Example:
```
 current: [1, 2, 3]
 stream:  [4, 5, 6]
 result:  [4, 5, 6, 1, 2, 3]
 
```
    Parameters:
    
    stream - the stream to prepend
    
    Returns:
    
    the new stream
    
    Since:
    
    1.2.2
    
    See Also:
    
    concat(Stream, Stream)
  - append
```
@NotNull
public Stream<T> append(@NotNull
                                 Stream<? extends T> stream)
```
    Appends given Stream to current and returns a new stream. This is similar to Stream.concat(this, stream)
    Example:
```
 current: [1, 2, 3]
 stream:  [4, 5, 6]
 result:  [1, 2, 3, 4, 5, 6]
 
```
    Parameters:
    
    stream - the stream to append
    
    Returns:
    
    the new stream
    
    Since:
    
    1.2.2
    
    See Also:
    
    concat(Stream, Stream)
  - filter
```
@NotNull
public Stream<T> filter(@NotNull
                                 Predicate<? super T> predicate)
```
    Returns Stream with elements that satisfy the given predicate.
    This is an intermediate operation.
    Example:
```
 predicate: (a) -> a > 2
 stream: [1, 2, 3, 4, -8, 0, 11]
 result: [3, 4, 11]
 
```
    Parameters:
    
    predicate - the predicate used to filter elements
    
    Returns:
    
    the new stream
  - filterIndexed
```
@NotNull
public Stream<T> filterIndexed(@NotNull
                                        IndexedPredicate<? super T> predicate)
```
    Returns a Stream with elements that satisfy the given IndexedPredicate.
    This is an intermediate operation.
    Example:
```
 predicate: (index, value) -> (index + value) > 6
 stream: [1, 2, 3, 4, 0, 11]
 index:  [0, 1, 2, 3, 4,  5]
 sum:    [1, 3, 5, 7, 4, 16]
 filter: [         7,    16]
 result: [4, 11]
 
```
    Parameters:
    
    predicate - the IndexedPredicate used to filter elements
    
    Returns:
    
    the new stream
    
    Since:
    
    1.1.6
  - filterIndexed
```
@NotNull
public Stream<T> filterIndexed(int from,
                                        int step,
                                        @NotNull
                                        IndexedPredicate<? super T> predicate)
```
    Returns a Stream with elements that satisfy the given IndexedPredicate.
    This is an intermediate operation.
    Example:
```
 from: 4
 step: 3
 predicate: (index, value) -> (index + value) > 15
 stream: [1, 2,  3,  4,  0, 11]
 index:  [4, 7, 10, 13, 16, 19]
 sum:    [5, 9, 13, 17, 16, 30]
 filter: [          17, 16, 30]
 result: [4, 0, 11]
 
```
    Parameters:
    
    from - the initial value of the index (inclusive)
    
    step - the step of the index
    
    predicate - the IndexedPredicate used to filter elements
    
    Returns:
    
    the new stream
    
    Since:
    
    1.1.6
  - filterNot
```
@NotNull
public Stream<T> filterNot(@NotNull
                                    Predicate<? super T> predicate)
```
    Returns Stream with elements that does not satisfy the given predicate.
    This is an intermediate operation.
    
    Parameters:
    
    predicate - the predicate used to filter elements
    
    Returns:
    
    the new stream
  - select
```
@NotNull
public <TT> Stream<TT> select(@NotNull
                                       java.lang.Class<TT> clazz)
```
    Returns a stream consisting of the elements of this stream which are instances of given class.
    This is an intermediate operation.
    
    Type Parameters:
    
    TT - a type of instances to select.
    
    Parameters:
    
    clazz - a class which instances should be selected
    
    Returns:
    
    the new stream of type passed as parameter
  - withoutNulls
```
@NotNull
public Stream<T> withoutNulls()
```
    Returns Stream without null elements.
    This is an intermediate operation.
    
    Returns:
    
    the new stream
    
    Since:
    
    1.1.6
  - nullsOnly
```
@NotNull
public Stream<T> nullsOnly()
```
    Returns Stream with elements that is null only.
    This is an intermediate operation.
    
    Returns:
    
    the new stream
    
    Since:
    
    1.1.6
  - equalsOnly
```
@NotNull
public Stream<T> equalsOnly(@Nullable
                                     T object)
```
    Returns Stream with elements that is equality of object only.
    This is an intermediate operation.
    
    Parameters:
    
    object - object
    
    Returns:
    
    the new stream
    
    Since:
    
    1.2.0
  - map
```
@NotNull
public <R> Stream<R> map(@NotNull
                                  Function<? super T,? extends R> mapper)
```
    Returns Stream with elements that obtained by applying the given function.
    This is an intermediate operation.
    Example:
```
 mapper: (a) -> a + 5
 stream: [1, 2, 3, 4]
 result: [6, 7, 8, 9]
 
```
    Type Parameters:
    
    R - the type of elements in resulting stream
    
    Parameters:
    
    mapper - the mapper function used to apply to each element
    
    Returns:
    
    the new stream
  - mapIndexed
```
@NotNull
public <R> Stream<R> mapIndexed(@NotNull
                                         IndexedFunction<? super T,? extends R> mapper)
```
    Returns a Stream with elements that obtained by applying the given IndexedFunction.
    This is an intermediate operation.
    Example:
```
 predicate: (index, value) -> (index * value)
 stream: [1, 2, 3,  4]
 index:  [0, 1, 2,  3]
 result: [0, 2, 6, 12]
 
```
    Type Parameters:
    
    R - the type of elements in resulting stream
    
    Parameters:
    
    mapper - the mapper function used to apply to each element
    
    Returns:
    
    the new stream
    
    Since:
    
    1.1.6
  - mapIndexed
```
@NotNull
public <R> Stream<R> mapIndexed(int from,
                                         int step,
                                         @NotNull
                                         IndexedFunction<? super T,? extends R> mapper)
```
    Returns a Stream with elements that obtained by applying the given IndexedFunction.
    This is an intermediate operation.
    Example:
```
 from: -2
 step: 2
 predicate: (index, value) -> (index * value)
 stream: [ 1, 2, 3,  4]
 index:  [-2, 0, 2,  4]
 result: [-2, 0, 6, 16]
 
```
    Type Parameters:
    
    R - the type of elements in resulting stream
    
    Parameters:
    
    from - the initial value of the index (inclusive)
    
    step - the step of the index
    
    mapper - the mapper function used to apply to each element
    
    Returns:
    
    the new stream
    
    Since:
    
    1.1.6
  - mapToInt
```
@NotNull
public IntStream mapToInt(@NotNull
                                   ToIntFunction<? super T> mapper)
```
    Returns IntStream with elements that obtained by applying the given function.
    This is an intermediate operation.
    
    Parameters:
    
    mapper - the mapper function used to apply to each element
    
    Returns:
    
    the new IntStream
    
    See Also:
    
    map(com.annimon.stream.function.Function)
  - mapToLong
```
@NotNull
public LongStream mapToLong(@NotNull
                                     ToLongFunction<? super T> mapper)
```
    Returns LongStream with elements that obtained by applying the given function.
    This is an intermediate operation.
    
    Parameters:
    
    mapper - the mapper function used to apply to each element
    
    Returns:
    
    the new LongStream
    
    Since:
    
    1.1.4
    
    See Also:
    
    map(com.annimon.stream.function.Function)
  - mapToDouble
```
@NotNull
public DoubleStream mapToDouble(@NotNull
                                         ToDoubleFunction<? super T> mapper)
```
    Returns DoubleStream with elements that obtained by applying the given function.
    This is an intermediate operation.
    
    Parameters:
    
    mapper - the mapper function used to apply to each element
    
    Returns:
    
    the new DoubleStream
    
    Since:
    
    1.1.4
    
    See Also:
    
    map(com.annimon.stream.function.Function)
  - flatMap
```
@NotNull
public <R> Stream<R> flatMap(@NotNull
                                      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.
    This is an intermediate operation.
    Example:
```
 mapper: (a) -> [a, a + 5]
 stream: [1, 2, 3, 4]
 result: [1, 6, 2, 7, 3, 8, 4, 9]
 
```
    Type Parameters:
    
    R - the type of elements in resulting stream
    
    Parameters:
    
    mapper - the mapper function used to apply to each element
    
    Returns:
    
    the new stream
  - flatMapToInt
```
@NotNull
public IntStream flatMapToInt(@NotNull
                                       Function<? super T,? extends IntStream> 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.
    This is an intermediate operation.
    
    Parameters:
    
    mapper - the mapper function used to apply to each element
    
    Returns:
    
    the new IntStream
    
    See Also:
    
    flatMap(com.annimon.stream.function.Function)
  - flatMapToLong
```
@NotNull
public LongStream flatMapToLong(@NotNull
                                         Function<? super T,? extends LongStream> 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.
    This is an intermediate operation.
    
    Parameters:
    
    mapper - the mapper function used to apply to each element
    
    Returns:
    
    the new LongStream
    
    See Also:
    
    flatMap(com.annimon.stream.function.Function)
  - flatMapToDouble
```
@NotNull
public DoubleStream flatMapToDouble(@NotNull
                                             Function<? super T,? extends DoubleStream> 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.
    This is an intermediate operation.
    
    Parameters:
    
    mapper - the mapper function used to apply to each element
    
    Returns:
    
    the new DoubleStream
    
    See Also:
    
    flatMap(com.annimon.stream.function.Function)
  - mapMulti
```
@NotNull
public <R> Stream<R> mapMulti(@NotNull
                                       BiConsumer<? super T,? super Consumer<R>> mapper)
```
    Returns a stream consisting of the results of replacing each element of this stream with zero or more elements, that passed to the provided consumer function.
    This is an intermediate operation.
    Example:
```
 stream: [1, 2, 3, 4]
 mapper: (a, consumer) -> {
   consumer.accept(a);
   consumer.accept(-a);
 }
 result: [1, -1, 2, -2, 3, -3, 4, -4]

 stream: [1, 2, 3, 4]
 mapper: (a, consumer) -> {
   if (a % 2 == 0)
     consumer.accept(a * 2);
 }
 result: [4, 8]
 
```
    Type Parameters:
    
    R - the type of elements in resulting stream
    
    Parameters:
    
    mapper - the mapper function used to apply to each element for producing replacing elements
    
    Returns:
    
    the new stream
    
    Since:
    
    1.2.2
    
    See Also:
    
    flatMap(com.annimon.stream.function.Function)
  - mapMultiToInt
```
@NotNull
public IntStream mapMultiToInt(@NotNull
                                        BiConsumer<? super T,? super IntConsumer> mapper)
```
    Returns a stream consisting of the results of replacing each element of this stream with zero or more elements, that passed to the provided consumer function.
    This is an intermediate operation.
    
    Parameters:
    
    mapper - the mapper function used to apply to each element for producing replacing elements
    
    Returns:
    
    the new stream
    
    Since:
    
    1.2.2
    
    See Also:
    
    mapMulti(com.annimon.stream.function.BiConsumer), flatMapToInt(com.annimon.stream.function.Function)
  - mapMultiToLong
```
@NotNull
public LongStream mapMultiToLong(@NotNull
                                          BiConsumer<? super T,? super LongConsumer> mapper)
```
    Returns a stream consisting of the results of replacing each element of this stream with zero or more elements, that passed to the provided consumer function.
    This is an intermediate operation.
    
    Parameters:
    
    mapper - the mapper function used to apply to each element for producing replacing elements
    
    Returns:
    
    the new stream
    
    Since:
    
    1.2.2
    
    See Also:
    
    mapMulti(com.annimon.stream.function.BiConsumer), flatMapToLong(com.annimon.stream.function.Function)
  - mapMultiToDouble
```
@NotNull
public DoubleStream mapMultiToDouble(@NotNull
                                              BiConsumer<? super T,? super DoubleConsumer> mapper)
```
    Returns a stream consisting of the results of replacing each element of this stream with zero or more elements, that passed to the provided consumer function.
    This is an intermediate operation.
    
    Parameters:
    
    mapper - the mapper function used to apply to each element for producing replacing elements
    
    Returns:
    
    the new stream
    
    Since:
    
    1.2.2
    
    See Also:
    
    mapMulti(com.annimon.stream.function.BiConsumer), flatMapToDouble(com.annimon.stream.function.Function)
  - indexed
```
@NotNull
public Stream<IntPair<T>> indexed()
```
    Returns Stream with indexed elements. Indexing starts from 0 with step 1.
    This is an intermediate operation.
    Example:
```
 stream: ["a", "b", "c"]
 result: [(0, "a"), (1, "b"), (2, "c")]
 
```
    Returns:
    
    the new IntPair stream
    
    Since:
    
    1.1.2
  - indexed
```
@NotNull
public Stream<IntPair<T>> indexed(int from,
                                           int step)
```
    Returns Stream with indexed elements.
    This is an intermediate operation.
    Example:
```
 from: 5, step: 10
 stream: ["a", "b", "c"]
 result: [(5, "a"), (15, "b"), (25, "c")]
 
```
    Parameters:
    
    from - the initial value (inclusive)
    
    step - the step
    
    Returns:
    
    the new IntPair stream
    
    Since:
    
    1.1.2
  - distinct
```
@NotNull
public Stream<T> distinct()
```
    Returns Stream with distinct elements (as determined by hashCode and equals methods).
    This is a stateful intermediate operation.
    Example:
```
 stream: [1, 4, 2, 3, 3, 4, 1]
 result: [1, 4, 2, 3]
 
```
    Returns:
    
    the new stream
  - distinctBy
```
@NotNull
public <K> Stream<T> distinctBy(@NotNull
                                         Function<? super T,? extends K> classifier)
```
    Returns Stream with distinct elements (as determined by hashCode and equals methods) according to the given classifier function.
    This is a stateful intermediate operation.
    Example:
```
 classifier: (str) -> str.length()
 stream: ["a", "bc", "d", "ef", "ghij"]
 result: ["a", "bc", "ghij"]
 
```
    Type Parameters:
    
    K - the type of the result of classifier function
    
    Parameters:
    
    classifier - the classifier function
    
    Returns:
    
    the new stream
    
    Since:
    
    1.1.8
  - sorted
```
@NotNull
public Stream<T> sorted()
```
    Returns Stream with sorted elements (as determinated by Comparable interface).
    This is a stateful intermediate operation.
    If the elements of this stream are not Comparable, a java.lang.ClassCastException may be thrown when the terminal operation is executed.
    Example:
```
 stream: [3, 4, 1, 2]
 result: [1, 2, 3, 4]
 
```
    Returns:
    
    the new stream
  - sorted
```
@NotNull
public Stream<T> sorted(@Nullable
                                 java.util.Comparator<? super T> comparator)
```
    Returns Stream with sorted elements (as determinated by provided Comparator).
    This is a stateful intermediate operation.
    Example:
```
 comparator: (a, b) -> -a.compareTo(b)
 stream: [1, 2, 3, 4]
 result: [4, 3, 2, 1]
 
```
    Parameters:
    
    comparator - the Comparator to compare elements
    
    Returns:
    
    the new stream
  - sortBy
```
@NotNull
public <R extends java.lang.Comparable<? super R>> Stream<T> sortBy(@NotNull
                                                                             Function<? super T,? extends R> f)
```
    Returns Stream with sorted elements (as determinated by Comparable interface). Each element transformed by given function f before comparing.
    This is a stateful intermediate operation.
    Example:
```
 f: (a) -> -a
 stream: [1, 2, 3, 4]
 result: [4, 3, 2, 1]
 
```
    Type Parameters:
    
    R - the type of the result of transforming function
    
    Parameters:
    
    f - the transformation function
    
    Returns:
    
    the new stream
  - groupBy
```
@NotNull
public <K> Stream<java.util.Map.Entry<K,java.util.List<T>>> groupBy(@NotNull
                                                                             Function<? super T,? extends K> classifier)
```
    Partitions Stream into Map entries according to the given classifier function.
    This is a stateful intermediate operation.
    Example:
```
 classifier: (str) -> str.length()
 stream: ["a", "bc", "d", "ef", "ghij"]
 result: [{1: ["a", "d"]}, {2: ["bc", "ef"]}, {4: ["ghij"]}]
 
```
    Type Parameters:
    
    K - the type of the keys, which are result of the classifier function
    
    Parameters:
    
    classifier - the classifier function
    
    Returns:
    
    the new stream
  - chunkBy
```
@NotNull
public <K> Stream<java.util.List<T>> chunkBy(@NotNull
                                                      Function<? super T,? extends K> classifier)
```
    Partitions Stream into Lists according to the given classifier function. In contrast to groupBy(Function), this method assumes that the elements of the stream are sorted. Because of this assumption, it does not need to first collect all elements and then partition them. Instead, it can emit a List of elements when it reaches the first element that does not belong to the same chunk as the previous elements.
    This is an intermediate operation.
    Example:
```
 classifier: (a) -> a % 5 == 0
 stream: [1, 2, 5, 6, 7, 9, 10, 12, 14]
 result: [[1, 2], [5], [6, 7, 9], [10], [12, 14]]
 
```
    Type Parameters:
    
    K - the type of the keys, which are the result of the classifier function
    
    Parameters:
    
    classifier - the classifier function
    
    Returns:
    
    the new stream
  - sample
```
@NotNull
public Stream<T> sample(int stepWidth)
```
    Samples the Stream by emitting every n-th element.
    This is an intermediate operation.
    Example:
```
 stepWidth: 3
 stream: [1, 2, 3, 4, 5, 6, 7, 8]
 result: [1, 4, 7]
 
```
    Parameters:
    
    stepWidth - step width
    
    Returns:
    
    the new stream
    
    Throws:
    
    java.lang.IllegalArgumentException - if stepWidth is zero or negative
  - slidingWindow
```
@NotNull
public Stream<java.util.List<T>> slidingWindow(int windowSize)
```
    Partitions Stream into Lists of fixed size by sliding over the elements of the stream. It starts with the first element and in each iteration moves by 1. This method yields the same results as calling slidingWindow(int, int) with a stepWidth of 1.
    This is an intermediate operation.
    Example:
```
 windowSize: 3
 stream: [1, 2, 3, 4, 5]
 result: [[1, 2, 3], [2, 3, 4], [3, 4, 5]]
 
```
    Parameters:
    
    windowSize - number of elements that will be emitted together in a list
    
    Returns:
    
    the new stream
    
    See Also:
    
    slidingWindow(int, int)
  - slidingWindow
```
@NotNull
public Stream<java.util.List<T>> slidingWindow(int windowSize,
                                                        int stepWidth)
```
    Partitions Stream into Lists of fixed size by sliding over the elements of the stream. It starts with the first element and in each iteration moves by the given step width. This method allows, for example, to partition the elements into batches of windowSize elements (by using a step width equal to the specified window size) or to sample every n-th element (by using a window size of 1 and a step width of n).
    This is an intermediate operation.
    Example:
```
 windowSize: 3, stepWidth: 3
 stream: [1, 1, 1, 2, 2, 2, 3, 3, 3]
 result: [[1, 1, 1], [2, 2, 2] [3, 3, 3]]

 windowSize: 2, stepWidth: 3
 stream: [1, 2, 3, 1, 2, 3, 1, 2, 3]
 result: [[1, 2], [1, 2], [1, 2]]

 windowSize: 3, stepWidth: 1
 stream: [1, 2, 3, 4, 5, 6]
 result: [[1, 2, 3], [2, 3, 4], [3, 4, 5], [4, 5, 6]]
 
```
    Parameters:
    
    windowSize - number of elements that will be emitted together in a list
    
    stepWidth - step width
    
    Returns:
    
    the new stream
    
    Throws:
    
    java.lang.IllegalArgumentException - if windowSize is zero or negative
    
    java.lang.IllegalArgumentException - if stepWidth is zero or negative
  - peek
```
@NotNull
public Stream<T> peek(@NotNull
                               Consumer<? super T> action)
```
    Performs provided action on each element.
    This is an intermediate operation.
    
    Parameters:
    
    action - the action to be performed on each element
    
    Returns:
    
    the new stream
  - scan
```
@NotNull
public Stream<T> scan(@NotNull
                               BiFunction<T,T,T> accumulator)
```
    Returns a Stream produced by iterative application of a accumulation function to reduction value and next element of the current stream. Produces a Stream consisting of value1, acc(value1, value2), acc(acc(value1, value2), value3), etc.
    This is an intermediate operation.
    Example:
```
 accumulator: (a, b) -> a + b
 stream: [1, 2, 3, 4, 5]
 result: [1, 3, 6, 10, 15]
 
```
    Parameters:
    
    accumulator - the accumulation function
    
    Returns:
    
    the new stream
    
    Throws:
    
    java.lang.NullPointerException - if accumulator is null
    
    Since:
    
    1.1.6
  - scan
```
@NotNull
public <R> Stream<R> scan(@Nullable
                                   R identity,
                                   @NotNull
                                   BiFunction<? super R,? super T,? extends R> accumulator)
```
    Returns a Stream produced by iterative application of a accumulation function to an initial element identity and next element of the current stream. Produces a Stream consisting of identity, acc(identity, value1), acc(acc(identity, value1), value2), etc.
    This is an intermediate operation.
    Example:
```
 identity: 0
 accumulator: (a, b) -> a + b
 stream: [1, 2, 3, 4, 5]
 result: [0, 1, 3, 6, 10, 15]
 
```
    Type Parameters:
    
    R - the type of the result
    
    Parameters:
    
    identity - the initial value
    
    accumulator - the accumulation function
    
    Returns:
    
    the new stream
    
    Throws:
    
    java.lang.NullPointerException - if accumulator is null
    
    Since:
    
    1.1.6
  - takeWhile
```
@NotNull
public Stream<T> takeWhile(@NotNull
                                    Predicate<? super T> predicate)
```
    Takes elements while the predicate returns true.
    This is an intermediate operation.
    Example:
```
 predicate: (a) -> a < 3
 stream: [1, 2, 3, 4, 1, 2, 3, 4]
 result: [1, 2]
 
```
    Parameters:
    
    predicate - the predicate used to take elements
    
    Returns:
    
    the new stream
  - takeWhileIndexed
```
@NotNull
public Stream<T> takeWhileIndexed(@NotNull
                                           IndexedPredicate<? super T> predicate)
```
    Takes elements while the IndexedPredicate returns true.
    This is an intermediate operation.
    Example:
```
 predicate: (index, value) -> (index + value) < 5
 stream: [1, 2, 3,  4, -5, -6, -7]
 index:  [0, 1, 2,  3,  4,  5,  6]
 sum:    [1, 3, 5,  7, -1, -1, -1]
 result: [1, 2]
 
```
    Parameters:
    
    predicate - the IndexedPredicate used to take elements
    
    Returns:
    
    the new stream
    
    Since:
    
    1.1.6
  - takeWhileIndexed
```
@NotNull
public Stream<T> takeWhileIndexed(int from,
                                           int step,
                                           @NotNull
                                           IndexedPredicate<? super T> predicate)
```
    Takes elements while the IndexedPredicate returns true.
    This is an intermediate operation.
    Example:
```
 from: 2
 step: 2
 predicate: (index, value) -> (index + value) < 8
 stream: [1, 2, 3,  4, -5, -6, -7]
 index:  [2, 4, 6,  8, 10, 12, 14]
 sum:    [3, 6, 9, 12,  5,  6,  7]
 result: [1, 2]
 
```
    Parameters:
    
    from - the initial value of the index (inclusive)
    
    step - the step of the index
    
    predicate - the IndexedPredicate used to take elements
    
    Returns:
    
    the new stream
    
    Since:
    
    1.1.6
  - takeUntil
```
@NotNull
public Stream<T> takeUntil(@NotNull
                                    Predicate<? super T> stopPredicate)
```
    Takes elements while the predicate returns false. Once predicate condition is satisfied by an element, the stream finishes with this element.
    This is an intermediate operation.
    Example:
```
 stopPredicate: (a) -> a > 2
 stream: [1, 2, 3, 4, 1, 2, 3, 4]
 result: [1, 2, 3]
 
```
    Parameters:
    
    stopPredicate - the predicate used to take elements
    
    Returns:
    
    the new stream
    
    Since:
    
    1.1.6
  - takeUntilIndexed
```
@NotNull
public Stream<T> takeUntilIndexed(@NotNull
                                           IndexedPredicate<? super T> stopPredicate)
```
    Takes elements while the IndexedPredicate returns false. Once predicate condition is satisfied by an element, the stream finishes with this element.
    This is an intermediate operation.
    Example:
```
 stopPredicate: (index, value) -> (index + value) > 4
 stream: [1, 2, 3, 4, 0, 1, 2]
 index:  [0, 1, 2, 3, 4, 5, 6]
 sum:    [1, 3, 5, 7, 4, 6, 8]
 result: [1, 2, 3]
 
```
    Parameters:
    
    stopPredicate - the IndexedPredicate used to take elements
    
    Returns:
    
    the new stream
    
    Since:
    
    1.1.6
  - takeUntilIndexed
```
@NotNull
public Stream<T> takeUntilIndexed(int from,
                                           int step,
                                           @NotNull
                                           IndexedPredicate<? super T> stopPredicate)
```
    Takes elements while the IndexedPredicate returns false. Once predicate condition is satisfied by an element, the stream finishes with this element.
    This is an intermediate operation.
    Example:
```
 from: 2
 step: 2
 stopPredicate: (index, value) -> (index + value) > 8
 stream: [1, 2, 3,  4,  0,  1,  2]
 index:  [2, 4, 6,  8, 10, 11, 14]
 sum:    [3, 6, 9, 12, 10, 12, 16]
 result: [1, 2, 3]
 
```
    Parameters:
    
    from - the initial value of the index (inclusive)
    
    step - the step of the index
    
    stopPredicate - the IndexedPredicate used to take elements
    
    Returns:
    
    the new stream
    
    Since:
    
    1.1.6
  - dropWhile
```
@NotNull
public Stream<T> dropWhile(@NotNull
                                    Predicate<? super T> predicate)
```
    Drops elements while the predicate is true, then returns the rest.
    This is an intermediate operation.
    Example:
```
 predicate: (a) -> a < 3
 stream: [1, 2, 3, 4, 1, 2, 3, 4]
 result: [3, 4, 1, 2, 3, 4]
 
```
    Parameters:
    
    predicate - the predicate used to drop elements
    
    Returns:
    
    the new stream
  - dropWhileIndexed
```
@NotNull
public Stream<T> dropWhileIndexed(@NotNull
                                           IndexedPredicate<? super T> predicate)
```
    Drops elements while the IndexedPredicate is true, then returns the rest.
    This is an intermediate operation.
    Example:
```
 predicate: (index, value) -> (index + value) < 5
 stream: [1, 2, 3, 4, 0, 1, 2]
 index:  [0, 1, 2, 3, 4, 5, 6]
 sum:    [1, 3, 5, 7, 4, 6, 8]
 result: [3, 4, 0, 1, 2]
 
```
    Parameters:
    
    predicate - the IndexedPredicate used to drop elements
    
    Returns:
    
    the new stream
    
    Since:
    
    1.1.6
  - dropWhileIndexed
```
@NotNull
public Stream<T> dropWhileIndexed(int from,
                                           int step,
                                           @NotNull
                                           IndexedPredicate<? super T> predicate)
```
    Drops elements while the IndexedPredicate is true, then returns the rest.
    This is an intermediate operation.
    Example:
```
 from: 2
 step: 2
 predicate: (index, value) -> (index + value) < 10
 stream: [1, 2, 3,  4, -5, -6, -7]
 index:  [2, 4, 6,  8, 10, 12, 14]
 sum:    [3, 6, 9, 12,  5,  6,  7]
 result: [4, -5, -6, -7]
 
```
    Parameters:
    
    from - the initial value of the index (inclusive)
    
    step - the step of the index
    
    predicate - the IndexedPredicate used to drop elements
    
    Returns:
    
    the new stream
    
    Since:
    
    1.1.6
  - limit
```
@NotNull
public Stream<T> limit(long maxSize)
```
    Returns Stream with first maxSize elements.
    This is a short-circuiting stateful intermediate operation.
    Example:
```
 maxSize: 3
 stream: [1, 2, 3, 4, 5]
 result: [1, 2, 3]

 maxSize: 10
 stream: [1, 2]
 result: [1, 2]
 
```
    Parameters:
    
    maxSize - the number of elements to limit
    
    Returns:
    
    the new stream
    
    Throws:
    
    java.lang.IllegalArgumentException - if maxSize is negative
  - skip
```
@NotNull
public Stream<T> skip(long n)
```
    Skips first n elements and returns Stream with remaining elements. If stream contains fewer than n elements, then an empty stream will be returned.
    This is a stateful intermediate operation.
    Example:
```
 n: 3
 stream: [1, 2, 3, 4, 5]
 result: [4, 5]

 n: 10
 stream: [1, 2]
 result: []
 
```
    Parameters:
    
    n - the number of elements to skip
    
    Returns:
    
    the new stream
    
    Throws:
    
    java.lang.IllegalArgumentException - if n is negative
  - forEach
```
public void forEach(@NotNull
                    Consumer<? super T> action)
```
    Performs the given action on each element.
    This is a terminal operation.
    
    Parameters:
    
    action - the action to be performed on each element
  - forEachIndexed
```
public void forEachIndexed(@NotNull
                           IndexedConsumer<? super T> action)
```
    Performs the given indexed action on each element.
    This is a terminal operation.
    
    Parameters:
    
    action - the action to be performed on each element
    
    Since:
    
    1.1.6
  - forEachIndexed
```
public void forEachIndexed(int from,
                           int step,
                           @NotNull
                           IndexedConsumer<? super T> action)
```
    Performs the given indexed action on each element.
    This is a terminal operation.
    
    Parameters:
    
    from - the initial value of the index (inclusive)
    
    step - the step of the index
    
    action - the action to be performed on each element
    
    Since:
    
    1.1.6
  - reduce
```
@Nullable
public <R> R reduce(@Nullable
                              R identity,
                              @NotNull
                              BiFunction<? super R,? super T,? extends R> accumulator)
```
    Reduces the elements using provided identity value and the associative accumulation function.
    This is a terminal operation.
    Example:
```
 identity: 0
 accumulator: (a, b) -> a + b
 stream: [1, 2, 3, 4, 5]
 result: 15
 
```
    Type Parameters:
    
    R - the type of the result
    
    Parameters:
    
    identity - the initial value
    
    accumulator - the accumulation function
    
    Returns:
    
    the result of the reduction
  - reduceIndexed
```
@Nullable
public <R> R reduceIndexed(@Nullable
                                     R identity,
                                     @NotNull
                                     IndexedBiFunction<? super R,? super T,? extends R> accumulator)
```
    Reduces the elements using provided identity value and the associative accumulation indexed function.
    This is a terminal operation.
    Example:
```
 identity: 10
 accumulator: (index, a, b) -> index + a + b
 stream: [1, 2, 3, 4, 5]
 index:  [0, 1, 2, 3, 4]
 result: 10 + 1 + 3 + 5 + 7 + 9 = 35
 
```
    Type Parameters:
    
    R - the type of the result
    
    Parameters:
    
    identity - the initial value
    
    accumulator - the accumulation function
    
    Returns:
    
    the result of the reduction
    
    Since:
    
    1.1.6
  - reduceIndexed
```
@Nullable
public <R> R reduceIndexed(int from,
                                     int step,
                                     @Nullable
                                     R identity,
                                     @NotNull
                                     IndexedBiFunction<? super R,? super T,? extends R> accumulator)
```
    Reduces the elements using provided identity value and the associative accumulation indexed function.
    This is a terminal operation.
    Example:
```
 from: 1
 step: 2
 identity: 10
 accumulator: (index, a, b) -> index + a + b
 stream: [1, 2, 3, 4, 5]
 index:  [1, 3, 5, 7, 9]
 result: 10 + 2 + 5 + 8 + 11 + 14 = 50
 
```
    Type Parameters:
    
    R - the type of the result
    
    Parameters:
    
    from - the initial value of the index (inclusive)
    
    step - the step of the index
    
    identity - the initial value
    
    accumulator - the accumulation function
    
    Returns:
    
    the result of the reduction
    
    Since:
    
    1.1.6
  - reduce
```
@NotNull
public Optional<T> reduce(@NotNull
                                   BiFunction<T,T,T> accumulator)
```
    Reduces the elements using provided associative accumulation function.
    This is a terminal operation.
    
    Parameters:
    
    accumulator - the accumulation function
    
    Returns:
    
    the result of the reduction
    
    See Also:
    
    reduce(java.lang.Object, com.annimon.stream.function.BiFunction)
  - toArray
```
@NotNull
public java.lang.Object[] toArray()
```
    Collects elements to an array.
    This is a terminal operation.
    
    Returns:
    
    the result of collect elements
    
    See Also:
    
    toArray(com.annimon.stream.function.IntFunction)
  - toArray
```
@NotNull
public <R> R[] toArray(@NotNull
                                IntFunction<R[]> generator)
```
    Collects elements to an array, the generator constructor of provided.
    This is a terminal operation.
    
    Type Parameters:
    
    R - the type of the result
    
    Parameters:
    
    generator - the array constructor reference that accommodates future array of assigned size
    
    Returns:
    
    the result of collect elements
  - toList
```
@NotNull
public java.util.List<T> toList()
```
    Collects elements to a new List.
    This implementation does not call collect(Collectors.toList()), so it can be faster by reducing method calls.
    This is a terminal operation.
    
    Returns:
    
    a new List
    
    Since:
    
    1.1.5
    
    See Also:
    
    Collectors.toList()
  - collect
```
@Nullable
public <R> R collect(@NotNull
                               Supplier<R> supplier,
                               @NotNull
                               BiConsumer<R,? super T> accumulator)
```
    Collects elements to supplier provided container by applying the given accumulation function.
    This is a terminal operation.
    
    Type Parameters:
    
    R - the type of the result
    
    Parameters:
    
    supplier - the supplier function that provides container
    
    accumulator - the accumulation function
    
    Returns:
    
    the result of collect elements
    
    See Also:
    
    collect(com.annimon.stream.Collector)
  - collect
```
@Nullable
public <R,A> R collect(@NotNull
                                 Collector<? super T,A,R> collector)
```
    Collects elements with collector that encapsulates supplier, accumulator and combiner functions.
    This is a terminal operation.
    
    Type Parameters:
    
    R - the type of result
    
    A - the intermediate used by Collector
    
    Parameters:
    
    collector - the Collector
    
    Returns:
    
    the result of collect elements
    
    See Also:
    
    collect(com.annimon.stream.function.Supplier, com.annimon.stream.function.BiConsumer)
  - min
```
@NotNull
public Optional<T> min(@NotNull
                                java.util.Comparator<? super T> comparator)
```
    Finds the minimum element according to the given comparator.
    This is a terminal operation.
    Example:
```
 comparator: (a, b) -> a.compareTo(b)
 stream: [1, 2, 3, 4, 5]
 result: 1
 
```
    Parameters:
    
    comparator - the Comparator to compare elements
    
    Returns:
    
    the minimum element
  - max
```
@NotNull
public Optional<T> max(@NotNull
                                java.util.Comparator<? super T> comparator)
```
    Finds the maximum element according to the given comparator.
    This is a terminal operation.
    Example:
```
 comparator: (a, b) -> a.compareTo(b)
 stream: [1, 2, 3, 4, 5]
 result: 5
 
```
    Parameters:
    
    comparator - the Comparator to compare elements
    
    Returns:
    
    the maximum element
  - count
```
public long count()
```
    Returns the count of elements in this stream.
    This is a terminal operation.
    
    Returns:
    
    the count of elements
  - anyMatch
```
public boolean anyMatch(@NotNull
                        Predicate<? super T> predicate)
```
    Tests whether any elements match the given predicate.
    This is a short-circuiting terminal operation.
    Example:
```
 predicate: (a) -> a == 5
 stream: [1, 2, 3, 4, 5]
 result: true

 predicate: (a) -> a == 5
 stream: [5, 5, 5]
 result: true
 
```
    Parameters:
    
    predicate - the predicate used to match elements
    
    Returns:
    
    true if any elements match the given predicate, otherwise false
  - allMatch
```
public boolean allMatch(@NotNull
                        Predicate<? super T> predicate)
```
    Tests whether all elements match the given predicate.
    This is a short-circuiting terminal operation.
    Example:
```
 predicate: (a) -> a == 5
 stream: [1, 2, 3, 4, 5]
 result: false

 predicate: (a) -> a == 5
 stream: [5, 5, 5]
 result: true
 
```
    Parameters:
    
    predicate - the predicate used to match elements
    
    Returns:
    
    true if all elements match the given predicate, otherwise false
  - noneMatch
```
public boolean noneMatch(@NotNull
                         Predicate<? super T> predicate)
```
    Tests whether no elements match the given predicate.
    This is a short-circuiting terminal operation.
    Example:
```
 predicate: (a) -> a == 5
 stream: [1, 2, 3, 4, 5]
 result: false

 predicate: (a) -> a == 5
 stream: [1, 2, 3]
 result: true
 
```
    Parameters:
    
    predicate - the predicate used to match elements
    
    Returns:
    
    true if no elements match the given predicate, otherwise false
  - findIndexed
```
@NotNull
public Optional<IntPair<T>> findIndexed(@NotNull
                                                 IndexedPredicate<? super T> predicate)
```
    Finds the first element and its index that matches the given predicate.
    This is a short-circuiting terminal operation.
    Example:
```
 predicate: (index, value) -> index + value == 7
 stream: [1, 2, 3, 4, 5, 2, 0]
 index:  [0, 1, 2, 3, 4, 5, 6]
 result: Optional.of(IntPair(3, 4))
 
```
    Parameters:
    
    predicate - the predicate to find value
    
    Returns:
    
    an Optional with IntPair or Optional.empty() if stream is empty or no value was found.
    
    Since:
    
    1.1.8
  - findIndexed
```
@NotNull
public Optional<IntPair<T>> findIndexed(int from,
                                                 int step,
                                                 @NotNull
                                                 IndexedPredicate<? super T> predicate)
```
    Finds the first element and its index that matches the given predicate.
    This is a short-circuiting terminal operation.
    Example:
```
 from: 0
 step: 10
 predicate: (index, value) -> index + value == 42
 stream: [1, 11, 22, 12, 40]
 index:  [0, 10, 20, 30, 40]
 result: Optional.of(IntPair(20, 22))
 
```
    Parameters:
    
    from - the initial value of the index (inclusive)
    
    step - the step of the index
    
    predicate - the predicate to find value
    
    Returns:
    
    an Optional with IntPair or Optional.empty() if stream is empty or no value was found.
    
    Since:
    
    1.1.8
  - findFirst
```
@NotNull
public Optional<T> findFirst()
```
    Returns the first element wrapped by Optional class. If stream is empty, returns Optional.empty().
    This is a short-circuiting terminal operation.
    
    Returns:
    
    an Optional with the first element or Optional.empty() if stream is empty
  - findFirstOrElse
```
@Nullable
public T findFirstOrElse(@Nullable
                                   T other)
```
    Returns the first element if stream is not empty, otherwise returns other.
    This is a short-circuiting terminal operation.
    
    Parameters:
    
    other - the value to be returned if stream is empty
    
    Returns:
    
    first element or other if stream is empty
    
    Since:
    
    1.2.2
  - findLast
```
@NotNull
public Optional<T> findLast()
```
    Returns the last element wrapped by Optional class. If stream is empty, returns Optional.empty().
    This is a short-circuiting terminal operation.
    
    Returns:
    
    an Optional with the last element or Optional.empty() if the stream is empty
    
    Since:
    
    1.1.8
  - single
```
@Nullable
public T single()
```
    Returns the single element of stream. If stream is empty, throws NoSuchElementException. If stream contains more than one element, throws IllegalStateException.
    This is a short-circuiting terminal operation.
    Example:
```
 stream: []
 result: NoSuchElementException

 stream: [1]
 result: 1

 stream: [1, 2, 3]
 result: IllegalStateException
 
```
    Returns:
    
    single element of stream
    
    Throws:
    
    java.util.NoSuchElementException - if stream is empty
    
    java.lang.IllegalStateException - if stream contains more than one element
    
    Since:
    
    1.1.2
  - findSingle
```
@NotNull
public Optional<T> findSingle()
```
    Returns the single element wrapped by Optional class. If stream is empty, returns Optional.empty(). If stream contains more than one element, throws IllegalStateException.
    This is a short-circuiting terminal operation.
    Example:
```
 stream: []
 result: Optional.empty()

 stream: [1]
 result: Optional.of(1)

 stream: [1, 2, 3]
 result: IllegalStateException
 
```
    Returns:
    
    an Optional with single element or Optional.empty() if stream is empty
    
    Throws:
    
    java.lang.IllegalStateException - if stream contains more than one element
    
    Since:
    
    1.1.2
  - onClose
```
@NotNull
public Stream<T> onClose(@NotNull
                                  java.lang.Runnable closeHandler)
```
    Adds close handler to the current stream.
    This is an intermediate operation.
    
    Parameters:
    
    closeHandler - an action to execute when the stream is closed
    
    Returns:
    
    the new stream with the close handler
    
    Since:
    
    1.1.8
  - close
```
public void close()
```
    Causes close handler to be invoked if it exists. Since most of the stream providers are lists or arrays, it is not necessary to close the stream.
    
    Specified by:
    
    close in interface java.io.Closeable
    
    Specified by:
    
    close in interface java.lang.AutoCloseable
    
    Since:
    
    1.1.8

Class Stream<T>

Method Summary

Methods inherited from class java.lang.Object

Method Detail

empty

of

of

of

of

ofNullable

ofNullable

ofNullable

ofNullable

ofNullable

range

range

rangeClosed

rangeClosed

generate

iterate

iterate

concat

concat

concat

concat

zip

zip

merge

merge

iterator

custom

prepend

append

filter

filterIndexed

filterIndexed

filterNot

select

withoutNulls

nullsOnly

equalsOnly

map

mapIndexed

mapIndexed

mapToInt

mapToLong

mapToDouble

flatMap

flatMapToInt

flatMapToLong

flatMapToDouble

mapMulti

mapMultiToInt

mapMultiToLong

mapMultiToDouble

indexed

indexed

distinct

distinctBy

sorted

sorted

sortBy

groupBy

chunkBy

sample

slidingWindow

slidingWindow

peek

scan

scan

takeWhile

takeWhileIndexed

takeWhileIndexed

takeUntil

takeUntilIndexed

takeUntilIndexed

dropWhile

dropWhileIndexed

dropWhileIndexed

limit