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. map(Class, 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

<R, E extends Exception> R

collect(Class<E> exceptionClass, ExSupplier<R, ? extends E> supplier, ExBiConsumer<R, ? super T, ? extends E> accumulator, ExBiConsumer<R, R, ? extends E> combiner)

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

ExStream<T>

distinct()

<E extends Exception> ExStream<T>

dropWhile(Class<E> exceptionClass, ExPredicate<? super T, ? extends E> predicate)

Equivalent of Stream.dropWhile(Predicate).

ExStream<T>

dropWhile(Predicate<? super T> predicate)

static <T> ExStream<T>

empty()

Returns an empty instance.

<E extends Exception> ExStream<T>

filter(Class<E> exceptionClass, ExPredicate<? super T, ? extends E> predicate)

Equivalent of Stream.filter(Predicate).

ExStream<T>

filter(Predicate<? super T> predicate)

<R, E extends Exception> ExStream<R>

flatMap(Class<E> exceptionClass, ExFunction<? super T, ? extends Stream<? extends R>, ? extends E> mapper)

Equivalent of Stream.flatMap(Function).

<R> ExStream<R>

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

<E extends Exception> ExDoubleStream

flatMapToDouble(Class<E> exceptionClass, ExFunction<? super T, ? extends DoubleStream, ? extends E> mapper)

Equivalent of Stream.flatMapToDouble(Function).

ExDoubleStream

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

<E extends Exception> ExIntStream

flatMapToInt(Class<E> exceptionClass, ExFunction<? super T, ? extends IntStream, ? extends E> mapper)

Equivalent of Stream.flatMapToInt(Function).

ExIntStream

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

<E extends Exception> ExLongStream

flatMapToLong(Class<E> exceptionClass, ExFunction<? super T, ? extends LongStream, ? extends E> mapper)

Equivalent of Stream.flatMapToLong(Function).

ExLongStream

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

<E extends Exception> void

forEach(Class<E> exceptionClass, ExConsumer<? super T, ? extends E> action)

Equivalent of Stream.forEach(Consumer).

<E extends Exception> void

forEachOrdered(Class<E> exceptionClass, ExConsumer<? super T, ? extends E> action)

Equivalent of Stream.forEachOrdered(Consumer).

ExStream<T>

limit(long maxSize)

<R, E extends Exception> ExStream<R>

map(Class<E> exceptionClass, ExFunction<? super T, ? extends R, ? extends E> mapper)

Equivalent of Stream.map(Function).

<R> ExStream<R>

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

<R, E extends Exception> ExStream<R>

mapMulti(Class<E> exceptionClass, ExBiConsumer<? super T, ? super Consumer<R>, ? extends E> mapper)

Equivalent of Stream.mapMulti(BiConsumer).

<R> ExStream<R>

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

<E extends Exception> ExDoubleStream

mapMultiToDouble(Class<E> exceptionClass, ExBiConsumer<? super T, ? super DoubleConsumer, ? extends E> mapper)

Equivalent of Stream.mapMultiToDouble(BiConsumer).

ExDoubleStream

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

<E extends Exception> ExIntStream

mapMultiToInt(Class<E> exceptionClass, ExBiConsumer<? super T, ? super IntConsumer, ? extends E> mapper)

Equivalent of Stream.mapMultiToInt(BiConsumer).

ExIntStream

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

<E extends Exception> ExLongStream

mapMultiToLong(Class<E> exceptionClass, ExBiConsumer<? super T, ? super LongConsumer, ? extends E> mapper)

Equivalent of Stream.mapMultiToLong(BiConsumer).

ExLongStream

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

<E extends Exception> ExDoubleStream

mapToDouble(Class<E> exceptionClass, ExToDoubleFunction<? super T, ? extends E> mapper)

Equivalent of Stream.mapToDouble(ToDoubleFunction).

ExDoubleStream

mapToDouble(ToDoubleFunction<? super T> mapper)

<E extends Exception> ExIntStream

mapToInt(Class<E> exceptionClass, ExToIntFunction<? super T, ? extends E> mapper)

Equivalent of Stream.mapToInt(ToIntFunction).

ExIntStream

mapToInt(ToIntFunction<? super T> mapper)

<E extends Exception> ExLongStream

mapToLong(Class<E> exceptionClass, ExToLongFunction<? super T, ? extends E> mapper)

Equivalent of Stream.mapToLong(ToLongFunction).

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.

<E extends Exception> ExStream<T>

peek(Class<E> exceptionClass, ExConsumer<? super T, ? extends E> action)

Equivalent of Stream.peek(Consumer).

ExStream<T>

peek(Consumer<? super T> action)

<E extends Exception> Optional<T>

reduce(Class<E> exceptionClass, ExBinaryOperator<T, ? extends E> accumulator)

Equivalent of Stream.reduce(BinaryOperator).

<E extends Exception> T

reduce(Class<E> exceptionClass, T identity, ExBinaryOperator<T, ? extends E> accumulator)

Equivalent of Stream.reduce(Object, BinaryOperator).

<U, E extends Exception> U

reduce(Class<E> exceptionClass, U identity, ExBiFunction<U, ? super T, U, ? extends E> accumulator, ExBinaryOperator<U, ? extends E> combiner)

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

ExStream<T>

skip(long n)

ExStream<T>

sorted()

ExStream<T>

sorted(Comparator<? super T> comparator)

<E extends Exception> ExStream<T>

takeWhile(Class<E> exceptionClass, ExPredicate<? super T, ? extends E> predicate)

Equivalent of Stream.takeWhile(Predicate).

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>
- filter
  
  public <E extends Exception> ExStream<T> filter(Class<E> exceptionClass, ExPredicate<? super T, ? extends E> 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.
  
  Type Parameters:
  
  E - The exception type thrown by mapper
  
  Parameters:
  
  exceptionClass - The exception class for E
  
  predicate - see Stream.filter(Predicate)
  
  Returns:
  
  see Stream.filter(Predicate)
- map
  
  public <R, E extends Exception> ExStream<R> map(Class<E> exceptionClass, ExFunction<? super T, ? extends R, ? extends E> 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
  
  E - The exception type thrown by mapper
  
  Parameters:
  
  exceptionClass - The exception class for E
  
  mapper - see Stream.map(Function)
  
  Returns:
  
  see Stream.map(Function)
- mapToDouble
  
  public <E extends Exception> ExDoubleStream mapToDouble(Class<E> exceptionClass, ExToDoubleFunction<? super T, ? extends E> 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.
  
  Type Parameters:
  
  E - The exception type thrown by mapper
  
  Parameters:
  
  exceptionClass - The exception class for E
  
  mapper - see Stream.mapToDouble(ToDoubleFunction)
  
  Returns:
  
  see Stream.mapToDouble(ToDoubleFunction)
- mapToInt
  
  public <E extends Exception> ExIntStream mapToInt(Class<E> exceptionClass, ExToIntFunction<? super T, ? extends E> 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.
  
  Type Parameters:
  
  E - The exception type thrown by mapper
  
  Parameters:
  
  exceptionClass - The exception class for E
  
  mapper - see Stream.mapToInt(ToIntFunction)
  
  Returns:
  
  see Stream.mapToInt(ToIntFunction)
- mapToLong
  
  public <E extends Exception> ExLongStream mapToLong(Class<E> exceptionClass, ExToLongFunction<? super T, ? extends E> 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.
  
  Type Parameters:
  
  E - The exception type thrown by mapper
  
  Parameters:
  
  exceptionClass - The exception class for E
  
  mapper - see Stream.mapToLong(ToLongFunction)
  
  Returns:
  
  see Stream.mapToLong(ToLongFunction)
- flatMap
  
  public <R, E extends Exception> ExStream<R> flatMap(Class<E> exceptionClass, ExFunction<? super T, ? extends Stream<? extends R>, ? extends E> 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
  
  E - The exception type thrown by mapper
  
  Parameters:
  
  exceptionClass - The exception class for E
  
  mapper - see Stream.flatMap(Function)
  
  Returns:
  
  see Stream.flatMap(Function)
- flatMapToDouble
  
  public <E extends Exception> ExDoubleStream flatMapToDouble(Class<E> exceptionClass, ExFunction<? super T, ? extends DoubleStream, ? extends E> 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.
  
  Type Parameters:
  
  E - The exception type thrown by mapper
  
  Parameters:
  
  exceptionClass - The exception class for E
  
  mapper - see Stream.flatMapToDouble(Function)
  
  Returns:
  
  see Stream.flatMapToDouble(Function)
- flatMapToInt
  
  public <E extends Exception> ExIntStream flatMapToInt(Class<E> exceptionClass, ExFunction<? super T, ? extends IntStream, ? extends E> 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.
  
  Type Parameters:
  
  E - The exception type thrown by mapper
  
  Parameters:
  
  exceptionClass - The exception class for E
  
  mapper - see Stream.flatMapToInt(Function)
  
  Returns:
  
  see Stream.flatMapToInt(Function)
- flatMapToLong
  
  public <E extends Exception> ExLongStream flatMapToLong(Class<E> exceptionClass, ExFunction<? super T, ? extends LongStream, ? extends E> 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.
  
  Type Parameters:
  
  E - The exception type thrown by mapper
  
  Parameters:
  
  exceptionClass - The exception class for E
  
  mapper - see Stream.flatMapToLong(Function)
  
  Returns:
  
  see Stream.flatMapToLong(Function)
- mapMulti
  
  public <R, E extends Exception> ExStream<R> mapMulti(Class<E> exceptionClass, ExBiConsumer<? super T, ? super Consumer<R>, ? extends E> 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
  
  E - The exception type thrown by mapper
  
  Parameters:
  
  exceptionClass - The exception class for E
  
  mapper - see Stream.mapMulti(BiConsumer)
  
  Returns:
  
  see Stream.mapMulti(BiConsumer)
- mapMultiToDouble
  
  public <E extends Exception> ExDoubleStream mapMultiToDouble(Class<E> exceptionClass, ExBiConsumer<? super T, ? super DoubleConsumer, ? extends E> 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.
  
  Type Parameters:
  
  E - The exception type thrown by mapper
  
  Parameters:
  
  exceptionClass - The exception class for E
  
  mapper - see Stream.mapMultiToDouble(BiConsumer)
  
  Returns:
  
  see Stream.mapMultiToDouble(BiConsumer)
- mapMultiToInt
  
  public <E extends Exception> ExIntStream mapMultiToInt(Class<E> exceptionClass, ExBiConsumer<? super T, ? super IntConsumer, ? extends E> 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.
  
  Type Parameters:
  
  E - The exception type thrown by mapper
  
  Parameters:
  
  exceptionClass - The exception class for E
  
  mapper - see Stream.mapMultiToInt(BiConsumer)
  
  Returns:
  
  see Stream.mapMultiToInt(BiConsumer)
- mapMultiToLong
  
  public <E extends Exception> ExLongStream mapMultiToLong(Class<E> exceptionClass, ExBiConsumer<? super T, ? super LongConsumer, ? extends E> 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.
  
  Type Parameters:
  
  E - The exception type thrown by mapper
  
  Parameters:
  
  exceptionClass - The exception class for E
  
  mapper - see Stream.mapMultiToLong(BiConsumer)
  
  Returns:
  
  see Stream.mapMultiToLong(BiConsumer)
- peek
  
  public <E extends Exception> ExStream<T> peek(Class<E> exceptionClass, ExConsumer<? super T, ? extends E> 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.
  
  Type Parameters:
  
  E - The exception type thrown by action
  
  Parameters:
  
  exceptionClass - The exception class for E
  
  action - see Stream.peek(Consumer)
  
  Returns:
  
  see Stream.peek(Consumer)
- takeWhile
  
  public <E extends Exception> ExStream<T> takeWhile(Class<E> exceptionClass, ExPredicate<? super T, ? extends E> 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.
  
  Type Parameters:
  
  E - The exception type thrown by predicate
  
  Parameters:
  
  exceptionClass - The exception class for E
  
  predicate - see Stream.takeWhile(Predicate)
  
  Returns:
  
  see Stream.takeWhile(Predicate)
- dropWhile
  
  public <E extends Exception> ExStream<T> dropWhile(Class<E> exceptionClass, ExPredicate<? super T, ? extends E> 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.
  
  Type Parameters:
  
  E - The exception type thrown by predicate
  
  Parameters:
  
  exceptionClass - The exception class for E
  
  predicate - see Stream.dropWhile(Predicate)
  
  Returns:
  
  see Stream.dropWhile(Predicate)
- forEach
  
  public <E extends Exception> void forEach(Class<E> exceptionClass, ExConsumer<? super T, ? extends E> 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.
  
  Type Parameters:
  
  E - The exception type thrown by action
  
  Parameters:
  
  exceptionClass - The exception class for E
  
  action - see Stream.forEach(Consumer)
- forEachOrdered
  
  public <E extends Exception> void forEachOrdered(Class<E> exceptionClass, ExConsumer<? super T, ? extends E> 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.
  
  Type Parameters:
  
  E - The exception type thrown by action
  
  Parameters:
  
  exceptionClass - The exception class for E
  
  action - see Stream.forEachOrdered(Consumer)
- reduce
  
  public <E extends Exception> Optional<T> reduce(Class<E> exceptionClass, ExBinaryOperator<T, ? extends E> 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.
  
  Type Parameters:
  
  E - The exception type thrown by accumulator
  
  Parameters:
  
  exceptionClass - The exception class for E
  
  accumulator - see Stream.reduce(BinaryOperator)
  
  Returns:
  
  see Stream.reduce(BinaryOperator)
- reduce
  
  public <E extends Exception> T reduce(Class<E> exceptionClass, T identity, ExBinaryOperator<T, ? extends E> 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.
  
  Type Parameters:
  
  E - The exception type thrown by accumulator
  
  Parameters:
  
  exceptionClass - The exception class for E
  
  identity - see Stream.reduce(Object, BiFunction, BinaryOperator)
  
  accumulator - see Stream.reduce(Object, BinaryOperator)
  
  Returns:
  
  see Stream.reduce(Object, BinaryOperator)
- reduce
  
  public <U, E extends Exception> U reduce(Class<E> exceptionClass, U identity, ExBiFunction<U, ? super T, U, ? extends E> accumulator, ExBinaryOperator<U, ? extends E> 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
  
  E - The exception type thrown by accumulator or combiner
  
  Parameters:
  
  exceptionClass - The exception class for E
  
  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)
- collect
  
  public <R, E extends Exception> R collect(Class<E> exceptionClass, ExSupplier<R, ? extends E> supplier, ExBiConsumer<R, ? super T, ? extends E> accumulator, ExBiConsumer<R, R, ? extends E> 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
  
  E - The exception type thrown by supplier, accumulator or combiner
  
  Parameters:
  
  exceptionClass - The exception class for E
  
  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)

Class ExStream<T>

Nested Class Summary

Nested classes/interfaces inherited from interface Stream

Method Summary

Methods inherited from class Object

Methods inherited from interface BaseStream

Methods inherited from interface Stream

Method Details

of

of

of

of

of

empty

of

ofNullable

of

filter

map

flatMap

mapMulti

distinct

sorted

sorted

peek

limit

skip

takeWhile

dropWhile

mapToDouble

flatMapToDouble

mapMultiToDouble

mapToInt

flatMapToInt

mapMultiToInt

mapToLong

flatMapToLong

mapMultiToLong

filter

map

mapToDouble

mapToInt

mapToLong

flatMap

flatMapToDouble

flatMapToInt

flatMapToLong

mapMulti

mapMultiToDouble

mapMultiToInt

mapMultiToLong

peek

takeWhile

dropWhile

forEach

forEachOrdered

reduce

reduce

reduce

collect