Class ExStream<T>

java.lang.Object

net.dapete.exceptional.stream.ExStream<T>

Type Parameters:

T - the type of the stream elements

All Implemented Interfaces:

AutoCloseable, BaseStream<T, Stream<T>>, Stream<T>

public final class ExStream<T>
extends Object
implements Stream<T>

A Stream with additional functionality for functional interfaces that throw Exceptions.

Implements versions of all methods from Stream that use functional interfaces, using their counterparts with Exceptions instead, e.g. exMap(ExFunction) in parallel to map(Function).

If these functional interfaces throw a checked exception, a ExException will be thrown instead. This will have the original exception as its cause.

Note that this exception will likely not be thrown when a method is called, but only when a terminal operation or a stateful intermediate operation is used on the stream (except if it is itself such an operation).

Nested Class Summary

Nested classes/interfaces inherited from interface Stream

Stream.Builder<T>

Method Summary

Modifier and Type	Method	Description
ExStream<T>	distinct()
ExStream<T>	dropWhile(Predicate<? super T> predicate)
static <T> ExStream<T>	empty()	Returns an empty instance.
<R> R	exCollect(ExSupplier<R,?> supplier, ExBiConsumer<R, ? super T, ?> accumulator, ExBiConsumer<R,R,?> combiner)	Equivalent of Stream.collect(Supplier, BiConsumer, BiConsumer).
ExStream<T>	exDropWhile(ExPredicate<? super T, ?> predicate)	Equivalent of Stream.dropWhile(Predicate).
ExStream<T>	exFilter(ExPredicate<? super T, ?> predicate)	Equivalent of Stream.filter(Predicate).
<R> ExStream<R>	exFlatMap(ExFunction<? super T, ? extends Stream<? extends R>, ?> mapper)	Equivalent of Stream.flatMap(Function).
ExDoubleStream	exFlatMapToDouble(ExFunction<? super T, ? extends DoubleStream, ?> mapper)	Equivalent of Stream.flatMapToDouble(Function).
ExIntStream	exFlatMapToInt(ExFunction<? super T, ? extends IntStream, ?> mapper)	Equivalent of Stream.flatMapToInt(Function).
ExLongStream	exFlatMapToLong(ExFunction<? super T, ? extends LongStream, ?> mapper)	Equivalent of Stream.flatMapToLong(Function).
void	exForEach(ExConsumer<? super T, ?> action)	Equivalent of Stream.forEach(Consumer).
void	exForEachOrdered(ExConsumer<? super T, ?> action)	Equivalent of Stream.forEachOrdered(Consumer).
<R> ExStream<R>	exMap(ExFunction<? super T, ? extends R, ?> mapper)	Equivalent of Stream.map(Function).
<R> ExStream<R>	exMapMulti(ExBiConsumer<? super T, ? super Consumer<R>, ?> mapper)	Equivalent of Stream.mapMulti(BiConsumer).
ExDoubleStream	exMapMultiToDouble(ExBiConsumer<? super T, ? super DoubleConsumer, ?> mapper)	Equivalent of Stream.mapMultiToDouble(BiConsumer).
ExIntStream	exMapMultiToInt(ExBiConsumer<? super T, ? super IntConsumer, ?> mapper)	Equivalent of Stream.mapMultiToInt(BiConsumer).
ExLongStream	exMapMultiToLong(ExBiConsumer<? super T, ? super LongConsumer, ?> mapper)	Equivalent of Stream.mapMultiToLong(BiConsumer).
ExDoubleStream	exMapToDouble(ExToDoubleFunction<? super T, ?> mapper)	Equivalent of Stream.mapToDouble(ToDoubleFunction).
ExIntStream	exMapToInt(ExToIntFunction<? super T, ?> mapper)	Equivalent of Stream.mapToInt(ToIntFunction).
ExLongStream	exMapToLong(ExToLongFunction<? super T, ?> mapper)	Equivalent of Stream.mapToLong(ToLongFunction).
ExStream<T>	exPeek(ExConsumer<? super T, ?> action)	Equivalent of Stream.peek(Consumer).
Optional<T>	exReduce(ExBinaryOperator<T,?> accumulator)	Equivalent of Stream.reduce(BinaryOperator).
T	exReduce(T identity, ExBinaryOperator<T,?> accumulator)	Equivalent of Stream.reduce(Object, BinaryOperator).
<U> U	exReduce(U identity, ExBiFunction<U, ? super T, U, ?> accumulator, ExBinaryOperator<U,?> combiner)	Equivalent of Stream.reduce(Object, BiFunction, BinaryOperator).
ExStream<T>	exTakeWhile(ExPredicate<? super T, ?> predicate)	Equivalent of Stream.takeWhile(Predicate).
ExStream<T>	filter(Predicate<? super T> predicate)
<R> ExStream<R>	flatMap(Function<? super T, ? extends Stream<? extends R>> mapper)
ExDoubleStream	flatMapToDouble(Function<? super T, ? extends DoubleStream> mapper)
ExIntStream	flatMapToInt(Function<? super T, ? extends IntStream> mapper)
ExLongStream	flatMapToLong(Function<? super T, ? extends LongStream> mapper)
ExStream<T>	limit(long maxSize)
<R> ExStream<R>	map(Function<? super T, ? extends R> mapper)
<R> ExStream<R>	mapMulti(BiConsumer<? super T, ? super Consumer<R>> mapper)
ExDoubleStream	mapMultiToDouble(BiConsumer<? super T, ? super DoubleConsumer> mapper)
ExIntStream	mapMultiToInt(BiConsumer<? super T, ? super IntConsumer> mapper)
ExLongStream	mapMultiToLong(BiConsumer<? super T, ? super LongConsumer> mapper)
ExDoubleStream	mapToDouble(ToDoubleFunction<? super T> mapper)
ExIntStream	mapToInt(ToIntFunction<? super T> mapper)
ExLongStream	mapToLong(ToLongFunction<? super T> mapper)
static <T> ExStream<T>	of(Collection<T> collection)	Create an instance from a collection.
static ExStream<Double>	of(DoubleStream stream)	Create an instance from an existing DoubleStream.
static ExStream<Integer>	of(IntStream stream)	Create an instance from an existing IntStream.
static ExStream<Long>	of(LongStream stream)	Create an instance from an existing IntStream.
static <T> ExStream<T>	of(Stream<T> stream)	Create an instance from an existing Stream.
static <T> ExStream<T>	of(T t)	Returns an instance containing a single element.
static <T> ExStream<T>	of(T... values)	Returns an instance whose elements are the specified values.
static <T> ExStream<T>	ofNullable(@Nullable T t)	Returns an instance containing a single element, if non-null, otherwise returns an empty instance.
ExStream<T>	peek(Consumer<? super T> action)
ExStream<T>	skip(long n)
ExStream<T>	sorted()
ExStream<T>	sorted(Comparator<? super T> comparator)
ExStream<T>	takeWhile(Predicate<? super T> predicate)

Methods inherited from class Object

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

Methods inherited from interface BaseStream

close, isParallel, iterator, onClose, parallel, sequential, spliterator, unordered

Methods inherited from interface Stream

allMatch, anyMatch, collect, collect, count, findAny, findFirst, forEach, forEachOrdered, max, min, noneMatch, reduce, reduce, reduce, toArray, toArray, toList

Method Details

of

public static <T> ExStream<T> of(Stream<T> stream)

Create an instance from an existing Stream.

Type Parameters:

T - the type of the stream elements

Parameters:

stream - existing stream

Returns:

instance from an existing Stream

of

public static ExStream<Double> of(DoubleStream stream)

Create an instance from an existing DoubleStream.

Parameters:

stream - existing stream

Returns:

instance from an existing Stream

of

public static ExStream<Integer> of(IntStream stream)

Create an instance from an existing IntStream.

Parameters:

stream - existing stream

Returns:

instance from an existing Stream

of

public static ExStream<Long> of(LongStream stream)

Create an instance from an existing IntStream.

Parameters:

stream - existing stream

Returns:

instance from an existing Stream

of

public static <T> ExStream<T> of(Collection<T> collection)

Create an instance from a collection.

Type Parameters:

T - the type of the stream elements

Parameters:

collection - collection

Returns:

instance from a collection

empty

public static <T> ExStream<T> empty()

Returns an empty instance.

Type Parameters:

T - the type of the stream elements

Returns:

an empty instance

of

public static <T> ExStream<T> of(T t)

Returns an instance containing a single element.

Type Parameters:

T - the type of the stream elements

Parameters:

t - the single element

Returns:

an instance containing a single element

ofNullable

public static <T> ExStream<T> ofNullable(@Nullable T t)

Returns an instance containing a single element, if non-null, otherwise returns an empty instance.

Type Parameters:

T - the type of stream elements

Parameters:

t - the single element

Returns:

a stream with a single element if the specified element is non-null, otherwise an empty stream

of

@SafeVarargs
public static <T> ExStream<T> of(T... values)

Returns an instance whose elements are the specified values.

Type Parameters:

T - the type of the stream elements

Parameters:

values - the elements of the new stream

Returns:

the new instance

filter

public ExStream<T> filter(Predicate<? super T> predicate)

Specified by:

filter in interface Stream<T>

map

public <R> ExStream<R> map(Function<? super T, ? extends R> mapper)

Specified by:

map in interface Stream<T>

flatMap

public <R> ExStream<R> flatMap(Function<? super T, ? extends Stream<? extends R>> mapper)

Specified by:

flatMap in interface Stream<T>

mapMulti

public <R> ExStream<R> mapMulti(BiConsumer<? super T, ? super Consumer<R>> mapper)

Specified by:

mapMulti in interface Stream<T>

distinct

public ExStream<T> distinct()

Specified by:

distinct in interface Stream<T>

sorted

public ExStream<T> sorted()

Specified by:

sorted in interface Stream<T>

sorted

public ExStream<T> sorted(Comparator<? super T> comparator)

Specified by:

sorted in interface Stream<T>

peek

public ExStream<T> peek(Consumer<? super T> action)

Specified by:

peek in interface Stream<T>

limit

public ExStream<T> limit(long maxSize)

Specified by:

limit in interface Stream<T>

skip

public ExStream<T> skip(long n)

Specified by:

skip in interface Stream<T>

takeWhile

public ExStream<T> takeWhile(Predicate<? super T> predicate)

Specified by:

takeWhile in interface Stream<T>

dropWhile

public ExStream<T> dropWhile(Predicate<? super T> predicate)

Specified by:

dropWhile in interface Stream<T>

mapToDouble

public ExDoubleStream mapToDouble(ToDoubleFunction<? super T> mapper)

Specified by:

mapToDouble in interface Stream<T>

flatMapToDouble

public ExDoubleStream flatMapToDouble(Function<? super T, ? extends DoubleStream> mapper)

Specified by:

flatMapToDouble in interface Stream<T>

mapMultiToDouble

public ExDoubleStream mapMultiToDouble(BiConsumer<? super T, ? super DoubleConsumer> mapper)

Specified by:

mapMultiToDouble in interface Stream<T>

mapToInt

public ExIntStream mapToInt(ToIntFunction<? super T> mapper)

Specified by:

mapToInt in interface Stream<T>

flatMapToInt

public ExIntStream flatMapToInt(Function<? super T, ? extends IntStream> mapper)

Specified by:

flatMapToInt in interface Stream<T>

mapMultiToInt

public ExIntStream mapMultiToInt(BiConsumer<? super T, ? super IntConsumer> mapper)

Specified by:

mapMultiToInt in interface Stream<T>

mapToLong

public ExLongStream mapToLong(ToLongFunction<? super T> mapper)

Specified by:

mapToLong in interface Stream<T>

flatMapToLong

public ExLongStream flatMapToLong(Function<? super T, ? extends LongStream> mapper)

Specified by:

flatMapToLong in interface Stream<T>

mapMultiToLong

public ExLongStream mapMultiToLong(BiConsumer<? super T, ? super LongConsumer> mapper)

Specified by:

mapMultiToLong in interface Stream<T>

exFilter

public ExStream<T> exFilter(ExPredicate<? super T, ?> predicate)

Equivalent of Stream.filter(Predicate).

If predicate throws a checked exception, a ExException will be thrown instead. This will have the original exception as its cause.

Note that this exception will likely not be thrown when a method is called, but only when a terminal operation or a stateful intermediate operation is used on the stream.

Parameters:

predicate - see Stream.filter(Predicate)

Returns:

see Stream.filter(Predicate)

exMap

public <R> ExStream<R> exMap(ExFunction<? super T, ? extends R, ?> mapper)

Equivalent of Stream.map(Function).

If mapper throws a checked exception, a ExException will be thrown instead. This will have the original exception as its cause.

Note that this exception will likely not be thrown when a method is called, but only when a terminal operation or a stateful intermediate operation is used on the stream.

Type Parameters:

R - The element type of the new stream

Parameters:

mapper - see Stream.map(Function)

Returns:

see Stream.map(Function)

exMapToDouble

public ExDoubleStream exMapToDouble(ExToDoubleFunction<? super T, ?> mapper)

Equivalent of Stream.mapToDouble(ToDoubleFunction).

If mapper throws a checked exception, a ExException will be thrown instead. This will have the original exception as its cause.

Note that this exception will likely not be thrown when a method is called, but only when a terminal operation or a stateful intermediate operation is used on the stream.

Parameters:

mapper - see Stream.mapToDouble(ToDoubleFunction)

Returns:

see Stream.mapToDouble(ToDoubleFunction)

exMapToInt

public ExIntStream exMapToInt(ExToIntFunction<? super T, ?> mapper)

Equivalent of Stream.mapToInt(ToIntFunction).

If mapper throws a checked exception, a ExException will be thrown instead. This will have the original exception as its cause.

Note that this exception will likely not be thrown when a method is called, but only when a terminal operation or a stateful intermediate operation is used on the stream.

Parameters:

mapper - see Stream.mapToInt(ToIntFunction)

Returns:

see Stream.mapToInt(ToIntFunction)

exMapToLong

public ExLongStream exMapToLong(ExToLongFunction<? super T, ?> mapper)

Equivalent of Stream.mapToLong(ToLongFunction).

If mapper throws a checked exception, a ExException will be thrown instead. This will have the original exception as its cause.

Note that this exception will likely not be thrown when a method is called, but only when a terminal operation or a stateful intermediate operation is used on the stream.

Parameters:

mapper - see Stream.mapToLong(ToLongFunction)

Returns:

see Stream.mapToLong(ToLongFunction)

exFlatMap

public <R> ExStream<R> exFlatMap(ExFunction<? super T, ? extends Stream<? extends R>, ?> mapper)

Equivalent of Stream.flatMap(Function).

If mapper throws a checked exception, a ExException will be thrown instead. This will have the original exception as its cause.

Note that this exception will likely not be thrown when a method is called, but only when a terminal operation or a stateful intermediate operation is used on the stream.

Type Parameters:

R - The element type of the new stream

Parameters:

mapper - see Stream.flatMap(Function)

Returns:

see Stream.flatMap(Function)

exFlatMapToDouble

public ExDoubleStream exFlatMapToDouble(ExFunction<? super T, ? extends DoubleStream, ?> mapper)

Equivalent of Stream.flatMapToDouble(Function).

If mapper throws a checked exception, a ExException will be thrown instead. This will have the original exception as its cause.

Note that this exception will likely not be thrown when a method is called, but only when a terminal operation or a stateful intermediate operation is used on the stream.

Parameters:

mapper - see Stream.flatMapToDouble(Function)

Returns:

see Stream.flatMapToDouble(Function)

exFlatMapToInt

public ExIntStream exFlatMapToInt(ExFunction<? super T, ? extends IntStream, ?> mapper)

Equivalent of Stream.flatMapToInt(Function).

If mapper throws a checked exception, a ExException will be thrown instead. This will have the original exception as its cause.

Note that this exception will likely not be thrown when a method is called, but only when a terminal operation or a stateful intermediate operation is used on the stream.

Parameters:

mapper - see Stream.flatMapToInt(Function)

Returns:

see Stream.flatMapToInt(Function)

exFlatMapToLong

public ExLongStream exFlatMapToLong(ExFunction<? super T, ? extends LongStream, ?> mapper)

Equivalent of Stream.flatMapToLong(Function).

If mapper throws a checked exception, a ExException will be thrown instead. This will have the original exception as its cause.

Note that this exception will likely not be thrown when a method is called, but only when a terminal operation or a stateful intermediate operation is used on the stream.

Parameters:

mapper - see Stream.flatMapToLong(Function)

Returns:

see Stream.flatMapToLong(Function)

exMapMulti

public <R> ExStream<R> exMapMulti(ExBiConsumer<? super T, ? super Consumer<R>, ?> mapper)

Equivalent of Stream.mapMulti(BiConsumer).

If mapper throws a checked exception, a ExException will be thrown instead. This will have the original exception as its cause.

Note that this exception will likely not be thrown when a method is called, but only when a terminal operation or a stateful intermediate operation is used on the stream.

Type Parameters:

R - The element type of the new stream

Parameters:

mapper - see Stream.mapMulti(BiConsumer)

Returns:

see Stream.mapMulti(BiConsumer)

exMapMultiToDouble

public ExDoubleStream exMapMultiToDouble(ExBiConsumer<? super T, ? super DoubleConsumer, ?> mapper)

Equivalent of Stream.mapMultiToDouble(BiConsumer).

If mapper throws a checked exception, a ExException will be thrown instead. This will have the original exception as its cause.

Note that this exception will likely not be thrown when a method is called, but only when a terminal operation or a stateful intermediate operation is used on the stream.

Parameters:

mapper - see Stream.mapMultiToDouble(BiConsumer)

Returns:

see Stream.mapMultiToDouble(BiConsumer)

exMapMultiToInt

public ExIntStream exMapMultiToInt(ExBiConsumer<? super T, ? super IntConsumer, ?> mapper)

Equivalent of Stream.mapMultiToInt(BiConsumer).

If mapper throws a checked exception, a ExException will be thrown instead. This will have the original exception as its cause.

Note that this exception will likely not be thrown when a method is called, but only when a terminal operation or a stateful intermediate operation is used on the stream.

Parameters:

mapper - see Stream.mapMultiToInt(BiConsumer)

Returns:

see Stream.mapMultiToInt(BiConsumer)

exMapMultiToLong

public ExLongStream exMapMultiToLong(ExBiConsumer<? super T, ? super LongConsumer, ?> mapper)

Equivalent of Stream.mapMultiToLong(BiConsumer).

If mapper throws a checked exception, a ExException will be thrown instead. This will have the original exception as its cause.

Note that this exception will likely not be thrown when a method is called, but only when a terminal operation or a stateful intermediate operation is used on the stream.

Parameters:

mapper - see Stream.mapMultiToLong(BiConsumer)

Returns:

see Stream.mapMultiToLong(BiConsumer)

exPeek

public ExStream<T> exPeek(ExConsumer<? super T, ?> action)

Equivalent of Stream.peek(Consumer).

If action throws a checked exception, a ExException will be thrown instead. This will have the original exception as its cause.

Parameters:

action - see Stream.peek(Consumer)

Returns:

see Stream.peek(Consumer)

exTakeWhile

public ExStream<T> exTakeWhile(ExPredicate<? super T, ?> predicate)

Equivalent of Stream.takeWhile(Predicate).

If predicate throws a checked exception, a ExException will be thrown instead. This will have the original exception as its cause.

Parameters:

predicate - see Stream.takeWhile(Predicate)

Returns:

see Stream.takeWhile(Predicate)

exDropWhile

public ExStream<T> exDropWhile(ExPredicate<? super T, ?> predicate)

Equivalent of Stream.dropWhile(Predicate).

If predicate throws a checked exception, a ExException will be thrown instead. This will have the original exception as its cause.

Note that this exception will likely not be thrown when this method is called, but only when a terminal operation like Stream.toList() is used on the stream.

Parameters:

predicate - see Stream.dropWhile(Predicate)

Returns:

see Stream.dropWhile(Predicate)

exForEach

public void exForEach(ExConsumer<? super T, ?> action)

Equivalent of Stream.forEach(Consumer).

If action throws a checked exception, a ExException will be thrown instead. This will have the original exception as its cause.

Parameters:

action - see Stream.forEach(Consumer)

exForEachOrdered

public void exForEachOrdered(ExConsumer<? super T, ?> action)

Equivalent of Stream.forEachOrdered(Consumer).

If action throws a checked exception, a ExException will be thrown instead. This will have the original exception as its cause.

Parameters:

action - see Stream.forEachOrdered(Consumer)

exReduce

public Optional<T> exReduce(ExBinaryOperator<T,?> accumulator)

Equivalent of Stream.reduce(BinaryOperator).

If accumulator throws a checked exception, a ExException will be thrown instead. This will have the original exception as its cause.

Parameters:

accumulator - see Stream.reduce(BinaryOperator)

Returns:

see Stream.reduce(BinaryOperator)

exReduce

public T exReduce(T identity,
 ExBinaryOperator<T,?> accumulator)

Equivalent of Stream.reduce(Object, BinaryOperator).

If accumulator throws a checked exception, a ExException will be thrown instead. This will have the original exception as its cause.

Parameters:

identity - see Stream.reduce(Object, BiFunction, BinaryOperator)

accumulator - see Stream.reduce(Object, BinaryOperator)

Returns:

see Stream.reduce(Object, BinaryOperator)

exReduce

public <U> U exReduce(U identity,
 ExBiFunction<U, ? super T, U, ?> accumulator,
 ExBinaryOperator<U,?> combiner)

Equivalent of Stream.reduce(Object, BiFunction, BinaryOperator).

If accumulator or combiner throw a checked exception, a ExException will be thrown instead. This will have the original exception as its cause.

Type Parameters:

U - the element type of the new stream

Parameters:

identity - see Stream.reduce(Object, BiFunction, BinaryOperator)

accumulator - see Stream.reduce(Object, BiFunction, BinaryOperator)

combiner - see Stream.reduce(Object, BiFunction, BinaryOperator)

Returns:

see Stream.reduce(Object, BiFunction, BinaryOperator)

exCollect

public <R> R exCollect(ExSupplier<R,?> supplier,
 ExBiConsumer<R, ? super T, ?> accumulator,
 ExBiConsumer<R,R,?> combiner)

Equivalent of Stream.collect(Supplier, BiConsumer, BiConsumer).

If supplier, accumulator or combiner throw a checked exception, a ExException will be thrown instead. This will have the original exception as its cause.

Type Parameters:

R - the type of the mutable result container

Parameters:

supplier - see Stream.collect(Supplier, BiConsumer, BiConsumer)

accumulator - see Stream.collect(Supplier, BiConsumer, BiConsumer)

combiner - see Stream.collect(Supplier, BiConsumer, BiConsumer)

Returns:

see Stream.collect(Supplier, BiConsumer, BiConsumer)