Stream (Lightweight-Stream-API 1.1.0 API)

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

Type Parameters:

T - the type of the stream elements
```
public class Stream<T>
extends Object
```
A sequence of elements supporting aggregate operations.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods Deprecated 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.
`<K> Stream<List<T>>`	`chunkBy(Function<? super T,? extends K> classifier)` Partitions `Stream` into `List`s according to the given classifier function.
`<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(Stream<? extends T> stream1, Stream<? extends T> stream2)` Concatenates two streams.
`long`	`count()` Counts the number 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 determinated by `equals` method).
`Stream<T>`	`dropWhile(Predicate<? super T> predicate)` Drops elements while the predicate is true and returns the rest.
`static <T> Stream<T>`	`empty()` Returns an empty stream.
`Stream<T>`	`filter(Predicate<? super T> predicate)` Returns `Stream` with elements that satisfy the given predicate.
`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.
`<R> Stream<R>`	`flatMap(Function<? super T,? extends Stream<? extends R>> mapper)` Generates `Stream` by concatenating elements that obtained by applying the given function.
`void`	`forEach(Consumer<? super T> action)` Performs the given action to each element.
`static <T> Stream<T>`	`generate(Supplier<T> supplier)` Creates a `Stream` by elements that generated by `Supplier`.
`Iterator<? extends T>`	`getIterator()` Returns internal stream iterator.
`<K> Stream<Map.Entry<K,List<T>>>`	`groupBy(Function<? super T,? extends K> classifier)` Partitions `Stream` into `Map` entries according to the given classifier function.
`static <T> Stream<T>`	`iterate(T seed, UnaryOperator<T> op)` Creates a `Stream` by applying `UnaryOperator` operation to an initial element `seed`.
`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.
`Optional<T>`	`max(Comparator<? super T> comparator)` Finds the maximum element according to the given comparator.
`Optional<T>`	`min(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.
`static <T> Stream<T>`	`of(Iterable<? extends T> iterable)` Creates a `Stream` from any class that implements `Iterable` interface.
`static <T> Stream<T>`	`of(Iterator<? extends T> iterator)` Creates a `Stream` from any class that implements `Iterator` interface.
`static <T> Stream<T>`	`of(List<? extends T> list)` Creates a `Stream` from `List`.
`static <K,V> Stream<Map.Entry<K,V>>`	`of(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 Stream<Integer>`	`ofRange(int from, int to)` Deprecated. As of release 1.0.7, replaced by `range(int, int)`
`static Stream<Long>`	`ofRange(long from, long to)` Deprecated. As of release 1.0.7, replaced by `range(long, long)`
`static Stream<Integer>`	`ofRangeClosed(int from, int to)` Deprecated. As of release 1.0.7, replaced by `rangeClosed(int, int)`
`static Stream<Long>`	`ofRangeClosed(long from, long to)` Deprecated. As of release 1.0.7, replaced by `rangeClosed(long, long)`
`Stream<T>`	`peek(Consumer<? super T> action)` Perform provided action to each elements.
`static Stream<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<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<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<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.
`Stream<T>`	`sample(int stepWidth)` Samples the `Stream` by emitting every n-th element.
`<TT> Stream<TT>`	`select(Class<TT> clazz)` Returns a stream consisting of the elements of this stream which are instances of given class.
`Stream<T>`	`skip(long n)` Skips first `n` elements and returns `Stream` with remaining elements.
`Stream<List<T>>`	`slidingWindow(int windowSize)` Partitions `Stream` into `List`s of fixed size by sliding over the elements of the stream.
`Stream<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 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(Comparator<? super T> comparator)` Returns `Stream` with sorted elements (as determinated by provided `Comparator`).
`Stream<T>`	`takeWhile(Predicate<? super T> predicate)` Takes elements while the predicate is true.
`Object[]`	`toArray()` Collects elements to an array.
`<R> R[]`	`toArray(IntFunction<R[]> generator)` Collects elements to an array, the `generator` constructor of provided.
`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
```
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
```
public static <K,V> Stream<Map.Entry<K,V>> of(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
  - of
```
public static <T> Stream<T> of(List<? extends T> list)
```
    Creates a Stream from List.
    
    Type Parameters:
    
    T - the type of the stream elements
    
    Parameters:
    
    list - the list with elements to be passed to stream
    
    Returns:
    
    the new stream
  - of
```
public static <T> Stream<T> of(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
  - of
```
public static <T> Stream<T> of(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
  - of
```
public static <T> Stream<T> of(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
  - range
```
public static Stream<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
  - ofRange
```
@Deprecated
public static Stream<Integer> ofRange(int from,
                                                   int to)
```
    Deprecated. As of release 1.0.7, replaced by range(int, int)
    
    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
  - range
```
public static Stream<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
  - ofRange
```
@Deprecated
public static Stream<Long> ofRange(long from,
                                                long to)
```
    Deprecated. As of release 1.0.7, replaced by range(long, long)
    
    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
```
public static Stream<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
  - ofRangeClosed
```
@Deprecated
public static Stream<Integer> ofRangeClosed(int from,
                                                         int to)
```
    Deprecated. As of release 1.0.7, replaced by rangeClosed(int, int)
    
    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
  - rangeClosed
```
public static Stream<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
  - ofRangeClosed
```
@Deprecated
public static Stream<Long> ofRangeClosed(long from,
                                                      long to)
```
    Deprecated. As of release 1.0.7, replaced by rangeClosed(long, long)
    
    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
```
public static <T> Stream<T> generate(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
  - iterate
```
public static <T> Stream<T> iterate(T seed,
                                    UnaryOperator<T> op)
```
    Creates a Stream by applying UnaryOperator operation to an initial element seed.
    
    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
  - concat
```
public static <T> Stream<T> concat(Stream<? extends T> stream1,
                                   Stream<? extends T> stream2)
```
    Concatenates two streams.
    
    Type Parameters:
    
    T - The type of stream elements
    
    Parameters:
    
    stream1 - the first stream
    
    stream2 - the second stream
    
    Returns:
    
    the new concatenated stream
  - zip
```
public 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.
    
    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
  - getIterator
```
public Iterator<? extends T> getIterator()
```
    Returns internal stream iterator.
    
    Returns:
    
    internal stream iterator
  - custom
```
public <R> R custom(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 static class Reverse<T> implements Function<Stream<T>, Stream<T>> {
         @Override
         public Stream<T> apply(Stream<T> stream) {
             final Iterator<? extends T> iterator = stream.getIterator();
             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 static 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 static 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 result
    
    Parameters:
    
    function - a transforming function
    
    Returns:
    
    a result of the transforming function
  - filter
```
public Stream<T> filter(Predicate<? super T> predicate)
```
    Returns Stream with elements that satisfy the given predicate.
    This is an intermediate operation.
    
    Parameters:
    
    predicate - the predicate used to filter elements
    
    Returns:
    
    the new stream
  - filterNot
```
public Stream<T> filterNot(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
```
public <TT> Stream<TT> select(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 param
  - map
```
public <R> Stream<R> map(Function<? super T,? extends R> mapper)
```
    Returns Stream with elements that obtained by applying the given function.
    This is an intermediate operation.
    
    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
  - flatMap
```
public <R> Stream<R> flatMap(Function<? super T,? extends Stream<? extends R>> mapper)
```
    Generates Stream by concatenating elements that obtained by applying the given function.
    This is an intermediate operation.
    
    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
  - distinct
```
public Stream<T> distinct()
```
    Returns Stream with distinct elements (as determinated by equals method).
    This is a stateful intermediate operation.
    
    Returns:
    
    the new stream
  - sorted
```
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.
    
    Returns:
    
    the new stream
  - sorted
```
public Stream<T> sorted(Comparator<? super T> comparator)
```
    Returns Stream with sorted elements (as determinated by provided Comparator).
    This is a stateful intermediate operation.
    
    Parameters:
    
    comparator - the Comparator to compare elements
    
    Returns:
    
    the new stream
  - sortBy
```
public <R extends Comparable<? super R>> Stream<T> sortBy(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.
    
    Type Parameters:
    
    R - the type of the result of transforming function
    
    Parameters:
    
    f - the transformation function
    
    Returns:
    
    the new stream
  - groupBy
```
public <K> Stream<Map.Entry<K,List<T>>> groupBy(Function<? super T,? extends K> classifier)
```
    Partitions Stream into Map entries according to the given classifier function.
    This is a stateful intermediate operation.
    
    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
```
public <K> Stream<List<T>> chunkBy(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.
    
    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
```
public Stream<T> sample(int stepWidth)
```
    Samples the Stream by emitting every n-th element.
    This is an intermediate operation.
    
    Parameters:
    
    stepWidth - step width
    
    Returns:
    
    the new stream
  - slidingWindow
```
public Stream<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.
    
    Parameters:
    
    windowSize - number of elements that will be emitted together in a list
    
    Returns:
    
    the new stream
    
    See Also:
    
    slidingWindow(int, int)
  - slidingWindow
```
public Stream<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.
    Examples:
```
 elements: [1, 1, 1, 2, 2, 2, 3, 3, 3]    windowSize: 3   stepWidth: 3

 => [1, 1, 1], [2, 2, 2] [3, 3, 3]


 elements: [1, 2, 3, 1, 2, 3, 1, 2, 3]    windowSize: 2   stepWidth: 3

 => [1, 2], [1, 2], [1, 2]


 elements: [1, 2, 3, 4, 5, 6]             windowSize: 3   stepWidth: 1

 => [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
  - peek
```
public Stream<T> peek(Consumer<? super T> action)
```
    Perform provided action to each elements.
    This is an intermediate operation.
    
    Parameters:
    
    action - the action to be performed on each element
    
    Returns:
    
    the new stream
  - takeWhile
```
public Stream<T> takeWhile(Predicate<? super T> predicate)
```
    Takes elements while the predicate is true.
    This is an intermediate operation.
    
    Parameters:
    
    predicate - the predicate used to take elements
    
    Returns:
    
    the new stream
  - dropWhile
```
public Stream<T> dropWhile(Predicate<? super T> predicate)
```
    Drops elements while the predicate is true and returns the rest.
    This is an intermediate operation.
    
    Parameters:
    
    predicate - the predicate used to drop elements
    
    Returns:
    
    the new stream
  - limit
```
public Stream<T> limit(long maxSize)
```
    Returns Stream with first maxSize elements.
    This is a short-circuiting stateful intermediate operation.
    
    Parameters:
    
    maxSize - the number of elements to limit
    
    Returns:
    
    the new stream
  - skip
```
public Stream<T> skip(long n)
```
    Skips first n elements and returns Stream with remaining elements.
    This is a stateful intermediate operation.
    
    Parameters:
    
    n - the number of elements to skip
    
    Returns:
    
    the new stream
  - forEach
```
public void forEach(Consumer<? super T> action)
```
    Performs the given action to each element.
    This is a terminal operation.
    
    Parameters:
    
    action - the action to be performed on each element
  - reduce
```
public <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.
    This is a terminal operation.
    
    Type Parameters:
    
    R - the type of the result
    
    Parameters:
    
    identity - the initial value
    
    accumulator - the accumulation function
    
    Returns:
    
    the result of the reduction
  - reduce
```
public Optional<T> reduce(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
  - toArray
```
public 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
```
public <R> R[] toArray(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
  - collect
```
public <R> R collect(Supplier<R> supplier,
                     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
```
public <R,A> R collect(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
```
public Optional<T> min(Comparator<? super T> comparator)
```
    Finds the minimum element according to the given comparator.
    This is a terminal operation.
    
    Parameters:
    
    comparator - the Comparator to compare elements
    
    Returns:
    
    the minimum element
  - max
```
public Optional<T> max(Comparator<? super T> comparator)
```
    Finds the maximum element according to the given comparator.
    This is a terminal operation.
    
    Parameters:
    
    comparator - the Comparator to compare elements
    
    Returns:
    
    the maximum element
  - count
```
public long count()
```
    Counts the number of elements in this stream.
    This is a terminal operation.
    
    Returns:
    
    the count of elements
  - anyMatch
```
public boolean anyMatch(Predicate<? super T> predicate)
```
    Tests whether any elements match the given predicate.
    This is a short-circuiting terminal operation.
    
    Parameters:
    
    predicate - the predicate used to match elements
    
    Returns:
    
    true if any elements match the given predicate, otherwise false
  - allMatch
```
public boolean allMatch(Predicate<? super T> predicate)
```
    Tests whether all elements match the given predicate.
    This is a short-circuiting terminal operation.
    
    Parameters:
    
    predicate - the predicate used to match elements
    
    Returns:
    
    true if all elements match the given predicate, otherwise false
  - noneMatch
```
public boolean noneMatch(Predicate<? super T> predicate)
```
    Tests whether no elements match the given predicate.
    This is a short-circuiting terminal operation.
    
    Parameters:
    
    predicate - the predicate used to match elements
    
    Returns:
    
    true if no elements match the given predicate, otherwise false
  - findFirst
```
public Optional<T> findFirst()
```
    Returns the first element wrapped by Optional class. If stream is empty, returns .
    This is a short-circuiting terminal operation.
    
    Returns:
    
    an Optional with first element or Optional.empty() if stream is empty

Class Stream<T>

Method Summary

Methods inherited from class java.lang.Object

Method Detail

empty

of

of

of

of

of

range

ofRange

range

ofRange

rangeClosed

ofRangeClosed

rangeClosed

ofRangeClosed

generate

iterate

concat

zip

getIterator

custom

filter

filterNot

select

map

flatMap

distinct

sorted

sorted

sortBy

groupBy

chunkBy

sample

slidingWindow

slidingWindow

peek

takeWhile

dropWhile

limit

skip

forEach

reduce

reduce

toArray

toArray

collect

collect

min

max

count

anyMatch

allMatch

noneMatch

findFirst