IntStream (abacus API Documentation)

java.lang.Object
- com.landawn.abacus.util.stream.IntStream

All Implemented Interfaces:

BaseStream<java.lang.Integer,int[],IntPredicate,IntConsumer,IntList,OptionalInt,com.landawn.abacus.util.IndexedInt,IntStream>, java.lang.AutoCloseable

Direct Known Subclasses:

IntStream.IntStreamEx
```
public abstract class IntStream
extends java.lang.Object
```
Note: It's copied from OpenJDK at: http://hg.openjdk.java.net/jdk8u/hs-dev/jdk
A sequence of primitive int-valued elements supporting sequential and parallel aggregate operations. This is the int primitive specialization of Stream.
The following example illustrates an aggregate operation using Stream and IntStream, computing the sum of the weights of the red widgets:
```
     int sum = widgets.stream()
                      .filter(w -> w.getColor() == RED)
                      .mapToInt(w -> w.getWeight())
                      .sum();
 
```
See the class documentation for Stream and the package documentation for java.util.stream for additional specification of streams, stream operations, stream pipelines, and parallelism.
Since:

1.8

See Also:

Stream, java.util.stream

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static class IntStream.IntStreamEx
- Nested classes/interfaces inherited from interface com.landawn.abacus.util.stream.BaseStream
  BaseStream.Splitor

Nested Classes
Modifier and Type	Class and Description
`static class`	`IntStream.IntStreamEx`

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`<R> R`	`__(Function<? super IntStream,R> transfer)`
`abstract DoubleStream`	`asDoubleStream()` Returns a `DoubleStream` consisting of the elements of this stream, converted to `double`.
`abstract FloatStream`	`asFloatStream()` Returns a `FloatStream` consisting of the elements of this stream, converted to `double`.
`abstract LongStream`	`asLongStream()` Returns a `LongStream` consisting of the elements of this stream, converted to `long`.
`abstract OptionalDouble`	`average()` Returns an `OptionalDouble` describing the arithmetic mean of elements of this stream, or an empty optional if this stream is empty.
`abstract Stream<java.lang.Integer>`	`boxed()` Returns a `Stream` consisting of the elements of this stream, each boxed to an `Integer`.
`S`	`carry(C action)` Same as `peek`
`void`	`close()` Closes this stream, causing all close handlers for this stream pipeline to be called.
`abstract IntStream`	`collapse(IntBiPredicate collapsible, IntBiFunction<java.lang.Integer> mergeFunction)` Merge series of adjacent elements which satisfy the given predicate using the merger function and return a new stream.
`abstract <R> R`	`collect(Supplier<R> supplier, ObjIntConsumer<R> accumulator)`
`abstract <R> R`	`collect(Supplier<R> supplier, ObjIntConsumer<R> accumulator, BiConsumer<R,R> combiner)` Performs a mutable reduction operation on the elements of this stream.
`static IntStream`	`concat(java.util.Collection<? extends IntStream> c)`
`static IntStream`	`concat(int[]... a)`
`static IntStream`	`concat(IntIterator... a)`
`static IntStream`	`concat(IntStream... a)`
`static IntStream`	`empty()`
`OT`	`findAny(P predicate)` Returns an `Optional` describing some element of the stream, or an empty `Optional` if the stream is empty.
`abstract IntStream`	`flatArray(IntFunction<int[]> mapper)`
`abstract 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.
`abstract ByteStream`	`flatMapToByte(IntFunction<? extends ByteStream> mapper)`
`abstract CharStream`	`flatMapToChar(IntFunction<? extends CharStream> mapper)`
`abstract DoubleStream`	`flatMapToDouble(IntFunction<? extends DoubleStream> mapper)`
`abstract FloatStream`	`flatMapToFloat(IntFunction<? extends FloatStream> mapper)`
`abstract LongStream`	`flatMapToLong(IntFunction<? extends LongStream> mapper)`
`abstract <T> Stream<T>`	`flatMapToObj(IntFunction<? extends Stream<T>> mapper)`
`abstract ShortStream`	`flatMapToShort(IntFunction<? extends ShortStream> mapper)`
`static IntStream`	`from(byte... a)`
`static IntStream`	`from(byte[] a, int fromIndex, int toIndex)`
`static IntStream`	`from(char... a)`
`static IntStream`	`from(char[] a, int fromIndex, int toIndex)`
`static IntStream`	`from(short... a)`
`static IntStream`	`from(short[] a, int fromIndex, int toIndex)`
`static IntStream`	`generate(IntSupplier s)`
`abstract OptionalInt`	`head()` Head and tail should be used by pair.
`abstract IntStream`	`head2()` Head2 and tail2 should be used by pair.
`abstract Pair<OptionalInt,IntStream>`	`headAndTail()`
`abstract Pair<IntStream,OptionalInt>`	`headAndTail2()`
`boolean`	`isParallel()` Returns whether this stream, if a terminal operation were to be executed, would execute in parallel.
`static IntStream`	`iterate(int seed, IntPredicate hasNext, IntUnaryOperator f)`
`static IntStream`	`iterate(int seed, IntUnaryOperator f)`
`static IntStream`	`iterate(int seed, Supplier<java.lang.Boolean> hasNext, IntUnaryOperator f)`
`static IntStream`	`iterate(Supplier<java.lang.Boolean> hasNext, IntSupplier next)`
`IntIterator`	`iterator()` Returns an iterator for the elements of this stream.
`abstract OptionalInt`	`kthLargest(int k)`
`abstract IntStream`	`map(IntUnaryOperator mapper)` Returns a stream consisting of the results of applying the given function to the elements of this stream.
`abstract ByteStream`	`mapToByte(IntToByteFunction mapper)`
`abstract CharStream`	`mapToChar(IntToCharFunction mapper)`
`abstract DoubleStream`	`mapToDouble(IntToDoubleFunction mapper)` Returns a `DoubleStream` consisting of the results of applying the given function to the elements of this stream.
`abstract FloatStream`	`mapToFloat(IntToFloatFunction mapper)` Returns a `FloatStream` consisting of the results of applying the given function to the elements of this stream.
`abstract LongStream`	`mapToLong(IntToLongFunction mapper)` Returns a `LongStream` consisting of the results of applying the given function to the elements of this stream.
`abstract <U> Stream<U>`	`mapToObj(IntFunction<? extends U> mapper)` Returns an object-valued `Stream` consisting of the results of applying the given function to the elements of this stream.
`abstract ShortStream`	`mapToShort(IntToShortFunction mapper)`
`abstract OptionalInt`	`max()` Returns an `OptionalInt` describing the maximum element of this stream, or an empty optional if this stream is empty.
`int`	`maxThreadNum()` Return the underlying `maxThreadNum` if the stream is parallel, otherwise `1` is returned.
`S`	`maxThreadNum(int maxThreadNum)` Returns a parallel stream with the specified `maxThreadNum` .
`static IntStream`	`merge(java.util.Collection<? extends IntStream> c, IntBiFunction<com.landawn.abacus.util.Nth> nextSelector)`
`static IntStream`	`merge(int[] a, int[] b, int[] c, IntBiFunction<com.landawn.abacus.util.Nth> nextSelector)`
`static IntStream`	`merge(int[] a, int[] b, IntBiFunction<com.landawn.abacus.util.Nth> nextSelector)`
`static IntStream`	`merge(IntIterator a, IntIterator b, IntBiFunction<com.landawn.abacus.util.Nth> nextSelector)`
`static IntStream`	`merge(IntIterator a, IntIterator b, IntIterator c, IntBiFunction<com.landawn.abacus.util.Nth> nextSelector)`
`abstract IntStream`	`merge(IntStream b, IntBiFunction<com.landawn.abacus.util.Nth> nextSelector)`
`static IntStream`	`merge(IntStream a, IntStream b, IntBiFunction<com.landawn.abacus.util.Nth> nextSelector)`
`static IntStream`	`merge(IntStream a, IntStream b, IntStream c, IntBiFunction<com.landawn.abacus.util.Nth> nextSelector)`
`abstract OptionalInt`	`min()` Returns an `OptionalInt` describing the minimum element of this stream, or an empty optional if this stream is empty.
`static IntStream`	`of(int... a)`
`static IntStream`	`of(int[][] a)`
`static IntStream`	`of(int[][][] a)`
`static IntStream`	`of(int[] a, int startIndex, int endIndex)`
`static IntStream`	`of(IntIterator iterator)`
`static IntStream`	`of(java.util.stream.IntStream stream)`
`static IntStream`	`of(Supplier<IntList> supplier)` Lazy evaluation.
`static IntStream`	`ofCodePoints(java.lang.CharSequence str)`
`S`	`parallel()` Returns an equivalent stream that is parallel.
`S`	`parallel(BaseStream.Splitor splitor)` Returns an equivalent stream that is parallel.
`S`	`parallel(int maxThreadNum)` Returns an equivalent stream that is parallel.
`static IntStream`	`parallelMerge(java.util.Collection<? extends IntStream> c, IntBiFunction<com.landawn.abacus.util.Nth> nextSelector)`
`static IntStream`	`parallelMerge(java.util.Collection<? extends IntStream> c, IntBiFunction<com.landawn.abacus.util.Nth> nextSelector, int maxThreadNum)`
`void`	`println()`
`static IntStream`	`random()`
`static IntStream`	`random(int startInclusive, int endExclusive)`
`static IntStream`	`range(int startInclusive, int endExclusive)`
`static IntStream`	`range(int startInclusive, int endExclusive, int by)`
`static IntStream`	`rangeClosed(int startInclusive, int endInclusive)`
`static IntStream`	`rangeClosed(int startInclusive, int endInclusive, int by)`
`abstract 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.
`abstract 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.
`static IntStream`	`repeat(int element, long n)`
`abstract IntStream`	`scan(IntBiFunction<java.lang.Integer> accumulator)` Returns a `Stream` produced by iterative application of a accumulation function to an initial element `seed` and next element of the current stream.
`abstract IntStream`	`scan(int seed, IntBiFunction<java.lang.Integer> accumulator)` Returns a `Stream` produced by iterative application of a accumulation function to an initial element `seed` and next element of the current stream.
`S`	`sequential()` Returns an equivalent stream that is sequential.
`Stream<S>`	`sliding(int windowSize)`
`Stream<PL>`	`slidingToList(int windowSize)`
`BaseStream.Splitor`	`splitor()` Return the underlying `splitor` if the stream is parallel, otherwise the default value `splitor.ITERATOR` is returned.
`S`	`splitor(BaseStream.Splitor splitor)` Returns a parallel stream with the specified `splitor` .
`abstract long`	`sum()` Returns the sum of elements in this stream.
`abstract IntSummaryStatistics`	`summarize()`
`abstract Pair<IntSummaryStatistics,Optional<java.util.Map<com.landawn.abacus.util.Percentage,java.lang.Integer>>>`	`summarize2()`
`abstract IntStream`	`tail()` Head and tail should be used by pair.
`abstract OptionalInt`	`tail2()` Head2 and tail2 should be used by pair.
`abstract IntList`	`toIntList()`
`abstract <K,A,D> java.util.Map<K,D>`	`toMap(IntFunction<? extends K> classifier, Collector<java.lang.Integer,A,D> downstream)`
`abstract <K,A,D,M extends java.util.Map<K,D>> M`	`toMap(IntFunction<? extends K> classifier, Collector<java.lang.Integer,A,D> downstream, Supplier<M> mapFactory)`
`abstract <K,U> java.util.Map<K,U>`	`toMap(IntFunction<? extends K> keyExtractor, IntFunction<? extends U> valueMapper)`
`abstract <K,U> java.util.Map<K,U>`	`toMap(IntFunction<? extends K> keyExtractor, IntFunction<? extends U> valueMapper, BinaryOperator<U> mergeFunction)`
`abstract <K,U,M extends java.util.Map<K,U>> M`	`toMap(IntFunction<? extends K> keyExtractor, IntFunction<? extends U> valueMapper, BinaryOperator<U> mergeFunction, Supplier<M> mapFactory)`
`abstract <K,U,M extends java.util.Map<K,U>> M`	`toMap(IntFunction<? extends K> keyExtractor, IntFunction<? extends U> valueMapper, Supplier<M> mapFactory)`
`abstract IntMatrix`	`toMatrix()`
`abstract IntStream`	`top(int n)` This method only run sequentially, even in parallel stream.
`abstract IntStream`	`top(int n, java.util.Comparator<? super java.lang.Integer> comparator)` This method only run sequentially, even in parallel stream.
`Try<S>`	`tried()`
`static IntStream`	`zip(java.util.Collection<? extends IntStream> c, int[] valuesForNone, IntNFunction<java.lang.Integer> zipFunction)` Zip together the iterators until all of them runs out of values.
`static IntStream`	`zip(java.util.Collection<? extends IntStream> c, IntNFunction<java.lang.Integer> zipFunction)` Zip together the iterators until one of them runs out of values.
`static IntStream`	`zip(int[] a, int[] b, int[] c, int valueForNoneA, int valueForNoneB, int valueForNoneC, IntTriFunction<java.lang.Integer> zipFunction)` Zip together the "a", "b" and "c" iterators until all of them runs out of values.
`static IntStream`	`zip(int[] a, int[] b, int[] c, IntTriFunction<java.lang.Integer> zipFunction)` Zip together the "a", "b" and "c" arrays until one of them runs out of values.
`static IntStream`	`zip(int[] a, int[] b, IntBiFunction<java.lang.Integer> zipFunction)` Zip together the "a" and "b" arrays until one of them runs out of values.
`static IntStream`	`zip(int[] a, int[] b, int valueForNoneA, int valueForNoneB, IntBiFunction<java.lang.Integer> zipFunction)` Zip together the "a" and "b" iterators until all of them runs out of values.
`static IntStream`	`zip(IntIterator a, IntIterator b, IntBiFunction<java.lang.Integer> zipFunction)` Zip together the "a" and "b" iterators until one of them runs out of values.
`static IntStream`	`zip(IntIterator a, IntIterator b, int valueForNoneA, int valueForNoneB, IntBiFunction<java.lang.Integer> zipFunction)` Zip together the "a" and "b" iterators until all of them runs out of values.
`static IntStream`	`zip(IntIterator a, IntIterator b, IntIterator c, int valueForNoneA, int valueForNoneB, int valueForNoneC, IntTriFunction<java.lang.Integer> zipFunction)` Zip together the "a", "b" and "c" iterators until all of them runs out of values.
`static IntStream`	`zip(IntIterator a, IntIterator b, IntIterator c, IntTriFunction<java.lang.Integer> zipFunction)` Zip together the "a", "b" and "c" iterators until one of them runs out of values.
`static IntStream`	`zip(IntStream a, IntStream b, IntBiFunction<java.lang.Integer> zipFunction)` Zip together the "a" and "b" streams until one of them runs out of values.
`static IntStream`	`zip(IntStream a, IntStream b, int valueForNoneA, int valueForNoneB, IntBiFunction<java.lang.Integer> zipFunction)` Zip together the "a" and "b" iterators until all of them runs out of values.
`static IntStream`	`zip(IntStream a, IntStream b, IntStream c, int valueForNoneA, int valueForNoneB, int valueForNoneC, IntTriFunction<java.lang.Integer> zipFunction)` Zip together the "a", "b" and "c" iterators until all of them runs out of values.
`static IntStream`	`zip(IntStream a, IntStream b, IntStream c, IntTriFunction<java.lang.Integer> zipFunction)` Zip together the "a", "b" and "c" streams until one of them runs out of values.
`abstract IntStream`	`zipWith(IntStream b, IntBiFunction<java.lang.Integer> zipFunction)`
`abstract IntStream`	`zipWith(IntStream b, int valueForNoneA, int valueForNoneB, IntBiFunction<java.lang.Integer> zipFunction)`
`abstract IntStream`	`zipWith(IntStream b, IntStream c, int valueForNoneA, int valueForNoneB, int valueForNoneC, IntTriFunction<java.lang.Integer> zipFunction)`
`abstract IntStream`	`zipWith(IntStream b, IntStream c, IntTriFunction<java.lang.Integer> zipFunction)`

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

Methods inherited from interface com.landawn.abacus.util.stream.BaseStream
allMatch, anyMatch, append, cached, count, difference, distinct, dropWhile, filter, findFirst, findFirstOrLast, findLast, first, forEach, indexed, intersection, join, join, last, limit, noneMatch, onClose, parallel, peek, percentiles, prepend, remove, removeIf, removeIf, removeWhile, reversed, reverseSorted, rotated, shuffled, shuffled, skip, sliding, slidingToList, sorted, split, split, split, splitAt, splitBy, splitToList, splitToList, splitToList, step, symmetricDifference, takeWhile, toArray, toList, toList, toLongMultiset, toLongMultiset, toMultiset, toMultiset, toSet, toSet

- Method Detail
  - map
```
public abstract IntStream map(IntUnaryOperator mapper)
```
    Returns a stream consisting of the results of applying the given function to the elements of this stream.
    This is an intermediate operation.
    
    Parameters:
    
    mapper - a non-interfering, stateless function to apply to each element
    
    Returns:
    
    the new stream
  - mapToChar
```
public abstract CharStream mapToChar(IntToCharFunction mapper)
```
  - mapToByte
```
public abstract ByteStream mapToByte(IntToByteFunction mapper)
```
  - mapToShort
```
public abstract ShortStream mapToShort(IntToShortFunction mapper)
```
  - mapToLong
```
public abstract 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 - a non-interfering, stateless function to apply to each element
    
    Returns:
    
    the new stream
  - mapToFloat
```
public abstract FloatStream mapToFloat(IntToFloatFunction mapper)
```
    Returns a FloatStream consisting of the results of applying the given function to the elements of this stream.
    This is an intermediate operation.
    
    Parameters:
    
    mapper - a non-interfering, stateless function to apply to each element
    
    Returns:
    
    the new stream
  - mapToDouble
```
public abstract 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 - a non-interfering, stateless function to apply to each element
    
    Returns:
    
    the new stream
  - mapToObj
```
public abstract <U> Stream<U> mapToObj(IntFunction<? extends U> mapper)
```
    Returns an object-valued Stream consisting of the results of applying the given function to the elements of this stream.
    This is an intermediate operation.
    
    Type Parameters:
    
    U - the element type of the new stream
    
    Parameters:
    
    mapper - a non-interfering, stateless function to apply to each element
    
    Returns:
    
    the new stream
  - flatMap
```
public abstract 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.
    
    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)
  - flatArray
```
public abstract IntStream flatArray(IntFunction<int[]> mapper)
```
  - flatMapToChar
```
public abstract CharStream flatMapToChar(IntFunction<? extends CharStream> mapper)
```
  - flatMapToByte
```
public abstract ByteStream flatMapToByte(IntFunction<? extends ByteStream> mapper)
```
  - flatMapToShort
```
public abstract ShortStream flatMapToShort(IntFunction<? extends ShortStream> mapper)
```
  - flatMapToLong
```
public abstract LongStream flatMapToLong(IntFunction<? extends LongStream> mapper)
```
  - flatMapToFloat
```
public abstract FloatStream flatMapToFloat(IntFunction<? extends FloatStream> mapper)
```
  - flatMapToDouble
```
public abstract DoubleStream flatMapToDouble(IntFunction<? extends DoubleStream> mapper)
```
  - flatMapToObj
```
public abstract <T> Stream<T> flatMapToObj(IntFunction<? extends Stream<T>> mapper)
```
  - collapse
```
public abstract IntStream collapse(IntBiPredicate collapsible,
                                   IntBiFunction<java.lang.Integer> mergeFunction)
```
    Merge series of adjacent elements which satisfy the given predicate using the merger function and return a new stream.
    This method only run sequentially, even in parallel stream.
    
    Parameters:
    
    collapsible -
    
    mergeFunction -
    
    Returns:
  - scan
```
public abstract IntStream scan(IntBiFunction<java.lang.Integer> accumulator)
```
    Returns a Stream produced by iterative application of a accumulation function to an initial element seed and next element of the current stream. Produces a Stream consisting of seed, acc(seed, value1), acc(acc(seed, value1), value2), etc.
    This is an intermediate operation.
    Example:
```
 accumulator: (a, b) -> a + b
 stream: [1, 2, 3, 4, 5]
 result: [1, 3, 6, 10, 15]
 
```
    This method only run sequentially, even in parallel stream.
    Parameters:
    
    accumulator - the accumulation function
    
    Returns:
    
    the new stream which has the extract same size as this stream.
  - scan
```
public abstract IntStream scan(int seed,
                               IntBiFunction<java.lang.Integer> accumulator)
```
    Returns a Stream produced by iterative application of a accumulation function to an initial element seed and next element of the current stream. Produces a Stream consisting of seed, acc(seed, value1), acc(acc(seed, value1), value2), etc.
    This is an intermediate operation.
    Example:
```
 seed:10
 accumulator: (a, b) -> a + b
 stream: [1, 2, 3, 4, 5]
 result: [11, 13, 16, 20, 25]
 
```
    This method only run sequentially, even in parallel stream.
    Parameters:
    
    seed - the initial value. it's only used once by accumulator to calculate the fist element in the returned stream. It will be ignored if this stream is empty and won't be the first element of the returned stream.
    
    accumulator - the accumulation function
    
    Returns:
    
    the new stream which has the extract same size as this stream.
  - top
```
public abstract IntStream top(int n)
```
    This method only run sequentially, even in parallel stream.
    
    Parameters:
    
    n -
    
    Returns:
  - top
```
public abstract IntStream top(int n,
                              java.util.Comparator<? super java.lang.Integer> comparator)
```
    This method only run sequentially, even in parallel stream.
    
    Parameters:
    
    n -
    
    comparator -
    
    Returns:
  - toIntList
```
public abstract IntList toIntList()
```
  - toMap
```
public abstract <K,U> java.util.Map<K,U> toMap(IntFunction<? extends K> keyExtractor,
                                               IntFunction<? extends U> valueMapper)
```
    Parameters:
    
    keyExtractor -
    
    valueMapper -
    
    Returns:
    
    See Also:
    
    Collectors.toMap(Function, Function)
  - toMap
```
public abstract <K,U,M extends java.util.Map<K,U>> M toMap(IntFunction<? extends K> keyExtractor,
                                                           IntFunction<? extends U> valueMapper,
                                                           Supplier<M> mapFactory)
```
    Parameters:
    
    keyExtractor -
    
    valueMapper -
    
    mapFactory -
    
    Returns:
    
    See Also:
    
    Collectors.toMap(Function, Function, Supplier)
  - toMap
```
public abstract <K,U> java.util.Map<K,U> toMap(IntFunction<? extends K> keyExtractor,
                                               IntFunction<? extends U> valueMapper,
                                               BinaryOperator<U> mergeFunction)
```
    Parameters:
    
    keyExtractor -
    
    valueMapper -
    
    mergeFunction -
    
    Returns:
    
    See Also:
    
    Collectors.toMap(Function, Function, BinaryOperator)
  - toMap
```
public abstract <K,U,M extends java.util.Map<K,U>> M toMap(IntFunction<? extends K> keyExtractor,
                                                           IntFunction<? extends U> valueMapper,
                                                           BinaryOperator<U> mergeFunction,
                                                           Supplier<M> mapFactory)
```
    Parameters:
    
    keyExtractor -
    
    valueMapper -
    
    mergeFunction -
    
    mapFactory -
    
    Returns:
    
    See Also:
    
    Collectors.toMap(Function, Function, BinaryOperator, Supplier)
  - toMap
```
public abstract <K,A,D> java.util.Map<K,D> toMap(IntFunction<? extends K> classifier,
                                                 Collector<java.lang.Integer,A,D> downstream)
```
    Parameters:
    
    classifier -
    
    downstream -
    
    Returns:
    
    See Also:
    
    Collectors.groupingBy(Function, Collector)
  - toMap
```
public abstract <K,A,D,M extends java.util.Map<K,D>> M toMap(IntFunction<? extends K> classifier,
                                                             Collector<java.lang.Integer,A,D> downstream,
                                                             Supplier<M> mapFactory)
```
    Parameters:
    
    classifier -
    
    downstream -
    
    mapFactory -
    
    Returns:
    
    See Also:
    
    Collectors.groupingBy(Function, Collector, Supplier)
  - toMatrix
```
public abstract IntMatrix toMatrix()
```
  - reduce
```
public abstract 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. This is equivalent to:
```
     int result = identity;
     for (int element : this stream)
         result = accumulator.applyAsInt(result, element)
     return result;
 
```
    but is not constrained to execute sequentially.
    The identity value must be an identity for the accumulator function. This means that for all x, accumulator.apply(identity, x) is equal to x. The accumulator function must be an associative function.
    This is a terminal operation.
    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(), average()
  - reduce
```
public abstract 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. This is equivalent to:
```
     boolean foundAny = false;
     int result = null;
     for (int element : this stream) {
         if (!foundAny) {
             foundAny = true;
             result = element;
         }
         else
             result = accumulator.applyAsInt(result, element);
     }
     return foundAny ? OptionalInt.of(result) : OptionalInt.empty();
 
```
    but is not constrained to execute sequentially.
    The accumulator 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)
  - collect
```
public abstract <R> R collect(Supplier<R> supplier,
                              ObjIntConsumer<R> accumulator,
                              BiConsumer<R,R> combiner)
```
    Performs a mutable reduction operation on the elements of this stream. A mutable reduction is one in which the reduced value is a mutable result container, such as an ArrayList, and elements are incorporated by updating the state of the result rather than by replacing the result. This produces a result equivalent to:
```
     R result = supplier.get();
     for (int element : this stream)
         accumulator.accept(result, element);
     return result;
 
```
    Like reduce(int, IntBinaryOperator), collect operations can be parallelized without requiring additional synchronization.
    This is a terminal operation.
    Type Parameters:
    
    R - type of the result
    
    Parameters:
    
    supplier - a function that creates a new result container. For a parallel execution, this function may be called multiple times and must return a fresh value each time.
    
    accumulator - an associative, non-interfering, stateless function for incorporating an additional element into a result
    
    combiner - an associative, non-interfering, stateless function for combining two values, which must be compatible with the accumulator function
    
    Returns:
    
    the result of the reduction
    
    See Also:
    
    Stream.collect(Supplier, BiConsumer, BiConsumer)
  - collect
```
public abstract <R> R collect(Supplier<R> supplier,
                              ObjIntConsumer<R> accumulator)
```
    Parameters:
    
    supplier -
    
    accumulator -
    
    Returns:
  - head
```
public abstract OptionalInt head()
```
    Head and tail should be used by pair. If only one is called, should use first() or skip(1) instead. Don't call any other methods with this stream after head() and tail() are called.
    
    Returns:
  - tail
```
public abstract IntStream tail()
```
    Head and tail should be used by pair. If only one is called, should use first() or skip(1) instead. Don't call any other methods with this stream after head() and tail() are called.
    
    Returns:
  - head2
```
public abstract IntStream head2()
```
    Head2 and tail2 should be used by pair. Don't call any other methods with this stream after head2() and tail2() are called.
    
    Returns:
  - tail2
```
public abstract OptionalInt tail2()
```
    Head2 and tail2 should be used by pair. Don't call any other methods with this stream after head2() and tail2() are called.
    
    Returns:
  - headAndTail
```
public abstract Pair<OptionalInt,IntStream> headAndTail()
```
  - headAndTail2
```
public abstract Pair<IntStream,OptionalInt> headAndTail2()
```
  - min
```
public abstract OptionalInt min()
```
    Returns an OptionalInt describing the minimum element of this stream, or an empty optional if this stream is empty. This is a special case of a reduction and is equivalent to:
```
     return reduce(Integer::min);
 
```
    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 abstract OptionalInt max()
```
    Returns an OptionalInt describing the maximum element of this stream, or an empty optional if this stream is empty. This is a special case of a reduction and is equivalent to:
```
     return reduce(Integer::max);
 
```
    This is a terminal operation.
    Returns:
    
    an OptionalInt containing the maximum element of this stream, or an empty OptionalInt if the stream is empty
  - kthLargest
```
public abstract OptionalInt kthLargest(int k)
```
    Parameters:
    
    k -
    
    Returns:
    
    OptionalByte.empty() if there is no element or count less than k, otherwise the kth largest element.
  - sum
```
public abstract long sum()
```
    Returns the sum of elements in this stream. This is a special case of a reduction and is equivalent to:
```
     return reduce(0, Integer::sum);
 
```
    This is a terminal operation.
    Returns:
    
    the sum of elements in this stream
  - average
```
public abstract OptionalDouble average()
```
    Returns an OptionalDouble describing the arithmetic mean of elements of this stream, or an empty optional if this stream is empty. This is a special case of a reduction.
    This is a terminal operation.
    
    Returns:
    
    an OptionalDouble containing the average element of this stream, or an empty optional if the stream is empty
  - summarize
```
public abstract IntSummaryStatistics summarize()
```
  - summarize2
```
public abstract Pair<IntSummaryStatistics,Optional<java.util.Map<com.landawn.abacus.util.Percentage,java.lang.Integer>>> summarize2()
```
  - merge
```
public abstract IntStream merge(IntStream b,
                                IntBiFunction<com.landawn.abacus.util.Nth> nextSelector)
```
    Parameters:
    
    b -
    
    nextSelector - first parameter is selected if Nth.FIRST is returned, otherwise the second parameter is selected.
    
    Returns:
  - zipWith
```
public abstract IntStream zipWith(IntStream b,
                                  IntBiFunction<java.lang.Integer> zipFunction)
```
  - zipWith
```
public abstract IntStream zipWith(IntStream b,
                                  IntStream c,
                                  IntTriFunction<java.lang.Integer> zipFunction)
```
  - zipWith
```
public abstract IntStream zipWith(IntStream b,
                                  int valueForNoneA,
                                  int valueForNoneB,
                                  IntBiFunction<java.lang.Integer> zipFunction)
```
  - zipWith
```
public abstract IntStream zipWith(IntStream b,
                                  IntStream c,
                                  int valueForNoneA,
                                  int valueForNoneB,
                                  int valueForNoneC,
                                  IntTriFunction<java.lang.Integer> zipFunction)
```
  - asLongStream
```
public abstract LongStream asLongStream()
```
    Returns a LongStream consisting of the elements of this stream, converted to long.
    This is an intermediate operation.
    
    Returns:
    
    a LongStream consisting of the elements of this stream, converted to long
  - asFloatStream
```
public abstract FloatStream asFloatStream()
```
    Returns a FloatStream consisting of the elements of this stream, converted to double.
    This is an intermediate operation.
    
    Returns:
    
    a FloatStream consisting of the elements of this stream, converted to double
  - asDoubleStream
```
public abstract DoubleStream asDoubleStream()
```
    Returns a DoubleStream consisting of the elements of this stream, converted to double.
    This is an intermediate operation.
    
    Returns:
    
    a DoubleStream consisting of the elements of this stream, converted to double
  - boxed
```
public abstract Stream<java.lang.Integer> boxed()
```
    Returns a Stream consisting of the elements of this stream, each boxed to an Integer.
    This is an intermediate operation.
    
    Returns:
    
    a Stream consistent of the elements of this stream, each boxed to an Integer
  - iterator
```
public IntIterator iterator()
```
    Description copied from interface: BaseStream
    
    Returns an iterator for the elements of this stream.
    
    Returns:
    
    the element iterator for this stream
  - __
```
public <R> R __(Function<? super IntStream,R> transfer)
```
  - empty
```
public static IntStream empty()
```
  - of
```
@SafeVarargs
public static IntStream of(int... a)
```
  - of
```
public static IntStream of(int[] a,
                           int startIndex,
                           int endIndex)
```
  - of
```
public static IntStream of(int[][] a)
```
  - of
```
public static IntStream of(int[][][] a)
```
  - of
```
public static IntStream of(IntIterator iterator)
```
  - of
```
public static IntStream of(Supplier<IntList> supplier)
```
    Lazy evaluation.
    
    Parameters:
    
    supplier -
    
    Returns:
  - of
```
public static IntStream of(java.util.stream.IntStream stream)
```
  - ofCodePoints
```
public static IntStream ofCodePoints(java.lang.CharSequence str)
```
  - from
```
@SafeVarargs
public static IntStream from(char... a)
```
  - from
```
public static IntStream from(char[] a,
                             int fromIndex,
                             int toIndex)
```
  - from
```
@SafeVarargs
public static IntStream from(byte... a)
```
  - from
```
public static IntStream from(byte[] a,
                             int fromIndex,
                             int toIndex)
```
  - from
```
@SafeVarargs
public static IntStream from(short... a)
```
  - from
```
public static IntStream from(short[] a,
                             int fromIndex,
                             int toIndex)
```
  - range
```
public static IntStream range(int startInclusive,
                              int endExclusive)
```
  - range
```
public static IntStream range(int startInclusive,
                              int endExclusive,
                              int by)
```
  - rangeClosed
```
public static IntStream rangeClosed(int startInclusive,
                                    int endInclusive)
```
  - rangeClosed
```
public static IntStream rangeClosed(int startInclusive,
                                    int endInclusive,
                                    int by)
```
  - repeat
```
public static IntStream repeat(int element,
                               long n)
```
  - random
```
public static IntStream random()
```
  - random
```
public static IntStream random(int startInclusive,
                               int endExclusive)
```
  - iterate
```
public static IntStream iterate(Supplier<java.lang.Boolean> hasNext,
                                IntSupplier next)
```
  - iterate
```
public static IntStream iterate(int seed,
                                Supplier<java.lang.Boolean> hasNext,
                                IntUnaryOperator f)
```
  - iterate
```
public static IntStream iterate(int seed,
                                IntPredicate hasNext,
                                IntUnaryOperator f)
```
    Parameters:
    
    seed -
    
    hasNext - test if has next by hasNext.test(seed) for first time and hasNext.test(f.apply(previous)) for remaining.
    
    f -
    
    Returns:
  - iterate
```
public static IntStream iterate(int seed,
                                IntUnaryOperator f)
```
  - generate
```
public static IntStream generate(IntSupplier s)
```
  - concat
```
@SafeVarargs
public static IntStream concat(int[]... a)
```
  - concat
```
@SafeVarargs
public static IntStream concat(IntIterator... a)
```
  - concat
```
@SafeVarargs
public static IntStream concat(IntStream... a)
```
  - concat
```
public static IntStream concat(java.util.Collection<? extends IntStream> c)
```
  - zip
```
public static IntStream zip(int[] a,
                            int[] b,
                            IntBiFunction<java.lang.Integer> zipFunction)
```
    Zip together the "a" and "b" arrays until one of them runs out of values. Each pair of values is combined into a single value using the supplied zipFunction function.
    
    Parameters:
    
    a -
    
    b -
    
    Returns:
  - zip
```
public static IntStream zip(int[] a,
                            int[] b,
                            int[] c,
                            IntTriFunction<java.lang.Integer> zipFunction)
```
    Zip together the "a", "b" and "c" arrays until one of them runs out of values. Each triple of values is combined into a single value using the supplied zipFunction function.
    
    Parameters:
    
    a -
    
    b -
    
    Returns:
  - zip
```
public static IntStream zip(IntIterator a,
                            IntIterator b,
                            IntBiFunction<java.lang.Integer> zipFunction)
```
    Zip together the "a" and "b" iterators until one of them runs out of values. Each pair of values is combined into a single value using the supplied zipFunction function.
    
    Parameters:
    
    a -
    
    b -
    
    Returns:
  - zip
```
public static IntStream zip(IntIterator a,
                            IntIterator b,
                            IntIterator c,
                            IntTriFunction<java.lang.Integer> zipFunction)
```
    Zip together the "a", "b" and "c" iterators until one of them runs out of values. Each triple of values is combined into a single value using the supplied zipFunction function.
    
    Parameters:
    
    a -
    
    b -
    
    Returns:
  - zip
```
public static IntStream zip(IntStream a,
                            IntStream b,
                            IntBiFunction<java.lang.Integer> zipFunction)
```
    Zip together the "a" and "b" streams until one of them runs out of values. Each pair of values is combined into a single value using the supplied zipFunction function.
    
    Parameters:
    
    a -
    
    b -
    
    Returns:
  - zip
```
public static IntStream zip(IntStream a,
                            IntStream b,
                            IntStream c,
                            IntTriFunction<java.lang.Integer> zipFunction)
```
    Zip together the "a", "b" and "c" streams until one of them runs out of values. Each triple of values is combined into a single value using the supplied zipFunction function.
    
    Parameters:
    
    a -
    
    b -
    
    Returns:
  - zip
```
public static IntStream zip(java.util.Collection<? extends IntStream> c,
                            IntNFunction<java.lang.Integer> zipFunction)
```
    Zip together the iterators until one of them runs out of values. Each array of values is combined into a single value using the supplied zipFunction function.
    
    Parameters:
    
    c -
    
    zipFunction -
    
    Returns:
  - zip
```
public static IntStream zip(int[] a,
                            int[] b,
                            int valueForNoneA,
                            int valueForNoneB,
                            IntBiFunction<java.lang.Integer> zipFunction)
```
    Zip together the "a" and "b" iterators until all of them runs out of values. Each pair of values is combined into a single value using the supplied zipFunction function.
    
    Parameters:
    
    a -
    
    b -
    
    valueForNoneA - value to fill if "a" runs out of values first.
    
    valueForNoneB - value to fill if "b" runs out of values first.
    
    zipFunction -
    
    Returns:
  - zip
```
public static IntStream zip(int[] a,
                            int[] b,
                            int[] c,
                            int valueForNoneA,
                            int valueForNoneB,
                            int valueForNoneC,
                            IntTriFunction<java.lang.Integer> zipFunction)
```
    Zip together the "a", "b" and "c" iterators until all of them runs out of values. Each triple of values is combined into a single value using the supplied zipFunction function.
    
    Parameters:
    
    a -
    
    b -
    
    c -
    
    valueForNoneA - value to fill if "a" runs out of values.
    
    valueForNoneB - value to fill if "b" runs out of values.
    
    valueForNoneC - value to fill if "c" runs out of values.
    
    zipFunction -
    
    Returns:
  - zip
```
public static IntStream zip(IntIterator a,
                            IntIterator b,
                            int valueForNoneA,
                            int valueForNoneB,
                            IntBiFunction<java.lang.Integer> zipFunction)
```
    Zip together the "a" and "b" iterators until all of them runs out of values. Each pair of values is combined into a single value using the supplied zipFunction function.
    
    Parameters:
    
    a -
    
    b -
    
    valueForNoneA - value to fill if "a" runs out of values first.
    
    valueForNoneB - value to fill if "b" runs out of values first.
    
    zipFunction -
    
    Returns:
  - zip
```
public static IntStream zip(IntIterator a,
                            IntIterator b,
                            IntIterator c,
                            int valueForNoneA,
                            int valueForNoneB,
                            int valueForNoneC,
                            IntTriFunction<java.lang.Integer> zipFunction)
```
    Zip together the "a", "b" and "c" iterators until all of them runs out of values. Each triple of values is combined into a single value using the supplied zipFunction function.
    
    Parameters:
    
    a -
    
    b -
    
    c -
    
    valueForNoneA - value to fill if "a" runs out of values.
    
    valueForNoneB - value to fill if "b" runs out of values.
    
    valueForNoneC - value to fill if "c" runs out of values.
    
    zipFunction -
    
    Returns:
  - zip
```
public static IntStream zip(IntStream a,
                            IntStream b,
                            int valueForNoneA,
                            int valueForNoneB,
                            IntBiFunction<java.lang.Integer> zipFunction)
```
    Zip together the "a" and "b" iterators until all of them runs out of values. Each pair of values is combined into a single value using the supplied zipFunction function.
    
    Parameters:
    
    a -
    
    b -
    
    valueForNoneA - value to fill if "a" runs out of values first.
    
    valueForNoneB - value to fill if "b" runs out of values first.
    
    zipFunction -
    
    Returns:
  - zip
```
public static IntStream zip(IntStream a,
                            IntStream b,
                            IntStream c,
                            int valueForNoneA,
                            int valueForNoneB,
                            int valueForNoneC,
                            IntTriFunction<java.lang.Integer> zipFunction)
```
    Zip together the "a", "b" and "c" iterators until all of them runs out of values. Each triple of values is combined into a single value using the supplied zipFunction function.
    
    Parameters:
    
    a -
    
    b -
    
    c -
    
    valueForNoneA - value to fill if "a" runs out of values.
    
    valueForNoneB - value to fill if "b" runs out of values.
    
    valueForNoneC - value to fill if "c" runs out of values.
    
    zipFunction -
    
    Returns:
  - zip
```
public static IntStream zip(java.util.Collection<? extends IntStream> c,
                            int[] valuesForNone,
                            IntNFunction<java.lang.Integer> zipFunction)
```
    Zip together the iterators until all of them runs out of values. Each array of values is combined into a single value using the supplied zipFunction function.
    
    Parameters:
    
    c -
    
    valuesForNone - value to fill for any iterator runs out of values.
    
    zipFunction -
    
    Returns:
  - merge
```
public static IntStream merge(int[] a,
                              int[] b,
                              IntBiFunction<com.landawn.abacus.util.Nth> nextSelector)
```
    Parameters:
    
    a -
    
    b -
    
    nextSelector - first parameter is selected if Nth.FIRST is returned, otherwise the second parameter is selected.
    
    Returns:
  - merge
```
public static IntStream merge(int[] a,
                              int[] b,
                              int[] c,
                              IntBiFunction<com.landawn.abacus.util.Nth> nextSelector)
```
    Parameters:
    
    a -
    
    b -
    
    c -
    
    nextSelector - first parameter is selected if Nth.FIRST is returned, otherwise the second parameter is selected.
    
    Returns:
  - merge
```
public static IntStream merge(IntIterator a,
                              IntIterator b,
                              IntBiFunction<com.landawn.abacus.util.Nth> nextSelector)
```
    Parameters:
    
    a -
    
    b -
    
    nextSelector - first parameter is selected if Nth.FIRST is returned, otherwise the second parameter is selected.
    
    Returns:
  - merge
```
public static IntStream merge(IntIterator a,
                              IntIterator b,
                              IntIterator c,
                              IntBiFunction<com.landawn.abacus.util.Nth> nextSelector)
```
    Parameters:
    
    a -
    
    b -
    
    c -
    
    nextSelector - first parameter is selected if Nth.FIRST is returned, otherwise the second parameter is selected.
    
    Returns:
  - merge
```
public static IntStream merge(IntStream a,
                              IntStream b,
                              IntBiFunction<com.landawn.abacus.util.Nth> nextSelector)
```
    Parameters:
    
    a -
    
    b -
    
    nextSelector - first parameter is selected if Nth.FIRST is returned, otherwise the second parameter is selected.
    
    Returns:
  - merge
```
public static IntStream merge(IntStream a,
                              IntStream b,
                              IntStream c,
                              IntBiFunction<com.landawn.abacus.util.Nth> nextSelector)
```
    Parameters:
    
    a -
    
    b -
    
    c -
    
    nextSelector - first parameter is selected if Nth.FIRST is returned, otherwise the second parameter is selected.
    
    Returns:
  - merge
```
public static IntStream merge(java.util.Collection<? extends IntStream> c,
                              IntBiFunction<com.landawn.abacus.util.Nth> nextSelector)
```
    Parameters:
    
    c -
    
    nextSelector - first parameter is selected if Nth.FIRST is returned, otherwise the second parameter is selected.
    
    Returns:
  - parallelMerge
```
public static IntStream parallelMerge(java.util.Collection<? extends IntStream> c,
                                      IntBiFunction<com.landawn.abacus.util.Nth> nextSelector)
```
    Parameters:
    
    c -
    
    nextSelector - first parameter is selected if Nth.FIRST is returned, otherwise the second parameter is selected.
    
    Returns:
  - parallelMerge
```
public static IntStream parallelMerge(java.util.Collection<? extends IntStream> c,
                                      IntBiFunction<com.landawn.abacus.util.Nth> nextSelector,
                                      int maxThreadNum)
```
    Parameters:
    
    c -
    
    nextSelector - first parameter is selected if Nth.FIRST is returned, otherwise the second parameter is selected.
    
    maxThreadNum -
    
    Returns:
  - carry
```
public S carry(C action)
```
    Description copied from interface: BaseStream
    
    Same as peek
    
    Specified by:
    
    carry in interface BaseStream<T,A,P,C,PL,OT,IT,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,S>>
    
    Returns:
    
    See Also:
    
    BaseStream.peek(Object)
  - findAny
```
public OT findAny(P predicate)
```
    Description copied from interface: BaseStream
    
    Returns an Optional describing some element of the stream, or an empty Optional if the stream is empty.
    This is a short-circuiting terminal operation.
    The behavior of this operation is explicitly nondeterministic; it is free to select any element in the stream. This is to allow for maximal performance in parallel operations; the cost is that multiple invocations on the same source may not return the same result. (If a stable result is desired, use #findFirst() instead.)
    
    Specified by:
    
    findAny in interface BaseStream<T,A,P,C,PL,OT,IT,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,S>>
    
    Returns:
    
    an Optional describing some element of this stream, or an empty Optional if the stream is empty
    
    See Also:
    
    #findFirst()
  - sliding
```
public Stream<S> sliding(int windowSize)
```
    Specified by:
    
    sliding in interface BaseStream<T,A,P,C,PL,OT,IT,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,S>>
    
    Returns:
    
    See Also:
    
    BaseStream.sliding(int, int)
  - slidingToList
```
public Stream<PL> slidingToList(int windowSize)
```
    Specified by:
    
    slidingToList in interface BaseStream<T,A,P,C,PL,OT,IT,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,S>>
    
    Returns:
    
    See Also:
    
    BaseStream.sliding(int, int)
  - println
```
public void println()
```
    Specified by:
    
    println in interface BaseStream<T,A,P,C,PL,OT,IT,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,S>>
  - isParallel
```
public boolean isParallel()
```
    Description copied from interface: BaseStream
    
    Returns whether this stream, if a terminal operation were to be executed, would execute in parallel. Calling this method after invoking an terminal stream operation method may yield unpredictable results.
    
    Specified by:
    
    isParallel in interface BaseStream<T,A,P,C,PL,OT,IT,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,S>>
    
    Returns:
    
    true if this stream would execute in parallel if executed
  - sequential
```
public S sequential()
```
    Description copied from interface: BaseStream
    
    Returns an equivalent stream that is sequential. May return itself, either because the stream was already sequential, or because the underlying stream state was modified to be sequential.
    
    Specified by:
    
    sequential in interface BaseStream<T,A,P,C,PL,OT,IT,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,S>>
    
    Returns:
    
    a sequential stream
  - parallel
```
public S parallel()
```
    Description copied from interface: BaseStream
    
    Returns an equivalent stream that is parallel. May return itself if the stream was already parallel. Any parallel should be closed by try-catch or call tried before last step.
    
    Specified by:
    
    parallel in interface BaseStream<T,A,P,C,PL,OT,IT,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,S>>
    
    Returns:
    
    a parallel stream
    
    See Also:
    
    BaseStream.parallel(int, Splitor)
  - parallel
```
public S parallel(int maxThreadNum)
```
    Description copied from interface: BaseStream
    
    Returns an equivalent stream that is parallel. May return itself if the stream was already parallel with the same maxThreadNum as the specified one.
    
    Specified by:
    
    parallel in interface BaseStream<T,A,P,C,PL,OT,IT,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,S>>
    
    Returns:
    
    See Also:
    
    BaseStream.parallel(int, Splitor)
  - parallel
```
public S parallel(BaseStream.Splitor splitor)
```
    Description copied from interface: BaseStream
    
    Returns an equivalent stream that is parallel. May return itself if the stream was already parallel with the same splitor as the specified one.
    
    Specified by:
    
    parallel in interface BaseStream<T,A,P,C,PL,OT,IT,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,S>>
    
    Returns:
    
    See Also:
    
    BaseStream.parallel(int, Splitor)
  - maxThreadNum
```
public int maxThreadNum()
```
    Description copied from interface: BaseStream
    
    Return the underlying maxThreadNum if the stream is parallel, otherwise 1 is returned.
    
    Specified by:
    
    maxThreadNum in interface BaseStream<T,A,P,C,PL,OT,IT,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,S>>
    
    Returns:
  - maxThreadNum
```
public S maxThreadNum(int maxThreadNum)
```
    Description copied from interface: BaseStream
    
    Returns a parallel stream with the specified maxThreadNum . Or return itself, either because the stream was already parallel with same maxThreadNum, or because it's a sequential stream.
    
    Specified by:
    
    maxThreadNum in interface BaseStream<T,A,P,C,PL,OT,IT,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,S>>
    
    Returns:
  - splitor
```
public BaseStream.Splitor splitor()
```
    Description copied from interface: BaseStream
    
    Return the underlying splitor if the stream is parallel, otherwise the default value splitor.ITERATOR is returned.
    
    Specified by:
    
    splitor in interface BaseStream<T,A,P,C,PL,OT,IT,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,S>>
    
    Returns:
  - splitor
```
public S splitor(BaseStream.Splitor splitor)
```
    Description copied from interface: BaseStream
    
    Returns a parallel stream with the specified splitor . Or return itself, either because the stream was already parallel with same splitor, or because it's a sequential stream.
    
    Specified by:
    
    splitor in interface BaseStream<T,A,P,C,PL,OT,IT,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,S>>
    
    Returns:
  - tried
```
public Try<S> tried()
```
    Specified by:
    
    tried in interface BaseStream<T,A,P,C,PL,OT,IT,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,S>>
  - close
```
public void close()
```
    Description copied from interface: BaseStream
    
    Closes this stream, causing all close handlers for this stream pipeline to be called.
    
    Specified by:
    
    close in interface BaseStream<T,A,P,C,PL,OT,IT,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,S>>
    
    Specified by:
    
    close in interface java.lang.AutoCloseable
    
    See Also:
    
    AutoCloseable.close()

Class IntStream

Nested Class Summary

Nested classes/interfaces inherited from interface com.landawn.abacus.util.stream.BaseStream

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface com.landawn.abacus.util.stream.BaseStream

Method Detail

map

mapToChar

mapToByte

mapToShort

mapToLong

mapToFloat

mapToDouble

mapToObj

flatMap

flatArray

flatMapToChar

flatMapToByte

flatMapToShort

flatMapToLong

flatMapToFloat

flatMapToDouble

flatMapToObj

collapse

scan

scan

top

top

toIntList

toMap

toMap

toMap

toMap

toMap

toMap

toMatrix

reduce

reduce

collect

collect

head

tail

head2

tail2

headAndTail

headAndTail2

min

max

kthLargest

sum

average

summarize

summarize2

merge

zipWith

zipWith

zipWith

zipWith

asLongStream

asFloatStream

asDoubleStream

boxed

iterator

__

empty

of

of

of

of

of

of

of

ofCodePoints

from

from

from

from

from

from