Uses of Annotation Interface
com.landawn.abacus.annotation.IntermediateOp

Packages that use IntermediateOp

Package	Description
com.landawn.abacus.util
com.landawn.abacus.util.stream

Uses of IntermediateOp in com.landawn.abacus.util

Methods in com.landawn.abacus.util with annotations of type IntermediateOp

Modifier and Type	Method	Description
<TT, EE extends Exception> CheckedStream<TT,EE>	CheckedStream.__(Function<? super CheckedStream<T,E>,CheckedStream<TT,EE>> transfer)	Deprecated. replaced by CheckedStream.transform(Function)
CheckedStream<T,E>	CheckedStream.append(CheckedStream<T,E> s)
CheckedStream<T,E>	CheckedStream.append(Collection<? extends T> c)
final CheckedStream<T,E>	CheckedStream.append(T... a)
CheckedStream<T,E>	CheckedStream.appendIfEmpty(Throwables.Supplier<? extends CheckedStream<T,E>,? extends E> supplier)	Append if empty.
CheckedStream<T,E>	CheckedStream.appendIfEmpty(Collection<? extends T> c)
final CheckedStream<T,E>	CheckedStream.appendIfEmpty(T... a)
CheckedStream<T,Exception>	CheckedStream.cast()
CheckedStream<List<T>,E>	CheckedStream.collapse(Throwables.BiPredicate<? super T,? super T,? extends E> collapsible)
CheckedStream<T,E>	CheckedStream.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> CheckedStream<R,E>	CheckedStream.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>> CheckedStream<C,E>	CheckedStream.collapse(Throwables.BiPredicate<? super T,? super T,? extends E> collapsible, Supplier<? extends C> supplier)
<R> CheckedStream<R,E>	CheckedStream.collapse(Throwables.BiPredicate<? super T,? super T,? extends E> collapsible, Collector<? super T,?,R> collector)
<U> CheckedStream<U,E>	CheckedStream.collapse(Throwables.BiPredicate<? super T,? super T,? extends E> collapsible, U init, Throwables.BiFunction<U,? super T,U,? extends E> op)
CheckedStream<List<T>,E>	CheckedStream.collapse(Throwables.TriPredicate<? super T,? super T,? super T,? extends E> collapsible)
CheckedStream<T,E>	CheckedStream.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> CheckedStream<R,E>	CheckedStream.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>> CheckedStream<C,E>	CheckedStream.collapse(Throwables.TriPredicate<? super T,? super T,? super T,? extends E> collapsible, Supplier<? extends C> supplier)
<R> CheckedStream<R,E>	CheckedStream.collapse(Throwables.TriPredicate<? super T,? super T,? super T,? extends E> collapsible, Collector<? super T,?,R> collector)	Merge series of adjacent elements which satisfy the given predicate using the merger function and return a new stream.
<U> CheckedStream<U,E>	CheckedStream.collapse(Throwables.TriPredicate<? super T,? super T,? super T,? extends E> collapsible, U init, Throwables.BiFunction<U,? super T,U,? extends E> op)
<K> CheckedStream<Map.Entry<K,Integer>,E>	CheckedStream.countBy(Throwables.Function<? super T,? extends K,? extends E> keyMapper)
CheckedStream<T,E>	CheckedStream.cycled()
CheckedStream<T,E>	CheckedStream.cycled(long rounds)
CheckedStream<T,E>	CheckedStream.defaultIfEmpty(Throwables.Supplier<? extends CheckedStream<T,E>,? extends E> supplier)
CheckedStream<T,E>	CheckedStream.defaultIfEmpty(T defaultValue)
CheckedStream<T,E>	CheckedStream.delay(Duration delay)
CheckedStream<T,E>	CheckedStream.distinct()	Distinct and filter by occurrences.
CheckedStream<T,E>	CheckedStream.distinct(Throwables.BinaryOperator<T,? extends E> mergeFunction)	Distinct and filter by occurrences.
CheckedStream<T,E>	CheckedStream.distinct(Throwables.Predicate<? super Long,? extends E> occurrencesFilter)	Distinct and filter by occurrences.
<K> CheckedStream<T,E>	CheckedStream.distinctBy(Throwables.Function<? super T,K,? extends E> keyMapper)	Distinct by the value mapped from keyMapper .
<K> CheckedStream<T,E>	CheckedStream.distinctBy(Throwables.Function<? super T,K,? extends E> keyMapper, Throwables.BinaryOperator<T,? extends E> mergeFunction)	Distinct and filter by occurrences.
<K> CheckedStream<T,E>	CheckedStream.distinctBy(Throwables.Function<? super T,K,? extends E> keyMapper, Throwables.Predicate<? super Map.Entry<Keyed<K,T>,Long>,? extends E> occurrencesFilter)	Distinct and filter by occurrences.
<K> CheckedStream<T,E>	CheckedStream.distinctLimitBy(Throwables.Function<? super T,K,? extends E> keyMapper, Throwables.BiFunction<? super K,? super List<T>,Integer,? extends E> limit)	Distinct and limit by keyMapper
CheckedStream<T,E>	CheckedStream.dropWhile(Throwables.Predicate<? super T,? extends E> predicate)
CheckedStream<T,E>	CheckedStream.dropWhile(Throwables.Predicate<? super T,? extends E> predicate, Throwables.Consumer<? super T,? extends E> actionOnDroppedItem)
CheckedStream<T,E>	CheckedStream.filter(Throwables.Predicate<? super T,? extends E> predicate)
CheckedStream<T,E>	CheckedStream.filter(Throwables.Predicate<? super T,? extends E> predicate, Throwables.Consumer<? super T,? extends E> actionOnDroppedItem)
CheckedStream<T,Exception>	CheckedStream.filterE(Throwables.Predicate<? super T,? extends Exception> predicate)
<R> CheckedStream<R,E>	CheckedStream.flatmap(Throwables.Function<? super T,? extends Collection<? extends R>,? extends E> mapper)
<R> CheckedStream<R,E>	CheckedStream.flatMap(Throwables.Function<? super T,? extends CheckedStream<? extends R,? extends E>,? extends E> mapper)
<R> CheckedStream<R,Exception>	CheckedStream.flatmapE(Throwables.Function<? super T,? extends Collection<? extends R>,? extends Exception> mapper)
<R> CheckedStream<R,Exception>	CheckedStream.flatMapE(Throwables.Function<? super T,? extends CheckedStream<? extends R,? extends Exception>,? extends Exception> mapper)
<R> CheckedStream<R,E>	CheckedStream.flatMapIfNotNull(Throwables.Function<? super T,? extends Collection<? extends R>,? extends E> mapper)
<U, R> CheckedStream<R,E>	CheckedStream.flatMapIfNotNull(Throwables.Function<? super T,? extends Collection<? extends U>,? extends E> mapper, Throwables.Function<? super U,? extends Collection<? extends R>,? extends E> mapper2)
CheckedStream<Boolean,E>	CheckedStream.flatMapToBoolean(Throwables.Function<? super T,boolean[],? extends E> mapper)
CheckedStream<Byte,E>	CheckedStream.flatMapToByte(Throwables.Function<? super T,byte[],? extends E> mapper)
CheckedStream<Character,E>	CheckedStream.flatMapToChar(Throwables.Function<? super T,char[],? extends E> mapper)
CheckedStream<Double,E>	CheckedStream.flatMapToDouble(Throwables.Function<? super T,double[],? extends E> mapper)
CheckedStream<Float,E>	CheckedStream.flatMapToFloat(Throwables.Function<? super T,float[],? extends E> mapper)
CheckedStream<Integer,E>	CheckedStream.flatMapToInteger(Throwables.Function<? super T,int[],? extends E> mapper)
CheckedStream<Long,E>	CheckedStream.flatMapToLong(Throwables.Function<? super T,long[],? extends E> mapper)
CheckedStream<Short,E>	CheckedStream.flatMapToShort(Throwables.Function<? super T,short[],? extends E> mapper)
<R> CheckedStream<R,E>	CheckedStream.flattmap(Throwables.Function<? super T,? extends Stream<? extends R>,? extends E> mapper)
<R> CheckedStream<R,E>	CheckedStream.flattMap(Throwables.Function<? super T,R[],? extends E> mapper)
<K> CheckedStream<Map.Entry<K,List<T>>,E>	CheckedStream.groupBy(Throwables.Function<? super T,? extends K,? extends E> keyMapper)
<K, V> CheckedStream<Map.Entry<K,List<V>>,E>	CheckedStream.groupBy(Throwables.Function<? super T,? extends K,? extends E> keyMapper, Throwables.Function<? super T,? extends V,? extends E> valueMapper)
<K, V> CheckedStream<Map.Entry<K,V>,E>	CheckedStream.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> CheckedStream<Map.Entry<K,V>,E>	CheckedStream.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> CheckedStream<Map.Entry<K,List<V>>,E>	CheckedStream.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, D> CheckedStream<Map.Entry<K,D>,E>	CheckedStream.groupBy(Throwables.Function<? super T,? extends K,? extends E> keyMapper, Throwables.Function<? super T,? extends V,? extends E> valueMapper, Collector<? super V,?,D> downstream)
<K, V, D> CheckedStream<Map.Entry<K,D>,E>	CheckedStream.groupBy(Throwables.Function<? super T,? extends K,? extends E> keyMapper, Throwables.Function<? super T,? extends V,? extends E> valueMapper, Collector<? super V,?,D> downstream, Supplier<? extends Map<K,D>> mapFactory)
<K> CheckedStream<Map.Entry<K,List<T>>,E>	CheckedStream.groupBy(Throwables.Function<? super T,? extends K,? extends E> keyMapper, Supplier<? extends Map<K,List<T>>> mapFactory)
<K, D> CheckedStream<Map.Entry<K,D>,E>	CheckedStream.groupBy(Throwables.Function<? super T,? extends K,? extends E> keyMapper, Collector<? super T,?,D> downstream)
<K, D> CheckedStream<Map.Entry<K,D>,E>	CheckedStream.groupBy(Throwables.Function<? super T,? extends K,? extends E> keyMapper, Collector<? super T,?,D> downstream, Supplier<? extends Map<K,D>> mapFactory)
CheckedStream<Indexed<T>,E>	CheckedStream.indexed()
CheckedStream<T,E>	CheckedStream.intersperse(T delimiter)
CheckedStream<T,E>	CheckedStream.last(int n)	A queue with size up to n will be maintained to filter out the last n elements.
CheckedStream<T,E>	CheckedStream.limit(long maxSize)
<R> CheckedStream<R,E>	CheckedStream.map(Throwables.Function<? super T,? extends R,? extends E> mapper)
<U> CheckedStream<U,Exception>	CheckedStream.mapE(Throwables.Function<? super T,? extends U,? extends Exception> mapper)
CheckedStream<T,E>	CheckedStream.mapFirst(Throwables.Function<? super T,? extends T,? extends E> mapperForFirst)
<R> CheckedStream<R,E>	CheckedStream.mapFirstOrElse(Throwables.Function<? super T,? extends R,E> mapperForFirst, Throwables.Function<? super T,? extends R,E> mapperForElse)
<R> CheckedStream<R,E>	CheckedStream.mapIfNotNull(Throwables.Function<? super T,? extends R,? extends E> mapper)	Convert the element to a new value if it's not null, otherwise skip it.
CheckedStream<T,E>	CheckedStream.mapLast(Throwables.Function<? super T,? extends T,? extends E> mapperForLast)
<R> CheckedStream<R,E>	CheckedStream.mapLastOrElse(Throwables.Function<? super T,? extends R,E> mapperForLast, Throwables.Function<? super T,? extends R,E> mapperForElse)
<R> CheckedStream<R,E>	CheckedStream.mapPartial(Throwables.Function<? super T,u.Optional<? extends R>,E> mapper)	Note: copied from StreamEx: https://github.com/amaembo/streamex
<R> CheckedStream<R,E>	CheckedStream.mapPartialJdk(Throwables.Function<? super T,Optional<? extends R>,E> mapper)	Note: copied from StreamEx: https://github.com/amaembo/streamex
CheckedStream<Double,E>	CheckedStream.mapPartialToDouble(Throwables.Function<? super T,u.OptionalDouble,E> mapper)	Note: copied from StreamEx: https://github.com/amaembo/streamex
CheckedStream<Double,E>	CheckedStream.mapPartialToDoubleJdk(Throwables.Function<? super T,OptionalDouble,E> mapper)	Note: copied from StreamEx: https://github.com/amaembo/streamex
CheckedStream<Integer,E>	CheckedStream.mapPartialToInt(Throwables.Function<? super T,u.OptionalInt,E> mapper)	Note: copied from StreamEx: https://github.com/amaembo/streamex
CheckedStream<Integer,E>	CheckedStream.mapPartialToIntJdk(Throwables.Function<? super T,OptionalInt,E> mapper)	Note: copied from StreamEx: https://github.com/amaembo/streamex
CheckedStream<Long,E>	CheckedStream.mapPartialToLong(Throwables.Function<? super T,u.OptionalLong,E> mapper)	Note: copied from StreamEx: https://github.com/amaembo/streamex
CheckedStream<Long,E>	CheckedStream.mapPartialToLongJdk(Throwables.Function<? super T,OptionalLong,E> mapper)	Note: copied from StreamEx: https://github.com/amaembo/streamex
CheckedStream<T,E>	CheckedStream.mergeWith(CheckedStream<? extends T,E> b, Throwables.BiFunction<? super T,? super T,MergeResult,E> nextSelector)
CheckedStream<T,E>	CheckedStream.mergeWith(Collection<? extends T> b, Throwables.BiFunction<? super T,? super T,MergeResult,E> nextSelector)
CheckedStream<T,E>	CheckedStream.onClose(Throwables.Runnable<? extends E> closeHandler)
CheckedStream<T,E>	CheckedStream.onEach(Throwables.Consumer<? super T,? extends E> action)
CheckedStream<T,Exception>	CheckedStream.onEachE(Throwables.Consumer<? super T,? extends Exception> action)
CheckedStream<Map.Entry<Boolean,List<T>>,E>	CheckedStream.partitionBy(Throwables.Predicate<? super T,E> predicate)
<D> CheckedStream<Map.Entry<Boolean,D>,E>	CheckedStream.partitionBy(Throwables.Predicate<? super T,E> predicate, Collector<? super T,?,D> downstream)
CheckedStream<T,E>	CheckedStream.peek(Throwables.Consumer<? super T,? extends E> action)
CheckedStream<T,E>	CheckedStream.peekFirst(Throwables.Consumer<? super T,? extends E> action)
CheckedStream<T,E>	CheckedStream.peekIf(Throwables.BiPredicate<? super T,? super Long,E> predicate, Consumer<? super T> action)
CheckedStream<T,E>	CheckedStream.peekIf(Throwables.Predicate<? super T,E> predicate, Throwables.Consumer<? super T,E> action)
CheckedStream<T,E>	CheckedStream.peekLast(Throwables.Consumer<? super T,? extends E> action)
CheckedStream<T,E>	CheckedStream.prepend(CheckedStream<T,E> s)
CheckedStream<T,E>	CheckedStream.prepend(Collection<? extends T> c)
final CheckedStream<T,E>	CheckedStream.prepend(T... a)
CheckedStream<T,E>	CheckedStream.rateLimited(double permitsPerSecond)
CheckedStream<T,E>	CheckedStream.rateLimited(RateLimiter rateLimiter)
CheckedStream<T,E>	CheckedStream.reversed()
CheckedStream<T,E>	CheckedStream.reverseSorted()
CheckedStream<T,E>	CheckedStream.reverseSorted(Comparator<? super T> comparator)
CheckedStream<T,E>	CheckedStream.reverseSortedBy(Function<? super T,? extends Comparable> keyMapper)
CheckedStream<T,E>	CheckedStream.reverseSortedByDouble(ToDoubleFunction<? super T> keyMapper)
CheckedStream<T,E>	CheckedStream.reverseSortedByInt(ToIntFunction<? super T> keyMapper)
CheckedStream<T,E>	CheckedStream.reverseSortedByLong(ToLongFunction<? super T> keyMapper)
CheckedStream<T,E>	CheckedStream.rotated(int distance)
CheckedStream<T,E>	CheckedStream.saveEach(File output)
CheckedStream<T,E>	CheckedStream.saveEach(File output, Throwables.BiConsumer<? super T,Writer,IOException> writeLine)
CheckedStream<T,E>	CheckedStream.saveEach(File output, Throwables.Function<? super T,String,E> toLine)
CheckedStream<T,E>	CheckedStream.saveEach(OutputStream output, Throwables.Function<? super T,String,E> toLine)
CheckedStream<T,E>	CheckedStream.saveEach(Writer output, Throwables.BiConsumer<? super T,Writer,IOException> writeLine)
CheckedStream<T,E>	CheckedStream.saveEach(Writer output, Throwables.Function<? super T,String,E> toLine)
CheckedStream<T,E>	CheckedStream.saveEach(Connection conn, String insertSQL, Throwables.BiConsumer<? super T,? super PreparedStatement,SQLException> stmtSetter)	To support batch call, please use onEach or onEachE.
CheckedStream<T,E>	CheckedStream.saveEach(PreparedStatement stmt, Throwables.BiConsumer<? super T,? super PreparedStatement,SQLException> stmtSetter)	To support batch call, please use onEach or onEachE.
CheckedStream<T,E>	CheckedStream.saveEach(DataSource ds, String insertSQL, Throwables.BiConsumer<? super T,? super PreparedStatement,SQLException> stmtSetter)	To support batch/parallel call, please use onEach or onEachE.
CheckedStream<T,E>	CheckedStream.scan(Throwables.BiFunction<? super T,? super T,T,? extends E> accumulator)
<U> CheckedStream<U,E>	CheckedStream.scan(U init, Throwables.BiFunction<U,? super T,U,? extends E> accumulator)
<U> CheckedStream<U,E>	CheckedStream.scan(U init, Throwables.BiFunction<U,? super T,U,? extends E> accumulator, boolean initIncluded)
CheckedStream<T,E>	CheckedStream.shuffled()
CheckedStream<T,E>	CheckedStream.shuffled(Random rnd)
CheckedStream<T,E>	CheckedStream.skip(long n)
CheckedStream<T,E>	CheckedStream.skipLast(int n)
CheckedStream<T,E>	CheckedStream.skipNull()	Deprecated. Use CheckedStream.skipNulls() instead
CheckedStream<T,E>	CheckedStream.skipNulls()
CheckedStream<T,E>	CheckedStream.skipUntil(Throwables.Predicate<? super T,? extends E> predicate)
CheckedStream<Stream<T>,E>	CheckedStream.sliding(int windowSize, int increment)
<C extends Collection<T>> CheckedStream<C,E>	CheckedStream.sliding(int windowSize, int increment, IntFunction<? extends C> collectionSupplier)
<R> CheckedStream<R,E>	CheckedStream.sliding(int windowSize, int increment, Collector<? super T,?,R> collector)
<R> CheckedStream<R,E>	CheckedStream.slidingMap(int increment, boolean ignoreNotPaired, Throwables.BiFunction<? super T,? super T,R,? extends E> mapper)
<R> CheckedStream<R,E>	CheckedStream.slidingMap(int increment, boolean ignoreNotPaired, Throwables.TriFunction<? super T,? super T,? super T,R,? extends E> mapper)
<R> CheckedStream<R,E>	CheckedStream.slidingMap(int increment, Throwables.BiFunction<? super T,? super T,R,? extends E> mapper)
<R> CheckedStream<R,E>	CheckedStream.slidingMap(int increment, Throwables.TriFunction<? super T,? super T,? super T,R,? extends E> mapper)
<R> CheckedStream<R,E>	CheckedStream.slidingMap(Throwables.BiFunction<? super T,? super T,R,? extends E> mapper)
<R> CheckedStream<R,E>	CheckedStream.slidingMap(Throwables.TriFunction<? super T,? super T,? super T,R,? extends E> mapper)
CheckedStream<List<T>,E>	CheckedStream.slidingToList(int windowSize, int increment)	Sliding to list.
CheckedStream<Set<T>,E>	CheckedStream.slidingToSet(int windowSize, int increment)	Sliding to set.
CheckedStream<T,E>	CheckedStream.sorted()
CheckedStream<T,E>	CheckedStream.sorted(Comparator<? super T> comparator)
CheckedStream<T,E>	CheckedStream.sortedBy(Function<? super T,? extends Comparable> keyMapper)
CheckedStream<T,E>	CheckedStream.sortedByDouble(ToDoubleFunction<? super T> keyMapper)
CheckedStream<T,E>	CheckedStream.sortedByInt(ToIntFunction<? super T> keyMapper)
CheckedStream<T,E>	CheckedStream.sortedByLong(ToLongFunction<? super T> keyMapper)
CheckedStream<Stream<T>,E>	CheckedStream.split(int chunkSize)
<C extends Collection<T>> CheckedStream<C,E>	CheckedStream.split(int chunkSize, IntFunction<? extends C> collectionSupplier)	Returns CheckedStream of C with consecutive sub sequences of the elements, each of the same size (the final sequence may be smaller).
<R> CheckedStream<R,E>	CheckedStream.split(int chunkSize, Collector<? super T,?,R> collector)
CheckedStream<CheckedStream<T,E>,E>	CheckedStream.splitAt(int where)
CheckedStream<CheckedStream<T,E>,E>	CheckedStream.splitAt(Throwables.Predicate<? super T,? extends E> where)
CheckedStream<List<T>,E>	CheckedStream.splitToList(int chunkSize)	Returns CheckedStream of List<T> with consecutive sub sequences of the elements, each of the same size (the final sequence may be smaller).
CheckedStream<Set<T>,E>	CheckedStream.splitToSet(int chunkSize)	Returns CheckedStream of Set<T> with consecutive sub sequences of the elements, each of the same size (the final sequence may be smaller).
<R> CheckedStream<R,E>	CheckedStream.sps(int maxThreadNum, Function<? super Stream<T>,? extends Stream<? extends R>> ops)	Temporarily switch the stream to parallel stream for operation ops and then switch back to sequence stream.
<R> CheckedStream<R,E>	CheckedStream.sps(Function<? super Stream<T>,? extends Stream<? extends R>> ops)	Temporarily switch the stream to parallel stream for operation ops and then switch back to sequence stream.
CheckedStream<T,E>	CheckedStream.spsFilter(int maxThreadNum, Throwables.Predicate<? super T,E> predicate)	Temporarily switch the stream to parallel stream for operation filter and then switch back to sequence stream.
CheckedStream<T,E>	CheckedStream.spsFilter(Throwables.Predicate<? super T,E> predicate)	Temporarily switch the stream to parallel stream for operation filter and then switch back to sequence stream.
CheckedStream<T,Exception>	CheckedStream.spsFilterE(int maxThreadNum, Throwables.Predicate<? super T,? extends Exception> predicate)	Temporarily switch the stream to parallel stream for operation filter and then switch back to sequence stream.
CheckedStream<T,Exception>	CheckedStream.spsFilterE(Throwables.Predicate<? super T,? extends Exception> predicate)	Temporarily switch the stream to parallel stream for operation filter and then switch back to sequence stream.
<R> CheckedStream<R,E>	CheckedStream.spsFlatmap(int maxThreadNum, Throwables.Function<? super T,? extends Collection<? extends R>,E> mapper)	Temporarily switch the stream to parallel stream for operation flatMap and then switch back to sequence stream.
<R> CheckedStream<R,E>	CheckedStream.spsFlatmap(Throwables.Function<? super T,? extends Collection<? extends R>,E> mapper)	Temporarily switch the stream to parallel stream for operation flatMap and then switch back to sequence stream.
<R> CheckedStream<R,E>	CheckedStream.spsFlatMap(int maxThreadNum, Throwables.Function<? super T,? extends Stream<? extends R>,E> mapper)	Temporarily switch the stream to parallel stream for operation flatMap and then switch back to sequence stream.
<R> CheckedStream<R,E>	CheckedStream.spsFlatMap(Throwables.Function<? super T,? extends Stream<? extends R>,E> mapper)	Temporarily switch the stream to parallel stream for operation flatMap and then switch back to sequence stream.
<R> CheckedStream<R,Exception>	CheckedStream.spsFlatmapE(int maxThreadNum, Throwables.Function<? super T,? extends Collection<? extends R>,? extends Exception> mapper)	Temporarily switch the stream to parallel stream for operation flatMap and then switch back to sequence stream.
<R> CheckedStream<R,Exception>	CheckedStream.spsFlatmapE(Throwables.Function<? super T,? extends Collection<? extends R>,? extends Exception> mapper)	Temporarily switch the stream to parallel stream for operation flatMap and then switch back to sequence stream.
<R> CheckedStream<R,Exception>	CheckedStream.spsFlatMapE(int maxThreadNum, Throwables.Function<? super T,? extends Stream<? extends R>,? extends Exception> mapper)	Temporarily switch the stream to parallel stream for operation flatMap and then switch back to sequence stream.
<R> CheckedStream<R,Exception>	CheckedStream.spsFlatMapE(Throwables.Function<? super T,? extends Stream<? extends R>,? extends Exception> mapper)	Temporarily switch the stream to parallel stream for operation flatMap and then switch back to sequence stream.
<R> CheckedStream<R,E>	CheckedStream.spsMap(int maxThreadNum, Throwables.Function<? super T,? extends R,E> mapper)	Temporarily switch the stream to parallel stream for operation map and then switch back to sequence stream.
<R> CheckedStream<R,E>	CheckedStream.spsMap(Throwables.Function<? super T,? extends R,E> mapper)	Temporarily switch the stream to parallel stream for operation map and then switch back to sequence stream.
<U> CheckedStream<U,Exception>	CheckedStream.spsMapE(int maxThreadNum, Throwables.Function<? super T,? extends U,? extends Exception> mapper)	Temporarily switch the stream to parallel stream for operation map and then switch back to sequence stream.
<U> CheckedStream<U,Exception>	CheckedStream.spsMapE(Throwables.Function<? super T,? extends U,? extends Exception> mapper)	Temporarily switch the stream to parallel stream for operation map and then switch back to sequence stream.
CheckedStream<T,E>	CheckedStream.spsOnEach(int maxThreadNum, Throwables.Consumer<? super T,E> action)	Temporarily switch the stream to parallel stream for operation onEach and then switch back to sequence stream.
CheckedStream<T,E>	CheckedStream.spsOnEach(Throwables.Consumer<? super T,E> action)	Temporarily switch the stream to parallel stream for operation onEach and then switch back to sequence stream.
CheckedStream<T,Exception>	CheckedStream.spsOnEachE(int maxThreadNum, Throwables.Consumer<? super T,? extends Exception> action)	Temporarily switch the stream to parallel stream for operation onEach and then switch back to sequence stream.
CheckedStream<T,Exception>	CheckedStream.spsOnEachE(Throwables.Consumer<? super T,? extends Exception> action)	Temporarily switch the stream to parallel stream for operation onEach and then switch back to sequence stream.
CheckedStream<T,E>	CheckedStream.step(long step)
CheckedStream<T,E>	CheckedStream.takeWhile(Throwables.Predicate<? super T,? extends E> predicate)
CheckedStream<T,E>	CheckedStream.throwIfEmpty(Supplier<? extends E> exceptionSupplier)
CheckedStream<Timed<T>,E>	CheckedStream.timed()
Stream<T>	CheckedStream.toJdkStream()
CheckedStream<T,E>	CheckedStream.top(int n)
CheckedStream<T,E>	CheckedStream.top(int n, Comparator<? super T> comparator)
<TT, EE extends Exception> CheckedStream<TT,EE>	CheckedStream.transform(Function<? super CheckedStream<T,E>,CheckedStream<TT,EE>> transfer)
Stream<T>	CheckedStream.unchecked()
<T2, T3, R> CheckedStream<R,E>	CheckedStream.zipWith(CheckedStream<T2,E> b, CheckedStream<T3,E> c, Throwables.TriFunction<? super T,? super T2,? super T3,? extends R,? extends E> zipFunction)
<T2, T3, R> CheckedStream<R,E>	CheckedStream.zipWith(CheckedStream<T2,E> b, CheckedStream<T3,E> c, T valueForNoneA, T2 valueForNoneB, T3 valueForNoneC, Throwables.TriFunction<? super T,? super T2,? super T3,? extends R,? extends E> zipFunction)
<T2, R> CheckedStream<R,E>	CheckedStream.zipWith(CheckedStream<T2,E> b, Throwables.BiFunction<? super T,? super T2,? extends R,? extends E> zipFunction)
<T2, R> CheckedStream<R,E>	CheckedStream.zipWith(CheckedStream<T2,E> b, T valueForNoneA, T2 valueForNoneB, Throwables.BiFunction<? super T,? super T2,? extends R,? extends E> zipFunction)
<T2, R> CheckedStream<R,E>	CheckedStream.zipWith(Collection<T2> b, Throwables.BiFunction<? super T,? super T2,? extends R,? extends E> zipFunction)
<T2, T3, R> CheckedStream<R,E>	CheckedStream.zipWith(Collection<T2> b, Collection<T3> c, Throwables.TriFunction<? super T,? super T2,? super T3,? extends R,? extends E> zipFunction)
<T2, T3, R> CheckedStream<R,E>	CheckedStream.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> CheckedStream<R,E>	CheckedStream.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

Methods in com.landawn.abacus.util.stream with annotations of type IntermediateOp

Modifier and Type	Method	Description
<SS extends BaseStream> SS	BaseStream.__(Function<? super S,? extends SS> transfer)	Deprecated. replaced by BaseStream.transform(Function)
S	BaseStream.append(OT op)
S	BaseStream.append(S stream)
abstract ByteStream	ByteStream.append(byte... a)
abstract CharStream	CharStream.append(char... a)
abstract DoubleStream	DoubleStream.append(double... a)
<M extends Map<? extends K, ? extends V>> EntryStream<K,V>	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)
abstract Stream<T>	Stream.append(Collection<? extends T> c)
final Stream<T>	Stream.append(T... a)
S	BaseStream.appendIfEmpty(Supplier<? extends S> supplier)
abstract ByteStream	ByteStream.appendIfEmpty(byte... a)
abstract CharStream	CharStream.appendIfEmpty(char... a)
abstract DoubleStream	DoubleStream.appendIfEmpty(double... a)
<M extends Map<? extends K, ? extends V>> EntryStream<K,V>	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)
abstract Stream<T>	Stream.appendIfEmpty(Collection<? extends T> c)
final Stream<T>	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 a LongStream consisting of the elements of this stream, converted to long.
abstract IntStream	ShortStream.asIntStream()
abstract LongStream	IntStream.asLongStream()
abstract Stream<Byte>	ByteStream.boxed()
abstract Stream<Character>	CharStream.boxed()	Returns a Stream consisting of the elements of this stream, each boxed to an Chareger.
abstract Stream<Double>	DoubleStream.boxed()
abstract Stream<Float>	FloatStream.boxed()
abstract Stream<Integer>	IntStream.boxed()
abstract Stream<Long>	LongStream.boxed()
abstract Stream<Short>	ShortStream.boxed()
abstract Stream<T>	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.
abstract Stream<T>	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.
abstract Stream<List<T>>	Stream.cartesianProduct(Collection<? extends Collection<? extends T>> cs)
final Stream<List<T>>	Stream.cartesianProduct(Collection<? extends T>... cs)
<KK, VV> EntryStream<KK,VV>	EntryStream.chain(Function<? super Stream<Map.Entry<K,V>>,? extends Stream<Map.Entry<KK,VV>>> transfer)
<E extends Exception> CheckedStream<T,E>	Stream.checked()
<E extends Exception> CheckedStream<T,E>	Stream.checked(Class<E> exceptionType)
abstract Stream<ByteList>	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)
abstract Stream<CharList>	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)
abstract Stream<FloatList>	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)
abstract Stream<IntList>	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)
abstract Stream<LongList>	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)
abstract Stream<ShortList>	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)
abstract Stream<List<T>>	Stream.collapse(TriPredicate<? super T,? super T,? super T> collapsible)
abstract Stream<T>	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> Stream<R>	Stream.collapse(TriPredicate<? super T,? super T,? super T> collapsible, Collector<? super T,?,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)
abstract Stream<List<T>>	Stream.collapse(BiPredicate<? super T,? super T> collapsible)
abstract Stream<T>	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> Stream<R>	Stream.collapse(BiPredicate<? super T,? super T> collapsible, Collector<? super T,?,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(BiPredicate<? super T,? super T> collapsible, U init, BiFunction<U,? super T,U> op)
Stream<List<V>>	EntryStream.collapseByKey(BiPredicate<? super K,? super K> collapsible)
<R> Stream<R>	EntryStream.collapseByKey(BiPredicate<? super K,? super K> collapsible, Collector<? super V,?,R> collector)	Merge series of adjacent elements which satisfy the given predicate using the merger function and return a new stream.
abstract Stream<List<T>>	Stream.combinations()	Stream.of(1, 2, 3).combinations().forEach(Fn.println()); // output [] [1] [2] [3] [1, 2] [1, 3] [2, 3] [1, 2, 3]
abstract Stream<List<T>>	Stream.combinations(int len)	Stream.of(1, 2, 3).combinations(2).forEach(Fn.println()); // output [1, 2] [1, 3] [2, 3]
abstract Stream<List<T>>	Stream.combinations(int len, boolean repeat)	It's same as N.cartesianProduct(N.repeat(toList(), len)) if repeat is true.
<K> Stream<Map.Entry<K,Integer>>	Stream.countBy(Function<? super T,? extends K> keyMapper)
<K> EntryStream<K,Integer>	Stream.countByToEntry(Function<? super T,? extends K> keyMapper)
S	BaseStream.cycled()	This method only runs sequentially, even in parallel stream and retrieved elements will be saved in memory for next cycle.
S	BaseStream.cycled(long rounds)	This method only runs sequentially, even in parallel stream and retrieved elements will be saved in memory for next cycle.
final Stream<T>	Stream.defaultIfEmpty(Supplier<? extends Stream<T>> supplier)
final Stream<T>	Stream.defaultIfEmpty(T defaultValue)
S	BaseStream.delay(Duration delay)
S	BaseStream.difference(Collection<?> c)	This method only runs sequentially, even in parallel stream.
abstract <U> Stream<T>	Stream.difference(Function<? super T,? extends U> mapper, Collection<U> c)	Except with the specified Collection by the values mapped by mapper.
S	BaseStream.distinct()	Returns a stream consisting of the distinct elements of this stream.
EntryStream<K,V>	EntryStream.distinct(BinaryOperator<Map.Entry<K,V>> mergeFunction)
EntryStream<K,V>	EntryStream.distinct(Predicate<? super Long> occurrencesFilter)
Stream<T>	Stream.distinct(BinaryOperator<T> mergeFunction)	Distinct and merge duplicated elements.
Stream<T>	Stream.distinct(Predicate<? super Long> occurrencesFilter)	Distinct and filter by occurrences.
<KK> EntryStream<K,V>	EntryStream.distinctBy(Function<? super Map.Entry<K,V>,KK> keyMapper)
<KK> EntryStream<K,V>	EntryStream.distinctBy(Function<? super Map.Entry<K,V>,KK> keyMapper, BinaryOperator<Map.Entry<K,V>> mergeFunction)
<KK> EntryStream<K,V>	EntryStream.distinctBy(Function<? super Map.Entry<K,V>,KK> keyMapper, Predicate<? super Map.Entry<Keyed<KK,Map.Entry<K,V>>,Long>> occurrencesFilter)
abstract Stream<T>	Stream.distinctBy(Function<? super T,?> keyMapper)	Distinct by the value mapped from keyMapper.
<K> Stream<T>	Stream.distinctBy(Function<? super T,K> keyMapper, BinaryOperator<T> mergeFunction)	Distinct and merge duplicated elements.
<K> Stream<T>	Stream.distinctBy(Function<? super T,K> keyMapper, Predicate<? super Map.Entry<Keyed<K,T>,Long>> occurrencesFilter)	Distinct and filter by occurrences.
EntryStream<K,V>	EntryStream.distinctByKey()
EntryStream<K,V>	EntryStream.distinctByValue()
<KK> EntryStream<K,V>	EntryStream.distinctLimitBy(Function<? super Map.Entry<K,V>,KK> keyMapper, BiFunction<? super KK,? super List<Map.Entry<K,V>>,Integer> limit)
<K> Stream<T>	Stream.distinctLimitBy(Function<? super T,K> keyMapper, BiFunction<? super K,? super List<T>,Integer> limit)	Distinct and limit by keyMapper
S	BaseStream.dropWhile(P predicate)	Remove the elements until the given predicate returns false.
S	BaseStream.dropWhile(P predicate, C actionOnDroppedItem)	Remove the elements until the given predicate returns false.
EntryStream<K,V>	EntryStream.dropWhile(BiPredicate<? super K,? super V> predicate)
Stream<Map.Entry<K,V>>	EntryStream.entries()
S	BaseStream.filter(P predicate)	Returns a stream consisting of the elements of this stream that match the given predicate.
S	BaseStream.filter(P predicate, C actionOnDroppedItem)	Returns a stream consisting of the elements of this stream that match the given predicate.
EntryStream<K,V>	EntryStream.filter(BiPredicate<? super K,? super V> predicate)
EntryStream<K,V>	EntryStream.filterByKey(Predicate<? super K> keyPredicate)
EntryStream<K,V>	EntryStream.filterByValue(Predicate<? super V> valuePredicate)
Stream<T>	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>	Stream.flatMap(Function<? super T,? extends Stream<? extends R>> mapper)
<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)
abstract DoubleStream	DoubleStream.flattmap(DoubleFunction<? extends DoubleStream> mapper)
abstract IntStream	IntStream.flattmap(IntFunction<? extends IntStream> mapper)
abstract LongStream	LongStream.flattmap(LongFunction<? extends LongStream> mapper)
abstract <R> Stream<R>	Stream.flattmap(Function<? super T,? extends Stream<? extends R>> mapper)
<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>	Stream.flattMap(Function<? super T,R[]> mapper)
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<K,V>	EntryStream.groupBy(BinaryOperator<V> mergeFunction)
EntryStream<K,V>	EntryStream.groupBy(BinaryOperator<V> mergeFunction, Supplier<? extends Map<K,V>> 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)
<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, D> EntryStream<KK,D>	EntryStream.groupBy(Function<? super Map.Entry<K,V>,? extends KK> keyMapper, Collector<? super Map.Entry<K,V>,?,D> downstream)
<KK, D> EntryStream<KK,D>	EntryStream.groupBy(Function<? super Map.Entry<K,V>,? extends KK> keyMapper, Collector<? super Map.Entry<K,V>,?,D> downstream, Supplier<? extends Map<KK,D>> mapFactory)
EntryStream<K,List<V>>	EntryStream.groupBy(Supplier<? extends Map<K,List<V>>> mapFactory)
<D> EntryStream<K,D>	EntryStream.groupBy(Collector<? super Map.Entry<K,V>,?,D> downstream)
<D> EntryStream<K,D>	EntryStream.groupBy(Collector<? super Map.Entry<K,V>,?,D> downstream, Supplier<? extends Map<K,D>> mapFactory)
abstract <K> Stream<Map.Entry<K,List<T>>>	Stream.groupBy(Function<? super T,? extends K> keyMapper)
abstract <K, V> Stream<Map.Entry<K,List<V>>>	Stream.groupBy(Function<? super T,? extends K> keyMapper, Function<? super T,? extends V> valueMapper)
abstract <K, V> Stream<Map.Entry<K,V>>	Stream.groupBy(Function<? super T,? extends K> keyMapper, Function<? super T,? extends V> valueMapper, BinaryOperator<V> mergeFunction)
abstract <K, V> Stream<Map.Entry<K,V>>	Stream.groupBy(Function<? super T,? extends K> keyMapper, Function<? super T,? extends V> valueMapper, BinaryOperator<V> mergeFunction, Supplier<? extends Map<K,V>> mapFactory)
abstract <K, V> Stream<Map.Entry<K,List<V>>>	Stream.groupBy(Function<? super T,? extends K> keyMapper, Function<? super T,? extends V> valueMapper, Supplier<? extends Map<K,List<V>>> mapFactory)
abstract <K, V, D> Stream<Map.Entry<K,D>>	Stream.groupBy(Function<? super T,? extends K> keyMapper, Function<? super T,? extends V> valueMapper, Collector<? super V,?,D> downstream)
abstract <K, V, D> Stream<Map.Entry<K,D>>	Stream.groupBy(Function<? super T,? extends K> keyMapper, Function<? super T,? extends V> valueMapper, Collector<? super V,?,D> downstream, Supplier<? extends Map<K,D>> mapFactory)
abstract <K> Stream<Map.Entry<K,List<T>>>	Stream.groupBy(Function<? super T,? extends K> keyMapper, Supplier<? extends Map<K,List<T>>> mapFactory)
abstract <K, D> Stream<Map.Entry<K,D>>	Stream.groupBy(Function<? super T,? extends K> keyMapper, Collector<? super T,?,D> downstream)
abstract <K, D> Stream<Map.Entry<K,D>>	Stream.groupBy(Function<? super T,? extends K> keyMapper, Collector<? super T,?,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, D> EntryStream<K,D>	Stream.groupByToEntry(Function<? super T,? extends K> keyMapper, Function<? super T,? extends V> valueMapper, Collector<? super V,?,D> downstream)
abstract <K, V, D> EntryStream<K,D>	Stream.groupByToEntry(Function<? super T,? extends K> keyMapper, Function<? super T,? extends V> valueMapper, Collector<? super V,?,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, D> EntryStream<K,D>	Stream.groupByToEntry(Function<? super T,? extends K> keyMapper, Collector<? super T,?,D> downstream)
abstract <K, D> EntryStream<K,D>	Stream.groupByToEntry(Function<? super T,? extends K> keyMapper, Collector<? super T,?,D> downstream, Supplier<? extends Map<K,D>> mapFactory)
Stream<IT>	BaseStream.indexed()	This method only runs sequentially, even in parallel stream.
S	BaseStream.intersection(Collection<?> c)	This method only runs sequentially, even in parallel stream.
abstract <U> Stream<T>	Stream.intersection(Function<? super T,? extends U> mapper, Collection<U> c)	Intersect with the specified Collection by the values mapped by mapper.
abstract Stream<T>	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<V,K>	EntryStream.inversed()
Stream<K>	EntryStream.keys()
abstract Stream<T>	Stream.last(int n)	A queue with size up to n will be maintained to filter out the last n elements.
S	BaseStream.limit(long maxSize)
EntryStream<K,V>	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>	Stream.map(Function<? super T,? extends R> mapper)
<R> Stream<R>	Stream.mapE(Throwables.Function<? super T,? extends R,? extends Exception> mapper)
abstract Stream<T>	Stream.mapFirst(Function<? super T,? extends T> mapperForFirst)
abstract <R> Stream<R>	Stream.mapFirstOrElse(Function<? super T,? extends R> mapperForFirst, Function<? super T,? extends R> mapperForElse)
<R> Stream<R>	Stream.mapIfNotNul(Function<? super T,? extends R> mapper)	Convert the element to a new value if it's not null, otherwise skip it.
<KK> EntryStream<KK,V>	EntryStream.mapKey(BiFunction<? super K,? super V,? extends KK> keyMapper)
<KK> EntryStream<KK,V>	EntryStream.mapKey(Function<? super K,? extends KK> keyMapper)
<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 Stream<T>	Stream.mapLast(Function<? super T,? extends T> mapperForLast)
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>	EntryStream.mapMulti(BiConsumer<? super Map.Entry<K,V>,? super Consumer<Map.Entry<KK,VV>>> mapper)
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/streamex
abstract CharStream	CharStream.mapPartial(CharFunction<u.OptionalChar> mapper)	Note: copied from StreamEx: https://github.com/amaembo/streamex
abstract 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/streamex
abstract IntStream	IntStream.mapPartial(IntFunction<u.OptionalInt> mapper)	Note: copied from StreamEx: https://github.com/amaembo/streamex
abstract LongStream	LongStream.mapPartial(LongFunction<u.OptionalLong> mapper)	Note: copied from StreamEx: https://github.com/amaembo/streamex
abstract ShortStream	ShortStream.mapPartial(ShortFunction<u.OptionalShort> mapper)	Note: copied from StreamEx: https://github.com/amaembo/streamex
abstract <R> Stream<R>	Stream.mapPartial(Function<? super T,u.Optional<? extends R>> mapper)	Note: copied from StreamEx: https://github.com/amaembo/streamex
abstract DoubleStream	DoubleStream.mapPartialJdk(DoubleFunction<OptionalDouble> mapper)	Note: copied from StreamEx: https://github.com/amaembo/streamex
abstract IntStream	IntStream.mapPartialJdk(IntFunction<OptionalInt> mapper)	Note: copied from StreamEx: https://github.com/amaembo/streamex
abstract LongStream	LongStream.mapPartialJdk(LongFunction<OptionalLong> mapper)	Note: copied from StreamEx: https://github.com/amaembo/streamex
abstract <R> Stream<R>	Stream.mapPartialJdk(Function<? super T,Optional<? extends R>> mapper)	Note: copied from StreamEx: https://github.com/amaembo/streamex
abstract DoubleStream	Stream.mapPartialToDouble(Function<? super T,u.OptionalDouble> mapper)	Note: copied from StreamEx: https://github.com/amaembo/streamex
abstract DoubleStream	Stream.mapPartialToDoubleJdk(Function<? super T,OptionalDouble> mapper)	Note: copied from StreamEx: https://github.com/amaembo/streamex
abstract IntStream	Stream.mapPartialToInt(Function<? super T,u.OptionalInt> mapper)	Note: copied from StreamEx: https://github.com/amaembo/streamex
abstract IntStream	Stream.mapPartialToIntJdk(Function<? super T,OptionalInt> mapper)	Note: copied from StreamEx: https://github.com/amaembo/streamex
abstract LongStream	Stream.mapPartialToLong(Function<? super T,u.OptionalLong> mapper)	Note: copied from StreamEx: https://github.com/amaembo/streamex
abstract LongStream	Stream.mapPartialToLongJdk(Function<? super T,OptionalLong> mapper)	Note: copied from StreamEx: https://github.com/amaembo/streamex
abstract 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 a IntStream 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-valued Stream 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>	EntryStream.mapValue(Function<? super V,? extends VV> valueMapper)
<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)
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)
abstract Stream<T>	Stream.mergeWith(Stream<? extends T> b, BiFunction<? super T,? super T,MergeResult> nextSelector)
abstract Stream<T>	Stream.mergeWith(Collection<? extends T> b, BiFunction<? super T,? super T,MergeResult> nextSelector)
S	BaseStream.onClose(Runnable closeHandler)
S	BaseStream.onEach(C action)	Same as peek
EntryStream<K,V>	EntryStream.onEach(BiConsumer<? super K,? super V> action)
Stream<T>	Stream.onEachE(Throwables.Consumer<? super T,? extends Exception> action)
abstract Stream<List<T>>	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]
abstract Stream<List<T>>	Stream.orderedPermutations(Comparator<? super T> comparator)
<U> Stream<Pair<T,U>>	Stream.pairWith(Function<? super T,? extends U> extractor)
S	BaseStream.parallel()	Consider using sps(Function) if only next operation need to be parallelized.
S	BaseStream.parallel(int maxThreadNum)	Consider using sps(int, Function) if only next operation need to be parallelized.
S	BaseStream.parallel(int maxThreadNum, BaseStream.Splitor splitor)	Returns an equivalent stream that is parallel.
S	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.
S	BaseStream.parallel(int maxThreadNum, Executor executor)	// Replace above line of code with "sps" if only "f" need to be parallelized.
S	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.
S	BaseStream.parallel(BaseStream.Splitor splitor)
S	BaseStream.parallel(Executor executor)	stream.parallel(executor).map(f).filter(p)...; // Replace above line of code with "sps" if only "f" need to be parallelized.
abstract Stream<Map.Entry<Boolean,List<T>>>	Stream.partitionBy(Predicate<? super T> predicate)
abstract <D> Stream<Map.Entry<Boolean,D>>	Stream.partitionBy(Predicate<? super T> predicate, Collector<? super T,?,D> downstream)
abstract EntryStream<Boolean,List<T>>	Stream.partitionByToEntry(Predicate<? super T> predicate)
abstract <D> EntryStream<Boolean,D>	Stream.partitionByToEntry(Predicate<? super T> predicate, Collector<? super T,?,D> downstream)
S	BaseStream.peek(C action)
EntryStream<K,V>	EntryStream.peek(BiConsumer<? super K,? super V> action)
abstract Stream<T>	Stream.peekFirst(Consumer<? super T> action)
Stream<T>	Stream.peekIf(BiPredicate<? super T,? super Long> predicate, Consumer<? super T> action)
Stream<T>	Stream.peekIf(Predicate<? super T> predicate, Consumer<? super T> action)
abstract Stream<T>	Stream.peekLast(Consumer<? super T> action)
u.Optional<Map<Percentage,T>>	BaseStream.percentiles()	All elements will be loaded to memory and sorted if not yet.
abstract Stream<List<T>>	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]
S	BaseStream.prepend(OT op)
S	BaseStream.prepend(S stream)
abstract ByteStream	ByteStream.prepend(byte... a)
abstract CharStream	CharStream.prepend(char... a)
abstract DoubleStream	DoubleStream.prepend(double... a)
<M extends Map<? extends K, ? extends V>> EntryStream<K,V>	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)
abstract Stream<T>	Stream.prepend(Collection<? extends T> c)
final Stream<T>	Stream.prepend(T... a)
<SS extends BaseStream> SS	BaseStream.psp(Function<? super S,? extends SS> ops)	Temporarily switch the stream to sequence stream for operation ops and then switch back to parallel stream with same maxThreadNum/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.
S	BaseStream.rateLimited(double permitsPerSecond)
S	BaseStream.rateLimited(RateLimiter rateLimiter)
S	BaseStream.reversed()	This method only runs sequentially, even in parallel stream and all elements will be loaded to memory.
S	BaseStream.reverseSorted()
EntryStream<K,V>	EntryStream.reverseSorted(Comparator<? super Map.Entry<K,V>> comparator)
abstract Stream<T>	Stream.reverseSorted(Comparator<? super T> comparator)
EntryStream<K,V>	EntryStream.reverseSortedBy(Function<? super Map.Entry<K,V>,? extends Comparable> keyMapper)
abstract Stream<T>	Stream.reverseSortedBy(Function<? super T,? extends Comparable> keyMapper)
abstract Stream<T>	Stream.reverseSortedByDouble(ToDoubleFunction<? super T> keyMapper)
abstract Stream<T>	Stream.reverseSortedByInt(ToIntFunction<? super T> keyMapper)
abstract Stream<T>	Stream.reverseSortedByLong(ToLongFunction<? super T> keyMapper)
abstract Stream<List<T>>	Stream.rollup()
S	BaseStream.rotated(int distance)	This method only runs sequentially, even in parallel stream and all elements will be loaded to memory.
abstract Stream<T>	Stream.saveEach(File output)
abstract Stream<T>	Stream.saveEach(File output, Throwables.BiConsumer<? super T,Writer,IOException> writeLine)
abstract Stream<T>	Stream.saveEach(File output, Function<? super T,String> toLine)
abstract Stream<T>	Stream.saveEach(OutputStream output, Function<? super T,String> toLine)
abstract Stream<T>	Stream.saveEach(Writer output, Throwables.BiConsumer<? super T,Writer,IOException> writeLine)
abstract Stream<T>	Stream.saveEach(Writer output, Function<? super T,String> toLine)
abstract Stream<T>	Stream.saveEach(Connection conn, String insertSQL, Throwables.BiConsumer<? super T,? super PreparedStatement,SQLException> stmtSetter)	To support batch call, please use onEach or onEachE.
abstract Stream<T>	Stream.saveEach(PreparedStatement stmt, Throwables.BiConsumer<? super T,? super PreparedStatement,SQLException> stmtSetter)	To support batch call, please use onEach or onEachE.
abstract Stream<T>	Stream.saveEach(DataSource ds, String insertSQL, Throwables.BiConsumer<? super T,? super PreparedStatement,SQLException> stmtSetter)	To support batch/parallel call, please use onEach or onEachE.
abstract ByteStream	ByteStream.scan(byte init, ByteBinaryOperator 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 ByteStream	ByteStream.scan(byte init, ByteBinaryOperator accumulator, boolean initIncluded)
abstract ByteStream	ByteStream.scan(ByteBinaryOperator 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 CharStream	CharStream.scan(char init, CharBinaryOperator 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 CharStream	CharStream.scan(char init, CharBinaryOperator accumulator, boolean initIncluded)
abstract CharStream	CharStream.scan(CharBinaryOperator 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 DoubleStream	DoubleStream.scan(double init, DoubleBinaryOperator 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 DoubleStream	DoubleStream.scan(double init, DoubleBinaryOperator accumulator, boolean initIncluded)
abstract DoubleStream	DoubleStream.scan(DoubleBinaryOperator 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 FloatStream	FloatStream.scan(float init, FloatBinaryOperator 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 FloatStream	FloatStream.scan(float init, FloatBinaryOperator accumulator, boolean initIncluded)
abstract FloatStream	FloatStream.scan(FloatBinaryOperator 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	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	IntStream.scan(int init, IntBinaryOperator accumulator, boolean initIncluded)
abstract IntStream	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 LongStream	LongStream.scan(long init, LongBinaryOperator 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 LongStream	LongStream.scan(long init, LongBinaryOperator accumulator, boolean initIncluded)
abstract LongStream	LongStream.scan(LongBinaryOperator 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 ShortStream	ShortStream.scan(short init, ShortBinaryOperator 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 ShortStream	ShortStream.scan(short init, ShortBinaryOperator accumulator, boolean initIncluded)
abstract ShortStream	ShortStream.scan(ShortBinaryOperator 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 Stream<T>	Stream.scan(BiFunction<? super T,? super T,T> 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 <U> Stream<U>	Stream.scan(U init, BiFunction<U,? super T,U> 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 <U> Stream<U>	Stream.scan(U init, BiFunction<U,? super T,U> accumulator, boolean initIncluded)
<U> Stream<U>	Stream.select(Class<? extends U> targetType)	Select the elements belong to the specified targetType(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.
S	BaseStream.sequential()
S	BaseStream.shuffled()	This method only runs sequentially, even in parallel stream and all elements will be loaded to memory.
S	BaseStream.shuffled(Random rnd)	This method only runs sequentially, even in parallel stream and all elements will be loaded to memory.
<R> Stream<R>	Stream.sjps(Function<? super Stream<T>,? extends Stream<? extends R>> op)	Temporarily switch the stream to Jdk parallel stream for operation ops and then switch back to sequence stream.
S	BaseStream.skip(long n)
S	BaseStream.skip(long n, C consumer)
EntryStream<K,V>	EntryStream.skip(long n)
abstract Stream<T>	Stream.skipLast(int n)	A queue with size up to n will be maintained to filter out the last n elements.
abstract Stream<T>	Stream.skipNull()	Deprecated. Use Stream.skipNulls() instead
abstract Stream<T>	Stream.skipNulls()
abstract Stream<T>	Stream.skipRange(int startInclusive, int endExclusive)	Skip the range: [fromIndexInclusive, fromIndexInclusive].
S	BaseStream.skipUntil(P predicate)
EntryStream<K,V>	EntryStream.skipUntil(BiPredicate<? super K,? super V> predicate)
Stream<T>	Stream.skipUntil(Predicate<? super T> predicate)
Stream<S>	BaseStream.sliding(int windowSize)
Stream<S>	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 <R> Stream<R>	Stream.sliding(int windowSize, int increment, Collector<? super T,?,R> collector)
abstract <C extends Collection<T>> Stream<C>	Stream.sliding(int windowSize, IntFunction<? extends C> collectionSupplier)
abstract <R> Stream<R>	Stream.sliding(int windowSize, Collector<? super T,?,R> collector)
abstract <R> Stream<R>	Stream.slidingMap(int increment, boolean ignoreNotPaired, TriFunction<? super T,? super T,? super T,? extends R> mapper)
abstract <R> Stream<R>	Stream.slidingMap(int increment, boolean ignoreNotPaired, BiFunction<? super T,? super T,? extends R> mapper)
abstract <R> Stream<R>	Stream.slidingMap(int increment, TriFunction<? super T,? super T,? super T,? extends R> mapper)	Slide with windowSize = 3 and the specified increment, then map by the specified mapper.
abstract <R> Stream<R>	Stream.slidingMap(int increment, BiFunction<? super T,? super T,? extends R> mapper)	Slide with windowSize = 2 and the specified increment, then map by the specified mapper.
abstract <R> Stream<R>	Stream.slidingMap(TriFunction<? super T,? super T,? super T,? extends R> mapper)
abstract <R> Stream<R>	Stream.slidingMap(BiFunction<? super T,? super T,? extends R> mapper)
Stream<PL>	BaseStream.slidingToList(int windowSize)
Stream<PL>	BaseStream.slidingToList(int windowSize, int increment)
Stream<Set<T>>	Stream.slidingToSet(int windowSize)
abstract Stream<Set<T>>	Stream.slidingToSet(int windowSize, int increment)
S	BaseStream.sorted()	Returns a stream consisting of the elements of this stream in sorted order.
EntryStream<K,V>	EntryStream.sorted(Comparator<? super Map.Entry<K,V>> comparator)
abstract Stream<T>	Stream.sorted(Comparator<? super T> comparator)
EntryStream<K,V>	EntryStream.sortedBy(Function<? super Map.Entry<K,V>,? extends Comparable> keyMapper)
abstract Stream<T>	Stream.sortedBy(Function<? super T,? extends Comparable> keyMapper)
EntryStream<K,V>	EntryStream.sortedByDouble(ToDoubleFunction<? super Map.Entry<K,V>> keyMapper)
abstract Stream<T>	Stream.sortedByDouble(ToDoubleFunction<? super T> keyMapper)
EntryStream<K,V>	EntryStream.sortedByInt(ToIntFunction<? super Map.Entry<K,V>> keyMapper)
abstract Stream<T>	Stream.sortedByInt(ToIntFunction<? super T> keyMapper)
EntryStream<K,V>	EntryStream.sortedByKey(Comparator<? super K> keyComparator)
EntryStream<K,V>	EntryStream.sortedByLong(ToLongFunction<? super Map.Entry<K,V>> keyMapper)
abstract Stream<T>	Stream.sortedByLong(ToLongFunction<? super T> keyMapper)
EntryStream<K,V>	EntryStream.sortedByValue(Comparator<? super V> valueComparator)
Stream<S>	BaseStream.split(int chunkSize)	Returns Stream of S with consecutive sub sequences of the elements, each of the same size (the final sequence may be smaller).
Stream<S>	BaseStream.split(P predicate)	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 <R> Stream<R>	Stream.split(int chunkSize, Collector<? super T,?,R> collector)
abstract <C extends Collection<T>> Stream<C>	Stream.split(Predicate<? super T> predicate, Supplier<? extends C> collectionSupplier)
abstract <R> Stream<R>	Stream.split(Predicate<? super T> predicate, Collector<? super T,?,R> collector)
Stream<S>	BaseStream.splitAt(int where)	Split the stream into two pieces at where.
Stream<S>	BaseStream.splitAt(P where)	Split the stream into two pieces at where turns to true.
abstract <R> Stream<R>	Stream.splitAt(int where, Collector<? super T,?,R> collector)	Split the stream into two pieces at where turns to false.
abstract <R> Stream<R>	Stream.splitAt(Predicate<? super T> where, Collector<? super T,?,R> collector)	Split the stream into two pieces at where turns to false.
Stream<PL>	BaseStream.splitToList(int chunkSize)	Returns Stream of PL with consecutive sub sequences of the elements, each of the same size (the final sequence may be smaller).
Stream<PL>	BaseStream.splitToList(P predicate)	Split the stream by the specified predicate.
abstract Stream<Set<T>>	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).
abstract Stream<Set<T>>	Stream.splitToSet(Predicate<? super T> predicate)
<SS extends BaseStream> SS	BaseStream.sps(int maxThreadNum, Function<? super S,? extends SS> ops)	Temporarily switch the stream to parallel stream for operation ops and then switch back to sequence stream.
<SS extends BaseStream> SS	BaseStream.sps(Function<? super S,? extends SS> ops)	Temporarily switch the stream to parallel stream for operation ops 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 operation op and then switch back to sequence stream.
Stream<T>	Stream.spsFilter(int maxThreadNum, int bufferSize, Predicate<? super T> predicate)	Temporarily switch the stream to parallel stream for operation filter and then switch back to sequence stream.
Stream<T>	Stream.spsFilter(int maxThreadNum, Predicate<? super T> predicate)	Temporarily switch the stream to parallel stream for operation filter and then switch back to sequence stream.
Stream<T>	Stream.spsFilter(Predicate<? super T> predicate)	Temporarily switch the stream to parallel stream for operation filter and then switch back to sequence stream.
Stream<T>	Stream.spsFilterE(int maxThreadNum, Throwables.Predicate<? super T,? extends Exception> predicate)	Temporarily switch the stream to parallel stream for operation filter and then switch back to sequence stream.
Stream<T>	Stream.spsFilterE(Throwables.Predicate<? super T,? extends Exception> predicate)	Temporarily switch the stream to parallel stream for operation filter 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 operation flatMap 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 operation flatMap 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 operation flatMap 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 operation flatMap 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 operation flatMap 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 operation flatMap 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 operation flatMap 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 operation flatMap 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 operation flatMap 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 operation flatMap and then switch back to sequence stream.
<R> Stream<R>	Stream.spsMap(int maxThreadNum, int bufferSize, Function<? super T,? extends R> mapper)	Temporarily switch the stream to parallel stream for operation map and then switch back to sequence stream.
<R> Stream<R>	Stream.spsMap(int maxThreadNum, Function<? super T,? extends R> mapper)	Temporarily switch the stream to parallel stream for operation map and then switch back to sequence stream.
<R> Stream<R>	Stream.spsMap(Function<? super T,? extends R> mapper)	Temporarily switch the stream to parallel stream for operation map 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 operation map 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 operation map and then switch back to sequence stream.
Stream<T>	Stream.spsOnEach(int maxThreadNum, int bufferSize, Consumer<? super T> action)	Temporarily switch the stream to parallel stream for operation onEach and then switch back to sequence stream.
Stream<T>	Stream.spsOnEach(int maxThreadNum, Consumer<? super T> action)	Temporarily switch the stream to parallel stream for operation onEach and then switch back to sequence stream.
Stream<T>	Stream.spsOnEach(Consumer<? super T> action)	Temporarily switch the stream to parallel stream for operation onEach and then switch back to sequence stream.
Stream<T>	Stream.spsOnEachE(int maxThreadNum, Throwables.Consumer<? super T,? extends Exception> action)	Temporarily switch the stream to parallel stream for operation onEach and then switch back to sequence stream.
Stream<T>	Stream.spsOnEachE(Throwables.Consumer<? super T,? extends Exception> action)	Temporarily switch the stream to parallel stream for operation onEach and then switch back to sequence stream.
S	BaseStream.step(long step)
S	BaseStream.symmetricDifference(Collection<T> c)	This method only runs sequentially, even in parallel stream.
S	BaseStream.takeWhile(P predicate)	Keep the elements until the given predicate returns false.
EntryStream<K,V>	EntryStream.takeWhile(BiPredicate<? super K,? super V> predicate)
S	BaseStream.throwIfEmpty(Supplier<? extends RuntimeException> exceptionSupplier)
abstract DoubleStream	DoubleStream.toJdkStream()
abstract IntStream	IntStream.toJdkStream()
abstract LongStream	LongStream.toJdkStream()
abstract Stream<T>	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.
abstract Stream<T>	Stream.top(int n)	This method only runs sequentially, even in parallel stream.
abstract Stream<T>	Stream.top(int n, Comparator<? super T> comparator)	This method only runs sequentially, even in parallel stream.
<SS extends BaseStream> SS	BaseStream.transform(Function<? super S,? extends SS> transfer)
Stream<V>	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)