Uses of Annotation Interface
com.landawn.abacus.annotation.IntermediateOp
-
Uses of IntermediateOp in com.landawn.abacus.util
Modifier and TypeMethodDescription<TT,
EE extends Exception>
ExceptionalStream<TT,EE> ExceptionalStream.__
(Function<? super ExceptionalStream<T, E>, ExceptionalStream<TT, EE>> transfer) ExceptionalStream.append
(ExceptionalStream<T, E> s) ExceptionalStream.append
(Collection<? extends T> c) final ExceptionalStream<T,
E> ExceptionalStream.appendIfEmpty
(Throwables.Supplier<? extends ExceptionalStream<T, E>, ? extends E> supplier) Append if empty.ExceptionalStream.appendIfEmpty
(Collection<? extends T> c) final ExceptionalStream<T,
E> ExceptionalStream.appendIfEmpty
(T... a) ExceptionalStream.cast()
ExceptionalStream.collapse
(Throwables.BiPredicate<? super T, ? super T, ? extends E> collapsible) ExceptionalStream.collapse
(Throwables.BiPredicate<? super T, ? super T, ? extends E> collapsible, Throwables.BiFunction<? super T, ? super T, T, ? extends E> mergeFunction) Merge series of adjacent elements which satisfy the given predicate using the merger function and return a new stream.<R> ExceptionalStream<R,
E> ExceptionalStream.collapse
(Throwables.BiPredicate<? super T, ? super T, ? extends E> collapsible, Throwables.Supplier<R, E> supplier, Throwables.BiConsumer<? super R, ? super T, ? extends E> accumulator) <C extends Collection<T>>
ExceptionalStream<C,E> ExceptionalStream.collapse
(Throwables.BiPredicate<? super T, ? super T, ? extends E> collapsible, Supplier<? extends C> supplier) <R,
A> ExceptionalStream<R, E> ExceptionalStream.collapse
(Throwables.BiPredicate<? super T, ? super T, ? extends E> collapsible, Collector<? super T, A, R> collector) <U> ExceptionalStream<U,
E> ExceptionalStream.collapse
(Throwables.BiPredicate<? super T, ? super T, ? extends E> collapsible, U init, Throwables.BiFunction<U, ? super T, U, ? extends E> op) ExceptionalStream.collapse
(Throwables.TriPredicate<? super T, ? super T, ? super T, ? extends E> collapsible) ExceptionalStream.collapse
(Throwables.TriPredicate<? super T, ? super T, ? super T, ? extends E> collapsible, Throwables.BiFunction<? super T, ? super T, T, ? extends E> mergeFunction) Merge series of adjacent elements which satisfy the given predicate using the merger function and return a new stream.<R> ExceptionalStream<R,
E> ExceptionalStream.collapse
(Throwables.TriPredicate<? super T, ? super T, ? super T, ? extends E> collapsible, Throwables.Supplier<R, E> supplier, Throwables.BiConsumer<? super R, ? super T, ? extends E> accumulator) <C extends Collection<T>>
ExceptionalStream<C,E> ExceptionalStream.collapse
(Throwables.TriPredicate<? super T, ? super T, ? super T, ? extends E> collapsible, Supplier<? extends C> supplier) <R,
A> ExceptionalStream<R, E> ExceptionalStream.collapse
(Throwables.TriPredicate<? super T, ? super T, ? super T, ? extends E> collapsible, Collector<? super T, A, R> collector) Merge series of adjacent elements which satisfy the given predicate using the merger function and return a new stream.<U> ExceptionalStream<U,
E> ExceptionalStream.collapse
(Throwables.TriPredicate<? super T, ? super T, ? super T, ? extends E> collapsible, U init, Throwables.BiFunction<U, ? super T, U, ? extends E> op) <K> ExceptionalStream<Map.Entry<K,
Integer>, E> ExceptionalStream.countBy
(Throwables.Function<? super T, ? extends K, ? extends E> keyMapper) ExceptionalStream.cycled()
ExceptionalStream.cycled
(long times) final ExceptionalStream<T,
E> ExceptionalStream.defaultIfEmpty
(Throwables.Supplier<? extends ExceptionalStream<T, E>, ? extends E> supplier) final ExceptionalStream<T,
E> ExceptionalStream.defaultIfEmpty
(T defaultValue) ExceptionalStream.distinct()
Distinct and filter by occurrences.ExceptionalStream.distinct
(Throwables.BinaryOperator<T, ? extends E> mergeFunction) Distinct and filter by occurrences.ExceptionalStream.distinct
(Throwables.Predicate<? super Long, ? extends E> occurrencesFilter) Distinct and filter by occurrences.<K> ExceptionalStream<T,
E> ExceptionalStream.distinctBy
(Throwables.Function<? super T, K, ? extends E> keyMapper) Distinct by the value mapped fromkeyMapper
.<K> ExceptionalStream<T,
E> ExceptionalStream.distinctBy
(Throwables.Function<? super T, K, ? extends E> keyMapper, Throwables.BinaryOperator<T, ? extends E> mergeFunction) Distinct and filter by occurrences.<K> ExceptionalStream<T,
E> ExceptionalStream.distinctBy
(Throwables.Function<? super T, K, ? extends E> keyMapper, Throwables.Predicate<? super Long, ? extends E> occurrencesFilter) Distinct and filter by occurrences.ExceptionalStream.dropWhile
(Throwables.Predicate<? super T, ? extends E> predicate) ExceptionalStream.dropWhile
(Throwables.Predicate<? super T, ? extends E> predicate, Throwables.Consumer<? super T, ? extends E> actionOnDroppedItem) ExceptionalStream.filter
(Throwables.Predicate<? super T, ? extends E> predicate) ExceptionalStream.filter
(Throwables.Predicate<? super T, ? extends E> predicate, Throwables.Consumer<? super T, ? extends E> actionOnDroppedItem) ExceptionalStream.filterE
(Throwables.Predicate<? super T, ? extends Exception> predicate) <R> ExceptionalStream<R,
E> ExceptionalStream.flatmap
(Throwables.Function<? super T, ? extends Collection<? extends R>, ? extends E> mapper) <R> ExceptionalStream<R,
E> ExceptionalStream.flatMap
(Throwables.Function<? super T, ? extends ExceptionalStream<? extends R, ? extends E>, ? extends E> mapper) <R> ExceptionalStream<R,
Exception> ExceptionalStream.flatmapE
(Throwables.Function<? super T, ? extends Collection<? extends R>, ? extends Exception> mapper) <R> ExceptionalStream<R,
Exception> ExceptionalStream.flatMapE
(Throwables.Function<? super T, ? extends ExceptionalStream<? extends R, ? extends Exception>, ? extends Exception> mapper) <R> ExceptionalStream<R,
E> ExceptionalStream.flatMapIfNotNull
(Throwables.Function<? super T, ? extends Collection<? extends R>, ? extends E> mapper) <U,
R> ExceptionalStream<R, E> ExceptionalStream.flatMapIfNotNull
(Throwables.Function<? super T, ? extends Collection<? extends U>, ? extends E> mapper, Throwables.Function<? super U, ? extends Collection<? extends R>, ? extends E> mapper2) <R> ExceptionalStream<R,
E> ExceptionalStream.flatMapp
(Throwables.Function<? super T, ? extends Stream<? extends R>, ? extends E> mapper) ExceptionalStream.flatMapToBoolean
(Throwables.Function<? super T, boolean[], ? extends E> mapper) ExceptionalStream.flatMapToByte
(Throwables.Function<? super T, byte[], ? extends E> mapper) ExceptionalStream.flatMapToChar
(Throwables.Function<? super T, char[], ? extends E> mapper) ExceptionalStream.flatMapToDouble
(Throwables.Function<? super T, double[], ? extends E> mapper) ExceptionalStream.flatMapToFloat
(Throwables.Function<? super T, float[], ? extends E> mapper) ExceptionalStream.flatMapToInteger
(Throwables.Function<? super T, int[], ? extends E> mapper) ExceptionalStream.flatMapToLong
(Throwables.Function<? super T, long[], ? extends E> mapper) ExceptionalStream.flatMapToShort
(Throwables.Function<? super T, short[], ? extends E> mapper) <R> ExceptionalStream<R,
E> ExceptionalStream.flattMap
(Throwables.Function<? super T, R[], ? extends E> mapper) <K> ExceptionalStream<Map.Entry<K,
List<T>>, E> ExceptionalStream.groupBy
(Throwables.Function<? super T, ? extends K, ? extends E> keyMapper) <K,
V> ExceptionalStream<Map.Entry<K, List<V>>, E> ExceptionalStream.groupBy
(Throwables.Function<? super T, ? extends K, ? extends E> keyMapper, Throwables.Function<? super T, ? extends V, ? extends E> valueMapper) <K,
V> ExceptionalStream<Map.Entry<K, V>, E> ExceptionalStream.groupBy
(Throwables.Function<? super T, ? extends K, ? extends E> keyMapper, Throwables.Function<? super T, ? extends V, ? extends E> valueMapper, Throwables.BinaryOperator<V, ? extends E> mergeFunction) <K,
V> ExceptionalStream<Map.Entry<K, V>, E> ExceptionalStream.groupBy
(Throwables.Function<? super T, ? extends K, ? extends E> keyMapper, Throwables.Function<? super T, ? extends V, ? extends E> valueMapper, Throwables.BinaryOperator<V, ? extends E> mergeFunction, Supplier<? extends Map<K, V>> mapFactory) <K,
V> ExceptionalStream<Map.Entry<K, List<V>>, E> ExceptionalStream.groupBy
(Throwables.Function<? super T, ? extends K, ? extends E> keyMapper, Throwables.Function<? super T, ? extends V, ? extends E> valueMapper, Supplier<? extends Map<K, List<V>>> mapFactory) <K,
V, A, D> ExceptionalStream<Map.Entry<K, D>, E> ExceptionalStream.groupBy
(Throwables.Function<? super T, ? extends K, ? extends E> keyMapper, Throwables.Function<? super T, ? extends V, ? extends E> valueMapper, Collector<? super V, A, D> downstream) <K,
V, A, D> ExceptionalStream<Map.Entry<K, D>, E> ExceptionalStream.groupBy
(Throwables.Function<? super T, ? extends K, ? extends E> keyMapper, Throwables.Function<? super T, ? extends V, ? extends E> valueMapper, Collector<? super V, A, D> downstream, Supplier<? extends Map<K, D>> mapFactory) <K> ExceptionalStream<Map.Entry<K,
List<T>>, E> ExceptionalStream.groupBy
(Throwables.Function<? super T, ? extends K, ? extends E> keyMapper, Supplier<? extends Map<K, List<T>>> mapFactory) <K,
A, D> ExceptionalStream<Map.Entry<K, D>, E> ExceptionalStream.groupBy
(Throwables.Function<? super T, ? extends K, ? extends E> keyMapper, Collector<? super T, A, D> downstream) <K,
A, D> ExceptionalStream<Map.Entry<K, D>, E> ExceptionalStream.groupBy
(Throwables.Function<? super T, ? extends K, ? extends E> keyMapper, Collector<? super T, A, D> downstream, Supplier<? extends Map<K, D>> mapFactory) ExceptionalStream.indexed()
ExceptionalStream.intersperse
(T delimiter) ExceptionalStream.last
(int n) A queue with size up ton
will be maintained to filter out the lastn
elements.ExceptionalStream.limit
(long maxSize) <R> ExceptionalStream<R,
E> ExceptionalStream.map
(Throwables.Function<? super T, ? extends R, ? extends E> mapper) <U> ExceptionalStream<U,
Exception> ExceptionalStream.mapE
(Throwables.Function<? super T, ? extends U, ? extends Exception> mapper) ExceptionalStream.mapFirst
(Throwables.Function<? super T, ? extends T, ? extends E> mapperForFirst) <R> ExceptionalStream<R,
E> ExceptionalStream.mapFirstOrElse
(Throwables.Function<? super T, ? extends R, E> mapperForFirst, Throwables.Function<? super T, ? extends R, E> mapperForElse) ExceptionalStream.mapLast
(Throwables.Function<? super T, ? extends T, ? extends E> mapperForLast) <R> ExceptionalStream<R,
E> ExceptionalStream.mapLastOrElse
(Throwables.Function<? super T, ? extends R, E> mapperForLast, Throwables.Function<? super T, ? extends R, E> mapperForElse) <R> ExceptionalStream<R,
E> ExceptionalStream.mapPartial
(Throwables.Function<? super T, u.Optional<? extends R>, E> mapper) Note: copied from StreamEx: https://github.com/amaembo/streamex<R> ExceptionalStream<R,
E> ExceptionalStream.mapPartialJdk
(Throwables.Function<? super T, Optional<? extends R>, E> mapper) Note: copied from StreamEx: https://github.com/amaembo/streamexExceptionalStream.mapPartialToDouble
(Throwables.Function<? super T, u.OptionalDouble, E> mapper) Note: copied from StreamEx: https://github.com/amaembo/streamexExceptionalStream.mapPartialToDoubleJdk
(Throwables.Function<? super T, OptionalDouble, E> mapper) Note: copied from StreamEx: https://github.com/amaembo/streamexExceptionalStream.mapPartialToInt
(Throwables.Function<? super T, u.OptionalInt, E> mapper) Note: copied from StreamEx: https://github.com/amaembo/streamexExceptionalStream.mapPartialToIntJdk
(Throwables.Function<? super T, OptionalInt, E> mapper) Note: copied from StreamEx: https://github.com/amaembo/streamexExceptionalStream.mapPartialToLong
(Throwables.Function<? super T, u.OptionalLong, E> mapper) Note: copied from StreamEx: https://github.com/amaembo/streamexExceptionalStream.mapPartialToLongJdk
(Throwables.Function<? super T, OptionalLong, E> mapper) Note: copied from StreamEx: https://github.com/amaembo/streamexExceptionalStream.mergeWith
(ExceptionalStream<? extends T, E> b, Throwables.BiFunction<? super T, ? super T, MergeResult, E> nextSelector) ExceptionalStream.mergeWith
(Collection<? extends T> b, Throwables.BiFunction<? super T, ? super T, MergeResult, E> nextSelector) ExceptionalStream.onClose
(Throwables.Runnable<? extends E> closeHandler) ExceptionalStream.onEach
(Throwables.Consumer<? super T, ? extends E> action) ExceptionalStream.onEachE
(Throwables.Consumer<? super T, ? extends Exception> action) ExceptionalStream.partitionBy
(Throwables.Predicate<? super T, E> predicate) <A,
D> ExceptionalStream<Map.Entry<Boolean, D>, E> ExceptionalStream.partitionBy
(Throwables.Predicate<? super T, E> predicate, Collector<? super T, A, D> downstream) ExceptionalStream.peek
(Throwables.Consumer<? super T, ? extends E> action) ExceptionalStream.peekFirst
(Throwables.Consumer<? super T, ? extends E> action) ExceptionalStream.peekIf
(Throwables.BiPredicate<? super T, ? super Long, E> predicate, Consumer<? super T> action) ExceptionalStream.peekIf
(Throwables.Predicate<? super T, E> predicate, Throwables.Consumer<? super T, E> action) ExceptionalStream.peekLast
(Throwables.Consumer<? super T, ? extends E> action) ExceptionalStream.prepend
(ExceptionalStream<T, E> s) ExceptionalStream.prepend
(Collection<? extends T> c) final ExceptionalStream<T,
E> ExceptionalStream.rateLimited
(double permitsPerSecond) ExceptionalStream.rateLimited
(RateLimiter rateLimiter) ExceptionalStream.reversed()
ExceptionalStream.reverseSorted()
ExceptionalStream.reverseSorted
(Comparator<? super T> comparator) ExceptionalStream.rotated
(int distance) <U> ExceptionalStream<U,
E> ExceptionalStream.scan
(U init, Throwables.BiFunction<U, ? super T, U, ? extends E> accumulator) <U> ExceptionalStream<U,
E> ExceptionalStream.scan
(U init, Throwables.BiFunction<U, ? super T, U, ? extends E> accumulator, boolean initIncluded) ExceptionalStream.shuffled()
ExceptionalStream.skip
(long n) ExceptionalStream.skipLast
(int n) ExceptionalStream.skipNull()
ExceptionalStream.skipUntil
(Throwables.Predicate<? super T, ? extends E> predicate) ExceptionalStream.sliding
(int windowSize, int increment) <C extends Collection<T>>
ExceptionalStream<C,E> ExceptionalStream.sliding
(int windowSize, int increment, IntFunction<? extends C> collectionSupplier) <A,
R> ExceptionalStream<R, E> <R> ExceptionalStream<R,
E> ExceptionalStream.slidingMap
(Throwables.BiFunction<? super T, ? super T, R, ? extends E> mapper) <R> ExceptionalStream<R,
E> ExceptionalStream.slidingMap
(Throwables.BiFunction<? super T, ? super T, R, ? extends E> mapper, int increment) <R> ExceptionalStream<R,
E> ExceptionalStream.slidingMap
(Throwables.BiFunction<? super T, ? super T, R, ? extends E> mapper, int increment, boolean ignoreNotPaired) <R> ExceptionalStream<R,
E> ExceptionalStream.slidingMap
(Throwables.TriFunction<? super T, ? super T, ? super T, R, ? extends E> mapper) <R> ExceptionalStream<R,
E> ExceptionalStream.slidingMap
(Throwables.TriFunction<? super T, ? super T, ? super T, R, ? extends E> mapper, int increment) <R> ExceptionalStream<R,
E> ExceptionalStream.slidingMap
(Throwables.TriFunction<? super T, ? super T, ? super T, R, ? extends E> mapper, int increment, boolean ignoreNotPaired) ExceptionalStream.slidingToList
(int windowSize, int increment) Sliding to list.ExceptionalStream.slidingToSet
(int windowSize, int increment) Sliding to set.ExceptionalStream.sorted()
ExceptionalStream.sorted
(Comparator<? super T> comparator) ExceptionalStream.sortedBy
(Function<? super T, ? extends Comparable> keyMapper) ExceptionalStream.split
(int chunkSize) <C extends Collection<T>>
ExceptionalStream<C,E> ExceptionalStream.split
(int chunkSize, IntFunction<? extends C> collectionSupplier) Returns ExceptionalStream ofC
with consecutive sub sequences of the elements, each of the same size (the final sequence may be smaller).<R,
A> ExceptionalStream<R, E> ExceptionalStream.splitAt
(int where) ExceptionalStream.splitAt
(Throwables.Predicate<? super T, ? extends E> where) ExceptionalStream.splitToList
(int chunkSize) Returns ExceptionalStream ofList<T>
with consecutive sub sequences of the elements, each of the same size (the final sequence may be smaller).ExceptionalStream.splitToSet
(int chunkSize) Returns ExceptionalStream ofSet<T>
with consecutive sub sequences of the elements, each of the same size (the final sequence may be smaller).<R> ExceptionalStream<R,
E> ExceptionalStream.sps
(int maxThreadNum, Function<? super Stream<T>, ? extends Stream<? extends R>> ops) Temporarily switch the stream to parallel stream for operationops
and then switch back to sequence stream.<R> ExceptionalStream<R,
E> Temporarily switch the stream to parallel stream for operationops
and then switch back to sequence stream.ExceptionalStream.spsFilter
(int maxThreadNum, Throwables.Predicate<? super T, E> predicate) Temporarily switch the stream to parallel stream for operationfilter
and then switch back to sequence stream.ExceptionalStream.spsFilter
(Throwables.Predicate<? super T, E> predicate) Temporarily switch the stream to parallel stream for operationfilter
and then switch back to sequence stream.ExceptionalStream.spsFilterE
(int maxThreadNum, Throwables.Predicate<? super T, ? extends Exception> predicate) Temporarily switch the stream to parallel stream for operationfilter
and then switch back to sequence stream.ExceptionalStream.spsFilterE
(Throwables.Predicate<? super T, ? extends Exception> predicate) Temporarily switch the stream to parallel stream for operationfilter
and then switch back to sequence stream.<R> ExceptionalStream<R,
E> ExceptionalStream.spsFlatmap
(int maxThreadNum, Throwables.Function<? super T, ? extends Collection<? extends R>, E> mapper) Temporarily switch the stream to parallel stream for operationflatMap
and then switch back to sequence stream.<R> ExceptionalStream<R,
E> ExceptionalStream.spsFlatmap
(Throwables.Function<? super T, ? extends Collection<? extends R>, E> mapper) Temporarily switch the stream to parallel stream for operationflatMap
and then switch back to sequence stream.<R> ExceptionalStream<R,
E> ExceptionalStream.spsFlatMap
(int maxThreadNum, Throwables.Function<? super T, ? extends Stream<? extends R>, E> mapper) Temporarily switch the stream to parallel stream for operationflatMap
and then switch back to sequence stream.<R> ExceptionalStream<R,
E> ExceptionalStream.spsFlatMap
(Throwables.Function<? super T, ? extends Stream<? extends R>, E> mapper) Temporarily switch the stream to parallel stream for operationflatMap
and then switch back to sequence stream.<R> ExceptionalStream<R,
Exception> ExceptionalStream.spsFlatmapE
(int maxThreadNum, Throwables.Function<? super T, ? extends Collection<? extends R>, ? extends Exception> mapper) Temporarily switch the stream to parallel stream for operationflatMap
and then switch back to sequence stream.<R> ExceptionalStream<R,
Exception> ExceptionalStream.spsFlatmapE
(Throwables.Function<? super T, ? extends Collection<? extends R>, ? extends Exception> mapper) Temporarily switch the stream to parallel stream for operationflatMap
and then switch back to sequence stream.<R> ExceptionalStream<R,
Exception> ExceptionalStream.spsFlatMapE
(int maxThreadNum, Throwables.Function<? super T, ? extends Stream<? extends R>, ? extends Exception> mapper) Temporarily switch the stream to parallel stream for operationflatMap
and then switch back to sequence stream.<R> ExceptionalStream<R,
Exception> ExceptionalStream.spsFlatMapE
(Throwables.Function<? super T, ? extends Stream<? extends R>, ? extends Exception> mapper) Temporarily switch the stream to parallel stream for operationflatMap
and then switch back to sequence stream.<R> ExceptionalStream<R,
E> ExceptionalStream.spsMap
(int maxThreadNum, Throwables.Function<? super T, ? extends R, E> mapper) Temporarily switch the stream to parallel stream for operationmap
and then switch back to sequence stream.<R> ExceptionalStream<R,
E> ExceptionalStream.spsMap
(Throwables.Function<? super T, ? extends R, E> mapper) Temporarily switch the stream to parallel stream for operationmap
and then switch back to sequence stream.<U> ExceptionalStream<U,
Exception> ExceptionalStream.spsMapE
(int maxThreadNum, Throwables.Function<? super T, ? extends U, ? extends Exception> mapper) Temporarily switch the stream to parallel stream for operationmap
and then switch back to sequence stream.<U> ExceptionalStream<U,
Exception> ExceptionalStream.spsMapE
(Throwables.Function<? super T, ? extends U, ? extends Exception> mapper) Temporarily switch the stream to parallel stream for operationmap
and then switch back to sequence stream.ExceptionalStream.spsOnEach
(int maxThreadNum, Throwables.Consumer<? super T, E> action) Temporarily switch the stream to parallel stream for operationonEach
and then switch back to sequence stream.ExceptionalStream.spsOnEach
(Throwables.Consumer<? super T, E> action) Temporarily switch the stream to parallel stream for operationonEach
and then switch back to sequence stream.ExceptionalStream.spsOnEachE
(int maxThreadNum, Throwables.Consumer<? super T, ? extends Exception> action) Temporarily switch the stream to parallel stream for operationonEach
and then switch back to sequence stream.ExceptionalStream.spsOnEachE
(Throwables.Consumer<? super T, ? extends Exception> action) Temporarily switch the stream to parallel stream for operationonEach
and then switch back to sequence stream.ExceptionalStream.step
(long step) ExceptionalStream.takeWhile
(Throwables.Predicate<? super T, ? extends E> predicate) ExceptionalStream.throwIfEmpty
(Supplier<? extends E> exceptionSupplier) ExceptionalStream.toJdkStream()
ExceptionalStream.top
(int n) ExceptionalStream.top
(int n, Comparator<? super T> comparator) ExceptionalStream.unchecked()
<T2,
T3, R> ExceptionalStream<R, E> ExceptionalStream.zipWith
(ExceptionalStream<T2, E> b, ExceptionalStream<T3, E> c, Throwables.TriFunction<? super T, ? super T2, ? super T3, ? extends R, ? extends E> zipFunction) <T2,
T3, R> ExceptionalStream<R, E> ExceptionalStream.zipWith
(ExceptionalStream<T2, E> b, ExceptionalStream<T3, E> c, T valueForNoneA, T2 valueForNoneB, T3 valueForNoneC, Throwables.TriFunction<? super T, ? super T2, ? super T3, ? extends R, ? extends E> zipFunction) <T2,
R> ExceptionalStream<R, E> ExceptionalStream.zipWith
(ExceptionalStream<T2, E> b, Throwables.BiFunction<? super T, ? super T2, ? extends R, ? extends E> zipFunction) <T2,
R> ExceptionalStream<R, E> ExceptionalStream.zipWith
(ExceptionalStream<T2, E> b, T valueForNoneA, T2 valueForNoneB, Throwables.BiFunction<? super T, ? super T2, ? extends R, ? extends E> zipFunction) <T2,
R> ExceptionalStream<R, E> ExceptionalStream.zipWith
(Collection<T2> b, Throwables.BiFunction<? super T, ? super T2, ? extends R, ? extends E> zipFunction) <T2,
T3, R> ExceptionalStream<R, E> ExceptionalStream.zipWith
(Collection<T2> b, Collection<T3> c, Throwables.TriFunction<? super T, ? super T2, ? super T3, ? extends R, ? extends E> zipFunction) <T2,
T3, R> ExceptionalStream<R, E> ExceptionalStream.zipWith
(Collection<T2> b, Collection<T3> c, T valueForNoneA, T2 valueForNoneB, T3 valueForNoneC, Throwables.TriFunction<? super T, ? super T2, ? super T3, ? extends R, ? extends E> zipFunction) <T2,
R> ExceptionalStream<R, E> ExceptionalStream.zipWith
(Collection<T2> b, T valueForNoneA, T2 valueForNoneB, Throwables.BiFunction<? super T, ? super T2, ? extends R, ? extends E> zipFunction) -
Uses of IntermediateOp in com.landawn.abacus.util.stream
Modifier and TypeMethodDescription<SS extends BaseStream>
SSabstract ByteStream
ByteStream.append
(byte... a) abstract CharStream
CharStream.append
(char... a) abstract DoubleStream
DoubleStream.append
(double... a) EntryStream.append
(M map) abstract FloatStream
FloatStream.append
(float... a) abstract IntStream
IntStream.append
(int... a) abstract LongStream
LongStream.append
(long... a) abstract ShortStream
ShortStream.append
(short... a) Stream.append
(Collection<? extends T> c) BaseStream.appendIfEmpty
(Supplier<? extends S> supplier) abstract ByteStream
ByteStream.appendIfEmpty
(byte... a) abstract CharStream
CharStream.appendIfEmpty
(char... a) abstract DoubleStream
DoubleStream.appendIfEmpty
(double... a) EntryStream.appendIfEmpty
(M map) abstract FloatStream
FloatStream.appendIfEmpty
(float... a) abstract IntStream
IntStream.appendIfEmpty
(int... a) abstract LongStream
LongStream.appendIfEmpty
(long... a) abstract ShortStream
ShortStream.appendIfEmpty
(short... a) Stream.appendIfEmpty
(Collection<? extends T> c) Stream.appendIfEmpty
(T... a) abstract DoubleStream
FloatStream.asDoubleStream()
abstract DoubleStream
IntStream.asDoubleStream()
abstract DoubleStream
LongStream.asDoubleStream()
abstract FloatStream
IntStream.asFloatStream()
abstract FloatStream
LongStream.asFloatStream()
Deprecated.abstract IntStream
ByteStream.asIntStream()
abstract IntStream
CharStream.asIntStream()
Returns aLongStream
consisting of the elements of this stream, converted tolong
.abstract IntStream
ShortStream.asIntStream()
abstract LongStream
IntStream.asLongStream()
ByteStream.boxed()
CharStream.boxed()
Returns aStream
consisting of the elements of this stream, each boxed to anChareger
.DoubleStream.boxed()
FloatStream.boxed()
IntStream.boxed()
LongStream.boxed()
ShortStream.boxed()
Stream.buffered()
Returns a new Stream with elements from a temporary queue which is filled by reading the elements from this Stream asynchronously with a new thread.Stream.buffered
(int bufferSize) Returns a new Stream with elements from a temporary queue which is filled by reading the elements from this Stream asynchronously with a new thread.Stream.cartesianProduct
(Collection<? extends Collection<? extends T>> cs) Stream.cartesianProduct
(Collection<? extends T>... cs) <E extends Exception>
ExceptionalStream<T,E> Stream.checked()
<E extends Exception>
ExceptionalStream<T,E> ByteStream.collapse
(ByteBiPredicate collapsible) Merge series of adjacent elements which satisfy the given predicate using the merger function and return a new stream.abstract ByteStream
ByteStream.collapse
(ByteBiPredicate collapsible, ByteBinaryOperator mergeFunction) Merge series of adjacent elements which satisfy the given predicate using the merger function and return a new stream.abstract ByteStream
ByteStream.collapse
(ByteTriPredicate collapsible, ByteBinaryOperator mergeFunction) CharStream.collapse
(CharBiPredicate collapsible) Merge series of adjacent elements which satisfy the given predicate using the merger function and return a new stream.abstract CharStream
CharStream.collapse
(CharBiPredicate collapsible, CharBinaryOperator mergeFunction) Merge series of adjacent elements which satisfy the given predicate using the merger function and return a new stream.abstract CharStream
CharStream.collapse
(CharTriPredicate collapsible, CharBinaryOperator mergeFunction) abstract Stream<DoubleList>
DoubleStream.collapse
(DoubleBiPredicate collapsible) Merge series of adjacent elements which satisfy the given predicate using the merger function and return a new stream.abstract DoubleStream
DoubleStream.collapse
(DoubleBiPredicate collapsible, DoubleBinaryOperator mergeFunction) Merge series of adjacent elements which satisfy the given predicate using the merger function and return a new stream.abstract DoubleStream
DoubleStream.collapse
(DoubleTriPredicate collapsible, DoubleBinaryOperator mergeFunction) FloatStream.collapse
(FloatBiPredicate collapsible) Merge series of adjacent elements which satisfy the given predicate using the merger function and return a new stream.abstract FloatStream
FloatStream.collapse
(FloatBiPredicate collapsible, FloatBinaryOperator mergeFunction) Merge series of adjacent elements which satisfy the given predicate using the merger function and return a new stream.abstract FloatStream
FloatStream.collapse
(FloatTriPredicate collapsible, FloatBinaryOperator mergeFunction) IntStream.collapse
(IntBiPredicate collapsible) Merge series of adjacent elements which satisfy the given predicate using the merger function and return a new stream.abstract IntStream
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 IntStream
IntStream.collapse
(IntTriPredicate collapsible, IntBinaryOperator mergeFunction) LongStream.collapse
(LongBiPredicate collapsible) Merge series of adjacent elements which satisfy the given predicate using the merger function and return a new stream.abstract LongStream
LongStream.collapse
(LongBiPredicate collapsible, LongBinaryOperator mergeFunction) Merge series of adjacent elements which satisfy the given predicate using the merger function and return a new stream.abstract LongStream
LongStream.collapse
(LongTriPredicate collapsible, LongBinaryOperator mergeFunction) ShortStream.collapse
(ShortBiPredicate collapsible) Merge series of adjacent elements which satisfy the given predicate using the merger function and return a new stream.abstract ShortStream
ShortStream.collapse
(ShortBiPredicate collapsible, ShortBinaryOperator mergeFunction) abstract ShortStream
ShortStream.collapse
(ShortTriPredicate collapsible, ShortBinaryOperator mergeFunction) Stream.collapse
(TriPredicate<? super T, ? super T, ? super T> collapsible) Stream.collapse
(TriPredicate<? super T, ? super T, ? super T> collapsible, BiFunction<? super T, ? super T, T> mergeFunction) Merge series of adjacent elements which satisfy the given predicate using the merger function and return a new stream.abstract <C extends Collection<T>>
Stream<C>Stream.collapse
(TriPredicate<? super T, ? super T, ? super T> collapsible, Supplier<? extends C> supplier) abstract <R> Stream<R>
Stream.collapse
(TriPredicate<? super T, ? super T, ? super T> collapsible, Supplier<R> supplier, BiConsumer<? super R, ? super T> accumulator) abstract <R,
A> Stream<R> Stream.collapse
(TriPredicate<? super T, ? super T, ? super T> collapsible, Collector<? super T, A, R> collector) Merge series of adjacent elements which satisfy the given predicate using the merger function and return a new stream.abstract <U> Stream<U>
Stream.collapse
(TriPredicate<? super T, ? super T, ? super T> collapsible, U init, BiFunction<U, ? super T, U> op) Stream.collapse
(BiPredicate<? super T, ? super T> collapsible) Stream.collapse
(BiPredicate<? super T, ? super T> collapsible, BiFunction<? super T, ? super T, T> mergeFunction) Merge series of adjacent elements which satisfy the given predicate using the merger function and return a new stream.abstract <C extends Collection<T>>
Stream<C>Stream.collapse
(BiPredicate<? super T, ? super T> collapsible, Supplier<? extends C> supplier) abstract <R> Stream<R>
Stream.collapse
(BiPredicate<? super T, ? super T> collapsible, Supplier<R> supplier, BiConsumer<? super R, ? super T> accumulator) abstract <R,
A> Stream<R> Merge series of adjacent elements which satisfy the given predicate using the merger function and return a new stream.abstract <U> Stream<U>
Stream.collapse
(BiPredicate<? super T, ? super T> collapsible, U init, BiFunction<U, ? super T, U> op) EntryStream.collapseByKey
(BiPredicate<? super K, ? super K> collapsible) <R,
A> Stream<R> EntryStream.collapseByKey
(BiPredicate<? super K, ? super K> collapsible, Collector<? super V, A, R> collector) Merge series of adjacent elements which satisfy the given predicate using the merger function and return a new stream.Stream.combinations()
Stream.of(1, 2, 3).combinations().forEach(Fn.println()); // output [] [1] [2] [3] [1, 2] [1, 3] [2, 3] [1, 2, 3]
Stream.combinations
(int len) Stream.of(1, 2, 3).combinations(2).forEach(Fn.println()); // output [1, 2] [1, 3] [2, 3]
Stream.combinations
(int len, boolean repeat) It's same asN.cartesianProduct(N.repeat(toList(), len))
ifrepeat
istrue
.<K> EntryStream<K,
Integer> Stream.countByToEntry
(Function<? super T, ? extends K> keyMapper) BaseStream.cycled()
This method only runs sequentially, even in parallel stream and retrieved elements will be saved in memory for next cycle.BaseStream.cycled
(long rounds)
This method only runs sequentially, even in parallel stream and retrieved elements will be saved in memory for next cycle.Stream.defaultIfEmpty
(Supplier<? extends Stream<T>> supplier) Stream.defaultIfEmpty
(T defaultValue) BaseStream.difference
(Collection<?> c)
This method only runs sequentially, even in parallel stream.Stream.difference
(Function<? super T, ? extends U> mapper, Collection<U> c) Except with the specified Collection by the values mapped bymapper
.BaseStream.distinct()
Returns a stream consisting of the distinct elements of this stream.EntryStream.distinct
(BinaryOperator<Map.Entry<K, V>> mergeFunction) Stream.distinct
(BinaryOperator<T> mergeFunction) Distinct and merge duplicated elements.Distinct and filter by occurrences.EntryStream.distinctBy
(Function<? super Map.Entry<K, V>, ?> keyMapper) EntryStream.distinctBy
(Function<? super Map.Entry<K, V>, ?> keyMapper, BinaryOperator<Map.Entry<K, V>> mergeFunction) EntryStream.distinctBy
(Function<? super Map.Entry<K, V>, ?> keyMapper, Predicate<? super Long> occurrencesFilter) Stream.distinctBy
(Function<? super T, ?> keyMapper) Distinct by the value mapped fromkeyMapper
Stream.distinctBy
(Function<? super T, K> keyMapper, BinaryOperator<T> mergeFunction) Distinct and merge duplicated elements.Stream.distinctBy
(Function<? super T, K> keyMapper, Predicate<? super Long> occurrencesFilter) Distinct and filter by occurrences.EntryStream.distinctByKey()
EntryStream.distinctByValue()
Remove the elements until the given predicate returns false.Remove the elements until the given predicate returns false.EntryStream.dropWhile
(BiPredicate<? super K, ? super V> predicate) EntryStream.entries()
Returns a stream consisting of the elements of this stream that match the given predicate.Returns a stream consisting of the elements of this stream that match the given predicate.EntryStream.filter
(BiPredicate<? super K, ? super V> predicate) EntryStream.filterByKey
(Predicate<? super K> keyPredicate) EntryStream.filterByValue
(Predicate<? super V> valuePredicate) Stream.filterE
(Throwables.Predicate<? super T, ? extends Exception> predicate) abstract ByteStream
ByteStream.flatmap
(ByteFunction<byte[]> mapper) abstract CharStream
CharStream.flatmap
(CharFunction<char[]> mapper) abstract DoubleStream
DoubleStream.flatmap
(DoubleFunction<double[]> mapper) <KK,
VV> EntryStream<KK, VV> EntryStream.flatmap
(BiFunction<? super K, ? super V, ? extends Map<? extends KK, ? extends VV>> mapper) <KK,
VV> EntryStream<KK, VV> EntryStream.flatmap
(Function<? super Map.Entry<K, V>, ? extends Map<? extends KK, ? extends VV>> mapper) abstract FloatStream
FloatStream.flatmap
(FloatFunction<float[]> mapper) abstract IntStream
IntStream.flatmap
(IntFunction<int[]> mapper) abstract LongStream
LongStream.flatmap
(LongFunction<long[]> mapper) abstract ShortStream
ShortStream.flatmap
(ShortFunction<short[]> mapper) abstract <R> Stream<R>
Stream.flatmap
(Function<? super T, ? extends Collection<? extends R>> mapper) abstract ByteStream
ByteStream.flatMap
(ByteFunction<? extends ByteStream> mapper) abstract CharStream
CharStream.flatMap
(CharFunction<? extends CharStream> 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 DoubleStream
DoubleStream.flatMap
(DoubleFunction<? extends DoubleStream> mapper) <KK,
VV> EntryStream<KK, VV> EntryStream.flatMap
(BiFunction<? super K, ? super V, ? extends EntryStream<? extends KK, ? extends VV>> mapper) <KK,
VV> EntryStream<KK, VV> EntryStream.flatMap
(Function<? super Map.Entry<K, V>, ? extends EntryStream<? extends KK, ? extends VV>> mapper) abstract FloatStream
FloatStream.flatMap
(FloatFunction<? extends FloatStream> mapper) abstract IntStream
IntStream.flatMap
(IntFunction<? extends IntStream> mapper) abstract LongStream
LongStream.flatMap
(LongFunction<? extends LongStream> mapper) abstract ShortStream
ShortStream.flatMap
(ShortFunction<? extends ShortStream> mapper) abstract <R> Stream<R>
<R> Stream<R>
Stream.flatmapE
(Throwables.Function<? super T, ? extends Collection<? extends R>, ? extends Exception> mapper) <R> Stream<R>
Stream.flatMapE
(Throwables.Function<? super T, ? extends Stream<? extends R>, ? extends Exception> mapper) <R> Stream<R>
Stream.flatMapIfNotNull
(Function<? super T, ? extends Collection<? extends R>> mapper) <U,
R> Stream<R> Stream.flatMapIfNotNull
(Function<? super T, ? extends Collection<? extends U>> mapper, Function<? super U, ? extends Collection<? extends R>> mapper2) <KK> EntryStream<KK,
V> EntryStream.flatmapKey
(BiFunction<? super K, ? super V, ? extends Collection<? extends KK>> keyMapper) <KK> EntryStream<KK,
V> EntryStream.flatmapKey
(Function<? super K, ? extends Collection<? extends KK>> keyMapper) <KK> EntryStream<KK,
V> EntryStream.flatMapKey
(BiFunction<? super K, ? super V, ? extends Stream<? extends KK>> keyMapper) <KK> EntryStream<KK,
V> EntryStream.flatMapKey
(Function<? super K, ? extends Stream<? extends KK>> keyMapper) abstract ByteStream
Stream.flatmapToByte
(Function<? super T, byte[]> mapper) abstract ByteStream
IntStream.flatMapToByte
(IntFunction<? extends ByteStream> mapper) abstract ByteStream
Stream.flatMapToByte
(Function<? super T, ? extends ByteStream> mapper) abstract CharStream
Stream.flatmapToChar
(Function<? super T, char[]> mapper) abstract CharStream
IntStream.flatMapToChar
(IntFunction<? extends CharStream> mapper) abstract CharStream
Stream.flatMapToChar
(Function<? super T, ? extends CharStream> mapper) abstract DoubleStream
Stream.flatmapToDouble
(Function<? super T, double[]> mapper) abstract DoubleStream
FloatStream.flatMapToDouble
(FloatFunction<? extends DoubleStream> mapper) abstract DoubleStream
IntStream.flatMapToDouble
(IntFunction<? extends DoubleStream> mapper) abstract DoubleStream
LongStream.flatMapToDouble
(LongFunction<? extends DoubleStream> mapper) abstract DoubleStream
Stream.flatMapToDouble
(Function<? super T, ? extends DoubleStream> mapper) abstract <K,
V> EntryStream<K, V> Stream.flatmapToEntry
(Function<? super T, ? extends Map<? extends K, ? extends V>> mapper) abstract <K,
V> EntryStream<K, V> Stream.flatMapToEntry
(Function<? super T, ? extends Stream<? extends Map.Entry<? extends K, ? extends V>>> mapper) abstract FloatStream
Stream.flatmapToFloat
(Function<? super T, float[]> mapper) abstract FloatStream
DoubleStream.flatMapToFloat
(DoubleFunction<? extends FloatStream> mapper) abstract FloatStream
IntStream.flatMapToFloat
(IntFunction<? extends FloatStream> mapper) abstract FloatStream
LongStream.flatMapToFloat
(LongFunction<? extends FloatStream> mapper) abstract FloatStream
Stream.flatMapToFloat
(Function<? super T, ? extends FloatStream> mapper) abstract IntStream
Stream.flatmapToInt
(Function<? super T, int[]> mapper) abstract IntStream
ByteStream.flatMapToInt
(ByteFunction<? extends IntStream> mapper) abstract IntStream
CharStream.flatMapToInt
(CharFunction<? extends IntStream> mapper) abstract IntStream
DoubleStream.flatMapToInt
(DoubleFunction<? extends IntStream> mapper) abstract IntStream
FloatStream.flatMapToInt
(FloatFunction<? extends IntStream> mapper) abstract IntStream
LongStream.flatMapToInt
(LongFunction<? extends IntStream> mapper) abstract IntStream
ShortStream.flatMapToInt
(ShortFunction<? extends IntStream> mapper) abstract IntStream
Stream.flatMapToInt
(Function<? super T, ? extends IntStream> mapper) abstract LongStream
Stream.flatmapToLong
(Function<? super T, long[]> mapper) abstract LongStream
DoubleStream.flatMapToLong
(DoubleFunction<? extends LongStream> mapper) abstract LongStream
FloatStream.flatMapToLong
(FloatFunction<? extends LongStream> mapper) abstract LongStream
IntStream.flatMapToLong
(IntFunction<? extends LongStream> mapper) abstract LongStream
Stream.flatMapToLong
(Function<? super T, ? extends LongStream> mapper) abstract <T> Stream<T>
ByteStream.flatmapToObj
(ByteFunction<? extends Collection<? extends T>> mapper) abstract <T> Stream<T>
CharStream.flatmapToObj
(CharFunction<? extends Collection<? extends T>> mapper) abstract <T> Stream<T>
DoubleStream.flatmapToObj
(DoubleFunction<? extends Collection<? extends T>> mapper) abstract <T> Stream<T>
FloatStream.flatmapToObj
(FloatFunction<? extends Collection<? extends T>> mapper) abstract <T> Stream<T>
IntStream.flatmapToObj
(IntFunction<? extends Collection<? extends T>> mapper) abstract <T> Stream<T>
LongStream.flatmapToObj
(LongFunction<? extends Collection<? extends T>> mapper) abstract <T> Stream<T>
ShortStream.flatmapToObj
(ShortFunction<? extends Collection<? extends T>> mapper) abstract <T> Stream<T>
ByteStream.flatMapToObj
(ByteFunction<? extends Stream<? extends T>> mapper) abstract <T> Stream<T>
CharStream.flatMapToObj
(CharFunction<? extends Stream<? extends T>> mapper) abstract <T> Stream<T>
DoubleStream.flatMapToObj
(DoubleFunction<? extends Stream<? extends T>> mapper) abstract <T> Stream<T>
FloatStream.flatMapToObj
(FloatFunction<? extends Stream<? extends T>> mapper) abstract <T> Stream<T>
IntStream.flatMapToObj
(IntFunction<? extends Stream<? extends T>> mapper) abstract <T> Stream<T>
LongStream.flatMapToObj
(LongFunction<? extends Stream<? extends T>> mapper) abstract <T> Stream<T>
ShortStream.flatMapToObj
(ShortFunction<? extends Stream<? extends T>> mapper) abstract ShortStream
Stream.flatmapToShort
(Function<? super T, short[]> mapper) abstract ShortStream
IntStream.flatMapToShort
(IntFunction<? extends ShortStream> mapper) abstract ShortStream
Stream.flatMapToShort
(Function<? super T, ? extends ShortStream> mapper) <VV> EntryStream<K,
VV> EntryStream.flatmapValue
(BiFunction<? super K, ? super V, ? extends Collection<? extends VV>> valueMapper) <VV> EntryStream<K,
VV> EntryStream.flatmapValue
(Function<? super V, ? extends Collection<? extends VV>> valueMapper) <VV> EntryStream<K,
VV> EntryStream.flatMapValue
(BiFunction<? super K, ? super V, ? extends Stream<? extends VV>> valueMapper) <VV> EntryStream<K,
VV> EntryStream.flatMapValue
(Function<? super V, ? extends Stream<? extends VV>> valueMapper) <KK,
VV> EntryStream<KK, VV> EntryStream.flattMap
(BiFunction<? super K, ? super V, ? extends Stream<? extends Map.Entry<? extends KK, ? extends VV>>> mapper) <KK,
VV> EntryStream<KK, VV> EntryStream.flattMap
(Function<? super Map.Entry<K, V>, ? extends Stream<? extends Map.Entry<? extends KK, ? extends VV>>> mapper) abstract <R> Stream<R>
abstract <K,
V> EntryStream<K, V> Stream.flattMapToEntry
(Function<? super T, ? extends EntryStream<? extends K, ? extends V>> mapper) abstract <T> Stream<T>
ByteStream.flattMapToObj
(ByteFunction<T[]> mapper) abstract <T> Stream<T>
CharStream.flattMapToObj
(CharFunction<T[]> mapper) abstract <T> Stream<T>
DoubleStream.flattMapToObj
(DoubleFunction<T[]> mapper) abstract <T> Stream<T>
FloatStream.flattMapToObj
(FloatFunction<T[]> mapper) abstract <T> Stream<T>
IntStream.flattMapToObj
(IntFunction<T[]> mapper) abstract <T> Stream<T>
LongStream.flattMapToObj
(LongFunction<T[]> mapper) abstract <T> Stream<T>
ShortStream.flattMapToObj
(ShortFunction<T[]> mapper) EntryStream<K,
List<V>> EntryStream.groupBy()
EntryStream.groupBy
(BinaryOperator<V> mergeFunction) <KK,
VV> EntryStream<KK, List<VV>> EntryStream.groupBy
(Function<? super Map.Entry<K, V>, ? extends KK> keyMapper, Function<? super Map.Entry<K, V>, ? extends VV> valueMapper) <KK,
VV> EntryStream<KK, VV> EntryStream.groupBy
(Function<? super Map.Entry<K, V>, ? extends KK> keyMapper, Function<? super Map.Entry<K, V>, ? extends VV> valueMapper, BinaryOperator<VV> mergeFunction) <KK,
VV> EntryStream<KK, VV> EntryStream.groupBy
(Function<? super Map.Entry<K, V>, ? extends KK> keyMapper, Function<? super Map.Entry<K, V>, ? extends VV> valueMapper, BinaryOperator<VV> mergeFunction, Supplier<? extends Map<KK, VV>> mapFactory) <KK,
VV> EntryStream<KK, List<VV>> EntryStream.groupBy
(Function<? super Map.Entry<K, V>, ? extends KK> keyMapper, Function<? super Map.Entry<K, V>, ? extends VV> valueMapper, Supplier<? extends Map<KK, List<VV>>> mapFactory) <KK,
A, D> EntryStream<KK, D> EntryStream.groupBy
(Function<? super Map.Entry<K, V>, ? extends KK> keyMapper, Collector<? super Map.Entry<K, V>, A, D> downstream) <KK,
A, D> EntryStream<KK, D> EntryStream.groupBy
(Function<? super Map.Entry<K, V>, ? extends KK> keyMapper, Collector<? super Map.Entry<K, V>, A, D> downstream, Supplier<? extends Map<KK, D>> mapFactory) EntryStream<K,
List<V>> <A,
D> EntryStream<K, D> <A,
D> EntryStream<K, D> EntryStream.groupBy
(Collector<? super Map.Entry<K, V>, A, D> downstream, Supplier<? extends Map<K, D>> mapFactory) Stream.groupBy
(Function<? super T, ? extends K> keyMapper, Function<? super T, ? extends V> valueMapper) Stream.groupBy
(Function<? super T, ? extends K> keyMapper, Function<? super T, ? extends V> valueMapper, BinaryOperator<V> mergeFunction) Stream.groupBy
(Function<? super T, ? extends K> keyMapper, Function<? super T, ? extends V> valueMapper, BinaryOperator<V> mergeFunction, Supplier<? extends Map<K, V>> mapFactory) Stream.groupBy
(Function<? super T, ? extends K> keyMapper, Function<? super T, ? extends V> valueMapper, Supplier<? extends Map<K, List<V>>> mapFactory) Stream.groupBy
(Function<? super T, ? extends K> keyMapper, Function<? super T, ? extends V> valueMapper, Collector<? super V, A, D> downstream) Stream.groupBy
(Function<? super T, ? extends K> keyMapper, Function<? super T, ? extends V> valueMapper, Collector<? super V, A, D> downstream, Supplier<? extends Map<K, D>> mapFactory) Stream.groupBy
(Function<? super T, ? extends K> keyMapper, Supplier<? extends Map<K, List<T>>> mapFactory) Stream.groupBy
(Function<? super T, ? extends K> keyMapper, Collector<? super T, A, D> downstream, Supplier<? extends Map<K, D>> mapFactory) abstract <K> EntryStream<K,
List<T>> Stream.groupByToEntry
(Function<? super T, ? extends K> keyMapper) abstract <K,
V> EntryStream<K, List<V>> Stream.groupByToEntry
(Function<? super T, ? extends K> keyMapper, Function<? super T, ? extends V> valueMapper) abstract <K,
V> EntryStream<K, V> Stream.groupByToEntry
(Function<? super T, ? extends K> keyMapper, Function<? super T, ? extends V> valueMapper, BinaryOperator<V> mergeFunction) abstract <K,
V> EntryStream<K, V> Stream.groupByToEntry
(Function<? super T, ? extends K> keyMapper, Function<? super T, ? extends V> valueMapper, BinaryOperator<V> mergeFunction, Supplier<? extends Map<K, V>> mapFactory) abstract <K,
V> EntryStream<K, List<V>> Stream.groupByToEntry
(Function<? super T, ? extends K> keyMapper, Function<? super T, ? extends V> valueMapper, Supplier<? extends Map<K, List<V>>> mapFactory) abstract <K,
V, A, D> EntryStream<K, D> Stream.groupByToEntry
(Function<? super T, ? extends K> keyMapper, Function<? super T, ? extends V> valueMapper, Collector<? super V, A, D> downstream) abstract <K,
V, A, D> EntryStream<K, D> Stream.groupByToEntry
(Function<? super T, ? extends K> keyMapper, Function<? super T, ? extends V> valueMapper, Collector<? super V, A, D> downstream, Supplier<? extends Map<K, D>> mapFactory) abstract <K> EntryStream<K,
List<T>> Stream.groupByToEntry
(Function<? super T, ? extends K> keyMapper, Supplier<? extends Map<K, List<T>>> mapFactory) abstract <K,
A, D> EntryStream<K, D> Stream.groupByToEntry
(Function<? super T, ? extends K> keyMapper, Collector<? super T, A, D> downstream) abstract <K,
A, D> EntryStream<K, D> Stream.groupByToEntry
(Function<? super T, ? extends K> keyMapper, Collector<? super T, A, D> downstream, Supplier<? extends Map<K, D>> mapFactory) BaseStream.indexed()
This method only runs sequentially, even in parallel stream.BaseStream.intersection
(Collection<?> c)
This method only runs sequentially, even in parallel stream.Stream.intersection
(Function<? super T, ? extends U> mapper, Collection<U> c) Intersect with the specified Collection by the values mapped bymapper
.Stream.intersperse
(T delimiter) Stream.of(1).intersperse(9) --> [1]
Stream.of(1, 2, 3).intersperse(9) --> [1, 9, 2, 9, 3]
This method only runs sequentially, even in parallel stream.EntryStream.inversed()
EntryStream.keys()
Stream.last
(int n) A queue with size up ton
will be maintained to filter out the lastn
elements.BaseStream.limit
(long maxSize) EntryStream.limit
(long maxSize) abstract ByteStream
ByteStream.map
(ByteUnaryOperator mapper) abstract CharStream
CharStream.map
(CharUnaryOperator mapper) Returns a stream consisting of the results of applying the given function to the elements of this stream.abstract DoubleStream
DoubleStream.map
(DoubleUnaryOperator mapper) <KK,
VV> EntryStream<KK, VV> EntryStream.map
(BiFunction<? super K, ? super V, ? extends Map.Entry<? extends KK, ? extends VV>> mapper) <KK,
VV> EntryStream<KK, VV> EntryStream.map
(BiFunction<? super K, ? super V, ? extends KK> keyMapper, BiFunction<? super K, ? super V, ? extends VV> valueMapper) <KK,
VV> EntryStream<KK, VV> EntryStream.map
(Function<? super Map.Entry<K, V>, ? extends Map.Entry<? extends KK, ? extends VV>> mapper) <KK,
VV> EntryStream<KK, VV> EntryStream.map
(Function<? super Map.Entry<K, V>, ? extends KK> keyMapper, Function<? super Map.Entry<K, V>, ? extends VV> valueMapper) abstract FloatStream
FloatStream.map
(FloatUnaryOperator mapper) abstract IntStream
IntStream.map
(IntUnaryOperator mapper) abstract LongStream
LongStream.map
(LongUnaryOperator mapper) abstract ShortStream
ShortStream.map
(ShortUnaryOperator mapper) abstract <R> Stream<R>
<R> Stream<R>
Stream.mapE
(Throwables.Function<? super T, ? extends R, ? extends Exception> mapper) abstract <R> Stream<R>
Stream.mapFirstOrElse
(Function<? super T, ? extends R> mapperForFirst, Function<? super T, ? extends R> mapperForElse) <KK> EntryStream<KK,
V> EntryStream.mapKey
(BiFunction<? super K, ? super V, ? extends KK> keyMapper) <KK> EntryStream<KK,
V> <KK> EntryStream<KK,
V> EntryStream.mapKeyPartial
(BiFunction<? super K, ? super V, u.Optional<? extends KK>> keyMapper) <KK> EntryStream<KK,
V> EntryStream.mapKeyPartial
(Function<? super K, u.Optional<? extends KK>> keyMapper) abstract <R> Stream<R>
Stream.mapLastOrElse
(Function<? super T, ? extends R> mapperForLast, Function<? super T, ? extends R> mapperForElse) abstract DoubleStream
DoubleStream.mapMulti
(DoubleMapMultiConsumer mapper) <KK,
VV> EntryStream<KK, VV> abstract IntStream
IntStream.mapMulti
(IntMapMultiConsumer mapper) abstract LongStream
LongStream.mapMulti
(LongMapMultiConsumer mapper) abstract <R> Stream<R>
Stream.mapMulti
(BiConsumer<? super T, ? super Consumer<R>> mapper) abstract DoubleStream
Stream.mapMultiToDouble
(BiConsumer<? super T, ? super DoubleConsumer> mapper) abstract IntStream
Stream.mapMultiToInt
(BiConsumer<? super T, ? super IntConsumer> mapper) abstract LongStream
Stream.mapMultiToLong
(BiConsumer<? super T, ? super LongConsumer> mapper) abstract ByteStream
ByteStream.mapPartial
(ByteFunction<u.OptionalByte> mapper) Note: copied from StreamEx: https://github.com/amaembo/streamexabstract CharStream
CharStream.mapPartial
(CharFunction<u.OptionalChar> mapper) Note: copied from StreamEx: https://github.com/amaembo/streamexabstract DoubleStream
DoubleStream.mapPartial
(DoubleFunction<u.OptionalDouble> mapper) Note: copied from StreamEx: https://github.com/amaembo/streamex<KK,
VV> EntryStream<KK, VV> EntryStream.mapPartial
(BiFunction<? super K, ? super V, u.Optional<? extends Map.Entry<? extends KK, ? extends VV>>> mapper) <KK,
VV> EntryStream<KK, VV> EntryStream.mapPartial
(Function<? super Map.Entry<K, V>, u.Optional<? extends Map.Entry<? extends KK, ? extends VV>>> mapper) abstract FloatStream
FloatStream.mapPartial
(FloatFunction<u.OptionalFloat> mapper) Note: copied from StreamEx: https://github.com/amaembo/streamexabstract IntStream
IntStream.mapPartial
(IntFunction<u.OptionalInt> mapper) Note: copied from StreamEx: https://github.com/amaembo/streamexabstract LongStream
LongStream.mapPartial
(LongFunction<u.OptionalLong> mapper) Note: copied from StreamEx: https://github.com/amaembo/streamexabstract ShortStream
ShortStream.mapPartial
(ShortFunction<u.OptionalShort> mapper) Note: copied from StreamEx: https://github.com/amaembo/streamexabstract <R> Stream<R>
Stream.mapPartial
(Function<? super T, u.Optional<? extends R>> mapper) Note: copied from StreamEx: https://github.com/amaembo/streamexabstract DoubleStream
DoubleStream.mapPartialJdk
(DoubleFunction<OptionalDouble> mapper) Note: copied from StreamEx: https://github.com/amaembo/streamexabstract IntStream
IntStream.mapPartialJdk
(IntFunction<OptionalInt> mapper) Note: copied from StreamEx: https://github.com/amaembo/streamexabstract LongStream
LongStream.mapPartialJdk
(LongFunction<OptionalLong> mapper) Note: copied from StreamEx: https://github.com/amaembo/streamexabstract <R> Stream<R>
Stream.mapPartialJdk
(Function<? super T, Optional<? extends R>> mapper) Note: copied from StreamEx: https://github.com/amaembo/streamexabstract DoubleStream
Stream.mapPartialToDouble
(Function<? super T, u.OptionalDouble> mapper) Note: copied from StreamEx: https://github.com/amaembo/streamexabstract DoubleStream
Stream.mapPartialToDoubleJdk
(Function<? super T, OptionalDouble> mapper) Note: copied from StreamEx: https://github.com/amaembo/streamexabstract IntStream
Stream.mapPartialToInt
(Function<? super T, u.OptionalInt> mapper) Note: copied from StreamEx: https://github.com/amaembo/streamexabstract IntStream
Stream.mapPartialToIntJdk
(Function<? super T, OptionalInt> mapper) Note: copied from StreamEx: https://github.com/amaembo/streamexabstract LongStream
Stream.mapPartialToLong
(Function<? super T, u.OptionalLong> mapper) Note: copied from StreamEx: https://github.com/amaembo/streamexabstract LongStream
Stream.mapPartialToLongJdk
(Function<? super T, OptionalLong> mapper) Note: copied from StreamEx: https://github.com/amaembo/streamexabstract ByteStream
IntStream.mapToByte
(IntToByteFunction mapper) abstract ByteStream
Stream.mapToByte
(ToByteFunction<? super T> mapper) abstract CharStream
IntStream.mapToChar
(IntToCharFunction mapper) abstract CharStream
Stream.mapToChar
(ToCharFunction<? super T> mapper) abstract DoubleStream
FloatStream.mapToDouble
(FloatToDoubleFunction mapper) abstract DoubleStream
IntStream.mapToDouble
(IntToDoubleFunction mapper) abstract DoubleStream
LongStream.mapToDouble
(LongToDoubleFunction mapper) abstract DoubleStream
Stream.mapToDouble
(ToDoubleFunction<? super T> mapper) abstract <K,
V> EntryStream<K, V> Stream.mapToEntry
(Function<? super T, ? extends Map.Entry<? extends K, ? extends V>> mapper) abstract <K,
V> EntryStream<K, V> Stream.mapToEntry
(Function<? super T, ? extends K> keyMapper, Function<? super T, ? extends V> valueMapper) abstract FloatStream
DoubleStream.mapToFloat
(DoubleToFloatFunction mapper) abstract FloatStream
IntStream.mapToFloat
(IntToFloatFunction mapper) abstract FloatStream
LongStream.mapToFloat
(LongToFloatFunction mapper) abstract FloatStream
Stream.mapToFloat
(ToFloatFunction<? super T> mapper) abstract IntStream
ByteStream.mapToInt
(ByteToIntFunction mapper) abstract IntStream
CharStream.mapToInt
(CharToIntFunction mapper) Returns aIntStream
consisting of the results of applying the given function to the elements of this stream.abstract IntStream
DoubleStream.mapToInt
(DoubleToIntFunction mapper) abstract IntStream
FloatStream.mapToInt
(FloatToIntFunction mapper) abstract IntStream
LongStream.mapToInt
(LongToIntFunction mapper) abstract IntStream
ShortStream.mapToInt
(ShortToIntFunction mapper) abstract IntStream
Stream.mapToInt
(ToIntFunction<? super T> mapper) abstract LongStream
DoubleStream.mapToLong
(DoubleToLongFunction mapper) abstract LongStream
FloatStream.mapToLong
(FloatToLongFunction mapper) abstract LongStream
IntStream.mapToLong
(IntToLongFunction mapper) abstract LongStream
Stream.mapToLong
(ToLongFunction<? super T> mapper) abstract <T> Stream<T>
ByteStream.mapToObj
(ByteFunction<? extends T> mapper) abstract <T> Stream<T>
CharStream.mapToObj
(CharFunction<? extends T> mapper) Returns an object-valuedStream
consisting of the results of applying the given function to the elements of this stream.abstract <T> Stream<T>
DoubleStream.mapToObj
(DoubleFunction<? extends T> mapper) abstract <T> Stream<T>
FloatStream.mapToObj
(FloatFunction<? extends T> mapper) abstract <T> Stream<T>
IntStream.mapToObj
(IntFunction<? extends T> mapper) abstract <T> Stream<T>
LongStream.mapToObj
(LongFunction<? extends T> mapper) abstract <T> Stream<T>
ShortStream.mapToObj
(ShortFunction<? extends T> mapper) abstract ShortStream
IntStream.mapToShort
(IntToShortFunction mapper) abstract ShortStream
Stream.mapToShort
(ToShortFunction<? super T> mapper) <VV> EntryStream<K,
VV> EntryStream.mapValue
(BiFunction<? super K, ? super V, ? extends VV> valueMapper) <VV> EntryStream<K,
VV> <VV> EntryStream<K,
VV> EntryStream.mapValuePartial
(BiFunction<? super K, ? super V, u.Optional<? extends VV>> valueMapper) <VV> EntryStream<K,
VV> EntryStream.mapValuePartial
(Function<? super V, u.Optional<? extends VV>> valueMapper) ByteStream.merge
(ByteStream b, ByteBiFunction<MergeResult> nextSelector) Deprecated.CharStream.merge
(CharStream b, CharBiFunction<MergeResult> nextSelector) Deprecated.replaced bymergeWith(CharStream, CharBiFunction)
DoubleStream.merge
(DoubleStream b, DoubleBiFunction<MergeResult> nextSelector) Deprecated.replaced bymergeWith(DoubleStream, DoubleBiFunction)
FloatStream.merge
(FloatStream b, FloatBiFunction<MergeResult> nextSelector) Deprecated.replaced bymergeWith(FloatStream, FloatBiFunction)
IntStream.merge
(IntStream b, IntBiFunction<MergeResult> nextSelector) Deprecated.replaced bymergeWith(IntStream, IntBiFunction)
LongStream.merge
(LongStream b, LongBiFunction<MergeResult> nextSelector) Deprecated.replaced bymergeWith(LongStream, LongBiFunction)
ShortStream.merge
(ShortStream b, ShortBiFunction<MergeResult> nextSelector) Deprecated.replaced bymergeWith(ShortStream, ShortBiFunction)
Stream.merge
(Stream<? extends T> b, BiFunction<? super T, ? super T, MergeResult> nextSelector) Deprecated.replaced bymergeWith(Stream, BiFunction)
abstract ByteStream
ByteStream.mergeWith
(ByteStream b, ByteBiFunction<MergeResult> nextSelector) abstract CharStream
CharStream.mergeWith
(CharStream b, CharBiFunction<MergeResult> nextSelector) abstract DoubleStream
DoubleStream.mergeWith
(DoubleStream b, DoubleBiFunction<MergeResult> nextSelector) abstract FloatStream
FloatStream.mergeWith
(FloatStream b, FloatBiFunction<MergeResult> nextSelector) abstract IntStream
IntStream.mergeWith
(IntStream b, IntBiFunction<MergeResult> nextSelector) abstract LongStream
LongStream.mergeWith
(LongStream b, LongBiFunction<MergeResult> nextSelector) abstract ShortStream
ShortStream.mergeWith
(ShortStream b, ShortBiFunction<MergeResult> nextSelector) Stream.mergeWith
(Stream<? extends T> b, BiFunction<? super T, ? super T, MergeResult> nextSelector) Stream.mergeWith
(Collection<? extends T> b, BiFunction<? super T, ? super T, MergeResult> nextSelector) Same aspeek
EntryStream.onEach
(BiConsumer<? super K, ? super V> action) Stream.onEachE
(Throwables.Consumer<? super T, ? extends Exception> action) Stream.orderedPermutations()
Stream.of(1, 2, 3).orderedPermutations().forEach(Fn.println()); // output [1, 2, 3] [1, 3, 2] [2, 1, 3] [2, 3, 1] [3, 1, 2] [3, 2, 1]
Stream.orderedPermutations
(Comparator<? super T> comparator) BaseStream.parallel()
Consider usingsps(Function)
if only next operation need to be parallelized.BaseStream.parallel
(int maxThreadNum) Consider usingsps(int, Function)
if only next operation need to be parallelized.BaseStream.parallel
(int maxThreadNum, BaseStream.Splitor splitor) Returns an equivalent stream that is parallel.BaseStream.parallel
(int maxThreadNum, BaseStream.Splitor splitor, Executor executor) stream.parallel(maxThreadNum, splitor, executor).map(f).filter(p)...; // Replace above line of code with "sps" if only "f" need to be parallelized.// Replace above line of code with "sps" if only "f" need to be parallelized.BaseStream.parallel
(BaseStream.ParallelSettings ps) stream.parallel(parallelSettings).map(f).filter(p)...; // Replace above line of code with "sps" if only "f" need to be parallelized.BaseStream.parallel
(BaseStream.Splitor splitor) stream.parallel(executor).map(f).filter(p)...; // Replace above line of code with "sps" if only "f" need to be parallelized.Stream.partitionBy
(Predicate<? super T> predicate) Stream.partitionBy
(Predicate<? super T> predicate, Collector<? super T, A, D> downstream) abstract EntryStream<Boolean,
List<T>> Stream.partitionByToEntry
(Predicate<? super T> predicate) abstract <A,
D> EntryStream<Boolean, D> Stream.partitionByToEntry
(Predicate<? super T> predicate, Collector<? super T, A, D> downstream) EntryStream.peek
(BiConsumer<? super K, ? super V> action) BaseStream.percentiles()
All elements will be loaded to memory and sorted if not yet.Stream.permutations()
Stream.of(1, 2, 3).permutations().forEach(Fn.println()); // output [1, 2, 3] [1, 3, 2] [3, 1, 2] [3, 2, 1] [2, 3, 1] [2, 1, 3]
abstract ByteStream
ByteStream.prepend
(byte... a) abstract CharStream
CharStream.prepend
(char... a) abstract DoubleStream
DoubleStream.prepend
(double... a) EntryStream.prepend
(M map) abstract FloatStream
FloatStream.prepend
(float... a) abstract IntStream
IntStream.prepend
(int... a) abstract LongStream
LongStream.prepend
(long... a) abstract ShortStream
ShortStream.prepend
(short... a) Stream.prepend
(Collection<? extends T> c) <SS extends BaseStream>
SSTemporarily switch the stream to sequence stream for operationops
and then switch back to parallel stream with samemaxThreadNum/splitor/asyncExecutor
.abstract ByteStream
ByteStream.rangeMap
(ByteBiPredicate sameRange, ByteBinaryOperator 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 CharStream
CharStream.rangeMap
(CharBiPredicate sameRange, CharBinaryOperator 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 DoubleStream
DoubleStream.rangeMap
(DoubleBiPredicate sameRange, DoubleBinaryOperator 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 FloatStream
FloatStream.rangeMap
(FloatBiPredicate sameRange, FloatBinaryOperator 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 IntStream
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 LongStream
LongStream.rangeMap
(LongBiPredicate sameRange, LongBinaryOperator 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 ShortStream
ShortStream.rangeMap
(ShortBiPredicate sameRange, ShortBinaryOperator 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> Stream<U>
Stream.rangeMap
(BiPredicate<? super T, ? super T> sameRange, BiFunction<? super T, ? super T, ? extends U> 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>
ByteStream.rangeMapToObj
(ByteBiPredicate sameRange, ByteBiFunction<? extends 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 <T> Stream<T>
CharStream.rangeMapToObj
(CharBiPredicate sameRange, CharBiFunction<? extends 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 <T> Stream<T>
DoubleStream.rangeMapToObj
(DoubleBiPredicate sameRange, DoubleBiFunction<? extends 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 <T> Stream<T>
FloatStream.rangeMapToObj
(FloatBiPredicate sameRange, FloatBiFunction<? extends 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 <T> Stream<T>
IntStream.rangeMapToObj
(IntBiPredicate sameRange, IntBiFunction<? extends 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 <T> Stream<T>
LongStream.rangeMapToObj
(LongBiPredicate sameRange, LongBiFunction<? extends 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 <T> Stream<T>
ShortStream.rangeMapToObj
(ShortBiPredicate sameRange, ShortBiFunction<? extends 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.BaseStream.rateLimited
(double permitsPerSecond) BaseStream.rateLimited
(RateLimiter rateLimiter) Deprecated.to be removed in future version.Deprecated.to be removed in future version.BaseStream.reversed()
This method only runs sequentially, even in parallel stream and all elements will be loaded to memory.BaseStream.reverseSorted()
EntryStream.reverseSorted
(Comparator<? super Map.Entry<K, V>> comparator) Stream.reverseSorted
(Comparator<? super T> comparator) Stream.rollup()
BaseStream.rotated
(int distance)
This method only runs sequentially, even in parallel stream and all elements will be loaded to memory.abstract ByteStream
ByteStream.scan
(byte init, ByteBinaryOperator accumulator) Returns aStream
produced by iterative application of a accumulation function to an initial elementinit
and next element of the current stream.abstract ByteStream
ByteStream.scan
(byte init, ByteBinaryOperator accumulator, boolean initIncluded) abstract ByteStream
ByteStream.scan
(ByteBinaryOperator accumulator) Returns aStream
produced by iterative application of a accumulation function to an initial elementinit
and next element of the current stream.abstract CharStream
CharStream.scan
(char init, CharBinaryOperator accumulator) Returns aStream
produced by iterative application of a accumulation function to an initial elementinit
and next element of the current stream.abstract CharStream
CharStream.scan
(char init, CharBinaryOperator accumulator, boolean initIncluded) abstract CharStream
CharStream.scan
(CharBinaryOperator accumulator) Returns aStream
produced by iterative application of a accumulation function to an initial elementinit
and next element of the current stream.abstract DoubleStream
DoubleStream.scan
(double init, DoubleBinaryOperator accumulator) Returns aStream
produced by iterative application of a accumulation function to an initial elementinit
and next element of the current stream.abstract DoubleStream
DoubleStream.scan
(double init, DoubleBinaryOperator accumulator, boolean initIncluded) abstract DoubleStream
DoubleStream.scan
(DoubleBinaryOperator accumulator) Returns aStream
produced by iterative application of a accumulation function to an initial elementinit
and next element of the current stream.abstract FloatStream
FloatStream.scan
(float init, FloatBinaryOperator accumulator) Returns aStream
produced by iterative application of a accumulation function to an initial elementinit
and next element of the current stream.abstract FloatStream
FloatStream.scan
(float init, FloatBinaryOperator accumulator, boolean initIncluded) abstract FloatStream
FloatStream.scan
(FloatBinaryOperator accumulator) Returns aStream
produced by iterative application of a accumulation function to an initial elementinit
and next element of the current stream.abstract IntStream
IntStream.scan
(int init, IntBinaryOperator accumulator) Returns aStream
produced by iterative application of a accumulation function to an initial elementinit
and next element of the current stream.abstract IntStream
IntStream.scan
(int init, IntBinaryOperator accumulator, boolean initIncluded) abstract IntStream
IntStream.scan
(IntBinaryOperator accumulator) Returns aStream
produced by iterative application of a accumulation function to an initial elementinit
and next element of the current stream.abstract LongStream
LongStream.scan
(long init, LongBinaryOperator accumulator) Returns aStream
produced by iterative application of a accumulation function to an initial elementinit
and next element of the current stream.abstract LongStream
LongStream.scan
(long init, LongBinaryOperator accumulator, boolean initIncluded) abstract LongStream
LongStream.scan
(LongBinaryOperator accumulator) Returns aStream
produced by iterative application of a accumulation function to an initial elementinit
and next element of the current stream.abstract ShortStream
ShortStream.scan
(short init, ShortBinaryOperator accumulator) Returns aStream
produced by iterative application of a accumulation function to an initial elementinit
and next element of the current stream.abstract ShortStream
ShortStream.scan
(short init, ShortBinaryOperator accumulator, boolean initIncluded) abstract ShortStream
ShortStream.scan
(ShortBinaryOperator accumulator) Returns aStream
produced by iterative application of a accumulation function to an initial elementinit
and next element of the current stream.Stream.scan
(BiFunction<? super T, ? super T, T> accumulator) Returns aStream
produced by iterative application of a accumulation function to an initial elementinit
and next element of the current stream.abstract <U> Stream<U>
Stream.scan
(U init, BiFunction<U, ? super T, U> accumulator) Returns aStream
produced by iterative application of a accumulation function to an initial elementinit
and next element of the current stream.abstract <U> Stream<U>
Stream.scan
(U init, BiFunction<U, ? super T, U> accumulator, boolean initIncluded) <U> Stream<U>
Select the elements belong to the specifiedtargetType
(including its subtype).<KK> EntryStream<KK,
V> EntryStream.selectByKey
(Class<KK> clazz) Returns a stream consisting of the elements of this stream which keys are instances of given class.<VV> EntryStream<K,
VV> EntryStream.selectByValue
(Class<VV> clazz) Returns a stream consisting of the elements of this stream which values are instances of given class.BaseStream.sequential()
BaseStream.shuffled()
This method only runs sequentially, even in parallel stream and all elements will be loaded to memory.
This method only runs sequentially, even in parallel stream and all elements will be loaded to memory.<R> Stream<R>
Temporarily switch the stream to Jdk parallel stream for operationops
and then switch back to sequence stream.BaseStream.skip
(long n) EntryStream.skip
(long n) Stream.skipLast
(int n) A queue with size up ton
will be maintained to filter out the lastn
elements.Stream.skipNull()
Stream.skipRange
(int startInclusive, int endExclusive) Skip the range: [fromIndexInclusive, fromIndexInclusive]EntryStream.skipUntil
(BiPredicate<? super K, ? super V> predicate) BaseStream.sliding
(int windowSize) BaseStream.sliding
(int windowSize, int increment) Stream.of(1, 2, 3, 4, 5, 6, 7, 8).sliding(3, 1).forEach(Stream::println)
output:
[1, 2, 3]
[2, 3, 4]
[3, 4, 5]
[4, 5, 6]
[5, 6, 7]
[6, 7, 8]
============================================================================Stream.of(1, 2, 3, 4, 5, 6, 7, 8).sliding(3, 3).forEach(Stream::println)
output:
[1, 2, 3]
[4, 5, 6]
[7, 8]
============================================================================Stream.of(1, 2, 3, 4, 5, 6, 7, 5).sliding(3, 5).forEach(Stream::println)
output:
[1, 2, 3]
[6, 7, 8]
This method only runs sequentially, even in parallel stream.abstract <C extends Collection<T>>
Stream<C>Stream.sliding
(int windowSize, int increment, IntFunction<? extends C> collectionSupplier) abstract <A,
R> Stream<R> abstract <C extends Collection<T>>
Stream<C>Stream.sliding
(int windowSize, IntFunction<? extends C> collectionSupplier) abstract <A,
R> Stream<R> abstract <R> Stream<R>
Stream.slidingMap
(TriFunction<? super T, ? super T, ? super T, ? extends R> mapper) abstract <R> Stream<R>
Stream.slidingMap
(TriFunction<? super T, ? super T, ? super T, ? extends R> mapper, int increment) Slide withwindowSize = 3
and the specifiedincrement
, thenmap
by the specifiedmapper
.abstract <R> Stream<R>
Stream.slidingMap
(TriFunction<? super T, ? super T, ? super T, ? extends R> mapper, int increment, boolean ignoreNotPaired) abstract <R> Stream<R>
Stream.slidingMap
(BiFunction<? super T, ? super T, ? extends R> mapper) abstract <R> Stream<R>
Stream.slidingMap
(BiFunction<? super T, ? super T, ? extends R> mapper, int increment) Slide withwindowSize = 2
and the specifiedincrement
, thenmap
by the specifiedmapper
.abstract <R> Stream<R>
Stream.slidingMap
(BiFunction<? super T, ? super T, ? extends R> mapper, int increment, boolean ignoreNotPaired) BaseStream.slidingToList
(int windowSize) BaseStream.slidingToList
(int windowSize, int increment) Stream.slidingToSet
(int windowSize) Stream.slidingToSet
(int windowSize, int increment) BaseStream.sorted()
Returns a stream consisting of the elements of this stream in sorted order.EntryStream.sorted
(Comparator<? super Map.Entry<K, V>> comparator) Stream.sorted
(Comparator<? super T> comparator) Stream.sortedBy
(Function<? super T, ? extends Comparable> keyMapper) EntryStream.sortedByDouble
(ToDoubleFunction<? super Map.Entry<K, V>> keyMapper) Stream.sortedByDouble
(ToDoubleFunction<? super T> keyMapper) EntryStream.sortedByInt
(ToIntFunction<? super Map.Entry<K, V>> keyMapper) Stream.sortedByInt
(ToIntFunction<? super T> keyMapper) EntryStream.sortedByKey
(Comparator<? super K> keyComparator) EntryStream.sortedByLong
(ToLongFunction<? super Map.Entry<K, V>> keyMapper) Stream.sortedByLong
(ToLongFunction<? super T> keyMapper) EntryStream.sortedByValue
(Comparator<? super V> valueComparator) BaseStream.split
(int chunkSize) Returns Stream ofS
with consecutive sub sequences of the elements, each of the same size (the final sequence may be smaller).Split the stream by the specified predicate.abstract <C extends Collection<T>>
Stream<C>Stream.split
(int chunkSize, IntFunction<? extends C> collectionSupplier) Returns Stream of Stream with consecutive sub sequences of the elements, each of the same size (the final sequence may be smaller).abstract <A,
R> Stream<R> abstract <C extends Collection<T>>
Stream<C>abstract <A,
R> Stream<R> BaseStream.splitAt
(int where) Split the stream into two pieces atwhere
.Split the stream into two pieces atwhere
turns totrue
.abstract <A,
R> Stream<R> Split the stream into two pieces atwhere
turns tofalse
.abstract <A,
R> Stream<R> Split the stream into two pieces atwhere
turns tofalse
.BaseStream.splitToList
(int chunkSize) Returns Stream ofPL
with consecutive sub sequences of the elements, each of the same size (the final sequence may be smaller).BaseStream.splitToList
(P predicate) Split the stream by the specified predicate.Stream.splitToSet
(int chunkSize) Returns Stream of Stream with consecutive sub sequences of the elements, each of the same size (the final sequence may be smaller).Stream.splitToSet
(Predicate<? super T> predicate) <SS extends BaseStream>
SSTemporarily switch the stream to parallel stream for operationops
and then switch back to sequence stream.<SS extends BaseStream>
SSTemporarily switch the stream to parallel stream for operationops
and then switch back to sequence stream.<R> Stream<R>
Stream.sps
(int maxThreadNum, int bufferSize, Function<? super Stream<T>, ? extends Stream<? extends R>> op) Temporarily switch the stream to parallel stream for operationop
and then switch back to sequence stream.Temporarily switch the stream to parallel stream for operationfilter
and then switch back to sequence stream.Temporarily switch the stream to parallel stream for operationfilter
and then switch back to sequence stream.Temporarily switch the stream to parallel stream for operationfilter
and then switch back to sequence stream.Stream.spsFilterE
(int maxThreadNum, Throwables.Predicate<? super T, ? extends Exception> predicate) Temporarily switch the stream to parallel stream for operationfilter
and then switch back to sequence stream.Stream.spsFilterE
(Throwables.Predicate<? super T, ? extends Exception> predicate) Temporarily switch the stream to parallel stream for operationfilter
and then switch back to sequence stream.<R> Stream<R>
Stream.spsFlatmap
(int maxThreadNum, int bufferSize, Function<? super T, ? extends Collection<? extends R>> mapper) Temporarily switch the stream to parallel stream for operationflatMap
and then switch back to sequence stream.<R> Stream<R>
Stream.spsFlatmap
(int maxThreadNum, Function<? super T, ? extends Collection<? extends R>> mapper) Temporarily switch the stream to parallel stream for operationflatMap
and then switch back to sequence stream.<R> Stream<R>
Stream.spsFlatmap
(Function<? super T, ? extends Collection<? extends R>> mapper) Temporarily switch the stream to parallel stream for operationflatMap
and then switch back to sequence stream.<R> Stream<R>
Stream.spsFlatMap
(int maxThreadNum, int bufferSize, Function<? super T, ? extends Stream<? extends R>> mapper) Temporarily switch the stream to parallel stream for operationflatMap
and then switch back to sequence stream.<R> Stream<R>
Stream.spsFlatMap
(int maxThreadNum, Function<? super T, ? extends Stream<? extends R>> mapper) Temporarily switch the stream to parallel stream for operationflatMap
and then switch back to sequence stream.<R> Stream<R>
Stream.spsFlatMap
(Function<? super T, ? extends Stream<? extends R>> mapper) Temporarily switch the stream to parallel stream for operationflatMap
and then switch back to sequence stream.<R> Stream<R>
Stream.spsFlatmapE
(int maxThreadNum, Throwables.Function<? super T, ? extends Collection<? extends R>, ? extends Exception> mapper) Temporarily switch the stream to parallel stream for operationflatMap
and then switch back to sequence stream.<R> Stream<R>
Stream.spsFlatmapE
(Throwables.Function<? super T, ? extends Collection<? extends R>, ? extends Exception> mapper) Temporarily switch the stream to parallel stream for operationflatMap
and then switch back to sequence stream.<R> Stream<R>
Stream.spsFlatMapE
(int maxThreadNum, Throwables.Function<? super T, ? extends Stream<? extends R>, ? extends Exception> mapper) Temporarily switch the stream to parallel stream for operationflatMap
and then switch back to sequence stream.<R> Stream<R>
Stream.spsFlatMapE
(Throwables.Function<? super T, ? extends Stream<? extends R>, ? extends Exception> mapper) Temporarily switch the stream to parallel stream for operationflatMap
and then switch back to sequence stream.<R> Stream<R>
Temporarily switch the stream to parallel stream for operationmap
and then switch back to sequence stream.<R> Stream<R>
Temporarily switch the stream to parallel stream for operationmap
and then switch back to sequence stream.<R> Stream<R>
Temporarily switch the stream to parallel stream for operationmap
and then switch back to sequence stream.<R> Stream<R>
Stream.spsMapE
(int maxThreadNum, Throwables.Function<? super T, ? extends R, ? extends Exception> mapper) Temporarily switch the stream to parallel stream for operationmap
and then switch back to sequence stream.<R> Stream<R>
Stream.spsMapE
(Throwables.Function<? super T, ? extends R, ? extends Exception> mapper) Temporarily switch the stream to parallel stream for operationmap
and then switch back to sequence stream.Temporarily switch the stream to parallel stream for operationonEach
and then switch back to sequence stream.Temporarily switch the stream to parallel stream for operationonEach
and then switch back to sequence stream.Temporarily switch the stream to parallel stream for operationonEach
and then switch back to sequence stream.Stream.spsOnEachE
(int maxThreadNum, Throwables.Consumer<? super T, ? extends Exception> action) Temporarily switch the stream to parallel stream for operationonEach
and then switch back to sequence stream.Stream.spsOnEachE
(Throwables.Consumer<? super T, ? extends Exception> action) Temporarily switch the stream to parallel stream for operationonEach
and then switch back to sequence stream.BaseStream.step
(long step) BaseStream.symmetricDifference
(Collection<T> c)
This method only runs sequentially, even in parallel stream.Keep the elements until the given predicate returns false.EntryStream.takeWhile
(BiPredicate<? super K, ? super V> predicate) BaseStream.throwIfEmpty
(Supplier<? extends RuntimeException> exceptionSupplier) abstract DoubleStream
DoubleStream.toJdkStream()
abstract IntStream
IntStream.toJdkStream()
abstract LongStream
LongStream.toJdkStream()
Stream.toJdkStream()
Remember to close this Stream after the iteration is done, if needed.abstract DoubleStream
DoubleStream.top
(int n)
This method only runs sequentially, even in parallel stream.abstract DoubleStream
DoubleStream.top
(int n, Comparator<? super Double> comparator)
This method only runs sequentially, even in parallel stream.abstract FloatStream
FloatStream.top
(int n)
This method only runs sequentially, even in parallel stream.abstract FloatStream
FloatStream.top
(int n, Comparator<? super Float> comparator)
This method only runs sequentially, even in parallel stream.abstract IntStream
IntStream.top
(int n)
This method only runs sequentially, even in parallel stream.abstract IntStream
IntStream.top
(int n, Comparator<? super Integer> comparator)
This method only runs sequentially, even in parallel stream.abstract LongStream
LongStream.top
(int n)
This method only runs sequentially, even in parallel stream.abstract LongStream
LongStream.top
(int n, Comparator<? super Long> comparator)
This method only runs sequentially, even in parallel stream.abstract ShortStream
ShortStream.top
(int n)
This method only runs sequentially, even in parallel stream.abstract ShortStream
ShortStream.top
(int n, Comparator<? super Short> comparator)
This method only runs sequentially, even in parallel stream.Stream.top
(int n)
This method only runs sequentially, even in parallel stream.Stream.top
(int n, Comparator<? super T> comparator)
This method only runs sequentially, even in parallel stream.EntryStream.values()
abstract ByteStream
ByteStream.zipWith
(ByteStream b, byte valueForNoneA, byte valueForNoneB, ByteBinaryOperator zipFunction) abstract ByteStream
ByteStream.zipWith
(ByteStream b, ByteBinaryOperator zipFunction) abstract ByteStream
ByteStream.zipWith
(ByteStream b, ByteStream c, byte valueForNoneA, byte valueForNoneB, byte valueForNoneC, ByteTernaryOperator zipFunction) abstract ByteStream
ByteStream.zipWith
(ByteStream b, ByteStream c, ByteTernaryOperator zipFunction) abstract CharStream
CharStream.zipWith
(CharStream b, char valueForNoneA, char valueForNoneB, CharBinaryOperator zipFunction) abstract CharStream
CharStream.zipWith
(CharStream b, CharBinaryOperator zipFunction) abstract CharStream
CharStream.zipWith
(CharStream b, CharStream c, char valueForNoneA, char valueForNoneB, char valueForNoneC, CharTernaryOperator zipFunction) abstract CharStream
CharStream.zipWith
(CharStream b, CharStream c, CharTernaryOperator zipFunction) abstract DoubleStream
DoubleStream.zipWith
(DoubleStream b, double valueForNoneA, double valueForNoneB, DoubleBinaryOperator zipFunction) abstract DoubleStream
DoubleStream.zipWith
(DoubleStream b, DoubleStream c, double valueForNoneA, double valueForNoneB, double valueForNoneC, DoubleTernaryOperator zipFunction) abstract DoubleStream
DoubleStream.zipWith
(DoubleStream b, DoubleStream c, DoubleTernaryOperator zipFunction) abstract DoubleStream
DoubleStream.zipWith
(DoubleStream b, DoubleBinaryOperator zipFunction) abstract FloatStream
FloatStream.zipWith
(FloatStream b, float valueForNoneA, float valueForNoneB, FloatBinaryOperator zipFunction) abstract FloatStream
FloatStream.zipWith
(FloatStream b, FloatBinaryOperator zipFunction) abstract FloatStream
FloatStream.zipWith
(FloatStream b, FloatStream c, float valueForNoneA, float valueForNoneB, float valueForNoneC, FloatTernaryOperator zipFunction) abstract FloatStream
FloatStream.zipWith
(FloatStream b, FloatStream c, FloatTernaryOperator zipFunction) abstract IntStream
IntStream.zipWith
(IntStream b, int valueForNoneA, int valueForNoneB, IntBinaryOperator zipFunction) abstract IntStream
IntStream.zipWith
(IntStream b, IntStream c, int valueForNoneA, int valueForNoneB, int valueForNoneC, IntTernaryOperator zipFunction) abstract IntStream
IntStream.zipWith
(IntStream b, IntStream c, IntTernaryOperator zipFunction) abstract IntStream
IntStream.zipWith
(IntStream b, IntBinaryOperator zipFunction) abstract LongStream
LongStream.zipWith
(LongStream b, long valueForNoneA, long valueForNoneB, LongBinaryOperator zipFunction) abstract LongStream
LongStream.zipWith
(LongStream b, LongStream c, long valueForNoneA, long valueForNoneB, long valueForNoneC, LongTernaryOperator zipFunction) abstract LongStream
LongStream.zipWith
(LongStream b, LongStream c, LongTernaryOperator zipFunction) abstract LongStream
LongStream.zipWith
(LongStream b, LongBinaryOperator zipFunction) abstract ShortStream
ShortStream.zipWith
(ShortStream b, short valueForNoneA, short valueForNoneB, ShortBinaryOperator zipFunction) abstract ShortStream
ShortStream.zipWith
(ShortStream b, ShortBinaryOperator zipFunction) abstract ShortStream
ShortStream.zipWith
(ShortStream b, ShortStream c, short valueForNoneA, short valueForNoneB, short valueForNoneC, ShortTernaryOperator zipFunction) abstract ShortStream
ShortStream.zipWith
(ShortStream b, ShortStream c, ShortTernaryOperator zipFunction) abstract <T2,
T3, R> Stream<R> Stream.zipWith
(Stream<T2> b, Stream<T3> c, TriFunction<? super T, ? super T2, ? super T3, ? extends R> zipFunction) abstract <T2,
T3, R> Stream<R> Stream.zipWith
(Stream<T2> b, Stream<T3> c, T valueForNoneA, T2 valueForNoneB, T3 valueForNoneC, TriFunction<? super T, ? super T2, ? super T3, ? extends R> zipFunction) abstract <T2,
R> Stream<R> Stream.zipWith
(Stream<T2> b, BiFunction<? super T, ? super T2, ? extends R> zipFunction) abstract <T2,
R> Stream<R> Stream.zipWith
(Stream<T2> b, T valueForNoneA, T2 valueForNoneB, BiFunction<? super T, ? super T2, ? extends R> zipFunction) abstract <T2,
T3, R> Stream<R> Stream.zipWith
(Collection<T2> b, Collection<T3> c, TriFunction<? super T, ? super T2, ? super T3, ? extends R> zipFunction) abstract <T2,
T3, R> Stream<R> Stream.zipWith
(Collection<T2> b, Collection<T3> c, T valueForNoneA, T2 valueForNoneB, T3 valueForNoneC, TriFunction<? super T, ? super T2, ? super T3, ? extends R> zipFunction) abstract <T2,
R> Stream<R> Stream.zipWith
(Collection<T2> b, BiFunction<? super T, ? super T2, ? extends R> zipFunction) abstract <T2,
R> Stream<R> Stream.zipWith
(Collection<T2> b, T valueForNoneA, T2 valueForNoneB, BiFunction<? super T, ? super T2, ? extends R> zipFunction)
mergeWith(ByteStream, ByteBiFunction)