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

Packages that use SequentialOnly

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

Uses of SequentialOnly in com.landawn.abacus.util

Classes in com.landawn.abacus.util with annotations of type SequentialOnly

Modifier and Type	Class	Description
class	ExceptionalStream<T,E extends Exception>	The Stream will be automatically closed after execution(A terminal method is executed/triggered).
interface	NoCachingNoUpdating	One-off Object.
static class	NoCachingNoUpdating.DisposableArray<T>	One-off Object.
static class	NoCachingNoUpdating.DisposableBooleanArray	One-off Object.
static class	NoCachingNoUpdating.DisposableByteArray	One-off Object.
static class	NoCachingNoUpdating.DisposableCharArray	One-off Object.
static class	NoCachingNoUpdating.DisposableDeque<T>	One-off Object.
static class	NoCachingNoUpdating.DisposableDoubleArray	One-off Object.
static class	NoCachingNoUpdating.DisposableEntry<K,V>	One-off Object.
static class	NoCachingNoUpdating.DisposableFloatArray	One-off Object.
static class	NoCachingNoUpdating.DisposableIntArray	One-off Object.
static class	NoCachingNoUpdating.DisposableLongArray	One-off Object.
static class	NoCachingNoUpdating.DisposableObjArray	One-off Object.
static class	NoCachingNoUpdating.DisposablePair<L,R>	One-off Object.
static class	NoCachingNoUpdating.DisposableShortArray	One-off Object.
static class	NoCachingNoUpdating.DisposableTriple<L,M,R>	One-off Object.

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

Modifier and Type	Method	Description
static ByteBiFunction<MergeResult>	Fn.FnB.alternated()	Deprecated.
static CharBiFunction<MergeResult>	Fn.FnC.alternated()	Deprecated.
static DoubleBiFunction<MergeResult>	Fn.FnD.alternated()	Deprecated.
static FloatBiFunction<MergeResult>	Fn.FnF.alternated()	Deprecated.
static IntBiFunction<MergeResult>	Fn.FnI.alternated()	Deprecated.
static LongBiFunction<MergeResult>	Fn.FnL.alternated()	Deprecated.
static ShortBiFunction<MergeResult>	Fn.FnS.alternated()	Deprecated.
static <T> Predicate<T>	Fn.Predicates.concurrentDistinct()	Returns a stateful Predicate.
static <T> Predicate<T>	Fn.Predicates.concurrentDistinctBy(Function<? super T,?> mapper)	Returns a stateful Predicate.
ExceptionalStream<T,E>	ExceptionalStream.cycled()
ExceptionalStream<T,E>	ExceptionalStream.cycled(long times)
static <T> Predicate<T>	Fn.Predicates.distinct()	Returns a stateful Predicate.
static <T> Predicate<T>	Fn.Predicates.distinctBy(Function<? super T,?> mapper)	Returns a stateful Predicate.
static <T, U> BiPredicate<T,U>	Fn.filterThenLimit(BiPredicate<T,U> predicate, int limit)	Returns a stateful Predicate.
static <T> Predicate<T>	Fn.filterThenLimit(Predicate<T> predicate, int limit)	Returns a stateful Predicate.
static <U, T> BiConsumer<U,T>	Fn.BiConsumers.indexed(IndexedBiConsumer<U,T> action)	Returns a stateful BiPredicate.
static <U, T, R> BiFunction<U,T,R>	Fn.BiFunctions.indexed(IndexedBiFunction<U,T,R> func)	Returns a stateful BiPredicate.
static <T, U> BiPredicate<T,U>	Fn.BiPredicates.indexed(IndexedBiPredicate<T,U> predicate)	Returns a stateful BiPredicate.
static <T> Consumer<T>	Fn.Consumers.indexed(IndexedConsumer<T> action)	Returns a stateful BiPredicate.
static <T, R> Function<T,R>	Fn.Functions.indexed(IndexedFunction<T,R> func)	Returns a stateful Function.
static <T> Function<T,Indexed<T>>	Fn.indexed()	Returns a stateful Predicate.
static <T> Predicate<T>	Fn.indexed(IndexedPredicate<T> predicate)	Returns a stateful Predicate.
static <T> Predicate<T>	Fn.Predicates.indexed(IndexedPredicate<T> predicate)	Returns a stateful Predicate.
static <T> Predicate<T>	Fn.Predicates.invertedByDuration(long delayInMillis, long periodInMillis, MutableBoolean cancellationFlag)	Deprecated.
static <T> Predicate<T>	Fn.Predicates.invertedByDuration(long delayInMillis, long periodInMillis, MutableBoolean cancellationFlag, Runnable update)	Deprecated.
static <T> Predicate<T>	Fn.Predicates.invertedByDuration(long periodInMillis, MutableBoolean cancellationFlag)	Deprecated.
static <T> Predicate<T>	Fn.Predicates.invertedByDuration(long periodInMillis, MutableBoolean cancellationFlag, Runnable update)	Deprecated.
static <T, U> BiPredicate<T,U>	Fn.limitThenFilter(int limit, BiPredicate<T,U> predicate)	Returns a stateful Predicate.
static <T> Predicate<T>	Fn.limitThenFilter(int limit, Predicate<T> predicate)	Returns a stateful Predicate.
static <T, R> Function<T,R>	Fn.memoize(Function<? super T,? extends R> func)
static <T> Supplier<T>	Fn.memoize(Supplier<T> supplier)	Returns a Supplier which returns a single instance created by calling the specified supplier.get().
static IntFunction<NoCachingNoUpdating.DisposableObjArray>	Fn.Factory.ofDisposableArray()
static <T> IntFunction<NoCachingNoUpdating.DisposableArray<T>>	Fn.Factory.ofDisposableArray(Class<T> componentType)
static <T, C extends Collection<T>> IntFunction<? extends C>	Fn.reuse(IntFunction<? extends C> supplier)	Deprecated.
static <T, C extends Collection<T>> Supplier<? extends C>	Fn.reuse(Supplier<? extends C> supplier)	Deprecated.
static <T, C extends Collection<T>> IntFunction<? extends C>	Fn.Factory.single(IntFunction<? extends C> supplier)	Deprecated.
static <T, C extends Collection<T>> Supplier<? extends C>	Fn.Suppliers.single(Supplier<? extends C> supplier)	Deprecated.
static <T> Predicate<T>	Fn.Predicates.skipRepeats()	Returns a stateful Predicate.
static <T> BiFunction<T,T,MergeResult>	Fn.switchOnNext()	Returns a stateful BiFunction.
static <T> BiFunction<T,T,MergeResult>	MergeResult.switchOnNext()	Deprecated. Use Fn.switchOnNext() instead
static <T> Predicate<T>	Fn.timeLimit(long timeInMillis)	Returns a stateful Predicate.
static <T> Predicate<T>	Fn.timeLimit(Duration duration)	Returns a stateful Predicate.

Uses of SequentialOnly in com.landawn.abacus.util.stream

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

Modifier and Type	Method	Description
<SS extends BaseStream> SS	BaseStream.__(Function<? super S,? extends SS> transfer)
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 u.OptionalDouble	ByteStream.average()
abstract u.OptionalDouble	CharStream.average()
abstract u.OptionalDouble	DoubleStream.average()
abstract u.OptionalDouble	FloatStream.average()
abstract u.OptionalDouble	IntStream.average()
abstract u.OptionalDouble	LongStream.average()
abstract u.OptionalDouble	ShortStream.average()
BiIterator<K,V>	EntryStream.biIterator()	Remember to close this Stream after the iteration is done, if needed.
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> ExceptionalStream<T,E>	Stream.checked()
<E extends Exception> ExceptionalStream<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<Stream<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, A> Stream<R>	Stream.collapse(BiPredicate<? super T,? super T> collapsible, Collector<? super T,A,R> collector)	Merge series of adjacent elements which satisfy the given predicate using the merger function and return a new stream.
abstract <U> Stream<U>	Stream.collapse(BiPredicate<? super T,? super T> collapsible, U init, BiFunction<U,? super T,U> op)
abstract Stream<Stream<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, A> Stream<R>	Stream.collapse(TriPredicate<? super T,? super T,? super T> collapsible, Collector<? super T,A,R> collector)	Merge series of adjacent elements which satisfy the given predicate using the merger function and return a new stream.
abstract <U> Stream<U>	Stream.collapse(TriPredicate<? super T,? super T,? super T> collapsible, U init, BiFunction<U,? super T,U> op)
Stream<List<V>>	EntryStream.collapseByKey(BiPredicate<? super K,? super K> collapsible)
<R, A> Stream<R>	EntryStream.collapseByKey(BiPredicate<? super K,? super K> collapsible, Collector<? super V,A,R> collector)	Merge series of adjacent elements which satisfy the given predicate using the merger function and return a new stream.
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.
abstract boolean	Stream.containsAll(Collection<? extends T> c)
abstract boolean	Stream.containsAll(T... a)
abstract boolean	Stream.containsAny(Collection<? extends T> c)
abstract boolean	Stream.containsAny(T... a)
long	BaseStream.count()
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.difference(Collection<?> c)	This method only runs sequentially, even in parallel stream.
S	BaseStream.distinct()	Returns a stream consisting of the distinct elements of this stream.
Stream<T>	Stream.distinct(Predicate<? super Long> occurrencesFilter)	Distinct and filter by occurrences.
EntryStream<K,V>	EntryStream.distinctByKey()
EntryStream<K,V>	EntryStream.distinctByValue()
OT	BaseStream.elementAt(long position)
Stream<Map.Entry<K,V>>	EntryStream.entries()
abstract <E extends Exception, E2 extends Exception> u.OptionalByte	ByteStream.findFirstOrLast(Throwables.BytePredicate<E> predicateForFirst, Throwables.BytePredicate<E> predicateForLast)
abstract <E extends Exception, E2 extends Exception> u.OptionalChar	CharStream.findFirstOrLast(Throwables.CharPredicate<E> predicateForFirst, Throwables.CharPredicate<E> predicateForLast)
abstract <E extends Exception, E2 extends Exception> u.OptionalDouble	DoubleStream.findFirstOrLast(Throwables.DoublePredicate<E> predicateForFirst, Throwables.DoublePredicate<E> predicateForLast)
abstract <E extends Exception, E2 extends Exception> u.OptionalFloat	FloatStream.findFirstOrLast(Throwables.FloatPredicate<E> predicateForFirst, Throwables.FloatPredicate<E> predicateForLast)
abstract <E extends Exception, E2 extends Exception> u.OptionalInt	IntStream.findFirstOrLast(Throwables.IntPredicate<E> predicateForFirst, Throwables.IntPredicate<E> predicateForLast)
abstract <E extends Exception, E2 extends Exception> u.OptionalLong	LongStream.findFirstOrLast(Throwables.LongPredicate<E> predicateForFirst, Throwables.LongPredicate<E> predicateForLast)
abstract <E extends Exception, E2 extends Exception> u.OptionalShort	ShortStream.findFirstOrLast(Throwables.ShortPredicate<E> predicateForFirst, Throwables.ShortPredicate<E> predicateForLast)
abstract <U, E extends Exception, E2 extends Exception> u.Optional<T>	Stream.findFirstOrLast(Function<? super T,U> preFunc, Throwables.BiPredicate<? super T,? super U,E> predicateForFirst, Throwables.BiPredicate<? super T,? super U,E2> predicateForLast)	This method only runs sequentially, even in parallel stream.
abstract <E extends Exception, E2 extends Exception> u.Optional<T>	Stream.findFirstOrLast(Throwables.Predicate<? super T,E> predicateForFirst, Throwables.Predicate<? super T,E2> predicateForLast)
abstract <U, E extends Exception, E2 extends Exception> u.Optional<T>	Stream.findFirstOrLast(U init, Throwables.BiPredicate<? super T,? super U,E> predicateForFirst, Throwables.BiPredicate<? super T,? super U,E2> predicateForLast)	This method only runs sequentially, even in parallel stream.
OT	BaseStream.first()
<KK> EntryStream<KK,V>	EntryStream.flatMapKeyToDisposableEntry(Function<? super K,? extends Stream<? extends KK>> keyMapper)	Deprecated.
<VV> EntryStream<K,VV>	EntryStream.flatMapValueToDisposableEntry(Function<? super V,? extends Stream<? extends VV>> valueMapper)	Deprecated.
<KK> EntryStream<KK,V>	EntryStream.flattMapKeyToDisposableEntry(Function<? super K,? extends Collection<? extends KK>> keyMapper)	Deprecated.
<VV> EntryStream<K,VV>	EntryStream.flattMapValueToDisposableEntry(Function<? super V,? extends Collection<? extends VV>> valueMapper)	Deprecated.
abstract <E extends Exception> u.Optional<T>	Stream.foldLeft(Throwables.BinaryOperator<T,E> accumulator)	This method will always run sequentially, even in parallel stream.
abstract <U, E extends Exception> U	Stream.foldLeft(U identity, Throwables.BiFunction<U,? super T,U,E> accumulator)	This method will always run sequentially, even in parallel stream.
abstract <E extends Exception> u.Optional<T>	Stream.foldRight(Throwables.BinaryOperator<T,E> accumulator)	This method will always run sequentially, even in parallel stream.
abstract <U, E extends Exception> U	Stream.foldRight(U identity, Throwables.BiFunction<U,? super T,U,E> accumulator)	This method will always run sequentially, even in parallel stream.
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)
EntryStream<K,List<V>>	EntryStream.groupBy(Supplier<? extends Map<K,List<V>>> mapFactory)
Map<K,List<V>>	EntryStream.groupTo()
<M extends Map<K, List<V>>> M	EntryStream.groupTo(Supplier<? extends M> mapFactory)
<R, E extends Exception> R	EntryStream.groupToAndThen(Throwables.Function<? super Map<K,List<V>>,R,E> func)
abstract boolean	Stream.hasDuplicates()
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 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()
EntryStream<V,K>	EntryStream.inversedToDisposableEntry()	Deprecated.
ITER	BaseStream.iterator()	Deprecated. ? may cause memory/resource leak if forget to close this Stream
FloatIterator	FloatStream.iterator()	Remember to close this Stream after the iteration is done, if needed.
IntIterator	IntStream.iterator()	Remember to close this Stream after the iteration is done, if needed.
LongIterator	LongStream.iterator()	Remember to close this Stream after the iteration is done, if needed.
ShortIterator	ShortStream.iterator()	Remember to close this Stream after the iteration is done, if needed.
ObjIterator<T>	Stream.iterator()	Remember to close this Stream after the iteration is done, if needed.
String	BaseStream.join(CharSequence delimiter)
String	BaseStream.join(CharSequence delimiter, CharSequence prefix, CharSequence suffix)
String	EntryStream.join(CharSequence delimiter, CharSequence keyValueDelimiter)
String	EntryStream.join(CharSequence delimiter, CharSequence keyValueDelimiter, CharSequence prefix, CharSequence suffix)
abstract String	Stream.join(Joiner joiner)
Stream<K>	EntryStream.keys()
abstract u.OptionalByte	ByteStream.kthLargest(int k)
abstract u.OptionalChar	CharStream.kthLargest(int k)
abstract u.OptionalDouble	DoubleStream.kthLargest(int k)
abstract u.OptionalFloat	FloatStream.kthLargest(int k)
abstract u.OptionalInt	IntStream.kthLargest(int k)
abstract u.OptionalLong	LongStream.kthLargest(int k)
abstract u.OptionalShort	ShortStream.kthLargest(int k)
OT	BaseStream.last()
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 Stream<T>	Stream.mapFirst(Function<? super T,? extends T> mapperForFirst)
abstract Stream<T>	Stream.mapLast(Function<? super T,? extends T> mapperForLast)
<KK, VV> EntryStream<KK,VV>	EntryStream.mapToDisposableEntry(BiFunction<? super K,? super V,? extends KK> keyMapper, BiFunction<? super K,? super V,? extends VV> valueMapper)	Deprecated.
<KK, VV> EntryStream<KK,VV>	EntryStream.mapToDisposableEntry(Function<? super Map.Entry<K,V>,? extends KK> keyMapper, Function<? super Map.Entry<K,V>,? extends VV> valueMapper)	Deprecated.
<K, V> Stream<NoCachingNoUpdating.DisposableEntry<K,V>>	Stream.mapToDisposableEntry(Function<? super T,? extends K> keyMapper, Function<? super T,? extends V> valueMapper)	Deprecated.
abstract u.OptionalByte	ByteStream.max()
abstract u.OptionalChar	CharStream.max()	Returns an OptionalChar describing the maximum element of this stream, or an empty optional if this stream is empty.
abstract u.OptionalDouble	DoubleStream.max()
abstract u.OptionalFloat	FloatStream.max()
abstract u.OptionalInt	IntStream.max()
abstract u.OptionalLong	LongStream.max()
abstract u.OptionalShort	ShortStream.max()
ByteStream	ByteStream.merge(ByteStream b, ByteBiFunction<MergeResult> nextSelector)	Deprecated. replaced by mergeWith(ByteStream, ByteBiFunction)
CharStream	CharStream.merge(CharStream b, CharBiFunction<MergeResult> nextSelector)	Deprecated. replaced by mergeWith(CharStream, CharBiFunction)
DoubleStream	DoubleStream.merge(DoubleStream b, DoubleBiFunction<MergeResult> nextSelector)	Deprecated. replaced by mergeWith(DoubleStream, DoubleBiFunction)
FloatStream	FloatStream.merge(FloatStream b, FloatBiFunction<MergeResult> nextSelector)	Deprecated. replaced by mergeWith(FloatStream, FloatBiFunction)
IntStream	IntStream.merge(IntStream b, IntBiFunction<MergeResult> nextSelector)	Deprecated. replaced by mergeWith(IntStream, IntBiFunction)
LongStream	LongStream.merge(LongStream b, LongBiFunction<MergeResult> nextSelector)	Deprecated. replaced by mergeWith(LongStream, LongBiFunction)
ShortStream	ShortStream.merge(ShortStream b, ShortBiFunction<MergeResult> nextSelector)	Deprecated. replaced by mergeWith(ShortStream, ShortBiFunction)
Stream<T>	Stream.merge(Stream<? extends T> b, BiFunction<? super T,? super T,MergeResult> nextSelector)	Deprecated. replaced by mergeWith(Stream, BiFunction)
abstract ByteStream	ByteStream.mergeWith(ByteStream b, ByteBiFunction<MergeResult> nextSelector)
abstract CharStream	CharStream.mergeWith(CharStream b, CharBiFunction<MergeResult> nextSelector)
abstract DoubleStream	DoubleStream.mergeWith(DoubleStream b, DoubleBiFunction<MergeResult> nextSelector)
abstract FloatStream	FloatStream.mergeWith(FloatStream b, FloatBiFunction<MergeResult> nextSelector)
abstract IntStream	IntStream.mergeWith(IntStream b, IntBiFunction<MergeResult> nextSelector)
abstract LongStream	LongStream.mergeWith(LongStream b, LongBiFunction<MergeResult> nextSelector)
abstract ShortStream	ShortStream.mergeWith(ShortStream b, ShortBiFunction<MergeResult> nextSelector)
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)
abstract u.OptionalByte	ByteStream.min()
abstract u.OptionalChar	CharStream.min()	Returns an OptionalChar describing the minimum element of this stream, or an empty optional if this stream is empty.
abstract u.OptionalDouble	DoubleStream.min()
abstract u.OptionalFloat	FloatStream.min()
abstract u.OptionalInt	IntStream.min()
abstract u.OptionalLong	LongStream.min()
abstract u.OptionalShort	ShortStream.min()
S	BaseStream.onClose(Runnable closeHandler)
abstract Stream<T>	Stream.onErrorContinue(Consumer<? super Throwable> errorConsumer)	This method should be only applied sequential Stream and whose up-streams are sequential Streams as well.
abstract Stream<T>	Stream.onErrorContinue(Predicate<? super Throwable> errorPredicate, Consumer<? super Throwable> errorConsumer)	This method should be only applied sequential Stream and whose up-streams are sequential Streams as well.
abstract Stream<T>	Stream.onErrorContinue(Predicate<? super Throwable> errorPredicate, Consumer<? super Throwable> errorConsumer, int maxErrorCountToStop)	This method should be only applied sequential Stream and whose up-streams are sequential Streams as well.
abstract Stream<T>	Stream.onErrorContinue(Class<? extends Throwable> type, Consumer<? super Throwable> errorConsumer)	This method should be only applied sequential Stream and whose up-streams are sequential Streams as well.
abstract Stream<T>	Stream.onErrorReturn(Predicate<? super Throwable> predicate, Function<? super Throwable,? extends T> mapperForFallbackValue, int maxErrorCountToStop)	This method should be only applied sequential Stream and whose up-streams are sequential Streams as well.
abstract Stream<T>	Stream.onErrorReturn(Predicate<? super Throwable> predicate, Supplier<? extends T> supplierForFallbackValue)	This method should be only applied sequential Stream and whose up-streams are sequential Streams as well.
abstract Stream<T>	Stream.onErrorReturn(Predicate<? super Throwable> predicate, T fallbackValue)	This method should be only applied sequential Stream and whose up-streams are sequential Streams as well.
abstract Stream<T>	Stream.onErrorReturn(Class<? extends Throwable> type, T fallbackValue)	This method should be only applied sequential Stream and whose up-streams are sequential Streams as well.
abstract Stream<T>	Stream.onErrorReturn(T fallbackValue)	This method should be only applied sequential Stream and whose up-streams are sequential Streams as well.
abstract Stream<T>	Stream.onErrorStop()
OT	BaseStream.onlyOne()
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)
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)	Consider using sps(ParallelSettings, Function) if only next operation need to be parallelized.
S	BaseStream.parallel(int maxThreadNum, Executor executor)	Consider using sps(ParallelSettings, Function) if only next operation need to be parallelized.
S	BaseStream.parallel(BaseStream.ParallelSettings ps)	Consider using sps(ParallelSettings, Function) if only next operation need to be parallelized.
S	BaseStream.parallel(BaseStream.Splitor splitor)	Consider using sps(ParallelSettings, Function) if only next operation need to be parallelized.
S	BaseStream.parallel(Executor executor)	Consider using sps(ParallelSettings, Function) if only next operation need to be parallelized.
abstract Stream<T>	Stream.peekFirst(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 u.Optional<Map<Percentage,T>>	Stream.percentiles(Comparator<? super T> comparator)
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]
abstract long	Stream.persist(Throwables.BiConsumer<? super T,Writer,IOException> writeLine, File file)
abstract long	Stream.persist(Throwables.BiConsumer<? super T,Writer,IOException> writeLine, Writer writer)
abstract long	Stream.persist(Throwables.BiConsumer<? super T,Writer,IOException> writeLine, String header, String tail, File file)
abstract long	Stream.persist(Throwables.BiConsumer<? super T,Writer,IOException> writeLine, String header, String tail, Writer writer)
abstract long	Stream.persist(Throwables.Function<? super T,String,IOException> toLine, File file)	toCSV:
abstract long	Stream.persist(Throwables.Function<? super T,String,IOException> toLine, OutputStream os)
abstract long	Stream.persist(Throwables.Function<? super T,String,IOException> toLine, Writer writer)	toCSV:
abstract long	Stream.persist(Throwables.Function<? super T,String,IOException> toLine, String header, String tail, File file)
abstract long	Stream.persist(Throwables.Function<? super T,String,IOException> toLine, String header, String tail, Writer writer)
abstract long	Stream.persist(File file)
abstract long	Stream.persist(String header, String tail, File file)
abstract long	Stream.persist(Connection conn, String insertSQL, int batchSize, int batchInterval, Throwables.BiConsumer<? super T,? super PreparedStatement,SQLException> stmtSetter)
abstract long	Stream.persist(PreparedStatement stmt, int batchSize, int batchInterval, Throwables.BiConsumer<? super T,? super PreparedStatement,SQLException> stmtSetter)
abstract long	Stream.persistToCSV(File file)	Each line in the output file/Writer is an array of JSON String without root bracket.
abstract long	Stream.persistToCSV(OutputStream os)	Each line in the output file/Writer is an array of JSON String without root bracket.
abstract long	Stream.persistToCSV(Writer writer)	Each line in the output file/Writer is an array of JSON String without root bracket.
abstract long	Stream.persistToCSV(Collection<String> csvHeaders, File file)	Each line in the output file/Writer is an array of JSON String without root bracket.
abstract long	Stream.persistToCSV(Collection<String> csvHeaders, OutputStream os)	Each line in the output file/Writer is an array of JSON String without root bracket.
abstract long	Stream.persistToCSV(Collection<String> csvHeaders, Writer writer)	Each line in the output file/Writer is an array of JSON String without root bracket.
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)
void	BaseStream.println()
<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<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<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<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<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<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<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<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)
Map.Entry<K,V>	EntryStream.reduce(Map.Entry<K,V> identity, BinaryOperator<Map.Entry<K,V>> accumulator)
S	BaseStream.reversed()	This method only runs sequentially, even in parallel stream and all elements will be loaded to memory.
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 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<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.
S	BaseStream.skip(long n)
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()
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 <A, R> Stream<R>	Stream.sliding(int windowSize, int increment, Collector<? super T,A,R> collector)
abstract <C extends Collection<T>> Stream<C>	Stream.sliding(int windowSize, IntFunction<? extends C> collectionSupplier)
abstract <A, R> Stream<R>	Stream.sliding(int windowSize, Collector<? super T,A,R> collector)
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)
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 <A, R> Stream<R>	Stream.split(int chunkSize, Collector<? super T,A,R> collector)
abstract <C extends Collection<T>> Stream<C>	Stream.split(Predicate<? super T> predicate, Supplier<? extends C> collectionSupplier)
abstract <A, R> Stream<R>	Stream.split(Predicate<? super T> predicate, Collector<? super T,A,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 <A, R> Stream<R>	Stream.splitAt(int where, Collector<? super T,A,R> collector)	Split the stream into two pieces at where turns to false.
abstract <A, R> Stream<R>	Stream.splitAt(Predicate<? super T> where, Collector<? super T,A,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.
<SS extends BaseStream> SS	BaseStream.sps(BaseStream.ParallelSettings ps, Function<? super S,? extends SS> ops)	Temporarily switch the stream to parallel stream for operation ops and then switch back to sequence stream.
S	BaseStream.step(long step)
abstract long	ByteStream.sum()
abstract long	CharStream.sum()
abstract double	DoubleStream.sum()
abstract double	FloatStream.sum()
abstract long	IntStream.sum()
abstract long	LongStream.sum()
abstract long	ShortStream.sum()
abstract ByteSummaryStatistics	ByteStream.summarize()
abstract CharSummaryStatistics	CharStream.summarize()
abstract DoubleSummaryStatistics	DoubleStream.summarize()
abstract FloatSummaryStatistics	FloatStream.summarize()
abstract IntSummaryStatistics	IntStream.summarize()
abstract LongSummaryStatistics	LongStream.summarize()
abstract ShortSummaryStatistics	ShortStream.summarize()
abstract Pair<ByteSummaryStatistics,u.Optional<Map<Percentage,Byte>>>	ByteStream.summarizeAndPercentiles()
abstract Pair<CharSummaryStatistics,u.Optional<Map<Percentage,Character>>>	CharStream.summarizeAndPercentiles()
abstract Pair<DoubleSummaryStatistics,u.Optional<Map<Percentage,Double>>>	DoubleStream.summarizeAndPercentiles()
abstract Pair<FloatSummaryStatistics,u.Optional<Map<Percentage,Float>>>	FloatStream.summarizeAndPercentiles()
abstract Pair<IntSummaryStatistics,u.Optional<Map<Percentage,Integer>>>	IntStream.summarizeAndPercentiles()
abstract Pair<LongSummaryStatistics,u.Optional<Map<Percentage,Long>>>	LongStream.summarizeAndPercentiles()
abstract Pair<ShortSummaryStatistics,u.Optional<Map<Percentage,Short>>>	ShortStream.summarizeAndPercentiles()
S	BaseStream.symmetricDifference(Collection<T> c)	This method only runs sequentially, even in parallel stream.
S	BaseStream.throwIfEmpty(Supplier<? extends RuntimeException> exceptionSupplier)
A	BaseStream.toArray()
abstract <A> A[]	Stream.toArray(IntFunction<A[]> generator)
abstract ByteList	ByteStream.toByteList()
abstract CharList	CharStream.toCharList()
<CC extends Collection<T>> CC	BaseStream.toCollection(Supplier<? extends CC> supplier)
abstract <R, CC extends Collection<T>, E extends Exception> R	Stream.toCollectionAndThen(Supplier<? extends CC> supplier, Throwables.Function<? super CC,R,E> func)
abstract DataSet	Stream.toDataSet()	The first row will be used as column names if its type is array or list, or obtain the column names from first row if its type is entity or map.
abstract DataSet	Stream.toDataSet(List<String> columnNames)	If the specified columnNames is null or empty, the first row will be used as column names if its type is array or list, or obtain the column names from first row if its type is entity or map.
abstract DoubleList	DoubleStream.toDoubleList()
abstract FloatList	FloatStream.toFloatList()
ImmutableList<T>	BaseStream.toImmutableList()
ImmutableMap<K,V>	EntryStream.toImmutableMap()
ImmutableMap<K,V>	EntryStream.toImmutableMap(BinaryOperator<V> mergeFunction)
ImmutableSet<T>	BaseStream.toImmutableSet()
abstract IntList	IntStream.toIntList()
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.
List<T>	BaseStream.toList()
abstract <R, E extends Exception> R	Stream.toListAndThen(Throwables.Function<? super List<T>,R,E> func)
abstract LongList	LongStream.toLongList()
LongMultiset<T>	BaseStream.toLongMultiset()
LongMultiset<T>	BaseStream.toLongMultiset(Supplier<? extends LongMultiset<T>> supplier)
Map<K,V>	EntryStream.toMap()
Map<K,V>	EntryStream.toMap(BinaryOperator<V> mergeFunction)
<M extends Map<K, V>> M	EntryStream.toMap(BinaryOperator<V> mergeFunction, Supplier<? extends M> mapFactory)
<M extends Map<K, V>> M	EntryStream.toMap(Supplier<? extends M> mapFactory)
<R, E extends Exception> R	EntryStream.toMapAndThen(Throwables.Function<? super Map<K,V>,R,E> func)
ListMultimap<K,V>	EntryStream.toMultimap()
<C extends Collection<V>, M extends Multimap<K, V, C>> M	EntryStream.toMultimap(Supplier<? extends M> mapFactory)
Multiset<T>	BaseStream.toMultiset()
Multiset<T>	BaseStream.toMultiset(Supplier<? extends Multiset<T>> supplier)
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.
Set<T>	BaseStream.toSet()
abstract <R, E extends Exception> R	Stream.toSetAndThen(Throwables.Function<? super Set<T>,R,E> func)
abstract ShortList	ShortStream.toShortList()
Stream<V>	EntryStream.values()