Package com.landawn.abacus.util

Class ExceptionalStream<T,E extends Exception>

java.lang.Object

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

Type Parameters:

T -

E -

All Implemented Interfaces:

Immutable, Closeable, AutoCloseable

Direct Known Subclasses:

ExceptionalStream.StreamE

@SequentialOnly
@Immutable
public class ExceptionalStream<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
• Collectors
• Fn.Fnn
• Comparators
• ExceptionUtil

Nested Class Summary

Nested Classes

Modifier and Type	Class	Description
static class	ExceptionalStream.ExceptionalIterator<T,E extends Exception>	The Class ExceptionalIterator.
static final class	ExceptionalStream.Seq	Deprecated. Mostly it's for android.
static final class	ExceptionalStream.StreamE<T,E extends Exception>

Method Summary

Modifier and Type	Method	Description
<TT, EE extends Exception> ExceptionalStream<TT,EE>	__(Function<? super ExceptionalStream<T,E>,ExceptionalStream<TT,EE>> transfer)
<E2 extends Exception> If.OrElse	acceptIfNotEmpty(Throwables.Consumer<? super ExceptionalStream<T,E>,E2> action)
<E2 extends Exception> boolean	allMatch(Throwables.Predicate<? super T,E2> predicate)
<E2 extends Exception> boolean	anyMatch(Throwables.Predicate<? super T,E2> predicate)
ExceptionalStream<T,E>	append(ExceptionalStream<T,E> s)
ExceptionalStream<T,E>	append(Collection<? extends T> c)
final ExceptionalStream<T,E>	append(T... a)
ExceptionalStream<T,E>	appendIfEmpty(Throwables.Supplier<? extends ExceptionalStream<T,E>,? extends E> supplier)	Append if empty.
ExceptionalStream<T,E>	appendIfEmpty(Collection<? extends T> c)
final ExceptionalStream<T,E>	appendIfEmpty(T... a)
<R, E2 extends Exception> u.Optional<R>	applyIfNotEmpty(Throwables.Function<? super ExceptionalStream<T,E>,R,E2> func)
<R> ContinuableFuture<R>	asyncCall(Throwables.Function<? super ExceptionalStream<T,E>,R,? extends Exception> terminalAction)
<R> ContinuableFuture<R>	asyncCall(Throwables.Function<? super ExceptionalStream<T,E>,R,? extends Exception> terminalAction, Executor executor)
ContinuableFuture<Void>	asyncRun(Throwables.Consumer<? super ExceptionalStream<T,E>,? extends Exception> terminalAction)
ContinuableFuture<Void>	asyncRun(Throwables.Consumer<? super ExceptionalStream<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)
ExceptionalStream<T,Exception>	cast()
void	close()	It will be called by terminal operations in final.
ExceptionalStream<Stream<T>,E>	collapse(Throwables.BiPredicate<? super T,? super T,? extends E> collapsible)
ExceptionalStream<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> ExceptionalStream<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>> ExceptionalStream<C,E>	collapse(Throwables.BiPredicate<? super T,? super T,? extends E> collapsible, Supplier<? extends C> supplier)
<R, A> ExceptionalStream<R,E>	collapse(Throwables.BiPredicate<? super T,? super T,? extends E> collapsible, Collector<? super T,A,R> collector)
<U> ExceptionalStream<U,E>	collapse(Throwables.BiPredicate<? super T,? super T,? extends E> collapsible, U init, Throwables.BiFunction<U,? super T,U,? extends E> op)
ExceptionalStream<Stream<T>,E>	collapse(Throwables.TriPredicate<? super T,? super T,? super T,? extends E> collapsible)
ExceptionalStream<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> ExceptionalStream<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>> ExceptionalStream<C,E>	collapse(Throwables.TriPredicate<? super T,? super T,? super T,? extends E> collapsible, Supplier<? extends C> supplier)
<R, A> ExceptionalStream<R,E>	collapse(Throwables.TriPredicate<? super T,? super T,? super T,? extends E> collapsible, Collector<? super T,A,R> collector)	Merge series of adjacent elements which satisfy the given predicate using the merger function and return a new stream.
<U> ExceptionalStream<U,E>	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, A> R	collect(Collector<? super T,A,R> collector)
<R, RR, A, E2 extends Exception> RR	collectAndThen(Collector<? super T,A,R> collector, Throwables.Function<? super R,? extends RR,E2> func)	Collect and then.
static <T, E extends Exception> ExceptionalStream<T,E>	concat(ExceptionalStream<? extends T,E>... a)
static <T, E extends Exception> ExceptionalStream<T,E>	concat(Iterable<? extends T>... a)
static <T, E extends Exception> ExceptionalStream<T,E>	concat(Collection<? extends ExceptionalStream<? extends T,E>> c)
static <T, E extends Exception> ExceptionalStream<T,E>	concat(Iterator<? extends T>... a)
static <T, E extends Exception> ExceptionalStream<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> ExceptionalStream<Map.Entry<K,Integer>,E>	countBy(Throwables.Function<? super T,? extends K,? extends E> keyMapper)
ExceptionalStream<T,E>	cycled()
ExceptionalStream<T,E>	cycled(long times)
final ExceptionalStream<T,E>	defaultIfEmpty(Throwables.Supplier<? extends ExceptionalStream<T,E>,? extends E> supplier)
final ExceptionalStream<T,E>	defaultIfEmpty(T defaultValue)
static <T, E extends Exception> ExceptionalStream<T,E>	defer(Throwables.Supplier<? extends ExceptionalStream<? extends T,? extends E>,? extends E> supplier)	Lazy evaluation.
ExceptionalStream<T,E>	difference(Collection<?> c)
<U> ExceptionalStream<T,E>	difference(Function<? super T,? extends U> mapper, Collection<U> c)
ExceptionalStream<T,E>	distinct()	Distinct and filter by occurrences.
ExceptionalStream<T,E>	distinct(Throwables.BinaryOperator<T,? extends E> mergeFunction)	Distinct and filter by occurrences.
ExceptionalStream<T,E>	distinct(Throwables.Predicate<? super Long,? extends E> occurrencesFilter)	Distinct and filter by occurrences.
<K> ExceptionalStream<T,E>	distinctBy(Throwables.Function<? super T,K,? extends E> keyMapper)	Distinct by the value mapped from keyMapper .
<K> ExceptionalStream<T,E>	distinctBy(Throwables.Function<? super T,K,? extends E> keyMapper, Throwables.BinaryOperator<T,? extends E> mergeFunction)	Distinct and filter by occurrences.
<K> ExceptionalStream<T,E>	distinctBy(Throwables.Function<? super T,K,? extends E> keyMapper, Throwables.Predicate<? super Long,? extends E> occurrencesFilter)	Distinct and filter by occurrences.
ExceptionalStream<T,E>	dropWhile(Throwables.Predicate<? super T,? extends E> predicate)
ExceptionalStream<T,E>	dropWhile(Throwables.Predicate<? super T,? extends E> predicate, Throwables.Consumer<? super T,? extends E> actionOnDroppedItem)
u.Optional<T>	elementAt(long position)
static <T, E extends Exception> ExceptionalStream<T,E>	empty()
ExceptionalStream<T,E>	filter(Throwables.Predicate<? super T,? extends E> predicate)
ExceptionalStream<T,E>	filter(Throwables.Predicate<? super T,? extends E> predicate, Throwables.Consumer<? super T,? extends E> actionOnDroppedItem)
ExceptionalStream<T,Exception>	filterE(Throwables.Predicate<? super T,? extends Exception> 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> ExceptionalStream<R,E>	flatmap(Throwables.Function<? super T,? extends Collection<? extends R>,? extends E> mapper)
<R> ExceptionalStream<R,E>	flatMap(Throwables.Function<? super T,? extends ExceptionalStream<? extends R,? extends E>,? extends E> mapper)
<R> ExceptionalStream<R,Exception>	flatmapE(Throwables.Function<? super T,? extends Collection<? extends R>,? extends Exception> mapper)
<R> ExceptionalStream<R,Exception>	flatMapE(Throwables.Function<? super T,? extends ExceptionalStream<? extends R,? extends Exception>,? extends Exception> mapper)
<R> ExceptionalStream<R,E>	flatMapIfNotNull(Throwables.Function<? super T,? extends Collection<? extends R>,? extends E> mapper)
<U, R> ExceptionalStream<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)
<R> ExceptionalStream<R,E>	flatMapp(Throwables.Function<? super T,? extends Stream<? extends R>,? extends E> mapper)
ExceptionalStream<Boolean,E>	flatMapToBoolean(Throwables.Function<? super T,boolean[],? extends E> mapper)
ExceptionalStream<Byte,E>	flatMapToByte(Throwables.Function<? super T,byte[],? extends E> mapper)
ExceptionalStream<Character,E>	flatMapToChar(Throwables.Function<? super T,char[],? extends E> mapper)
ExceptionalStream<Double,E>	flatMapToDouble(Throwables.Function<? super T,double[],? extends E> mapper)
ExceptionalStream<Float,E>	flatMapToFloat(Throwables.Function<? super T,float[],? extends E> mapper)
ExceptionalStream<Integer,E>	flatMapToInteger(Throwables.Function<? super T,int[],? extends E> mapper)
ExceptionalStream<Long,E>	flatMapToLong(Throwables.Function<? super T,long[],? extends E> mapper)
ExceptionalStream<Short,E>	flatMapToShort(Throwables.Function<? super T,short[],? extends E> mapper)
<R> ExceptionalStream<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 Collection<? 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 Collection<T2>,E2> flatMapper, Throwables.Function<? super T2,? extends Collection<T3>,E3> flatMapper2, Throwables.TriConsumer<? super T,? super T2,? super T3,E4> action)
<E2 extends Exception> void	forEachIndexed(Throwables.IndexedConsumer<? super T,E2> action)
<E2 extends Exception> void	forEachInParallel(Throwables.Consumer<? super T,E2> action, int threadNum)
<E2 extends Exception> void	forEachInParallel(Throwables.Consumer<? super T,E2> action, int threadNum, Executor executor)
<E2 extends Exception> void	forEachPair(Throwables.BiConsumer<? super T,? super T,E2> action)	For each pair.
<E2 extends Exception> void	forEachPair(Throwables.BiConsumer<? super T,? super T,E2> action, int increment)	For each pair.
<E2 extends Exception> void	forEachTriple(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, int increment)	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> ExceptionalStream<T,E>	from(Throwables.Supplier<? extends Collection<? extends T>,? extends E> supplier)	Lazy evaluation.
static <T, E extends Exception> ExceptionalStream<T,E>	generate(Throwables.Supplier<T,E> supplier)
<K> ExceptionalStream<Map.Entry<K,List<T>>,E>	groupBy(Throwables.Function<? super T,? extends K,? extends E> keyMapper)
<K, V> ExceptionalStream<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> ExceptionalStream<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> ExceptionalStream<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> ExceptionalStream<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, A, D> ExceptionalStream<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,A,D> downstream)
<K, V, A, D> ExceptionalStream<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,A,D> downstream, Supplier<? extends Map<K,D>> mapFactory)
<K> ExceptionalStream<Map.Entry<K,List<T>>,E>	groupBy(Throwables.Function<? super T,? extends K,? extends E> keyMapper, Supplier<? extends Map<K,List<T>>> mapFactory)
<K, A, D> ExceptionalStream<Map.Entry<K,D>,E>	groupBy(Throwables.Function<? super T,? extends K,? extends E> keyMapper, Collector<? super T,A,D> downstream)
<K, A, D> ExceptionalStream<Map.Entry<K,D>,E>	groupBy(Throwables.Function<? super T,? extends K,? extends E> keyMapper, Collector<? super T,A,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, A, 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,A,D> downstream)
<K, V, A, 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,A,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, A, D, E2 extends Exception> Map<K,D>	groupTo(Throwables.Function<? super T,? extends K,E2> keyMapper, Collector<? super T,A,D> downstream)
<K, A, D, M extends Map<K, D>, E2 extends Exception> M	groupTo(Throwables.Function<? super T,? extends K,E2> keyMapper, Collector<? super T,A,D> downstream, Supplier<? extends M> mapFactory)
boolean	hasDuplicates()
ExceptionalStream<Indexed<T>,E>	indexed()
<U> ExceptionalStream<T,E>	intersection(Throwables.Function<? super T,? extends U,E> mapper, Collection<U> c)
ExceptionalStream<T,E>	intersection(Collection<?> c)
ExceptionalStream<T,E>	intersperse(T delimiter)
static <T, E extends Exception> ExceptionalStream<T,E>	iterate(Throwables.BooleanSupplier<? extends E> hasNext, Throwables.Supplier<? extends T,E> next)
static <T, E extends Exception> ExceptionalStream<T,E>	iterate(T init, Throwables.BooleanSupplier<? extends E> hasNext, Throwables.UnaryOperator<T,? extends E> f)
static <T, E extends Exception> ExceptionalStream<T,E>	iterate(T init, Throwables.Predicate<? super T,? extends E> hasNext, Throwables.UnaryOperator<T,? extends E> f)
static <T, E extends Exception> ExceptionalStream<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> ExceptionalStream<T,E>	just(T e)
static <T, E extends Exception> ExceptionalStream<T,E>	just(T e, Class<E> exceptionType)
u.Optional<T>	kthLargest(int k, Comparator<? super T> comparator)
u.Optional<T>	last()
ExceptionalStream<T,E>	last(int n)	A queue with size up to n will be maintained to filter out the last n elements.
ExceptionalStream<T,E>	limit(long maxSize)
static ExceptionalStream<String,IOException>	lines(File file)
static ExceptionalStream<String,IOException>	lines(File file, Charset charset)
static ExceptionalStream<String,IOException>	lines(Reader reader)
static ExceptionalStream<String,IOException>	lines(Path path)
static ExceptionalStream<String,IOException>	lines(Path path, Charset charset)
static ExceptionalStream<File,IOException>	listFiles(File parentPath)
static ExceptionalStream<File,IOException>	listFiles(File parentPath, boolean recursively)
<U> ExceptionalStream<U,E>	map(Throwables.Function<? super T,? extends U,? extends E> mapper)
<U> ExceptionalStream<U,Exception>	mapE(Throwables.Function<? super T,? extends U,? extends Exception> mapper)
ExceptionalStream<T,E>	mapFirst(Throwables.Function<? super T,? extends T,? extends E> mapperForFirst)
<R> ExceptionalStream<R,E>	mapFirstOrElse(Throwables.Function<? super T,? extends R,E> mapperForFirst, Throwables.Function<? super T,? extends R,E> mapperForElse)
ExceptionalStream<T,E>	mapLast(Throwables.Function<? super T,? extends T,? extends E> mapperForLast)
<R> ExceptionalStream<R,E>	mapLastOrElse(Throwables.Function<? super T,? extends R,E> mapperForLast, Throwables.Function<? super T,? extends R,E> mapperForElse)
<R> ExceptionalStream<R,E>	mapMulti(Throwables.BiConsumer<? super T,? super Consumer<R>,? extends E> mapper)
<R> ExceptionalStream<R,E>	mapPartial(Throwables.Function<? super T,u.Optional<? extends R>,E> mapper)	Note: copied from StreamEx: https://github.com/amaembo/streamex
<R> ExceptionalStream<R,E>	mapPartialJdk(Throwables.Function<? super T,Optional<? extends R>,E> mapper)	Note: copied from StreamEx: https://github.com/amaembo/streamex
ExceptionalStream<Double,E>	mapPartialToDouble(Throwables.Function<? super T,u.OptionalDouble,E> mapper)	Note: copied from StreamEx: https://github.com/amaembo/streamex
ExceptionalStream<Double,E>	mapPartialToDoubleJdk(Throwables.Function<? super T,OptionalDouble,E> mapper)	Note: copied from StreamEx: https://github.com/amaembo/streamex
ExceptionalStream<Integer,E>	mapPartialToInt(Throwables.Function<? super T,u.OptionalInt,E> mapper)	Note: copied from StreamEx: https://github.com/amaembo/streamex
ExceptionalStream<Integer,E>	mapPartialToIntJdk(Throwables.Function<? super T,OptionalInt,E> mapper)	Note: copied from StreamEx: https://github.com/amaembo/streamex
ExceptionalStream<Long,E>	mapPartialToLong(Throwables.Function<? super T,u.OptionalLong,E> mapper)	Note: copied from StreamEx: https://github.com/amaembo/streamex
ExceptionalStream<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> ExceptionalStream<T,E>	merge(ExceptionalStream<? extends T,E> a, ExceptionalStream<? extends T,E> b, ExceptionalStream<? extends T,E> c, Throwables.BiFunction<? super T,? super T,MergeResult,E> nextSelector)
static <T, E extends Exception> ExceptionalStream<T,E>	merge(ExceptionalStream<? extends T,E> a, ExceptionalStream<? extends T,E> b, Throwables.BiFunction<? super T,? super T,MergeResult,E> nextSelector)
static <T, E extends Exception> ExceptionalStream<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> ExceptionalStream<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> ExceptionalStream<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> ExceptionalStream<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> ExceptionalStream<T,E>	merge(T[] a, T[] b, Throwables.BiFunction<? super T,? super T,MergeResult,E> nextSelector)
static <T, E extends Exception> ExceptionalStream<T,E>	merge(T[] a, T[] b, T[] c, Throwables.BiFunction<? super T,? super T,MergeResult,E> nextSelector)
ExceptionalStream<T,E>	mergeWith(ExceptionalStream<? extends T,E> b, Throwables.BiFunction<? super T,? super T,MergeResult,E> nextSelector)
ExceptionalStream<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> ExceptionalStream<Boolean,E>	of(boolean[] a)
static <E extends Exception> ExceptionalStream<Byte,E>	of(byte[] a)
static <E extends Exception> ExceptionalStream<Character,E>	of(char[] a)
static <E extends Exception> ExceptionalStream<Double,E>	of(double[] a)
static <E extends Exception> ExceptionalStream<Float,E>	of(float[] a)
static <E extends Exception> ExceptionalStream<Integer,E>	of(int[] a)
static <E extends Exception> ExceptionalStream<Long,E>	of(long[] a)
static <E extends Exception> ExceptionalStream<Short,E>	of(short[] a)
static <T, E extends Exception> ExceptionalStream<T,E>	of(Stream<? extends T> stream)
static <T, E extends Exception> ExceptionalStream<T,E>	of(Stream<? extends T> stream, Class<E> exceptionType)
static <T, E extends Exception> ExceptionalStream<T,E>	of(u.Optional<T> op)
static <T, E extends Exception> ExceptionalStream<T,E>	of(Iterable<? extends T> iterable)
static <T, E extends Exception> ExceptionalStream<T,E>	of(Iterable<? extends T> iterable, Class<E> exceptionType)
static <T, E extends Exception> ExceptionalStream<T,E>	of(Collection<? extends T> c)
static <T, E extends Exception> ExceptionalStream<T,E>	of(Collection<? extends T> c, Class<E> exceptionType)
static <T, E extends Exception> ExceptionalStream<T,E>	of(Iterator<? extends T> iter)
static <T, E extends Exception> ExceptionalStream<T,E>	of(Iterator<? extends T> iter, Class<E> exceptionType)
static <K, V, E extends Exception> ExceptionalStream<Map.Entry<K,V>,E>	of(Map<K,V> m)
static <K, V, E extends Exception> ExceptionalStream<Map.Entry<K,V>,E>	of(Map<K,V> m, Class<E> exceptionType)
static <T, E extends Exception> ExceptionalStream<T,E>	of(Optional<T> op)
static <T, E extends Exception> ExceptionalStream<T,E>	of(Stream<? extends T> stream)
static <T, E extends Exception> ExceptionalStream<T,E>	of(Stream<? extends T> stream, Class<E> exceptionType)
static <T, E extends Exception> ExceptionalStream<T,E>	of(T... a)
static <K, E extends Exception> ExceptionalStream<K,E>	ofKeys(Map<K,?> map)
static <K, V, E extends Exception> ExceptionalStream<K,E>	ofKeys(Map<K,V> map, Throwables.BiPredicate<? super K,? super V,E> filter)
static <K, V, E extends Exception> ExceptionalStream<K,E>	ofKeys(Map<K,V> map, Throwables.Predicate<? super V,E> valueFilter)
static <T, E extends Exception> ExceptionalStream<T,E>	ofNullable(T e)	Returns an empty Stream if the specified t is null.
static <V, E extends Exception> ExceptionalStream<V,E>	ofValues(Map<?,V> map)
static <K, V, E extends Exception> ExceptionalStream<V,E>	ofValues(Map<K,V> map, Throwables.BiPredicate<? super K,? super V,E> filter)
static <K, V, E extends Exception> ExceptionalStream<V,E>	ofValues(Map<K,V> map, Throwables.Predicate<? super K,E> keyFilter)
ExceptionalStream<T,E>	onClose(Throwables.Runnable<? extends E> closeHandler)
ExceptionalStream<T,E>	onEach(Throwables.Consumer<? super T,? extends E> action)
ExceptionalStream<T,Exception>	onEachE(Throwables.Consumer<? super T,? extends Exception> action)
u.Optional<T>	onlyOne()
ExceptionalStream<Map.Entry<Boolean,List<T>>,E>	partitionBy(Throwables.Predicate<? super T,E> predicate)
<A, D> ExceptionalStream<Map.Entry<Boolean,D>,E>	partitionBy(Throwables.Predicate<? super T,E> predicate, Collector<? super T,A,D> downstream)
<E2 extends Exception> Map<Boolean,List<T>>	partitionTo(Throwables.Predicate<? super T,E2> predicate)
<A, D, E2 extends Exception> Map<Boolean,D>	partitionTo(Throwables.Predicate<? super T,E2> predicate, Collector<? super T,A,D> downstream)
ExceptionalStream<T,E>	peek(Throwables.Consumer<? super T,? extends E> action)
ExceptionalStream<T,E>	peekFirst(Throwables.Consumer<? super T,? extends E> action)
ExceptionalStream<T,E>	peekIf(Throwables.BiPredicate<? super T,? super Long,E> predicate, Consumer<? super T> action)
ExceptionalStream<T,E>	peekIf(Throwables.Predicate<? super T,E> predicate, Throwables.Consumer<? super T,E> action)
ExceptionalStream<T,E>	peekLast(Throwables.Consumer<? super T,? extends E> action)
u.Optional<Map<Percentage,T>>	percentiles(Comparator<? super T> comparator)
long	persist(Throwables.BiConsumer<? super T,Writer,IOException> writeLine, File file)
long	persist(Throwables.BiConsumer<? super T,Writer,IOException> writeLine, Writer writer)
long	persist(Throwables.BiConsumer<? super T,Writer,IOException> writeLine, String header, String tail, File file)
long	persist(Throwables.BiConsumer<? super T,Writer,IOException> writeLine, String header, String tail, Writer writer)
long	persist(Throwables.Function<? super T,String,IOException> toLine, File file)	toCSV:
long	persist(Throwables.Function<? super T,String,IOException> toLine, OutputStream os)
long	persist(Throwables.Function<? super T,String,IOException> toLine, Writer writer)	toCSV:
long	persist(Throwables.Function<? super T,String,IOException> toLine, String header, String tail, File file)
long	persist(Throwables.Function<? super T,String,IOException> toLine, String header, String tail, Writer writer)
long	persist(File file)
long	persist(String header, String tail, File file)
long	persist(Connection conn, String insertSQL, int batchSize, int batchInterval, Throwables.BiConsumer<? super T,? super PreparedStatement,SQLException> stmtSetter)
long	persist(PreparedStatement stmt, int batchSize, int batchInterval, Throwables.BiConsumer<? super T,? super PreparedStatement,SQLException> stmtSetter)
long	persistToCSV(File file)	Each line in the output file/Writer is an array of JSON String without root bracket.
long	persistToCSV(OutputStream os)	Each line in the output file/Writer is an array of JSON String without root bracket.
long	persistToCSV(Writer writer)	Each line in the output file/Writer is an array of JSON String without root bracket.
long	persistToCSV(Collection<String> csvHeaders, File file)	Each line in the output file/Writer is an array of JSON String without root bracket.
long	persistToCSV(Collection<String> csvHeaders, OutputStream os)	Each line in the output file/Writer is an array of JSON String without root bracket.
long	persistToCSV(Collection<String> csvHeaders, Writer writer)	Each line in the output file/Writer is an array of JSON String without root bracket.
ExceptionalStream<T,E>	prepend(ExceptionalStream<T,E> s)
ExceptionalStream<T,E>	prepend(Collection<? extends T> c)
final ExceptionalStream<T,E>	prepend(T... a)
void	println()
static <E extends Exception> ExceptionalStream<Integer,E>	range(int startInclusive, int endExclusive)
static <E extends Exception> ExceptionalStream<Integer,E>	range(int startInclusive, int endExclusive, int by)
static <E extends Exception> ExceptionalStream<Integer,E>	rangeClosed(int startInclusive, int endExclusive)
static <E extends Exception> ExceptionalStream<Integer,E>	rangeClosed(int startInclusive, int endExclusive, int by)
ExceptionalStream<T,E>	rateLimited(double permitsPerSecond)
ExceptionalStream<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> ExceptionalStream<T,E>	repeat(T element, long n)
ExceptionalStream<T,E>	reversed()
ExceptionalStream<T,E>	reverseSorted()
ExceptionalStream<T,E>	reverseSorted(Comparator<? super T> comparator)
ExceptionalStream<T,E>	rotated(int distance)
ExceptionalStream<T,E>	scan(Throwables.BiFunction<? super T,? super T,T,? extends E> accumulator)
<U> ExceptionalStream<U,E>	scan(U init, Throwables.BiFunction<U,? super T,U,? extends E> accumulator)
<U> ExceptionalStream<U,E>	scan(U init, Throwables.BiFunction<U,? super T,U,? extends E> accumulator, boolean initIncluded)
ExceptionalStream<T,E>	shuffled()
ExceptionalStream<T,E>	shuffled(Random rnd)
ExceptionalStream<T,E>	skip(long n)
ExceptionalStream<T,E>	skipLast(int n)
ExceptionalStream<T,E>	skipNull()
ExceptionalStream<T,E>	skipUntil(Throwables.Predicate<? super T,? extends E> predicate)
ExceptionalStream<Stream<T>,E>	sliding(int windowSize, int increment)
<C extends Collection<T>> ExceptionalStream<C,E>	sliding(int windowSize, int increment, IntFunction<? extends C> collectionSupplier)
<A, R> ExceptionalStream<R,E>	sliding(int windowSize, int increment, Collector<? super T,A,R> collector)
<R> ExceptionalStream<R,E>	slidingMap(Throwables.BiFunction<? super T,? super T,R,? extends E> mapper)
<R> ExceptionalStream<R,E>	slidingMap(Throwables.BiFunction<? super T,? super T,R,? extends E> mapper, int increment)
<R> ExceptionalStream<R,E>	slidingMap(Throwables.BiFunction<? super T,? super T,R,? extends E> mapper, int increment, boolean ignoreNotPaired)
<R> ExceptionalStream<R,E>	slidingMap(Throwables.TriFunction<? super T,? super T,? super T,R,? extends E> mapper)
<R> ExceptionalStream<R,E>	slidingMap(Throwables.TriFunction<? super T,? super T,? super T,R,? extends E> mapper, int increment)
<R> ExceptionalStream<R,E>	slidingMap(Throwables.TriFunction<? super T,? super T,? super T,R,? extends E> mapper, int increment, boolean ignoreNotPaired)
ExceptionalStream<List<T>,E>	slidingToList(int windowSize, int increment)	Sliding to list.
ExceptionalStream<Set<T>,E>	slidingToSet(int windowSize, int increment)	Sliding to set.
ExceptionalStream<T,E>	sorted()
ExceptionalStream<T,E>	sorted(Comparator<? super T> comparator)
ExceptionalStream<T,E>	sortedBy(Function<? super T,? extends Comparable> keyMapper)
ExceptionalStream<Stream<T>,E>	split(int chunkSize)
<C extends Collection<T>> ExceptionalStream<C,E>	split(int chunkSize, IntFunction<? extends C> collectionSupplier)	Returns ExceptionalStream of C with consecutive sub sequences of the elements, each of the same size (the final sequence may be smaller).
<R, A> ExceptionalStream<R,E>	split(int chunkSize, Collector<? super T,A,R> collector)
static <E extends Exception> ExceptionalStream<String,E>	split(CharSequence str, CharSequence delimiter)
ExceptionalStream<ExceptionalStream<T,E>,E>	splitAt(int where)
ExceptionalStream<ExceptionalStream<T,E>,E>	splitAt(Throwables.Predicate<? super T,? extends E> where)
ExceptionalStream<List<T>,E>	splitToList(int chunkSize)	Returns ExceptionalStream of List<T> with consecutive sub sequences of the elements, each of the same size (the final sequence may be smaller).
ExceptionalStream<Set<T>,E>	splitToSet(int chunkSize)	Returns ExceptionalStream of Set<T> with consecutive sub sequences of the elements, each of the same size (the final sequence may be smaller).
<R> ExceptionalStream<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> ExceptionalStream<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.
ExceptionalStream<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.
ExceptionalStream<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.
ExceptionalStream<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.
ExceptionalStream<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> ExceptionalStream<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> ExceptionalStream<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> ExceptionalStream<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> ExceptionalStream<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> ExceptionalStream<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> ExceptionalStream<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> ExceptionalStream<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> ExceptionalStream<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> ExceptionalStream<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> ExceptionalStream<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> ExceptionalStream<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> ExceptionalStream<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.
ExceptionalStream<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.
ExceptionalStream<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.
ExceptionalStream<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.
ExceptionalStream<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.
ExceptionalStream<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)
ExceptionalStream<T,E>	symmetricDifference(Collection<T> c)
ExceptionalStream<T,E>	takeWhile(Throwables.Predicate<? super T,? extends E> predicate)
ExceptionalStream<T,E>	throwIfEmpty(Supplier<? extends E> exceptionSupplier)
Object[]	toArray()
<A> A[]	toArray(IntFunction<A[]> generator)
<C extends Collection<T>> C	toCollection(Supplier<? extends C> supplier)
<R, CC extends Collection<T>, E2 extends Exception> R	toCollectionAndThen(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 entity 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 entity 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()
<R, E2 extends Exception> R	toListAndThen(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)
final <K, V, A, D, E2 extends Exception, E3 extends Exception> Map<K,D>	toMap(Throwables.Function<? super T,? extends K,E2> keyMapper, Throwables.Function<? super T,? extends V,E3> valueMapper, Collector<? super V,A,D> downstream)	Deprecated. replaced by groupTo
final <K, V, A, D, M extends Map<K, D>, E2 extends Exception, E3 extends Exception> M	toMap(Throwables.Function<? super T,? extends K,E2> keyMapper, Throwables.Function<? super T,? extends V,E3> valueMapper, Collector<? super V,A,D> downstream, Supplier<? extends M> mapFactory)	Deprecated. replaced by groupTo
final <K, A, D, E2 extends Exception> Map<K,D>	toMap(Throwables.Function<? super T,? extends K,E2> keyMapper, Collector<? super T,A,D> downstream)	Deprecated. replaced by groupTo
final <K, A, D, M extends Map<K, D>, E2 extends Exception> M	toMap(Throwables.Function<? super T,? extends K,E2> keyMapper, Collector<? super T,A,D> downstream, Supplier<? extends M> mapFactory)	Deprecated. replaced by groupTo
<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)
ExceptionalStream<T,E>	top(int n)
ExceptionalStream<T,E>	top(int n, Comparator<? super T> comparator)
Set<T>	toSet()
<R, E2 extends Exception> R	toSetAndThen(Throwables.Function<? super Set<T>,R,E2> func)
Stream<T>	unchecked()
static <A, B, T, E extends Exception> ExceptionalStream<T,E>	zip(A[] a, B[] b, A valueForNoneA, B valueForNoneB, Throwables.BiFunction<? super A,? super B,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> ExceptionalStream<T,E>	zip(A[] a, B[] b, C[] c, A valueForNoneA, B valueForNoneB, C valueForNoneC, Throwables.TriFunction<? super A,? super B,? super C,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> ExceptionalStream<T,E>	zip(A[] a, B[] b, C[] c, Throwables.TriFunction<? super A,? super B,? super C,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> ExceptionalStream<T,E>	zip(A[] a, B[] b, Throwables.BiFunction<? super A,? super B,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> ExceptionalStream<T,E>	zip(ExceptionalStream<? extends A,E> a, ExceptionalStream<? extends B,E> b, A valueForNoneA, B valueForNoneB, Throwables.BiFunction<? super A,? super B,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> ExceptionalStream<T,E>	zip(ExceptionalStream<? extends A,E> a, ExceptionalStream<? extends B,E> b, ExceptionalStream<? extends C,E> c, A valueForNoneA, B valueForNoneB, C valueForNoneC, Throwables.TriFunction<? super A,? super B,? super C,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> ExceptionalStream<T,E>	zip(ExceptionalStream<? extends A,E> a, ExceptionalStream<? extends B,E> b, ExceptionalStream<? extends C,E> c, Throwables.TriFunction<? super A,? super B,? super C,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> ExceptionalStream<T,E>	zip(ExceptionalStream<? extends A,E> a, ExceptionalStream<? extends B,E> b, Throwables.BiFunction<? super A,? super B,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> ExceptionalStream<T,E>	zip(Iterable<? extends A> a, Iterable<? extends B> b, A valueForNoneA, B valueForNoneB, Throwables.BiFunction<? super A,? super B,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> ExceptionalStream<T,E>	zip(Iterable<? extends A> a, Iterable<? extends B> b, Throwables.BiFunction<? super A,? super B,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> ExceptionalStream<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,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> ExceptionalStream<T,E>	zip(Iterable<? extends A> a, Iterable<? extends B> b, Iterable<? extends C> c, Throwables.TriFunction<? super A,? super B,? super C,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> ExceptionalStream<T,E>	zip(Iterator<? extends A> a, Iterator<? extends B> b, A valueForNoneA, B valueForNoneB, Throwables.BiFunction<? super A,? super B,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> ExceptionalStream<T,E>	zip(Iterator<? extends A> a, Iterator<? extends B> b, Throwables.BiFunction<? super A,? super B,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> ExceptionalStream<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,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> ExceptionalStream<T,E>	zip(Iterator<? extends A> a, Iterator<? extends B> b, Iterator<? extends C> c, Throwables.TriFunction<? super A,? super B,? super C,T,? extends E> zipFunction)	Zip together the "a", "b" and "c" iterators until one of them runs out of values.
<T2, T3, R> ExceptionalStream<R,E>	zipWith(ExceptionalStream<T2,E> b, ExceptionalStream<T3,E> c, Throwables.TriFunction<? super T,? super T2,? super T3,R,? extends E> zipFunction)
<T2, T3, R> ExceptionalStream<R,E>	zipWith(ExceptionalStream<T2,E> b, ExceptionalStream<T3,E> c, T valueForNoneA, T2 valueForNoneB, T3 valueForNoneC, Throwables.TriFunction<? super T,? super T2,? super T3,R,? extends E> zipFunction)
<T2, R> ExceptionalStream<R,E>	zipWith(ExceptionalStream<T2,E> b, Throwables.BiFunction<? super T,? super T2,R,? extends E> zipFunction)
<T2, R> ExceptionalStream<R,E>	zipWith(ExceptionalStream<T2,E> b, T valueForNoneA, T2 valueForNoneB, Throwables.BiFunction<? super T,? super T2,R,? extends E> zipFunction)
<T2, R> ExceptionalStream<R,E>	zipWith(Collection<T2> b, Throwables.BiFunction<? super T,? super T2,R,? extends E> zipFunction)
<T2, T3, R> ExceptionalStream<R,E>	zipWith(Collection<T2> b, Collection<T3> c, Throwables.TriFunction<? super T,? super T2,? super T3,R,? extends E> zipFunction)
<T2, T3, R> ExceptionalStream<R,E>	zipWith(Collection<T2> b, Collection<T3> c, T valueForNoneA, T2 valueForNoneB, T3 valueForNoneC, Throwables.TriFunction<? super T,? super T2,? super T3,R,? extends E> zipFunction)
<T2, R> ExceptionalStream<R,E>	zipWith(Collection<T2> b, T valueForNoneA, T2 valueForNoneB, Throwables.BiFunction<? super T,? super T2,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>
ExceptionalStream<T,E> empty()

Type Parameters:

T -

E -

Returns:

just

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

Type Parameters:

T -

E -

Parameters:

e -

Returns:

just

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

Type Parameters:

T -

E -

Parameters:

e -

exceptionType -

Returns:

ofNullable

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

Returns an empty Stream if the specified t is null.

Type Parameters:

T -

E -

Parameters:

e -

Returns:

of

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

Type Parameters:

T -

E -

Parameters:

a -

Returns:

of

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

Type Parameters:

T -

E -

Parameters:

c -

Returns:

of

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

Type Parameters:

T -

E -

Parameters:

iter -

Returns:

of

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

Type Parameters:

T -

E -

Parameters:

iterable -

Returns:

of

public static <K,
V,
E extends Exception>
ExceptionalStream<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>
ExceptionalStream<T,E> of(Stream<? extends T> stream)

Type Parameters:

T -

E -

Parameters:

stream -

Returns:

of

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

Type Parameters:

T -

E -

Parameters:

stream -

Returns:

of

public static <T,
E extends Exception>
ExceptionalStream<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>
ExceptionalStream<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>
ExceptionalStream<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>
ExceptionalStream<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>
ExceptionalStream<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>
ExceptionalStream<T,E> of(Stream<? extends T> stream,
 Class<E> exceptionType)

Type Parameters:

T -

E -

Parameters:

stream -

exceptionType -

Returns:

of

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

of

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

of

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

of

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

of

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

Type Parameters:

E -

Parameters:

a -

Returns:

of

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

Type Parameters:

E -

Parameters:

a -

Returns:

of

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

of

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

Type Parameters:

E -

Parameters:

a -

Returns:

of

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

of

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

ofKeys

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

ofKeys

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

ofKeys

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

ofValues

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

ofValues

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

ofValues

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

from

@Beta
public static <T,
E extends Exception>
ExceptionalStream<T,E> from(Throwables.Supplier<? extends Collection<? extends T>,? extends E> supplier)

Lazy evaluation.
This is equal to: ExceptionalStream.just(supplier).flatmap(it -> it.get()).

Parameters:

supplier -

Returns:

defer

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

Lazy evaluation.
This is equal to: ExceptionalStream.just(supplier).flatMap(it -> it.get()).

Parameters:

supplier -

Returns:

iterate

public static <T,
E extends Exception>
ExceptionalStream<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>
ExceptionalStream<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>
ExceptionalStream<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>
ExceptionalStream<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>
ExceptionalStream<T,E> generate(Throwables.Supplier<T,E> supplier)

repeat

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

range

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

range

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

rangeClosed

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

rangeClosed

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

split

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

lines

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

Parameters:

file -

Returns:

lines

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

Parameters:

file -

charset -

Returns:

lines

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

Parameters:

path -

Returns:

lines

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

Parameters:

path -

charset -

Returns:

lines

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

Parameters:

reader -

Returns:

listFiles

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

listFiles

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

concat

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

concat

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

concat

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

concat

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

Type Parameters:

T -

E -

Parameters:

a -

Returns:

concat

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

Type Parameters:

T -

E -

Parameters:

c -

Returns:

zip

public static <A,
B,
T,
E extends Exception>
ExceptionalStream<T,E> zip(A[] a,
 B[] b,
 Throwables.BiFunction<? super A,? super B,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.

Parameters:

a -

b -

Returns:

zip

public static <A,
B,
C,
T,
E extends Exception>
ExceptionalStream<T,E> zip(A[] a,
 B[] b,
 C[] c,
 Throwables.TriFunction<? super A,? super B,? super C,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.

Parameters:

a -

b -

Returns:

zip

public static <A,
B,
T,
E extends Exception>
ExceptionalStream<T,E> zip(Iterable<? extends A> a,
 Iterable<? extends B> b,
 Throwables.BiFunction<? super A,? super B,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.

Parameters:

a -

b -

Returns:

zip

public static <A,
B,
C,
T,
E extends Exception>
ExceptionalStream<T,E> zip(Iterable<? extends A> a,
 Iterable<? extends B> b,
 Iterable<? extends C> c,
 Throwables.TriFunction<? super A,? super B,? super C,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.

Parameters:

a -

b -

Returns:

zip

public static <A,
B,
T,
E extends Exception>
ExceptionalStream<T,E> zip(Iterator<? extends A> a,
 Iterator<? extends B> b,
 Throwables.BiFunction<? super A,? super B,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.

Parameters:

a -

b -

Returns:

zip

public static <A,
B,
C,
T,
E extends Exception>
ExceptionalStream<T,E> zip(Iterator<? extends A> a,
 Iterator<? extends B> b,
 Iterator<? extends C> c,
 Throwables.TriFunction<? super A,? super B,? super C,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.

Parameters:

a -

b -

Returns:

zip

public static <A,
B,
T,
E extends Exception>
ExceptionalStream<T,E> zip(ExceptionalStream<? extends A,E> a,
 ExceptionalStream<? extends B,E> b,
 Throwables.BiFunction<? super A,? super B,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.

Parameters:

a -

b -

Returns:

zip

public static <A,
B,
C,
T,
E extends Exception>
ExceptionalStream<T,E> zip(ExceptionalStream<? extends A,E> a,
 ExceptionalStream<? extends B,E> b,
 ExceptionalStream<? extends C,E> c,
 Throwables.TriFunction<? super A,? super B,? super C,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.

Parameters:

a -

b -

c -

Returns:

zip

public static <A,
B,
T,
E extends Exception>
ExceptionalStream<T,E> zip(A[] a,
 B[] b,
 A valueForNoneA,
 B valueForNoneB,
 Throwables.BiFunction<? super A,? super B,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.

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>
ExceptionalStream<T,E> zip(A[] a,
 B[] b,
 C[] c,
 A valueForNoneA,
 B valueForNoneB,
 C valueForNoneC,
 Throwables.TriFunction<? super A,? super B,? super C,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.

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>
ExceptionalStream<T,E> zip(Iterable<? extends A> a,
 Iterable<? extends B> b,
 A valueForNoneA,
 B valueForNoneB,
 Throwables.BiFunction<? super A,? super B,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.

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>
ExceptionalStream<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,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.

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>
ExceptionalStream<T,E> zip(Iterator<? extends A> a,
 Iterator<? extends B> b,
 A valueForNoneA,
 B valueForNoneB,
 Throwables.BiFunction<? super A,? super B,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.

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>
ExceptionalStream<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,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.

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>
ExceptionalStream<T,E> zip(ExceptionalStream<? extends A,E> a,
 ExceptionalStream<? extends B,E> b,
 A valueForNoneA,
 B valueForNoneB,
 Throwables.BiFunction<? super A,? super B,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.

Parameters:

a -

b -

Returns:

zip

public static <A,
B,
C,
T,
E extends Exception>
ExceptionalStream<T,E> zip(ExceptionalStream<? extends A,E> a,
 ExceptionalStream<? extends B,E> b,
 ExceptionalStream<? extends C,E> c,
 A valueForNoneA,
 B valueForNoneB,
 C valueForNoneC,
 Throwables.TriFunction<? super A,? super B,? super C,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.

Parameters:

a -

b -

c -

Returns:

merge

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

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>
ExceptionalStream<T,E> merge(T[] a,
 T[] b,
 T[] c,
 Throwables.BiFunction<? super T,? super T,MergeResult,E> nextSelector)

Parameters:

a -

b -

c -

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

Returns:

merge

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

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>
ExceptionalStream<T,E> merge(Iterable<? extends T> a,
 Iterable<? extends T> b,
 Iterable<? extends T> c,
 Throwables.BiFunction<? super T,? super T,MergeResult,E> nextSelector)

Parameters:

a -

b -

c -

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

Returns:

merge

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

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>
ExceptionalStream<T,E> merge(Iterator<? extends T> a,
 Iterator<? extends T> b,
 Iterator<? extends T> c,
 Throwables.BiFunction<? super T,? super T,MergeResult,E> nextSelector)

Parameters:

a -

b -

c -

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

Returns:

merge

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

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>
ExceptionalStream<T,E> merge(ExceptionalStream<? extends T,E> a,
 ExceptionalStream<? extends T,E> b,
 ExceptionalStream<? extends T,E> c,
 Throwables.BiFunction<? super T,? super T,MergeResult,E> nextSelector)

filter

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

Parameters:

predicate -

Returns:

filter

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

Parameters:

predicate -

actionOnDroppedItem -

Returns:

takeWhile

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

Parameters:

predicate -

Returns:

dropWhile

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

Parameters:

predicate -

Returns:

dropWhile

@IntermediateOp
public ExceptionalStream<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 ExceptionalStream<T,E> skipUntil(Throwables.Predicate<? super T,? extends E> predicate)

Parameters:

predicate -

Returns:

distinct

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

Distinct and filter by occurrences.

Returns:

distinct

@IntermediateOp
@TerminalOpTriggered
public ExceptionalStream<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 ExceptionalStream<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> ExceptionalStream<T,E> distinctBy(Throwables.Function<? super T,K,? extends E> keyMapper)

Distinct by the value mapped from keyMapper .

Parameters:

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

Returns:

distinctBy

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

Distinct and filter by occurrences.

Parameters:

keyMapper -

mergeFunction -

Returns:

See Also:

• #groupBy(Function, Function, BinaryOperator)

distinctBy

@IntermediateOp
@TerminalOpTriggered
public <K> ExceptionalStream<T,E> distinctBy(Throwables.Function<? super T,K,? extends E> keyMapper,
 Throwables.Predicate<? super Long,? extends E> occurrencesFilter)

Distinct and filter by occurrences.

Parameters:

keyMapper -

occurrencesFilter -

Returns:

See Also:

• #groupBy(Function, Collector)

map

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

Type Parameters:

U -

Parameters:

mapper -

Returns:

mapFirst

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

mapFirstOrElse

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

mapLast

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

mapLastOrElse

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

flatMap

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

Type Parameters:

R -

Parameters:

mapper -

Returns:

flatmap

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

Type Parameters:

R -

Parameters:

mapper -

Returns:

flattMap

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

Type Parameters:

R -

Parameters:

mapper -

Returns:

flatMapp

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

Type Parameters:

R -

Parameters:

mapper -

Returns:

flatMapIfNotNull

@Beta
@IntermediateOp
public <R> ExceptionalStream<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> ExceptionalStream<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 ExceptionalStream<Boolean,E> flatMapToBoolean(Throwables.Function<? super T,boolean[],? extends E> mapper)

Type Parameters:

R -

Parameters:

mapper -

Returns:

flatMapToChar

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

Type Parameters:

R -

Parameters:

mapper -

Returns:

flatMapToByte

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

Type Parameters:

R -

Parameters:

mapper -

Returns:

flatMapToShort

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

Type Parameters:

R -

Parameters:

mapper -

Returns:

flatMapToInteger

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

Type Parameters:

R -

Parameters:

mapper -

Returns:

flatMapToLong

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

Type Parameters:

R -

Parameters:

mapper -

Returns:

flatMapToFloat

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

Type Parameters:

R -

Parameters:

mapper -

Returns:

flatMapToDouble

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

Type Parameters:

R -

Parameters:

mapper -

Returns:

mapPartial

@Beta
@IntermediateOp
public <R> ExceptionalStream<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 ExceptionalStream<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 ExceptionalStream<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 ExceptionalStream<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> ExceptionalStream<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 ExceptionalStream<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 ExceptionalStream<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 ExceptionalStream<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> ExceptionalStream<R,E> mapMulti(Throwables.BiConsumer<? super T,? super Consumer<R>,? extends E> mapper)

slidingMap

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

Type Parameters:

R -

Parameters:

mapper -

Returns:

slidingMap

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

Type Parameters:

R -

Parameters:

mapper -

increment -

Returns:

slidingMap

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

Type Parameters:

R -

Parameters:

mapper -

increment -

ignoreNotPaired -

Returns:

slidingMap

@IntermediateOp
public <R> ExceptionalStream<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> ExceptionalStream<R,E> slidingMap(Throwables.TriFunction<? super T,? super T,? super T,R,? extends E> mapper,
 int increment)

Type Parameters:

R -

Parameters:

mapper -

increment -

Returns:

slidingMap

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

Type Parameters:

R -

Parameters:

mapper -

increment -

ignoreNotPaired -

Returns:

groupBy

@IntermediateOp
@TerminalOpTriggered
public <K>
ExceptionalStream<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>
ExceptionalStream<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>
ExceptionalStream<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>
ExceptionalStream<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> ExceptionalStream<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> ExceptionalStream<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,
A,
D> ExceptionalStream<Map.Entry<K,D>,E> groupBy(Throwables.Function<? super T,? extends K,? extends E> keyMapper,
 Collector<? super T,A,D> downstream)

Type Parameters:

K - the key type

A -

D -

Parameters:

keyMapper -

downstream -

Returns:

Throws:

E - the e

groupBy

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

Type Parameters:

K - the key type

A -

D -

Parameters:

keyMapper -

downstream -

mapFactory -

Returns:

Throws:

E - the e

groupBy

@IntermediateOp
@TerminalOpTriggered
public <K,
V,
A,
D>
ExceptionalStream<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,A,D> downstream)

Type Parameters:

K - the key type

V - the value type

A -

D -

Parameters:

keyMapper -

valueMapper -

downstream -

Returns:

Throws:

E - the e

groupBy

@IntermediateOp
@TerminalOpTriggered
public <K,
V,
A,
D>
ExceptionalStream<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,A,D> downstream,
 Supplier<? extends Map<K,D>> mapFactory)

Type Parameters:

K - the key type

V - the value type

A -

D -

Parameters:

keyMapper -

valueMapper -

downstream -

mapFactory -

Returns:

Throws:

E - the e

partitionBy

@IntermediateOp
@TerminalOpTriggered
public ExceptionalStream<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 <A,
D>
ExceptionalStream<Map.Entry<Boolean,D>,E> partitionBy(Throwables.Predicate<? super T,E> predicate,
 Collector<? super T,A,D> downstream)

Parameters:

predicate -

downstream -

Returns:

See Also:

• Collectors.partitioningBy(Predicate, Collector)

countBy

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

Type Parameters:

K -

Parameters:

keyMapper -

Returns:

collapse

@IntermediateOp
public ExceptionalStream<Stream<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>>
ExceptionalStream<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 ExceptionalStream<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:

 
 ExceptionalStream.of(new Integer[0]).collapse((p, c) -> p < c, (r, c) -> r + c) => []
 ExceptionalStream.of(1).collapse((p, c) -> p < c, (r, c) -> r + c) => [1]
 ExceptionalStream.of(1, 2).collapse((p, c) -> p < c, (r, c) -> r + c) => [3]
 ExceptionalStream.of(1, 2, 3).collapse((p, c) -> p < c, (r, c) -> r + c) => [6]
 ExceptionalStream.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> ExceptionalStream<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> ExceptionalStream<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,
A> ExceptionalStream<R,E> collapse(Throwables.BiPredicate<? super T,? super T,? extends E> collapsible,
 Collector<? super T,A,R> collector)

Type Parameters:

R -

A -

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 ExceptionalStream<Stream<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>>
ExceptionalStream<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 ExceptionalStream<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> ExceptionalStream<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> ExceptionalStream<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,
A> ExceptionalStream<R,E> collapse(Throwables.TriPredicate<? super T,? super T,? super T,? extends E> collapsible,
 Collector<? super T,A,R> collector)

Merge series of adjacent elements which satisfy the given predicate using the merger function and return a new stream.

Example:

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

Type Parameters:

R -

A -

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 ExceptionalStream<T,E> scan(Throwables.BiFunction<? super T,? super T,T,? extends E> accumulator)

Parameters:

accumulator -

Returns:

scan

@IntermediateOp
public <U> ExceptionalStream<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> ExceptionalStream<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 ExceptionalStream<T,E> intersection(Collection<?> c)

Parameters:

c -

Returns:

See Also:

• N.intersection(Collection, Collection)

intersection

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

Parameters:

mapper -

c -

Returns:

See Also:

• N.intersection(Collection, Collection)

difference

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

Parameters:

c -

Returns:

See Also:

• N.difference(Collection, Collection)

difference

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

Parameters:

mapper -

c -

Returns:

See Also:

• N.difference(Collection, Collection)

symmetricDifference

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

Parameters:

c -

Returns:

See Also:

• N.symmetricDifference(Collection, Collection)

defaultIfEmpty

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

Parameters:

defaultValue -

Returns:

See Also:

• appendIfEmpty(Object...)

defaultIfEmpty

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

Parameters:

supplier -

Returns:

See Also:

• appendIfEmpty(Throwables.Supplier)

prepend

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

prepend

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

prepend

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

Parameters:

s -

Returns:

append

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

append

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

append

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

Parameters:

s -

Returns:

appendIfEmpty

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

appendIfEmpty

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

appendIfEmpty

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

Append if empty.

Parameters:

supplier -

Returns:

Throws:

E - the e

throwIfEmpty

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

applyIfNotEmpty

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

Throws:

E extends Exception

E2 extends Exception

acceptIfNotEmpty

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

Throws:

E extends Exception

E2 extends Exception

onEach

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

Parameters:

action -

Returns:

peek

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

Parameters:

action -

Returns:

peekFirst

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

peekLast

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

peekIf

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

Parameters:

predicate -

action -

Returns:

peekIf

@Beta
@IntermediateOp
public ExceptionalStream<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 ExceptionalStream<Stream<T>,E> split(int chunkSize)

Parameters:

chunkSize -

Returns:

splitToList

@IntermediateOp
public ExceptionalStream<List<T>,E> splitToList(int chunkSize)

Returns ExceptionalStream 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 ExceptionalStream<Set<T>,E> splitToSet(int chunkSize)

Returns ExceptionalStream 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>>
ExceptionalStream<C,E> split(int chunkSize,
 IntFunction<? extends C> collectionSupplier)

Returns ExceptionalStream 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,
A> ExceptionalStream<R,E> split(int chunkSize,
 Collector<? super T,A,R> collector)

Type Parameters:

R -

A -

Parameters:

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

collector -

Returns:

splitAt

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

splitAt

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

sliding

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

Parameters:

windowSize -

increment -

Returns:

slidingToList

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

Sliding to list.

Parameters:

windowSize -

increment -

Returns:

slidingToSet

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

Sliding to set.

Parameters:

windowSize -

increment -

Returns:

sliding

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

Type Parameters:

C -

Parameters:

windowSize -

increment -

collectionSupplier -

Returns:

sliding

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

Type Parameters:

A -

R -

Parameters:

windowSize -

increment -

collector -

Returns:

skip

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

Parameters:

n -

Returns:

skipNull

@IntermediateOp
public ExceptionalStream<T,E> skipNull()

limit

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

Parameters:

maxSize -

Returns:

top

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

top

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

last

@Beta
@IntermediateOp
public ExceptionalStream<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 ExceptionalStream<T,E> skipLast(int n)

reversed

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

rotated

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

shuffled

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

shuffled

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

sorted

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

sorted

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

Parameters:

comparator -

Returns:

sortedBy

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

Parameters:

keyMapper -

Returns:

reverseSorted

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

reverseSorted

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

cycled

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

cycled

@SequentialOnly
@IntermediateOp
public ExceptionalStream<T,E> cycled(long times)

rateLimited

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

Parameters:

rateLimiter -

Returns:

rateLimited

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

Parameters:

permitsPerSecond -

Returns:

See Also:

• RateLimiter.create(double)

intersperse

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

step

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

indexed

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

mergeWith

@IntermediateOp
public ExceptionalStream<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 ExceptionalStream<T,E> mergeWith(ExceptionalStream<? 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> ExceptionalStream<R,E> zipWith(Collection<T2> b,
 Throwables.BiFunction<? super T,? super T2,R,? extends E> zipFunction)

Type Parameters:

T2 -

R -

Parameters:

b -

zipFunction -

Returns:

zipWith

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

Type Parameters:

T2 -

R -

Parameters:

b -

valueForNoneA -

valueForNoneB -

zipFunction -

Returns:

zipWith

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

Type Parameters:

T2 -

T3 -

R -

Parameters:

b -

c -

zipFunction -

Returns:

zipWith

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

Type Parameters:

T2 -

T3 -

R -

Parameters:

b -

c -

valueForNoneA -

valueForNoneB -

valueForNoneC -

zipFunction -

Returns:

zipWith

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

Type Parameters:

T2 -

R -

Parameters:

b -

zipFunction -

Returns:

zipWith

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

Type Parameters:

T2 -

R -

Parameters:

b -

valueForNoneA -

valueForNoneB -

zipFunction -

Returns:

zipWith

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

Type Parameters:

T2 -

T3 -

R -

Parameters:

b -

c -

zipFunction -

Returns:

zipWith

@IntermediateOp
public <T2,
T3,
R> ExceptionalStream<R,E> zipWith(ExceptionalStream<T2,E> b,
 ExceptionalStream<T3,E> c,
 T valueForNoneA,
 T2 valueForNoneB,
 T3 valueForNoneC,
 Throwables.TriFunction<? super T,? super T2,? super T3,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.IndexedConsumer<? 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, com.landawn.abacus.util.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(com.landawn.abacus.util.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 Collection<? 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 Collection<T2>,E2> flatMapper,
 Throwables.Function<? super T2,? extends Collection<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(Throwables.BiConsumer<? super T,? super T,E2> action,
 int increment)
                                        throws E,
E2

For each pair.

Type Parameters:

E2 -

Parameters:

action -

increment -

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(Throwables.TriConsumer<? super T,? super T,? super T,E2> action,
 int increment)
                                          throws E,
E2

For each triple.

Type Parameters:

E2 -

Parameters:

action -

increment -

Throws:

E - the e

E2 - the e2

forEachInParallel

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

Type Parameters:

E2 -

Parameters:

action -

Throws:

E - the e

E2 - the e2

forEachInParallel

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

Type Parameters:

E2 -

Parameters:

action -

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(com.landawn.abacus.util.Throwables.Predicate)

containsAll

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

Throws:

E extends Exception

containsAll

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

Throws:

E extends Exception

containsAny

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

Throws:

E extends Exception

containsAny

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

Throws:

E extends Exception

hasDuplicates

@TerminalOp
public boolean hasDuplicates()
                      throws E

Throws:

E extends Exception

kthLargest

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

Throws:

E extends Exception

percentiles

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

Throws:

E extends Exception

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 DuplicatedResultException,
E

Returns:

Throws:

DuplicatedResultException - 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

toListAndThen

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

Throws:

E extends Exception

E2 extends Exception

toSetAndThen

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

Throws:

E extends Exception

E2 extends Exception

toCollectionAndThen

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

Throws:

E extends Exception

E2 extends Exception

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

Parameters:

keyMapper -

valueMapper -

Returns:

Throws:

E - the e

IllegalStateException - if there are duplicated keys.

E2 extends Exception

E3 extends Exception

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

Parameters:

keyMapper -

valueMapper -

mergeFunction -

Returns:

Throws:

E - the e

E2 extends Exception

E3 extends Exception

E4 extends Exception

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

Parameters:

keyMapper -

valueMapper -

Returns:

Throws:

E - the e

IllegalStateException - if there are duplicated keys.

E2 extends Exception

E3 extends Exception

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 -

Parameters:

keyMapper -

valueMapper -

mapFactory -

Returns:

Throws:

E - the e

IllegalStateException - if there are duplicated keys.

E2 extends Exception

E3 extends Exception

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

Parameters:

keyMapper -

valueMapper -

mergeFunction -

Returns:

Throws:

E - the e

E2 extends Exception

E3 extends Exception

E4 extends Exception

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 -

Parameters:

keyMapper -

valueMapper -

mergeFunction -

mapFactory -

Returns:

Throws:

E - the e

E2 extends Exception

E3 extends Exception

E4 extends Exception

toMap

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

Deprecated.

replaced by groupTo

Parameters:

keyMapper -

downstream -

Returns:

Throws:

E extends Exception

E2 extends Exception

See Also:

• groupTo(com.landawn.abacus.util.Throwables.Function, Collector)

toMap

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

Deprecated.

replaced by groupTo

Parameters:

keyMapper -

downstream -

mapFactory -

Returns:

Throws:

E extends Exception

E2 extends Exception

See Also:

• groupTo(com.landawn.abacus.util.Throwables.Function, Collector, Supplier)

toMap

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

Deprecated.

replaced by groupTo

Parameters:

keyMapper -

valueMapper -

downstream -

Returns:

Throws:

E extends Exception

E2 extends Exception

E3 extends Exception

See Also:

• groupTo(com.landawn.abacus.util.Throwables.Function, com.landawn.abacus.util.Throwables.Function, Collector)

toMap

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

Deprecated.

replaced by groupTo

Parameters:

keyMapper -

valueMapper -

downstream -

mapFactory -

Returns:

Throws:

E extends Exception

E2 extends Exception

E3 extends Exception

See Also:

• groupTo(com.landawn.abacus.util.Throwables.Function, com.landawn.abacus.util.Throwables.Function, Collector, Supplier)

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

Parameters:

keyMapper -

Returns:

Throws:

E - the e

E2 extends Exception

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 -

Parameters:

keyMapper -

mapFactory -

Returns:

Throws:

E - the e

E2 extends Exception

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

Parameters:

keyMapper -

valueMapper -

Returns:

Throws:

E - the e

E2 extends Exception

E3 extends Exception

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 -

Parameters:

keyMapper -

valueMapper -

mapFactory -

Returns:

Throws:

E - the e

E2 extends Exception

E3 extends Exception

See Also:

• Collectors.toMultimap(Function, Function, Supplier)

groupTo

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

Type Parameters:

K - the key type

A -

D -

Parameters:

keyMapper -

downstream -

Returns:

Throws:

E - the e

E2 extends Exception

groupTo

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

Type Parameters:

K - the key type

A -

D -

M -

Parameters:

keyMapper -

downstream -

mapFactory -

Returns:

Throws:

E - the e

E2 extends Exception

groupTo

@TerminalOp
public <K,
V,
A,
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,A,D> downstream)
          throws E,
E2,
E3

Type Parameters:

K - the key type

V - the value type

A -

D -

Parameters:

keyMapper -

valueMapper -

downstream -

Returns:

Throws:

E - the e

E2 extends Exception

E3 extends Exception

groupTo

@TerminalOp
public <K,
V,
A,
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,A,D> downstream,
 Supplier<? extends M> mapFactory)
   throws E,
E2,
E3

Type Parameters:

K - the key type

V - the value type

A -

D -

M -

Parameters:

keyMapper -

valueMapper -

downstream -

mapFactory -

Returns:

Throws:

E - the e

E2 extends Exception

E3 extends Exception

partitionTo

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

Parameters:

predicate -

Returns:

Throws:

E extends Exception

E2 extends Exception

See Also:

• Collectors.partitioningBy(Predicate)

partitionTo

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

Parameters:

predicate -

downstream -

Returns:

Throws:

E extends Exception

E2 extends Exception

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

Throws:

E extends Exception

E2 extends Exception

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

Throws:

E extends Exception

E2 extends Exception

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

Throws:

E extends Exception

E2 extends Exception

E3 extends Exception

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

Throws:

E extends Exception

E2 extends Exception

E3 extends Exception

toMultiset

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

Throws:

E extends Exception

toMultiset

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

Throws:

E extends Exception

toLongMultiset

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

Throws:

E extends Exception

toLongMultiset

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

Throws:

E extends Exception

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

Parameters:

columnNames -

Returns:

Throws:

E

sumInt

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

Parameters:

func -

Returns:

Throws:

E - the e

E2 extends Exception

sumLong

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

Parameters:

func -

Returns:

Throws:

E - the e

E2 extends Exception

sumDouble

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

Parameters:

func -

Returns:

Throws:

E - the e

E2 extends Exception

averageInt

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

Parameters:

func -

Returns:

Throws:

E - the e

E2 extends Exception

averageLong

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

Parameters:

func -

Returns:

Throws:

E - the e

E2 extends Exception

averageDouble

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

Parameters:

func -

Returns:

Throws:

E - the e

E2 extends Exception

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,
A> R collect(Collector<? super T,A,R> collector)
                throws E

Type Parameters:

R -

A -

Parameters:

collector -

Returns:

Throws:

E - the e

collectAndThen

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

Collect and then.

Type Parameters:

R -

RR -

A -

E2 -

Parameters:

collector -

func -

Returns:

Throws:

E - the e

E2 - the e2

join

@TerminalOp
public String join(CharSequence delimiter)
            throws E

Throws:

E extends Exception

join

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

Throws:

E extends Exception

persist

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

Throws:

E extends Exception

IOException

persist

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

Throws:

E extends Exception

IOException

persist

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

toCSV:

 final JSONSerializationConfig jsc = JSC.create().setBracketRootValue(false);
 final Throwables.Function<? super T, String, IOException> toLine = it -> N.toJSON(it, jsc);
 stream.persist(toLine, header, outputFile);
 

Parameters:

toLine -

file -

Returns:

Throws:

E

IOException

persist

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

Throws:

E extends Exception

IOException

persist

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

Throws:

E extends Exception

IOException

persist

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

toCSV:

 final JSONSerializationConfig jsc = JSC.create().setBracketRootValue(false);
 final Throwables.Function<? super T, String, IOException> toLine = it -> N.toJSON(it, jsc);
 stream.persist(toLine, header, outputFile);
 

Parameters:

toLine -

writer -

Returns:

Throws:

E

IOException

persist

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

Throws:

E extends Exception

IOException

persist

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

Throws:

E extends Exception

IOException

persist

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

Throws:

E extends Exception

IOException

persist

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

Throws:

E extends Exception

IOException

persist

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

Throws:

E extends Exception

IOException

persist

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

Throws:

E extends Exception

SQLException

persist

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

Throws:

E extends Exception

SQLException

persistToCSV

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

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

Parameters:

file -

Returns:

Throws:

E

IOException

persistToCSV

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

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

Parameters:

csvHeaders -

file -

Returns:

Throws:

E

IOException

persistToCSV

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

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

Parameters:

os -

Returns:

Throws:

E

IOException

persistToCSV

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

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

Parameters:

csvHeaders -

os -

Returns:

Throws:

E

IOException

persistToCSV

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

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

Parameters:

writer -

Returns:

Throws:

E

IOException

persistToCSV

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

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

Parameters:

headers -

writer -

Returns:

Throws:

E

IOException

println

@Beta
@TerminalOp
public void println()
             throws E

Throws:

E extends Exception

unchecked

@IntermediateOp
public Stream<T> unchecked()

toJdkStream

@IntermediateOp
public Stream<T> toJdkStream()

cast

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

__

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

Type Parameters:

SS -

Parameters:

transfer -

Returns:

Throws:

E - the e

sps

@Beta
@IntermediateOp
public <R> ExceptionalStream<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> ExceptionalStream<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 ExceptionalStream<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> ExceptionalStream<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> ExceptionalStream<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> ExceptionalStream<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 ExceptionalStream<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 ExceptionalStream<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:

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

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

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

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

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

R -

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

R -

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> ExceptionalStream<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> ExceptionalStream<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 ExceptionalStream<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 ExceptionalStream<T,Exception> filterE(Throwables.Predicate<? super T,? extends Exception> predicate)

Parameters:

predicate -

Returns:

mapE

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

Type Parameters:

U -

Parameters:

mapper -

Returns:

flatMapE

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

Type Parameters:

R -

Parameters:

mapper -

Returns:

flatmapE

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

Type Parameters:

R -

Parameters:

mapper -

Returns:

onEachE

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

Parameters:

action -

Returns:

asyncRun

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

Parameters:

terminalAction - a terminal operation should be called.

Returns:

asyncRun

@Beta
@TerminalOp
public ContinuableFuture<Void> asyncRun(Throwables.Consumer<? super ExceptionalStream<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 ExceptionalStream<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 ExceptionalStream<T,E>,R,? extends Exception> terminalAction,
 Executor executor)

Type Parameters:

R -

Parameters:

terminalAction - a terminal operation should be called.

executor -

Returns:

onClose

@IntermediateOp
public ExceptionalStream<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

Throws:

E - the e