IntStream (Lightweight-Stream-API 1.1.9 API)

java.lang.Object
- com.annimon.stream.IntStream

All Implemented Interfaces:

Closeable, AutoCloseable
```
public final class IntStream
extends Object
implements Closeable
```
A sequence of primitive int-valued elements supporting sequential operations. This is the int primitive specialization of Stream.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`boolean`	`allMatch(IntPredicate predicate)` Returns whether all elements of this stream match the provided predicate.
`boolean`	`anyMatch(IntPredicate predicate)` Returns whether any elements of this stream match the provided predicate.
`Stream<Integer>`	`boxed()` Returns a `Stream` consisting of the elements of this stream, each boxed to an `Integer`.
`void`	`close()` Causes close handler to be invoked if it exists.
`<R> R`	`collect(Supplier<R> supplier, ObjIntConsumer<R> accumulator)` Collects elements to `supplier` provided container by applying the given accumulation function.
`static IntStream`	`concat(IntStream a, IntStream b)` Creates a lazily concatenated stream whose elements are all the elements of the first stream followed by all the elements of the second stream.
`long`	`count()` Returns the count of elements in this stream.
`<R> R`	`custom(Function<IntStream,R> function)` Applies custom operator on stream.
`IntStream`	`distinct()` Returns a stream consisting of the distinct elements of this stream.
`IntStream`	`dropWhile(IntPredicate predicate)` Drops elements while the predicate is true and returns the rest.
`static IntStream`	`empty()` Returns an empty stream.
`IntStream`	`filter(IntPredicate predicate)` Returns a stream consisting of the elements of this stream that match the given predicate.
`IntStream`	`filterNot(IntPredicate predicate)` Returns a stream consisting of the elements of this stream that don't match the given predicate.
`OptionalInt`	`findFirst()` Returns an `OptionalInt` describing the first element of this stream, or an empty `OptionalInt` if the stream is empty.
`OptionalInt`	`findLast()` Returns the last element wrapped by `OptionalInt` class.
`OptionalInt`	`findSingle()` Returns the single element wrapped by `OptionalInt` class.
`IntStream`	`flatMap(IntFunction<? 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.
`void`	`forEach(IntConsumer action)` Performs an action for each element of this stream.
`static IntStream`	`generate(IntSupplier s)` Returns an infinite sequential unordered stream where each element is generated by the provided `IntSupplier`.
`static IntStream`	`iterate(int seed, IntPredicate predicate, IntUnaryOperator op)` Creates an `IntStream` by iterative application `IntUnaryOperator` function to an initial element `seed`, conditioned on satisfying the supplied predicate.
`static IntStream`	`iterate(int seed, IntUnaryOperator f)` Returns an infinite sequential ordered `IntStream` produced by iterative application of a function `f` to an initial element `seed`, producing a `Stream` consisting of `seed`, `f(seed)`, `f(f(seed))`, etc.
`PrimitiveIterator.OfInt`	`iterator()` Returns internal `IntStream` iterator.
`IntStream`	`limit(long maxSize)` Returns a stream consisting of the elements of this stream, truncated to be no longer than `maxSize` in length.
`IntStream`	`map(IntUnaryOperator mapper)` Returns an `IntStream` consisting of the results of applying the given function to the elements of this stream.
`DoubleStream`	`mapToDouble(IntToDoubleFunction mapper)` Returns a `DoubleStream` consisting of the results of applying the given function to the elements of this stream.
`LongStream`	`mapToLong(IntToLongFunction mapper)` Returns a `LongStream` consisting of the results of applying the given function to the elements of this stream.
`<R> Stream<R>`	`mapToObj(IntFunction<? extends R> mapper)` Returns a `Stream` consisting of the results of applying the given function to the elements of this stream.
`OptionalInt`	`max()` Returns an `OptionalInt` describing the maximum element of this stream, or an empty optional if this stream is empty.
`OptionalInt`	`min()` Returns an `OptionalInt` describing the minimum element of this stream, or an empty optional if this stream is empty.
`boolean`	`noneMatch(IntPredicate predicate)` Returns whether no elements of this stream match the provided predicate.
`static IntStream`	`of(int... values)` Returns stream whose elements are the specified values.
`static IntStream`	`of(int t)` Returns stream which contains single element passed as parameter.
`static IntStream`	`of(PrimitiveIterator.OfInt iterator)` Creates a `IntStream` from `PrimitiveIterator.OfInt`.
`static IntStream`	`ofCodePoints(CharSequence charSequence)` Creates an `IntStream` of code point values from the given sequence.
`IntStream`	`onClose(Runnable closeHandler)` Adds close handler to the current stream.
`IntStream`	`peek(IntConsumer action)` Returns a stream consisting of the elements of this stream, additionally performing the provided action on each element as elements are consumed from the resulting stream.
`static IntStream`	`range(int startInclusive, int endExclusive)` Returns a sequential ordered `IntStream` from `startInclusive` (inclusive) to `endExclusive` (exclusive) by an incremental step of `1`.
`static IntStream`	`rangeClosed(int startInclusive, int endInclusive)` Returns a sequential ordered `IntStream` from `startInclusive` (inclusive) to `endInclusive` (inclusive) by an incremental step of `1`.
`OptionalInt`	`reduce(IntBinaryOperator op)` Performs a reduction on the elements of this stream, using an associative accumulation function, and returns an `OptionalInt` describing the reduced value, if any.
`int`	`reduce(int identity, IntBinaryOperator op)` Performs a reduction on the elements of this stream, using the provided identity value and an associative accumulation function, and returns the reduced value.
`IntStream`	`sample(int stepWidth)` Samples the `IntStream` by emitting every n-th element.
`IntStream`	`scan(IntBinaryOperator accumulator)` Returns a `IntStream` produced by iterative application of a accumulation function to reduction value and next element of the current stream.
`IntStream`	`scan(int identity, IntBinaryOperator accumulator)` Returns a `IntStream` produced by iterative application of a accumulation function to an initial element `identity` and next element of the current stream.
`int`	`single()` Returns the single element of stream.
`IntStream`	`skip(long n)` Returns a stream consisting of the remaining elements of this stream after discarding the first `n` elements of the stream.
`IntStream`	`sorted()` Returns a stream consisting of the elements of this stream in sorted order.
`IntStream`	`sorted(Comparator<Integer> comparator)` Returns `IntStream` with sorted elements (as determinated by provided `Comparator`).
`int`	`sum()` Returns the sum of elements in this stream.
`IntStream`	`takeUntil(IntPredicate stopPredicate)` Takes elements while the predicate returns `false`.
`IntStream`	`takeWhile(IntPredicate predicate)` Takes elements while the predicate returns `true`.
`int[]`	`toArray()` Returns an array containing the elements of this stream.

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

- Method Detail
  - empty
```
public static IntStream empty()
```
    Returns an empty stream.
    
    Returns:
    
    the empty stream
  - of
```
public static IntStream of(PrimitiveIterator.OfInt iterator)
```
    Creates a IntStream from PrimitiveIterator.OfInt.
    
    Parameters:
    
    iterator - the iterator with elements to be passed to stream
    
    Returns:
    
    the new IntStream
    
    Throws:
    
    NullPointerException - if iterator is null
  - of
```
public static IntStream of(int... values)
```
    Returns stream whose elements are the specified values.
    
    Parameters:
    
    values - the elements of the new stream
    
    Returns:
    
    the new stream
    
    Throws:
    
    NullPointerException - if values is null
  - of
```
public static IntStream of(int t)
```
    Returns stream which contains single element passed as parameter.
    
    Parameters:
    
    t - element of the stream
    
    Returns:
    
    the new stream
  - ofCodePoints
```
public static IntStream ofCodePoints(CharSequence charSequence)
```
    Creates an IntStream of code point values from the given sequence. Any surrogate pairs encountered in the sequence are combined as if by Character.toCodePoint and the result is passed to the stream. Any other code units, including ordinary BMP characters, unpaired surrogates, and undefined code units, are zero-extended to int values which are then passed to the stream.
    
    Parameters:
    
    charSequence - the sequence where to get all code points values.
    
    Returns:
    
    the new stream
    
    Since:
    
    1.1.8
  - range
```
public static IntStream range(int startInclusive,
                              int endExclusive)
```
    Returns a sequential ordered IntStream from startInclusive (inclusive) to endExclusive (exclusive) by an incremental step of 1.
    
    Parameters:
    
    startInclusive - the (inclusive) initial value
    
    endExclusive - the exclusive upper bound
    
    Returns:
    
    a sequential IntStream for the range of int elements
  - rangeClosed
```
public static IntStream rangeClosed(int startInclusive,
                                    int endInclusive)
```
    Returns a sequential ordered IntStream from startInclusive (inclusive) to endInclusive (inclusive) by an incremental step of 1.
    
    Parameters:
    
    startInclusive - the (inclusive) initial value
    
    endInclusive - the inclusive upper bound
    
    Returns:
    
    a sequential IntStream for the range of int elements
  - generate
```
public static IntStream generate(IntSupplier s)
```
    Returns an infinite sequential unordered stream where each element is generated by the provided IntSupplier. This is suitable for generating constant streams, streams of random elements, etc.
    
    Parameters:
    
    s - the IntSupplier for generated elements
    
    Returns:
    
    a new infinite sequential IntStream
    
    Throws:
    
    NullPointerException - if s is null
  - iterate
```
public static IntStream iterate(int seed,
                                IntUnaryOperator f)
```
    Returns an infinite sequential ordered IntStream produced by iterative application of a function f to an initial element seed, producing a Stream consisting of seed, f(seed), f(f(seed)), etc.
    The first element (position 0) in the IntStream will be the provided seed. For n > 0, the element at position n, will be the result of applying the function f to the element at position n - 1.
    Example:
```
 seed: 1
 f: (a) -> a + 5
 result: [1, 6, 11, 16, ...]
 
```
    Parameters:
    
    seed - the initial element
    
    f - a function to be applied to the previous element to produce a new element
    
    Returns:
    
    a new sequential IntStream
    
    Throws:
    
    NullPointerException - if f is null
  - iterate
```
public static IntStream iterate(int seed,
                                IntPredicate predicate,
                                IntUnaryOperator op)
```
    Creates an IntStream by iterative application IntUnaryOperator function to an initial element seed, conditioned on satisfying the supplied predicate.
    Example:
```
 seed: 0
 predicate: (a) -> a < 20
 f: (a) -> a + 5
 result: [0, 5, 10, 15]
 
```
    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:
    
    NullPointerException - if op is null
    
    Since:
    
    1.1.5
  - concat
```
public static IntStream concat(IntStream a,
                               IntStream b)
```
    Creates a lazily concatenated stream whose elements are all the elements of the first stream followed by all the elements of the second stream.
    Example:
```
 stream a: [1, 2, 3, 4]
 stream b: [5, 6]
 result:   [1, 2, 3, 4, 5, 6]
 
```
    Parameters:
    
    a - the first stream
    
    b - the second stream
    
    Returns:
    
    the concatenation of the two input streams
    
    Throws:
    
    NullPointerException - if a or b is null
  - iterator
```
public PrimitiveIterator.OfInt iterator()
```
    Returns internal IntStream iterator.
    
    Returns:
    
    internal IntStream iterator.
  - custom
```
public <R> R custom(Function<IntStream,R> function)
```
    Applies custom operator on stream. Transforming function can return IntStream for intermediate operations, or any value for terminal operation.
    Operator examples:
```
     // Intermediate operator
     public class Zip<T> implements Function<IntStream, IntStream> {
         @Override
         public IntStream apply(IntStream firstStream) {
             final PrimitiveIterator.OfInt it1 = firstStream.iterator();
             final PrimitiveIterator.OfInt it2 = secondStream.iterator();
             return IntStream.of(new PrimitiveIterator.OfInt() {
                 @Override
                 public boolean hasNext() {
                     return it1.hasNext() && it2.hasNext();
                 }

                 @Override
                 public int nextInt() {
                     return combiner.applyAsInt(it1.nextInt(), it2.nextInt());
                 }
             });
         }
     }

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

         private final int skip, limit;

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

         @Override
         public IntStream apply(IntStream stream) {
             return stream.skip(skip).limit(limit);
         }
     }

     // Terminal operator
     public class Average implements Function<IntStream, Double> {
         long count = 0, sum = 0;

         @Override
         public Double apply(IntStream stream) {
             final PrimitiveIterator.OfInt it = stream.iterator();
             while (it.hasNext()) {
                 count++;
                 sum += it.nextInt();
             }
             return (count == 0) ? 0 : sum / (double) count;
         }
     }
 
```
    Type Parameters:
    
    R - the type of the result
    
    Parameters:
    
    function - a transforming function
    
    Returns:
    
    a result of the transforming function
    
    Throws:
    
    NullPointerException - if function is null
    
    See Also:
    
    Stream.custom(com.annimon.stream.function.Function)
  - boxed
```
public Stream<Integer> boxed()
```
    Returns a Stream consisting of the elements of this stream, each boxed to an Integer.
    This is an lazy intermediate operation.
    
    Returns:
    
    a Stream consistent of the elements of this stream, each boxed to an Integer
  - filter
```
public IntStream filter(IntPredicate predicate)
```
    Returns a stream consisting of the elements of this stream that match 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 - non-interfering, stateless predicate to apply to each element to determine if it should be included
    
    Returns:
    
    the new stream
  - filterNot
```
public IntStream filterNot(IntPredicate predicate)
```
    Returns a stream consisting of the elements of this stream that don't match the given predicate.
    This is an intermediate operation.
    
    Parameters:
    
    predicate - non-interfering, stateless predicate to apply to each element to determine if it should not be included
    
    Returns:
    
    the new stream
  - map
```
public IntStream map(IntUnaryOperator mapper)
```
    Returns an IntStream consisting of the results of applying the given function to the elements of this stream.
    This is an intermediate operation.
    Example:
```
 mapper: (a) -> a + 5
 stream: [1, 2, 3, 4]
 result: [6, 7, 8, 9]
 
```
    Parameters:
    
    mapper - a non-interfering stateless function to apply to each element
    
    Returns:
    
    the new IntStream
  - mapToObj
```
public <R> Stream<R> mapToObj(IntFunction<? extends R> mapper)
```
    Returns a Stream consisting of the results of applying the given function to the elements of this stream.
    This is an intermediate operation.
    
    Type Parameters:
    
    R - the type result
    
    Parameters:
    
    mapper - the mapper function used to apply to each element
    
    Returns:
    
    the new Stream
  - mapToLong
```
public LongStream mapToLong(IntToLongFunction mapper)
```
    Returns a LongStream consisting of the results of applying the given function to the elements of this stream.
    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:
    
    flatMap(com.annimon.stream.function.IntFunction)
  - mapToDouble
```
public DoubleStream mapToDouble(IntToDoubleFunction mapper)
```
    Returns a DoubleStream consisting of the results of applying the given function to the elements of this stream.
    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:
    
    flatMap(com.annimon.stream.function.IntFunction)
  - flatMap
```
public IntStream flatMap(IntFunction<? 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.
    Example:
```
 mapper: (a) -> [a, a + 5]
 stream: [1, 2, 3, 4]
 result: [1, 6, 2, 7, 3, 8, 4, 9]
 
```
    Parameters:
    
    mapper - a non-interfering stateless function to apply to each element which produces an IntStream of new values
    
    Returns:
    
    the new stream
    
    See Also:
    
    Stream.flatMap(Function)
  - distinct
```
public IntStream distinct()
```
    Returns a stream consisting of the distinct elements of this stream.
    This is a stateful intermediate operation.
    Example:
```
 stream: [1, 4, 2, 3, 3, 4, 1]
 result: [1, 4, 2, 3]
 
```
    Returns:
    
    the new stream
  - sorted
```
public IntStream sorted()
```
    Returns a stream consisting of the elements of this stream in sorted order.
    This is a stateful intermediate operation.
    Example:
```
 stream: [3, 4, 1, 2]
 result: [1, 2, 3, 4]
 
```
    Returns:
    
    the new stream
  - sorted
```
public IntStream sorted(Comparator<Integer> comparator)
```
    Returns IntStream 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 IntStream
  - sample
```
public IntStream sample(int stepWidth)
```
    Samples the IntStream 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 IntStream
    
    Throws:
    
    IllegalArgumentException - if stepWidth is zero or negative
    
    See Also:
    
    Stream.sample(int)
  - peek
```
public IntStream peek(IntConsumer action)
```
    Returns a stream consisting of the elements of this stream, additionally performing the provided action on each element as elements are consumed from the resulting stream. Handy method for debugging purposes.
    This is an intermediate operation.
    
    Parameters:
    
    action - the action to be performed on each element
    
    Returns:
    
    the new stream
  - scan
```
public IntStream scan(IntBinaryOperator accumulator)
```
    Returns a IntStream produced by iterative application of a accumulation function to reduction value and next element of the current stream. Produces a IntStream 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:
    
    NullPointerException - if accumulator is null
    
    Since:
    
    1.1.6
  - scan
```
public IntStream scan(int identity,
                      IntBinaryOperator accumulator)
```
    Returns a IntStream produced by iterative application of a accumulation function to an initial element identity and next element of the current stream. Produces a IntStream 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]
 
```
    Parameters:
    
    identity - the initial value
    
    accumulator - the accumulation function
    
    Returns:
    
    the new stream
    
    Throws:
    
    NullPointerException - if accumulator is null
    
    Since:
    
    1.1.6
  - takeWhile
```
public IntStream takeWhile(IntPredicate 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 IntStream
  - takeUntil
```
public IntStream takeUntil(IntPredicate 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 IntStream
    
    Since:
    
    1.1.6
  - dropWhile
```
public IntStream dropWhile(IntPredicate predicate)
```
    Drops elements while the predicate is true and 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 IntStream
  - limit
```
public IntStream limit(long maxSize)
```
    Returns a stream consisting of the elements of this stream, truncated to be no longer than maxSize in length.
    This is a short-circuiting stateful intermediate operation.
    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 the stream should be limited to
    
    Returns:
    
    the new stream
    
    Throws:
    
    IllegalArgumentException - if maxSize is negative
  - skip
```
public IntStream skip(long n)
```
    Returns a stream consisting of the remaining elements of this stream after discarding the first n elements of the stream. If this stream contains fewer than n elements then an empty stream will be returned.
    This is a stateful intermediate operation.
    Example:
```
 n: 3
 stream: [1, 2, 3, 4, 5]
 result: [4, 5]

 n: 10
 stream: [1, 2]
 result: []
 
```
    Parameters:
    
    n - the number of leading elements to skip
    
    Returns:
    
    the new stream
    
    Throws:
    
    IllegalArgumentException - if n is negative
  - forEach
```
public void forEach(IntConsumer action)
```
    Performs an action for each element of this stream.
    This is a terminal operation.
    
    Parameters:
    
    action - a non-interfering action to perform on the elements
  - reduce
```
public int reduce(int identity,
                  IntBinaryOperator op)
```
    Performs a reduction on the elements of this stream, using the provided identity value and an associative accumulation function, and returns the reduced value.
    The identity value must be an identity for the accumulator function. This means that for all x, accumulator.apply(identity, x) is equal to x. The accumulator function must be an associative function.
    This is a terminal operation.
    Example:
```
 identity: 0
 accumulator: (a, b) -> a + b
 stream: [1, 2, 3, 4, 5]
 result: 15
 
```
    Parameters:
    
    identity - the identity value for the accumulating function
    
    op - an associative non-interfering stateless function for combining two values
    
    Returns:
    
    the result of the reduction
    
    See Also:
    
    sum(), min(), max()
  - reduce
```
public OptionalInt reduce(IntBinaryOperator op)
```
    Performs a reduction on the elements of this stream, using an associative accumulation function, and returns an OptionalInt describing the reduced value, if any.
    The op function must be an associative function.
    This is a terminal operation.
    
    Parameters:
    
    op - an associative, non-interfering, stateless function for combining two values
    
    Returns:
    
    the result of the reduction
    
    See Also:
    
    reduce(int, IntBinaryOperator)
  - toArray
```
public int[] toArray()
```
    Returns an array containing the elements of this stream.
    This is a terminal operation.
    
    Returns:
    
    an array containing the elements of this stream
  - collect
```
public <R> R collect(Supplier<R> supplier,
                     ObjIntConsumer<R> 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:
    
    Stream.collect(com.annimon.stream.function.Supplier, com.annimon.stream.function.BiConsumer)
  - sum
```
public int sum()
```
    Returns the sum of elements in this stream.
    
    Returns:
    
    the sum of elements in this stream
  - min
```
public OptionalInt min()
```
    Returns an OptionalInt describing the minimum element of this stream, or an empty optional if this stream is empty.
    This is a terminal operation.
    
    Returns:
    
    an OptionalInt containing the minimum element of this stream, or an empty OptionalInt if the stream is empty
  - max
```
public OptionalInt max()
```
    Returns an OptionalInt describing the maximum element of this stream, or an empty optional if this stream is empty.
    This is a terminal operation.
    
    Returns:
    
    an OptionalInt containing the maximum element of this stream, or an empty OptionalInt if the stream is empty
  - count
```
public long count()
```
    Returns the count of elements in this stream.
    This is a terminal operation.
    
    Returns:
    
    the count of elements in this stream
  - anyMatch
```
public boolean anyMatch(IntPredicate predicate)
```
    Returns whether any elements of this stream match the provided predicate. May not evaluate the predicate on all elements if not necessary for determining the result. If the stream is empty then false is returned and the predicate is not evaluated.
    This is a short-circuiting terminal operation.
    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 - a non-interfering stateless predicate to apply to elements of this stream
    
    Returns:
    
    true if any elements of the stream match the provided predicate, otherwise false
  - allMatch
```
public boolean allMatch(IntPredicate predicate)
```
    Returns whether all elements of this stream match the provided predicate. May not evaluate the predicate on all elements if not necessary for determining the result. If the stream is empty then true is returned and the predicate is not evaluated.
    This is a short-circuiting terminal operation.
    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 - a non-interfering stateless predicate to apply to elements of this stream
    
    Returns:
    
    true if either all elements of the stream match the provided predicate or the stream is empty, otherwise false
  - noneMatch
```
public boolean noneMatch(IntPredicate predicate)
```
    Returns whether no elements of this stream match the provided predicate. May not evaluate the predicate on all elements if not necessary for determining the result. If the stream is empty then true is returned and the predicate is not evaluated.
    This is a short-circuiting terminal operation.
    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 - a non-interfering stateless predicate to apply to elements of this stream
    
    Returns:
    
    true if either no elements of the stream match the provided predicate or the stream is empty, otherwise false
  - findFirst
```
public OptionalInt findFirst()
```
    Returns an OptionalInt describing the first element of this stream, or an empty OptionalInt if the stream is empty.
    This is a short-circuiting terminal operation.
    
    Returns:
    
    an OptionalInt describing the first element of this stream, or an empty OptionalInt if the stream is empty
  - findLast
```
public OptionalInt findLast()
```
    Returns the last element wrapped by OptionalInt class. If stream is empty, returns OptionalInt.empty().
    This is a short-circuiting terminal operation.
    
    Returns:
    
    an OptionalInt with the last element or OptionalInt.empty() if the stream is empty
    
    Since:
    
    1.1.8
  - single
```
public int 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:
    
    NoSuchElementException - if stream is empty
    
    IllegalStateException - if stream contains more than one element
    
    Since:
    
    1.1.3
  - findSingle
```
public OptionalInt findSingle()
```
    Returns the single element wrapped by OptionalInt class. If stream is empty, returns OptionalInt.empty(). If stream contains more than one element, throws IllegalStateException.
    This is a short-circuiting terminal operation.
    Example:
```
 stream: []
 result: OptionalInt.empty()

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

 stream: [1, 2, 3]
 result: IllegalStateException
 
```
    Returns:
    
    an OptionalInt with single element or OptionalInt.empty() if stream is empty
    
    Throws:
    
    IllegalStateException - if stream contains more than one element
    
    Since:
    
    1.1.3
  - onClose
```
public IntStream onClose(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 Closeable
    
    Specified by:
    
    close in interface AutoCloseable
    
    Since:
    
    1.1.8

Class IntStream

Method Summary

Methods inherited from class java.lang.Object

Method Detail

empty

of

of

of

ofCodePoints

range

rangeClosed

generate

iterate

iterate

concat

iterator

custom

boxed

filter

filterNot

map

mapToObj

mapToLong

mapToDouble

flatMap

distinct

sorted

sorted

sample

peek

scan

scan

takeWhile

takeUntil

dropWhile

limit

skip

forEach

reduce

reduce

toArray

collect

sum

min

max

count

anyMatch

allMatch

noneMatch

findFirst

findLast

single

findSingle

onClose

close