com.codepoetics.protonpack

Class StreamUtils

java.lang.Object

com.codepoetics.protonpack.StreamUtils

public final class StreamUtils
extends Object

Utility class providing static methods for performing various operations on Streams.

Method Summary

Modifier and Type	Method and Description
static <T> java.util.stream.Stream<List<T>>	aggregate(java.util.stream.Stream<T> source, java.util.function.BiPredicate<T,T> predicate) Aggregates items from source stream into list of items while supplied predicate is true when evaluated on previous and current item.
static <T> java.util.stream.Stream<List<T>>	aggregate(java.util.stream.Stream<T> source, int size) Aggregates items from source stream into list of items with fixed size
static <T> java.util.stream.Stream<List<T>>	aggregateOnListCondition(java.util.stream.Stream<T> source, java.util.function.BiPredicate<List<T>,T> predicate) Aggregates items from source stream.
static <T> java.util.stream.Stream<T>	cycle(T... items) Cycles through a set of items indefinitely.
static <T extends Comparable<T>> java.util.stream.Stream<List<T>>	groupRuns(java.util.stream.Stream<T> source) Constructs a stream that represents grouped run using the default comparator.
static <T> java.util.stream.Stream<List<T>>	groupRuns(java.util.stream.Stream<T> source, Comparator<T> comparator) Constructs a stream that represents grouped run using the custom comparator.
static java.util.stream.LongStream	indices() Constructs an infinite (although in practice bounded by Long.MAX_VALUE) stream of longs 0, 1, 2, 3...
static <T> java.util.stream.Stream<T>	interleave(java.util.function.Function<T[],Integer> selector, List<java.util.stream.Stream<T>> streams) Construct a stream which interleaves the supplied streams, picking items using the supplied selector function.
static <T> java.util.stream.Stream<T>	interleave(java.util.function.Function<T[],Integer> selector, java.util.stream.Stream<T>... streams) Construct a stream which interleaves the supplied streams, picking items using the supplied selector function.
static <T,O> java.util.stream.Stream<O>	merge(java.util.function.Supplier<O> unitSupplier, java.util.function.BiFunction<O,T,O> merger, java.util.stream.Stream<T>... streams) Construct a stream which merges together values from the supplied streams, somewhat in the manner of the stream constructed by zip(java.util.stream.Stream, java.util.stream.Stream, java.util.function.BiFunction), but for an arbitrary number of streams and using a merger to merge the values from multiple streams into an accumulator.
static <T> java.util.stream.Stream<List<T>>	mergeToList(java.util.stream.Stream<T>... streams) Construct a stream which merges together values from the supplied streams into lists of values, somewhat in the manner of the stream constructed by zip(java.util.stream.Stream, java.util.stream.Stream, java.util.function.BiFunction), but for an arbitrary number of streams.
static java.util.stream.DoubleStream	ofNullable(double[] nullable) Converts nullable float array into an empty stream, and non-null array into a stream.
static java.util.stream.IntStream	ofNullable(int[] nullable) Converts nullable int array into an empty stream, and non-null array into a stream.
static <T> java.util.stream.Stream<T>	ofNullable(Iterable<T> iterable) Converts a nullable Iterable into a Stream.
static java.util.stream.LongStream	ofNullable(long[] nullable) Converts nullable long array into an empty stream, and non-null array into a stream.
static <T> java.util.stream.Stream<T>	ofNullable(T[] nullable) Converts nullable array into an empty stream, and non-null array into a stream.
static <T> java.util.stream.Stream<T>	ofSingleNullable(T nullable) Converts nulls into an empty stream, and non-null values into a stream with one element.
static <T> java.util.stream.Stream<T>	reject(java.util.stream.Stream<T> source, java.util.function.Predicate<? super T> predicate) Filter with the condition negated.
static <T> java.util.stream.Stream<T>	skipUntil(java.util.stream.Stream<T> source, java.util.function.Predicate<T> condition) Construct a stream which skips values from the source stream for as long as they do not meet the supplied condition, then streams every remaining value as soon as the first value is found which does meet the condition.
static <T> java.util.stream.Stream<T>	skipUntilInclusive(java.util.stream.Stream<T> source, java.util.function.Predicate<T> condition) Construct a stream which skips values from the source stream up until but including the first value is found that satisfies the given condition.
static <T> java.util.stream.Stream<T>	skipWhile(java.util.stream.Stream<T> source, java.util.function.Predicate<T> condition) Construct a stream which skips values from the source stream for as long as they meet the supplied condition, then streams every remaining value as soon as the first value is found which does not meet the condition.
static <T> java.util.stream.Stream<T>	skipWhileInclusive(java.util.stream.Stream<T> source, java.util.function.Predicate<T> condition) Construct a stream which skips values from the source stream up until but including the first value is found that does not meet the given condition.
static <T> java.util.stream.Stream<T>	stream(Iterable<T> iterable) Converts an Iterable into a Stream.
static <T> java.util.stream.Stream<T>	stream(Optional<T> optional) Converts an Optional value to a stream of 0..1 values
static <T> java.util.stream.Stream<T>	streamNullable(T nullable) Deprecated. use ofSingleNullable(Object)
static <T> java.util.stream.Stream<T>	takeUntil(java.util.stream.Stream<T> source, java.util.function.Predicate<T> condition) Construct a stream which takes values from the source stream until one of them meets the supplied condition, and then stops.
static <T> java.util.stream.Stream<T>	takeUntilInclusive(java.util.stream.Stream<T> source, java.util.function.Predicate<T> condition) Construct a stream which takes values from the source stream until but including the first value that is encountered which meets the supplied condition.
static <T> java.util.stream.Stream<T>	takeWhile(java.util.stream.Stream<T> source, java.util.function.Predicate<T> condition) Construct a stream which takes values from the source stream for as long as they meet the supplied condition, and stops as soon as a value is encountered which does not meet the condition.
static <T> java.util.stream.Stream<T>	takeWhileInclusive(java.util.stream.Stream<T> source, java.util.function.Predicate<T> condition) Construct a stream which takes values from the source stream until but including the first value that is encountered which does not meet the condition.
static <T> java.util.stream.Stream<T>	unfold(T seed, java.util.function.Function<T,Optional<T>> generator) Construct a stream which takes the seed value and applies the generator to create the next value, feeding each new value back into the generator to create subsequent values.
static <T> java.util.stream.Stream<List<T>>	windowed(java.util.stream.Stream<T> source, int windowSize) Constructs a stream that is a windowed view of the source stream of the size window size with a default overlap of one item
static <T> java.util.stream.Stream<List<T>>	windowed(java.util.stream.Stream<T> source, int windowSize, int skip) Constructs a windowed stream where each element is a list of the window size and the skip is the offset from the start of each window.
static <T> java.util.stream.Stream<List<T>>	windowed(java.util.stream.Stream<T> source, int windowSize, int skip, boolean allowLesserSize) Constructs a windowed stream where each element is a list of the window size and the skip is the offset from the start of each window.
static <T,O> java.util.stream.Stream<O>	zip(List<java.util.stream.Stream<T>> streams, java.util.function.Function<List<T>,O> combiner) Zip together a list of streams until one of them runs out of values.
static <L,M,R,O> java.util.stream.Stream<O>	zip(java.util.stream.Stream<L> lefts, java.util.stream.Stream<M> middles, java.util.stream.Stream<R> rights, TriFunction<L,M,R,O> combiner) Zip together the "left", "middle" and "right" streams until any stream runs out of values.
static <L,R,O> java.util.stream.Stream<O>	zip(java.util.stream.Stream<L> lefts, java.util.stream.Stream<R> rights, java.util.function.BiFunction<L,R,O> combiner) Zip together the "left" and "right" streams until either runs out of values.
static <T> java.util.stream.Stream<Indexed<T>>	zipWithIndex(java.util.stream.Stream<T> source) Zip the source stream together with the stream of indices() to provide a stream of indexed values.

Methods inherited from class java.lang.Object

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

Method Detail

indices

public static java.util.stream.LongStream indices()

Constructs an infinite (although in practice bounded by Long.MAX_VALUE) stream of longs 0, 1, 2, 3... for use as indices.

Returns:

A stream of longs.

zipWithIndex

public static <T> java.util.stream.Stream<Indexed<T>> zipWithIndex(java.util.stream.Stream<T> source)

Zip the source stream together with the stream of indices() to provide a stream of indexed values.

Type Parameters:

T - The type over which the source stream streams.

Parameters:

source - The source stream.

Returns:

A stream of indexed values.

zip

public static <L,R,O> java.util.stream.Stream<O> zip(java.util.stream.Stream<L> lefts,
                                                     java.util.stream.Stream<R> rights,
                                                     java.util.function.BiFunction<L,R,O> combiner)

Zip together the "left" and "right" streams until either runs out of values. Each pair of values is combined into a single value using the supplied combiner function.

Type Parameters:

L - The type over which the "left" stream streams.

R - The type over which the "right" stream streams.

O - The type created by the combiner out of pairs of "left" and "right" values, over which the resulting stream streams.

Parameters:

lefts - The "left" stream to zip.

rights - The "right" stream to zip.

combiner - The function to combine "left" and "right" values.

Returns:

A stream of zipped values.

zip

public static <L,M,R,O> java.util.stream.Stream<O> zip(java.util.stream.Stream<L> lefts,
                                                       java.util.stream.Stream<M> middles,
                                                       java.util.stream.Stream<R> rights,
                                                       TriFunction<L,M,R,O> combiner)

Zip together the "left", "middle" and "right" streams until any stream runs out of values. Each triple of values is combined into a single value using the supplied combiner function.

Type Parameters:

L - The type over which the "left" stream streams.

M - The type over which the "middle" stream streams.

R - The type over which the "right" stream streams.

O - The type created by the combiner out of triples of "left", "middle" and "right" values, over which the resulting stream streams.

Parameters:

lefts - The "left" stream to zip.

middles - The "middle" stream to zip.

rights - The "right" stream to zip.

combiner - The function to combine "left", "middle" and "right" values.

Returns:

A stream of zipped values.

zip

public static <T,O> java.util.stream.Stream<O> zip(List<java.util.stream.Stream<T>> streams,
                                                   java.util.function.Function<List<T>,O> combiner)

Zip together a list of streams until one of them runs out of values. Each tuple of values is combined into a single value using the supplied combiner function.

Type Parameters:

T - The type over which the streams stream.

O - The type created by the combiner out of groups of values, over which the resulting stream streams.

Parameters:

streams - The streams to zip.

combiner - The function to combine the values.

Returns:

A stream of zipped values.

takeWhile

public static <T> java.util.stream.Stream<T> takeWhile(java.util.stream.Stream<T> source,
                                                       java.util.function.Predicate<T> condition)

Construct a stream which takes values from the source stream for as long as they meet the supplied condition, and stops as soon as a value is encountered which does not meet the condition.

Type Parameters:

T - The type over which the stream streams.

Parameters:

source - The source stream.

condition - The condition to apply to elements of the source stream.

Returns:

A condition-bounded stream.

takeWhileInclusive

public static <T> java.util.stream.Stream<T> takeWhileInclusive(java.util.stream.Stream<T> source,
                                                                java.util.function.Predicate<T> condition)

Construct a stream which takes values from the source stream until but including the first value that is encountered which does not meet the condition.

Type Parameters:

T - The type over which the stream streams.

Parameters:

source - The source stream.

condition - The condition to apply to elements of the source stream.

Returns:

A condition-bounded stream.

takeUntil

public static <T> java.util.stream.Stream<T> takeUntil(java.util.stream.Stream<T> source,
                                                       java.util.function.Predicate<T> condition)

Construct a stream which takes values from the source stream until one of them meets the supplied condition, and then stops.

Type Parameters:

T - The type over which the stream streams.

Parameters:

source - The source stream.

condition - The condition to apply to elements of the source stream.

Returns:

A condition-bounded stream.

takeUntilInclusive

public static <T> java.util.stream.Stream<T> takeUntilInclusive(java.util.stream.Stream<T> source,
                                                                java.util.function.Predicate<T> condition)

Construct a stream which takes values from the source stream until but including the first value that is encountered which meets the supplied condition.

Type Parameters:

T - The type over which the stream streams.

Parameters:

source - The source stream.

condition - The condition to apply to elements of the source stream.

Returns:

A condition-bounded stream.

skipWhile

public static <T> java.util.stream.Stream<T> skipWhile(java.util.stream.Stream<T> source,
                                                       java.util.function.Predicate<T> condition)

Construct a stream which skips values from the source stream for as long as they meet the supplied condition, then streams every remaining value as soon as the first value is found which does not meet the condition.

Type Parameters:

T - The type over which the stream streams.

Parameters:

source - The source stream.

condition - The condition to apply to elements of the source stream.

Returns:

An element-skipping stream.

skipWhileInclusive

public static <T> java.util.stream.Stream<T> skipWhileInclusive(java.util.stream.Stream<T> source,
                                                                java.util.function.Predicate<T> condition)

Construct a stream which skips values from the source stream up until but including the first value is found that does not meet the given condition.

Type Parameters:

T - The type over which the stream streams.

Parameters:

source - The source stream.

condition - The condition to apply to elements of the source stream.

Returns:

An element-skipping stream.

skipUntil

public static <T> java.util.stream.Stream<T> skipUntil(java.util.stream.Stream<T> source,
                                                       java.util.function.Predicate<T> condition)

Construct a stream which skips values from the source stream for as long as they do not meet the supplied condition, then streams every remaining value as soon as the first value is found which does meet the condition.

Type Parameters:

T - The type over which the stream streams.

Parameters:

source - The source stream.

condition - The condition to apply to elements of the source stream.

Returns:

An element-skipping stream.

skipUntilInclusive

public static <T> java.util.stream.Stream<T> skipUntilInclusive(java.util.stream.Stream<T> source,
                                                                java.util.function.Predicate<T> condition)

Construct a stream which skips values from the source stream up until but including the first value is found that satisfies the given condition.

Type Parameters:

T - The type over which the stream streams.

Parameters:

source - The source stream.

condition - The condition to apply to elements of the source stream.

Returns:

An element-skipping stream.

unfold

public static <T> java.util.stream.Stream<T> unfold(T seed,
                                                    java.util.function.Function<T,Optional<T>> generator)

Construct a stream which takes the seed value and applies the generator to create the next value, feeding each new value back into the generator to create subsequent values. If the generator returns Optional.empty(), then the stream has no more values.

Type Parameters:

T - The type over which the stream streams.

Parameters:

seed - The seed value.

generator - The generator to use to create new values.

Returns:

An unfolding stream.

windowed

public static <T> java.util.stream.Stream<List<T>> windowed(java.util.stream.Stream<T> source,
                                                            int windowSize)

Constructs a stream that is a windowed view of the source stream of the size window size with a default overlap of one item

Type Parameters:

T - The type over which to stream

Parameters:

source - The source stream

windowSize - The window size

Returns:

A stream of lists representing the window

windowed

public static <T> java.util.stream.Stream<List<T>> windowed(java.util.stream.Stream<T> source,
                                                            int windowSize,
                                                            int skip)

Constructs a windowed stream where each element is a list of the window size and the skip is the offset from the start of each window. For example, a skip of size 1 is a traditional window a la ([1, 2, 3], [2, 3, 4] ...). A skip of size 2 for a window of size 3 would look like ([1, 2, 3], [3, 4, 5], ...) If the stream finishes, the last window is guaranteed to be of the desired size (possible data loss). A stream [1, 2, 3] with a size 2 and skip 2 will result in ([1,2])

Type Parameters:

T - The type over which to stream

Parameters:

source - The input stream

windowSize - The window size

skip - The skip amount between windows

Returns:

A stream of lists representing the windows

windowed

public static <T> java.util.stream.Stream<List<T>> windowed(java.util.stream.Stream<T> source,
                                                            int windowSize,
                                                            int skip,
                                                            boolean allowLesserSize)

Constructs a windowed stream where each element is a list of the window size and the skip is the offset from the start of each window. For example, a skip of size 1 is a traditional window a la ([1, 2, 3], [2, 3, 4] ...). A skip of size 2 for a window of size 3 would look like ([1, 2, 3], [3, 4, 5], ...) If the stream finishes, the last windows may have a window size lesser than the desired size. This is allowed via the allowLesserSize parameter.

Type Parameters:

T - The type over which to stream

Parameters:

source - The input stream

windowSize - The window size

skip - The skip amount between windows

allowLesserSize - Allow end of stream windows to have a lower size for completion

Returns:

A stream of lists representing the windows

groupRuns

public static <T extends Comparable<T>> java.util.stream.Stream<List<T>> groupRuns(java.util.stream.Stream<T> source)

Constructs a stream that represents grouped run using the default comparator. This means that similar elements will get grouped into a list. I.e. given a list of [1,1,2,3,4,4] you will get a stream of ([1,1], [2], [3], [4, 4])

Type Parameters:

T - The type over which to stream

Parameters:

source - The input stream

Returns:

A stream of lists of grouped runs

groupRuns

public static <T> java.util.stream.Stream<List<T>> groupRuns(java.util.stream.Stream<T> source,
                                                             Comparator<T> comparator)

Constructs a stream that represents grouped run using the custom comparator. This means that similar elements will get grouped into a list. I.e. given a list of [1,1,2,3,4,4] you will get a stream of ([1,1], [2], [3], [4, 4])

Type Parameters:

T - The type over which to stream

Parameters:

source - The input stream

comparator - The comparator to determine if neighbor elements are the same

Returns:

A stream of lists of grouped runs

interleave

@SafeVarargs
public static <T> java.util.stream.Stream<T> interleave(java.util.function.Function<T[],Integer> selector,
                                                                     java.util.stream.Stream<T>... streams)

Construct a stream which interleaves the supplied streams, picking items using the supplied selector function. The selector function will be passed an array containing one value from each stream, or null if that stream has no more values, and must return the integer index of the value to accept. That value will become part of the interleaved stream, and the source stream at that index will advance to the next value. See the Selectors class for ready-made selectors for round-robin and sorted item selection.

Type Parameters:

T - The type over which the interleaved streams stream.

Parameters:

selector - The selector function to use.

streams - The streams to interleave.

Returns:

An interleaved stream.

interleave

public static <T> java.util.stream.Stream<T> interleave(java.util.function.Function<T[],Integer> selector,
                                                        List<java.util.stream.Stream<T>> streams)

Construct a stream which interleaves the supplied streams, picking items using the supplied selector function. The selector function will be passed an array containing one value from each stream, or null if that stream has no more values, and must return the integer index of the value to accept. That value will become part of the interleaved stream, and the source stream at that index will advance to the next value. See the Selectors class for ready-made selectors for round-robin and sorted item selection.

Type Parameters:

T - The type over which the interleaved streams stream.

Parameters:

selector - The selector function to use.

streams - The streams to interleave.

Returns:

An interleaved stream.

merge

@SafeVarargs
public static <T,O> java.util.stream.Stream<O> merge(java.util.function.Supplier<O> unitSupplier,
                                                                  java.util.function.BiFunction<O,T,O> merger,
                                                                  java.util.stream.Stream<T>... streams)

Construct a stream which merges together values from the supplied streams, somewhat in the manner of the stream constructed by zip(java.util.stream.Stream, java.util.stream.Stream, java.util.function.BiFunction), but for an arbitrary number of streams and using a merger to merge the values from multiple streams into an accumulator.

Type Parameters:

T - The type over which the merged streams stream.

O - The type of the accumulator, over which the constructed stream streams.

Parameters:

unitSupplier - Supplies the initial "zero" or "unit" value for the accumulator.

merger - Merges each item from the collection of values taken from the source streams into the accumulator value.

streams - The streams to merge.

Returns:

A merging stream.

mergeToList

@SafeVarargs
public static <T> java.util.stream.Stream<List<T>> mergeToList(java.util.stream.Stream<T>... streams)

Construct a stream which merges together values from the supplied streams into lists of values, somewhat in the manner of the stream constructed by zip(java.util.stream.Stream, java.util.stream.Stream, java.util.function.BiFunction), but for an arbitrary number of streams.

Type Parameters:

T - The type over which the merged streams stream.

Parameters:

streams - The streams to merge.

Returns:

A merging stream of lists of T.

reject

public static <T> java.util.stream.Stream<T> reject(java.util.stream.Stream<T> source,
                                                    java.util.function.Predicate<? super T> predicate)

Filter with the condition negated. Will throw away any members of the source stream that match the condition.

Type Parameters:

T - The type over which the stream streams.

Parameters:

source - The source stream.

predicate - The filter condition.

Returns:

A rejecting stream.

aggregate

public static <T> java.util.stream.Stream<List<T>> aggregate(java.util.stream.Stream<T> source,
                                                             java.util.function.BiPredicate<T,T> predicate)

Aggregates items from source stream into list of items while supplied predicate is true when evaluated on previous and current item. Can by seen as streaming alternative to Collectors.groupingBy when source stream is sorted by key.

Type Parameters:

T - The type over which the stream streams.

Parameters:

source - - source stream

predicate - - predicate specifying boundary between groups of items

Returns:

Stream of List<T> aggregated according to predicate

aggregate

public static <T> java.util.stream.Stream<List<T>> aggregate(java.util.stream.Stream<T> source,
                                                             int size)

Aggregates items from source stream into list of items with fixed size

Type Parameters:

T - The type over which the stream streams.

Parameters:

source - - source stream

size - - size of the aggregated list

Returns:

Stream of List<T> with all list of size @size with possible exception of last List<T>

aggregateOnListCondition

public static <T> java.util.stream.Stream<List<T>> aggregateOnListCondition(java.util.stream.Stream<T> source,
                                                                            java.util.function.BiPredicate<List<T>,T> predicate)

Aggregates items from source stream. Similar to @aggregate, but uses different predicate, evaluated on all items aggregated so far and next item from source stream.

Type Parameters:

T - The type over which the stream streams.

Parameters:

source - - source stream

predicate - - predicate specifying boundary between groups of items

Returns:

Stream of List<T> aggregated according to predicate

streamNullable

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

Deprecated. use ofSingleNullable(Object)

Converts nulls into an empty stream, and non-null values into a stream with one element.

Type Parameters:

T - The type of the value.

Parameters:

nullable - The nullable value to convert.

Returns:

A stream of zero or one values.

ofSingleNullable

public static <T> java.util.stream.Stream<T> ofSingleNullable(T nullable)

Converts nulls into an empty stream, and non-null values into a stream with one element.

Type Parameters:

T - The type of the value.

Parameters:

nullable - The nullable value to convert.

Returns:

A stream of zero or one values.

stream

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

Converts an Optional value to a stream of 0..1 values

Type Parameters:

T - The type of the optional value

Parameters:

optional - source optional value

Returns:

Stream of a single item of type T or an empty stream

stream

public static <T> java.util.stream.Stream<T> stream(Iterable<T> iterable)

Converts an Iterable into a Stream.

Type Parameters:

T - The type of the iterable

Parameters:

iterable - The iterable to stream.

Returns:

Stream of the values returned by the iterable

ofNullable

public static <T> java.util.stream.Stream<T> ofNullable(Iterable<T> iterable)

Converts a nullable Iterable into a Stream.

Type Parameters:

T - The type of the iterable

Parameters:

iterable - The iterable to stream.

Returns:

Stream of the values returned by the iterable, or an empty stream if the iterable is null

ofNullable

public static java.util.stream.IntStream ofNullable(int[] nullable)

Converts nullable int array into an empty stream, and non-null array into a stream.

Parameters:

nullable - The nullable array to convert.

Returns:

A stream of zero or more values.

ofNullable

public static java.util.stream.LongStream ofNullable(long[] nullable)

Converts nullable long array into an empty stream, and non-null array into a stream.

Parameters:

nullable - The nullable array to convert.

Returns:

A stream of zero or more values.

ofNullable

public static java.util.stream.DoubleStream ofNullable(double[] nullable)

Converts nullable float array into an empty stream, and non-null array into a stream.

Parameters:

nullable - The nullable array to convert.

Returns:

A stream of zero or more values.

ofNullable

public static <T> java.util.stream.Stream<T> ofNullable(T[] nullable)

Converts nullable array into an empty stream, and non-null array into a stream.

Type Parameters:

T - The type of the value.

Parameters:

nullable - The nullable array to convert.

Returns:

A stream of zero or more values.

cycle

public static <T> java.util.stream.Stream<T> cycle(T... items)

Cycles through a set of items indefinitely.

Type Parameters:

T - The type of the items.

Parameters:

items - The items to cycle through.

Returns:

An infinite stream cycling through the supplied items.