Package com.landawn.abacus.util

Class CheckedStream<T,E extends Exception>

java.lang.Object

com.landawn.abacus.util.CheckedStream<T,E>

Type Parameters:

T -

E -

All Implemented Interfaces:

Immutable, Closeable, AutoCloseable

@SequentialOnly
@Immutable
public final class CheckedStream<T,E extends Exception>
extends Object
implements Closeable, Immutable

The Stream will be automatically closed after execution(A terminal method is executed/triggered).

Since:

1.3

Author:

Haiyang Li

See Also:

• BaseStream
• Stream
• IntStream
• LongStream
• DoubleStream
• Collectorsa
• Fn.Fnn
• Comparators
• ExceptionUtil

Nested Class Summary

Nested Classes

Modifier and Type	Class	Description
static class	CheckedStream.CheckedIterator<T,E extends Exception>	The Class CheckedIterator.

Method Summary

Modifier and Type	Method	Description
<TT, EE extends Exception> CheckedStream<TT,EE>	__(Function<? super CheckedStream<T,E>,CheckedStream<TT,EE>> transfer)	Deprecated. replaced by transform(Function)
<E2 extends Exception> If.OrElse	acceptIfNotEmpty(Throwables.Consumer<? super CheckedStream<T,E>,E2> action)
CheckedStream<T,E>	addSubscriber(Throwables.Consumer<? super CheckedStream<T,E>,? extends Exception> consumerForNewStreamWithTerminalAction)	Add a new Stream with terminal action to listen/consume the elements from upstream.
CheckedStream<T,E>	addSubscriber(Throwables.Consumer<? super CheckedStream<T,E>,? extends Exception> consumerForNewStreamWithTerminalAction, int queueSize, Executor executor)	Add a new Stream with terminal action to listen/consume the elements from upstream.
<E2 extends Exception> boolean	allMatch(Throwables.Predicate<? super T,E2> predicate)
<E2 extends Exception> boolean	anyMatch(Throwables.Predicate<? super T,E2> predicate)
CheckedStream<T,E>	append(CheckedStream<T,E> s)
CheckedStream<T,E>	append(Collection<? extends T> c)
final CheckedStream<T,E>	append(T... a)
CheckedStream<T,E>	appendIfEmpty(Throwables.Supplier<? extends CheckedStream<T,E>,? extends E> supplier)	Append if empty.
CheckedStream<T,E>	appendIfEmpty(Collection<? extends T> c)
final CheckedStream<T,E>	appendIfEmpty(T... a)
<R, E2 extends Exception> u.Optional<R>	applyIfNotEmpty(Throwables.Function<? super CheckedStream<T,E>,R,E2> func)
<R> ContinuableFuture<R>	asyncCall(Throwables.Function<? super CheckedStream<T,E>,R,? extends Exception> terminalAction)
<R> ContinuableFuture<R>	asyncCall(Throwables.Function<? super CheckedStream<T,E>,R,? extends Exception> terminalAction, Executor executor)
ContinuableFuture<Void>	asyncRun(Throwables.Consumer<? super CheckedStream<T,E>,? extends Exception> terminalAction)
ContinuableFuture<Void>	asyncRun(Throwables.Consumer<? super CheckedStream<T,E>,? extends Exception> terminalAction, Executor executor)
<E2 extends Exception> u.OptionalDouble	averageDouble(Throwables.ToDoubleFunction<? super T,E2> func)
<E2 extends Exception> u.OptionalDouble	averageInt(Throwables.ToIntFunction<? super T,E2> func)
<E2 extends Exception> u.OptionalDouble	averageLong(Throwables.ToLongFunction<? super T,E2> func)
CheckedStream<T,E>	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.
CheckedStream<T,E>	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.
CheckedStream<T,Exception>	cast()
void	close()	It will be called by terminal operations in final.
CheckedStream<List<T>,E>	collapse(Throwables.BiPredicate<? super T,? super T,? extends E> collapsible)
CheckedStream<T,E>	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>	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>	collapse(Throwables.BiPredicate<? super T,? super T,? extends E> collapsible, Supplier<? extends C> supplier)
<R> CheckedStream<R,E>	collapse(Throwables.BiPredicate<? super T,? super T,? extends E> collapsible, Collector<? super T,?,R> collector)
<U> CheckedStream<U,E>	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>	collapse(Throwables.TriPredicate<? super T,? super T,? super T,? extends E> collapsible)
CheckedStream<T,E>	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>	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>	collapse(Throwables.TriPredicate<? super T,? super T,? super T,? extends E> collapsible, Supplier<? extends C> supplier)
<R> CheckedStream<R,E>	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>	collapse(Throwables.TriPredicate<? super T,? super T,? super T,? extends E> collapsible, U init, Throwables.BiFunction<U,? super T,U,? extends E> op)
<R, E2 extends Exception, E3 extends Exception> R	collect(Throwables.Supplier<R,E2> supplier, Throwables.BiConsumer<? super R,? super T,E3> accumulator)
<R, RR, E2 extends Exception, E3 extends Exception, E4 extends Exception> RR	collect(Throwables.Supplier<R,E2> supplier, Throwables.BiConsumer<? super R,? super T,E3> accumulator, Throwables.Function<? super R,? extends RR,E4> finisher)
<R> R	collect(Collector<? super T,?,R> collector)
<R, E2 extends Exception> void	collectThenAccept(Collector<? super T,?,R> collector, Throwables.Consumer<? super R,E2> consumer)
<R, RR, E2 extends Exception> RR	collectThenApply(Collector<? super T,?,R> collector, Throwables.Function<? super R,? extends RR,E2> func)
static <T, E extends Exception> CheckedStream<T,E>	concat(CheckedStream<? extends T,E>... a)
static <T, E extends Exception> CheckedStream<T,E>	concat(Iterable<? extends T>... a)
static <T, E extends Exception> CheckedStream<T,E>	concat(Collection<? extends CheckedStream<? extends T,E>> c)
static <T, E extends Exception> CheckedStream<T,E>	concat(Iterator<? extends T>... a)
static <T, E extends Exception> CheckedStream<T,E>	concat(T[]... a)
boolean	containsAll(Collection<? extends T> c)
final boolean	containsAll(T... a)
boolean	containsAny(Collection<? extends T> c)
final boolean	containsAny(T... a)
long	count()
<K> CheckedStream<Map.Entry<K,Integer>,E>	countBy(Throwables.Function<? super T,? extends K,? extends E> keyMapper)
CheckedStream<T,E>	cycled()
CheckedStream<T,E>	cycled(long rounds)
CheckedStream<T,E>	defaultIfEmpty(Throwables.Supplier<? extends CheckedStream<T,E>,? extends E> supplier)
CheckedStream<T,E>	defaultIfEmpty(T defaultValue)
static <T, E extends Exception> CheckedStream<T,E>	defer(Throwables.Supplier<? extends CheckedStream<? extends T,? extends E>,? extends E> supplier)	Lazy evaluation.
CheckedStream<T,E>	delay(Duration delay)
CheckedStream<T,E>	difference(Collection<?> c)
<U> CheckedStream<T,E>	difference(Function<? super T,? extends U> mapper, Collection<U> c)
CheckedStream<T,E>	distinct()	Distinct and filter by occurrences.
CheckedStream<T,E>	distinct(Throwables.BinaryOperator<T,? extends E> mergeFunction)	Distinct and filter by occurrences.
CheckedStream<T,E>	distinct(Throwables.Predicate<? super Long,? extends E> occurrencesFilter)	Distinct and filter by occurrences.
<K> CheckedStream<T,E>	distinctBy(Throwables.Function<? super T,K,? extends E> keyMapper)	Distinct by the value mapped from keyMapper .
<K> CheckedStream<T,E>	distinctBy(Throwables.Function<? super T,K,? extends E> keyMapper, Throwables.BinaryOperator<T,? extends E> mergeFunction)	Distinct and filter by occurrences.
<K> CheckedStream<T,E>	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>	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>	dropWhile(Throwables.Predicate<? super T,? extends E> predicate)
CheckedStream<T,E>	dropWhile(Throwables.Predicate<? super T,? extends E> predicate, Throwables.Consumer<? super T,? extends E> actionOnDroppedItem)
CheckedStream<T,E>	dropWhileAddSubscriber(Predicate<? super T> predicate, Throwables.Consumer<? super CheckedStream<T,E>,? extends Exception> consumerForNewStreamWithTerminalAction)	Add a new Stream with terminal action to listen/consume the elements dropped by the specified predicate.
CheckedStream<T,E>	dropWhileAddSubscriber(Predicate<? super T> predicate, Throwables.Consumer<? super CheckedStream<T,E>,? extends Exception> consumerForNewStreamWithTerminalAction, int queueSize, Executor executor)	Add a new Stream with terminal action to listen/consume the elements dropped by the specified predicate.
u.Optional<T>	elementAt(long position)
static <T, E extends Exception> CheckedStream<T,E>	empty()
CheckedStream<T,E>	filter(Throwables.Predicate<? super T,? extends E> predicate)
CheckedStream<T,E>	filter(Throwables.Predicate<? super T,? extends E> predicate, Throwables.Consumer<? super T,? extends E> actionOnDroppedItem)
CheckedStream<T,Exception>	filterE(Throwables.Predicate<? super T,? extends Exception> predicate)
CheckedStream<T,E>	filterWhileAddSubscriber(Predicate<? super T> predicate, Throwables.Consumer<? super CheckedStream<T,E>,? extends Exception> consumerForNewStreamWithTerminalAction)	Add a new Stream with terminal action to listen/consume the elements filtered out by the specified predicate.
CheckedStream<T,E>	filterWhileAddSubscriber(Predicate<? super T> predicate, Throwables.Consumer<? super CheckedStream<T,E>,? extends Exception> consumerForNewStreamWithTerminalAction, int queueSize, Executor executor)	Add a new Stream with terminal action to listen/consume the elements filtered out by the specified predicate.
<E2 extends Exception> u.Optional<T>	findAny(Throwables.Predicate<? super T,E2> predicate)	Same as findFirst(Throwables.Predicate).
<E2 extends Exception> u.Optional<T>	findFirst(Throwables.Predicate<? super T,E2> predicate)
<E2 extends Exception> u.Optional<T>	findFirstOrAny(Throwables.Predicate<? super T,E2> predicateForFirst)	Returns the first element matched by predicateForFirst if found or the first element if this stream is not empty Otherwise an empty Optional<T> will be returned.
<E2 extends Exception, E3 extends Exception> u.Optional<T>	findFirstOrAny(Throwables.Predicate<? super T,E2> predicateForFirst, Throwables.Predicate<? super T,E3> predicateForAny)	Returns the first element matched by predicateForFirst if found or the first element matched by predicateForAny.
<E2 extends Exception> u.Optional<T>	findFirstOrLast(Throwables.Predicate<? super T,E2> predicateForFirst)	Returns the first element matched by predicateForFirst if found or the last element if this stream is not empty Otherwise an empty Optional<T> will be returned.
<E2 extends Exception> u.Optional<T>	findLast(Throwables.Predicate<? super T,E2> predicate)	Consider using: stream.reversed().findFirst(predicate) for better performance if possible.
u.Optional<T>	first()
<R> CheckedStream<R,E>	flatmap(Throwables.Function<? super T,? extends Collection<? extends R>,? extends E> mapper)
<R> CheckedStream<R,E>	flatMap(Throwables.Function<? super T,? extends CheckedStream<? extends R,? extends E>,? extends E> mapper)
<R> CheckedStream<R,Exception>	flatmapE(Throwables.Function<? super T,? extends Collection<? extends R>,? extends Exception> mapper)
<R> CheckedStream<R,Exception>	flatMapE(Throwables.Function<? super T,? extends CheckedStream<? extends R,? extends Exception>,? extends Exception> mapper)
<R> CheckedStream<R,E>	flatMapIfNotNull(Throwables.Function<? super T,? extends Collection<? extends R>,? extends E> mapper)
<U, R> CheckedStream<R,E>	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>	flatMapToBoolean(Throwables.Function<? super T,boolean[],? extends E> mapper)
CheckedStream<Byte,E>	flatMapToByte(Throwables.Function<? super T,byte[],? extends E> mapper)
CheckedStream<Character,E>	flatMapToChar(Throwables.Function<? super T,char[],? extends E> mapper)
CheckedStream<Double,E>	flatMapToDouble(Throwables.Function<? super T,double[],? extends E> mapper)
CheckedStream<Float,E>	flatMapToFloat(Throwables.Function<? super T,float[],? extends E> mapper)
CheckedStream<Integer,E>	flatMapToInteger(Throwables.Function<? super T,int[],? extends E> mapper)
CheckedStream<Long,E>	flatMapToLong(Throwables.Function<? super T,long[],? extends E> mapper)
CheckedStream<Short,E>	flatMapToShort(Throwables.Function<? super T,short[],? extends E> mapper)
<R> CheckedStream<R,E>	flattmap(Throwables.Function<? super T,? extends Stream<? extends R>,? extends E> mapper)
<R> CheckedStream<R,E>	flattMap(Throwables.Function<? super T,R[],? extends E> mapper)
<E2 extends Exception> void	forEach(Throwables.Consumer<? super T,E2> action)
<E2 extends Exception, E3 extends Exception> void	forEach(Throwables.Consumer<? super T,E2> action, Throwables.Runnable<E3> onComplete)
<U, E2 extends Exception, E3 extends Exception> void	forEach(Throwables.Function<? super T,? extends Iterable<? extends U>,E2> flatMapper, Throwables.BiConsumer<? super T,? super U,E3> action)
<T2, T3, E2 extends Exception, E3 extends Exception, E4 extends Exception> void	forEach(Throwables.Function<? super T,? extends Iterable<T2>,E2> flatMapper, Throwables.Function<? super T2,? extends Iterable<T3>,E3> flatMapper2, Throwables.TriConsumer<? super T,? super T2,? super T3,E4> action)
<E2 extends Exception> void	forEachIndexed(Throwables.IntObjConsumer<? super T,E2> action)
<E2 extends Exception> void	forEachInParallel(int threadNum, Throwables.Consumer<? super T,E2> action)
<E2 extends Exception> void	forEachInParallel(int threadNum, Throwables.Consumer<? super T,E2> action, Executor executor)
<E2 extends Exception> void	forEachPair(int increment, Throwables.BiConsumer<? super T,? super T,E2> action)	For each pair.
<E2 extends Exception> void	forEachPair(Throwables.BiConsumer<? super T,? super T,E2> action)	For each pair.
<E2 extends Exception> void	forEachTriple(int increment, Throwables.TriConsumer<? super T,? super T,? super T,E2> action)	For each triple.
<E2 extends Exception> void	forEachTriple(Throwables.TriConsumer<? super T,? super T,? super T,E2> action)	For each triple.
<E2 extends Exception> void	forEachUntil(MutableBoolean flagToBreak, Throwables.Consumer<? super T,E2> action)	Iterate and execute action until flagToBreak is set true.
<E2 extends Exception> void	forEachUntil(Throwables.BiConsumer<? super T,MutableBoolean,E2> action)	Iterate and execute action until the flag is set true.
static <T, E extends Exception> CheckedStream<T,E>	generate(Throwables.Supplier<T,E> supplier)
<K> CheckedStream<Map.Entry<K,List<T>>,E>	groupBy(Throwables.Function<? super T,? extends K,? extends E> keyMapper)
<K, V> CheckedStream<Map.Entry<K,List<V>>,E>	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>	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>	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>	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>	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>	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>	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>	groupBy(Throwables.Function<? super T,? extends K,? extends E> keyMapper, Collector<? super T,?,D> downstream)
<K, D> CheckedStream<Map.Entry<K,D>,E>	groupBy(Throwables.Function<? super T,? extends K,? extends E> keyMapper, Collector<? super T,?,D> downstream, Supplier<? extends Map<K,D>> mapFactory)
<K, E2 extends Exception> Map<K,List<T>>	groupTo(Throwables.Function<? super T,? extends K,E2> keyMapper)
<K, V, E2 extends Exception, E3 extends Exception> Map<K,List<V>>	groupTo(Throwables.Function<? super T,? extends K,E2> keyMapper, Throwables.Function<? super T,? extends V,E3> valueMapper)
<K, V, M extends Map<K, List<V>>, E2 extends Exception, E3 extends Exception> M	groupTo(Throwables.Function<? super T,? extends K,E2> keyMapper, Throwables.Function<? super T,? extends V,E3> valueMapper, Supplier<? extends M> mapFactory)
<K, V, D, E2 extends Exception, E3 extends Exception> Map<K,D>	groupTo(Throwables.Function<? super T,? extends K,E2> keyMapper, Throwables.Function<? super T,? extends V,E3> valueMapper, Collector<? super V,?,D> downstream)
<K, V, D, M extends Map<K, D>, E2 extends Exception, E3 extends Exception> M	groupTo(Throwables.Function<? super T,? extends K,E2> keyMapper, Throwables.Function<? super T,? extends V,E3> valueMapper, Collector<? super V,?,D> downstream, Supplier<? extends M> mapFactory)
<K, M extends Map<K, List<T>>, E2 extends Exception> M	groupTo(Throwables.Function<? super T,? extends K,E2> keyMapper, Supplier<? extends M> mapFactory)
<K, D, E2 extends Exception> Map<K,D>	groupTo(Throwables.Function<? super T,? extends K,E2> keyMapper, Collector<? super T,?,D> downstream)
<K, D, M extends Map<K, D>, E2 extends Exception> M	groupTo(Throwables.Function<? super T,? extends K,E2> keyMapper, Collector<? super T,?,D> downstream, Supplier<? extends M> mapFactory)
boolean	hasDuplicates()
CheckedStream<Indexed<T>,E>	indexed()
<U> CheckedStream<T,E>	intersection(Throwables.Function<? super T,? extends U,E> mapper, Collection<U> c)
CheckedStream<T,E>	intersection(Collection<?> c)
CheckedStream<T,E>	intersperse(T delimiter)
static <T, E extends Exception> CheckedStream<T,E>	iterate(Throwables.BooleanSupplier<? extends E> hasNext, Throwables.Supplier<? extends T,E> next)
static <T, E extends Exception> CheckedStream<T,E>	iterate(T init, Throwables.BooleanSupplier<? extends E> hasNext, Throwables.UnaryOperator<T,? extends E> f)
static <T, E extends Exception> CheckedStream<T,E>	iterate(T init, Throwables.Predicate<? super T,? extends E> hasNext, Throwables.UnaryOperator<T,? extends E> f)
static <T, E extends Exception> CheckedStream<T,E>	iterate(T init, Throwables.UnaryOperator<T,? extends E> f)
String	join(CharSequence delimiter)
String	join(CharSequence delimiter, CharSequence prefix, CharSequence suffix)
static <T, E extends Exception> CheckedStream<T,E>	just(T e)
static <T, E extends Exception> CheckedStream<T,E>	just(T e, Class<E> exceptionType)
u.Optional<T>	kthLargest(int k, Comparator<? super T> comparator)
u.Optional<T>	last()
CheckedStream<T,E>	last(int n)	A queue with size up to n will be maintained to filter out the last n elements.
CheckedStream<T,E>	limit(long maxSize)
static CheckedStream<String,IOException>	lines(File file)
static CheckedStream<String,IOException>	lines(File file, Charset charset)
static CheckedStream<String,IOException>	lines(Reader reader)
static CheckedStream<String,IOException>	lines(Path path)
static CheckedStream<String,IOException>	lines(Path path, Charset charset)
static CheckedStream<File,IOException>	listFiles(File parentPath)
static CheckedStream<File,IOException>	listFiles(File parentPath, boolean recursively)
<R> CheckedStream<R,E>	map(Throwables.Function<? super T,? extends R,? extends E> mapper)
<U> CheckedStream<U,Exception>	mapE(Throwables.Function<? super T,? extends U,? extends Exception> mapper)
CheckedStream<T,E>	mapFirst(Throwables.Function<? super T,? extends T,? extends E> mapperForFirst)
<R> CheckedStream<R,E>	mapFirstOrElse(Throwables.Function<? super T,? extends R,E> mapperForFirst, Throwables.Function<? super T,? extends R,E> mapperForElse)
<R> CheckedStream<R,E>	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>	mapLast(Throwables.Function<? super T,? extends T,? extends E> mapperForLast)
<R> CheckedStream<R,E>	mapLastOrElse(Throwables.Function<? super T,? extends R,E> mapperForLast, Throwables.Function<? super T,? extends R,E> mapperForElse)
<R> CheckedStream<R,E>	mapMulti(Throwables.BiConsumer<? super T,? super Consumer<R>,? extends E> mapper)
<R> CheckedStream<R,E>	mapPartial(Throwables.Function<? super T,u.Optional<? extends R>,E> mapper)	Note: copied from StreamEx: https://github.com/amaembo/streamex
<R> CheckedStream<R,E>	mapPartialJdk(Throwables.Function<? super T,Optional<? extends R>,E> mapper)	Note: copied from StreamEx: https://github.com/amaembo/streamex
CheckedStream<Double,E>	mapPartialToDouble(Throwables.Function<? super T,u.OptionalDouble,E> mapper)	Note: copied from StreamEx: https://github.com/amaembo/streamex
CheckedStream<Double,E>	mapPartialToDoubleJdk(Throwables.Function<? super T,OptionalDouble,E> mapper)	Note: copied from StreamEx: https://github.com/amaembo/streamex
CheckedStream<Integer,E>	mapPartialToInt(Throwables.Function<? super T,u.OptionalInt,E> mapper)	Note: copied from StreamEx: https://github.com/amaembo/streamex
CheckedStream<Integer,E>	mapPartialToIntJdk(Throwables.Function<? super T,OptionalInt,E> mapper)	Note: copied from StreamEx: https://github.com/amaembo/streamex
CheckedStream<Long,E>	mapPartialToLong(Throwables.Function<? super T,u.OptionalLong,E> mapper)	Note: copied from StreamEx: https://github.com/amaembo/streamex
CheckedStream<Long,E>	mapPartialToLongJdk(Throwables.Function<? super T,OptionalLong,E> mapper)	Note: copied from StreamEx: https://github.com/amaembo/streamex
u.Optional<T>	max(Comparator<? super T> comparator)
u.Optional<T>	maxBy(Function<? super T,? extends Comparable> keyMapper)
static <T, E extends Exception> CheckedStream<T,E>	merge(CheckedStream<? extends T,E> a, CheckedStream<? extends T,E> b, CheckedStream<? extends T,E> c, Throwables.BiFunction<? super T,? super T,MergeResult,E> nextSelector)
static <T, E extends Exception> CheckedStream<T,E>	merge(CheckedStream<? extends T,E> a, CheckedStream<? extends T,E> b, Throwables.BiFunction<? super T,? super T,MergeResult,E> nextSelector)
static <T, E extends Exception> CheckedStream<T,E>	merge(Iterable<? extends T> a, Iterable<? extends T> b, Throwables.BiFunction<? super T,? super T,MergeResult,E> nextSelector)
static <T, E extends Exception> CheckedStream<T,E>	merge(Iterable<? extends T> a, Iterable<? extends T> b, Iterable<? extends T> c, Throwables.BiFunction<? super T,? super T,MergeResult,E> nextSelector)
static <T, E extends Exception> CheckedStream<T,E>	merge(Iterator<? extends T> a, Iterator<? extends T> b, Throwables.BiFunction<? super T,? super T,MergeResult,E> nextSelector)
static <T, E extends Exception> CheckedStream<T,E>	merge(Iterator<? extends T> a, Iterator<? extends T> b, Iterator<? extends T> c, Throwables.BiFunction<? super T,? super T,MergeResult,E> nextSelector)
static <T, E extends Exception> CheckedStream<T,E>	merge(T[] a, T[] b, Throwables.BiFunction<? super T,? super T,MergeResult,E> nextSelector)
static <T, E extends Exception> CheckedStream<T,E>	merge(T[] a, T[] b, T[] c, Throwables.BiFunction<? super T,? super T,MergeResult,E> nextSelector)
CheckedStream<T,E>	mergeWith(CheckedStream<? extends T,E> b, Throwables.BiFunction<? super T,? super T,MergeResult,E> nextSelector)
CheckedStream<T,E>	mergeWith(Collection<? extends T> b, Throwables.BiFunction<? super T,? super T,MergeResult,E> nextSelector)
u.Optional<T>	min(Comparator<? super T> comparator)
u.Optional<T>	minBy(Function<? super T,? extends Comparable> keyMapper)
<E2 extends Exception> boolean	nMatch(long atLeast, long atMost, Throwables.Predicate<? super T,E2> predicate)
<E2 extends Exception> boolean	noneMatch(Throwables.Predicate<? super T,E2> predicate)
static <E extends Exception> CheckedStream<Boolean,E>	of(boolean[] a)
static <E extends Exception> CheckedStream<Byte,E>	of(byte[] a)
static <E extends Exception> CheckedStream<Character,E>	of(char[] a)
static <E extends Exception> CheckedStream<Double,E>	of(double[] a)
static <E extends Exception> CheckedStream<Float,E>	of(float[] a)
static <E extends Exception> CheckedStream<Integer,E>	of(int[] a)
static <E extends Exception> CheckedStream<Long,E>	of(long[] a)
static <E extends Exception> CheckedStream<Short,E>	of(short[] a)
static <T, E extends Exception> CheckedStream<T,E>	of(Stream<? extends T> stream)
static <T, E extends Exception> CheckedStream<T,E>	of(Stream<? extends T> stream, Class<E> exceptionType)
static <T, E extends Exception> CheckedStream<T,E>	of(u.Optional<T> op)
static <T, E extends Exception> CheckedStream<T,E>	of(Iterable<? extends T> iterable)
static <T, E extends Exception> CheckedStream<T,E>	of(Iterable<? extends T> iterable, Class<E> exceptionType)
static <T, E extends Exception> CheckedStream<T,E>	of(Collection<? extends T> c)
static <T, E extends Exception> CheckedStream<T,E>	of(Collection<? extends T> c, Class<E> exceptionType)
static <T, E extends Exception> CheckedStream<T,E>	of(Iterator<? extends T> iter)
static <T, E extends Exception> CheckedStream<T,E>	of(Iterator<? extends T> iter, Class<E> exceptionType)
static <K, V, E extends Exception> CheckedStream<Map.Entry<K,V>,E>	of(Map<K,V> m)
static <K, V, E extends Exception> CheckedStream<Map.Entry<K,V>,E>	of(Map<K,V> m, Class<E> exceptionType)
static <T, E extends Exception> CheckedStream<T,E>	of(Optional<T> op)
static <T, E extends Exception> CheckedStream<T,E>	of(Stream<? extends T> stream)
static <T, E extends Exception> CheckedStream<T,E>	of(Stream<? extends T> stream, Class<E> exceptionType)
static <T, E extends Exception> CheckedStream<T,E>	of(T... a)
static <K, E extends Exception> CheckedStream<K,E>	ofKeys(Map<K,?> map)
static <K, V, E extends Exception> CheckedStream<K,E>	ofKeys(Map<K,V> map, Throwables.BiPredicate<? super K,? super V,E> filter)
static <K, V, E extends Exception> CheckedStream<K,E>	ofKeys(Map<K,V> map, Throwables.Predicate<? super V,E> valueFilter)
static <T, E extends Exception> CheckedStream<T,E>	ofNullable(T e)	Returns an empty Stream if the specified t is null.
static <T, E extends Exception> CheckedStream<T,E>	ofNullable(T e, Class<E> exceptionType)	Returns an empty Stream if the specified t is null.
static <V, E extends Exception> CheckedStream<V,E>	ofValues(Map<?,V> map)
static <K, V, E extends Exception> CheckedStream<V,E>	ofValues(Map<K,V> map, Throwables.BiPredicate<? super K,? super V,E> filter)
static <K, V, E extends Exception> CheckedStream<V,E>	ofValues(Map<K,V> map, Throwables.Predicate<? super K,E> keyFilter)
CheckedStream<T,E>	onClose(Throwables.Runnable<? extends E> closeHandler)
CheckedStream<T,E>	onEach(Throwables.Consumer<? super T,? extends E> action)
CheckedStream<T,Exception>	onEachE(Throwables.Consumer<? super T,? extends Exception> action)
u.Optional<T>	onlyOne()
CheckedStream<Map.Entry<Boolean,List<T>>,E>	partitionBy(Throwables.Predicate<? super T,E> predicate)
<D> CheckedStream<Map.Entry<Boolean,D>,E>	partitionBy(Throwables.Predicate<? super T,E> predicate, Collector<? super T,?,D> downstream)
<E2 extends Exception> Map<Boolean,List<T>>	partitionTo(Throwables.Predicate<? super T,E2> predicate)
<D, E2 extends Exception> Map<Boolean,D>	partitionTo(Throwables.Predicate<? super T,E2> predicate, Collector<? super T,?,D> downstream)
CheckedStream<T,E>	peek(Throwables.Consumer<? super T,? extends E> action)
CheckedStream<T,E>	peekFirst(Throwables.Consumer<? super T,? extends E> action)
CheckedStream<T,E>	peekIf(Throwables.BiPredicate<? super T,? super Long,E> predicate, Consumer<? super T> action)
CheckedStream<T,E>	peekIf(Throwables.Predicate<? super T,E> predicate, Throwables.Consumer<? super T,E> action)
CheckedStream<T,E>	peekLast(Throwables.Consumer<? super T,? extends E> action)
u.Optional<Map<Percentage,T>>	percentiles(Comparator<? super T> comparator)
long	persist(File output)
long	persist(File output, Throwables.BiConsumer<? super T,Writer,IOException> writeLine)
long	persist(File output, Throwables.Function<? super T,String,E> toLine)
long	persist(File output, String header, String tail)
long	persist(File output, String header, String tail, Throwables.BiConsumer<? super T,Writer,IOException> writeLine)
long	persist(File output, String header, String tail, Throwables.Function<? super T,String,E> toLine)
long	persist(OutputStream output, Throwables.Function<? super T,String,E> toLine)
long	persist(OutputStream output, String header, String tail, Throwables.Function<? super T,String,E> toLine)
long	persist(Writer output, Throwables.BiConsumer<? super T,Writer,IOException> writeLine)
long	persist(Writer output, Throwables.Function<? super T,String,E> toLine)
long	persist(Writer output, String header, String tail, Throwables.BiConsumer<? super T,Writer,IOException> writeLine)
long	persist(Writer output, String header, String tail, Throwables.Function<? super T,String,E> toLine)
long	persist(Connection conn, String insertSQL, int batchSize, long batchIntervalInMillis, Throwables.BiConsumer<? super T,? super PreparedStatement,SQLException> stmtSetter)
long	persist(PreparedStatement stmt, int batchSize, long batchIntervalInMillis, Throwables.BiConsumer<? super T,? super PreparedStatement,SQLException> stmtSetter)
long	persist(DataSource ds, String insertSQL, int batchSize, long batchIntervalInMillis, Throwables.BiConsumer<? super T,? super PreparedStatement,SQLException> stmtSetter)
long	persistToCSV(File output)	Each line in the output file/Writer is an array of JSON String without root bracket.
long	persistToCSV(File output, Collection<String> csvHeaders)	Each line in the output file/Writer is an array of JSON String without root bracket.
long	persistToCSV(OutputStream output)	Each line in the output file/Writer is an array of JSON String without root bracket.
long	persistToCSV(OutputStream output, Collection<String> csvHeaders)	Each line in the output file/Writer is an array of JSON String without root bracket.
long	persistToCSV(Writer output)	Each line in the output file/Writer is an array of JSON String without root bracket.
long	persistToCSV(Writer output, Collection<String> csvHeaders)	Each line in the output file/Writer is an array of JSON String without root bracket.
long	persistToJSON(File output)
long	persistToJSON(OutputStream output)
long	persistToJSON(Writer output)
CheckedStream<T,E>	prepend(CheckedStream<T,E> s)
CheckedStream<T,E>	prepend(Collection<? extends T> c)
final CheckedStream<T,E>	prepend(T... a)
void	println()
static <E extends Exception> CheckedStream<Integer,E>	range(int startInclusive, int endExclusive)
static <E extends Exception> CheckedStream<Integer,E>	range(int startInclusive, int endExclusive, int by)
static <E extends Exception> CheckedStream<Integer,E>	rangeClosed(int startInclusive, int endExclusive)
static <E extends Exception> CheckedStream<Integer,E>	rangeClosed(int startInclusive, int endExclusive, int by)
CheckedStream<T,E>	rateLimited(double permitsPerSecond)
CheckedStream<T,E>	rateLimited(RateLimiter rateLimiter)
<E2 extends Exception> u.Optional<T>	reduce(Throwables.BinaryOperator<T,E2> accumulator)
<U, E2 extends Exception> U	reduce(U identity, Throwables.BiFunction<U,? super T,U,E2> accumulator)
<E2 extends Exception> u.Optional<T>	reduceUntil(Throwables.BinaryOperator<T,E2> accumulator, Throwables.Predicate<? super T,E2> conditionToBreak)
<U, E2 extends Exception> U	reduceUntil(U identity, Throwables.BiFunction<U,? super T,U,E2> accumulator, Throwables.Predicate<? super U,E2> conditionToBreak)
static <T, E extends Exception> CheckedStream<T,E>	repeat(T element, long n)
CheckedStream<T,E>	reversed()
CheckedStream<T,E>	reverseSorted()
CheckedStream<T,E>	reverseSorted(Comparator<? super T> comparator)
CheckedStream<T,E>	reverseSortedBy(Function<? super T,? extends Comparable> keyMapper)
CheckedStream<T,E>	reverseSortedByDouble(ToDoubleFunction<? super T> keyMapper)
CheckedStream<T,E>	reverseSortedByInt(ToIntFunction<? super T> keyMapper)
CheckedStream<T,E>	reverseSortedByLong(ToLongFunction<? super T> keyMapper)
CheckedStream<T,E>	rotated(int distance)
CheckedStream<T,E>	saveEach(File output)
CheckedStream<T,E>	saveEach(File output, Throwables.BiConsumer<? super T,Writer,IOException> writeLine)
CheckedStream<T,E>	saveEach(File output, Throwables.Function<? super T,String,E> toLine)
CheckedStream<T,E>	saveEach(OutputStream output, Throwables.Function<? super T,String,E> toLine)
CheckedStream<T,E>	saveEach(Writer output, Throwables.BiConsumer<? super T,Writer,IOException> writeLine)
CheckedStream<T,E>	saveEach(Writer output, Throwables.Function<? super T,String,E> toLine)
CheckedStream<T,E>	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>	saveEach(PreparedStatement stmt, Throwables.BiConsumer<? super T,? super PreparedStatement,SQLException> stmtSetter)	To support batch call, please use onEach or onEachE.
CheckedStream<T,E>	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>	scan(Throwables.BiFunction<? super T,? super T,T,? extends E> accumulator)
<U> CheckedStream<U,E>	scan(U init, Throwables.BiFunction<U,? super T,U,? extends E> accumulator)
<U> CheckedStream<U,E>	scan(U init, Throwables.BiFunction<U,? super T,U,? extends E> accumulator, boolean initIncluded)
CheckedStream<T,E>	shuffled()
CheckedStream<T,E>	shuffled(Random rnd)
CheckedStream<T,E>	skip(long n)
CheckedStream<T,E>	skipLast(int n)
CheckedStream<T,E>	skipNull()	Deprecated. Use skipNulls() instead
CheckedStream<T,E>	skipNulls()
CheckedStream<T,E>	skipUntil(Throwables.Predicate<? super T,? extends E> predicate)
CheckedStream<Stream<T>,E>	sliding(int windowSize, int increment)
<C extends Collection<T>> CheckedStream<C,E>	sliding(int windowSize, int increment, IntFunction<? extends C> collectionSupplier)
<R> CheckedStream<R,E>	sliding(int windowSize, int increment, Collector<? super T,?,R> collector)
<R> CheckedStream<R,E>	slidingMap(int increment, boolean ignoreNotPaired, Throwables.BiFunction<? super T,? super T,R,? extends E> mapper)
<R> CheckedStream<R,E>	slidingMap(int increment, boolean ignoreNotPaired, Throwables.TriFunction<? super T,? super T,? super T,R,? extends E> mapper)
<R> CheckedStream<R,E>	slidingMap(int increment, Throwables.BiFunction<? super T,? super T,R,? extends E> mapper)
<R> CheckedStream<R,E>	slidingMap(int increment, Throwables.TriFunction<? super T,? super T,? super T,R,? extends E> mapper)
<R> CheckedStream<R,E>	slidingMap(Throwables.BiFunction<? super T,? super T,R,? extends E> mapper)
<R> CheckedStream<R,E>	slidingMap(Throwables.TriFunction<? super T,? super T,? super T,R,? extends E> mapper)
CheckedStream<List<T>,E>	slidingToList(int windowSize, int increment)	Sliding to list.
CheckedStream<Set<T>,E>	slidingToSet(int windowSize, int increment)	Sliding to set.
CheckedStream<T,E>	sorted()
CheckedStream<T,E>	sorted(Comparator<? super T> comparator)
CheckedStream<T,E>	sortedBy(Function<? super T,? extends Comparable> keyMapper)
CheckedStream<T,E>	sortedByDouble(ToDoubleFunction<? super T> keyMapper)
CheckedStream<T,E>	sortedByInt(ToIntFunction<? super T> keyMapper)
CheckedStream<T,E>	sortedByLong(ToLongFunction<? super T> keyMapper)
CheckedStream<Stream<T>,E>	split(int chunkSize)
<C extends Collection<T>> CheckedStream<C,E>	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>	split(int chunkSize, Collector<? super T,?,R> collector)
static <E extends Exception> CheckedStream<String,E>	split(CharSequence str, CharSequence delimiter)
CheckedStream<CheckedStream<T,E>,E>	splitAt(int where)
CheckedStream<CheckedStream<T,E>,E>	splitAt(Throwables.Predicate<? super T,? extends E> where)
CheckedStream<List<T>,E>	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>	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>	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>	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>	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>	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>	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>	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>	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>	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>	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>	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>	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>	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>	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>	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>	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>	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>	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>	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>	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>	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>	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>	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>	step(long step)
<E2 extends Exception> double	sumDouble(Throwables.ToDoubleFunction<? super T,E2> func)
<E2 extends Exception> long	sumInt(Throwables.ToIntFunction<? super T,E2> func)
<E2 extends Exception> long	sumLong(Throwables.ToLongFunction<? super T,E2> func)
CheckedStream<T,E>	symmetricDifference(Collection<T> c)
CheckedStream<T,E>	takeWhile(Throwables.Predicate<? super T,? extends E> predicate)
CheckedStream<T,E>	takeWhileAddSubscriber(Predicate<? super T> predicate, Throwables.Consumer<? super CheckedStream<T,E>,? extends Exception> consumerForNewStreamWithTerminalAction)	Add a new Stream with terminal action to listen/consume the elements not token by the specified predicate.
CheckedStream<T,E>	takeWhileAddSubscriber(Predicate<? super T> predicate, Throwables.Consumer<? super CheckedStream<T,E>,? extends Exception> consumerForNewStreamWithTerminalAction, int queueSize, Executor executor)	Add a new Stream with terminal action to listen/consume the elements not token by the specified predicate.
CheckedStream<T,E>	throwIfEmpty()	Throws NoSuchElementException in terminal operation if this CheckedStream if empty.
CheckedStream<T,E>	throwIfEmpty(Supplier<? extends E> exceptionSupplier)
CheckedStream<Timed<T>,E>	timed()
Object[]	toArray()
<A> A[]	toArray(IntFunction<A[]> generator)
<C extends Collection<T>> C	toCollection(Supplier<? extends C> supplier)
<CC extends Collection<T>, E2 extends Exception> void	toCollectionThenAccept(Supplier<? extends CC> supplier, Throwables.Consumer<? super CC,E2> consumer)
<R, CC extends Collection<T>, E2 extends Exception> R	toCollectionThenApply(Supplier<? extends CC> supplier, Throwables.Function<? super CC,R,E2> func)
DataSet	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 bean or map.
DataSet	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 bean or map.
ImmutableList<T>	toImmutableList()
<K, V, E2 extends Exception, E3 extends Exception> ImmutableMap<K,V>	toImmutableMap(Throwables.Function<? super T,? extends K,E2> keyMapper, Throwables.Function<? super T,? extends V,E3> valueMapper)
<K, V, E2 extends Exception, E3 extends Exception, E4 extends Exception> ImmutableMap<K,V>	toImmutableMap(Throwables.Function<? super T,? extends K,E2> keyMapper, Throwables.Function<? super T,? extends V,E3> valueMapper, Throwables.BinaryOperator<V,E4> mergeFunction)
ImmutableSet<T>	toImmutableSet()
Stream<T>	toJdkStream()
List<T>	toList()
<E2 extends Exception> void	toListThenAccept(Throwables.Consumer<? super List<T>,E2> consumer)
<R, E2 extends Exception> R	toListThenApply(Throwables.Function<? super List<T>,R,E2> func)
LongMultiset<T>	toLongMultiset()
LongMultiset<T>	toLongMultiset(Supplier<? extends LongMultiset<T>> supplier)
<K, V, E2 extends Exception, E3 extends Exception> Map<K,V>	toMap(Throwables.Function<? super T,? extends K,E2> keyMapper, Throwables.Function<? super T,? extends V,E3> valueMapper)
<K, V, E2 extends Exception, E3 extends Exception, E4 extends Exception> Map<K,V>	toMap(Throwables.Function<? super T,? extends K,E2> keyMapper, Throwables.Function<? super T,? extends V,E3> valueMapper, Throwables.BinaryOperator<V,E4> mergeFunction)
<K, V, M extends Map<K, V>, E2 extends Exception, E3 extends Exception, E4 extends Exception> M	toMap(Throwables.Function<? super T,? extends K,E2> keyMapper, Throwables.Function<? super T,? extends V,E3> valueMapper, Throwables.BinaryOperator<V,E4> mergeFunction, Supplier<? extends M> mapFactory)
<K, V, M extends Map<K, V>, E2 extends Exception, E3 extends Exception> M	toMap(Throwables.Function<? super T,? extends K,E2> keyMapper, Throwables.Function<? super T,? extends V,E3> valueMapper, Supplier<? extends M> mapFactory)
<K, E2 extends Exception> ListMultimap<K,T>	toMultimap(Throwables.Function<? super T,? extends K,E2> keyMapper)
<K, V, E2 extends Exception, E3 extends Exception> ListMultimap<K,V>	toMultimap(Throwables.Function<? super T,? extends K,E2> keyMapper, Throwables.Function<? super T,? extends V,E3> valueMapper)
<K, V, C extends Collection<V>, M extends Multimap<K, V, C>, E2 extends Exception, E3 extends Exception> M	toMultimap(Throwables.Function<? super T,? extends K,E2> keyMapper, Throwables.Function<? super T,? extends V,E3> valueMapper, Supplier<? extends M> mapFactory)
<K, V extends Collection<T>, M extends Multimap<K, T, V>, E2 extends Exception> M	toMultimap(Throwables.Function<? super T,? extends K,E2> keyMapper, Supplier<? extends M> mapFactory)
Multiset<T>	toMultiset()
Multiset<T>	toMultiset(Supplier<? extends Multiset<T>> supplier)
CheckedStream<T,E>	top(int n)
CheckedStream<T,E>	top(int n, Comparator<? super T> comparator)
Set<T>	toSet()
<E2 extends Exception> void	toSetThenAccept(Throwables.Consumer<? super Set<T>,E2> consumer)
<R, E2 extends Exception> R	toSetThenApply(Throwables.Function<? super Set<T>,R,E2> func)
<TT, EE extends Exception> CheckedStream<TT,EE>	transform(Function<? super CheckedStream<T,E>,CheckedStream<TT,EE>> transfer)
Stream<T>	unchecked()
static <A, B, T, E extends Exception> CheckedStream<T,E>	zip(A[] a, B[] b, A valueForNoneA, B valueForNoneB, Throwables.BiFunction<? super A,? super B,? extends T,? extends E> zipFunction)	Zip together the "a" and "b" iterators until all of them runs out of values.
static <A, B, C, T, E extends Exception> CheckedStream<T,E>	zip(A[] a, B[] b, C[] c, A valueForNoneA, B valueForNoneB, C valueForNoneC, Throwables.TriFunction<? super A,? super B,? super C,? extends T,? extends E> zipFunction)	Zip together the "a", "b" and "c" iterators until all of them runs out of values.
static <A, B, C, T, E extends Exception> CheckedStream<T,E>	zip(A[] a, B[] b, C[] c, Throwables.TriFunction<? super A,? super B,? super C,? extends T,? extends E> zipFunction)	Zip together the "a", "b" and "c" arrays until one of them runs out of values.
static <A, B, T, E extends Exception> CheckedStream<T,E>	zip(A[] a, B[] b, Throwables.BiFunction<? super A,? super B,? extends T,? extends E> zipFunction)	Zip together the "a" and "b" arrays until one of them runs out of values.
static <A, B, T, E extends Exception> CheckedStream<T,E>	zip(CheckedStream<? extends A,E> a, CheckedStream<? extends B,E> b, A valueForNoneA, B valueForNoneB, Throwables.BiFunction<? super A,? super B,? extends T,? extends E> zipFunction)	Zip together the "a" and "b" streams until one of them runs out of values.
static <A, B, C, T, E extends Exception> CheckedStream<T,E>	zip(CheckedStream<? extends A,E> a, CheckedStream<? extends B,E> b, CheckedStream<? extends C,E> c, A valueForNoneA, B valueForNoneB, C valueForNoneC, Throwables.TriFunction<? super A,? super B,? super C,? extends T,? extends E> zipFunction)	Zip together the "a", "b" and "c" streams until one of them runs out of values.
static <A, B, C, T, E extends Exception> CheckedStream<T,E>	zip(CheckedStream<? extends A,E> a, CheckedStream<? extends B,E> b, CheckedStream<? extends C,E> c, Throwables.TriFunction<? super A,? super B,? super C,? extends T,? extends E> zipFunction)	Zip together the "a", "b" and "c" streams until one of them runs out of values.
static <A, B, T, E extends Exception> CheckedStream<T,E>	zip(CheckedStream<? extends A,E> a, CheckedStream<? extends B,E> b, Throwables.BiFunction<? super A,? super B,? extends T,? extends E> zipFunction)	Zip together the "a" and "b" streams until one of them runs out of values.
static <A, B, T, E extends Exception> CheckedStream<T,E>	zip(Iterable<? extends A> a, Iterable<? extends B> b, A valueForNoneA, B valueForNoneB, Throwables.BiFunction<? super A,? super B,? extends T,? extends E> zipFunction)	Zip together the "a" and "b" iterators until all of them runs out of values.
static <A, B, T, E extends Exception> CheckedStream<T,E>	zip(Iterable<? extends A> a, Iterable<? extends B> b, Throwables.BiFunction<? super A,? super B,? extends T,? extends E> zipFunction)	Zip together the "a" and "b" arrays until one of them runs out of values.
static <A, B, C, T, E extends Exception> CheckedStream<T,E>	zip(Iterable<? extends A> a, Iterable<? extends B> b, Iterable<? extends C> c, A valueForNoneA, B valueForNoneB, C valueForNoneC, Throwables.TriFunction<? super A,? super B,? super C,? extends T,? extends E> zipFunction)	Zip together the "a", "b" and "c" iterators until all of them runs out of values.
static <A, B, C, T, E extends Exception> CheckedStream<T,E>	zip(Iterable<? extends A> a, Iterable<? extends B> b, Iterable<? extends C> c, Throwables.TriFunction<? super A,? super B,? super C,? extends T,? extends E> zipFunction)	Zip together the "a", "b" and "c" arrays until one of them runs out of values.
static <A, B, T, E extends Exception> CheckedStream<T,E>	zip(Iterator<? extends A> a, Iterator<? extends B> b, A valueForNoneA, B valueForNoneB, Throwables.BiFunction<? super A,? super B,? extends T,? extends E> zipFunction)	Zip together the "a" and "b" iterators until all of them runs out of values.
static <A, B, T, E extends Exception> CheckedStream<T,E>	zip(Iterator<? extends A> a, Iterator<? extends B> b, Throwables.BiFunction<? super A,? super B,? extends T,? extends E> zipFunction)	Zip together the "a" and "b" iterators until one of them runs out of values.
static <A, B, C, T, E extends Exception> CheckedStream<T,E>	zip(Iterator<? extends A> a, Iterator<? extends B> b, Iterator<? extends C> c, A valueForNoneA, B valueForNoneB, C valueForNoneC, Throwables.TriFunction<? super A,? super B,? super C,? extends T,? extends E> zipFunction)	Zip together the "a", "b" and "c" iterators until all of them runs out of values.
static <A, B, C, T, E extends Exception> CheckedStream<T,E>	zip(Iterator<? extends A> a, Iterator<? extends B> b, Iterator<? extends C> c, Throwables.TriFunction<? super A,? super B,? super C,? extends T,? extends E> zipFunction)	Zip together the "a", "b" and "c" iterators until one of them runs out of values.
<T2, T3, R> CheckedStream<R,E>	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>	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>	zipWith(CheckedStream<T2,E> b, Throwables.BiFunction<? super T,? super T2,? extends R,? extends E> zipFunction)
<T2, R> CheckedStream<R,E>	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>	zipWith(Collection<T2> b, Throwables.BiFunction<? super T,? super T2,? extends R,? extends E> zipFunction)
<T2, T3, R> CheckedStream<R,E>	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>	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>	zipWith(Collection<T2> b, T valueForNoneA, T2 valueForNoneB, Throwables.BiFunction<? super T,? super T2,? extends R,? extends E> zipFunction)

Methods inherited from class java.lang.Object

equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Method Details

empty

public static <T,
E extends Exception>
CheckedStream<T,E> empty()

Type Parameters:

T -

E -

Returns:

just

public static <T,
E extends Exception>
CheckedStream<T,E> just(T e)

Type Parameters:

T -

E -

Parameters:

e -

Returns:

just

public static <T,
E extends Exception>
CheckedStream<T,E> just(T e,
 Class<E> exceptionType)

Type Parameters:

T -

E -

Parameters:

e -

exceptionType -

Returns:

ofNullable

public static <T,
E extends Exception>
CheckedStream<T,E> ofNullable(T e)

Returns an empty Stream if the specified t is null.

Type Parameters:

T -

E -

Parameters:

e -

Returns:

ofNullable

public static <T,
E extends Exception>
CheckedStream<T,E> ofNullable(T e,
 Class<E> exceptionType)

Returns an empty Stream if the specified t is null.

Type Parameters:

T -

E -

Parameters:

e -

exceptionType -

Returns:

of

public static <T,
E extends Exception>
CheckedStream<T,E> of(T... a)

Type Parameters:

T -

E -

Parameters:

a -

Returns:

of

public static <T,
E extends Exception>
CheckedStream<T,E> of(Collection<? extends T> c)

Type Parameters:

T -

E -

Parameters:

c -

Returns:

of

public static <T,
E extends Exception>
CheckedStream<T,E> of(Iterator<? extends T> iter)

Type Parameters:

T -

E -

Parameters:

iter -

Returns:

of

public static <T,
E extends Exception>
CheckedStream<T,E> of(Iterable<? extends T> iterable)

Type Parameters:

T -

E -

Parameters:

iterable -

Returns:

of

public static <K,
V,
E extends Exception>
CheckedStream<Map.Entry<K,V>,E> of(Map<K,V> m)

Type Parameters:

K - the key type

V - the value type

E -

Parameters:

m -

Returns:

of

public static <T,
E extends Exception>
CheckedStream<T,E> of(Stream<? extends T> stream)

Type Parameters:

T -

E -

Parameters:

stream -

Returns:

of

public static <T,
E extends Exception>
CheckedStream<T,E> of(Stream<? extends T> stream)

Type Parameters:

T -

E -

Parameters:

stream -

Returns:

of

public static <T,
E extends Exception>
CheckedStream<T,E> of(Collection<? extends T> c,
 Class<E> exceptionType)

Type Parameters:

T -

E -

Parameters:

c -

exceptionType -

Returns:

of

public static <T,
E extends Exception>
CheckedStream<T,E> of(Iterator<? extends T> iter,
 Class<E> exceptionType)

Type Parameters:

T -

E -

Parameters:

iter -

exceptionType -

Returns:

of

public static <T,
E extends Exception>
CheckedStream<T,E> of(Iterable<? extends T> iterable,
 Class<E> exceptionType)

Type Parameters:

T -

E -

Parameters:

iterable -

exceptionType -

Returns:

of

public static <K,
V,
E extends Exception>
CheckedStream<Map.Entry<K,V>,E> of(Map<K,V> m,
 Class<E> exceptionType)

Type Parameters:

K - the key type

V - the value type

E -

Parameters:

m -

exceptionType -

Returns:

of

public static <T,
E extends Exception>
CheckedStream<T,E> of(Stream<? extends T> stream,
 Class<E> exceptionType)

Type Parameters:

T -

E -

Parameters:

stream -

exceptionType -

Returns:

of

public static <T,
E extends Exception>
CheckedStream<T,E> of(Stream<? extends T> stream,
 Class<E> exceptionType)

Type Parameters:

T -

E -

Parameters:

stream -

exceptionType -

Returns:

of

public static <E extends Exception>
CheckedStream<Boolean,E> of(boolean[] a)

Type Parameters:

E -

Parameters:

a -

Returns:

of

public static <E extends Exception>
CheckedStream<Character,E> of(char[] a)

Type Parameters:

E -

Parameters:

a -

Returns:

of

public static <E extends Exception>
CheckedStream<Byte,E> of(byte[] a)

Type Parameters:

E -

Parameters:

a -

Returns:

of

public static <E extends Exception>
CheckedStream<Short,E> of(short[] a)

Type Parameters:

E -

Parameters:

a -

Returns:

of

public static <E extends Exception>
CheckedStream<Integer,E> of(int[] a)

Type Parameters:

E -

Parameters:

a -

Returns:

of

public static <E extends Exception>
CheckedStream<Long,E> of(long[] a)

Type Parameters:

E -

Parameters:

a -

Returns:

of

public static <E extends Exception>
CheckedStream<Float,E> of(float[] a)

Type Parameters:

E -

Parameters:

a -

Returns:

of

public static <E extends Exception>
CheckedStream<Double,E> of(double[] a)

Type Parameters:

E -

Parameters:

a -

Returns:

of

public static <T,
E extends Exception>
CheckedStream<T,E> of(u.Optional<T> op)

Type Parameters:

T -

E -

Parameters:

op -

Returns:

of

public static <T,
E extends Exception>
CheckedStream<T,E> of(Optional<T> op)

Type Parameters:

T -

E -

Parameters:

op -

Returns:

ofKeys

public static <K,
E extends Exception>
CheckedStream<K,E> ofKeys(Map<K,?> map)

Type Parameters:

K -

E -

Parameters:

map -

Returns:

ofKeys

public static <K,
V,
E extends Exception>
CheckedStream<K,E> ofKeys(Map<K,V> map,
 Throwables.Predicate<? super V,E> valueFilter)

Type Parameters:

K -

V -

E -

Parameters:

map -

valueFilter -

Returns:

ofKeys

public static <K,
V,
E extends Exception>
CheckedStream<K,E> ofKeys(Map<K,V> map,
 Throwables.BiPredicate<? super K,? super V,E> filter)

Type Parameters:

K -

V -

E -

Parameters:

map -

filter -

Returns:

ofValues

public static <V,
E extends Exception>
CheckedStream<V,E> ofValues(Map<?,V> map)

Type Parameters:

V -

E -

Parameters:

map -

Returns:

ofValues

public static <K,
V,
E extends Exception>
CheckedStream<V,E> ofValues(Map<K,V> map,
 Throwables.Predicate<? super K,E> keyFilter)

Type Parameters:

K -

V -

E -

Parameters:

map -

keyFilter -

Returns:

ofValues

public static <K,
V,
E extends Exception>
CheckedStream<V,E> ofValues(Map<K,V> map,
 Throwables.BiPredicate<? super K,? super V,E> filter)

Type Parameters:

K -

V -

E -

Parameters:

map -

filter -

Returns:

defer

public static <T,
E extends Exception>
CheckedStream<T,E> defer(Throwables.Supplier<? extends CheckedStream<? extends T,? extends E>,? extends E> supplier)

Lazy evaluation.
This is equal to: CheckedStream.just(supplier).flatMap(Throwables.Supplier::get).

Type Parameters:

T -

E -

Parameters:

supplier -

Returns:

iterate

public static <T,
E extends Exception>
CheckedStream<T,E> iterate(Throwables.BooleanSupplier<? extends E> hasNext,
 Throwables.Supplier<? extends T,E> next)

Type Parameters:

T -

E -

Parameters:

hasNext -

next -

Returns:

iterate

public static <T,
E extends Exception>
CheckedStream<T,E> iterate(T init,
 Throwables.BooleanSupplier<? extends E> hasNext,
 Throwables.UnaryOperator<T,? extends E> f)

Type Parameters:

T -

E -

Parameters:

init -

hasNext -

f -

Returns:

iterate

public static <T,
E extends Exception>
CheckedStream<T,E> iterate(T init,
 Throwables.Predicate<? super T,? extends E> hasNext,
 Throwables.UnaryOperator<T,? extends E> f)

Type Parameters:

T -

E -

Parameters:

init -

hasNext -

f -

Returns:

iterate

public static <T,
E extends Exception>
CheckedStream<T,E> iterate(T init,
 Throwables.UnaryOperator<T,? extends E> f)

Type Parameters:

T -

E -

Parameters:

init -

f -

Returns:

generate

public static <T,
E extends Exception>
CheckedStream<T,E> generate(Throwables.Supplier<T,E> supplier)

Type Parameters:

T -

E -

Parameters:

supplier -

Returns:

repeat

public static <T,
E extends Exception>
CheckedStream<T,E> repeat(T element,
 long n)

Type Parameters:

T -

E -

Parameters:

element -

n -

Returns:

range

public static <E extends Exception>
CheckedStream<Integer,E> range(int startInclusive,
 int endExclusive)

Type Parameters:

E -

Parameters:

startInclusive -

endExclusive -

Returns:

range

public static <E extends Exception>
CheckedStream<Integer,E> range(int startInclusive,
 int endExclusive,
 int by)

Type Parameters:

E -

Parameters:

startInclusive -

endExclusive -

by -

Returns:

rangeClosed

public static <E extends Exception>
CheckedStream<Integer,E> rangeClosed(int startInclusive,
 int endExclusive)

Type Parameters:

E -

Parameters:

startInclusive -

endExclusive -

Returns:

rangeClosed

public static <E extends Exception>
CheckedStream<Integer,E> rangeClosed(int startInclusive,
 int endExclusive,
 int by)

Type Parameters:

E -

Parameters:

startInclusive -

endExclusive -

by -

Returns:

split

public static <E extends Exception>
CheckedStream<String,E> split(CharSequence str,
 CharSequence delimiter)

Type Parameters:

E -

Parameters:

str -

delimiter -

Returns:

lines

public static CheckedStream<String,IOException> lines(File file)

Parameters:

file -

Returns:

lines

public static CheckedStream<String,IOException> lines(File file,
 Charset charset)

Parameters:

file -

charset -

Returns:

lines

public static CheckedStream<String,IOException> lines(Path path)

Parameters:

path -

Returns:

lines

public static CheckedStream<String,IOException> lines(Path path,
 Charset charset)

Parameters:

path -

charset -

Returns:

lines

public static CheckedStream<String,IOException> lines(Reader reader)

Parameters:

reader -

Returns:

listFiles

public static CheckedStream<File,IOException> listFiles(File parentPath)

Parameters:

parentPath -

Returns:

listFiles

public static CheckedStream<File,IOException> listFiles(File parentPath,
 boolean recursively)

Parameters:

parentPath -

recursively -

Returns:

concat

@SafeVarargs
public static <T,
E extends Exception>
CheckedStream<T,E> concat(T[]... a)

Type Parameters:

T -

E -

Parameters:

a -

Returns:

concat

@SafeVarargs
public static <T,
E extends Exception>
CheckedStream<T,E> concat(Iterable<? extends T>... a)

Type Parameters:

T -

E -

Parameters:

a -

Returns:

concat

@SafeVarargs
public static <T,
E extends Exception>
CheckedStream<T,E> concat(Iterator<? extends T>... a)

Type Parameters:

T -

E -

Parameters:

a -

Returns:

concat

@SafeVarargs
public static <T,
E extends Exception>
CheckedStream<T,E> concat(CheckedStream<? extends T,E>... a)

Type Parameters:

T -

E -

Parameters:

a -

Returns:

concat

public static <T,
E extends Exception>
CheckedStream<T,E> concat(Collection<? extends CheckedStream<? extends T,E>> c)

Type Parameters:

T -

E -

Parameters:

c -

Returns:

zip

public static <A,
B,
T,
E extends Exception>
CheckedStream<T,E> zip(A[] a,
 B[] b,
 Throwables.BiFunction<? super A,? super B,? extends T,? extends E> zipFunction)

Zip together the "a" and "b" arrays until one of them runs out of values. Each pair of values is combined into a single value using the supplied zipFunction function.

Type Parameters:

A -

B -

T -

E -

Parameters:

a -

b -

zipFunction -

Returns:

zip

public static <A,
B,
C,
T,
E extends Exception>
CheckedStream<T,E> zip(A[] a,
 B[] b,
 C[] c,
 Throwables.TriFunction<? super A,? super B,? super C,? extends T,? extends E> zipFunction)

Zip together the "a", "b" and "c" arrays until one of them runs out of values. Each triple of values is combined into a single value using the supplied zipFunction function.

Type Parameters:

A -

B -

C -

T -

E -

Parameters:

a -

b -

c -

zipFunction -

Returns:

zip

public static <A,
B,
T,
E extends Exception>
CheckedStream<T,E> zip(Iterable<? extends A> a,
 Iterable<? extends B> b,
 Throwables.BiFunction<? super A,? super B,? extends T,? extends E> zipFunction)

Zip together the "a" and "b" arrays until one of them runs out of values. Each pair of values is combined into a single value using the supplied zipFunction function.

Type Parameters:

A -

B -

T -

E -

Parameters:

a -

b -

zipFunction -

Returns:

zip

public static <A,
B,
C,
T,
E extends Exception>
CheckedStream<T,E> zip(Iterable<? extends A> a,
 Iterable<? extends B> b,
 Iterable<? extends C> c,
 Throwables.TriFunction<? super A,? super B,? super C,? extends T,? extends E> zipFunction)

Zip together the "a", "b" and "c" arrays until one of them runs out of values. Each triple of values is combined into a single value using the supplied zipFunction function.

Type Parameters:

A -

B -

C -

T -

E -

Parameters:

a -

b -

c -

zipFunction -

Returns:

zip

public static <A,
B,
T,
E extends Exception>
CheckedStream<T,E> zip(Iterator<? extends A> a,
 Iterator<? extends B> b,
 Throwables.BiFunction<? super A,? super B,? extends T,? extends E> zipFunction)

Zip together the "a" and "b" iterators until one of them runs out of values. Each pair of values is combined into a single value using the supplied zipFunction function.

Type Parameters:

A -

B -

T -

E -

Parameters:

a -

b -

zipFunction -

Returns:

zip

public static <A,
B,
C,
T,
E extends Exception>
CheckedStream<T,E> zip(Iterator<? extends A> a,
 Iterator<? extends B> b,
 Iterator<? extends C> c,
 Throwables.TriFunction<? super A,? super B,? super C,? extends T,? extends E> zipFunction)

Zip together the "a", "b" and "c" iterators until one of them runs out of values. Each triple of values is combined into a single value using the supplied zipFunction function.

Type Parameters:

A -

B -

C -

T -

E -

Parameters:

a -

b -

c -

zipFunction -

Returns:

zip

public static <A,
B,
T,
E extends Exception>
CheckedStream<T,E> zip(CheckedStream<? extends A,E> a,
 CheckedStream<? extends B,E> b,
 Throwables.BiFunction<? super A,? super B,? extends T,? extends E> zipFunction)

Zip together the "a" and "b" streams until one of them runs out of values. Each pair of values is combined into a single value using the supplied zipFunction function.

Type Parameters:

A -

B -

T -

E -

Parameters:

a -

b -

zipFunction -

Returns:

zip

public static <A,
B,
C,
T,
E extends Exception>
CheckedStream<T,E> zip(CheckedStream<? extends A,E> a,
 CheckedStream<? extends B,E> b,
 CheckedStream<? extends C,E> c,
 Throwables.TriFunction<? super A,? super B,? super C,? extends T,? extends E> zipFunction)

Zip together the "a", "b" and "c" streams until one of them runs out of values. Each triple of values is combined into a single value using the supplied zipFunction function.

Type Parameters:

A -

B -

C -

T -

E -

Parameters:

a -

b -

c -

zipFunction -

Returns:

zip

public static <A,
B,
T,
E extends Exception>
CheckedStream<T,E> zip(A[] a,
 B[] b,
 A valueForNoneA,
 B valueForNoneB,
 Throwables.BiFunction<? super A,? super B,? extends T,? extends E> zipFunction)

Zip together the "a" and "b" iterators until all of them runs out of values. Each pair of values is combined into a single value using the supplied zipFunction function.

Type Parameters:

A -

B -

T -

E -

Parameters:

a -

b -

valueForNoneA - value to fill if "a" runs out of values first.

valueForNoneB - value to fill if "b" runs out of values first.

zipFunction -

Returns:

zip

public static <A,
B,
C,
T,
E extends Exception>
CheckedStream<T,E> zip(A[] a,
 B[] b,
 C[] c,
 A valueForNoneA,
 B valueForNoneB,
 C valueForNoneC,
 Throwables.TriFunction<? super A,? super B,? super C,? extends T,? extends E> zipFunction)

Zip together the "a", "b" and "c" iterators until all of them runs out of values. Each triple of values is combined into a single value using the supplied zipFunction function.

Type Parameters:

A -

B -

C -

T -

E -

Parameters:

a -

b -

c -

valueForNoneA - value to fill if "a" runs out of values.

valueForNoneB - value to fill if "b" runs out of values.

valueForNoneC - value to fill if "c" runs out of values.

zipFunction -

Returns:

zip

public static <A,
B,
T,
E extends Exception>
CheckedStream<T,E> zip(Iterable<? extends A> a,
 Iterable<? extends B> b,
 A valueForNoneA,
 B valueForNoneB,
 Throwables.BiFunction<? super A,? super B,? extends T,? extends E> zipFunction)

Zip together the "a" and "b" iterators until all of them runs out of values. Each pair of values is combined into a single value using the supplied zipFunction function.

Type Parameters:

A -

B -

T -

E -

Parameters:

a -

b -

valueForNoneA - value to fill if "a" runs out of values first.

valueForNoneB - value to fill if "b" runs out of values first.

zipFunction -

Returns:

zip

public static <A,
B,
C,
T,
E extends Exception>
CheckedStream<T,E> zip(Iterable<? extends A> a,
 Iterable<? extends B> b,
 Iterable<? extends C> c,
 A valueForNoneA,
 B valueForNoneB,
 C valueForNoneC,
 Throwables.TriFunction<? super A,? super B,? super C,? extends T,? extends E> zipFunction)

Zip together the "a", "b" and "c" iterators until all of them runs out of values. Each triple of values is combined into a single value using the supplied zipFunction function.

Type Parameters:

A -

B -

C -

T -

E -

Parameters:

a -

b -

c -

valueForNoneA - value to fill if "a" runs out of values.

valueForNoneB - value to fill if "b" runs out of values.

valueForNoneC - value to fill if "c" runs out of values.

zipFunction -

Returns:

zip

public static <A,
B,
T,
E extends Exception>
CheckedStream<T,E> zip(Iterator<? extends A> a,
 Iterator<? extends B> b,
 A valueForNoneA,
 B valueForNoneB,
 Throwables.BiFunction<? super A,? super B,? extends T,? extends E> zipFunction)

Zip together the "a" and "b" iterators until all of them runs out of values. Each pair of values is combined into a single value using the supplied zipFunction function.

Type Parameters:

A -

B -

T -

E -

Parameters:

a -

b -

valueForNoneA - value to fill if "a" runs out of values first.

valueForNoneB - value to fill if "b" runs out of values first.

zipFunction -

Returns:

zip

public static <A,
B,
C,
T,
E extends Exception>
CheckedStream<T,E> zip(Iterator<? extends A> a,
 Iterator<? extends B> b,
 Iterator<? extends C> c,
 A valueForNoneA,
 B valueForNoneB,
 C valueForNoneC,
 Throwables.TriFunction<? super A,? super B,? super C,? extends T,? extends E> zipFunction)

Zip together the "a", "b" and "c" iterators until all of them runs out of values. Each triple of values is combined into a single value using the supplied zipFunction function.

Type Parameters:

A -

B -

C -

T -

E -

Parameters:

a -

b -

c -

valueForNoneA - value to fill if "a" runs out of values.

valueForNoneB - value to fill if "b" runs out of values.

valueForNoneC - value to fill if "c" runs out of values.

zipFunction -

Returns:

zip

public static <A,
B,
T,
E extends Exception>
CheckedStream<T,E> zip(CheckedStream<? extends A,E> a,
 CheckedStream<? extends B,E> b,
 A valueForNoneA,
 B valueForNoneB,
 Throwables.BiFunction<? super A,? super B,? extends T,? extends E> zipFunction)

Zip together the "a" and "b" streams until one of them runs out of values. Each pair of values is combined into a single value using the supplied zipFunction function.

Type Parameters:

A -

B -

T -

E -

Parameters:

a -

b -

valueForNoneA -

valueForNoneB -

zipFunction -

Returns:

zip

public static <A,
B,
C,
T,
E extends Exception>
CheckedStream<T,E> zip(CheckedStream<? extends A,E> a,
 CheckedStream<? extends B,E> b,
 CheckedStream<? extends C,E> c,
 A valueForNoneA,
 B valueForNoneB,
 C valueForNoneC,
 Throwables.TriFunction<? super A,? super B,? super C,? extends T,? extends E> zipFunction)

Zip together the "a", "b" and "c" streams until one of them runs out of values. Each triple of values is combined into a single value using the supplied zipFunction function.

Type Parameters:

A -

B -

C -

T -

E -

Parameters:

a -

b -

c -

valueForNoneA -

valueForNoneB -

valueForNoneC -

zipFunction -

Returns:

merge

public static <T,
E extends Exception>
CheckedStream<T,E> merge(T[] a,
 T[] b,
 Throwables.BiFunction<? super T,? super T,MergeResult,E> nextSelector)

Type Parameters:

T -

E -

Parameters:

a -

b -

nextSelector - first parameter is selected if Nth.FIRST is returned, otherwise the second parameter is selected.

Returns:

merge

public static <T,
E extends Exception>
CheckedStream<T,E> merge(T[] a,
 T[] b,
 T[] c,
 Throwables.BiFunction<? super T,? super T,MergeResult,E> nextSelector)

Type Parameters:

T -

E -

Parameters:

a -

b -

c -

nextSelector - first parameter is selected if Nth.FIRST is returned, otherwise the second parameter is selected.

Returns:

merge

public static <T,
E extends Exception>
CheckedStream<T,E> merge(Iterable<? extends T> a,
 Iterable<? extends T> b,
 Throwables.BiFunction<? super T,? super T,MergeResult,E> nextSelector)

Type Parameters:

T -

E -

Parameters:

a -

b -

nextSelector - first parameter is selected if Nth.FIRST is returned, otherwise the second parameter is selected.

Returns:

merge

public static <T,
E extends Exception>
CheckedStream<T,E> merge(Iterable<? extends T> a,
 Iterable<? extends T> b,
 Iterable<? extends T> c,
 Throwables.BiFunction<? super T,? super T,MergeResult,E> nextSelector)

Type Parameters:

T -

E -

Parameters:

a -

b -

c -

nextSelector - first parameter is selected if Nth.FIRST is returned, otherwise the second parameter is selected.

Returns:

merge

public static <T,
E extends Exception>
CheckedStream<T,E> merge(Iterator<? extends T> a,
 Iterator<? extends T> b,
 Throwables.BiFunction<? super T,? super T,MergeResult,E> nextSelector)

Type Parameters:

T -

E -

Parameters:

a -

b -

nextSelector - first parameter is selected if Nth.FIRST is returned, otherwise the second parameter is selected.

Returns:

merge

public static <T,
E extends Exception>
CheckedStream<T,E> merge(Iterator<? extends T> a,
 Iterator<? extends T> b,
 Iterator<? extends T> c,
 Throwables.BiFunction<? super T,? super T,MergeResult,E> nextSelector)

Type Parameters:

T -

E -

Parameters:

a -

b -

c -

nextSelector - first parameter is selected if Nth.FIRST is returned, otherwise the second parameter is selected.

Returns:

merge

public static <T,
E extends Exception>
CheckedStream<T,E> merge(CheckedStream<? extends T,E> a,
 CheckedStream<? extends T,E> b,
 Throwables.BiFunction<? super T,? super T,MergeResult,E> nextSelector)

Type Parameters:

T -

E -

Parameters:

a -

b -

nextSelector - first parameter is selected if Nth.FIRST is returned, otherwise the second parameter is selected.

Returns:

merge

public static <T,
E extends Exception>
CheckedStream<T,E> merge(CheckedStream<? extends T,E> a,
 CheckedStream<? extends T,E> b,
 CheckedStream<? extends T,E> c,
 Throwables.BiFunction<? super T,? super T,MergeResult,E> nextSelector)

Type Parameters:

T -

E -

Parameters:

a -

b -

c -

nextSelector -

Returns:

filter

@IntermediateOp
public CheckedStream<T,E> filter(Throwables.Predicate<? super T,? extends E> predicate)

Parameters:

predicate -

Returns:

filter

@IntermediateOp
public CheckedStream<T,E> filter(Throwables.Predicate<? super T,? extends E> predicate,
 Throwables.Consumer<? super T,? extends E> actionOnDroppedItem)

Parameters:

predicate -

actionOnDroppedItem -

Returns:

takeWhile

@IntermediateOp
public CheckedStream<T,E> takeWhile(Throwables.Predicate<? super T,? extends E> predicate)

Parameters:

predicate -

Returns:

dropWhile

@IntermediateOp
public CheckedStream<T,E> dropWhile(Throwables.Predicate<? super T,? extends E> predicate)

Parameters:

predicate -

Returns:

dropWhile

@IntermediateOp
public CheckedStream<T,E> dropWhile(Throwables.Predicate<? super T,? extends E> predicate,
 Throwables.Consumer<? super T,? extends E> actionOnDroppedItem)

Parameters:

predicate -

actionOnDroppedItem -

Returns:

skipUntil

@Beta
@IntermediateOp
public CheckedStream<T,E> skipUntil(Throwables.Predicate<? super T,? extends E> predicate)

Parameters:

predicate -

Returns:

distinct

@IntermediateOp
public CheckedStream<T,E> distinct()

Distinct and filter by occurrences.

Returns:

distinct

@IntermediateOp
@TerminalOpTriggered
public CheckedStream<T,E> distinct(Throwables.BinaryOperator<T,? extends E> mergeFunction)

Distinct and filter by occurrences.

Parameters:

mergeFunction -

Returns:

See Also:

• #groupBy(Function, Function, BinaryOperator)

distinct

@IntermediateOp
@TerminalOpTriggered
public CheckedStream<T,E> distinct(Throwables.Predicate<? super Long,? extends E> occurrencesFilter)

Distinct and filter by occurrences.

Parameters:

occurrencesFilter -

Returns:

See Also:

• #groupBy(Function, Collector)

distinctBy

@IntermediateOp
public <K> CheckedStream<T,E> distinctBy(Throwables.Function<? super T,K,? extends E> keyMapper)

Distinct by the value mapped from keyMapper .

Type Parameters:

K -

Parameters:

keyMapper - don't change value of the input parameter.

Returns:

distinctBy

@IntermediateOp
@TerminalOpTriggered
public <K> CheckedStream<T,E> distinctBy(Throwables.Function<? super T,K,? extends E> keyMapper,
 Throwables.BinaryOperator<T,? extends E> mergeFunction)

Distinct and filter by occurrences.

Type Parameters:

K -

Parameters:

keyMapper -

mergeFunction -

Returns:

See Also:

• #groupBy(Function, Function, BinaryOperator)

distinctBy

@IntermediateOp
@TerminalOpTriggered
public <K> CheckedStream<T,E> 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.

Type Parameters:

K -

Parameters:

keyMapper -

occurrencesFilter -

Returns:

See Also:

• #groupBy(Function, Collector)

distinctLimitBy

@IntermediateOp
@TerminalOpTriggered
public <K> CheckedStream<T,E> 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

Type Parameters:

K -

Parameters:

keyMapper -

limit -

Returns:

See Also:

• #groupBy(Function, Collector)

map

@IntermediateOp
public <R> CheckedStream<R,E> map(Throwables.Function<? super T,? extends R,? extends E> mapper)

Type Parameters:

R -

Parameters:

mapper -

Returns:

mapIfNotNull

@Beta
@IntermediateOp
public <R> CheckedStream<R,E> 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.

Type Parameters:

R -

Parameters:

mapper -

Returns:

mapFirst

@IntermediateOp
public CheckedStream<T,E> mapFirst(Throwables.Function<? super T,? extends T,? extends E> mapperForFirst)

Parameters:

mapperForFirst -

Returns:

mapFirstOrElse

@IntermediateOp
public <R> CheckedStream<R,E> mapFirstOrElse(Throwables.Function<? super T,? extends R,E> mapperForFirst,
 Throwables.Function<? super T,? extends R,E> mapperForElse)

Type Parameters:

R -

Parameters:

mapperForFirst -

mapperForElse -

Returns:

mapLast

@IntermediateOp
public CheckedStream<T,E> mapLast(Throwables.Function<? super T,? extends T,? extends E> mapperForLast)

Parameters:

mapperForLast -

Returns:

mapLastOrElse

@IntermediateOp
public <R> CheckedStream<R,E> mapLastOrElse(Throwables.Function<? super T,? extends R,E> mapperForLast,
 Throwables.Function<? super T,? extends R,E> mapperForElse)

Type Parameters:

R -

Parameters:

mapperForLast -

mapperForElse -

Returns:

flatMap

@IntermediateOp
public <R> CheckedStream<R,E> flatMap(Throwables.Function<? super T,? extends CheckedStream<? extends R,? extends E>,? extends E> mapper)

Type Parameters:

R -

Parameters:

mapper -

Returns:

flatmap

@IntermediateOp
public <R> CheckedStream<R,E> flatmap(Throwables.Function<? super T,? extends Collection<? extends R>,? extends E> mapper)

Type Parameters:

R -

Parameters:

mapper -

Returns:

flattMap

@IntermediateOp
public <R> CheckedStream<R,E> flattMap(Throwables.Function<? super T,R[],? extends E> mapper)

Type Parameters:

R -

Parameters:

mapper -

Returns:

flattmap

@Beta
@IntermediateOp
public <R> CheckedStream<R,E> flattmap(Throwables.Function<? super T,? extends Stream<? extends R>,? extends E> mapper)

Type Parameters:

R -

Parameters:

mapper -

Returns:

flatMapIfNotNull

@Beta
@IntermediateOp
public <R> CheckedStream<R,E> flatMapIfNotNull(Throwables.Function<? super T,? extends Collection<? extends R>,? extends E> mapper)

Type Parameters:

R -

Parameters:

mapper -

Returns:

flatMapIfNotNull

@Beta
@IntermediateOp
public <U,
R> CheckedStream<R,E> flatMapIfNotNull(Throwables.Function<? super T,? extends Collection<? extends U>,? extends E> mapper,
 Throwables.Function<? super U,? extends Collection<? extends R>,? extends E> mapper2)

Type Parameters:

U -

R -

Parameters:

mapper -

mapper2 -

Returns:

flatMapToBoolean

@Beta
@IntermediateOp
public CheckedStream<Boolean,E> flatMapToBoolean(Throwables.Function<? super T,boolean[],? extends E> mapper)

Parameters:

mapper -

Returns:

flatMapToChar

@Beta
@IntermediateOp
public CheckedStream<Character,E> flatMapToChar(Throwables.Function<? super T,char[],? extends E> mapper)

Parameters:

mapper -

Returns:

flatMapToByte

@Beta
@IntermediateOp
public CheckedStream<Byte,E> flatMapToByte(Throwables.Function<? super T,byte[],? extends E> mapper)

Parameters:

mapper -

Returns:

flatMapToShort

@Beta
@IntermediateOp
public CheckedStream<Short,E> flatMapToShort(Throwables.Function<? super T,short[],? extends E> mapper)

Parameters:

mapper -

Returns:

flatMapToInteger

@Beta
@IntermediateOp
public CheckedStream<Integer,E> flatMapToInteger(Throwables.Function<? super T,int[],? extends E> mapper)

Parameters:

mapper -

Returns:

flatMapToLong

@Beta
@IntermediateOp
public CheckedStream<Long,E> flatMapToLong(Throwables.Function<? super T,long[],? extends E> mapper)

Parameters:

mapper -

Returns:

flatMapToFloat

@Beta
@IntermediateOp
public CheckedStream<Float,E> flatMapToFloat(Throwables.Function<? super T,float[],? extends E> mapper)

Parameters:

mapper -

Returns:

flatMapToDouble

@Beta
@IntermediateOp
public CheckedStream<Double,E> flatMapToDouble(Throwables.Function<? super T,double[],? extends E> mapper)

Parameters:

mapper -

Returns:

mapPartial

@Beta
@IntermediateOp
public <R> CheckedStream<R,E> mapPartial(Throwables.Function<? super T,u.Optional<? extends R>,E> mapper)

Note: copied from StreamEx: https://github.com/amaembo/streamex

Type Parameters:

R -

Parameters:

mapper -

Returns:

mapPartialToInt

@Beta
@IntermediateOp
public CheckedStream<Integer,E> mapPartialToInt(Throwables.Function<? super T,u.OptionalInt,E> mapper)

Note: copied from StreamEx: https://github.com/amaembo/streamex

Parameters:

mapper -

Returns:

mapPartialToLong

@Beta
@IntermediateOp
public CheckedStream<Long,E> mapPartialToLong(Throwables.Function<? super T,u.OptionalLong,E> mapper)

Note: copied from StreamEx: https://github.com/amaembo/streamex

Parameters:

mapper -

Returns:

mapPartialToDouble

@Beta
@IntermediateOp
public CheckedStream<Double,E> mapPartialToDouble(Throwables.Function<? super T,u.OptionalDouble,E> mapper)

Note: copied from StreamEx: https://github.com/amaembo/streamex

Parameters:

mapper -

Returns:

mapPartialJdk

@Beta
@IntermediateOp
public <R> CheckedStream<R,E> mapPartialJdk(Throwables.Function<? super T,Optional<? extends R>,E> mapper)

Note: copied from StreamEx: https://github.com/amaembo/streamex

Type Parameters:

R -

Parameters:

mapper -

Returns:

mapPartialToIntJdk

@Beta
@IntermediateOp
public CheckedStream<Integer,E> mapPartialToIntJdk(Throwables.Function<? super T,OptionalInt,E> mapper)

Note: copied from StreamEx: https://github.com/amaembo/streamex

Parameters:

mapper -

Returns:

mapPartialToLongJdk

@Beta
@IntermediateOp
public CheckedStream<Long,E> mapPartialToLongJdk(Throwables.Function<? super T,OptionalLong,E> mapper)

Note: copied from StreamEx: https://github.com/amaembo/streamex

Parameters:

mapper -

Returns:

mapPartialToDoubleJdk

@Beta
@IntermediateOp
public CheckedStream<Double,E> mapPartialToDoubleJdk(Throwables.Function<? super T,OptionalDouble,E> mapper)

Note: copied from StreamEx: https://github.com/amaembo/streamex

Parameters:

mapper -

Returns:

mapMulti

public <R> CheckedStream<R,E> mapMulti(Throwables.BiConsumer<? super T,? super Consumer<R>,? extends E> mapper)

Type Parameters:

R -

Parameters:

mapper -

Returns:

slidingMap

@IntermediateOp
public <R> CheckedStream<R,E> slidingMap(Throwables.BiFunction<? super T,? super T,R,? extends E> mapper)

Type Parameters:

R -

Parameters:

mapper -

Returns:

slidingMap

@IntermediateOp
public <R> CheckedStream<R,E> slidingMap(int increment,
 Throwables.BiFunction<? super T,? super T,R,? extends E> mapper)

Type Parameters:

R -

Parameters:

increment -

mapper -

Returns:

slidingMap

@IntermediateOp
public <R> CheckedStream<R,E> slidingMap(int increment,
 boolean ignoreNotPaired,
 Throwables.BiFunction<? super T,? super T,R,? extends E> mapper)

Type Parameters:

R -

Parameters:

increment -

ignoreNotPaired -

mapper -

Returns:

slidingMap

@IntermediateOp
public <R> CheckedStream<R,E> slidingMap(Throwables.TriFunction<? super T,? super T,? super T,R,? extends E> mapper)

Type Parameters:

R -

Parameters:

mapper -

Returns:

slidingMap

@IntermediateOp
public <R> CheckedStream<R,E> slidingMap(int increment,
 Throwables.TriFunction<? super T,? super T,? super T,R,? extends E> mapper)

Type Parameters:

R -

Parameters:

increment -

mapper -

Returns:

slidingMap

@IntermediateOp
public <R> CheckedStream<R,E> slidingMap(int increment,
 boolean ignoreNotPaired,
 Throwables.TriFunction<? super T,? super T,? super T,R,? extends E> mapper)

Type Parameters:

R -

Parameters:

increment -

ignoreNotPaired -

mapper -

Returns:

groupBy

@IntermediateOp
@TerminalOpTriggered
public <K> CheckedStream<Map.Entry<K,List<T>>,E> groupBy(Throwables.Function<? super T,? extends K,? extends E> keyMapper)

Type Parameters:

K - the key type

Parameters:

keyMapper -

Returns:

groupBy

@IntermediateOp
@TerminalOpTriggered
public <K> CheckedStream<Map.Entry<K,List<T>>,E> groupBy(Throwables.Function<? super T,? extends K,? extends E> keyMapper,
 Supplier<? extends Map<K,List<T>>> mapFactory)

Type Parameters:

K - the key type

Parameters:

keyMapper -

mapFactory -

Returns:

groupBy

@IntermediateOp
@TerminalOpTriggered
public <K,
V> CheckedStream<Map.Entry<K,List<V>>,E> groupBy(Throwables.Function<? super T,? extends K,? extends E> keyMapper,
 Throwables.Function<? super T,? extends V,? extends E> valueMapper)

Type Parameters:

K - the key type

V - the value type

Parameters:

keyMapper -

valueMapper -

Returns:

See Also:

• Collectors.toMultimap(Function, Function)

groupBy

@IntermediateOp
@TerminalOpTriggered
public <K,
V> CheckedStream<Map.Entry<K,List<V>>,E> 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)

Type Parameters:

K - the key type

V - the value type

Parameters:

keyMapper -

valueMapper -

mapFactory -

Returns:

See Also:

• Collectors.toMultimap(Function, Function, Supplier)

groupBy

@IntermediateOp
@TerminalOpTriggered
public <K,
V> CheckedStream<Map.Entry<K,V>,E> 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)

Type Parameters:

K - the key type

V - the value type

Parameters:

keyMapper -

valueMapper -

mergeFunction -

Returns:

groupBy

@IntermediateOp
@TerminalOpTriggered
public <K,
V> CheckedStream<Map.Entry<K,V>,E> 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)

Type Parameters:

K - the key type

V - the value type

Parameters:

keyMapper -

valueMapper -

mergeFunction -

mapFactory -

Returns:

groupBy

@IntermediateOp
@TerminalOpTriggered
public <K,
D> CheckedStream<Map.Entry<K,D>,E> groupBy(Throwables.Function<? super T,? extends K,? extends E> keyMapper,
 Collector<? super T,?,D> downstream)

Type Parameters:

K - the key type

D -

Parameters:

keyMapper -

downstream -

Returns:

groupBy

@IntermediateOp
@TerminalOpTriggered
public <K,
D> CheckedStream<Map.Entry<K,D>,E> groupBy(Throwables.Function<? super T,? extends K,? extends E> keyMapper,
 Collector<? super T,?,D> downstream,
 Supplier<? extends Map<K,D>> mapFactory)

Type Parameters:

K - the key type

D -

Parameters:

keyMapper -

downstream -

mapFactory -

Returns:

groupBy

@IntermediateOp
@TerminalOpTriggered
public <K,
V,
D> CheckedStream<Map.Entry<K,D>,E> groupBy(Throwables.Function<? super T,? extends K,? extends E> keyMapper,
 Throwables.Function<? super T,? extends V,? extends E> valueMapper,
 Collector<? super V,?,D> downstream)

Type Parameters:

K - the key type

V - the value type

D -

Parameters:

keyMapper -

valueMapper -

downstream -

Returns:

groupBy

@IntermediateOp
@TerminalOpTriggered
public <K,
V,
D> CheckedStream<Map.Entry<K,D>,E> 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)

Type Parameters:

K - the key type

V - the value type

D -

Parameters:

keyMapper -

valueMapper -

downstream -

mapFactory -

Returns:

partitionBy

@IntermediateOp
@TerminalOpTriggered
public CheckedStream<Map.Entry<Boolean,List<T>>,E> partitionBy(Throwables.Predicate<? super T,E> predicate)

Parameters:

predicate -

Returns:

See Also:

• Collectors.partitioningBy(Predicate)

partitionBy

@IntermediateOp
@TerminalOpTriggered
public <D> CheckedStream<Map.Entry<Boolean,D>,E> partitionBy(Throwables.Predicate<? super T,E> predicate,
 Collector<? super T,?,D> downstream)

Type Parameters:

D -

Parameters:

predicate -

downstream -

Returns:

See Also:

• Collectors.partitioningBy(Predicate, Collector)

countBy

@IntermediateOp
@TerminalOpTriggered
public <K> CheckedStream<Map.Entry<K,Integer>,E> countBy(Throwables.Function<? super T,? extends K,? extends E> keyMapper)

Type Parameters:

K -

Parameters:

keyMapper -

Returns:

collapse

@IntermediateOp
public CheckedStream<List<T>,E> collapse(Throwables.BiPredicate<? super T,? super T,? extends E> collapsible)

Parameters:

collapsible - test the current element with its previous element. The first parameter is the previous element of current element, the second parameter is the current element.

Returns:

collapse

@IntermediateOp
public <C extends Collection<T>> CheckedStream<C,E> collapse(Throwables.BiPredicate<? super T,? super T,? extends E> collapsible,
 Supplier<? extends C> supplier)

Type Parameters:

C -

Parameters:

collapsible - test the current element with its previous element. The first parameter is the previous element of current element, the second parameter is the current element.

supplier -

Returns:

collapse

@IntermediateOp
public CheckedStream<T,E> 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.

Example:

 
 CheckedStream.of(new Integer[0]).collapse((p, c) -> p < c, (r, c) -> r + c) => []
 CheckedStream.of(1).collapse((p, c) -> p < c, (r, c) -> r + c) => [1]
 CheckedStream.of(1, 2).collapse((p, c) -> p < c, (r, c) -> r + c) => [3]
 CheckedStream.of(1, 2, 3).collapse((p, c) -> p < c, (r, c) -> r + c) => [6]
 CheckedStream.of(1, 2, 3, 3, 2, 1).collapse((p, c) -> p < c, (r, c) -> r + c) => [6, 3, 2, 1]
 
 

This method only runs sequentially, even in parallel stream.

Parameters:

collapsible - test the current element with its previous element. The first parameter is the previous element of current element, the second parameter is the current element.

mergeFunction -

Returns:

collapse

@IntermediateOp
public <U> CheckedStream<U,E> collapse(Throwables.BiPredicate<? super T,? super T,? extends E> collapsible,
 U init,
 Throwables.BiFunction<U,? super T,U,? extends E> op)

Type Parameters:

U -

Parameters:

collapsible - test the current element with its previous element. The first parameter is the previous element of current element, the second parameter is the current element.

init - is used by op to generate the first result value in the series.

op -

Returns:

collapse

@IntermediateOp
public <R> CheckedStream<R,E> collapse(Throwables.BiPredicate<? super T,? super T,? extends E> collapsible,
 Throwables.Supplier<R,E> supplier,
 Throwables.BiConsumer<? super R,? super T,? extends E> accumulator)

Type Parameters:

R -

Parameters:

collapsible - test the current element with its previous element. The first parameter is the previous element of current element, the second parameter is the current element.

supplier -

accumulator -

Returns:

collapse

@IntermediateOp
public <R> CheckedStream<R,E> collapse(Throwables.BiPredicate<? super T,? super T,? extends E> collapsible,
 Collector<? super T,?,R> collector)

Type Parameters:

R -

Parameters:

collapsible - test the current element with its previous element. The first parameter is the previous element of current element, the second parameter is the current element.

collector -

Returns:

collapse

@IntermediateOp
public CheckedStream<List<T>,E> collapse(Throwables.TriPredicate<? super T,? super T,? super T,? extends E> collapsible)

Parameters:

collapsible - test the current element with the first element and previous element in the series. The first parameter is the first element of this series, the second parameter is the previous element and the third parameter is the current element.

Returns:

collapse

@IntermediateOp
public <C extends Collection<T>> CheckedStream<C,E> collapse(Throwables.TriPredicate<? super T,? super T,? super T,? extends E> collapsible,
 Supplier<? extends C> supplier)

Type Parameters:

C -

Parameters:

collapsible - test the current element with the first element and previous element in the series. The first parameter is the first element of this series, the second parameter is the previous element and the third parameter is the current element.

supplier -

Returns:

collapse

@IntermediateOp
public CheckedStream<T,E> 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.

Example:

 
 Stream.of(new Integer[0]).collapse((f, p, c) -> f < c, (r, c) -> r + c) => []
 Stream.of(1).collapse((f, p, c) -> f < c, (r, c) -> r + c) => [1]
 Stream.of(1, 2).collapse((f, p, c) -> f < c, (r, c) -> r + c) => [3]
 Stream.of(1, 2, 3).collapse((f, p, c) -> f < c, (r, c) -> r + c) => [6]
 Stream.of(1, 2, 3, 3, 2, 1).collapse((f, p, c) -> f < c, (r, c) -> r + c) => [11, 1]
 
 

This method only runs sequentially, even in parallel stream.

Parameters:

collapsible - test the current element with the first element and previous element in the series. The first parameter is the first element of this series, the second parameter is the previous element and the third parameter is the current element.

mergeFunction -

Returns:

collapse

@IntermediateOp
public <U> CheckedStream<U,E> collapse(Throwables.TriPredicate<? super T,? super T,? super T,? extends E> collapsible,
 U init,
 Throwables.BiFunction<U,? super T,U,? extends E> op)

Type Parameters:

U -

Parameters:

collapsible - test the current element with the first element and previous element in the series. The first parameter is the first element of this series, the second parameter is the previous element and the third parameter is the current element.

init - is used by op to generate the first result value in the series.

op -

Returns:

collapse

@IntermediateOp
public <R> CheckedStream<R,E> 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)

Type Parameters:

R -

Parameters:

collapsible - test the current element with the first element and previous element in the series. The first parameter is the first element of this series, the second parameter is the previous element and the third parameter is the current element.

supplier -

accumulator -

Returns:

collapse

@IntermediateOp
public <R> CheckedStream<R,E> 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.

Example:

 
 CheckedStream.of(new Integer[0]).collapse((f, p, c) -> f < c, Collectors.summingInt(Fn.unboxI())) => []
 CheckedStream.of(1).collapse((f, p, c) -> f < c, Collectors.summingInt(Fn.unboxI())) => [1]
 CheckedStream.of(1, 2).collapse((f, p, c) -> f < c, Collectors.summingInt(Fn.unboxI())) => [3]
 CheckedStream.of(1, 2, 3).collapse((f, p, c) -> f < c, Collectors.summingInt(Fn.unboxI())) => [6]
 CheckedStream.of(1, 2, 3, 3, 2, 1).collapse((f, p, c) -> f < c, Collectors.summingInt(Fn.unboxI())) => [11, 1]
 
 

Type Parameters:

R -

Parameters:

collapsible - test the current element with the first element and previous element in the series. The first parameter is the first element of this series, the second parameter is the previous element and the third parameter is the current element.

collector -

Returns:

scan

@IntermediateOp
public CheckedStream<T,E> scan(Throwables.BiFunction<? super T,? super T,T,? extends E> accumulator)

Parameters:

accumulator -

Returns:

scan

@IntermediateOp
public <U> CheckedStream<U,E> scan(U init,
 Throwables.BiFunction<U,? super T,U,? extends E> accumulator)

Type Parameters:

U -

Parameters:

init -

accumulator -

Returns:

scan

@IntermediateOp
public <U> CheckedStream<U,E> scan(U init,
 Throwables.BiFunction<U,? super T,U,? extends E> accumulator,
 boolean initIncluded)

Type Parameters:

U -

Parameters:

init -

accumulator -

initIncluded -

Returns:

intersection

public CheckedStream<T,E> intersection(Collection<?> c)

Parameters:

c -

Returns:

See Also:

• N.intersection(Collection, Collection)

intersection

public <U> CheckedStream<T,E> intersection(Throwables.Function<? super T,? extends U,E> mapper,
 Collection<U> c)

Type Parameters:

U -

Parameters:

mapper -

c -

Returns:

See Also:

• N.intersection(Collection, Collection)

difference

public CheckedStream<T,E> difference(Collection<?> c)

Parameters:

c -

Returns:

See Also:

• N.difference(Collection, Collection)

difference

public <U> CheckedStream<T,E> difference(Function<? super T,? extends U> mapper,
 Collection<U> c)

Type Parameters:

U -

Parameters:

mapper -

c -

Returns:

See Also:

• N.difference(Collection, Collection)

symmetricDifference

public CheckedStream<T,E> symmetricDifference(Collection<T> c)

Parameters:

c -

Returns:

See Also:

• N.symmetricDifference(Collection, Collection)

defaultIfEmpty

@IntermediateOp
public CheckedStream<T,E> defaultIfEmpty(T defaultValue)

Parameters:

defaultValue -

Returns:

See Also:

• appendIfEmpty(Object...)

defaultIfEmpty

@IntermediateOp
public CheckedStream<T,E> defaultIfEmpty(Throwables.Supplier<? extends CheckedStream<T,E>,? extends E> supplier)

Parameters:

supplier -

Returns:

See Also:

• appendIfEmpty(Throwables.Supplier)

prepend

@IntermediateOp
@SafeVarargs
public final CheckedStream<T,E> prepend(T... a)

Parameters:

a -

Returns:

prepend

@IntermediateOp
public CheckedStream<T,E> prepend(Collection<? extends T> c)

Parameters:

c -

Returns:

prepend

@IntermediateOp
public CheckedStream<T,E> prepend(CheckedStream<T,E> s)

Parameters:

s -

Returns:

append

@IntermediateOp
@SafeVarargs
public final CheckedStream<T,E> append(T... a)

Parameters:

a -

Returns:

append

@IntermediateOp
public CheckedStream<T,E> append(Collection<? extends T> c)

Parameters:

c -

Returns:

append

@IntermediateOp
public CheckedStream<T,E> append(CheckedStream<T,E> s)

Parameters:

s -

Returns:

appendIfEmpty

@IntermediateOp
@SafeVarargs
public final CheckedStream<T,E> appendIfEmpty(T... a)

Parameters:

a -

Returns:

appendIfEmpty

@IntermediateOp
public CheckedStream<T,E> appendIfEmpty(Collection<? extends T> c)

Parameters:

c -

Returns:

appendIfEmpty

@IntermediateOp
public CheckedStream<T,E> appendIfEmpty(Throwables.Supplier<? extends CheckedStream<T,E>,? extends E> supplier)

Append if empty.

Parameters:

supplier -

Returns:

throwIfEmpty

@IntermediateOp
public CheckedStream<T,E> throwIfEmpty()

Throws NoSuchElementException in terminal operation if this CheckedStream if empty.

Returns:

throwIfEmpty

@IntermediateOp
public CheckedStream<T,E> throwIfEmpty(Supplier<? extends E> exceptionSupplier)

Parameters:

exceptionSupplier -

Returns:

applyIfNotEmpty

@TerminalOp
public <R,
E2 extends Exception> u.Optional<R> applyIfNotEmpty(Throwables.Function<? super CheckedStream<T,E>,R,E2> func)
                                                       throws E,
E2

Type Parameters:

R -

E2 -

Parameters:

func -

Returns:

Throws:

E

E2

acceptIfNotEmpty

@TerminalOp
public <E2 extends Exception> If.OrElse acceptIfNotEmpty(Throwables.Consumer<? super CheckedStream<T,E>,E2> action)
                                                  throws E,
E2

Type Parameters:

E2 -

Parameters:

action -

Returns:

Throws:

E

E2

onEach

@IntermediateOp
public CheckedStream<T,E> onEach(Throwables.Consumer<? super T,? extends E> action)

Parameters:

action -

Returns:

peek

@IntermediateOp
public CheckedStream<T,E> peek(Throwables.Consumer<? super T,? extends E> action)

Parameters:

action -

Returns:

peekFirst

@IntermediateOp
public CheckedStream<T,E> peekFirst(Throwables.Consumer<? super T,? extends E> action)

Parameters:

action -

Returns:

peekLast

@IntermediateOp
public CheckedStream<T,E> peekLast(Throwables.Consumer<? super T,? extends E> action)

Parameters:

action -

Returns:

peekIf

@IntermediateOp
public CheckedStream<T,E> peekIf(Throwables.Predicate<? super T,E> predicate,
 Throwables.Consumer<? super T,E> action)

Parameters:

predicate -

action -

Returns:

peekIf

@Beta
@IntermediateOp
public CheckedStream<T,E> peekIf(Throwables.BiPredicate<? super T,? super Long,E> predicate,
 Consumer<? super T> action)

Parameters:

predicate - The first parameter is the element. The second parameter is the count of iterated elements, starts with 1.

action -

Returns:

split

@IntermediateOp
public CheckedStream<Stream<T>,E> split(int chunkSize)

Parameters:

chunkSize -

Returns:

splitToList

@IntermediateOp
public CheckedStream<List<T>,E> 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).

Parameters:

chunkSize - the desired size of each sub sequence (the last may be smaller).

Returns:

splitToSet

@IntermediateOp
public CheckedStream<Set<T>,E> 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).

Parameters:

chunkSize - the desired size of each sub sequence (the last may be smaller).

Returns:

split

@IntermediateOp
public <C extends Collection<T>> CheckedStream<C,E> 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).

Type Parameters:

C -

Parameters:

chunkSize - the desired size of each sub sequence (the last may be smaller).

collectionSupplier -

Returns:

split

@IntermediateOp
public <R> CheckedStream<R,E> split(int chunkSize,
 Collector<? super T,?,R> collector)

Type Parameters:

R -

Parameters:

chunkSize - the desired size of each sub sequence (the last may be smaller).

collector -

Returns:

splitAt

@IntermediateOp
public CheckedStream<CheckedStream<T,E>,E> splitAt(int where)

Parameters:

where -

Returns:

splitAt

@IntermediateOp
public CheckedStream<CheckedStream<T,E>,E> splitAt(Throwables.Predicate<? super T,? extends E> where)

Parameters:

where -

Returns:

sliding

@IntermediateOp
public CheckedStream<Stream<T>,E> sliding(int windowSize,
 int increment)

Parameters:

windowSize -

increment -

Returns:

slidingToList

@IntermediateOp
public CheckedStream<List<T>,E> slidingToList(int windowSize,
 int increment)

Sliding to list.

Parameters:

windowSize -

increment -

Returns:

slidingToSet

@IntermediateOp
public CheckedStream<Set<T>,E> slidingToSet(int windowSize,
 int increment)

Sliding to set.

Parameters:

windowSize -

increment -

Returns:

sliding

@IntermediateOp
public <C extends Collection<T>> CheckedStream<C,E> sliding(int windowSize,
 int increment,
 IntFunction<? extends C> collectionSupplier)

Type Parameters:

C -

Parameters:

windowSize -

increment -

collectionSupplier -

Returns:

sliding

@IntermediateOp
public <R> CheckedStream<R,E> sliding(int windowSize,
 int increment,
 Collector<? super T,?,R> collector)

Type Parameters:

R -

Parameters:

windowSize -

increment -

collector -

Returns:

skip

@IntermediateOp
public CheckedStream<T,E> skip(long n)

Parameters:

n -

Returns:

skipNull

@Deprecated
@IntermediateOp
public CheckedStream<T,E> skipNull()

Deprecated.

Use skipNulls() instead

Returns:

skipNulls

@IntermediateOp
public CheckedStream<T,E> skipNulls()

Returns:

limit

@IntermediateOp
public CheckedStream<T,E> limit(long maxSize)

Parameters:

maxSize -

Returns:

top

@IntermediateOp
public CheckedStream<T,E> top(int n)

Parameters:

n -

Returns:

top

@IntermediateOp
public CheckedStream<T,E> top(int n,
 Comparator<? super T> comparator)

Parameters:

n -

comparator -

Returns:

last

@Beta
@IntermediateOp
public CheckedStream<T,E> last(int n)

A queue with size up to n will be maintained to filter out the last n elements. It may cause out of memory error if n is big enough.
All the elements will be loaded to get the last n elements and the Stream will be closed after that, if a terminal operation is triggered.

Parameters:

n -

Returns:

See Also:

• Stream.last(int)

skipLast

@IntermediateOp
public CheckedStream<T,E> skipLast(int n)

Parameters:

n -

Returns:

reversed

@IntermediateOp
@TerminalOpTriggered
public CheckedStream<T,E> reversed()

Returns:

rotated

@IntermediateOp
@TerminalOpTriggered
public CheckedStream<T,E> rotated(int distance)

Parameters:

distance -

Returns:

shuffled

@IntermediateOp
@TerminalOpTriggered
public CheckedStream<T,E> shuffled()

Returns:

shuffled

@IntermediateOp
@TerminalOpTriggered
public CheckedStream<T,E> shuffled(Random rnd)

Parameters:

rnd -

Returns:

sorted

@IntermediateOp
@TerminalOpTriggered
public CheckedStream<T,E> sorted()

Returns:

sorted

@IntermediateOp
@TerminalOpTriggered
public CheckedStream<T,E> sorted(Comparator<? super T> comparator)

Parameters:

comparator -

Returns:

sortedByInt

@IntermediateOp
@TerminalOpTriggered
public CheckedStream<T,E> sortedByInt(ToIntFunction<? super T> keyMapper)

sortedByLong

@IntermediateOp
@TerminalOpTriggered
public CheckedStream<T,E> sortedByLong(ToLongFunction<? super T> keyMapper)

sortedByDouble

@IntermediateOp
@TerminalOpTriggered
public CheckedStream<T,E> sortedByDouble(ToDoubleFunction<? super T> keyMapper)

sortedBy

@IntermediateOp
@TerminalOpTriggered
public CheckedStream<T,E> sortedBy(Function<? super T,? extends Comparable> keyMapper)

Parameters:

keyMapper -

Returns:

reverseSorted

@IntermediateOp
@TerminalOpTriggered
public CheckedStream<T,E> reverseSorted()

Returns:

reverseSorted

@IntermediateOp
@TerminalOpTriggered
public CheckedStream<T,E> reverseSorted(Comparator<? super T> comparator)

Parameters:

comparator -

Returns:

reverseSortedByInt

@IntermediateOp
@TerminalOpTriggered
public CheckedStream<T,E> reverseSortedByInt(ToIntFunction<? super T> keyMapper)

reverseSortedByLong

@IntermediateOp
@TerminalOpTriggered
public CheckedStream<T,E> reverseSortedByLong(ToLongFunction<? super T> keyMapper)

reverseSortedByDouble

@IntermediateOp
@TerminalOpTriggered
public CheckedStream<T,E> reverseSortedByDouble(ToDoubleFunction<? super T> keyMapper)

reverseSortedBy

@IntermediateOp
@TerminalOpTriggered
public CheckedStream<T,E> reverseSortedBy(Function<? super T,? extends Comparable> keyMapper)

Parameters:

keyMapper -

Returns:

cycled

@SequentialOnly
@IntermediateOp
public CheckedStream<T,E> cycled()

Returns:

cycled

@SequentialOnly
@IntermediateOp
public CheckedStream<T,E> cycled(long rounds)

Parameters:

rounds -

Returns:

rateLimited

@IntermediateOp
public CheckedStream<T,E> rateLimited(double permitsPerSecond)

Parameters:

permitsPerSecond -

Returns:

rateLimited

@IntermediateOp
public CheckedStream<T,E> rateLimited(RateLimiter rateLimiter)

Parameters:

rateLimiter -

Returns:

See Also:

• RateLimiter.create(double)

delay

@IntermediateOp
public CheckedStream<T,E> delay(Duration delay)

Parameters:

delay -

Returns:

timed

@Beta
@IntermediateOp
public CheckedStream<Timed<T>,E> timed()

Returns:

intersperse

@IntermediateOp
public CheckedStream<T,E> intersperse(T delimiter)

Parameters:

delimiter -

Returns:

step

@Beta
@IntermediateOp
public CheckedStream<T,E> step(long step)

Parameters:

step -

Returns:

indexed

@Beta
@IntermediateOp
public CheckedStream<Indexed<T>,E> indexed()

Returns:

buffered

@SequentialOnly
@IntermediateOp
public CheckedStream<T,E> 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. Default queue size is 64.
Mostly it's for read-write with different threads mode.

Returns:

See Also:

• buffered()

buffered

@SequentialOnly
@IntermediateOp
public CheckedStream<T,E> 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.
Mostly it's for read-write with different threads mode.

Parameters:

bufferSize -

Returns:

See Also:

• buffered(int)

mergeWith

@IntermediateOp
public CheckedStream<T,E> mergeWith(Collection<? extends T> b,
 Throwables.BiFunction<? super T,? super T,MergeResult,E> nextSelector)

Parameters:

b -

nextSelector - first parameter is selected if Nth.FIRST is returned, otherwise the second parameter is selected.

Returns:

mergeWith

@IntermediateOp
public CheckedStream<T,E> mergeWith(CheckedStream<? extends T,E> b,
 Throwables.BiFunction<? super T,? super T,MergeResult,E> nextSelector)

Parameters:

b -

nextSelector - first parameter is selected if Nth.FIRST is returned, otherwise the second parameter is selected.

Returns:

zipWith

@IntermediateOp
public <T2,
R> CheckedStream<R,E> zipWith(Collection<T2> b,
 Throwables.BiFunction<? super T,? super T2,? extends R,? extends E> zipFunction)

Type Parameters:

T2 -

R -

Parameters:

b -

zipFunction -

Returns:

zipWith

@IntermediateOp
public <T2,
R> CheckedStream<R,E> zipWith(Collection<T2> b,
 T valueForNoneA,
 T2 valueForNoneB,
 Throwables.BiFunction<? super T,? super T2,? extends R,? extends E> zipFunction)

Type Parameters:

T2 -

R -

Parameters:

b -

valueForNoneA -

valueForNoneB -

zipFunction -

Returns:

zipWith

@IntermediateOp
public <T2,
T3,
R> CheckedStream<R,E> zipWith(Collection<T2> b,
 Collection<T3> c,
 Throwables.TriFunction<? super T,? super T2,? super T3,? extends R,? extends E> zipFunction)

Type Parameters:

T2 -

T3 -

R -

Parameters:

b -

c -

zipFunction -

Returns:

zipWith

@IntermediateOp
public <T2,
T3,
R> CheckedStream<R,E> 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)

Type Parameters:

T2 -

T3 -

R -

Parameters:

b -

c -

valueForNoneA -

valueForNoneB -

valueForNoneC -

zipFunction -

Returns:

zipWith

@IntermediateOp
public <T2,
R> CheckedStream<R,E> zipWith(CheckedStream<T2,E> b,
 Throwables.BiFunction<? super T,? super T2,? extends R,? extends E> zipFunction)

Type Parameters:

T2 -

R -

Parameters:

b -

zipFunction -

Returns:

zipWith

@IntermediateOp
public <T2,
R> CheckedStream<R,E> zipWith(CheckedStream<T2,E> b,
 T valueForNoneA,
 T2 valueForNoneB,
 Throwables.BiFunction<? super T,? super T2,? extends R,? extends E> zipFunction)

Type Parameters:

T2 -

R -

Parameters:

b -

valueForNoneA -

valueForNoneB -

zipFunction -

Returns:

zipWith

@IntermediateOp
public <T2,
T3,
R> CheckedStream<R,E> zipWith(CheckedStream<T2,E> b,
 CheckedStream<T3,E> c,
 Throwables.TriFunction<? super T,? super T2,? super T3,? extends R,? extends E> zipFunction)

Type Parameters:

T2 -

T3 -

R -

Parameters:

b -

c -

zipFunction -

Returns:

zipWith

@IntermediateOp
public <T2,
T3,
R> CheckedStream<R,E> 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)

Type Parameters:

T2 -

T3 -

R -

Parameters:

b -

c -

valueForNoneA -

valueForNoneB -

valueForNoneC -

zipFunction -

Returns:

forEach

@TerminalOp
public <E2 extends Exception> void forEach(Throwables.Consumer<? super T,E2> action)
                                    throws E,
E2

Type Parameters:

E2 -

Parameters:

action -

Throws:

E - the e

E2 - the e2

forEachIndexed

@TerminalOp
public <E2 extends Exception> void forEachIndexed(Throwables.IntObjConsumer<? super T,E2> action)
                                           throws E,
E2

Type Parameters:

E2 -

Parameters:

action -

Throws:

E - the e

E2 - the e2

forEachUntil

@Beta
@TerminalOp
public <E2 extends Exception> void forEachUntil(Throwables.BiConsumer<? super T,MutableBoolean,E2> action)
                                         throws E,
E2

Iterate and execute action until the flag is set true. Flag can only be set after at least one element is iterated and executed by action.

Type Parameters:

E2 -

Parameters:

action - the second parameter is a flag to break the for-each loop. Set it to true to break the loop if you don't want to continue the action. Iteration on this stream will also be stopped when this flag is set to true.

Throws:

E

E2

See Also:

• forEachUntil(MutableBoolean, Throwables.Consumer)

forEachUntil

@Beta
@TerminalOp
public <E2 extends Exception> void forEachUntil(MutableBoolean flagToBreak,
 Throwables.Consumer<? super T,E2> action)
                                         throws E,
E2

Iterate and execute action until flagToBreak is set true. If flagToBreak is set to true at the begin, there will be no element iterated from stream before this stream is stopped and closed.

Type Parameters:

E2 -

Parameters:

flagToBreak - a flag to break the for-each loop. Set it to true to break the loop if you don't want to continue the action. Iteration on this stream will also be stopped when this flag is set to true.

action -

Throws:

E

E2

See Also:

• forEachUntil(Throwables.BiConsumer)

forEach

@TerminalOp
public <E2 extends Exception,
E3 extends Exception>
void forEach(Throwables.Consumer<? super T,E2> action,
 Throwables.Runnable<E3> onComplete)
      throws E,
E2,
E3

Type Parameters:

E2 -

E3 -

Parameters:

action -

onComplete -

Throws:

E - the e

E2 - the e2

E3 - the e3

forEach

@TerminalOp
public <U,
E2 extends Exception,
E3 extends Exception>
void forEach(Throwables.Function<? super T,? extends Iterable<? extends U>,E2> flatMapper,
 Throwables.BiConsumer<? super T,? super U,E3> action)
      throws E,
E2,
E3

Type Parameters:

U -

E2 -

E3 -

Parameters:

flatMapper -

action -

Throws:

E - the e

E2 - the e2

E3 - the e3

forEach

@TerminalOp
public <T2,
T3,
E2 extends Exception,
E3 extends Exception,
E4 extends Exception>
void forEach(Throwables.Function<? super T,? extends Iterable<T2>,E2> flatMapper,
 Throwables.Function<? super T2,? extends Iterable<T3>,E3> flatMapper2,
 Throwables.TriConsumer<? super T,? super T2,? super T3,E4> action)
      throws E,
E2,
E3,
E4

Type Parameters:

T2 -

T3 -

E2 -

E3 -

E4 -

Parameters:

flatMapper -

flatMapper2 -

action -

Throws:

E - the e

E2 - the e2

E3 - the e3

E4 - the e4

forEachPair

@TerminalOp
public <E2 extends Exception> void forEachPair(Throwables.BiConsumer<? super T,? super T,E2> action)
                                        throws E,
E2

For each pair.

Type Parameters:

E2 -

Parameters:

action -

Throws:

E - the e

E2 - the e2

forEachPair

@TerminalOp
public <E2 extends Exception> void forEachPair(int increment,
 Throwables.BiConsumer<? super T,? super T,E2> action)
                                        throws E,
E2

For each pair.

Type Parameters:

E2 -

Parameters:

increment -

action -

Throws:

E - the e

E2 - the e2

forEachTriple

@TerminalOp
public <E2 extends Exception> void forEachTriple(Throwables.TriConsumer<? super T,? super T,? super T,E2> action)
                                          throws E,
E2

For each triple.

Type Parameters:

E2 -

Parameters:

action -

Throws:

E - the e

E2 - the e2

forEachTriple

@TerminalOp
public <E2 extends Exception> void forEachTriple(int increment,
 Throwables.TriConsumer<? super T,? super T,? super T,E2> action)
                                          throws E,
E2

For each triple.

Type Parameters:

E2 -

Parameters:

increment -

action -

Throws:

E - the e

E2 - the e2

forEachInParallel

@Beta
@TerminalOp
public <E2 extends Exception> void forEachInParallel(int threadNum,
 Throwables.Consumer<? super T,E2> action)
                                              throws E,
E2

Type Parameters:

E2 -

Parameters:

threadNum -

action -

Throws:

E - the e

E2 - the e2

forEachInParallel

@Beta
@TerminalOp
public <E2 extends Exception> void forEachInParallel(int threadNum,
 Throwables.Consumer<? super T,E2> action,
 Executor executor)
                                              throws E,
E2

Type Parameters:

E2 -

Parameters:

threadNum -

action -

executor -

Throws:

E - the e

E2 - the e2

min

@TerminalOp
public u.Optional<T> min(Comparator<? super T> comparator)
                  throws E

Parameters:

comparator -

Returns:

Throws:

E - the e

minBy

@TerminalOp
public u.Optional<T> minBy(Function<? super T,? extends Comparable> keyMapper)
                    throws E

Parameters:

keyMapper -

Returns:

Throws:

E - the e

max

@TerminalOp
public u.Optional<T> max(Comparator<? super T> comparator)
                  throws E

Parameters:

comparator -

Returns:

Throws:

E - the e

maxBy

@TerminalOp
public u.Optional<T> maxBy(Function<? super T,? extends Comparable> keyMapper)
                    throws E

Parameters:

keyMapper -

Returns:

Throws:

E - the e

anyMatch

@TerminalOp
public <E2 extends Exception> boolean anyMatch(Throwables.Predicate<? super T,E2> predicate)
                                        throws E,
E2

Type Parameters:

E2 -

Parameters:

predicate -

Returns:

Throws:

E

E2

allMatch

@TerminalOp
public <E2 extends Exception> boolean allMatch(Throwables.Predicate<? super T,E2> predicate)
                                        throws E,
E2

Type Parameters:

E2 -

Parameters:

predicate -

Returns:

Throws:

E

E2

noneMatch

@TerminalOp
public <E2 extends Exception> boolean noneMatch(Throwables.Predicate<? super T,E2> predicate)
                                         throws E,
E2

Type Parameters:

E2 -

Parameters:

predicate -

Returns:

Throws:

E

E2

nMatch

@TerminalOp
public <E2 extends Exception> boolean nMatch(long atLeast,
 long atMost,
 Throwables.Predicate<? super T,E2> predicate)
                                      throws E,
E2

Type Parameters:

E2 -

Parameters:

atLeast -

atMost -

predicate -

Returns:

Throws:

E

E2

findFirst

@TerminalOp
public <E2 extends Exception> u.Optional<T> findFirst(Throwables.Predicate<? super T,E2> predicate)
                                               throws E,
E2

Type Parameters:

E2 -

Parameters:

predicate -

Returns:

Throws:

E

E2

findFirstOrAny

@TerminalOp
public <E2 extends Exception> u.Optional<T> findFirstOrAny(Throwables.Predicate<? super T,E2> predicateForFirst)
                                                    throws E,
E2

Returns the first element matched by predicateForFirst if found or the first element if this stream is not empty Otherwise an empty Optional<T> will be returned.

Type Parameters:

E2 -

Parameters:

predicateForFirst -

Returns:

Throws:

E

E2

findFirstOrAny

@TerminalOp
public <E2 extends Exception,
E3 extends Exception>
u.Optional<T> findFirstOrAny(Throwables.Predicate<? super T,E2> predicateForFirst,
 Throwables.Predicate<? super T,E3> predicateForAny)
                      throws E,
E2,
E3

Returns the first element matched by predicateForFirst if found or the first element matched by predicateForAny. Otherwise an empty Optional<T> will be returned.

Type Parameters:

E2 -

E3 -

Parameters:

predicateForFirst -

predicateForAny -

Returns:

Throws:

E

E2

E3

findFirstOrLast

@TerminalOp
public <E2 extends Exception> u.Optional<T> findFirstOrLast(Throwables.Predicate<? super T,E2> predicateForFirst)
                                                     throws E,
E2

Returns the first element matched by predicateForFirst if found or the last element if this stream is not empty Otherwise an empty Optional<T> will be returned.

Type Parameters:

E2 -

Parameters:

predicateForFirst -

Returns:

Throws:

E

E2

findLast

@TerminalOp
public <E2 extends Exception> u.Optional<T> findLast(Throwables.Predicate<? super T,E2> predicate)
                                              throws E,
E2

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

Type Parameters:

E2 -

Parameters:

predicate -

Returns:

Throws:

E

E2

findAny

@TerminalOp
public <E2 extends Exception> u.Optional<T> findAny(Throwables.Predicate<? super T,E2> predicate)
                                             throws E,
E2

Same as findFirst(Throwables.Predicate).

Type Parameters:

E2 -

Parameters:

predicate -

Returns:

Throws:

E

E2

See Also:

• findFirst(Throwables.Predicate)

containsAll

@TerminalOp
@SafeVarargs
public final boolean containsAll(T... a)
                          throws E

Parameters:

a -

Returns:

Throws:

E

containsAll

@TerminalOp
public boolean containsAll(Collection<? extends T> c)
                    throws E

Parameters:

c -

Returns:

Throws:

E

containsAny

@TerminalOp
@SafeVarargs
public final boolean containsAny(T... a)
                          throws E

Parameters:

a -

Returns:

Throws:

E

containsAny

@TerminalOp
public boolean containsAny(Collection<? extends T> c)
                    throws E

Parameters:

c -

Returns:

Throws:

E

hasDuplicates

@TerminalOp
public boolean hasDuplicates()
                      throws E

Returns:

Throws:

E

kthLargest

@TerminalOp
public u.Optional<T> kthLargest(int k,
 Comparator<? super T> comparator)
                         throws E

Parameters:

k -

comparator -

Returns:

Throws:

E

percentiles

@TerminalOp
public u.Optional<Map<Percentage,T>> percentiles(Comparator<? super T> comparator)
                                          throws E

Parameters:

comparator -

Returns:

Throws:

E

first

@TerminalOp
public u.Optional<T> first()
                    throws E

Returns:

Throws:

E - the e

last

@TerminalOp
public u.Optional<T> last()
                   throws E

Returns:

Throws:

E - the e

elementAt

@Beta
@TerminalOp
public u.Optional<T> elementAt(long position)
                        throws E

Parameters:

position - in current stream(not upstream or origin source). It starts from 0.

Returns:

Throws:

E - the e

onlyOne

@TerminalOp
public u.Optional<T> onlyOne()
                      throws TooManyElementsException,
E

Returns:

Throws:

TooManyElementsException - if there are more than one elements.

E - the e

count

@TerminalOp
public long count()
           throws E

Returns:

Throws:

E - the e

toArray

@TerminalOp
public Object[] toArray()
                 throws E

Returns:

Throws:

E - the e

toArray

@TerminalOp
public <A> A[] toArray(IntFunction<A[]> generator)
                throws E

Type Parameters:

A -

Parameters:

generator -

Returns:

Throws:

E - the e

toList

@TerminalOp
public List<T> toList()
               throws E

Returns:

Throws:

E - the e

toSet

@TerminalOp
public Set<T> toSet()
             throws E

Returns:

Throws:

E - the e

toImmutableList

@TerminalOp
public ImmutableList<T> toImmutableList()
                                 throws E

Returns:

Throws:

E - the e

toImmutableSet

@TerminalOp
public ImmutableSet<T> toImmutableSet()
                               throws E

Returns:

Throws:

E - the e

toCollection

@TerminalOp
public <C extends Collection<T>> C toCollection(Supplier<? extends C> supplier)
                                         throws E

Type Parameters:

C -

Parameters:

supplier -

Returns:

Throws:

E - the e

toListThenApply

@TerminalOp
public <R,
E2 extends Exception> R toListThenApply(Throwables.Function<? super List<T>,R,E2> func)
                                           throws E,
E2

Type Parameters:

R -

E2 -

Parameters:

func -

Returns:

Throws:

E

E2

toListThenAccept

@TerminalOp
public <E2 extends Exception> void toListThenAccept(Throwables.Consumer<? super List<T>,E2> consumer)
                                             throws E,
E2

Type Parameters:

E2 -

Parameters:

consumer -

Throws:

E

E2

toSetThenApply

@TerminalOp
public <R,
E2 extends Exception> R toSetThenApply(Throwables.Function<? super Set<T>,R,E2> func)
                                          throws E,
E2

Type Parameters:

R -

E2 -

Parameters:

func -

Returns:

Throws:

E

E2

toSetThenAccept

@TerminalOp
public <E2 extends Exception> void toSetThenAccept(Throwables.Consumer<? super Set<T>,E2> consumer)
                                            throws E,
E2

Type Parameters:

E2 -

Parameters:

consumer -

Throws:

E

E2

toCollectionThenApply

@TerminalOp
public <R,
CC extends Collection<T>,
E2 extends Exception>
R toCollectionThenApply(Supplier<? extends CC> supplier,
 Throwables.Function<? super CC,R,E2> func)
                 throws E,
E2

Type Parameters:

R -

CC -

E2 -

Parameters:

supplier -

func -

Returns:

Throws:

E

E2

toCollectionThenAccept

@TerminalOp
public <CC extends Collection<T>,
E2 extends Exception>
void toCollectionThenAccept(Supplier<? extends CC> supplier,
 Throwables.Consumer<? super CC,E2> consumer)
                     throws E,
E2

Type Parameters:

E2 -

Parameters:

consumer -

Throws:

E

E2

toImmutableMap

@TerminalOp
public <K,
V,
E2 extends Exception,
E3 extends Exception>
ImmutableMap<K,V> toImmutableMap(Throwables.Function<? super T,? extends K,E2> keyMapper,
 Throwables.Function<? super T,? extends V,E3> valueMapper)
                          throws E,
E2,
E3,
IllegalStateException

Type Parameters:

K - the key type

V - the value type

E2 -

E3 -

Parameters:

keyMapper -

valueMapper -

Returns:

Throws:

E - the e

E2

E3

IllegalStateException - if there are duplicated keys.

toImmutableMap

@TerminalOp
public <K,
V,
E2 extends Exception,
E3 extends Exception,
E4 extends Exception>
ImmutableMap<K,V> toImmutableMap(Throwables.Function<? super T,? extends K,E2> keyMapper,
 Throwables.Function<? super T,? extends V,E3> valueMapper,
 Throwables.BinaryOperator<V,E4> mergeFunction)
                          throws E,
E2,
E3,
E4

Type Parameters:

K - the key type

V - the value type

E2 -

E3 -

E4 -

Parameters:

keyMapper -

valueMapper -

mergeFunction -

Returns:

Throws:

E - the e

E2

E3

E4

toMap

@TerminalOp
public <K,
V,
E2 extends Exception,
E3 extends Exception>
Map<K,V> toMap(Throwables.Function<? super T,? extends K,E2> keyMapper,
 Throwables.Function<? super T,? extends V,E3> valueMapper)
        throws E,
E2,
E3,
IllegalStateException

Type Parameters:

K - the key type

V - the value type

E2 -

E3 -

Parameters:

keyMapper -

valueMapper -

Returns:

Throws:

E - the e

E2

E3

IllegalStateException - if there are duplicated keys.

toMap

@TerminalOp
public <K,
V,
M extends Map<K,
V>,
E2 extends Exception,
E3 extends Exception>
M toMap(Throwables.Function<? super T,? extends K,E2> keyMapper,
 Throwables.Function<? super T,? extends V,E3> valueMapper,
 Supplier<? extends M> mapFactory)
 throws E,
E2,
E3,
IllegalStateException

Type Parameters:

K - the key type

V - the value type

M -

E2 -

E3 -

Parameters:

keyMapper -

valueMapper -

mapFactory -

Returns:

Throws:

E - the e

E2

E3

IllegalStateException - if there are duplicated keys.

toMap

@TerminalOp
public <K,
V,
E2 extends Exception,
E3 extends Exception,
E4 extends Exception>
Map<K,V> toMap(Throwables.Function<? super T,? extends K,E2> keyMapper,
 Throwables.Function<? super T,? extends V,E3> valueMapper,
 Throwables.BinaryOperator<V,E4> mergeFunction)
        throws E,
E2,
E3,
E4

Type Parameters:

K - the key type

V - the value type

E2 -

E3 -

E4 -

Parameters:

keyMapper -

valueMapper -

mergeFunction -

Returns:

Throws:

E - the e

E2

E3

E4

toMap

@TerminalOp
public <K,
V,
M extends Map<K,
V>,
E2 extends Exception,
E3 extends Exception,
E4 extends Exception>
M toMap(Throwables.Function<? super T,? extends K,E2> keyMapper,
 Throwables.Function<? super T,? extends V,E3> valueMapper,
 Throwables.BinaryOperator<V,E4> mergeFunction,
 Supplier<? extends M> mapFactory)
 throws E,
E2,
E3,
E4

Type Parameters:

K - the key type

V - the value type

M -

E2 -

E3 -

E4 -

Parameters:

keyMapper -

valueMapper -

mergeFunction -

mapFactory -

Returns:

Throws:

E - the e

E2

E3

E4

groupTo

@TerminalOp
public <K,
E2 extends Exception> Map<K,List<T>> groupTo(Throwables.Function<? super T,? extends K,E2> keyMapper)
                                                throws E,
E2

Type Parameters:

K - the key type

E2 -

Parameters:

keyMapper -

Returns:

Throws:

E - the e

E2

See Also:

• Collectors.groupingBy(Function)

groupTo

@TerminalOp
public <K,
M extends Map<K,
List<T>>,
E2 extends Exception>
M groupTo(Throwables.Function<? super T,? extends K,E2> keyMapper,
 Supplier<? extends M> mapFactory)
   throws E,
E2

Type Parameters:

K - the key type

M -

E2 -

Parameters:

keyMapper -

mapFactory -

Returns:

Throws:

E - the e

E2

See Also:

• Collectors.groupingBy(Function, Supplier)

groupTo

@TerminalOp
public <K,
V,
E2 extends Exception,
E3 extends Exception>
Map<K,List<V>> groupTo(Throwables.Function<? super T,? extends K,E2> keyMapper,
 Throwables.Function<? super T,? extends V,E3> valueMapper)
                throws E,
E2,
E3

Type Parameters:

K - the key type

V - the value type

E2 -

E3 -

Parameters:

keyMapper -

valueMapper -

Returns:

Throws:

E - the e

E2

E3

groupTo

@TerminalOp
public <K,
V,
M extends Map<K,
List<V>>,
E2 extends Exception,
E3 extends Exception>
M groupTo(Throwables.Function<? super T,? extends K,E2> keyMapper,
 Throwables.Function<? super T,? extends V,E3> valueMapper,
 Supplier<? extends M> mapFactory)
   throws E,
E2,
E3

Type Parameters:

K - the key type

V - the value type

M -

E2 -

E3 -

Parameters:

keyMapper -

valueMapper -

mapFactory -

Returns:

Throws:

E - the e

E2

E3

See Also:

• Collectors.toMultimap(Function, Function, Supplier)

groupTo

@TerminalOp
public <K,
D,
E2 extends Exception> Map<K,D> groupTo(Throwables.Function<? super T,? extends K,E2> keyMapper,
 Collector<? super T,?,D> downstream)
                                            throws E,
E2

Type Parameters:

K - the key type

D -

E2 -

Parameters:

keyMapper -

downstream -

Returns:

Throws:

E - the e

E2

groupTo

@TerminalOp
public <K,
D,
M extends Map<K,
D>,
E2 extends Exception>
M groupTo(Throwables.Function<? super T,? extends K,E2> keyMapper,
 Collector<? super T,?,D> downstream,
 Supplier<? extends M> mapFactory)
   throws E,
E2

Type Parameters:

K - the key type

D -

M -

E2 -

Parameters:

keyMapper -

downstream -

mapFactory -

Returns:

Throws:

E - the e

E2

groupTo

@TerminalOp
public <K,
V,
D,
E2 extends Exception,
E3 extends Exception>
Map<K,D> groupTo(Throwables.Function<? super T,? extends K,E2> keyMapper,
 Throwables.Function<? super T,? extends V,E3> valueMapper,
 Collector<? super V,?,D> downstream)
          throws E,
E2,
E3

Type Parameters:

K - the key type

V - the value type

D -

E2 -

E3 -

Parameters:

keyMapper -

valueMapper -

downstream -

Returns:

Throws:

E - the e

E2

E3

groupTo

@TerminalOp
public <K,
V,
D,
M extends Map<K,
D>,
E2 extends Exception,
E3 extends Exception>
M groupTo(Throwables.Function<? super T,? extends K,E2> keyMapper,
 Throwables.Function<? super T,? extends V,E3> valueMapper,
 Collector<? super V,?,D> downstream,
 Supplier<? extends M> mapFactory)
   throws E,
E2,
E3

Type Parameters:

K - the key type

V - the value type

D -

M -

E2 -

E3 -

Parameters:

keyMapper -

valueMapper -

downstream -

mapFactory -

Returns:

Throws:

E - the e

E2

E3

partitionTo

@TerminalOp
public <E2 extends Exception> Map<Boolean,List<T>> partitionTo(Throwables.Predicate<? super T,E2> predicate)
                                                        throws E,
E2

Type Parameters:

E2 -

Parameters:

predicate -

Returns:

Throws:

E

E2

See Also:

• Collectors.partitioningBy(Predicate)

partitionTo

@TerminalOp
public <D,
E2 extends Exception> Map<Boolean,D> partitionTo(Throwables.Predicate<? super T,E2> predicate,
 Collector<? super T,?,D> downstream)
                                                    throws E,
E2

Type Parameters:

D -

E2 -

Parameters:

predicate -

downstream -

Returns:

Throws:

E

E2

See Also:

• Collectors.partitioningBy(Predicate, Collector)

toMultimap

@TerminalOp
public <K,
E2 extends Exception> ListMultimap<K,T> toMultimap(Throwables.Function<? super T,? extends K,E2> keyMapper)
                                                      throws E,
E2

Type Parameters:

K -

E2 -

Parameters:

keyMapper -

Returns:

Throws:

E

E2

toMultimap

@TerminalOp
public <K,
V extends Collection<T>,
M extends Multimap<K,
T,
V>,
E2 extends Exception>
M toMultimap(Throwables.Function<? super T,? extends K,E2> keyMapper,
 Supplier<? extends M> mapFactory)
      throws E,
E2

Type Parameters:

K -

V -

M -

E2 -

Parameters:

keyMapper -

mapFactory -

Returns:

Throws:

E

E2

toMultimap

@TerminalOp
public <K,
V,
E2 extends Exception,
E3 extends Exception>
ListMultimap<K,V> toMultimap(Throwables.Function<? super T,? extends K,E2> keyMapper,
 Throwables.Function<? super T,? extends V,E3> valueMapper)
                      throws E,
E2,
E3

Type Parameters:

K -

V -

E2 -

E3 -

Parameters:

keyMapper -

valueMapper -

Returns:

Throws:

E

E2

E3

toMultimap

@TerminalOp
public <K,
V,
C extends Collection<V>,
M extends Multimap<K,
V,
C>,
E2 extends Exception,
E3 extends Exception>
M toMultimap(Throwables.Function<? super T,? extends K,E2> keyMapper,
 Throwables.Function<? super T,? extends V,E3> valueMapper,
 Supplier<? extends M> mapFactory)
      throws E,
E2,
E3

Type Parameters:

K -

V -

C -

M -

E2 -

E3 -

Parameters:

keyMapper -

valueMapper -

mapFactory -

Returns:

Throws:

E

E2

E3

toMultiset

@TerminalOp
public Multiset<T> toMultiset()
                       throws E

Returns:

Throws:

E

toMultiset

@TerminalOp
public Multiset<T> toMultiset(Supplier<? extends Multiset<T>> supplier)
                       throws E

Parameters:

supplier -

Returns:

Throws:

E

toLongMultiset

@TerminalOp
public LongMultiset<T> toLongMultiset()
                               throws E

Returns:

Throws:

E

toLongMultiset

@TerminalOp
public LongMultiset<T> toLongMultiset(Supplier<? extends LongMultiset<T>> supplier)
                               throws E

Parameters:

supplier -

Returns:

Throws:

E

toDataSet

@TerminalOp
public DataSet toDataSet()
                  throws E

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 bean or map.

Returns:

Throws:

E

toDataSet

@TerminalOp
public DataSet toDataSet(List<String> columnNames)
                  throws E

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 bean or map.

Parameters:

columnNames -

Returns:

Throws:

E

sumInt

@TerminalOp
public <E2 extends Exception> long sumInt(Throwables.ToIntFunction<? super T,E2> func)
                                   throws E,
E2

Type Parameters:

E2 -

Parameters:

func -

Returns:

Throws:

E - the e

E2

sumLong

@TerminalOp
public <E2 extends Exception> long sumLong(Throwables.ToLongFunction<? super T,E2> func)
                                    throws E,
E2

Type Parameters:

E2 -

Parameters:

func -

Returns:

Throws:

E - the e

E2

sumDouble

@TerminalOp
public <E2 extends Exception> double sumDouble(Throwables.ToDoubleFunction<? super T,E2> func)
                                        throws E,
E2

Type Parameters:

E2 -

Parameters:

func -

Returns:

Throws:

E - the e

E2

averageInt

@TerminalOp
public <E2 extends Exception> u.OptionalDouble averageInt(Throwables.ToIntFunction<? super T,E2> func)
                                                   throws E,
E2

Type Parameters:

E2 -

Parameters:

func -

Returns:

Throws:

E - the e

E2

averageLong

@TerminalOp
public <E2 extends Exception> u.OptionalDouble averageLong(Throwables.ToLongFunction<? super T,E2> func)
                                                    throws E,
E2

Type Parameters:

E2 -

Parameters:

func -

Returns:

Throws:

E - the e

E2

averageDouble

@TerminalOp
public <E2 extends Exception> u.OptionalDouble averageDouble(Throwables.ToDoubleFunction<? super T,E2> func)
                                                      throws E,
E2

Type Parameters:

E2 -

Parameters:

func -

Returns:

Throws:

E - the e

E2

reduce

@TerminalOp
public <E2 extends Exception> u.Optional<T> reduce(Throwables.BinaryOperator<T,E2> accumulator)
                                            throws E,
E2

Type Parameters:

E2 -

Parameters:

accumulator -

Returns:

Throws:

E - the e

E2 - the e2

reduce

@TerminalOp
public <U,
E2 extends Exception> U reduce(U identity,
 Throwables.BiFunction<U,? super T,U,E2> accumulator)
                                  throws E,
E2

Type Parameters:

U -

E2 -

Parameters:

identity -

accumulator -

Returns:

Throws:

E - the e

E2 - the e2

reduceUntil

@Beta
@TerminalOp
public <E2 extends Exception> u.Optional<T> reduceUntil(Throwables.BinaryOperator<T,E2> accumulator,
 Throwables.Predicate<? super T,E2> conditionToBreak)
                                                 throws E,
E2

Type Parameters:

E2 -

Parameters:

accumulator -

conditionToBreak - the input parameter is the return value of accumulator, not the element from this Stream. Returns true to break the loop if you don't want to continue the action. Iteration on this stream will also be stopped when this flag is set to true.

Returns:

Throws:

E

E2

reduceUntil

@Beta
@TerminalOp
public <U,
E2 extends Exception> U reduceUntil(U identity,
 Throwables.BiFunction<U,? super T,U,E2> accumulator,
 Throwables.Predicate<? super U,E2> conditionToBreak)
                                       throws E,
E2

Type Parameters:

U -

E2 -

Parameters:

identity -

accumulator -

conditionToBreak - the input parameter is the return value of accumulator, not the element from this Stream. Returns true to break the loop if you don't want to continue the action. Iteration on this stream will also be stopped when this flag is set to true.

Returns:

Throws:

E

E2

collect

@TerminalOp
public <R,
E2 extends Exception,
E3 extends Exception>
R collect(Throwables.Supplier<R,E2> supplier,
 Throwables.BiConsumer<? super R,? super T,E3> accumulator)
   throws E,
E2,
E3

Type Parameters:

R -

E2 -

E3 -

Parameters:

supplier -

accumulator -

Returns:

Throws:

E - the e

E2 - the e2

E3 - the e3

collect

@TerminalOp
public <R,
RR,
E2 extends Exception,
E3 extends Exception,
E4 extends Exception>
RR collect(Throwables.Supplier<R,E2> supplier,
 Throwables.BiConsumer<? super R,? super T,E3> accumulator,
 Throwables.Function<? super R,? extends RR,E4> finisher)
    throws E,
E2,
E3,
E4

Type Parameters:

R -

RR -

E2 -

E3 -

E4 -

Parameters:

supplier -

accumulator -

finisher -

Returns:

Throws:

E - the e

E2 - the e2

E3 - the e3

E4 - the e4

collect

@TerminalOp
public <R> R collect(Collector<? super T,?,R> collector)
              throws E

Type Parameters:

R -

Parameters:

collector -

Returns:

Throws:

E - the e

collectThenApply

@TerminalOp
public <R,
RR,
E2 extends Exception> RR collectThenApply(Collector<? super T,?,R> collector,
 Throwables.Function<? super R,? extends RR,E2> func)
                                                throws E,
E2

Type Parameters:

R -

RR -

E2 -

Parameters:

collector -

func -

Returns:

Throws:

E - the e

E2 - the e2

collectThenAccept

@TerminalOp
public <R,
E2 extends Exception> void collectThenAccept(Collector<? super T,?,R> collector,
 Throwables.Consumer<? super R,E2> consumer)
                                                throws E,
E2

Type Parameters:

R -

E2 -

Parameters:

collector -

consumer -

Throws:

E - the e

E2 - the e2

join

@TerminalOp
public String join(CharSequence delimiter)
            throws E

Parameters:

delimiter -

Returns:

Throws:

E

join

@TerminalOp
public String join(CharSequence delimiter,
 CharSequence prefix,
 CharSequence suffix)
            throws E

Parameters:

delimiter -

prefix -

suffix -

Returns:

Throws:

E

saveEach

@Beta
@IntermediateOp
public CheckedStream<T,E> saveEach(File output)

Parameters:

output -

Returns:

See Also:

• onEach(com.landawn.abacus.util.Throwables.Consumer)
• onEachE(com.landawn.abacus.util.Throwables.Consumer)

saveEach

@Beta
@IntermediateOp
public CheckedStream<T,E> saveEach(File output,
 Throwables.Function<? super T,String,E> toLine)

Parameters:

output -

toLine -

Returns:

See Also:

• onEach(com.landawn.abacus.util.Throwables.Consumer)
• onEachE(com.landawn.abacus.util.Throwables.Consumer)

saveEach

@Beta
@IntermediateOp
public CheckedStream<T,E> saveEach(OutputStream output,
 Throwables.Function<? super T,String,E> toLine)

Parameters:

output -

toLine -

Returns:

See Also:

• onEach(com.landawn.abacus.util.Throwables.Consumer)
• onEachE(com.landawn.abacus.util.Throwables.Consumer)

saveEach

@Beta
@IntermediateOp
public CheckedStream<T,E> saveEach(Writer output,
 Throwables.Function<? super T,String,E> toLine)

Parameters:

output -

toLine -

Returns:

See Also:

• onEach(com.landawn.abacus.util.Throwables.Consumer)
• onEachE(com.landawn.abacus.util.Throwables.Consumer)

saveEach

@Beta
@IntermediateOp
public CheckedStream<T,E> saveEach(File output,
 Throwables.BiConsumer<? super T,Writer,IOException> writeLine)

Parameters:

output -

writeLine -

Returns:

See Also:

• onEach(com.landawn.abacus.util.Throwables.Consumer)
• onEachE(com.landawn.abacus.util.Throwables.Consumer)

saveEach

@Beta
@IntermediateOp
public CheckedStream<T,E> saveEach(Writer output,
 Throwables.BiConsumer<? super T,Writer,IOException> writeLine)

Parameters:

output -

writeLine -

Returns:

See Also:

• onEach(com.landawn.abacus.util.Throwables.Consumer)
• onEachE(com.landawn.abacus.util.Throwables.Consumer)

saveEach

@Beta
@IntermediateOp
public CheckedStream<T,E> saveEach(PreparedStatement stmt,
 Throwables.BiConsumer<? super T,? super PreparedStatement,SQLException> stmtSetter)

To support batch call, please use onEach or onEachE.

Parameters:

stmt -

stmtSetter -

Returns:

See Also:

• onEach(com.landawn.abacus.util.Throwables.Consumer)
• onEachE(com.landawn.abacus.util.Throwables.Consumer)

saveEach

@Beta
@IntermediateOp
public CheckedStream<T,E> saveEach(Connection conn,
 String insertSQL,
 Throwables.BiConsumer<? super T,? super PreparedStatement,SQLException> stmtSetter)

To support batch call, please use onEach or onEachE.

Parameters:

conn -

insertSQL -

stmtSetter -

Returns:

See Also:

• onEach(com.landawn.abacus.util.Throwables.Consumer)
• onEachE(com.landawn.abacus.util.Throwables.Consumer)

saveEach

@Beta
@IntermediateOp
public CheckedStream<T,E> saveEach(DataSource ds,
 String insertSQL,
 Throwables.BiConsumer<? super T,? super PreparedStatement,SQLException> stmtSetter)

To support batch/parallel call, please use onEach or onEachE.

Parameters:

ds -

insertSQL -

stmtSetter -

Returns:

See Also:

• onEach(com.landawn.abacus.util.Throwables.Consumer)
• onEachE(com.landawn.abacus.util.Throwables.Consumer)
• spsOnEach(com.landawn.abacus.util.Throwables.Consumer)
• spsOnEachE(com.landawn.abacus.util.Throwables.Consumer)

persist

@TerminalOp
public long persist(File output)
             throws E,
IOException

Parameters:

output -

Returns:

Throws:

E

IOException

persist

@TerminalOp
public long persist(File output,
 String header,
 String tail)
             throws E,
IOException

Parameters:

output -

header -

tail -

Returns:

Throws:

E

IOException

persist

@TerminalOp
public long persist(File output,
 Throwables.Function<? super T,String,E> toLine)
             throws E,
IOException

Parameters:

output -

toLine -

Returns:

Throws:

E

IOException

persist

@TerminalOp
public long persist(File output,
 String header,
 String tail,
 Throwables.Function<? super T,String,E> toLine)
             throws E,
IOException

Parameters:

output -

header -

tail -

toLine -

Returns:

Throws:

E

IOException

persist

@TerminalOp
public long persist(OutputStream output,
 Throwables.Function<? super T,String,E> toLine)
             throws E,
IOException

Parameters:

output -

toLine -

Returns:

Throws:

E

IOException

persist

@TerminalOp
public long persist(OutputStream output,
 String header,
 String tail,
 Throwables.Function<? super T,String,E> toLine)
             throws E,
IOException

Parameters:

output -

header -

tail -

toLine -

Returns:

Throws:

E

IOException

persist

@TerminalOp
public long persist(Writer output,
 Throwables.Function<? super T,String,E> toLine)
             throws E,
IOException

Parameters:

output -

toLine -

Returns:

Throws:

E

IOException

persist

@TerminalOp
public long persist(Writer output,
 String header,
 String tail,
 Throwables.Function<? super T,String,E> toLine)
             throws E,
IOException

Parameters:

output -

header -

tail -

toLine -

Returns:

Throws:

E

IOException

persist

@TerminalOp
public long persist(File output,
 Throwables.BiConsumer<? super T,Writer,IOException> writeLine)
             throws E,
IOException

Parameters:

output -

writeLine -

Returns:

Throws:

E

IOException

persist

@TerminalOp
public long persist(File output,
 String header,
 String tail,
 Throwables.BiConsumer<? super T,Writer,IOException> writeLine)
             throws E,
IOException

Parameters:

output -

header -

tail -

writeLine -

Returns:

Throws:

E

IOException

persist

@TerminalOp
public long persist(Writer output,
 Throwables.BiConsumer<? super T,Writer,IOException> writeLine)
             throws E,
IOException

Parameters:

output -

writeLine -

Returns:

Throws:

E

IOException

persist

@TerminalOp
public long persist(Writer output,
 String header,
 String tail,
 Throwables.BiConsumer<? super T,Writer,IOException> writeLine)
             throws E,
IOException

Parameters:

output -

header -

tail -

writeLine -

Returns:

Throws:

E

IOException

persist

@TerminalOp
public long persist(PreparedStatement stmt,
 int batchSize,
 long batchIntervalInMillis,
 Throwables.BiConsumer<? super T,? super PreparedStatement,SQLException> stmtSetter)
             throws E,
SQLException

Parameters:

stmt -

batchSize -

batchIntervalInMillis -

stmtSetter -

Returns:

Throws:

E

SQLException

persist

@TerminalOp
public long persist(Connection conn,
 String insertSQL,
 int batchSize,
 long batchIntervalInMillis,
 Throwables.BiConsumer<? super T,? super PreparedStatement,SQLException> stmtSetter)
             throws E,
SQLException

Parameters:

conn -

insertSQL -

batchSize -

batchIntervalInMillis -

stmtSetter -

Returns:

Throws:

E

SQLException

persist

@TerminalOp
public long persist(DataSource ds,
 String insertSQL,
 int batchSize,
 long batchIntervalInMillis,
 Throwables.BiConsumer<? super T,? super PreparedStatement,SQLException> stmtSetter)
             throws E,
SQLException

Parameters:

ds -

insertSQL -

batchSize -

batchIntervalInMillis -

stmtSetter -

Returns:

Throws:

E

SQLException

persistToCSV

@TerminalOp
public long persistToCSV(File output)
                  throws E,
IOException

Each line in the output file/Writer is an array of JSON String without root bracket.

Parameters:

output -

Returns:

Throws:

E

IOException

persistToCSV

@TerminalOp
public long persistToCSV(File output,
 Collection<String> csvHeaders)
                  throws E,
IOException

Each line in the output file/Writer is an array of JSON String without root bracket.

Parameters:

output -

csvHeaders -

Returns:

Throws:

E

IOException

persistToCSV

@TerminalOp
public long persistToCSV(OutputStream output)
                  throws E,
IOException

Each line in the output file/Writer is an array of JSON String without root bracket.

Parameters:

output -

Returns:

Throws:

E

IOException

persistToCSV

@TerminalOp
public long persistToCSV(OutputStream output,
 Collection<String> csvHeaders)
                  throws E,
IOException

Each line in the output file/Writer is an array of JSON String without root bracket.

Parameters:

output -

csvHeaders -

Returns:

Throws:

E

IOException

persistToCSV

@TerminalOp
public long persistToCSV(Writer output)
                  throws E,
IOException

Each line in the output file/Writer is an array of JSON String without root bracket.

Parameters:

output -

Returns:

Throws:

E

IOException

persistToCSV

@TerminalOp
public long persistToCSV(Writer output,
 Collection<String> csvHeaders)
                  throws E,
IOException

Each line in the output file/Writer is an array of JSON String without root bracket.

Parameters:

output -

csvHeaders -

Returns:

Throws:

E

IOException

persistToJSON

@TerminalOp
public long persistToJSON(File output)
                   throws E,
IOException

Throws:

E extends Exception

IOException

persistToJSON

@TerminalOp
public long persistToJSON(OutputStream output)
                   throws E,
IOException

Throws:

E extends Exception

IOException

persistToJSON

@TerminalOp
public long persistToJSON(Writer output)
                   throws E,
IOException

Throws:

E extends Exception

IOException

println

@Beta
@TerminalOp
public void println()
             throws E

Throws:

E

unchecked

@IntermediateOp
public Stream<T> unchecked()

Returns:

toJdkStream

@IntermediateOp
public Stream<T> toJdkStream()

Returns:

cast

@Beta
@IntermediateOp
public CheckedStream<T,Exception> cast()

Returns:

transform

@Beta
@IntermediateOp
public <TT,
EE extends Exception>
CheckedStream<TT,EE> transform(Function<? super CheckedStream<T,E>,CheckedStream<TT,EE>> transfer)

Type Parameters:

TT -

EE -

Parameters:

transfer -

Returns:

__

@Beta
@IntermediateOp
@Deprecated
public <TT,
EE extends Exception>
CheckedStream<TT,EE> __(Function<? super CheckedStream<T,E>,CheckedStream<TT,EE>> transfer)

Deprecated.

replaced by transform(Function)

Type Parameters:

TT -

EE -

Parameters:

transfer -

Returns:

sps

@Beta
@IntermediateOp
public <R> CheckedStream<R,E> 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.

Type Parameters:

R -

Parameters:

ops -

Returns:

See Also:

• BaseStream.sps(Function)
• ExceptionUtil.toRuntimeException(Throwable)
• ExceptionUtil.registerRuntimeExceptionMapper(Class, Function)
• ExceptionUtil.hasCause(Throwable, Class)
• ExceptionUtil.hasCause(Throwable, Predicate)

sps

@Beta
@IntermediateOp
public <R> CheckedStream<R,E> 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.

Type Parameters:

R -

Parameters:

maxThreadNum -

ops -

Returns:

See Also:

• BaseStream.sps(int, Function)
• ExceptionUtil.toRuntimeException(Throwable)
• ExceptionUtil.registerRuntimeExceptionMapper(Class, Function)
• ExceptionUtil.hasCause(Throwable, Class)
• ExceptionUtil.hasCause(Throwable, Predicate)

spsFilter

@Beta
@IntermediateOp
public CheckedStream<T,E> spsFilter(Throwables.Predicate<? super T,E> predicate)

Temporarily switch the stream to parallel stream for operation filter and then switch back to sequence stream.

Parameters:

predicate -

Returns:

See Also:

• Stream.spsFilter(Predicate)
• ExceptionUtil.toRuntimeException(Throwable)
• ExceptionUtil.registerRuntimeExceptionMapper(Class, Function)
• ExceptionUtil.hasCause(Throwable, Class)
• ExceptionUtil.hasCause(Throwable, Predicate)

spsMap

@Beta
@IntermediateOp
public <R> CheckedStream<R,E> 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.

Type Parameters:

R -

Parameters:

mapper -

Returns:

See Also:

• Stream.spsMap(Function)
• ExceptionUtil.toRuntimeException(Throwable)
• ExceptionUtil.registerRuntimeExceptionMapper(Class, Function)
• ExceptionUtil.hasCause(Throwable, Class)
• ExceptionUtil.hasCause(Throwable, Predicate)

spsFlatMap

@Beta
@IntermediateOp
public <R> CheckedStream<R,E> 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.

Type Parameters:

R -

Parameters:

mapper -

Returns:

See Also:

• Stream.spsFlatMap(Function)
• ExceptionUtil.toRuntimeException(Throwable)
• ExceptionUtil.registerRuntimeExceptionMapper(Class, Function)
• ExceptionUtil.hasCause(Throwable, Class)
• ExceptionUtil.hasCause(Throwable, Predicate)

spsFlatmap

@Beta
@IntermediateOp
public <R> CheckedStream<R,E> 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.

Type Parameters:

R -

Parameters:

mapper -

Returns:

See Also:

• Stream.spsFlatmap(Function)
• ExceptionUtil.toRuntimeException(Throwable)
• ExceptionUtil.registerRuntimeExceptionMapper(Class, Function)
• ExceptionUtil.hasCause(Throwable, Class)
• ExceptionUtil.hasCause(Throwable, Predicate)

spsOnEach

@Beta
@IntermediateOp
public CheckedStream<T,E> spsOnEach(Throwables.Consumer<? super T,E> action)

Temporarily switch the stream to parallel stream for operation onEach and then switch back to sequence stream.

Parameters:

action -

Returns:

See Also:

• Stream#onEach(Consumer)
• ExceptionUtil.toRuntimeException(Throwable)
• ExceptionUtil.registerRuntimeExceptionMapper(Class, Function)
• ExceptionUtil.hasCause(Throwable, Class)
• ExceptionUtil.hasCause(Throwable, Predicate)

spsFilter

@Beta
@IntermediateOp
public CheckedStream<T,E> 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.

Parameters:

maxThreadNum -

predicate -

Returns:

See Also:

• Stream.spsFilter(int, Predicate)
• ExceptionUtil.toRuntimeException(Throwable)
• ExceptionUtil.registerRuntimeExceptionMapper(Class, Function)
• ExceptionUtil.hasCause(Throwable, Class)
• ExceptionUtil.hasCause(Throwable, Predicate)

spsMap

@Beta
@IntermediateOp
public <R> CheckedStream<R,E> 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.

Type Parameters:

R -

Parameters:

maxThreadNum -

mapper -

Returns:

See Also:

• Stream.spsMap(int, Function)
• ExceptionUtil.toRuntimeException(Throwable)
• ExceptionUtil.registerRuntimeExceptionMapper(Class, Function)
• ExceptionUtil.hasCause(Throwable, Class)
• ExceptionUtil.hasCause(Throwable, Predicate)

spsFlatMap

@Beta
@IntermediateOp
public <R> CheckedStream<R,E> 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.

Type Parameters:

R -

Parameters:

maxThreadNum -

mapper -

Returns:

See Also:

• Stream.spsFlatMap(int, Function)
• ExceptionUtil.toRuntimeException(Throwable)
• ExceptionUtil.registerRuntimeExceptionMapper(Class, Function)
• ExceptionUtil.hasCause(Throwable, Class)
• ExceptionUtil.hasCause(Throwable, Predicate)

spsFlatmap

@Beta
@IntermediateOp
public <R> CheckedStream<R,E> 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.

Type Parameters:

R -

Parameters:

maxThreadNum -

mapper -

Returns:

See Also:

• Stream.spsFlatmap(int, Function)
• ExceptionUtil.toRuntimeException(Throwable)
• ExceptionUtil.registerRuntimeExceptionMapper(Class, Function)
• ExceptionUtil.hasCause(Throwable, Class)
• ExceptionUtil.hasCause(Throwable, Predicate)

spsOnEach

@Beta
@IntermediateOp
public CheckedStream<T,E> 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.

Parameters:

maxThreadNum -

action -

Returns:

See Also:

• Stream#onEach(int, Consumer)
• ExceptionUtil.toRuntimeException(Throwable)
• ExceptionUtil.registerRuntimeExceptionMapper(Class, Function)
• ExceptionUtil.hasCause(Throwable, Class)
• ExceptionUtil.hasCause(Throwable, Predicate)

spsFilterE

@Beta
@IntermediateOp
public CheckedStream<T,Exception> 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.

Parameters:

predicate -

Returns:

See Also:

• Stream.spsFilter(Predicate)
• ExceptionUtil.toRuntimeException(Throwable)
• ExceptionUtil.registerRuntimeExceptionMapper(Class, Function)
• ExceptionUtil.hasCause(Throwable, Class)
• ExceptionUtil.hasCause(Throwable, Predicate)

spsMapE

@Beta
@IntermediateOp
public <U> CheckedStream<U,Exception> 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.

Type Parameters:

U -

Parameters:

mapper -

Returns:

See Also:

• Stream.spsMap(Function)
• ExceptionUtil.toRuntimeException(Throwable)
• ExceptionUtil.registerRuntimeExceptionMapper(Class, Function)
• ExceptionUtil.hasCause(Throwable, Class)
• ExceptionUtil.hasCause(Throwable, Predicate)

spsFlatMapE

@Beta
@IntermediateOp
public <R> CheckedStream<R,Exception> 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.

Type Parameters:

R -

Parameters:

mapper -

Returns:

See Also:

• Stream.spsFlatMap(Function)
• ExceptionUtil.toRuntimeException(Throwable)
• ExceptionUtil.registerRuntimeExceptionMapper(Class, Function)
• ExceptionUtil.hasCause(Throwable, Class)
• ExceptionUtil.hasCause(Throwable, Predicate)

spsFlatmapE

@Beta
@IntermediateOp
public <R> CheckedStream<R,Exception> 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.

Type Parameters:

R -

Parameters:

mapper -

Returns:

See Also:

• Stream.spsFlatmap(Function)
• ExceptionUtil.toRuntimeException(Throwable)
• ExceptionUtil.registerRuntimeExceptionMapper(Class, Function)
• ExceptionUtil.hasCause(Throwable, Class)
• ExceptionUtil.hasCause(Throwable, Predicate)

spsOnEachE

@Beta
@IntermediateOp
public CheckedStream<T,Exception> 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.

Parameters:

action -

Returns:

See Also:

• Stream#onEach(Consumer)
• ExceptionUtil.toRuntimeException(Throwable)
• ExceptionUtil.registerRuntimeExceptionMapper(Class, Function)
• ExceptionUtil.hasCause(Throwable, Class)
• ExceptionUtil.hasCause(Throwable, Predicate)

spsFilterE

@Beta
@IntermediateOp
public CheckedStream<T,Exception> 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.

Parameters:

maxThreadNum -

predicate -

Returns:

See Also:

• Stream.spsFilter(Predicate)
• ExceptionUtil.toRuntimeException(Throwable)
• ExceptionUtil.registerRuntimeExceptionMapper(Class, Function)
• ExceptionUtil.hasCause(Throwable, Class)
• ExceptionUtil.hasCause(Throwable, Predicate)

spsMapE

@Beta
@IntermediateOp
public <U> CheckedStream<U,Exception> 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.

Type Parameters:

U -

Parameters:

maxThreadNum -

mapper -

Returns:

See Also:

• Stream.spsMap(Function)
• ExceptionUtil.toRuntimeException(Throwable)
• ExceptionUtil.registerRuntimeExceptionMapper(Class, Function)
• ExceptionUtil.hasCause(Throwable, Class)
• ExceptionUtil.hasCause(Throwable, Predicate)

spsFlatMapE

@Beta
@IntermediateOp
public <R> CheckedStream<R,Exception> 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.

Type Parameters:

R -

Parameters:

maxThreadNum -

mapper -

Returns:

See Also:

• Stream.spsFlatMap(Function)
• ExceptionUtil.toRuntimeException(Throwable)
• ExceptionUtil.registerRuntimeExceptionMapper(Class, Function)
• ExceptionUtil.hasCause(Throwable, Class)
• ExceptionUtil.hasCause(Throwable, Predicate)

spsFlatmapE

@Beta
@IntermediateOp
public <R> CheckedStream<R,Exception> 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.

Type Parameters:

R -

Parameters:

maxThreadNum -

mapper -

Returns:

See Also:

• Stream.spsFlatmap(Function)
• ExceptionUtil.toRuntimeException(Throwable)
• ExceptionUtil.registerRuntimeExceptionMapper(Class, Function)
• ExceptionUtil.hasCause(Throwable, Class)
• ExceptionUtil.hasCause(Throwable, Predicate)

spsOnEachE

@Beta
@IntermediateOp
public CheckedStream<T,Exception> 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.

Parameters:

maxThreadNum -

action -

Returns:

See Also:

• Stream#onEach(Consumer)
• ExceptionUtil.toRuntimeException(Throwable)
• ExceptionUtil.registerRuntimeExceptionMapper(Class, Function)
• ExceptionUtil.hasCause(Throwable, Class)
• ExceptionUtil.hasCause(Throwable, Predicate)

filterE

@Beta
@IntermediateOp
public CheckedStream<T,Exception> filterE(Throwables.Predicate<? super T,? extends Exception> predicate)

Parameters:

predicate -

Returns:

mapE

@Beta
@IntermediateOp
public <U> CheckedStream<U,Exception> mapE(Throwables.Function<? super T,? extends U,? extends Exception> mapper)

Type Parameters:

U -

Parameters:

mapper -

Returns:

flatMapE

@Beta
@IntermediateOp
public <R> CheckedStream<R,Exception> flatMapE(Throwables.Function<? super T,? extends CheckedStream<? extends R,? extends Exception>,? extends Exception> mapper)

Type Parameters:

R -

Parameters:

mapper -

Returns:

flatmapE

@Beta
@IntermediateOp
public <R> CheckedStream<R,Exception> flatmapE(Throwables.Function<? super T,? extends Collection<? extends R>,? extends Exception> mapper)

Type Parameters:

R -

Parameters:

mapper -

Returns:

onEachE

@Beta
@IntermediateOp
public CheckedStream<T,Exception> onEachE(Throwables.Consumer<? super T,? extends Exception> action)

Parameters:

action -

Returns:

addSubscriber

@Beta
@SequentialOnly
@IntermediateOp
public CheckedStream<T,E> addSubscriber(Throwables.Consumer<? super CheckedStream<T,E>,? extends Exception> consumerForNewStreamWithTerminalAction)

Add a new Stream with terminal action to listen/consume the elements from upstream.

Parameters:

consumerForNewStreamWithTerminalAction -

Returns:

See Also:

• addSubscriber(com.landawn.abacus.util.Throwables.Consumer, int, Executor)

addSubscriber

@Beta
@SequentialOnly
@IntermediateOp
public CheckedStream<T,E> addSubscriber(Throwables.Consumer<? super CheckedStream<T,E>,? extends Exception> consumerForNewStreamWithTerminalAction,
 int queueSize,
 Executor executor)

Add a new Stream with terminal action to listen/consume the elements from upstream. The terminal action of the new Stream will be executed in a new Thread. The new thread is started when the new Stream receives first element or this stream is closed if there is no element pulled by this Stream. At the begin, elements from upstream will be pulled by this Stream and put in a queue to share with the new Stream. After this Stream is finished, the new Stream will continue to pull remaining elements from upstream if needed. This stream and the new Stream run independently. Operations in one stream won't impact the elements or final result in another Stream.

If the new Stream fetch more elements than this Stream, the new Stream may be finished later.
If the new Stream fetch less elements than this Stream, the new Stream may be finished earlier.
If the new Stream is finished later, this Stream will wait to it's finished in the close method.

To get the return value of the new Stream, An output parameter can be used. for example:

 
     final Holder resultHolder = new Holder<>();
     thisStream.injectNewStream(newStream -> resultHolder.set(newStream.filter(...).map(...).join(",")));
 
 

Parameters:

consumerForNewStreamWithTerminalAction -

Returns:

filterWhileAddSubscriber

public CheckedStream<T,E> filterWhileAddSubscriber(Predicate<? super T> predicate,
 Throwables.Consumer<? super CheckedStream<T,E>,? extends Exception> consumerForNewStreamWithTerminalAction)

Add a new Stream with terminal action to listen/consume the elements filtered out by the specified predicate.

Parameters:

predicate -

consumerForNewStreamWithTerminalAction -

Returns:

See Also:

• addSubscriber(com.landawn.abacus.util.Throwables.Consumer, int, Executor)

filterWhileAddSubscriber

public CheckedStream<T,E> filterWhileAddSubscriber(Predicate<? super T> predicate,
 Throwables.Consumer<? super CheckedStream<T,E>,? extends Exception> consumerForNewStreamWithTerminalAction,
 int queueSize,
 Executor executor)

Add a new Stream with terminal action to listen/consume the elements filtered out by the specified predicate.

Parameters:

predicate -

consumerForNewStreamWithTerminalAction -

queueSize -

executor -

Returns:

See Also:

• addSubscriber(com.landawn.abacus.util.Throwables.Consumer, int, Executor)

takeWhileAddSubscriber

public CheckedStream<T,E> takeWhileAddSubscriber(Predicate<? super T> predicate,
 Throwables.Consumer<? super CheckedStream<T,E>,? extends Exception> consumerForNewStreamWithTerminalAction)

Add a new Stream with terminal action to listen/consume the elements not token by the specified predicate.

Parameters:

predicate -

consumerForNewStreamWithTerminalAction -

Returns:

See Also:

• addSubscriber(com.landawn.abacus.util.Throwables.Consumer, int, Executor)

takeWhileAddSubscriber

public CheckedStream<T,E> takeWhileAddSubscriber(Predicate<? super T> predicate,
 Throwables.Consumer<? super CheckedStream<T,E>,? extends Exception> consumerForNewStreamWithTerminalAction,
 int queueSize,
 Executor executor)

Add a new Stream with terminal action to listen/consume the elements not token by the specified predicate.

Parameters:

predicate -

consumerForNewStreamWithTerminalAction -

queueSize -

executor -

Returns:

See Also:

• addSubscriber(com.landawn.abacus.util.Throwables.Consumer, int, Executor)

dropWhileAddSubscriber

public CheckedStream<T,E> dropWhileAddSubscriber(Predicate<? super T> predicate,
 Throwables.Consumer<? super CheckedStream<T,E>,? extends Exception> consumerForNewStreamWithTerminalAction)

Add a new Stream with terminal action to listen/consume the elements dropped by the specified predicate.

Parameters:

predicate -

consumerForNewStreamWithTerminalAction -

Returns:

See Also:

• addSubscriber(com.landawn.abacus.util.Throwables.Consumer, int, Executor)

dropWhileAddSubscriber

public CheckedStream<T,E> dropWhileAddSubscriber(Predicate<? super T> predicate,
 Throwables.Consumer<? super CheckedStream<T,E>,? extends Exception> consumerForNewStreamWithTerminalAction,
 int queueSize,
 Executor executor)

Add a new Stream with terminal action to listen/consume the elements dropped by the specified predicate.

Parameters:

predicate -

consumerForNewStreamWithTerminalAction -

queueSize -

executor -

Returns:

See Also:

• addSubscriber(com.landawn.abacus.util.Throwables.Consumer, int, Executor)

asyncRun

@Beta
@TerminalOp
public ContinuableFuture<Void> asyncRun(Throwables.Consumer<? super CheckedStream<T,E>,? extends Exception> terminalAction)

Parameters:

terminalAction - a terminal operation should be called.

Returns:

asyncRun

@Beta
@TerminalOp
public ContinuableFuture<Void> asyncRun(Throwables.Consumer<? super CheckedStream<T,E>,? extends Exception> terminalAction,
 Executor executor)

Parameters:

terminalAction - a terminal operation should be called.

executor -

Returns:

asyncCall

@Beta
@TerminalOp
public <R> ContinuableFuture<R> asyncCall(Throwables.Function<? super CheckedStream<T,E>,R,? extends Exception> terminalAction)

Type Parameters:

R -

Parameters:

terminalAction - a terminal operation should be called.

Returns:

asyncCall

@Beta
@TerminalOp
public <R> ContinuableFuture<R> asyncCall(Throwables.Function<? super CheckedStream<T,E>,R,? extends Exception> terminalAction,
 Executor executor)

Type Parameters:

R -

Parameters:

terminalAction - a terminal operation should be called.

executor -

Returns:

onClose

@IntermediateOp
public CheckedStream<T,E> onClose(Throwables.Runnable<? extends E> closeHandler)

Parameters:

closeHandler -

Returns:

close

@TerminalOp
public void close()

It will be called by terminal operations in final.

Specified by:

close in interface AutoCloseable

Specified by:

close in interface Closeable