com.landawn.abacus.util

Class ExceptionalStream<T,E extends Exception>

java.lang.Object

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

Type Parameters:

T -

E -

All Implemented Interfaces:

Immutable, Closeable, AutoCloseable

Direct Known Subclasses:

ExceptionalStream.StreamE

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

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

Since:

1.3

Author:

Haiyang Li

See Also:

BaseStream, Stream, IntStream, LongStream, DoubleStream, Collectors, Fn.Fnn, Comparators, ExceptionUtil

Nested Class Summary

Nested Classes

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

Method Summary

Modifier and Type	Method and Description
<TT,EE extends Exception> ExceptionalStream<TT,EE>	__(Throwables.Function<? super ExceptionalStream<T,E>,ExceptionalStream<TT,EE>,E> transfer)
<E2 extends Exception> If.OrElse	acceptIfNotEmpty(Throwables.Consumer<? super ExceptionalStream<T,E>,E2> action)
<E2 extends Exception> boolean	allMatch(Throwables.Predicate<? super T,E2> predicate)
<E2 extends Exception> boolean	anyMatch(Throwables.Predicate<? super T,E2> predicate)
ExceptionalStream<T,E>	append(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(T... a)
ExceptionalStream<T,E>	appendIfEmpty(Throwables.Supplier<? extends ExceptionalStream<T,E>,? extends E> supplier) Append if empty.
<R,E2 extends Exception> u.Optional<R>	applyIfNotEmpty(Throwables.Function<? super ExceptionalStream<T,E>,R,E2> func)
<E2 extends Exception> u.OptionalDouble	averageDouble(Throwables.ToDoubleFunction<? super T,E2> func)
<E2 extends Exception> u.OptionalDouble	averageInt(Throwables.ToIntFunction<? super T,E2> func)
<E2 extends Exception> u.OptionalDouble	averageLong(Throwables.ToLongFunction<? super T,E2> func)
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,A> R	collect(Collector<? super T,A,R> collector)
<R,E2 extends Exception,E3 extends Exception> R	collect(Throwables.Supplier<R,E2> supplier, Throwables.BiConsumer<? super R,? super T,E3> accumulator)
<R,RR,E2 extends Exception,E3 extends Exception,E4 extends Exception> RR	collect(Throwables.Supplier<R,E2> supplier, Throwables.BiConsumer<? super R,? super T,E3> accumulator, Throwables.Function<? super R,? extends RR,E4> finisher)
<R,RR,A,E2 extends Exception> RR	collectAndThen(Collector<? super T,A,R> collector, Throwables.Function<? super R,? extends RR,E2> func) Collect and then.
<R,RR,A,E2 extends Exception> RR	collectAndThen(Collector<? super T,A,R> collector, Throwables.Function<? super R,? extends RR,E2> func) Collect and then.
static <T,E extends Exception> ExceptionalStream<T,E>	concat(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) The time complexity is O(n * m) : n is the size of this Stream and m is the size of specified collection b.
<U,R> ExceptionalStream<R,E>	crossJoin(Collection<? extends U> b, Throwables.BiFunction<? super T,? super U,R,? extends E> func) The time complexity is O(n * m) : n is the size of this Stream and m is the size of specified collection b.
<U,R> ExceptionalStream<R,E>	crossJoin(ExceptionalStream<? extends U,E> b, Throwables.BiFunction<? super T,? super U,R,? extends E> func) The time complexity is O(n * m) : n is the size of this Stream and m is the size of specified collection b.
ExceptionalStream<T,E>	defaultIfEmpty(T defaultValue)
ExceptionalStream<T,E>	defaultIfEmpty(Throwables.Supplier<? extends ExceptionalStream<T,E>,? extends E> supplier)
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)
ExceptionalStream<T,Exception>	filterE(Throwables.Predicate<? super T,? extends Exception> predicate)
<E2 extends Exception> u.Optional<T>	findAny(Throwables.Predicate<? super T,E2> predicate) Same as findFirst(Throwables.Predicate).
<E2 extends Exception> u.Optional<T>	findFirst(Throwables.Predicate<? super T,E2> predicate)
<E2 extends Exception> u.Optional<T>	findLast(Throwables.Predicate<? super T,E2> predicate) Consider using: stream.reversed().findFirst(predicate) for better performance if possible.
u.Optional<T>	first()
<R> ExceptionalStream<R,E>	flatMap(Throwables.Function<? super T,? extends ExceptionalStream<? extends R,? extends E>,? extends E> mapper)
<R> ExceptionalStream<R,Exception>	flatMapE(Throwables.Function<? super T,? extends ExceptionalStream<? extends R,? extends Exception>,? extends Exception> 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)
<R> ExceptionalStream<R,Exception>	flattMapE(Throwables.Function<? super T,? extends Collection<? extends R>,? extends Exception> mapper)
<E2 extends Exception> void	forEach(Throwables.Consumer<? super T,E2> action)
<E2 extends Exception,E3 extends Exception> void	forEach(Throwables.Consumer<? super T,E2> action, Throwables.Runnable<E3> onComplete)
<U,E2 extends Exception,E3 extends Exception> void	forEach(Throwables.Function<? super T,? extends Collection<? extends U>,E2> flatMapper, Throwables.BiConsumer<? super T,? super U,E3> action)
<T2,T3,E2 extends Exception,E3 extends Exception,E4 extends Exception> void	forEach(Throwables.Function<? super T,? extends Collection<T2>,E2> flatMapper, Throwables.Function<? super T2,? extends Collection<T3>,E3> flatMapper2, Throwables.TriConsumer<? super T,? super T2,? super T3,E4> action)
<E2 extends Exception> void	forEachIndexed(Throwables.IndexedConsumer<? super T,E2> action)
<E2 extends Exception> void	forEachPair(Throwables.BiConsumer<? super T,? super T,E2> action) For each pair.
<E2 extends Exception> void	forEachPair(Throwables.BiConsumer<? super T,? super T,E2> action, int increment) For each pair.
<E2 extends Exception> void	forEachToBreak(MutableBoolean flagToBreak, Throwables.Consumer<? super T,E2> action)
<E2 extends Exception> void	forEachToBreak(Throwables.BiConsumer<? super T,MutableBoolean,E2> action)
<E2 extends Exception> void	forEachTriple(Throwables.TriConsumer<? super T,? super T,? super T,E2> action) For each triple.
<E2 extends Exception> void	forEachTriple(Throwables.TriConsumer<? super T,? super T,? super T,E2> action, int increment) For each triple.
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) The time complexity is O(n + m) : n is the size of this Stream and m is the size of specified collection b.
<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) The time complexity is O(n + m) : n is the size of this Stream and m is the size of specified collection b.
<U> ExceptionalStream<Pair<T,U>,E>	fullJoin(Collection<? extends U> b, Throwables.BiPredicate<? super T,? super U,? extends E> predicate) Deprecated. The time complexity is O(n * m). You should try fullJoin(Collection, Function, Function) first.
<U,R> ExceptionalStream<R,E>	fullJoin(Collection<? extends U> b, Throwables.BiPredicate<? super T,? super U,? extends E> predicate, Throwables.BiFunction<? super T,? super U,R,? extends E> func) Deprecated. The time complexity is O(n * m). You should try fullJoin(Collection, Function, Function, BiFunction) first.
<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) The time complexity is O(n + m) : n is the size of this Stream and m is the size of specified collection b.
<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) The time complexity is O(n + m) : n is the size of this Stream and m is the size of specified collection b.
<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) The time complexity is O(n + m) : n is the size of this Stream and m is the size of specified collection b.
<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) The time complexity is O(n + m) : n is the size of this Stream and m is the size of specified collection b.
<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) The time complexity is O(n + m) : n is the size of this Stream and m is the size of specified collection b.
<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) The time complexity is O(n + m) : n is the size of this Stream and m is the size of specified collection b.
<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) The time complexity is O(n + m) : n is the size of this Stream and m is the size of specified collection b.
<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) The time complexity is O(n + m) : n is the size of this Stream and m is the size of specified collection b.
<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) The time complexity is O(n + m) : n is the size of this Stream and m is the size of specified collection b.
<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) The time complexity is O(n + m) : n is the size of this Stream and m is the size of specified collection b.
<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) The time complexity is O(n + m) : n is the size of this Stream and m is the size of specified collection b.
<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) The time complexity is O(n + m) : n is the size of this Stream and m is the size of specified collection b.
<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) The time complexity is O(n + m) : n is the size of this Stream and m is the size of specified collection b.
<K,E2 extends Exception> Map<K,List<T>>	groupTo(Throwables.Function<? super T,? extends K,E2> keyMapper)
<K,M extends Map<K,List<T>>,E2 extends Exception> M	groupTo(Throwables.Function<? super T,? extends K,E2> keyMapper, Supplier<? extends M> mapFactory)
<K,V,E2 extends Exception,E3 extends Exception> Map<K,List<V>>	groupTo(Throwables.Function<? super T,? extends K,E2> keyMapper, Throwables.Function<? super T,? extends V,E3> valueMapper)
<K,V,M extends Map<K,List<V>>,E2 extends Exception,E3 extends Exception> M	groupTo(Throwables.Function<? super T,? extends K,E2> keyMapper, Throwables.Function<? super T,? extends V,E3> valueMapper, Supplier<? extends M> mapFactory)
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) The time complexity is O(n + m) : n is the size of this Stream and m is the size of specified collection b.
<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) The time complexity is O(n + m) : n is the size of this Stream and m is the size of specified collection b.
<U> ExceptionalStream<Pair<T,U>,E>	innerJoin(Collection<? extends U> b, Throwables.BiPredicate<? super T,? super U,? extends E> predicate) Deprecated. The time complexity is O(n * m). You should try innerJoin(Collection, Function, Function) first.
<U,R> ExceptionalStream<R,E>	innerJoin(Collection<? extends U> b, Throwables.BiPredicate<? super T,? super U,? extends E> predicate, Throwables.BiFunction<? super T,? super U,R,? extends E> func) Deprecated. The time complexity is O(n * m). You should try innerJoin(Collection, Function, Function, BiFunction) first.
<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) The time complexity is O(n + m) : n is the size of this Stream and m is the size of specified collection b.
<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) The time complexity is O(n + m) : n is the size of this Stream and m is the size of specified collection b.
<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) The time complexity is O(n + m) : n is the size of this Stream and m is the size of specified collection b.
ExceptionalStream<T,E>	intersection(Collection<?> c)
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) The time complexity is O(n + m) : n is the size of this Stream and m is the size of specified collection b.
<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) The time complexity is O(n + m) : n is the size of this Stream and m is the size of specified collection b.
<U> ExceptionalStream<Pair<T,U>,E>	leftJoin(Collection<? extends U> b, Throwables.BiPredicate<? super T,? super U,? extends E> predicate) Deprecated. The time complexity is O(n * m). You should try leftJoin(Collection, Function, Function) first.
<U,R> ExceptionalStream<R,E>	leftJoin(Collection<? extends U> b, Throwables.BiPredicate<? super T,? super U,? extends E> predicate, Throwables.BiFunction<? super T,? super U,R,? extends E> func) Deprecated. The time complexity is O(n * m). You should try leftJoin(Collection, Function, Function, BiFunction) first.
<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) The time complexity is O(n + m) : n is the size of this Stream and m is the size of specified collection b.
<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) The time complexity is O(n + m) : n is the size of this Stream and m is the size of specified collection b.
<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) The time complexity is O(n + m) : n is the size of this Stream and m is the size of specified collection b.
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)
<U> ExceptionalStream<U,Exception>	mapE(Throwables.Function<? super T,? extends U,? extends Exception> mapper)
ExceptionalStream<T,E>	mapFirst(Throwables.Function<? super T,? extends T,? extends E> mapperForFirst)
<R> ExceptionalStream<R,E>	mapFirstOrElse(Throwables.Function<? super T,? extends R,E> mapperForFirst, Throwables.Function<? super T,? extends R,E> mapperForElse)
ExceptionalStream<T,E>	mapLast(Throwables.Function<? super T,? extends T,? extends E> mapperForLast)
<R> ExceptionalStream<R,E>	mapLastOrElse(Throwables.Function<? super T,? extends R,E> mapperForLast, Throwables.Function<? super T,? extends R,E> mapperForElse)
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)
<E2 extends Exception> boolean	nMatch(long atLeast, long atMost, Throwables.Predicate<? super T,E2> predicate)
<E2 extends Exception> boolean	noneMatch(Throwables.Predicate<? super T,E2> predicate)
static <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(Optional<T> op)
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) ======= ======= >>>>>>> .merge-right.r2804 >>>>>>> .merge-right.r2926
ExceptionalStream<T,E>	onEach(Throwables.Consumer<? super T,? extends E> action)
ExceptionalStream<T,Exception>	onEachE(Throwables.Consumer<? super T,? extends Exception> action)
u.Optional<T>	onlyOne()
ExceptionalStream<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 T,? super PreparedStatement,SQLException> stmtSetter)
long	persist(File file)
long	persist(PreparedStatement stmt, int batchSize, int batchInterval, Throwables.BiConsumer<? super T,? super PreparedStatement,SQLException> stmtSetter)
long	persist(String header, String tail, File file)
long	persist(Throwables.BiConsumer<? super T,Writer,IOException> writeLine, String header, String tail, Writer writer)
long	persist(Throwables.BiConsumer<? super T,Writer,IOException> writeLine, Writer writer)
long	persist(Throwables.Function<? super T,String,IOException> toLine, File file) toCSV:
long	persist(Throwables.Function<? super T,String,IOException> toLine, OutputStream os)
long	persist(Throwables.Function<? super T,String,IOException> toLine, 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) toCSV:
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,E2> accumulator)
<U,E2 extends Exception> U	reduce(U identity, Throwables.BiFunction<U,? super T,U,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) The time complexity is O(n + m) : n is the size of this Stream and m is the size of specified collection b.
<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) The time complexity is O(n + m) : n is the size of this Stream and m is the size of specified collection b.
<U> ExceptionalStream<Pair<T,U>,E>	rightJoin(Collection<? extends U> b, Throwables.BiPredicate<? super T,? super U,? extends E> predicate) Deprecated. The time complexity is O(n * m). You should try rightJoin(Collection, Function, Function) first.
<U,R> ExceptionalStream<R,E>	rightJoin(Collection<? extends U> b, Throwables.BiPredicate<? super T,? super U,? extends E> predicate, Throwables.BiFunction<? super T,? super U,R,? extends E> func) Deprecated. The time complexity is O(n * m). You should try rightJoin(Collection, Function, Function, BiFunction) first.
<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) The time complexity is O(n + m) : n is the size of this Stream and m is the size of specified collection b.
<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) The time complexity is O(n + m) : n is the size of this Stream and m is the size of specified collection b.
<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) The time complexity is O(n + m) : n is the size of this Stream and m is the size of specified collection b.
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).
<E2 extends Exception> u.OptionalDouble	sumDouble(Throwables.ToDoubleFunction<? super T,E2> func)
<E2 extends Exception> u.OptionalLong	sumInt(Throwables.ToIntFunction<? super T,E2> func)
<E2 extends Exception> u.OptionalLong	sumLong(Throwables.ToLongFunction<? super T,E2> func)
ExceptionalStream<T,E>	symmetricDifference(Collection<T> c)
ExceptionalStream<T,E>	takeWhile(Throwables.Predicate<? super T,? extends E> predicate)
ExceptionalStream<T,E>	throwIfEmpty(Supplier<? extends E> exceptionSupplier)
Object[]	toArray()
<A> A[]	toArray(IntFunction<A[]> generator)
<C extends Collection<T>> C	toCollection(Supplier<? extends C> supplier)
<R,CC extends Collection<T>,E2 extends Exception> R	toCollectionAndThen(Supplier<? extends CC> supplier, Throwables.Function<? super CC,R,E2> func)
DataSet	toDataSet() The first row will be used as column names if its type is array or list, or obtain the column names from first row if its type is entity or map.
DataSet	toDataSet(List<String> columnNames) If the specified columnNames is null or empty, the first row will be used as column names if its type is array or list, or obtain the column names from first row if its type is entity or map.
ImmutableList<T>	toImmutableList()
ImmutableSet<T>	toImmutableSet()
List<T>	toList()
<R,E2 extends Exception> R	toListAndThen(Throwables.Function<? super List<T>,R,E2> func)
<K,A,D,E2 extends Exception> Map<K,D>	toMap(Throwables.Function<? super T,? extends K,E2> keyMapper, Collector<? super T,A,D> downstream)
<K,A,D,M extends Map<K,D>,E2 extends Exception> M	toMap(Throwables.Function<? super T,? extends K,E2> keyMapper, Collector<? super T,A,D> downstream, Supplier<? extends M> mapFactory)
<K,V,E2 extends Exception,E3 extends Exception> Map<K,V>	toMap(Throwables.Function<? super T,? extends K,E2> keyMapper, Throwables.Function<? super T,? extends V,E3> valueMapper)
<K,V,A,D,E2 extends Exception,E3 extends Exception> Map<K,D>	toMap(Throwables.Function<? super T,? extends K,E2> keyMapper, Throwables.Function<? super T,? extends V,E3> valueMapper, Collector<? super V,A,D> downstream)
<K,V,A,D,M extends Map<K,D>,E2 extends Exception,E3 extends Exception> M	toMap(Throwables.Function<? super T,? extends K,E2> keyMapper, Throwables.Function<? super T,? extends V,E3> valueMapper, Collector<? super V,A,D> downstream, Supplier<? extends M> mapFactory)
<K,V,M extends Map<K,V>,E2 extends Exception,E3 extends Exception> M	toMap(Throwables.Function<? super T,? extends K,E2> keyMapper, Throwables.Function<? super T,? extends V,E3> valueMapper, Supplier<? extends M> mapFactory)
<K,V,E2 extends Exception,E3 extends Exception> Map<K,V>	toMap(Throwables.Function<? super T,? extends K,E2> keyMapper, Throwables.Function<? super T,? extends V,E3> valueMapper, Throwables.BinaryOperator<V,? extends E> mergeFunction)
<K,V,M extends Map<K,V>,E2 extends Exception,E3 extends Exception> M	toMap(Throwables.Function<? super T,? extends K,E2> keyMapper, Throwables.Function<? super T,? extends V,E3> valueMapper, Throwables.BinaryOperator<V,? extends E> mergeFunction, Supplier<? extends M> mapFactory)
<K,E2 extends Exception> ListMultimap<K,T>	toMultimap(Throwables.Function<? super T,? extends K,E2> keyMapper)
<K,V extends Collection<T>,M extends Multimap<K,T,V>,E2 extends Exception> M	toMultimap(Throwables.Function<? super T,? extends K,E2> keyMapper, Supplier<? extends M> mapFactory)
<K,V,E2 extends Exception,E3 extends Exception> ListMultimap<K,V>	toMultimap(Throwables.Function<? super T,? extends K,E2> keyMapper, Throwables.Function<? super T,? extends V,E3> valueMapper)
<K,V,C extends Collection<V>,M extends Multimap<K,V,C>,E2 extends Exception,E3 extends Exception> M	toMultimap(Throwables.Function<? super T,? extends K,E2> keyMapper, Throwables.Function<? super T,? extends V,E3> valueMapper, Supplier<? extends M> mapFactory)
Multiset<T>	toMultiset()
Multiset<T>	toMultiset(Supplier<? extends Multiset<T>> supplier)
ExceptionalStream<T,E>	top(int n)
ExceptionalStream<T,E>	top(int n, Comparator<? super T> comparator)
Set<T>	toSet()
<R,E2 extends Exception> R	toSetAndThen(Throwables.Function<? super Set<T>,R,E2> func)
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

public static <T,E extends Exception> ExceptionalStream<T,E> of(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)

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

Parameters:

supplier -

Returns:

See Also:

appendIfEmpty(Throwables.Supplier)

prepend

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

prepend

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

prepend

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

Parameters:

s -

Returns:

append

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

append

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

append

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

Parameters:

s -

Returns:

appendIfEmpty

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

appendIfEmpty

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

appendIfEmpty

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

Append if empty.

Parameters:

supplier -

Returns:

Throws:

E - the e

throwIfEmpty

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

applyIfNotEmpty

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

Throws:

E extends Exception

acceptIfNotEmpty

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

The time complexity is O(n * m) : n is the size of this Stream and m is the size of specified collection 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)

The time complexity is O(n * m) : n is the size of this Stream and m is the size of specified collection b.

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)

The time complexity is O(n * m) : n is the size of this Stream and m is the size of specified collection b.

Type Parameters:

U -

R -

Parameters:

b - will be loaded to memory. If b is too big to load to memory, please use b.cronJoin(this, ...)

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)

The time complexity is O(n + m) : n is the size of this Stream and m is the size of specified collection b.

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)

The time complexity is O(n + m) : n is the size of this Stream and m is the size of specified collection b.

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)

The time complexity is O(n + m) : n is the size of this Stream and m is the size of specified collection b.

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)

The time complexity is O(n + m) : n is the size of this Stream and m is the size of specified collection b.

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)

The time complexity is O(n + m) : n is the size of this Stream and m is the size of specified collection b.

Type Parameters:

U -

K -

R -

Parameters:

b - will be loaded to memory. If b is too big to load to memory, please use b.innerJoin(this, ...)

leftKeyMapper -

rightKeyMapper -

func -

Returns:

innerJoin

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

Deprecated. The time complexity is O(n * m). You should try innerJoin(Collection, Function, Function) first.

The time complexity is O(n * m) : n is the size of this Stream and m is the size of specified collection b.

Type Parameters:

U -

Parameters:

b -

predicate -

Returns:

innerJoin

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

Deprecated. The time complexity is O(n * m). You should try innerJoin(Collection, Function, Function, BiFunction) first.

The time complexity is O(n * m) : n is the size of this Stream and m is the size of specified collection b.

Type Parameters:

U -

R -

Parameters:

b -

predicate -

func -

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)

The time complexity is O(n + m) : n is the size of this Stream and m is the size of specified collection b.

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)

The time complexity is O(n + m) : n is the size of this Stream and m is the size of specified collection b.

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)

The time complexity is O(n + m) : n is the size of this Stream and m is the size of specified collection b.

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)

The time complexity is O(n + m) : n is the size of this Stream and m is the size of specified collection b.

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 - will be loaded to memory. If b is too big to load to memory, please use b.fullJoin(this, ...)

leftKeyMapper -

rightKeyMapper -

func -

Returns:

fullJoin

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

Deprecated. The time complexity is O(n * m). You should try fullJoin(Collection, Function, Function) first.

The time complexity is O(n * m) : n is the size of this Stream and m is the size of specified collection b.

Type Parameters:

U -

Parameters:

b -

predicate -

Returns:

fullJoin

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

Deprecated. The time complexity is O(n * m). You should try fullJoin(Collection, Function, Function, BiFunction) first.

The time complexity is O(n * m) : n is the size of this Stream and m is the size of specified collection b.

Type Parameters:

U -

R -

Parameters:

b -

predicate -

func -

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)

The time complexity is O(n + m) : n is the size of this Stream and m is the size of specified collection b.

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)

The time complexity is O(n + m) : n is the size of this Stream and m is the size of specified collection b.

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)

The time complexity is O(n + m) : n is the size of this Stream and m is the size of specified collection b.

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)

The time complexity is O(n + m) : n is the size of this Stream and m is the size of specified collection b.

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)

The time complexity is O(n + m) : n is the size of this Stream and m is the size of specified collection b.

Type Parameters:

K -

U -

R -

Parameters:

b - will be loaded to memory. If b is too big to load to memory, please use b.leftJoin(this, ...)

leftKeyMapper -

rightKeyMapper -

func -

Returns:

leftJoin

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

Deprecated. The time complexity is O(n * m). You should try leftJoin(Collection, Function, Function) first.

The time complexity is O(n * m) : n is the size of this Stream and m is the size of specified collection b.

Type Parameters:

U -

Parameters:

b -

predicate -

Returns:

leftJoin

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

Deprecated. The time complexity is O(n * m). You should try leftJoin(Collection, Function, Function, BiFunction) first.

The time complexity is O(n * m) : n is the size of this Stream and m is the size of specified collection b.

Type Parameters:

U -

R -

Parameters:

b -

predicate -

func -

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)

The time complexity is O(n + m) : n is the size of this Stream and m is the size of specified collection b.

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)

The time complexity is O(n + m) : n is the size of this Stream and m is the size of specified collection b.

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)

The time complexity is O(n + m) : n is the size of this Stream and m is the size of specified collection b.

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)

The time complexity is O(n + m) : n is the size of this Stream and m is the size of specified collection b.

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)

The time complexity is O(n + m) : n is the size of this Stream and m is the size of specified collection b.

Type Parameters:

K -

U -

R -

Parameters:

b - will be loaded to memory. If b is too big to load to memory, please use b.rightJoin(this, ...)

leftKeyMapper -

rightKeyMapper -

func -

Returns:

rightJoin

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

Deprecated. The time complexity is O(n * m). You should try rightJoin(Collection, Function, Function) first.

The time complexity is O(n * m) : n is the size of this Stream and m is the size of specified collection b.

Type Parameters:

U -

Parameters:

b -

predicate -

Returns:

rightJoin

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

Deprecated. The time complexity is O(n * m). You should try rightJoin(Collection, Function, Function, BiFunction) first.

The time complexity is O(n * m) : n is the size of this Stream and m is the size of specified collection b.

Type Parameters:

U -

R -

Parameters:

b -

predicate -

func -

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)

The time complexity is O(n + m) : n is the size of this Stream and m is the size of specified collection b.

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)

The time complexity is O(n + m) : n is the size of this Stream and m is the size of specified collection b.

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)

The time complexity is O(n + m) : n is the size of this Stream and m is the size of specified collection b.

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)

The time complexity is O(n + m) : n is the size of this Stream and m is the size of specified collection b.

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)

The time complexity is O(n + m) : n is the size of this Stream and m is the size of specified collection b.

Type Parameters:

U -

K -

R -

Parameters:

b - will be loaded to memory. If b is too big to load to memory, please use b.groupJoin(this, ...)

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)

The time complexity is O(n + m) : n is the size of this Stream and m is the size of specified collection b.

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)

The time complexity is O(n + m) : n is the size of this Stream and m is the size of specified collection b.

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)

The time complexity is O(n + m) : n is the size of this Stream and m is the size of specified collection b.

Type Parameters:

U -

K -

R -

Parameters:

b - will be loaded to memory. If b is too big to load to memory, please use b.groupJoin(this, ...)

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)

The time complexity is O(n + m) : n is the size of this Stream and m is the size of specified collection b.

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)

The time complexity is O(n + m) : n is the size of this Stream and m is the size of specified collection b.

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)

The time complexity is O(n + m) : n is the size of this Stream and m is the size of specified collection b.

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,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,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 <E2 extends Exception> void forEachToBreak(Throwables.BiConsumer<? super T,MutableBoolean,E2> action)
                                                                throws E extends Exception,
                                                                       E2 extends Exception

Throws:

E extends Exception

forEachToBreak

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

Throws:

E extends Exception

forEach

@TerminalOp
public <E2 extends Exception,E3 extends Exception> void forEach(Throwables.Consumer<? super T,E2> action,
                                                                             Throwables.Runnable<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>,E2> flatMapper,
                                                                               Throwables.BiConsumer<? super T,? super U,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>,E2> flatMapper,
                                                                                                        Throwables.Function<? super T2,? extends Collection<T3>,E3> flatMapper2,
                                                                                                        Throwables.TriConsumer<? super T,? super T2,? super T3,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,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,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,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,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 <E2 extends Exception> boolean anyMatch(Throwables.Predicate<? super T,E2> predicate)
                                                     throws E extends Exception,
                                                            E2 extends Exception

Type Parameters:

E2 -

Parameters:

predicate -

Returns:

Throws:

E

E2

E extends Exception

allMatch

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

Type Parameters:

E2 -

Parameters:

predicate -

Returns:

Throws:

E

E2

E extends Exception

noneMatch

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

Type Parameters:

E2 -

Parameters:

predicate -

Returns:

Throws:

E

E2

E extends Exception

nMatch

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

Type Parameters:

E2 -

Parameters:

atLeast -

atMost -

predicate -

Returns:

Throws:

E

E2

E extends Exception

findFirst

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

Type Parameters:

E2 -

Parameters:

predicate -

Returns:

Throws:

E

E2

E extends Exception

findLast

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

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

Type Parameters:

E2 -

Parameters:

predicate -

Returns:

Throws:

E

E2

E extends Exception

findAny

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

Same as findFirst(Throwables.Predicate).

Type Parameters:

E2 -

Parameters:

predicate -

Returns:

Throws:

E

E2

E extends Exception

See Also:

findFirst(com.landawn.abacus.util.Throwables.Predicate)

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,E2 extends Exception> R toListAndThen(Throwables.Function<? super List<T>,R,E2> func)
                                                      throws E extends Exception,
                                                             E2 extends Exception

Throws:

E extends Exception

toSetAndThen

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

Throws:

E extends Exception

toCollectionAndThen

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

Throws:

E extends Exception

toMap

@TerminalOp
public <K,V,E2 extends Exception,E3 extends Exception> Map<K,V> toMap(Throwables.Function<? super T,? extends K,E2> keyMapper,
                                                                                   Throwables.Function<? super T,? extends V,E3> valueMapper)
                                                                            throws E extends Exception,
                                                                                   E2 extends Exception,
                                                                                   E3 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>,E2 extends Exception,E3 extends Exception> M toMap(Throwables.Function<? super T,? extends K,E2> keyMapper,
                                                                                               Throwables.Function<? super T,? extends V,E3> valueMapper,
                                                                                               Supplier<? extends M> mapFactory)
                                                                                        throws E extends Exception,
                                                                                               E2 extends Exception,
                                                                                               E3 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,E2 extends Exception,E3 extends Exception> Map<K,V> toMap(Throwables.Function<? super T,? extends K,E2> keyMapper,
                                                                                   Throwables.Function<? super T,? extends V,E3> valueMapper,
                                                                                   Throwables.BinaryOperator<V,? extends E> mergeFunction)
                                                                            throws E extends Exception,
                                                                                   E2 extends Exception,
                                                                                   E3 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>,E2 extends Exception,E3 extends Exception> M toMap(Throwables.Function<? super T,? extends K,E2> keyMapper,
                                                                                               Throwables.Function<? super T,? extends V,E3> valueMapper,
                                                                                               Throwables.BinaryOperator<V,? extends E> mergeFunction,
                                                                                               Supplier<? extends M> mapFactory)
                                                                                        throws E extends Exception,
                                                                                               E2 extends Exception,
                                                                                               E3 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,E2 extends Exception> Map<K,D> toMap(Throwables.Function<? super T,? extends K,E2> keyMapper,
                                                                Collector<? super T,A,D> downstream)
                                                         throws E extends Exception,
                                                                E2 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>,E2 extends Exception> M toMap(Throwables.Function<? super T,? extends K,E2> keyMapper,
                                                                            Collector<? super T,A,D> downstream,
                                                                            Supplier<? extends M> mapFactory)
                                                                     throws E extends Exception,
                                                                            E2 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,E2 extends Exception,E3 extends Exception> Map<K,D> toMap(Throwables.Function<? super T,? extends K,E2> keyMapper,
                                                                                       Throwables.Function<? super T,? extends V,E3> valueMapper,
                                                                                       Collector<? super V,A,D> downstream)
                                                                                throws E extends Exception,
                                                                                       E2 extends Exception,
                                                                                       E3 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>,E2 extends Exception,E3 extends Exception> M toMap(Throwables.Function<? super T,? extends K,E2> keyMapper,
                                                                                                   Throwables.Function<? super T,? extends V,E3> valueMapper,
                                                                                                   Collector<? super V,A,D> downstream,
                                                                                                   Supplier<? extends M> mapFactory)
                                                                                            throws E extends Exception,
                                                                                                   E2 extends Exception,
                                                                                                   E3 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,E2 extends Exception> Map<K,List<T>> groupTo(Throwables.Function<? super T,? extends K,E2> keyMapper)
                                                             throws E extends Exception,
                                                                    E2 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>>,E2 extends Exception> M groupTo(Throwables.Function<? super T,? extends K,E2> keyMapper,
                                                                                Supplier<? extends M> mapFactory)
                                                                         throws E extends Exception,
                                                                                E2 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,E2 extends Exception,E3 extends Exception> Map<K,List<V>> groupTo(Throwables.Function<? super T,? extends K,E2> keyMapper,
                                                                                           Throwables.Function<? super T,? extends V,E3> valueMapper)
                                                                                    throws E extends Exception,
                                                                                           E2 extends Exception,
                                                                                           E3 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>>,E2 extends Exception,E3 extends Exception> M groupTo(Throwables.Function<? super T,? extends K,E2> keyMapper,
                                                                                                       Throwables.Function<? super T,? extends V,E3> valueMapper,
                                                                                                       Supplier<? extends M> mapFactory)
                                                                                                throws E extends Exception,
                                                                                                       E2 extends Exception,
                                                                                                       E3 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,E2 extends Exception> ListMultimap<K,T> toMultimap(Throwables.Function<? super T,? extends K,E2> keyMapper)
                                                                   throws E extends Exception,
                                                                          E2 extends Exception

Throws:

E extends Exception

toMultimap

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

Throws:

E extends Exception

toMultimap

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

Throws:

E extends Exception

toMultimap

@TerminalOp
public <K,V,C extends Collection<V>,M extends Multimap<K,V,C>,E2 extends Exception,E3 extends Exception> M toMultimap(Throwables.Function<? super T,? extends K,E2> keyMapper,
                                                                                                                                   Throwables.Function<? super T,? extends V,E3> valueMapper,
                                                                                                                                   Supplier<? extends M> mapFactory)
                                                                                                                            throws E extends Exception,
                                                                                                                                   E2 extends Exception,
                                                                                                                                   E3 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 <E2 extends Exception> u.OptionalLong sumInt(Throwables.ToIntFunction<? super T,E2> func)
                                                          throws E extends Exception,
                                                                 E2 extends Exception

Parameters:

func -

Returns:

Throws:

E - the e

E extends Exception

sumLong

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

Parameters:

func -

Returns:

Throws:

E - the e

E extends Exception

sumDouble

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

Parameters:

func -

Returns:

Throws:

E - the e

E extends Exception

averageInt

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

Parameters:

func -

Returns:

Throws:

E - the e

E extends Exception

averageLong

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

Parameters:

func -

Returns:

Throws:

E - the e

E extends Exception

averageDouble

@TerminalOp
public <E2 extends Exception> u.OptionalDouble averageDouble(Throwables.ToDoubleFunction<? super T,E2> func)
                                                                   throws E extends Exception,
                                                                          E2 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,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,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,E2> supplier,
                                                                            Throwables.BiConsumer<? super R,? super T,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,E2> supplier,
                                                                                                     Throwables.BiConsumer<? super R,? super T,E3> accumulator,
                                                                                                     Throwables.Function<? super R,? extends RR,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

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

collectAndThen

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

toCSV:

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

Parameters:

toLine -

file -

Returns:

Throws:

E

IOException

E extends Exception

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

toCSV:

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

Parameters:

toLine -

writer -

Returns:

Throws:

E

IOException

E extends Exception

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(Throwables.BiConsumer<? super T,Writer,IOException> writeLine,
                    Writer writer)
             throws E extends Exception,
                    IOException

Throws:

E extends Exception

IOException

persist

public long persist(Throwables.BiConsumer<? super T,Writer,IOException> writeLine,
                    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 T,? super PreparedStatement,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 T,? super PreparedStatement,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> __(Throwables.Function<? super ExceptionalStream<T,E>,ExceptionalStream<TT,EE>,E> transfer)
                                                                               throws E extends Exception

Type Parameters:

SS -

Parameters:

transfer -

Returns:

Throws:

E - the e

E extends Exception

filterE

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

Parameters:

predicate -

Returns:

mapE

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

Type Parameters:

U -

Parameters:

mapper -

Returns:

flatMapE

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

Type Parameters:

R -

Parameters:

mapper -

Returns:

flattMapE

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

Type Parameters:

R -

Parameters:

mapper -

Returns:

onEachE

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

Parameters:

action -

Returns:

onClose

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

======= ======= >>>>>>> .merge-right.r2804 >>>>>>> .merge-right.r2926

Parameters:

closeHandler -

Returns:

close

@TerminalOp
public void close()

Specified by:

close in interface Closeable

Specified by:

close in interface AutoCloseable

Throws:

E - the e