uk.co.strangeskies.collection.stream

Class StreamUtilities

java.lang.Object

uk.co.strangeskies.collection.stream.StreamUtilities

public class StreamUtilities
extends java.lang.Object

A collection of static utility methods for working with streams.

Method Summary

Modifier and Type	Method and Description
static <A,B> java.util.stream.Collector<java.util.Map.Entry<? extends A,? extends B>,?,java.util.Map<A,B>>	entriesToMap()
static boolean	equals(java.util.stream.Stream<?> first, java.util.stream.Stream<?> second)
static <T> java.util.stream.Stream<T>	flatMapRecursive(java.util.stream.Stream<? extends T> stream, java.util.function.Function<? super T,? extends java.util.stream.Stream<? extends T>> mapping) Generate a stream which recursively traverses depth-first over the elements of some nested data structure starting from those in a given stream.
static <T> java.util.stream.Stream<T>	flatMapRecursive(T root, java.util.function.Function<? super T,? extends java.util.stream.Stream<? extends T>> mapping) Generate a stream which recursively traverses depth-first over the elements of some nested data structure starting from its root.
static <T> java.util.stream.Stream<T>	flatMapRecursiveDistinct(java.util.stream.Stream<? extends T> stream, java.util.function.Function<? super T,? extends java.util.stream.Stream<? extends T>> mapping) Generate a stream which recursively traverses depth-first over the elements of some nested data structure starting from those in a given stream.
protected static <T> java.util.stream.Stream<T>	flatMapRecursiveDistinct(java.util.stream.Stream<? extends T> stream, java.util.function.Function<? super T,? extends java.util.stream.Stream<? extends T>> mapping, java.util.Set<T> visited)
static <T> java.util.stream.Stream<T>	flatMapRecursiveDistinct(T root, java.util.function.Function<? super T,? extends java.util.stream.Stream<? extends T>> mapping) Generate a stream which recursively traverses depth-first over the elements of some nested data structure starting from its root.
static <T> java.util.stream.Stream<T>	iterate(T root, java.util.function.Function<? super T,? extends T> mapping) A bit like Stream.iterate(Object, UnaryOperator) but not completely and utterly useless because it actually supports termination.
static <T> java.util.stream.Stream<T>	iterateOptional(java.util.Optional<? extends T> root, java.util.function.Function<? super T,java.util.Optional<? extends T>> mapping) A bit like Stream.iterate(Object, UnaryOperator) but not completely and utterly useless because it actually supports termination.
static <T> java.util.stream.Stream<T>	iterateOptional(T root, java.util.function.Function<? super T,java.util.Optional<? extends T>> mapping) A bit like Stream.iterate(Object, UnaryOperator) but not completely and utterly useless because it actually supports termination.
static <T> java.util.stream.Stream<T>	reverse(java.util.stream.Stream<? extends T> stream)
static <T> java.util.stream.Stream<T>	streamNullable(T optional)
static <T> java.util.stream.Stream<T>	streamOptional(java.util.Optional<? extends T> optional)
static <T> java.util.function.BinaryOperator<T>	throwingReduce()
static <T> java.util.function.BinaryOperator<T>	throwingReduce(java.util.function.BiFunction<T,T,java.lang.RuntimeException> exception)
static <T> java.util.function.BinaryOperator<T>	throwingSerialCombiner()
static <T> java.util.Optional<T>	tryOptional(java.util.function.Supplier<T> attempt, java.util.function.Consumer<? super java.lang.RuntimeException> exceptions)
static <T> java.util.Optional<T>	tryOptional(ThrowingSupplier<? extends T,?> attempt)
static <T,E extends java.lang.Exception> java.util.Optional<T>	tryOptional(ThrowingSupplier<? extends T,E> attempt, java.util.function.Consumer<? super java.lang.Exception> runtimeExceptions, java.util.function.Consumer<? super E> checkedExceptions)
static <T> java.util.Optional<T>	upcastOptional(java.util.Optional<? extends T> stream)
static <T> java.util.stream.Stream<T>	upcastStream(java.util.stream.Stream<? extends T> stream)
static <A,B> java.util.stream.Stream<java.util.Map.Entry<A,B>>	zip(java.util.stream.Stream<A> first, java.util.stream.Stream<B> second)
static <A,B,R> java.util.stream.Stream<R>	zip(java.util.stream.Stream<A> first, java.util.stream.Stream<B> second, java.util.function.BiFunction<A,B,R> combiner)
static <A,B,R> java.util.stream.Stream<R>	zip(java.util.stream.Stream<A> first, java.util.stream.Stream<B> second, java.util.function.BiFunction<A,B,R> combiner, java.util.function.Supplier<java.lang.RuntimeException> mismatchedStreams)
static <A,B> java.util.stream.Stream<java.util.Map.Entry<A,B>>	zip(java.util.stream.Stream<A> first, java.util.stream.Stream<B> second, java.util.function.Supplier<java.lang.RuntimeException> mismatchedStreams)

Methods inherited from class java.lang.Object

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

Method Detail

throwingSerialCombiner

public static <T> java.util.function.BinaryOperator<T> throwingSerialCombiner()

throwingReduce

public static <T> java.util.function.BinaryOperator<T> throwingReduce()

throwingReduce

public static <T> java.util.function.BinaryOperator<T> throwingReduce(java.util.function.BiFunction<T,T,java.lang.RuntimeException> exception)

equals

public static boolean equals(java.util.stream.Stream<?> first,
                             java.util.stream.Stream<?> second)

upcastStream

public static <T> java.util.stream.Stream<T> upcastStream(java.util.stream.Stream<? extends T> stream)

upcastOptional

public static <T> java.util.Optional<T> upcastOptional(java.util.Optional<? extends T> stream)

streamOptional

public static <T> java.util.stream.Stream<T> streamOptional(java.util.Optional<? extends T> optional)

streamNullable

public static <T> java.util.stream.Stream<T> streamNullable(T optional)

tryOptional

public static <T> java.util.Optional<T> tryOptional(ThrowingSupplier<? extends T,?> attempt)

tryOptional

public static <T,E extends java.lang.Exception> java.util.Optional<T> tryOptional(ThrowingSupplier<? extends T,E> attempt,
                                                                                  java.util.function.Consumer<? super java.lang.Exception> runtimeExceptions,
                                                                                  java.util.function.Consumer<? super E> checkedExceptions)

tryOptional

public static <T> java.util.Optional<T> tryOptional(java.util.function.Supplier<T> attempt,
                                                    java.util.function.Consumer<? super java.lang.RuntimeException> exceptions)

entriesToMap

public static <A,B> java.util.stream.Collector<java.util.Map.Entry<? extends A,? extends B>,?,java.util.Map<A,B>> entriesToMap()

zip

public static <A,B> java.util.stream.Stream<java.util.Map.Entry<A,B>> zip(java.util.stream.Stream<A> first,
                                                                          java.util.stream.Stream<B> second)

zip

public static <A,B> java.util.stream.Stream<java.util.Map.Entry<A,B>> zip(java.util.stream.Stream<A> first,
                                                                          java.util.stream.Stream<B> second,
                                                                          java.util.function.Supplier<java.lang.RuntimeException> mismatchedStreams)

zip

public static <A,B,R> java.util.stream.Stream<R> zip(java.util.stream.Stream<A> first,
                                                     java.util.stream.Stream<B> second,
                                                     java.util.function.BiFunction<A,B,R> combiner)

zip

public static <A,B,R> java.util.stream.Stream<R> zip(java.util.stream.Stream<A> first,
                                                     java.util.stream.Stream<B> second,
                                                     java.util.function.BiFunction<A,B,R> combiner,
                                                     java.util.function.Supplier<java.lang.RuntimeException> mismatchedStreams)

reverse

public static <T> java.util.stream.Stream<T> reverse(java.util.stream.Stream<? extends T> stream)

Type Parameters:

T - the type of the stream elements

Parameters:

stream - an ordered stream

Returns:

a new stream over the elements contained in the given stream in reverse order

iterate

public static <T> java.util.stream.Stream<T> iterate(T root,
                                                     java.util.function.Function<? super T,? extends T> mapping)

A bit like Stream.iterate(Object, UnaryOperator) but not completely and utterly useless because it actually supports termination. TODO should hopefully be made redundant by takeWhile in Java 9

Type Parameters:

T - the type of the stream elements

Parameters:

root - the root element

mapping - a mapping from an element to the next element

Returns:

a stream over each element in sequence

iterateOptional

public static <T> java.util.stream.Stream<T> iterateOptional(T root,
                                                             java.util.function.Function<? super T,java.util.Optional<? extends T>> mapping)

A bit like Stream.iterate(Object, UnaryOperator) but not completely and utterly useless because it actually supports termination.

Type Parameters:

T - the type of the stream elements

Parameters:

root - the root element

mapping - a mapping from an element to the next element

Returns:

a stream over each element in sequence

iterateOptional

public static <T> java.util.stream.Stream<T> iterateOptional(java.util.Optional<? extends T> root,
                                                             java.util.function.Function<? super T,java.util.Optional<? extends T>> mapping)

A bit like Stream.iterate(Object, UnaryOperator) but not completely and utterly useless because it actually supports termination.

Type Parameters:

T - the type of the stream elements

Parameters:

root - the root element

mapping - a mapping from an element to the next element

Returns:

a stream over each element in sequence

flatMapRecursive

public static <T> java.util.stream.Stream<T> flatMapRecursive(T root,
                                                              java.util.function.Function<? super T,? extends java.util.stream.Stream<? extends T>> mapping)

Generate a stream which recursively traverses depth-first over the elements of some nested data structure starting from its root.

Type Parameters:

T - the type of the stream elements

Parameters:

root - the root element

mapping - a mapping from an element to a stream of its direct children

Returns:

a stream over the root and each of its children, as well as each of their children, in a depth first manner

flatMapRecursive

public static <T> java.util.stream.Stream<T> flatMapRecursive(java.util.stream.Stream<? extends T> stream,
                                                              java.util.function.Function<? super T,? extends java.util.stream.Stream<? extends T>> mapping)

Generate a stream which recursively traverses depth-first over the elements of some nested data structure starting from those in a given stream.

Type Parameters:

T - the type of the stream elements

Parameters:

stream - the stream of initial elements

mapping - a mapping from an element to a stream of its direct children

Returns:

a stream over elements in a tree and each of their children, as well as each of their children, in a depth first manner

flatMapRecursiveDistinct

public static <T> java.util.stream.Stream<T> flatMapRecursiveDistinct(T root,
                                                                      java.util.function.Function<? super T,? extends java.util.stream.Stream<? extends T>> mapping)

Generate a stream which recursively traverses depth-first over the elements of some nested data structure starting from its root.

Type Parameters:

T - the type of the stream elements

Parameters:

root - the root element

mapping - a mapping from an element to a stream of its direct children

Returns:

a stream over the root and each of its children, as well as each of their children, in a depth first manner

flatMapRecursiveDistinct

public static <T> java.util.stream.Stream<T> flatMapRecursiveDistinct(java.util.stream.Stream<? extends T> stream,
                                                                      java.util.function.Function<? super T,? extends java.util.stream.Stream<? extends T>> mapping)

Generate a stream which recursively traverses depth-first over the elements of some nested data structure starting from those in a given stream.

Repeated elements will be ignored.

Type Parameters:

T - the type of the stream elements

Parameters:

stream - the stream of initial elements

mapping - a mapping from an element to a stream of its direct children

Returns:

a stream over elements in a tree and each of their children, as well as each of their children, in a depth first manner

flatMapRecursiveDistinct

protected static <T> java.util.stream.Stream<T> flatMapRecursiveDistinct(java.util.stream.Stream<? extends T> stream,
                                                                         java.util.function.Function<? super T,? extends java.util.stream.Stream<? extends T>> mapping,
                                                                         java.util.Set<T> visited)