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:

Collectors, Fn.Fnn, Comparators

Nested Class Summary

Nested Classes

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

Method Summary

Modifier and Type	Method and Description
<TT,EE extends Exception> ExceptionalStream<TT,EE>	__(Function<? super ExceptionalStream<T,E>,ExceptionalStream<TT,EE>> transfer)
If.OrElse	acceptIfNotEmpty(Throwables.Consumer<? super ExceptionalStream<T,E>,? extends E> action)
boolean	allMatch(Throwables.Predicate<? super T,? extends E> predicate)
boolean	anyMatch(Throwables.Predicate<? super T,? extends E> predicate)
ExceptionalStream<T,E>	append(Collection<? extends T> c)
ExceptionalStream<T,E>	append(ExceptionalStream<T,E> s)
ExceptionalStream<T,E>	append(T... a)
ExceptionalStream<T,E>	appendIfEmpty(Collection<? extends T> c)
ExceptionalStream<T,E>	appendIfEmpty(Supplier<? extends ExceptionalStream<T,E>> supplier) Append if empty.
ExceptionalStream<T,E>	appendIfEmpty(T... a)
<R> u.Optional<R>	applyIfNotEmpty(Throwables.Function<? super ExceptionalStream<T,E>,R,? extends E> func)
u.OptionalDouble	averageDouble(Throwables.ToDoubleFunction<? super T,? extends E> func)
u.OptionalDouble	averageInt(Throwables.ToIntFunction<? super T,? extends E> func)
u.OptionalDouble	averageLong(Throwables.ToLongFunction<? super T,? extends E> func)
void	close()
<R,A> ExceptionalStream<R,E>	collapse(Throwables.BiPredicate<? super T,? super T,? extends E> collapsible, Collector<? super T,A,R> collector)
<C extends Collection<T>> ExceptionalStream<C,E>	collapse(Throwables.BiPredicate<? super T,? super T,? extends E> collapsible, Supplier<? extends C> supplier)
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)
<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)
<R,A> R	collect(Collector<? super T,A,R> collector)
<R,E2 extends Exception,E3 extends Exception> R	collect(Throwables.Supplier<R,? extends E2> supplier, Throwables.BiConsumer<? super R,? super T,? extends E3> accumulator)
<R,RR,E2 extends Exception,E3 extends Exception,E4 extends Exception> RR	collect(Throwables.Supplier<R,? extends E2> supplier, Throwables.BiConsumer<? super R,? super T,? extends E3> accumulator, Throwables.Function<? super R,? extends RR,? extends E4> finisher)
<R,RR,A,E2 extends Exception> RR	collectAndThen(Collector<? super T,A,R> collector, Throwables.Function<? super R,? extends RR,? extends E2> func) Collect and then.
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(Collection<? extends T>... a)
static <T,E extends Exception> ExceptionalStream<T,E>	concat(ExceptionalStream<? extends T,E>... a)
static <T,E extends Exception> ExceptionalStream<T,E>	concat(T[]... a)
boolean	containsAll(Collection<? extends T> c)
boolean	containsAll(T... a)
boolean	containsAny(Collection<? extends T> c)
boolean	containsAny(T... a)
long	count()
<K> ExceptionalStream<Map.Entry<K,Integer>,E>	countBy(Throwables.Function<? super T,? extends K,? extends E> keyMapper)
<U> ExceptionalStream<Pair<T,U>,E>	crossJoin(Collection<? extends U> b)
<U,R> ExceptionalStream<R,E>	crossJoin(Collection<? extends U> b, Throwables.BiFunction<? super T,? super U,R,? extends E> func)
<U,R> ExceptionalStream<R,E>	crossJoin(ExceptionalStream<? extends U,E> b, Throwables.BiFunction<? super T,? super U,R,? extends E> func)
ExceptionalStream<T,E>	defaultIfEmpty(Supplier<? extends ExceptionalStream<T,E>> supplier)
ExceptionalStream<T,E>	defaultIfEmpty(T defaultValue)
ExceptionalStream<T,E>	difference(Collection<?> c)
ExceptionalStream<T,E>	difference(Function<? super T,?> mapper, Collection<?> c)
ExceptionalStream<T,E>	distinct() 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)
u.Optional<T>	findAny(Throwables.Predicate<? super T,E> predicate)
u.Optional<T>	findFirst(Throwables.Predicate<? super T,E> predicate)
u.Optional<T>	findLast(Throwables.Predicate<? super T,E> 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 ExceptionalStream<? extends R,? extends E>,? extends E> mapper)
<R> ExceptionalStream<R,E>	flatMapp(Throwables.Function<? super T,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,? extends Collection<? extends R>,? extends E> mapper)
<E2 extends Exception> void	forEach(Throwables.Consumer<? super T,? extends E2> action)
<E2 extends Exception,E3 extends Exception> void	forEach(Throwables.Consumer<? super T,? extends E2> action, Throwables.Runnable<? extends E3> onComplete)
<U,E2 extends Exception,E3 extends Exception> void	forEach(Throwables.Function<? super T,? extends Collection<? extends U>,? extends E2> flatMapper, Throwables.BiConsumer<? super T,? super U,? extends E3> action)
<T2,T3,E2 extends Exception,E3 extends Exception,E4 extends Exception> void	forEach(Throwables.Function<? super T,? extends Collection<T2>,? extends E2> flatMapper, Throwables.Function<? super T2,? extends Collection<T3>,? extends E3> flatMapper2, Throwables.TriConsumer<? super T,? super T2,? super T3,? extends E4> action)
<E2 extends Exception> void	forEachIndexed(Throwables.IndexedConsumer<? super T,? extends E2> action)
<E2 extends Exception> void	forEachPair(Throwables.BiConsumer<? super T,? super T,? extends E2> action) For each pair.
<E2 extends Exception> void	forEachPair(Throwables.BiConsumer<? super T,? super T,? extends E2> action, int increment) For each pair.
void	forEachToBreak(MutableBoolean flagToBreak, Throwables.Consumer<? super T,E> action)
void	forEachToBreak(Throwables.BiConsumer<? super T,MutableBoolean,E> action)
<E2 extends Exception> void	forEachTriple(Throwables.TriConsumer<? super T,? super T,? super T,? extends E2> action) For each triple.
<E2 extends Exception> void	forEachTriple(Throwables.TriConsumer<? super T,? super T,? super T,? extends E2> action, int increment) For each triple.
static <T,E extends Exception> ExceptionalStream<T,E>	from(Throwables.Supplier<ExceptionalStream<? extends T,? extends E>,? extends E> supplier) Lazy evaluation.
<K> ExceptionalStream<Pair<T,T>,E>	fullJoin(Collection<? extends T> b, Throwables.Function<? super T,? extends K,? extends E> keyMapper)
<K,R> ExceptionalStream<R,E>	fullJoin(Collection<? extends T> b, Throwables.Function<? super T,? extends K,? extends E> keyMapper, Throwables.BiFunction<? super T,? super T,R,? extends E> func)
<U> ExceptionalStream<Pair<T,U>,E>	fullJoin(Collection<? extends U> b, Throwables.BiPredicate<? super T,? super U,? extends E> predicate)
<U,K> ExceptionalStream<Pair<T,U>,E>	fullJoin(Collection<? extends U> b, Throwables.Function<? super T,? extends K,? extends E> leftKeyMapper, Throwables.Function<? super U,? extends K,? extends E> rightKeyMapper)
<U,K,R> ExceptionalStream<R,E>	fullJoin(Collection<? extends U> b, Throwables.Function<? super T,? extends K,? extends E> leftKeyMapper, Throwables.Function<? super U,? extends K,? extends E> rightKeyMapper, Throwables.BiFunction<? super T,? super U,R,? extends E> func)
<U,K,R> ExceptionalStream<R,E>	fullJoin(ExceptionalStream<? extends U,E> b, Throwables.Function<? super T,? extends K,? extends E> leftKeyMapper, Throwables.Function<? super U,? extends K,? extends E> rightKeyMapper, Throwables.BiFunction<? super T,? super U,R,? extends E> func)
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,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> 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,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,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,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> 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> ExceptionalStream<Pair<T,List<T>>,E>	groupJoin(Collection<? extends T> b, Throwables.Function<? super T,? extends K,? extends E> keyMapper)
<K,R> ExceptionalStream<R,E>	groupJoin(Collection<? extends T> b, Throwables.Function<? super T,? extends K,? extends E> keyMapper, Throwables.BiFunction<? super T,? super List<T>,R,? extends E> func)
<U,K> ExceptionalStream<Pair<T,List<U>>,E>	groupJoin(Collection<? extends U> b, Throwables.Function<? super T,? extends K,? extends E> leftKeyMapper, Throwables.Function<? super U,? extends K,? extends E> rightKeyMapper)
<U,K,A,D> ExceptionalStream<Pair<T,D>,E>	groupJoin(Collection<? extends U> b, Throwables.Function<? super T,? extends K,? extends E> leftKeyMapper, Throwables.Function<? super U,? extends K,? extends E> rightKeyMapper, Collector<? super U,A,D> downstream)
<U,K,A,D,R> ExceptionalStream<R,E>	groupJoin(Collection<? extends U> b, Throwables.Function<? super T,? extends K,? extends E> leftKeyMapper, Throwables.Function<? super U,? extends K,? extends E> rightKeyMapper, Collector<? super U,A,D> downstream, Throwables.BiFunction<? super T,? super D,R,? extends E> func)
<U,K,R> ExceptionalStream<R,E>	groupJoin(Collection<? extends U> b, Throwables.Function<? super T,? extends K,? extends E> leftKeyMapper, Throwables.Function<? super U,? extends K,? extends E> rightKeyMapper, Throwables.BiFunction<? super T,? super List<U>,R,? extends E> func)
<U,K> ExceptionalStream<Pair<T,U>,E>	groupJoin(Collection<? extends U> b, Throwables.Function<? super T,? extends K,? extends E> leftKeyMapper, Throwables.Function<? super U,? extends K,? extends E> rightKeyMapper, Throwables.BinaryOperator<U,? extends E> mergeFunction)
<U,K,R> ExceptionalStream<R,E>	groupJoin(Collection<? extends U> b, Throwables.Function<? super T,? extends K,? extends E> leftKeyMapper, Throwables.Function<? super U,? extends K,? extends E> rightKeyMapper, Throwables.BinaryOperator<U,? extends E> mergeFunction, Throwables.BiFunction<? super T,? super U,R,? extends E> func)
<U,K,A,D,R> ExceptionalStream<R,E>	groupJoin(ExceptionalStream<? extends U,E> b, Throwables.Function<? super T,? extends K,? extends E> leftKeyMapper, Throwables.Function<? super U,? extends K,? extends E> rightKeyMapper, Collector<? super U,A,D> downstream, Throwables.BiFunction<? super T,? super D,R,? extends E> func)
<U,K,R> ExceptionalStream<R,E>	groupJoin(ExceptionalStream<? extends U,E> b, Throwables.Function<? super T,? extends K,? extends E> leftKeyMapper, Throwables.Function<? super U,? extends K,? extends E> rightKeyMapper, Throwables.BiFunction<? super T,? super List<U>,R,? extends E> func)
<U,K,R> ExceptionalStream<R,E>	groupJoin(ExceptionalStream<? extends U,E> b, Throwables.Function<? super T,? extends K,? extends E> leftKeyMapper, Throwables.Function<? super U,? extends K,? extends E> rightKeyMapper, Throwables.BinaryOperator<U,? extends E> mergeFunction, Throwables.BiFunction<? super T,? super U,R,? extends E> func)
<K> Map<K,List<T>>	groupTo(Throwables.Function<? super T,? extends K,? extends E> keyMapper)
<K,M extends Map<K,List<T>>> M	groupTo(Throwables.Function<? super T,? extends K,? extends E> keyMapper, Supplier<? extends M> mapFactory)
<K,V> Map<K,List<V>>	groupTo(Throwables.Function<? super T,? extends K,? extends E> keyMapper, Throwables.Function<? super T,? extends V,? extends E> valueMapper)
<K,V,M extends Map<K,List<V>>> M	groupTo(Throwables.Function<? super T,? extends K,? extends E> keyMapper, Throwables.Function<? super T,? extends V,? extends E> valueMapper, Supplier<? extends M> mapFactory)
boolean	hasDuplicates()
ExceptionalStream<Indexed<T>,E>	indexed()
<K> ExceptionalStream<Pair<T,T>,E>	innerJoin(Collection<? extends T> b, Throwables.Function<? super T,? extends K,? extends E> keyMapper)
<K,R> ExceptionalStream<R,E>	innerJoin(Collection<? extends T> b, Throwables.Function<? super T,? extends K,? extends E> keyMapper, Throwables.BiFunction<? super T,? super T,R,? extends E> func)
<U> ExceptionalStream<Pair<T,U>,E>	innerJoin(Collection<? extends U> b, Throwables.BiPredicate<? super T,? super U,? extends E> predicate)
<U,K> ExceptionalStream<Pair<T,U>,E>	innerJoin(Collection<? extends U> b, Throwables.Function<? super T,? extends K,? extends E> leftKeyMapper, Throwables.Function<? super U,? extends K,? extends E> rightKeyMapper)
<U,K,R> ExceptionalStream<R,E>	innerJoin(Collection<? extends U> b, Throwables.Function<? super T,? extends K,? extends E> leftKeyMapper, Throwables.Function<? super U,? extends K,? extends E> rightKeyMapper, Throwables.BiFunction<? super T,? super U,R,? extends E> func)
<U,K,R> ExceptionalStream<R,E>	innerJoin(ExceptionalStream<? extends U,E> b, Throwables.Function<? super T,? extends K,? extends E> leftKeyMapper, Throwables.Function<? super U,? extends K,? extends E> rightKeyMapper, Throwables.BiFunction<? super T,? super U,R,? extends E> func)
ExceptionalStream<T,E>	intersection(Collection<?> c) <<<<<<< .working
ExceptionalStream<T,E>	intersection(Throwables.Function<? super T,?,E> mapper, 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)
<K> ExceptionalStream<Pair<T,T>,E>	leftJoin(Collection<? extends T> b, Throwables.Function<? super T,? extends K,? extends E> keyMapper)
<K,R> ExceptionalStream<R,E>	leftJoin(Collection<? extends T> b, Throwables.Function<? super T,? extends K,? extends E> keyMapper, Throwables.BiFunction<? super T,? super T,R,? extends E> func)
<U> ExceptionalStream<Pair<T,U>,E>	leftJoin(Collection<? extends U> b, Throwables.BiPredicate<? super T,? super U,? extends E> predicate)
<U,K> ExceptionalStream<Pair<T,U>,E>	leftJoin(Collection<? extends U> b, Throwables.Function<? super T,? extends K,? extends E> leftKeyMapper, Throwables.Function<? super U,? extends K,? extends E> rightKeyMapper)
<U,K,R> ExceptionalStream<R,E>	leftJoin(Collection<? extends U> b, Throwables.Function<? super T,? extends K,? extends E> leftKeyMapper, Throwables.Function<? super U,? extends K,? extends E> rightKeyMapper, Throwables.BiFunction<? super T,? super U,R,? extends E> func)
<U,K,R> ExceptionalStream<R,E>	leftJoin(ExceptionalStream<? extends U,E> b, Throwables.Function<? super T,? extends K,? extends E> leftKeyMapper, Throwables.Function<? super U,? extends K,? extends E> rightKeyMapper, Throwables.BiFunction<? super T,? super U,R,? extends E> func)
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(Path path)
static ExceptionalStream<String,IOException>	lines(Path path, Charset charset)
static ExceptionalStream<String,IOException>	lines(Reader reader)
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)
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)
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(Collection<? extends T> a, Collection<? extends T> b, Collection<? extends T> c, Throwables.BiFunction<? super T,? super T,MergeResult,E> nextSelector)
static <T,E extends Exception> ExceptionalStream<T,E>	merge(Collection<? extends T> a, Collection<? extends T> b, 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, 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(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(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(T[] a, T[] b, 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)
ExceptionalStream<T,E>	mergeWith(Collection<? extends T> b, 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)
u.Optional<T>	min(Comparator<? super T> comparator)
u.Optional<T>	minBy(Function<? super T,? extends Comparable> keyMapper)
boolean	nMatch(long atLeast, long atMost, Throwables.Predicate<? super T,? extends E> predicate)
boolean	noneMatch(Throwables.Predicate<? super T,? extends E> predicate)
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 <E extends Exception> ExceptionalStream<Double,E>	of(double[] a)
static <E extends Exception> ExceptionalStream<Integer,E>	of(int[] a)
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(Iterator<? extends T> iter)
static <T,E extends Exception> ExceptionalStream<T,E>	of(Iterator<? extends T> iter, Class<E> exceptionType)
static <E extends Exception> ExceptionalStream<Long,E>	of(long[] a)
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(T... a)
static <T,E extends Exception> ExceptionalStream<T,E>	of(Throwables.Supplier<Collection<? extends T>,? extends E> supplier) Lazy evaluation.
static <T,E extends Exception> ExceptionalStream<T,E>	of(u.Optional<T> op)
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)
u.Optional<T>	onlyOne()
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>	peekLast(Throwables.Consumer<? super T,? extends E> action)
u.Optional<Map<Percentage,T>>	percentiles(Comparator<? super T> comparator)
long	persist(Connection conn, String insertSQL, int batchSize, int batchInterval, Throwables.BiConsumer<? super PreparedStatement,? super T,SQLException> stmtSetter)
long	persist(File file)
long	persist(PreparedStatement stmt, int batchSize, int batchInterval, Throwables.BiConsumer<? super PreparedStatement,? super T,SQLException> stmtSetter)
long	persist(String header, String tail, File file)
long	persist(Throwables.Function<? super T,String,IOException> toLine, File file)
long	persist(Throwables.Function<? super T,String,IOException> toLine, OutputStream os)
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(Throwables.Function<? super T,String,IOException> toLine, Writer writer)
ExceptionalStream<T,E>	prepend(Collection<? extends T> c)
ExceptionalStream<T,E>	prepend(ExceptionalStream<T,E> s)
ExceptionalStream<T,E>	prepend(T... a)
void	println()
<E2 extends Exception> u.Optional<T>	reduce(Throwables.BinaryOperator<T,? extends E2> accumulator)
<U,E2 extends Exception> U	reduce(U identity, Throwables.BiFunction<U,? super T,U,? extends E2> accumulator)
static <T,E extends Exception> ExceptionalStream<T,E>	repeat(T element, long n)
ExceptionalStream<T,E>	reversed()
ExceptionalStream<T,E>	reverseSorted()
<K> ExceptionalStream<Pair<T,T>,E>	rightJoin(Collection<? extends T> b, Throwables.Function<? super T,? extends K,? extends E> keyMapper)
<K,R> ExceptionalStream<R,E>	rightJoin(Collection<? extends T> b, Throwables.Function<? super T,? extends K,? extends E> keyMapper, Throwables.BiFunction<? super T,? super T,R,? extends E> func)
<U> ExceptionalStream<Pair<T,U>,E>	rightJoin(Collection<? extends U> b, Throwables.BiPredicate<? super T,? super U,? extends E> predicate)
<U,K> ExceptionalStream<Pair<T,U>,E>	rightJoin(Collection<? extends U> b, Throwables.Function<? super T,? extends K,? extends E> leftKeyMapper, Throwables.Function<? super U,? extends K,? extends E> rightKeyMapper)
<U,K,R> ExceptionalStream<R,E>	rightJoin(Collection<? extends U> b, Throwables.Function<? super T,? extends K,? extends E> leftKeyMapper, Throwables.Function<? super U,? extends K,? extends E> rightKeyMapper, Throwables.BiFunction<? super T,? super U,R,? extends E> func)
<U,K,R> ExceptionalStream<R,E>	rightJoin(ExceptionalStream<? extends U,E> b, Throwables.Function<? super T,? extends K,? extends E> leftKeyMapper, Throwables.Function<? super U,? extends K,? extends E> rightKeyMapper, Throwables.BiFunction<? super T,? super U,R,? extends E> func)
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)
<A,R> ExceptionalStream<R,E>	sliding(int windowSize, int increment, Collector<? super T,A,R> collector)
<C extends Collection<T>> ExceptionalStream<C,E>	sliding(int windowSize, int increment, IntFunction<? extends C> collectionSupplier)
<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)
<R,A> ExceptionalStream<R,E>	split(int chunkSize, Collector<? super T,A,R> collector)
<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).
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).
u.OptionalDouble	sumDouble(Throwables.ToDoubleFunction<? super T,? extends E> func)
u.OptionalLong	sumInt(Throwables.ToIntFunction<? super T,? extends E> func)
u.OptionalLong	sumLong(Throwables.ToLongFunction<? super T,? extends E> func)
ExceptionalStream<T,E>	symmetricDifference(Collection<T> c)
ExceptionalStream<T,E>	takeWhile(Throwables.Predicate<? super T,? extends E> predicate)
Object[]	toArray()
<A> A[]	toArray(IntFunction<A[]> generator)
<C extends Collection<T>> C	toCollection(Supplier<? extends C> supplier)
<R,CC extends Collection<T>> R	toCollectionAndThen(Supplier<? extends CC> supplier, Throwables.Function<? super CC,R,E> 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()
ImmutableSet<T>	toImmutableSet()
List<T>	toList()
<R> R	toListAndThen(Throwables.Function<? super List<T>,R,E> func)
<K,A,D> Map<K,D>	toMap(Throwables.Function<? super T,? extends K,? extends E> keyMapper, Collector<? super T,A,D> downstream)
<K,A,D,M extends Map<K,D>> M	toMap(Throwables.Function<? super T,? extends K,? extends E> keyMapper, Collector<? super T,A,D> downstream, Supplier<? extends M> mapFactory)
<K,V> Map<K,V>	toMap(Throwables.Function<? super T,? extends K,? extends E> keyMapper, Throwables.Function<? super T,? extends V,? extends E> valueMapper)
<K,V,A,D> Map<K,D>	toMap(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,M extends Map<K,D>> M	toMap(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 M> mapFactory)
<K,V,M extends Map<K,V>> M	toMap(Throwables.Function<? super T,? extends K,? extends E> keyMapper, Throwables.Function<? super T,? extends V,? extends E> valueMapper, Supplier<? extends M> mapFactory)
<K,V> Map<K,V>	toMap(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,M extends Map<K,V>> M	toMap(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 M> mapFactory)
<K> ListMultimap<K,T>	toMultimap(Throwables.Function<? super T,? extends K,? extends E> keyMapper)
<K,V extends Collection<T>,M extends Multimap<K,T,V>> M	toMultimap(Throwables.Function<? super T,? extends K,? extends E> keyMapper, Supplier<? extends M> mapFactory)
<K,V> ListMultimap<K,V>	toMultimap(Throwables.Function<? super T,? extends K,? extends E> keyMapper, Throwables.Function<? super T,? extends V,? extends E> valueMapper)
<K,V,C extends Collection<V>,M extends Multimap<K,V,C>> M	toMultimap(Throwables.Function<? super T,? extends K,? extends E> keyMapper, Throwables.Function<? super T,? extends V,? extends E> valueMapper, 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> R	toSetAndThen(Throwables.Function<? super Set<T>,R,E> func)
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(Collection<? extends A> a, Collection<? 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,C,T,E extends Exception> ExceptionalStream<T,E>	zip(Collection<? extends A> a, Collection<? extends B> b, Collection<? 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(Collection<? extends A> a, Collection<? extends B> b, Collection<? 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(Collection<? extends A> a, Collection<? 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,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(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,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.
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.
<T2,R> ExceptionalStream<R,E>	zipWith(Collection<T2> b, Throwables.BiFunction<? super T,? super T2,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)
<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)

Methods inherited from class java.lang.Object

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

Method Detail

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

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

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

Parameters:

supplier -

Returns:

from

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

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

Parameters:

supplier -

Returns:

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)

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)

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(Collection<? 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(Collection<? extends A> a,
                                                                     Collection<? 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(Collection<? extends A> a,
                                                                       Collection<? extends B> b,
                                                                       Collection<? 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(Collection<? extends A> a,
                                                                     Collection<? 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(Collection<? extends A> a,
                                                                       Collection<? extends B> b,
                                                                       Collection<? 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(Collection<? extends T> a,
                                                                   Collection<? 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(Collection<? extends T> a,
                                                                   Collection<? extends T> b,
                                                                   Collection<? 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

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

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.Predicate<? super Long,? extends E> occurrencesFilter)

Distinct and filter by occurrences.

Parameters:

keyMapper -

occurrencesFilter -

Returns:

See Also:

#groupBy(Function, Collector)

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 -

occurrencesFilter -

Returns:

See Also:

#groupBy(Function, Function, BinaryOperator)

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:

flattMap

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

Type Parameters:

R -

Parameters:

mapper -

Returns:

flatMapp

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

Type Parameters:

R -

Parameters:

mapper -

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:

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:

See Also:

Fn.Fnn#throwingMerger()}, Fn.Fnn#replacingMerger()}, Fn.Fnn#ignoringMerger()}

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

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

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:

 
 Stream.of(new Integer[0]).collapse((a, b) -> a < b, (a, b) -> a + b) => []
 Stream.of(1).collapse((a, b) -> a < b, (a, b) -> a + b) => [1]
 Stream.of(1, 2).collapse((a, b) -> a < b, (a, b) -> a + b) => [3]
 Stream.of(1, 2, 3).collapse((a, b) -> a < b, (a, b) -> a + b) => [6]
 Stream.of(1, 2, 3, 3, 2, 1).collapse((a, b) -> a < b, (a, b) -> a + b) => [6, 3, 2, 1]
 
 

This method only run sequentially, even in parallel stream.

Parameters:

collapsible -

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 -

init -

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 -

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 -

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)

<<<<<<< .working

Parameters:

c -

Returns:

See Also:

N.intersection(Collection, Collection)

intersection

public ExceptionalStream<T,E> intersection(Throwables.Function<? super T,?,E> mapper,
                                           Collection<?> 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 ExceptionalStream<T,E> difference(Function<? super T,?> mapper,
                                         Collection<?> 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(Supplier<? extends ExceptionalStream<T,E>> supplier)

Parameters:

supplier -

Returns:

See Also:

appendIfEmpty(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(Supplier<? extends ExceptionalStream<T,E>> supplier)

Append if empty.

Parameters:

supplier -

Returns:

Throws:

E - the e

applyIfNotEmpty

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

Throws:

E extends Exception

acceptIfNotEmpty

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

Throws:

E 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)

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:

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

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

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()

reverseSorted

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

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:

intersperse

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

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

crossJoin

@IntermediateOp
public <U> ExceptionalStream<Pair<T,U>,E> crossJoin(Collection<? extends U> b)

Type Parameters:

U -

Parameters:

b -

Returns:

crossJoin

@IntermediateOp
public <U,R> ExceptionalStream<R,E> crossJoin(Collection<? extends U> b,
                                                               Throwables.BiFunction<? super T,? super U,R,? extends E> func)

Type Parameters:

U -

R -

Parameters:

b -

func -

Returns:

crossJoin

@IntermediateOp
public <U,R> ExceptionalStream<R,E> crossJoin(ExceptionalStream<? extends U,E> b,
                                                               Throwables.BiFunction<? super T,? super U,R,? extends E> func)

Type Parameters:

U -

R -

Parameters:

b -

func -

Returns:

innerJoin

@IntermediateOp
public <U,K> ExceptionalStream<Pair<T,U>,E> innerJoin(Collection<? extends U> b,
                                                                       Throwables.Function<? super T,? extends K,? extends E> leftKeyMapper,
                                                                       Throwables.Function<? super U,? extends K,? extends E> rightKeyMapper)

Type Parameters:

U -

K -

Parameters:

b -

leftKeyMapper -

rightKeyMapper -

Returns:

innerJoin

@IntermediateOp
public <U,K,R> ExceptionalStream<R,E> innerJoin(Collection<? extends U> b,
                                                                 Throwables.Function<? super T,? extends K,? extends E> leftKeyMapper,
                                                                 Throwables.Function<? super U,? extends K,? extends E> rightKeyMapper,
                                                                 Throwables.BiFunction<? super T,? super U,R,? extends E> func)

Type Parameters:

U -

K -

R -

Parameters:

b -

leftKeyMapper -

rightKeyMapper -

func -

Returns:

innerJoin

public <K> ExceptionalStream<Pair<T,T>,E> innerJoin(Collection<? extends T> b,
                                                    Throwables.Function<? super T,? extends K,? extends E> keyMapper)

Type Parameters:

K -

Parameters:

b -

keyMapper -

Returns:

innerJoin

@IntermediateOp
public <K,R> ExceptionalStream<R,E> innerJoin(Collection<? extends T> b,
                                                               Throwables.Function<? super T,? extends K,? extends E> keyMapper,
                                                               Throwables.BiFunction<? super T,? super T,R,? extends E> func)

Type Parameters:

K -

R -

Parameters:

b -

keyMapper -

func -

Returns:

innerJoin

@IntermediateOp
public <U,K,R> ExceptionalStream<R,E> innerJoin(ExceptionalStream<? extends U,E> b,
                                                                 Throwables.Function<? super T,? extends K,? extends E> leftKeyMapper,
                                                                 Throwables.Function<? super U,? extends K,? extends E> rightKeyMapper,
                                                                 Throwables.BiFunction<? super T,? super U,R,? extends E> func)

Type Parameters:

U -

K -

R -

Parameters:

b -

leftKeyMapper -

rightKeyMapper -

func -

Returns:

innerJoin

@IntermediateOp
public <U> ExceptionalStream<Pair<T,U>,E> innerJoin(Collection<? extends U> b,
                                                                     Throwables.BiPredicate<? super T,? super U,? extends E> predicate)

Type Parameters:

U -

Parameters:

b -

predicate -

Returns:

fullJoin

@IntermediateOp
public <U,K> ExceptionalStream<Pair<T,U>,E> fullJoin(Collection<? extends U> b,
                                                                      Throwables.Function<? super T,? extends K,? extends E> leftKeyMapper,
                                                                      Throwables.Function<? super U,? extends K,? extends E> rightKeyMapper)

Type Parameters:

K -

U -

Parameters:

b -

leftKeyMapper -

rightKeyMapper -

Returns:

fullJoin

@IntermediateOp
public <U,K,R> ExceptionalStream<R,E> fullJoin(Collection<? extends U> b,
                                                                Throwables.Function<? super T,? extends K,? extends E> leftKeyMapper,
                                                                Throwables.Function<? super U,? extends K,? extends E> rightKeyMapper,
                                                                Throwables.BiFunction<? super T,? super U,R,? extends E> func)

Type Parameters:

K -

U -

R -

Parameters:

b -

leftKeyMapper -

rightKeyMapper -

func -

Returns:

fullJoin

public <K> ExceptionalStream<Pair<T,T>,E> fullJoin(Collection<? extends T> b,
                                                   Throwables.Function<? super T,? extends K,? extends E> keyMapper)

Type Parameters:

K -

Parameters:

b -

keyMapper -

Returns:

fullJoin

@IntermediateOp
public <K,R> ExceptionalStream<R,E> fullJoin(Collection<? extends T> b,
                                                              Throwables.Function<? super T,? extends K,? extends E> keyMapper,
                                                              Throwables.BiFunction<? super T,? super T,R,? extends E> func)

Type Parameters:

K -

R -

Parameters:

b -

keyMapper -

func -

Returns:

fullJoin

@IntermediateOp
public <U,K,R> ExceptionalStream<R,E> fullJoin(ExceptionalStream<? extends U,E> b,
                                                                Throwables.Function<? super T,? extends K,? extends E> leftKeyMapper,
                                                                Throwables.Function<? super U,? extends K,? extends E> rightKeyMapper,
                                                                Throwables.BiFunction<? super T,? super U,R,? extends E> func)

Type Parameters:

K -

U -

R -

Parameters:

b -

leftKeyMapper -

rightKeyMapper -

func -

Returns:

fullJoin

@IntermediateOp
public <U> ExceptionalStream<Pair<T,U>,E> fullJoin(Collection<? extends U> b,
                                                                    Throwables.BiPredicate<? super T,? super U,? extends E> predicate)

Type Parameters:

U -

Parameters:

b -

predicate -

Returns:

leftJoin

@IntermediateOp
public <U,K> ExceptionalStream<Pair<T,U>,E> leftJoin(Collection<? extends U> b,
                                                                      Throwables.Function<? super T,? extends K,? extends E> leftKeyMapper,
                                                                      Throwables.Function<? super U,? extends K,? extends E> rightKeyMapper)

Type Parameters:

K -

U -

Parameters:

b -

leftKeyMapper -

rightKeyMapper -

Returns:

leftJoin

@IntermediateOp
public <U,K,R> ExceptionalStream<R,E> leftJoin(Collection<? extends U> b,
                                                                Throwables.Function<? super T,? extends K,? extends E> leftKeyMapper,
                                                                Throwables.Function<? super U,? extends K,? extends E> rightKeyMapper,
                                                                Throwables.BiFunction<? super T,? super U,R,? extends E> func)

Type Parameters:

K -

U -

R -

Parameters:

b -

leftKeyMapper -

rightKeyMapper -

func -

Returns:

leftJoin

public <K> ExceptionalStream<Pair<T,T>,E> leftJoin(Collection<? extends T> b,
                                                   Throwables.Function<? super T,? extends K,? extends E> keyMapper)

Type Parameters:

K -

Parameters:

b -

keyMapper -

Returns:

leftJoin

@IntermediateOp
public <K,R> ExceptionalStream<R,E> leftJoin(Collection<? extends T> b,
                                                              Throwables.Function<? super T,? extends K,? extends E> keyMapper,
                                                              Throwables.BiFunction<? super T,? super T,R,? extends E> func)

Type Parameters:

K -

R -

Parameters:

b -

keyMapper -

func -

Returns:

leftJoin

@IntermediateOp
public <U,K,R> ExceptionalStream<R,E> leftJoin(ExceptionalStream<? extends U,E> b,
                                                                Throwables.Function<? super T,? extends K,? extends E> leftKeyMapper,
                                                                Throwables.Function<? super U,? extends K,? extends E> rightKeyMapper,
                                                                Throwables.BiFunction<? super T,? super U,R,? extends E> func)

Type Parameters:

K -

U -

R -

Parameters:

b -

leftKeyMapper -

rightKeyMapper -

func -

Returns:

leftJoin

@IntermediateOp
public <U> ExceptionalStream<Pair<T,U>,E> leftJoin(Collection<? extends U> b,
                                                                    Throwables.BiPredicate<? super T,? super U,? extends E> predicate)

Type Parameters:

U -

Parameters:

b -

predicate -

Returns:

rightJoin

@IntermediateOp
public <U,K> ExceptionalStream<Pair<T,U>,E> rightJoin(Collection<? extends U> b,
                                                                       Throwables.Function<? super T,? extends K,? extends E> leftKeyMapper,
                                                                       Throwables.Function<? super U,? extends K,? extends E> rightKeyMapper)

Type Parameters:

K -

U -

Parameters:

b -

leftKeyMapper -

rightKeyMapper -

Returns:

rightJoin

@IntermediateOp
public <U,K,R> ExceptionalStream<R,E> rightJoin(Collection<? extends U> b,
                                                                 Throwables.Function<? super T,? extends K,? extends E> leftKeyMapper,
                                                                 Throwables.Function<? super U,? extends K,? extends E> rightKeyMapper,
                                                                 Throwables.BiFunction<? super T,? super U,R,? extends E> func)

Type Parameters:

K -

U -

R -

Parameters:

b -

leftKeyMapper -

rightKeyMapper -

func -

Returns:

rightJoin

public <K> ExceptionalStream<Pair<T,T>,E> rightJoin(Collection<? extends T> b,
                                                    Throwables.Function<? super T,? extends K,? extends E> keyMapper)

Type Parameters:

K -

Parameters:

b -

keyMapper -

Returns:

rightJoin

@IntermediateOp
public <K,R> ExceptionalStream<R,E> rightJoin(Collection<? extends T> b,
                                                               Throwables.Function<? super T,? extends K,? extends E> keyMapper,
                                                               Throwables.BiFunction<? super T,? super T,R,? extends E> func)

Type Parameters:

K -

R -

Parameters:

b -

keyMapper -

func -

Returns:

rightJoin

@IntermediateOp
public <U,K,R> ExceptionalStream<R,E> rightJoin(ExceptionalStream<? extends U,E> b,
                                                                 Throwables.Function<? super T,? extends K,? extends E> leftKeyMapper,
                                                                 Throwables.Function<? super U,? extends K,? extends E> rightKeyMapper,
                                                                 Throwables.BiFunction<? super T,? super U,R,? extends E> func)

Type Parameters:

K -

U -

R -

Parameters:

b -

leftKeyMapper -

rightKeyMapper -

func -

Returns:

rightJoin

@IntermediateOp
public <U> ExceptionalStream<Pair<T,U>,E> rightJoin(Collection<? extends U> b,
                                                                     Throwables.BiPredicate<? super T,? super U,? extends E> predicate)

Type Parameters:

U -

Parameters:

b -

predicate -

Returns:

groupJoin

@IntermediateOp
public <U,K> ExceptionalStream<Pair<T,List<U>>,E> groupJoin(Collection<? extends U> b,
                                                                             Throwables.Function<? super T,? extends K,? extends E> leftKeyMapper,
                                                                             Throwables.Function<? super U,? extends K,? extends E> rightKeyMapper)

Type Parameters:

U -

K -

Parameters:

b -

leftKeyMapper -

rightKeyMapper -

Returns:

groupJoin

@IntermediateOp
public <U,K,R> ExceptionalStream<R,E> groupJoin(Collection<? extends U> b,
                                                                 Throwables.Function<? super T,? extends K,? extends E> leftKeyMapper,
                                                                 Throwables.Function<? super U,? extends K,? extends E> rightKeyMapper,
                                                                 Throwables.BiFunction<? super T,? super List<U>,R,? extends E> func)

Type Parameters:

U -

K -

R -

Parameters:

b -

leftKeyMapper -

rightKeyMapper -

func -

Returns:

groupJoin

public <K> ExceptionalStream<Pair<T,List<T>>,E> groupJoin(Collection<? extends T> b,
                                                          Throwables.Function<? super T,? extends K,? extends E> keyMapper)

Type Parameters:

K -

Parameters:

b -

keyMapper -

Returns:

groupJoin

@IntermediateOp
public <K,R> ExceptionalStream<R,E> groupJoin(Collection<? extends T> b,
                                                               Throwables.Function<? super T,? extends K,? extends E> keyMapper,
                                                               Throwables.BiFunction<? super T,? super List<T>,R,? extends E> func)

Type Parameters:

K -

R -

Parameters:

b -

keyMapper -

func -

Returns:

groupJoin

@IntermediateOp
public <U,K,R> ExceptionalStream<R,E> groupJoin(ExceptionalStream<? extends U,E> b,
                                                                 Throwables.Function<? super T,? extends K,? extends E> leftKeyMapper,
                                                                 Throwables.Function<? super U,? extends K,? extends E> rightKeyMapper,
                                                                 Throwables.BiFunction<? super T,? super List<U>,R,? extends E> func)

Type Parameters:

U -

K -

R -

Parameters:

b -

leftKeyMapper -

rightKeyMapper -

func -

Returns:

groupJoin

@IntermediateOp
public <U,K> ExceptionalStream<Pair<T,U>,E> groupJoin(Collection<? extends U> b,
                                                                       Throwables.Function<? super T,? extends K,? extends E> leftKeyMapper,
                                                                       Throwables.Function<? super U,? extends K,? extends E> rightKeyMapper,
                                                                       Throwables.BinaryOperator<U,? extends E> mergeFunction)

Type Parameters:

U -

K -

Parameters:

b -

leftKeyMapper -

rightKeyMapper -

mergeFunction -

Returns:

groupJoin

@IntermediateOp
public <U,K,R> ExceptionalStream<R,E> groupJoin(Collection<? extends U> b,
                                                                 Throwables.Function<? super T,? extends K,? extends E> leftKeyMapper,
                                                                 Throwables.Function<? super U,? extends K,? extends E> rightKeyMapper,
                                                                 Throwables.BinaryOperator<U,? extends E> mergeFunction,
                                                                 Throwables.BiFunction<? super T,? super U,R,? extends E> func)

Type Parameters:

U -

K -

R -

Parameters:

b -

leftKeyMapper -

rightKeyMapper -

mergeFunction -

func -

Returns:

groupJoin

@IntermediateOp
public <U,K,R> ExceptionalStream<R,E> groupJoin(ExceptionalStream<? extends U,E> b,
                                                                 Throwables.Function<? super T,? extends K,? extends E> leftKeyMapper,
                                                                 Throwables.Function<? super U,? extends K,? extends E> rightKeyMapper,
                                                                 Throwables.BinaryOperator<U,? extends E> mergeFunction,
                                                                 Throwables.BiFunction<? super T,? super U,R,? extends E> func)

Type Parameters:

U -

K -

R -

Parameters:

b -

leftKeyMapper -

rightKeyMapper -

mergeFunction -

func -

Returns:

groupJoin

@IntermediateOp
public <U,K,A,D> ExceptionalStream<Pair<T,D>,E> groupJoin(Collection<? extends U> b,
                                                                           Throwables.Function<? super T,? extends K,? extends E> leftKeyMapper,
                                                                           Throwables.Function<? super U,? extends K,? extends E> rightKeyMapper,
                                                                           Collector<? super U,A,D> downstream)

Type Parameters:

U -

K -

A -

D -

Parameters:

b -

leftKeyMapper -

rightKeyMapper -

downstream -

Returns:

groupJoin

@IntermediateOp
public <U,K,A,D,R> ExceptionalStream<R,E> groupJoin(Collection<? extends U> b,
                                                                     Throwables.Function<? super T,? extends K,? extends E> leftKeyMapper,
                                                                     Throwables.Function<? super U,? extends K,? extends E> rightKeyMapper,
                                                                     Collector<? super U,A,D> downstream,
                                                                     Throwables.BiFunction<? super T,? super D,R,? extends E> func)

Type Parameters:

U -

K -

A -

D -

R -

Parameters:

b -

leftKeyMapper -

rightKeyMapper -

downstream -

func -

Returns:

groupJoin

@IntermediateOp
public <U,K,A,D,R> ExceptionalStream<R,E> groupJoin(ExceptionalStream<? extends U,E> b,
                                                                     Throwables.Function<? super T,? extends K,? extends E> leftKeyMapper,
                                                                     Throwables.Function<? super U,? extends K,? extends E> rightKeyMapper,
                                                                     Collector<? super U,A,D> downstream,
                                                                     Throwables.BiFunction<? super T,? super D,R,? extends E> func)

Type Parameters:

U -

K -

A -

D -

R -

Parameters:

b -

leftKeyMapper -

rightKeyMapper -

downstream -

func -

Returns:

forEach

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

Type Parameters:

E2 -

Parameters:

action -

Throws:

E - the e

E2 - the e2

E extends Exception

forEachIndexed

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

Type Parameters:

E2 -

Parameters:

action -

Throws:

E - the e

E2 - the e2

E extends Exception

forEachToBreak

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

Throws:

E extends Exception

forEachToBreak

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

Throws:

E extends Exception

forEach

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

Type Parameters:

E2 -

E3 -

Parameters:

action -

onComplete -

Throws:

E - the e

E2 - the e2

E3 - the e3

E extends Exception

forEach

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

Type Parameters:

U -

E2 -

E3 -

Parameters:

flatMapper -

action -

Throws:

E - the e

E2 - the e2

E3 - the e3

E extends Exception

forEach

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

Type Parameters:

T2 -

T3 -

E2 -

E3 -

E4 -

Parameters:

flatMapper -

flatMapper2 -

action -

Throws:

E - the e

E2 - the e2

E3 - the e3

E4 - the e4

E extends Exception

forEachPair

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

For each pair.

Type Parameters:

E2 -

Parameters:

action -

Throws:

E - the e

E2 - the e2

E extends Exception

forEachPair

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

For each pair.

Type Parameters:

E2 -

Parameters:

action -

increment -

Throws:

E - the e

E2 - the e2

E extends Exception

forEachTriple

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

For each triple.

Type Parameters:

E2 -

Parameters:

action -

Throws:

E - the e

E2 - the e2

E extends Exception

forEachTriple

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

For each triple.

Type Parameters:

E2 -

Parameters:

action -

increment -

Throws:

E - the e

E2 - the e2

E extends Exception

min

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

Parameters:

comparator -

Returns:

Throws:

E - the e

E extends Exception

minBy

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

Parameters:

keyMapper -

Returns:

Throws:

E - the e

E extends Exception

max

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

Parameters:

comparator -

Returns:

Throws:

E - the e

E extends Exception

maxBy

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

Parameters:

keyMapper -

Returns:

Throws:

E - the e

E extends Exception

anyMatch

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

Parameters:

predicate -

Returns:

Throws:

E - the e

E extends Exception

allMatch

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

Parameters:

predicate -

Returns:

Throws:

E - the e

E extends Exception

noneMatch

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

Parameters:

predicate -

Returns:

Throws:

E - the e

E extends Exception

nMatch

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

Parameters:

atLeast -

atMost -

predicate -

Returns:

Throws:

E

E extends Exception

findFirst

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

Throws:

E extends Exception

findLast

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

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

Type Parameters:

E -

Parameters:

predicate -

Returns:

Throws:

E

E extends Exception

findAny

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

Throws:

E extends Exception

containsAll

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

Throws:

E extends Exception

containsAll

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

Throws:

E extends Exception

containsAny

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

Throws:

E extends Exception

containsAny

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

Throws:

E extends Exception

hasDuplicates

@TerminalOp
public boolean hasDuplicates()
                                   throws E extends Exception

Throws:

E extends Exception

kthLargest

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

Throws:

E extends Exception

percentiles

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

Throws:

E extends Exception

first

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

Returns:

Throws:

E - the e

E extends Exception

last

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

Returns:

Throws:

E - the e

E extends Exception

elementAt

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

Parameters:

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

Returns:

Throws:

E - the e

E extends Exception

onlyOne

@TerminalOp
public u.Optional<T> onlyOne()
                                   throws DuplicatedResultException,
                                          E extends Exception

Returns:

Throws:

DuplicatedResultException - if there are more than one elements.

E - the e

E extends Exception

count

@TerminalOp
public long count()
                        throws E extends Exception

Returns:

Throws:

E - the e

E extends Exception

toArray

@TerminalOp
public Object[] toArray()
                              throws E extends Exception

Returns:

Throws:

E - the e

E extends Exception

toArray

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

Type Parameters:

A -

Parameters:

generator -

Returns:

Throws:

E - the e

E extends Exception

toList

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

Returns:

Throws:

E - the e

E extends Exception

toSet

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

Returns:

Throws:

E - the e

E extends Exception

toImmutableList

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

Returns:

Throws:

E - the e

E extends Exception

toImmutableSet

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

Returns:

Throws:

E - the e

E extends Exception

toCollection

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

Type Parameters:

C -

Parameters:

supplier -

Returns:

Throws:

E - the e

E extends Exception

toListAndThen

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

Throws:

E extends Exception

toSetAndThen

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

Throws:

E extends Exception

toCollectionAndThen

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

Throws:

E extends Exception

toMap

@TerminalOp
public <K,V> Map<K,V> toMap(Throwables.Function<? super T,? extends K,? extends E> keyMapper,
                                         Throwables.Function<? super T,? extends V,? extends E> valueMapper)
                                  throws E extends Exception,
                                         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.

E extends Exception

See Also:

Fn.Fnn#throwingMerger()}, Fn.Fnn#replacingMerger()}, Fn.Fnn#ignoringMerger()}

toMap

@TerminalOp
public <K,V,M extends Map<K,V>> M toMap(Throwables.Function<? super T,? extends K,? extends E> keyMapper,
                                                     Throwables.Function<? super T,? extends V,? extends E> valueMapper,
                                                     Supplier<? extends M> mapFactory)
                                              throws E extends Exception,
                                                     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.

E extends Exception

See Also:

Fn.Fnn#throwingMerger()}, Fn.Fnn#replacingMerger()}, Fn.Fnn#ignoringMerger()}

toMap

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

Type Parameters:

K - the key type

V - the value type

Parameters:

keyMapper -

valueMapper -

mergeFunction -

Returns:

Throws:

E - the e

E extends Exception

See Also:

Fn.Fnn#throwingMerger()}, Fn.Fnn#replacingMerger()}, Fn.Fnn#ignoringMerger()}

toMap

@TerminalOp
public <K,V,M extends Map<K,V>> M toMap(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 M> mapFactory)
                                              throws E extends Exception

Type Parameters:

K - the key type

V - the value type

M -

Parameters:

keyMapper -

valueMapper -

mergeFunction -

mapFactory -

Returns:

Throws:

E - the e

E extends Exception

See Also:

Fn.Fnn#throwingMerger()}, Fn.Fnn#replacingMerger()}, Fn.Fnn#ignoringMerger()}

toMap

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

Type Parameters:

K - the key type

A -

D -

Parameters:

keyMapper -

downstream -

Returns:

Throws:

E - the e

E extends Exception

toMap

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

Type Parameters:

K - the key type

A -

D -

M -

Parameters:

keyMapper -

downstream -

mapFactory -

Returns:

Throws:

E - the e

E extends Exception

toMap

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

Type Parameters:

K - the key type

V - the value type

A -

D -

Parameters:

keyMapper -

valueMapper -

downstream -

Returns:

Throws:

E - the e

E extends Exception

toMap

@TerminalOp
public <K,V,A,D,M extends Map<K,D>> M toMap(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 M> mapFactory)
                                                  throws E extends Exception

Type Parameters:

K - the key type

V - the value type

A -

D -

M -

Parameters:

keyMapper -

valueMapper -

downstream -

mapFactory -

Returns:

Throws:

E - the e

E extends Exception

groupTo

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

Type Parameters:

K - the key type

Parameters:

keyMapper -

Returns:

Throws:

E - the e

E extends Exception

See Also:

Collectors.groupingBy(Function)

groupTo

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

Type Parameters:

K - the key type

M -

Parameters:

keyMapper -

mapFactory -

Returns:

Throws:

E - the e

E extends Exception

See Also:

Collectors.groupingBy(Function, Supplier)

groupTo

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

Type Parameters:

K - the key type

V - the value type

Parameters:

keyMapper -

valueMapper -

Returns:

Throws:

E - the e

E extends Exception

groupTo

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

Type Parameters:

K - the key type

V - the value type

M -

Parameters:

keyMapper -

valueMapper -

mapFactory -

Returns:

Throws:

E - the e

E extends Exception

See Also:

Collectors.toMultimap(Function, Function, Supplier)

toMultimap

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

Throws:

E extends Exception

toMultimap

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

Throws:

E extends Exception

toMultimap

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

Throws:

E extends Exception

toMultimap

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

Throws:

E extends Exception

toMultiset

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

Throws:

E extends Exception

toMultiset

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

Throws:

E extends Exception

toDataSet

@TerminalOp
public DataSet toDataSet()
                               throws E extends Exception

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

E extends Exception

See Also:

N#newDataSet(Collection)}

toDataSet

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

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

E extends Exception

See Also:

N#newDataSet(Collection, Collection)}

sumInt

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

Parameters:

func -

Returns:

Throws:

E - the e

E extends Exception

sumLong

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

Parameters:

func -

Returns:

Throws:

E - the e

E extends Exception

sumDouble

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

Parameters:

func -

Returns:

Throws:

E - the e

E extends Exception

averageInt

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

Parameters:

func -

Returns:

Throws:

E - the e

E extends Exception

averageLong

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

Parameters:

func -

Returns:

Throws:

E - the e

E extends Exception

averageDouble

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

Parameters:

func -

Returns:

Throws:

E - the e

E extends Exception

reduce

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

Type Parameters:

E2 -

Parameters:

accumulator -

Returns:

Throws:

E - the e

E2 - the e2

E extends Exception

reduce

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

Type Parameters:

U -

E2 -

Parameters:

identity -

accumulator -

Returns:

Throws:

E - the e

E2 - the e2

E extends Exception

collect

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

Type Parameters:

R -

E2 -

E3 -

Parameters:

supplier -

accumulator -

Returns:

Throws:

E - the e

E2 - the e2

E3 - the e3

E extends Exception

collect

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

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

E extends Exception

collect

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

Type Parameters:

R -

A -

Parameters:

collector -

Returns:

Throws:

E - the e

E extends Exception

collectAndThen

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

Collect and then.

Type Parameters:

R -

RR -

A -

E2 -

Parameters:

collector -

func -

Returns:

Throws:

E - the e

E2 - the e2

E extends Exception

join

@TerminalOp
public String join(CharSequence delimiter)
                         throws E extends Exception

Throws:

E extends Exception

join

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

Throws:

E extends Exception

persist

public long persist(File file)
             throws E extends Exception,
                    IOException

Throws:

E extends Exception

IOException

persist

public long persist(String header,
                    String tail,
                    File file)
             throws E extends Exception,
                    IOException

Throws:

E extends Exception

IOException

persist

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

Throws:

E extends Exception

IOException

persist

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

Throws:

E extends Exception

IOException

persist

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

Throws:

E extends Exception

IOException

persist

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

Throws:

E extends Exception

IOException

persist

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

Throws:

E extends Exception

IOException

persist

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

Throws:

E extends Exception

SQLException

persist

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

Throws:

E extends Exception

SQLException

println

@TerminalOp
 @Beta
public void println()
                                  throws E extends Exception

Throws:

E extends Exception

__

@IntermediateOp
 @Beta
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

onClose

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

Parameters:

closeHandler -

Returns:

close

@TerminalOp
public void close()

Specified by:

close in interface Closeable

Specified by:

close in interface AutoCloseable

Throws:

E - the e