IntStream (abacus-util 1.20.28 API)

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

All Implemented Interfaces:

Immutable, BaseStream<Integer,int[],IntPredicate,IntConsumer,IntList,u.OptionalInt,IndexedInt,IntIterator,IntStream>, AutoCloseable

Direct Known Subclasses:

IntStream.IntStreamEx
```
public abstract class IntStream
extends Object
```
The Stream will be automatically closed after execution(A terminal method is executed/triggered).

See Also:

BaseStream, 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
`<SS extends BaseStream> SS`	`__(Function<? super IntStream,SS> transfer)`
`abstract <E extends Exception> boolean`	`allMatch(Throwables.IntPredicate<E> predicate)`
`abstract <E extends Exception> boolean`	`anyMatch(Throwables.IntPredicate<E> predicate)`
`abstract IntStream`	`append(int... a)`
`abstract IntStream`	`appendIfEmpty(int... a)`
`abstract DoubleStream`	`asDoubleStream()`
`abstract FloatStream`	`asFloatStream()`
`abstract LongStream`	`asLongStream()`
`abstract u.OptionalDouble`	`average()`
`abstract Stream<Integer>`	`boxed()`
`S`	`carry(C action)` Same as `peek`
`void`	`close()`
`abstract Stream<IntList>`	`collapse(IntBiPredicate collapsible)` Merge series of adjacent elements which satisfy the given predicate using the merger function and return a new stream.
`abstract IntStream`	`collapse(IntBiPredicate collapsible, IntBinaryOperator 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<? super R> accumulator)`
`abstract <R> R`	`collect(Supplier<R> supplier, ObjIntConsumer<? super R> accumulator, BiConsumer<R,R> combiner)`
`static IntStream`	`concat(Collection<? extends IntStream> c)`
`static IntStream`	`concat(int[]... a)`
`static IntStream`	`concat(IntIterator... a)`
`static IntStream`	`concat(IntStream... a)`
`static IntStream`	`empty()`
`abstract <E extends Exception> u.OptionalInt`	`findAny(Throwables.IntPredicate<E> predicate)`
`abstract <E extends Exception> u.OptionalInt`	`findFirst(Throwables.IntPredicate<E> predicate)`
`abstract <E extends Exception,E2 extends Exception> u.OptionalInt`	`findFirstOrLast(Throwables.IntPredicate<E> predicateForFirst, Throwables.IntPredicate<E> predicateForLast)`
`abstract <E extends Exception> u.OptionalInt`	`findLast(Throwables.IntPredicate<E> predicate)` Consider using: `stream.reversed().findFirst(predicate)` for better performance if possible.
`abstract IntStream`	`flatMap(IntFunction<? extends IntStream> mapper)`
`abstract <T> Stream<T>`	`flatMappToObj(IntFunction<T[]> mapper)`
`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`	`flatten(int[][] a)`
`static IntStream`	`flatten(int[][][] a)`
`static IntStream`	`flatten(int[][] a, boolean vertically)`
`static IntStream`	`flatten(int[][] a, int valueForNone, boolean vertically)`
`abstract IntStream`	`flattMap(IntFunction<int[]> mapper)`
`abstract <T> Stream<T>`	`flattMapToObj(IntFunction<? extends Collection<T>> mapper)`
`abstract <E extends Exception> void`	`forEach(Throwables.IntConsumer<E> action)`
`abstract <E extends Exception> void`	`forEachIndexed(Throwables.IndexedIntConsumer<E> action)`
`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)`
`boolean`	`isParallel()`
`static IntStream`	`iterate(BooleanSupplier hasNext, IntSupplier next)`
`static IntStream`	`iterate(int init, BooleanSupplier hasNext, IntUnaryOperator f)`
`static IntStream`	`iterate(int init, IntPredicate hasNext, IntUnaryOperator f)`
`static IntStream`	`iterate(int init, IntUnaryOperator f)`
`IntIterator`	`iterator()` Remember to close this Stream after the iteration is done, if needed.
`String`	`join(CharSequence delimiter)`
`abstract u.OptionalInt`	`kthLargest(int k)`
`abstract IntStream`	`map(IntUnaryOperator mapper)`
`abstract ByteStream`	`mapToByte(IntToByteFunction mapper)`
`abstract CharStream`	`mapToChar(IntToCharFunction mapper)`
`abstract DoubleStream`	`mapToDouble(IntToDoubleFunction mapper)`
`abstract FloatStream`	`mapToFloat(IntToFloatFunction mapper)`
`abstract LongStream`	`mapToLong(IntToLongFunction mapper)`
`abstract <U> Stream<U>`	`mapToObj(IntFunction<? extends U> mapper)`
`abstract ShortStream`	`mapToShort(IntToShortFunction mapper)`
`abstract u.OptionalInt`	`max()`
`static IntStream`	`merge(Collection<? extends IntStream> c, IntBiFunction<MergeResult> nextSelector)`
`static IntStream`	`merge(int[] a, int[] b, int[] c, IntBiFunction<MergeResult> nextSelector)`
`static IntStream`	`merge(int[] a, int[] b, IntBiFunction<MergeResult> nextSelector)`
`static IntStream`	`merge(IntIterator a, IntIterator b, IntBiFunction<MergeResult> nextSelector)`
`static IntStream`	`merge(IntIterator a, IntIterator b, IntIterator c, IntBiFunction<MergeResult> nextSelector)`
`abstract IntStream`	`merge(IntStream b, IntBiFunction<MergeResult> nextSelector)`
`static IntStream`	`merge(IntStream a, IntStream b, IntBiFunction<MergeResult> nextSelector)`
`static IntStream`	`merge(IntStream a, IntStream b, IntStream c, IntBiFunction<MergeResult> nextSelector)`
`abstract u.OptionalInt`	`min()`
`abstract <E extends Exception> boolean`	`noneMatch(Throwables.IntPredicate<E> predicate)`
`static IntStream`	`of(Collection<Integer> c)`
`static IntStream`	`of(int... a)`
`static IntStream`	`of(int[] a, int startIndex, int endIndex)`
`static IntStream`	`of(Integer[] a)`
`static IntStream`	`of(Integer[] a, int startIndex, int endIndex)`
`static IntStream`	`of(IntIterator iterator)`
`static IntStream`	`of(IntStream stream)`
`static IntStream`	`of(Supplier<IntList> supplier)` Lazy evaluation.
`static IntStream`	`ofCodePoints(CharSequence str)`
`static <AC> IntStream`	`ofIndices(AC source, BiFunction<? super AC,Integer,Integer> indexFunc)`
`static <AC> IntStream`	`ofIndices(AC source, int fromIndex, BiFunction<? super AC,Integer,Integer> indexFunc)`
`static <AC> IntStream`	`ofIndices(AC source, int fromIndex, int increment, BiFunction<? super AC,Integer,Integer> indexFunc)` // Forwards: int[] a = {1, 2, 3, 2, 5, 1}; IntStream.ofIndices(a, N::indexOf).println(); // [0, 5] IntStream.ofIndices(a, 1, N::indexOf).println(); // [5] // Backwards IntStream.ofIndices(a, 5, -1, N::lastIndexOf).println(); // [5, 0] IntStream.ofIndices(a, 4, -1, N::lastIndexOf).println(); // [0] // OR // Forwards: int[] source = { 1, 2, 3, 1, 2, 1 }; int[] targetSubArray = { 1, 2 }; IntStream.ofIndices(source, (a, fromIndex) -> Index.ofSubArray(a, fromIndex, targetSubArray, 0, targetSubArray.length).orElse(-1)).println(); // [0, 3] // Backwards IntStream.ofIndices(source, 5, -2, (a, fromIndex) -> Index.ofSubArray(a, fromIndex, targetSubArray, 0, targetSubArray.length).orElse(-1)) .println(); // [3, 0]
`static <AC> IntStream`	`ofIndices(AC source, int fromIndex, int increment, int sourceLen, BiFunction<? super AC,Integer,Integer> indexFunc)`
`S`	`parallel()`
`S`	`parallel(BaseStream.Splitor splitor)`
`S`	`parallel(Executor executor)`
`S`	`parallel(int maxThreadNum)`
`S`	`parallel(int maxThreadNum, BaseStream.Splitor splitor)` Returns an equivalent stream that is parallel.
`S`	`parallel(int maxThreadNum, BaseStream.Splitor splitor, Executor executor)`
`S`	`parallel(int maxThreadNum, Executor executor)`
`static IntStream`	`parallelMerge(Collection<? extends IntStream> c, IntBiFunction<MergeResult> nextSelector)`
`static IntStream`	`parallelMerge(Collection<? extends IntStream> c, IntBiFunction<MergeResult> nextSelector, int maxThreadNum)`
`abstract IntStream`	`prepend(int... a)`
`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 IntStream`	`rangeMap(IntBiPredicate sameRange, IntBinaryOperator mapper)` Note: copied from StreamEx: https://github.com/amaembo/streamex Returns a stream consisting of results of applying the given function to the ranges created from the source elements.
`abstract <T> Stream<T>`	`rangeMapToObj(IntBiPredicate sameRange, IntBiFunction<T> mapper)` Note: copied from StreamEx: https://github.com/amaembo/streamex Returns a stream consisting of results of applying the given function to the ranges created from the source elements.
`abstract u.OptionalInt`	`reduce(IntBinaryOperator op)`
`abstract int`	`reduce(int identity, IntBinaryOperator op)`
`static IntStream`	`repeat(int element, long n)`
`abstract IntStream`	`scan(IntBinaryOperator accumulator)` Returns a `Stream` produced by iterative application of a accumulation function to an initial element `init` and next element of the current stream.
`abstract IntStream`	`scan(int init, IntBinaryOperator accumulator)` Returns a `Stream` produced by iterative application of a accumulation function to an initial element `init` and next element of the current stream.
`abstract IntStream`	`scan(int init, IntBinaryOperator accumulator, boolean initIncluded)`
`S`	`sequential()`
`S`	`shuffled()` This method only run sequentially, even in parallel stream and all elements will be loaded to memory.
`IntStream`	`skipUntil(IntPredicate predicate)`
`Stream<S>`	`sliding(int windowSize)`
`Stream<PL>`	`slidingToList(int windowSize)`
`abstract long`	`sum()`
`abstract IntSummaryStatistics`	`summarize()`
`abstract Pair<IntSummaryStatistics,u.Optional<Map<Percentage,Integer>>>`	`summarizeAndPercentiles()`
`ImmutableList<T>`	`toImmutableList()`
`ImmutableSet<T>`	`toImmutableSet()`
`abstract IntList`	`toIntList()`
`abstract IntStream`	`toJdkStream()`
`abstract <K,A,D> Map<K,D>`	`toMap(IntFunction<? extends K> keyMapper, Collector<Integer,A,D> downstream)`
`abstract <K,A,D,M extends Map<K,D>> M`	`toMap(IntFunction<? extends K> keyMapper, Collector<Integer,A,D> downstream, Supplier<? extends M> mapFactory)`
`abstract <K,V> Map<K,V>`	`toMap(IntFunction<? extends K> keyMapper, IntFunction<? extends V> valueMapper)`
`abstract <K,V> Map<K,V>`	`toMap(IntFunction<? extends K> keyMapper, IntFunction<? extends V> valueMapper, BinaryOperator<V> mergeFunction)`
`abstract <K,V,M extends Map<K,V>> M`	`toMap(IntFunction<? extends K> keyMapper, IntFunction<? extends V> valueMapper, BinaryOperator<V> mergeFunction, Supplier<? extends M> mapFactory)`
`abstract <K,V,M extends Map<K,V>> M`	`toMap(IntFunction<? extends K> keyMapper, IntFunction<? extends V> valueMapper, Supplier<? extends M> mapFactory)`
`abstract IntStream`	`top(int n)` This method only run sequentially, even in parallel stream.
`abstract IntStream`	`top(int n, Comparator<? super Integer> comparator)` This method only run sequentially, even in parallel stream.
`static IntStream`	`zip(Collection<? extends IntStream> c, int[] valuesForNone, IntNFunction<Integer> zipFunction)` Zip together the iterators until all of them runs out of values.
`static IntStream`	`zip(Collection<? extends IntStream> c, IntNFunction<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, IntTernaryOperator 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, IntTernaryOperator zipFunction)` Zip together the "a", "b" and "c" arrays until one of them runs out of values.
`static IntStream`	`zip(int[] a, int[] b, IntBinaryOperator 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, IntBinaryOperator zipFunction)` Zip together the "a" and "b" iterators until all of them runs out of values.
`static IntStream`	`zip(IntIterator a, IntIterator b, IntBinaryOperator 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, IntBinaryOperator 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, IntTernaryOperator 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, IntTernaryOperator zipFunction)` Zip together the "a", "b" and "c" iterators until one of them runs out of values.
`static IntStream`	`zip(IntStream a, IntStream b, IntBinaryOperator 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, IntBinaryOperator 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, IntTernaryOperator 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, IntTernaryOperator zipFunction)` Zip together the "a", "b" and "c" streams until one of them runs out of values.
`abstract IntStream`	`zipWith(IntStream b, IntBinaryOperator zipFunction)`
`abstract IntStream`	`zipWith(IntStream b, int valueForNoneA, int valueForNoneB, IntBinaryOperator zipFunction)`
`abstract IntStream`	`zipWith(IntStream b, IntStream c, int valueForNoneA, int valueForNoneB, int valueForNoneC, IntTernaryOperator zipFunction)`
`abstract IntStream`	`zipWith(IntStream b, IntStream c, IntTernaryOperator 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
acceptIfNotEmpty, append, appendIfEmpty, applyIfNotEmpty, count, difference, distinct, dropWhile, dropWhile, filter, filter, first, indexed, intersection, join, last, limit, onClose, onlyOne, peek, percentiles, prepend, removeIf, removeIf, reversed, reverseSorted, rotated, shuffled, skip, skip, sliding, slidingToList, sorted, split, split, splitAt, splitBy, splitToList, splitToList, step, symmetricDifference, takeWhile, toArray, toCollection, toList, toLongMultiset, toLongMultiset, toMultiset, toMultiset, toSet

Method Detail

skipUntil

@ParallelSupported
 @IntermediateOp
 @Beta
public IntStream skipUntil(IntPredicate predicate)

map

public abstract IntStream map(IntUnaryOperator mapper)

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)

mapToFloat

public abstract FloatStream mapToFloat(IntToFloatFunction mapper)

mapToDouble

public abstract DoubleStream mapToDouble(IntToDoubleFunction mapper)

mapToObj

public abstract <U> Stream<U> mapToObj(IntFunction<? extends U> mapper)

flatMap

public abstract IntStream flatMap(IntFunction<? extends IntStream> mapper)

flattMap

public abstract IntStream flattMap(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)

flattMapToObj

public abstract <T> Stream<T> flattMapToObj(IntFunction<? extends Collection<T>> mapper)

flatMappToObj

public abstract <T> Stream<T> flatMappToObj(IntFunction<T[]> mapper)

rangeMap
```
@SequentialOnly
public abstract IntStream rangeMap(IntBiPredicate sameRange,
                                                    IntBinaryOperator mapper)
```
Note: copied from StreamEx: https://github.com/amaembo/streamex
Returns a stream consisting of results of applying the given function to the ranges created from the source elements. This is a quasi-intermediate partial reduction operation.

Parameters:

sameRange - a non-interfering, stateless predicate to apply to the leftmost and next elements which returns true for elements which belong to the same range.

mapper - a non-interfering, stateless function to apply to the range borders and produce the resulting element. If value was not merged to the interval, then mapper will receive the same value twice, otherwise it will receive the leftmost and the rightmost values which were merged to the range.

Returns:

See Also:

collapse(IntBiPredicate, IntBinaryOperator), Stream.rangeMap(BiPredicate, BiFunction)

rangeMapToObj
```
@SequentialOnly
public abstract <T> Stream<T> rangeMapToObj(IntBiPredicate sameRange,
                                                             IntBiFunction<T> mapper)
```
Note: copied from StreamEx: https://github.com/amaembo/streamex
Returns a stream consisting of results of applying the given function to the ranges created from the source elements. This is a quasi-intermediate partial reduction operation.

Parameters:

sameRange - a non-interfering, stateless predicate to apply to the leftmost and next elements which returns true for elements which belong to the same range.

mapper - a non-interfering, stateless function to apply to the range borders and produce the resulting element. If value was not merged to the interval, then mapper will receive the same value twice, otherwise it will receive the leftmost and the rightmost values which were merged to the range.

Returns:

See Also:

Stream.rangeMap(BiPredicate, BiFunction)

collapse
```
@SequentialOnly
public abstract Stream<IntList> collapse(IntBiPredicate collapsible)
```
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 -

Returns:

collapse
```
@SequentialOnly
public abstract IntStream collapse(IntBiPredicate collapsible,
                                                    IntBinaryOperator 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
```
@SequentialOnly
public abstract IntStream scan(IntBinaryOperator accumulator)
```
Returns a Stream produced by iterative application of a accumulation function to an initial element init and next element of the current stream. Produces a Stream consisting of init, acc(init, value1), acc(acc(init, 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:

scan
```
@SequentialOnly
public abstract IntStream scan(int init,
                                                IntBinaryOperator accumulator)
```
Returns a Stream produced by iterative application of a accumulation function to an initial element init and next element of the current stream. Produces a Stream consisting of init, acc(init, value1), acc(acc(init, value1), value2), etc.
This is an intermediate operation.
Example:
```
 init: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:

init - 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:

scan

@SequentialOnly
public abstract IntStream scan(int init,
                                                IntBinaryOperator accumulator,
                                                boolean initIncluded)

Parameters:: init -; accumulator -; initIncluded -
Returns:

prepend

public abstract IntStream prepend(int... a)

append

public abstract IntStream append(int... a)

appendIfEmpty

public abstract IntStream appendIfEmpty(int... a)

top
```
@SequentialOnly
public abstract IntStream top(int n)
```
This method only run sequentially, even in parallel stream.

Parameters:

n -

Returns:

top

@SequentialOnly
public abstract IntStream top(int n,
                                               Comparator<? super Integer> comparator)

This method only run sequentially, even in parallel stream.

Parameters:: n -; comparator -
Returns:

toIntList
```
public abstract IntList toIntList()
```

toMap

public abstract <K,V> Map<K,V> toMap(IntFunction<? extends K> keyMapper,
                                     IntFunction<? extends V> valueMapper)

Parameters:: keyMapper -; valueMapper -
Returns:
See Also:: Collectors.toMap(Function, Function)

toMap

public abstract <K,V,M extends Map<K,V>> M toMap(IntFunction<? extends K> keyMapper,
                                                 IntFunction<? extends V> valueMapper,
                                                 Supplier<? extends M> mapFactory)

Parameters:: keyMapper -; valueMapper -; mapFactory -
Returns:
See Also:: Collectors.toMap(Function, Function, Supplier)

toMap

public abstract <K,V> Map<K,V> toMap(IntFunction<? extends K> keyMapper,
                                     IntFunction<? extends V> valueMapper,
                                     BinaryOperator<V> mergeFunction)

Parameters:: keyMapper -; valueMapper -; mergeFunction -
Returns:
See Also:: Collectors.toMap(Function, Function, BinaryOperator)

toMap

public abstract <K,V,M extends Map<K,V>> M toMap(IntFunction<? extends K> keyMapper,
                                                 IntFunction<? extends V> valueMapper,
                                                 BinaryOperator<V> mergeFunction,
                                                 Supplier<? extends M> mapFactory)

Parameters:: keyMapper -; valueMapper -; mergeFunction -; mapFactory -
Returns:
See Also:: Collectors.toMap(Function, Function, BinaryOperator, Supplier)

toMap

public abstract <K,A,D> Map<K,D> toMap(IntFunction<? extends K> keyMapper,
                                       Collector<Integer,A,D> downstream)

Parameters:: keyMapper -; downstream -
Returns:
See Also:: Collectors.groupingBy(Function, Collector)

toMap

public abstract <K,A,D,M extends Map<K,D>> M toMap(IntFunction<? extends K> keyMapper,
                                                   Collector<Integer,A,D> downstream,
                                                   Supplier<? extends M> mapFactory)

Parameters:: keyMapper -; downstream -; mapFactory -
Returns:
See Also:: Collectors.groupingBy(Function, Collector, Supplier)

reduce

public abstract int reduce(int identity,
                           IntBinaryOperator op)

reduce

public abstract u.OptionalInt reduce(IntBinaryOperator op)

collect

public abstract <R> R collect(Supplier<R> supplier,
                              ObjIntConsumer<? super R> accumulator,
                              BiConsumer<R,R> combiner)

collect

public abstract <R> R collect(Supplier<R> supplier,
                              ObjIntConsumer<? super R> accumulator)

Parameters:: supplier -; accumulator -
Returns:

forEach

@ParallelSupported
 @TerminalOp
public abstract <E extends Exception> void forEach(Throwables.IntConsumer<E> action)
                                                                              throws E extends Exception

Throws:: E extends Exception

forEachIndexed

@ParallelSupported
 @TerminalOp
public abstract <E extends Exception> void forEachIndexed(Throwables.IndexedIntConsumer<E> action)
                                                                                     throws E extends Exception

Throws:: E extends Exception

anyMatch

public abstract <E extends Exception> boolean anyMatch(Throwables.IntPredicate<E> predicate)
                                                throws E extends Exception

Throws:: E extends Exception

allMatch

public abstract <E extends Exception> boolean allMatch(Throwables.IntPredicate<E> predicate)
                                                throws E extends Exception

Throws:: E extends Exception

noneMatch

public abstract <E extends Exception> boolean noneMatch(Throwables.IntPredicate<E> predicate)
                                                 throws E extends Exception

Throws:: E extends Exception

findFirst

public abstract <E extends Exception> u.OptionalInt findFirst(Throwables.IntPredicate<E> predicate)
                                                       throws E extends Exception

Throws:: E extends Exception

findLast

public abstract <E extends Exception> u.OptionalInt findLast(Throwables.IntPredicate<E> predicate)
                                                      throws E extends Exception

Consider using: stream.reversed().findFirst(predicate) for better performance if possible.

Type Parameters:: E -
Parameters:: predicate -
Returns:
Throws:: E; E extends Exception

findFirstOrLast

public abstract <E extends Exception,E2 extends Exception> u.OptionalInt findFirstOrLast(Throwables.IntPredicate<E> predicateForFirst,
                                                                                         Throwables.IntPredicate<E> predicateForLast)
                                                                                  throws E extends Exception,
                                                                                         E2 extends Exception

Throws:: E extends Exception

findAny

public abstract <E extends Exception> u.OptionalInt findAny(Throwables.IntPredicate<E> predicate)
                                                     throws E extends Exception

Throws:: E extends Exception

min
```
public abstract u.OptionalInt min()
```

max
```
public abstract u.OptionalInt max()
```

kthLargest
```
public abstract u.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()
```

average

public abstract u.OptionalDouble average()

summarize

public abstract IntSummaryStatistics summarize()

summarizeAndPercentiles

public abstract Pair<IntSummaryStatistics,u.Optional<Map<Percentage,Integer>>> summarizeAndPercentiles()

merge

public abstract IntStream merge(IntStream b,
                                IntBiFunction<MergeResult> 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,
                                  IntBinaryOperator zipFunction)

zipWith

public abstract IntStream zipWith(IntStream b,
                                  IntStream c,
                                  IntTernaryOperator zipFunction)

zipWith

public abstract IntStream zipWith(IntStream b,
                                  int valueForNoneA,
                                  int valueForNoneB,
                                  IntBinaryOperator zipFunction)

zipWith

public abstract IntStream zipWith(IntStream b,
                                  IntStream c,
                                  int valueForNoneA,
                                  int valueForNoneB,
                                  int valueForNoneC,
                                  IntTernaryOperator zipFunction)

asLongStream

public abstract LongStream asLongStream()

asFloatStream

public abstract FloatStream asFloatStream()

asDoubleStream

public abstract DoubleStream asDoubleStream()

toJdkStream

public abstract IntStream toJdkStream()

boxed

public abstract Stream<Integer> boxed()

iterator
```
@SequentialOnly
public IntIterator iterator()
```
Remember to close this Stream after the iteration is done, if needed.

Returns:

__

@SequentialOnly
 @IntermediateOp
 @Beta
public <SS extends BaseStream> SS __(Function<? super IntStream,SS> 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(Integer[] a)

of

public static IntStream of(Integer[] a,
                           int startIndex,
                           int endIndex)

of

public static IntStream of(Collection<Integer> c)

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(IntStream stream)

ofCodePoints

public static IntStream ofCodePoints(CharSequence str)

flatten

public static IntStream flatten(int[][] a)

flatten

public static IntStream flatten(int[][] a,
                                boolean vertically)

flatten

public static IntStream flatten(int[][] a,
                                int valueForNone,
                                boolean vertically)

flatten

public static IntStream flatten(int[][][] a)

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(BooleanSupplier hasNext,
                                IntSupplier next)

iterate

public static IntStream iterate(int init,
                                BooleanSupplier hasNext,
                                IntUnaryOperator f)

iterate

public static IntStream iterate(int init,
                                IntPredicate hasNext,
                                IntUnaryOperator f)

Parameters:: init -; hasNext - test if has next by hasNext.test(init) for first time and hasNext.test(f.apply(previous)) for remaining.; f -
Returns:

iterate

public static IntStream iterate(int init,
                                IntUnaryOperator f)

generate

public static IntStream generate(IntSupplier s)

ofIndices

public static <AC> IntStream ofIndices(AC source,
                                       BiFunction<? super AC,Integer,Integer> indexFunc)

Parameters:: source -; indexFunc -
Returns:
See Also:: ofIndices(Object, int, int, BiFunction)

ofIndices

public static <AC> IntStream ofIndices(AC source,
                                       int fromIndex,
                                       BiFunction<? super AC,Integer,Integer> indexFunc)

Parameters:: source -; fromIndex -; indexFunc -
Returns:
See Also:: ofIndices(Object, int, int, BiFunction)

ofIndices

public static <AC> IntStream ofIndices(AC source,
                                       int fromIndex,
                                       int increment,
                                       BiFunction<? super AC,Integer,Integer> indexFunc)

 
 // Forwards:
 int[] a = {1, 2, 3, 2, 5, 1};
 IntStream.ofIndices(a, N::indexOf).println(); // [0, 5]
 IntStream.ofIndices(a, 1, N::indexOf).println(); // [5]

 // Backwards
 IntStream.ofIndices(a, 5, -1, N::lastIndexOf).println(); // [5, 0]
 IntStream.ofIndices(a, 4, -1, N::lastIndexOf).println(); // [0]

 // OR
 // Forwards:
 int[] source = { 1, 2, 3, 1, 2, 1 };
 int[] targetSubArray = { 1, 2 };
 IntStream.ofIndices(source, (a, fromIndex) -> Index.ofSubArray(a, fromIndex, targetSubArray, 0, targetSubArray.length).orElse(-1)).println(); // [0, 3]

 // Backwards
 IntStream.ofIndices(source, 5, -2, (a, fromIndex) -> Index.ofSubArray(a, fromIndex, targetSubArray, 0, targetSubArray.length).orElse(-1))
                    .println(); // [3, 0]

Parameters:: source -; fromIndex -; increment -; indexFunc -
Returns:
See Also:: ofIndices(Object, int, int, BiFunction)

ofIndices

public static <AC> IntStream ofIndices(AC source,
                                       int fromIndex,
                                       int increment,
                                       int sourceLen,
                                       BiFunction<? super AC,Integer,Integer> indexFunc)

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(Collection<? extends IntStream> c)

zip
```
public static IntStream zip(int[] a,
                            int[] b,
                            IntBinaryOperator 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,
                            IntTernaryOperator 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 -; c -
Returns:

zip

public static IntStream zip(IntIterator a,
                            IntIterator b,
                            IntBinaryOperator 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,
                            IntTernaryOperator 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,
                            IntBinaryOperator 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,
                            IntTernaryOperator 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(Collection<? extends IntStream> c,
                            IntNFunction<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,
                            IntBinaryOperator 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,
                            IntTernaryOperator 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,
                            IntBinaryOperator 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,
                            IntTernaryOperator 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,
                            IntBinaryOperator 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,
                            IntTernaryOperator 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(Collection<? extends IntStream> c,
                            int[] valuesForNone,
                            IntNFunction<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<MergeResult> 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<MergeResult> 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<MergeResult> 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<MergeResult> 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<MergeResult> 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<MergeResult> 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(Collection<? extends IntStream> c,
                              IntBiFunction<MergeResult> 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(Collection<? extends IntStream> c,
                                      IntBiFunction<MergeResult> 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(Collection<? extends IntStream> c,
                                      IntBiFunction<MergeResult> 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,ITER,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,ITER,S>>

Returns:

See Also:

BaseStream.peek(Object)

sliding
```
public Stream<S> sliding(int windowSize)
```
Specified by:

sliding in interface BaseStream<T,A,P,C,PL,OT,IT,ITER,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,ITER,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,ITER,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,ITER,S>>

Returns:

See Also:

BaseStream.sliding(int, int)

shuffled
```
public S shuffled()
```
Description copied from interface: BaseStream

This method only run sequentially, even in parallel stream and all elements will be loaded to memory.

Specified by:

shuffled in interface BaseStream<T,A,P,C,PL,OT,IT,ITER,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,ITER,S>>

Returns:

toImmutableList
```
public ImmutableList<T> toImmutableList()
```
Specified by:

toImmutableList in interface BaseStream<T,A,P,C,PL,OT,IT,ITER,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,ITER,S>>

toImmutableSet
```
public ImmutableSet<T> toImmutableSet()
```
Specified by:

toImmutableSet in interface BaseStream<T,A,P,C,PL,OT,IT,ITER,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,ITER,S>>

join
```
public String join(CharSequence delimiter)
```
Specified by:

join in interface BaseStream<T,A,P,C,PL,OT,IT,ITER,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,ITER,S>>

println
```
public void println()
```
Specified by:

println in interface BaseStream<T,A,P,C,PL,OT,IT,ITER,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,ITER,S>>

isParallel
```
public boolean isParallel()
```
Specified by:

isParallel in interface BaseStream<T,A,P,C,PL,OT,IT,ITER,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,ITER,S>>

Returns:

sequential
```
public S sequential()
```
Specified by:

sequential in interface BaseStream<T,A,P,C,PL,OT,IT,ITER,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,ITER,S>>

Returns:

parallel
```
public S parallel()
```
Specified by:

parallel in interface BaseStream<T,A,P,C,PL,OT,IT,ITER,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,ITER,S>>

Returns:

parallel
```
public S parallel(int maxThreadNum)
```
Specified by:

parallel in interface BaseStream<T,A,P,C,PL,OT,IT,ITER,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,ITER,S>>

Returns:

parallel
```
public S parallel(BaseStream.Splitor splitor)
```
Specified by:

parallel in interface BaseStream<T,A,P,C,PL,OT,IT,ITER,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,ITER,S>>

Returns:

parallel

public S parallel(int maxThreadNum,
                  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 maxThreadNum and splitor as the specified ones.

When to use parallel Streams?

First of all, do NOT and should NOT use parallel Streams if you don't have any problem with sequential Streams, because using parallel Streams has extra cost.
Consider using parallel Streams only when N(the number of elements) * Q(cost per element of F, the per-element function (usually a lambda)) is big enough(e.g. IO involved. Network: DB/web service request..., Reading/Writing file...).
It's easy to test out the differences of performance by sequential Streams and parallel Streams with Profiler:

 
 Profiler.run(1, 1, 3, "sequential", () -> Stream.of(list).operation(F)...).printResult();
 Profiler.run(1, 1, 3, "parallel", () -> Stream.of(list).parallel().operation(F)...).printResult();

Here is a sample performance test with computer: CPU Intel i7-3520M 4-cores 2.9 GHz, JDK 1.8.0_101, Windows 7:

 
 public void test_perf() {
     final String[] strs = new String[10_000];
     N.fill(strs, N.uuid());

     final int m = 1;
     final Function mapper = str -> {
         long result = 0;
         for (int i = 0; i < m; i++) {
             result += sum(str.toCharArray()) + 1;
         }
         return result;
     };

     final MutableLong sum = MutableLong.of(0);

     for (int i = 0, len = strs.length; i < len; i++) {
         sum.add(mapper.apply(strs[i]));
     }

     final int threadNum = 1, loopNum = 100, roundNum = 3;

     Profiler.run(threadNum, loopNum, roundNum, "For Loop", () -> {
         long result = 0;
         for (int i = 0, len = strs.length; i < len; i++) {
             result += mapper.apply(strs[i]);
         }
         assertEquals(sum.longValue(), result);
     }).printResult();

     Profiler.run(threadNum, loopNum, roundNum, "JDK Sequential",
             () -> assertEquals(sum.longValue(), java.util.stream.Stream.of(strs).map(mapper).mapToLong(e -> e).sum())).printResult();

     Profiler.run(threadNum, loopNum, roundNum, "JDK Parallel",
             () -> assertEquals(sum.longValue(), java.util.stream.Stream.of(strs).parallel().map(mapper).mapToLong(e -> e).sum())).printResult();

     Profiler.run(threadNum, loopNum, roundNum, "Abcus Sequential",
             () -> assertEquals(sum.longValue(), Stream.of(strs).map(mapper).mapToLong(e -> e).sum().longValue())).printResult();

     Profiler.run(threadNum, loopNum, roundNum, "Abcus Parallel",
             () -> assertEquals(sum.longValue(), Stream.of(strs).parallel().map(mapper).mapToLong(e -> e).sum().longValue())).printResult();
 }

And test result: Unit is milliseconds. N(the number of elements) is 10_000, Q(cost per element of F, the per-element function (usually a lambda), here is mapper) is calculated by: value of 'For loop' / N(10_000).

	m = 1	m = 10	m = 50	m = 100	m = 500	m = 1000
Q	0.00002	0.0002	0.001	0.002	0.01	0.02
For Loop	0.23	2.3	11	22	110	219
JDK Sequential	0.28	2.3	11	22	114	212
JDK Parallel	0.22	1.3	6	12	66	122
Abcus Sequential	0.3	2	11	22	112	212
Abcus Parallel	11	11	11	16	77	128

Comparison:

Again, do NOT and should NOT use parallel Streams if you don't have any performance problem with sequential Streams, because using parallel Streams has extra cost.
Again, consider using parallel Streams only when N(the number of elements) * Q(cost per element of F, the per-element function (usually a lambda)) is big enough.
The implementation of parallel Streams in Abacus is more than 10 times, slower than parallel Streams in JDK when Q is tiny(here is less than 0.0002 milliseconds by the test):

The implementation of parallel Streams in JDK 8 still can beat the sequential/for loop when Q is tiny(Here is 0.00002 milliseconds by the test). That's amazing, considering the extra cost brought by parallel computation. It's well done.
The implementation of parallel Streams in Abacus is pretty simple and straight forward. The extra cost(starting threads/synchronization/queue...) brought by parallel Streams in Abacus is too bigger to tiny Q(Here is less than 0.001 milliseconds by the test). But it starts to be faster than sequential Streams when Q is big enough(Here is 0.001 milliseconds by the test) and starts to catch the parallel Streams in JDK when Q is bigger(Here is 0.01 milliseconds by the test).
Consider using the parallel Streams in Abacus when Q is big enough, specially when IO involved in F. Because one IO operation(e.g. DB/web service request..., Reading/Writing file...) usually takes 1 to 1000 milliseconds, or even longer. By the parallel Streams APIs in Abacus, it's very simple to specify max thread numbers. Sometimes, it's much faster to execute IO/Network requests with a bit more threads. It's fair to say that the parallel Streams in Abacus is high efficient, may same as or faster than the parallel Streams in JDK when Q is big enough, except F is heavy cpu-used operation. Most of the times, the Q is big enough to consider using parallel Stream is because IO/Network is involved in F.

JDK 7 is supported by the Streams in Abacus. It's perfect to work with retrolambda on Android
All primitive types are supported by Stream APIs in Abacus except boolean

A bit more about Lambdas/Stream APIs, you may heard that Lambdas/Stream APIs is 5 time slower than imperative programming. It's true when Q and F is VERY, VERY tiny, like f = (int a, int b) -> a + b;. But if we look into the samples in the article and think about it: it just takes less than 1 milliseconds to get the max value in 100k numbers. There is potential performance issue only if the "get the max value in 100K numbers" call many, many times in your API or single request. Otherwise, the difference between 0.1 milliseconds to 0.5 milliseconds can be totally ignored. Usually we meet performance issue only if Q and F is big enough. However, the performance of Lambdas/Streams APIs is closed to for loop when Q and F is big enough. No matter in which scenario, We don't need and should not concern the performance of Lambdas/Stream APIs.

Although it's is parallel Streams, it doesn't means all the methods are executed in parallel. Because the sequential way is as fast, or even faster than the parallel way for some methods, or is pretty difficult, if not possible, to implement the method by parallel approach. Here are the methods which are executed sequentially even in parallel Streams.

splitXXX/splitAt/splitBy/slidingXXX/collapse, distinct, reverse, rotate, shuffle, indexed, cached, top, kthLargest, count, toArray, toList, toList, toSet, toMultiset, toLongMultiset, intersection(Collection c), difference(Collection c), symmetricDifference(Collection c), forEach(identity, accumulator, predicate), findFirstOrLast, findFirstAndLast

Specified by:

parallel in interface BaseStream<T,A,P,C,PL,OT,IT,ITER,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,ITER,S>>

Parameters:

maxThreadNum - Default value is the number of cpu-cores. Steps/operations will be executed sequentially if maxThreadNum is 1.

splitor - The target array is split by ranges for multiple threads if splitor is splitor.ARRAY and target stream composed by array. It looks like:


 for (int i = 0; i < maxThreadNum; i++) {
     final int sliceIndex = i;

     futureList.add(asyncExecutor.execute(new Runnable() {
         public void run() {
             int cursor = fromIndex + sliceIndex * sliceSize;
             final int to = toIndex - cursor > sliceSize ? cursor + sliceSize : toIndex;
             while (cursor < to) {
                 action.accept(elements[cursor++]);
             }
        }
    }));
 }

Otherwise, each thread will get the elements from the target array/iterator in the stream one by one with the target array/iterator synchronized. It looks like:


 for (int i = 0; i < maxThreadNum; i++) {
     futureList.add(asyncExecutor.execute(new Runnable() {
         public void run() {
             T next = null;

             while (true) {
                 synchronized (elements) {
                     if (cursor.intValue() < toIndex) {
                         next = elements[cursor.getAndIncrement()];
                     } else {
                         break;
                     }
                 }

                 action.accept(next);
             }
         }
     }));
 }

Using splitor.ARRAY only when F (the per-element function (usually a lambda)) is very tiny and the cost of synchronization on the target array/iterator is too big to it. For the F involving IO or taking 'long' to complete, choose splitor.ITERATOR. Default value is splitor.ITERATOR.

Returns:

See Also:

MergeResult, com.landawn.abacus.util.Profiler#run(int, int, int, String, Runnable), Understanding Parallel Stream Performance in Java SE 8, When to use parallel Streams

parallel
```
public S parallel(int maxThreadNum,
                  BaseStream.Splitor splitor,
                  Executor executor)
```
Specified by:

parallel in interface BaseStream<T,A,P,C,PL,OT,IT,ITER,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,ITER,S>>

executor - should be able to execute maxThreadNum * following up operations in parallel.

Returns:

parallel
```
public S parallel(int maxThreadNum,
                  Executor executor)
```
Specified by:

parallel in interface BaseStream<T,A,P,C,PL,OT,IT,ITER,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,ITER,S>>

executor - should be able to execute maxThreadNum * following up operations in parallel.

Returns:

parallel
```
public S parallel(Executor executor)
```
Specified by:

parallel in interface BaseStream<T,A,P,C,PL,OT,IT,ITER,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,ITER,S>>

Parameters:

executor - should be able to execute maxThreadNum * following up operations in parallel.

Returns:

close
```
public void close()
```
Specified by:

close in interface BaseStream<T,A,P,C,PL,OT,IT,ITER,S extends com.landawn.abacus.util.stream.StreamBase<T,A,P,C,PL,OT,IT,ITER,S>>

Specified by:

close in interface AutoCloseable

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

skipUntil

map

mapToChar

mapToByte

mapToShort

mapToLong

mapToFloat

mapToDouble

mapToObj

flatMap

flattMap

flatMapToChar

flatMapToByte

flatMapToShort

flatMapToLong

flatMapToFloat

flatMapToDouble

flatMapToObj

flattMapToObj

flatMappToObj

rangeMap

rangeMapToObj

collapse

collapse

scan

scan

scan

prepend

append

appendIfEmpty

top

top

toIntList

toMap

toMap

toMap

toMap

toMap

toMap

reduce

reduce

collect

collect

forEach

forEachIndexed

anyMatch

allMatch

noneMatch

findFirst

findLast

findFirstOrLast

findAny

min

max

kthLargest

sum

average

summarize

summarizeAndPercentiles

merge

zipWith

zipWith

zipWith

zipWith

asLongStream

asFloatStream

asDoubleStream

toJdkStream

boxed

iterator

__

empty

of