StreamUtils (cyclops-react 1.0.4 API)

java.lang.Object
- com.aol.cyclops.control.StreamUtils

```
public class StreamUtils
extends java.lang.Object
```
Static utility methods for working with Java 8 Streams

Constructor Summary

Constructors
Constructor and Description

StreamUtils()

Constructors
Constructor and Description
`StreamUtils()`

Method Summary

All Methods Static Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`static <T> java.util.stream.Stream<T>`	`append(java.util.stream.Stream<T> stream, T... values)` Append values to the end of this SequenceM
`static <T> java.util.stream.Stream<T>`	`appendStream(java.util.stream.Stream<T> stream1, java.util.stream.Stream<T> append)` Append Stream to this SequenceM
`static <T> java.util.stream.Stream<ListX<T>>`	`batchBySize(java.util.stream.Stream<T> stream, int groupSize)` Deprecated.
`static <T,C extends java.util.Collection<? super T>> java.util.stream.Stream<C>`	`batchBySize(java.util.stream.Stream<T> stream, int groupSize, java.util.function.Supplier<C> factory)` Deprecated.
`static <T> java.util.stream.Stream<ListX<T>>`	`batchBySizeAndTime(java.util.stream.Stream<T> stream, int size, long time, java.util.concurrent.TimeUnit t)` Deprecated.
`static <T,C extends java.util.Collection<? super T>> java.util.stream.Stream<C>`	`batchBySizeAndTime(java.util.stream.Stream<T> stream, int size, long time, java.util.concurrent.TimeUnit t, java.util.function.Supplier<C> factory)` Deprecated.
`static <T> java.util.stream.Stream<ListX<T>>`	`batchByTime(java.util.stream.Stream<T> stream, long time, java.util.concurrent.TimeUnit t)` Deprecated.
`static <T,C extends java.util.Collection<? super T>> java.util.stream.Stream<C>`	`batchByTime(java.util.stream.Stream<T> stream, long time, java.util.concurrent.TimeUnit t, java.util.function.Supplier<C> factory)` Deprecated.
`static <T> java.util.stream.Stream<ListX<T>>`	`batchUntil(java.util.stream.Stream<T> stream, java.util.function.Predicate<? super T> predicate)` Deprecated.
`static <T> java.util.stream.Stream<ListX<T>>`	`batchWhile(java.util.stream.Stream<T> stream, java.util.function.Predicate<? super T> predicate)` Deprecated.
`static <T,C extends java.util.Collection<? super T>> java.util.stream.Stream<C>`	`batchWhile(java.util.stream.Stream<T> stream, java.util.function.Predicate<? super T> predicate, java.util.function.Supplier<C> factory)` Deprecated.
`static <T,U> java.util.stream.Stream<U>`	`cast(java.util.stream.Stream<T> stream, java.lang.Class<? extends U> type)` Cast all elements in a stream to a given type, possibly throwing a `ClassCastException`.
`static <T> java.util.stream.Stream<T>`	`combine(java.util.stream.Stream<T> stream, java.util.function.BiPredicate<? super T,? super T> predicate, java.util.function.BinaryOperator<T> op)`
`static <T> java.util.stream.Stream<T>`	`completableFutureToStream(java.util.concurrent.CompletableFuture<T> future)` Convert a CompletableFuture to a Stream
`static <U> java.util.stream.Stream<U>`	`concat(java.lang.Object o, java.util.stream.Stream<U> stream)` Concat an Object and a Stream If the Object is a Stream, Streamable or Iterable will be converted (or left) in Stream form and concatonated Otherwise a new Stream.of(o) is created
`static <U> java.util.stream.Stream<U>`	`cycle(int times, Streamable<U> s)` Create a Stream that finitely cycles the provided Streamable, provided number of times
`static <T> java.util.stream.Stream<T>`	`cycle(java.util.stream.Stream<T> stream, Monoid<T> m, int times)` Convert to a Stream with the result of a reduction operation repeated specified times
`static <U> java.util.stream.Stream<U>`	`cycle(java.util.stream.Stream<U> s)` Create a new Stream that infiniteable cycles the provided Stream
`static <U> java.util.stream.Stream<U>`	`cycle(Streamable<U> s)` Create a Stream that infiniteable cycles the provided Streamable
`static <T> java.util.stream.Stream<T>`	`cycleUntil(java.util.stream.Stream<T> stream, java.util.function.Predicate<? super T> predicate)` Repeat in a Stream until specified predicate holds
`static <T> java.util.stream.Stream<T>`	`cycleWhile(java.util.stream.Stream<T> stream, java.util.function.Predicate<? super T> predicate)` Repeat in a Stream while specified predicate holds
`static <T> java.util.stream.Stream<T>`	`debounce(java.util.stream.Stream<T> stream, long time, java.util.concurrent.TimeUnit t)` Allow one element through per time period, drop all other elements in that time period
`static <T> java.util.stream.Stream<T>`	`deleteBetween(java.util.stream.Stream<T> stream, int start, int end)` Delete elements between given indexes in a Stream
`static <T> org.jooq.lambda.tuple.Tuple2<java.util.stream.Stream<T>,java.util.stream.Stream<T>>`	`duplicate(java.util.stream.Stream<T> stream)` Duplicate a Stream, buffers intermediate values, leaders may change positions so a limit can be safely applied to the leading stream.
`static <T> boolean`	`endsWith(java.util.stream.Stream<T> stream, java.lang.Iterable<T> iterable)`
`static <T> T`	`firstValue(java.util.stream.Stream<T> stream)`
`static <T> java.util.stream.Stream<T>`	`fixedDelay(java.util.stream.Stream<T> stream, long time, java.util.concurrent.TimeUnit unit)`
`static <T,R> java.util.stream.Stream<R>`	`flatMapAnyM(java.util.stream.Stream<T> stream, java.util.function.Function<? super T,AnyM<? extends R>> fn)`
`static <T> java.util.stream.Stream<java.lang.String>`	`flatMapBufferedReader(java.util.stream.Stream<T> stream, java.util.function.Function<? super T,java.io.BufferedReader> fn)` Perform a flatMap operation where the result will be a flattened stream of Strings from the text loaded from the supplied BufferedReaders
`static <T> java.util.stream.Stream<java.lang.Character>`	`flatMapCharSequence(java.util.stream.Stream<T> stream, java.util.function.Function<? super T,java.lang.CharSequence> fn)` Perform a flatMap operation where the result will be a flattened stream of Characters from the CharSequence returned by the supplied function.
`static <T,R> java.util.stream.Stream<R>`	`flatMapCompletableFuture(java.util.stream.Stream<T> stream, java.util.function.Function<? super T,java.util.concurrent.CompletableFuture<? extends R>> fn)` `assertThat(StreamUtils.flatMapCompletableFuture(Stream.of(1,2,3), i->CompletableFuture.completedFuture(i+2)) .collect(Collectors.toList()), equalTo(Arrays.asList(3,4,5)));`
`static <T> java.util.stream.Stream<java.lang.String>`	`flatMapFile(java.util.stream.Stream<T> stream, java.util.function.Function<? super T,java.io.File> fn)` Perform a flatMap operation where the result will be a flattened stream of Strings from the text loaded from the supplied files.
`static <T,R> java.util.stream.Stream<R>`	`flatMapIterable(java.util.stream.Stream<T> stream, java.util.function.Function<? super T,? extends java.lang.Iterable<? extends R>> fn)` flatMap operation that allows a Collection to be returned
`static <T,R> java.util.stream.Stream<R>`	`flatMapOptional(java.util.stream.Stream<T> stream, java.util.function.Function<? super T,java.util.Optional<? extends R>> fn)` cross type flatMap, removes null entries
`static <T,R> java.util.stream.Stream<R>`	`flatMapSequenceM(java.util.stream.Stream<T> stream, java.util.function.Function<? super T,ReactiveSeq<? extends R>> fn)` flatMap operation
`static <T,R> java.util.stream.Stream<R>`	`flatMapStream(java.util.stream.Stream<T> stream, java.util.function.Function<? super T,? extends java.util.stream.BaseStream<? extends R,?>> fn)` `assertThat(StreamUtils.flatMapStream(Stream.of(1,2,3), i->Stream.of(i)).collect(Collectors.toList()), equalTo(Arrays.asList(1,2,3)));`
`static <T> java.util.stream.Stream<java.lang.String>`	`flatMapURL(java.util.stream.Stream<T> stream, java.util.function.Function<? super T,java.net.URL> fn)` Perform a flatMap operation where the result will be a flattened stream of Strings from the text loaded from the supplied URLs
`static <T,R> ReactiveSeq<R>`	`flatten(java.util.stream.Stream<T> stream)`
`static <T> T`	`foldLeft(java.util.stream.Stream<T> stream, Monoid<T> reducer)`
`static <T> T`	`foldLeftMapToType(java.util.stream.Stream<T> stream, Reducer<T> reducer)` Attempt to map this Monad to the same type as the supplied Monoid (using mapToType on the monoid interface) Then use Monoid to reduce values
`static <T> T`	`foldRight(java.util.stream.Stream<T> stream, Monoid<T> reducer)`
`static <T> T`	`foldRightMapToType(java.util.stream.Stream<T> stream, Reducer<T> reducer)` Attempt to map this Monad to the same type as the supplied Monoid (using mapToType on the monoid interface) Then use Monoid to reduce values
`static <T,X extends java.lang.Throwable> void`	`forEachEvent(java.util.stream.Stream<T> stream, java.util.function.Consumer<? super T> consumerElement, java.util.function.Consumer<? super java.lang.Throwable> consumerError, java.lang.Runnable onComplete)` Perform a forEach operation over the Stream capturing any elements and errors in the supplied consumers when the entire Stream has been processed an onComplete event will be recieved.
`static <T,X extends java.lang.Throwable> void`	`forEachWithError(java.util.stream.Stream<T> stream, java.util.function.Consumer<? super T> consumerElement, java.util.function.Consumer<? super java.lang.Throwable> consumerError)` Perform a forEach operation over the Stream capturing any elements and errors in the supplied consumers,
`static <T,X extends java.lang.Throwable> org.reactivestreams.Subscription`	`forEachX(java.util.stream.Stream<T> stream, long x, java.util.function.Consumer<? super T> consumerElement)` Perform a forEach operation over the Stream, without closing it, consuming only the specified number of elements from the Stream, at this time.
`static <T,X extends java.lang.Throwable> org.reactivestreams.Subscription`	`forEachXEvents(java.util.stream.Stream<T> stream, long x, java.util.function.Consumer<? super T> consumerElement, java.util.function.Consumer<? super java.lang.Throwable> consumerError, java.lang.Runnable onComplete)` Perform a forEach operation over the Stream without closing it, capturing any elements and errors in the supplied consumers, but only consuming the specified number of elements from the Stream, at this time.
`static <T,X extends java.lang.Throwable> org.reactivestreams.Subscription`	`forEachXWithError(java.util.stream.Stream<T> stream, long x, java.util.function.Consumer<? super T> consumerElement, java.util.function.Consumer<? super java.lang.Throwable> consumerError)` Perform a forEach operation over the Stream without closing it, capturing any elements and errors in the supplied consumers, but only consuming the specified number of elements from the Stream, at this time.
`static <T> FutureOperations<T>`	`futureOperations(java.util.stream.Stream<T> stream, java.util.concurrent.Executor exec)`
`static <T> java.util.stream.Stream<ListX<T>>`	`grouped(java.util.stream.Stream<T> stream, int groupSize)` Group elements in a Stream by size
`static <T,C extends java.util.Collection<? super T>> java.util.stream.Stream<C>`	`grouped(java.util.stream.Stream<T> stream, int groupSize, java.util.function.Supplier<C> factory)` Deprecated.
`static <T> java.util.stream.Stream<ListX<T>>`	`groupedBySizeAndTime(java.util.stream.Stream<T> stream, int size, long time, java.util.concurrent.TimeUnit t)` Group a Stream by size and time constraints
`static <T,C extends java.util.Collection<? super T>> java.util.stream.Stream<C>`	`groupedBySizeAndTime(java.util.stream.Stream<T> stream, int size, long time, java.util.concurrent.TimeUnit t, java.util.function.Supplier<C> factory)` Group a Stream by size and time constraints
`static <T> java.util.stream.Stream<ListX<T>>`	`groupedByTime(java.util.stream.Stream<T> stream, long time, java.util.concurrent.TimeUnit t)`
`static <T,C extends java.util.Collection<? super T>> java.util.stream.Stream<C>`	`groupedByTime(java.util.stream.Stream<T> stream, long time, java.util.concurrent.TimeUnit t, java.util.function.Supplier<C> factory)`
`static <T> java.util.stream.Stream<ListX<T>>`	`groupedStatefullyUntil(java.util.stream.Stream<T> stream, java.util.function.BiPredicate<ListX<? super T>,? super T> predicate)` Group data in a Stream using knowledge of the current batch and the next entry to determing grouping limits
`static <T> java.util.stream.Stream<ListX<T>>`	`groupedUntil(java.util.stream.Stream<T> stream, java.util.function.Predicate<? super T> predicate)` Group a Stream until the supplied predicate holds
`static <T> java.util.stream.Stream<ListX<T>>`	`groupedWhile(java.util.stream.Stream<T> stream, java.util.function.Predicate<? super T> predicate)` Group a Stream while the supplied predicate holds
`static <T,C extends java.util.Collection<? super T>> java.util.stream.Stream<C>`	`groupedWhile(java.util.stream.Stream<T> stream, java.util.function.Predicate<? super T> predicate, java.util.function.Supplier<C> factory)` Group a Stream while the supplied predicate holds
`static <T> HeadAndTail<T>`	`headAndTail(java.util.stream.Stream<T> stream)` extract head and tail together
`static <T> HotStream<T>`	`hotStream(java.util.stream.Stream<T> stream, java.util.concurrent.Executor exec)`
`static <T> java.util.stream.Stream<T>`	`insertAt(java.util.stream.Stream<T> stream, int pos, T... values)` Insert data into a stream at given position
`static <T> java.util.stream.Stream<T>`	`insertStreamAt(java.util.stream.Stream<T> stream1, int pos, java.util.stream.Stream<T> insert)` Insert a Stream into the middle of this stream at the specified position
`static <T> java.util.stream.Stream<T>`	`intersperse(java.util.stream.Stream<T> stream, T value)` Returns a stream with a given value interspersed between any two values of this stream.
`static <T> java.util.stream.Stream<T>`	`jitter(java.util.stream.Stream<T> stream, long jitterInNanos)` Introduce a random jitter / time delay between the emission of elements
`static <T> java.lang.String`	`join(java.util.stream.Stream<T> stream)`
`static <T> java.lang.String`	`join(java.util.stream.Stream<T> stream, java.lang.String sep)`
`static <T> java.lang.String`	`join(java.util.stream.Stream<T> stream, java.lang.String sep, java.lang.String start, java.lang.String end)`
`static <U> java.util.stream.Stream<U>`	`limit(java.util.stream.Stream<U> stream, long time, java.util.concurrent.TimeUnit unit)`
`static <U> java.util.stream.Stream<U>`	`limitLast(java.util.stream.Stream<U> stream, int num)`
`static <U> java.util.stream.Stream<U>`	`limitUntil(java.util.stream.Stream<U> stream, java.util.function.Predicate<? super U> predicate)` Take elements from a Stream until the predicate holds
`static <U> java.util.stream.Stream<U>`	`limitWhile(java.util.stream.Stream<U> stream, java.util.function.Predicate<? super U> predicate)` Take elements from a stream while the predicates hold
`static <T,R> R`	`mapReduce(java.util.stream.Stream<T> stream, java.util.function.Function<? super T,? extends R> mapper, Monoid<R> reducer)` Attempt to map this Monad to the same type as the supplied Monoid, using supplied function Then use Monoid to reduce values
`static <T,R> R`	`mapReduce(java.util.stream.Stream<T> stream, Reducer<R> reducer)` Attempt to map this Monad to the same type as the supplied Monoid (using mapToType on the monoid interface) Then use Monoid to reduce values
`static <T> java.util.Optional<T>`	`max(java.util.stream.Stream<T> stream, java.util.Comparator<? super T> comparator)`
`static <T,C extends java.lang.Comparable<? super C>> java.util.Optional<T>`	`maxBy(java.util.stream.Stream<T> stream, java.util.function.Function<? super T,? extends C> f)`
`static <T> java.util.Optional<T>`	`min(java.util.stream.Stream<T> stream, java.util.Comparator<? super T> comparator)`
`static <T,C extends java.lang.Comparable<? super C>> java.util.Optional<T>`	`minBy(java.util.stream.Stream<T> stream, java.util.function.Function<? super T,? extends C> f)`
`static <T> boolean`	`noneMatch(java.util.stream.Stream<T> stream, java.util.function.Predicate<? super T> c)` `assertThat(StreamUtils.noneMatch(of(1,2,3,4,5),it-> it==5000),equalTo(true));`
`static <T,U> java.util.stream.Stream<U>`	`ofType(java.util.stream.Stream<T> stream, java.lang.Class<? extends U> type)` Keep only those elements in a stream that are of a given type.
`static <T> java.util.stream.Stream<T>`	`onePer(java.util.stream.Stream<T> stream, long time, java.util.concurrent.TimeUnit t)` emit one element per time period
`static <T> java.util.stream.Stream<T>`	`optionalToStream(java.util.Optional<T> optional)` Convert an Optional to a Stream
`static <T> org.jooq.lambda.tuple.Tuple2<java.util.stream.Stream<T>,java.util.stream.Stream<T>>`	`partition(java.util.stream.Stream<T> stream, java.util.function.Predicate<T> splitter)` Partition a Stream into two one a per element basis, based on predicate's boolean value
`static <T> PausableHotStream<T>`	`pausableHotStream(java.util.stream.Stream<T> stream, java.util.concurrent.Executor exec)`
`static <T> java.util.stream.Stream<T>`	`prepend(java.util.stream.Stream<T> stream, T... values)` Prepend given values to the start of the Stream
`static <T> java.util.stream.Stream<T>`	`prependStream(java.util.stream.Stream<T> stream1, java.util.stream.Stream<T> prepend)` Prepend Stream to this SequenceM
`static <T> HotStream<T>`	`primedHotStream(java.util.stream.Stream<T> stream, java.util.concurrent.Executor exec)`
`static <T> PausableHotStream<T>`	`primedPausableHotStream(java.util.stream.Stream<T> stream, java.util.concurrent.Executor exec)`
`static <T> org.jooq.lambda.tuple.Tuple4<java.util.stream.Stream<T>,java.util.stream.Stream<T>,java.util.stream.Stream<T>,java.util.stream.Stream<T>>`	`quadruplicate(java.util.stream.Stream<T> stream)` Makes four copies of a Stream Buffers intermediate values, leaders may change positions so a limit can be safely applied to the leading stream.
`static <T> ReactiveSeq<T>`	`reactiveSeq(java.util.stream.Stream<T> stream, java.util.Optional<com.aol.cyclops.internal.stream.spliterators.ReversableSpliterator> rev)`
`static <T,EX extends java.lang.Throwable> java.util.stream.Stream<T>`	`recover(java.util.stream.Stream<T> stream, java.lang.Class<EX> type, java.util.function.Function<EX,? extends T> fn)`
`static <T> java.util.stream.Stream<T>`	`recover(java.util.stream.Stream<T> stream, java.util.function.Function<java.lang.Throwable,? extends T> fn)`
`static <R> ListX<R>`	`reduce(java.util.stream.Stream<R> stream, java.lang.Iterable<? extends Monoid<R>> reducers)` Simultaneously reduce a stream with multiple reducers
`static <R> ListX<R>`	`reduce(java.util.stream.Stream<R> stream, java.util.stream.Stream<? extends Monoid<R>> reducers)` Simultanously reduce a stream with multiple reducers
`static <U> java.util.stream.Stream<U>`	`reverse(java.util.stream.Stream<U> stream)` Reverse a Stream
`static <U> java.util.stream.Stream<U>`	`reversedStream(java.util.List<U> list)` Create a reversed Stream from a List
`static <T> java.util.stream.Stream<T>`	`scanLeft(java.util.stream.Stream<T> stream, Monoid<T> monoid)` Scan left using supplied Monoid
`static <U,T> java.util.stream.Stream<U>`	`scanRight(java.util.stream.Stream<T> stream, U identity, java.util.function.BiFunction<? super T,? super U,? extends U> combiner)`
`static <T> HotStream<T>`	`schedule(java.util.stream.Stream<T> stream, java.lang.String cron, java.util.concurrent.ScheduledExecutorService ex)` Execute this Stream on a schedule
`static <T> HotStream<T>`	`scheduleFixedDelay(java.util.stream.Stream<T> stream, long delay, java.util.concurrent.ScheduledExecutorService ex)` Execute this Stream on a schedule
`static <T> HotStream<T>`	`scheduleFixedRate(java.util.stream.Stream<T> stream, long rate, java.util.concurrent.ScheduledExecutorService ex)` Execute this Stream on a schedule
`static <T> Streamable<T>`	`shuffle(java.util.stream.Stream<T> stream)`
`static <U> java.util.stream.Stream<U>`	`skip(java.util.stream.Stream<U> stream, long time, java.util.concurrent.TimeUnit unit)`
`static <U> java.util.stream.Stream<U>`	`skipLast(java.util.stream.Stream<U> stream, int num)`
`static <U> java.util.stream.Stream<U>`	`skipUntil(java.util.stream.Stream<U> stream, java.util.function.Predicate<? super U> predicate)` skip elements in Stream until Predicate holds true
`static <U> java.util.stream.Stream<U>`	`skipWhile(java.util.stream.Stream<U> stream, java.util.function.Predicate<? super U> predicate)` skip elements in a Stream while Predicate holds true
`static <T> java.util.stream.Stream<ListX<T>>`	`sliding(java.util.stream.Stream<T> stream, int windowSize)` Create a sliding view over this Stream
`static <T> java.util.stream.Stream<ListX<T>>`	`sliding(java.util.stream.Stream<T> stream, int windowSize, int increment)` Create a sliding view over this Stream
`static <T> org.jooq.lambda.tuple.Tuple2<java.util.stream.Stream<T>,java.util.stream.Stream<T>>`	`splitAt(java.util.stream.Stream<T> stream, int where)` Split at supplied location
`static <T> org.jooq.lambda.tuple.Tuple2<java.util.stream.Stream<T>,java.util.stream.Stream<T>>`	`splitBy(java.util.stream.Stream<T> stream, java.util.function.Predicate<T> splitter)` Split stream at point where predicate no longer holds
`static <T> boolean`	`startsWith(java.util.stream.Stream<T> stream, java.lang.Iterable<T> iterable)` `assertTrue(StreamUtils.startsWith(Stream.of(1,2,3,4),Arrays.asList(1,2,3)));`
`static <T> boolean`	`startsWith(java.util.stream.Stream<T> stream, java.util.Iterator<T> iterator)` `assertTrue(StreamUtils.startsWith(Stream.of(1,2,3,4),Arrays.asList(1,2,3).iterator()))`
`static <T> boolean`	`startsWith(java.util.stream.Stream<T> stream, java.util.stream.Stream<T> stream2)`
`static <U> java.util.stream.Stream<U>`	`stream(java.lang.Iterable<U> it)` Create a stream from an iterable
`static <U> java.util.stream.Stream<U>`	`stream(java.util.Iterator<U> it)` Create a stream from an iterator
`static <K,V> java.util.stream.Stream<java.util.Map.Entry<K,V>>`	`stream(java.util.Map<K,V> it)` Create a stream from a map
`static <U> java.util.stream.Stream<U>`	`stream(java.util.Spliterator<U> it)`
`static <T> java.util.concurrent.CompletableFuture<java.util.List<T>>`	`streamToCompletableFuture(java.util.stream.Stream<T> stream)` Create a CompletableFuture containing a List materialized from a Stream
`static <T> java.util.Optional<ListX<T>>`	`streamToOptional(java.util.stream.Stream<T> stream)` Create an Optional containing a List materialized from a Stream
`static <A> ListX<java.util.Iterator<A>>`	`toBufferingCopier(java.util.Iterator<A> iterator, int copies)`
`static <A> org.jooq.lambda.tuple.Tuple2<java.util.Iterator<A>,java.util.Iterator<A>>`	`toBufferingDuplicator(java.util.Iterator<A> iterator)`
`static <A> org.jooq.lambda.tuple.Tuple2<java.util.Iterator<A>,java.util.Iterator<A>>`	`toBufferingDuplicator(java.util.Iterator<A> iterator, long pos)`
`static <A> CollectionX<A>`	`toConcurrentLazyCollection(java.util.Iterator<A> iterator)`
`static <A> CollectionX<A>`	`toConcurrentLazyCollection(java.util.stream.Stream<A> stream)` Lazily constructs a Collection from specified Stream.
`static <T> Streamable<T>`	`toConcurrentLazyStreamable(java.util.stream.Stream<T> stream)`
`static <A> CollectionX<A>`	`toLazyCollection(java.util.Iterator<A> iterator)`
`static <A> CollectionX<A>`	`toLazyCollection(java.util.stream.Stream<A> stream)` Projects an immutable collection of this stream.
`static <T> Streamable<T>`	`toLazyStreamable(java.util.stream.Stream<T> stream)`
`static <T> java.util.List<T>`	`toList(java.util.stream.Stream<T> stream)`
`static <T> java.util.Set<T>`	`toSet(java.util.stream.Stream<T> stream)`
`static <T> Streamable<T>`	`toStreamable(java.util.stream.Stream<T> stream)`
`static <T> org.jooq.lambda.tuple.Tuple3<java.util.stream.Stream<T>,java.util.stream.Stream<T>,java.util.stream.Stream<T>>`	`triplicate(java.util.stream.Stream<T> stream)` Triplicates a Stream Buffers intermediate values, leaders may change positions so a limit can be safely applied to the leading stream.
`static <T> java.util.stream.Stream<Streamable<T>>`	`window(java.util.stream.Stream<T> stream, int windowSize, int increment)` Create a sliding view over this Stream
`static <T> java.util.stream.Stream<Streamable<T>>`	`windowByTime(java.util.stream.Stream<T> stream, long time, java.util.concurrent.TimeUnit t)`
`static <T> boolean`	`xMatch(java.util.stream.Stream<T> stream, int num, java.util.function.Predicate<? super T> c)` Check that there are specified number of matches of predicate in the Stream
`static <T> java.util.stream.Stream<T>`	`xPer(java.util.stream.Stream<T> stream, int x, long time, java.util.concurrent.TimeUnit t)`
`static <T,S,R> java.util.stream.Stream<R>`	`zipAnyM(java.util.stream.Stream<T> stream, AnyM<? extends S> second, java.util.function.BiFunction<? super T,? super S,? extends R> zipper)` Generic zip function.
`static <T,S,R> java.util.stream.Stream<R>`	`zipSequence(java.util.stream.Stream<T> stream, java.util.stream.Stream<? extends S> second, java.util.function.BiFunction<? super T,? super S,? extends R> zipper)` Generic zip function.
`static <T,S,R> java.util.stream.Stream<R>`	`zipStream(java.util.stream.Stream<T> stream, java.util.stream.BaseStream<? extends S,? extends java.util.stream.BaseStream<? extends S,?>> second, java.util.function.BiFunction<? super T,? super S,? extends R> zipper)` Zip this Monad with a Stream

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail
- StreamUtils
```
public StreamUtils()
```

Method Detail

streamToOptional

public static final <T> java.util.Optional<ListX<T>> streamToOptional(java.util.stream.Stream<T> stream)

Create an Optional containing a List materialized from a Stream

  
   Optional<ListX<Integer>> opt = StreamUtils.streamToOptional(Stream.of(1,2,3));
   
   //Optional[[1,2,3]]

Parameters:: stream - To convert into an Optional
Returns:: Optional with a List of values

optionalToStream

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

Convert an Optional to a Stream

  
     Stream<Integer> stream = StreamUtils.optionalToStream(Optional.of(1));
     //Stream[1]
     
     Stream<Integer> empty = StreamUtils.optionalToStream(Optional.empty());
     //Stream[]

Parameters:: optional - Optional to convert to a Stream
Returns:: Stream with a single value (if present) created from an Optional

streamToCompletableFuture
```
public static final <T> java.util.concurrent.CompletableFuture<java.util.List<T>> streamToCompletableFuture(java.util.stream.Stream<T> stream)
```
Create a CompletableFuture containing a List materialized from a Stream

Parameters:

stream - To convert into an Optional

Returns:

CompletableFuture with a List of values

completableFutureToStream
```
public static final <T> java.util.stream.Stream<T> completableFutureToStream(java.util.concurrent.CompletableFuture<T> future)
```
Convert a CompletableFuture to a Stream

Parameters:

future - CompletableFuture to convert

Returns:

Stream with a single value created from a CompletableFuture

forEachX
```
public static <T,X extends java.lang.Throwable> org.reactivestreams.Subscription forEachX(java.util.stream.Stream<T> stream,
 long x,
 java.util.function.Consumer<? super T> consumerElement)
```
Perform a forEach operation over the Stream, without closing it, consuming only the specified number of elements from the Stream, at this time. More elements can be consumed later, by called request on the returned Subscription
Parameters:

Stream - - the Stream to consume data from

numberOfElements - To consume from the Stream at this time

consumer - To accept incoming events from the Stream

Returns:

Subscription so that further processing can be continued or cancelled.

forEachXWithError
```
public static <T,X extends java.lang.Throwable> org.reactivestreams.Subscription forEachXWithError(java.util.stream.Stream<T> stream,
 long x,
 java.util.function.Consumer<? super T> consumerElement,
 java.util.function.Consumer<? super java.lang.Throwable> consumerError)
```
Perform a forEach operation over the Stream without closing it, capturing any elements and errors in the supplied consumers, but only consuming the specified number of elements from the Stream, at this time. More elements can be consumed later, by called request on the returned Subscription
Parameters:

Stream - - the Stream to consume data from

numberOfElements - To consume from the Stream at this time

consumer - To accept incoming elements from the Stream

consumerError - To accept incoming processing errors from the Stream

onComplete - To run after an onComplete event

Returns:

Subscription so that further processing can be continued or cancelled.

forEachXEvents
```
public static <T,X extends java.lang.Throwable> org.reactivestreams.Subscription forEachXEvents(java.util.stream.Stream<T> stream,
 long x,
 java.util.function.Consumer<? super T> consumerElement,
 java.util.function.Consumer<? super java.lang.Throwable> consumerError,
 java.lang.Runnable onComplete)
```
Perform a forEach operation over the Stream without closing it, capturing any elements and errors in the supplied consumers, but only consuming the specified number of elements from the Stream, at this time. More elements can be consumed later, by called request on the returned Subscription, when the entire Stream has been processed an onComplete event will be recieved.
Parameters:

Stream - - the Stream to consume data from

numberOfElements - To consume from the Stream at this time

consumer - To accept incoming elements from the Stream

consumerError - To accept incoming processing errors from the Stream

onComplete - To run after an onComplete event

Returns:

Subscription so that further processing can be continued or cancelled.

forEachWithError

public static <T,X extends java.lang.Throwable> void forEachWithError(java.util.stream.Stream<T> stream,
                                                                      java.util.function.Consumer<? super T> consumerElement,
                                                                      java.util.function.Consumer<? super java.lang.Throwable> consumerError)

Perform a forEach operation over the Stream capturing any elements and errors in the supplied consumers,

Parameters:: Stream - - the Stream to consume data from; consumer - To accept incoming elements from the Stream; consumerError - To accept incoming processing errors from the Stream

forEachEvent

public static <T,X extends java.lang.Throwable> void forEachEvent(java.util.stream.Stream<T> stream,
                                                                  java.util.function.Consumer<? super T> consumerElement,
                                                                  java.util.function.Consumer<? super java.lang.Throwable> consumerError,
                                                                  java.lang.Runnable onComplete)

Perform a forEach operation over the Stream capturing any elements and errors in the supplied consumers when the entire Stream has been processed an onComplete event will be recieved.

Parameters:: Stream - - the Stream to consume data from; consumer - To accept incoming elements from the Stream; consumerError - To accept incoming processing errors from the Stream; onComplete - To run after an onComplete event

schedule

public static <T> HotStream<T> schedule(java.util.stream.Stream<T> stream,
                                        java.lang.String cron,
                                        java.util.concurrent.ScheduledExecutorService ex)

Execute this Stream on a schedule

 
  //run at 8PM every night
 StreamUtils.schedule(Stream.generate(()->"next job:"+formatDate(new Date()))
            .map(this::processJob)
            ,"0 20 * * *",Executors.newScheduledThreadPool(1)));

Connect to the Scheduled Stream

  
 HotStream<Data> dataStream = StreamUtils.schedule(Stream.generate(()->"next job:"+formatDate(new Date()))
            							  .map(this::processJob)
            							  ,"0 20 * * *",Executors.newScheduledThreadPool(1)));
 
 
 data.connect().forEach(this::logToDB);

Parameters:: stream - the stream to schedule element processing on; cron - Expression that determines when each job will run; ex - ScheduledExecutorService
Returns:: Connectable HotStream of output from scheduled Stream

scheduleFixedDelay

public static <T> HotStream<T> scheduleFixedDelay(java.util.stream.Stream<T> stream,
                                                  long delay,
                                                  java.util.concurrent.ScheduledExecutorService ex)

Execute this Stream on a schedule

 
  //run every 60 seconds after last job completes
  StreamUtils.scheduleFixedDelay(Stream.generate(()->"next job:"+formatDate(new Date()))
            .map(this::processJob)
            ,60_000,Executors.newScheduledThreadPool(1)));

Connect to the Scheduled Stream

  
 HotStream<Data> dataStream = StreamUtils.scheduleFixedDelay(Stream.generate(()->"next job:"+formatDate(new Date()))
            							  .map(this::processJob)
            							  ,60_000,Executors.newScheduledThreadPool(1)));
 
 
 data.connect().forEach(this::logToDB);

Parameters:: stream - the stream to schedule element processing on; delay - Between last element completes passing through the Stream until the next one starts; ex - ScheduledExecutorService
Returns:: Connectable HotStream of output from scheduled Stream

scheduleFixedRate

public static <T> HotStream<T> scheduleFixedRate(java.util.stream.Stream<T> stream,
                                                 long rate,
                                                 java.util.concurrent.ScheduledExecutorService ex)

Execute this Stream on a schedule

 
  //run every 60 seconds
  StreamUtils.scheduleFixedRate(Stream.generate(()->"next job:"+formatDate(new Date()))
            .map(this::processJob),
            60_000,Executors.newScheduledThreadPool(1)));

Connect to the Scheduled Stream

  
 HotStream<Data> dataStream = StreamUtils.scheduleFixedRate(Stream.generate(()->"next job:"+formatDate(new Date()))
            							  .map(this::processJob)
            							  ,60_000,Executors.newScheduledThreadPool(1)));
 
 
 data.connect().forEach(this::logToDB);

Parameters:: stream - the stream to schedule element processing on; rate - Time in millis between job runs; ex - ScheduledExecutorService
Returns:: Connectable HotStream of output from scheduled Stream

splitAt

public static final <T> org.jooq.lambda.tuple.Tuple2<java.util.stream.Stream<T>,java.util.stream.Stream<T>> splitAt(java.util.stream.Stream<T> stream,
                                                                                                                    int where)

Split at supplied location

  
 ReactiveSeq.of(1,2,3).splitAt(1)
 
  //SequenceM[1], SequenceM[2,3]

splitBy

public static final <T> org.jooq.lambda.tuple.Tuple2<java.util.stream.Stream<T>,java.util.stream.Stream<T>> splitBy(java.util.stream.Stream<T> stream,
                                                                                                                    java.util.function.Predicate<T> splitter)

Split stream at point where predicate no longer holds

 
   ReactiveSeq.of(1, 2, 3, 4, 5, 6).splitBy(i->i<4)
   
   //SequenceM[1,2,3] SequenceM[4,5,6]

partition

public static final <T> org.jooq.lambda.tuple.Tuple2<java.util.stream.Stream<T>,java.util.stream.Stream<T>> partition(java.util.stream.Stream<T> stream,
                                                                                                                      java.util.function.Predicate<T> splitter)

Partition a Stream into two one a per element basis, based on predicate's boolean value

  
  ReactiveSeq.of(1, 2, 3, 4, 5, 6).partition(i -> i % 2 != 0) 
  
  //SequenceM[1,3,5], SequenceM[2,4,6]

duplicate

public static final <T> org.jooq.lambda.tuple.Tuple2<java.util.stream.Stream<T>,java.util.stream.Stream<T>> duplicate(java.util.stream.Stream<T> stream)

Duplicate a Stream, buffers intermediate values, leaders may change positions so a limit can be safely applied to the leading stream. Not thread-safe.

  
  Tuple2<ReactiveSeq<Integer>, ReactiveSeq<Integer>> copies =of(1,2,3,4,5,6).duplicate();
    	 assertTrue(copies.v1.anyMatch(i->i==2));
    	 assertTrue(copies.v2.anyMatch(i->i==2));

Returns:: duplicated stream

triplicate

public static final <T> org.jooq.lambda.tuple.Tuple3<java.util.stream.Stream<T>,java.util.stream.Stream<T>,java.util.stream.Stream<T>> triplicate(java.util.stream.Stream<T> stream)

Triplicates a Stream Buffers intermediate values, leaders may change positions so a limit can be safely applied to the leading stream. Not thread-safe.

  
 	Tuple3<ReactiveSeq<Tuple3<T1,T2,T3>>,ReactiveSeq<Tuple3<T1,T2,T3>>,ReactiveSeq<Tuple3<T1,T2,T3>>> Tuple3 = sequence.triplicate();

quadruplicate

public static final <T> org.jooq.lambda.tuple.Tuple4<java.util.stream.Stream<T>,java.util.stream.Stream<T>,java.util.stream.Stream<T>,java.util.stream.Stream<T>> quadruplicate(java.util.stream.Stream<T> stream)

Makes four copies of a Stream Buffers intermediate values, leaders may change positions so a limit can be safely applied to the leading stream. Not thread-safe.

 
 
 		Tuple4<ReactiveSeq<Tuple4<T1,T2,T3,T4>>,ReactiveSeq<Tuple4<T1,T2,T3,T4>>,ReactiveSeq<Tuple4<T1,T2,T3,T4>>,ReactiveSeq<Tuple4<T1,T2,T3,T4>>> quad = sequence.quadruplicate();

Returns:

appendStream

public static final <T> java.util.stream.Stream<T> appendStream(java.util.stream.Stream<T> stream1,
                                                                java.util.stream.Stream<T> append)

Append Stream to this SequenceM

  
 List<String> result = 	of(1,2,3).appendStream(of(100,200,300))
    									.map(it ->it+"!!")
    									.collect(Collectors.toList());
    
    		assertThat(result,equalTo(Arrays.asList("1!!","2!!","3!!","100!!","200!!","300!!")));

Parameters:: stream - to append
Returns:: SequenceM with Stream appended

prependStream

public static final <T> java.util.stream.Stream<T> prependStream(java.util.stream.Stream<T> stream1,
                                                                 java.util.stream.Stream<T> prepend)

Prepend Stream to this SequenceM

  
 List<String> result = of(1,2,3).prependStream(of(100,200,300))
    			.map(it ->it+"!!").collect(Collectors.toList());
    
    		assertThat(result,equalTo(Arrays.asList("100!!","200!!","300!!","1!!","2!!","3!!")));

Parameters:: stream - to Prepend
Returns:: SequenceM with Stream prepended

append

public static final <T> java.util.stream.Stream<T> append(java.util.stream.Stream<T> stream,
                                                          T... values)

Append values to the end of this SequenceM

  
 List<String> result = 	of(1,2,3).append(100,200,300)
    									.map(it ->it+"!!")
    									.collect(Collectors.toList());
    
    		assertThat(result,equalTo(Arrays.asList("1!!","2!!","3!!","100!!","200!!","300!!")));

Parameters:: values - to append
Returns:: SequenceM with appended values

prepend

public static final <T> java.util.stream.Stream<T> prepend(java.util.stream.Stream<T> stream,
                                                           T... values)

Prepend given values to the start of the Stream

  
 List<String> result = 	of(1,2,3).prepend(100,200,300)
    			.map(it ->it+"!!").collect(Collectors.toList());
    
    		assertThat(result,equalTo(Arrays.asList("100!!","200!!","300!!","1!!","2!!","3!!")));

Parameters:: values - to prepend
Returns:: SequenceM with values prepended

insertAt

public static final <T> java.util.stream.Stream<T> insertAt(java.util.stream.Stream<T> stream,
                                                            int pos,
                                                            T... values)

Insert data into a stream at given position

  
 List<String> result = 	of(1,2,3).insertAt(1,100,200,300)
    			.map(it ->it+"!!").collect(Collectors.toList());
    
    		assertThat(result,equalTo(Arrays.asList("1!!","100!!","200!!","300!!","2!!","3!!")));

Parameters:: pos - to insert data at; values - to insert
Returns:: Stream with new data inserted

deleteBetween

public static final <T> java.util.stream.Stream<T> deleteBetween(java.util.stream.Stream<T> stream,
                                                                 int start,
                                                                 int end)

Delete elements between given indexes in a Stream

  
 List<String> result = 	StreamUtils.deleteBetween(Stream.of(1,2,3,4,5,6),2,4)
    										.map(it ->it+"!!")
    										.collect(Collectors.toList());
    
    		assertThat(result,equalTo(Arrays.asList("1!!","2!!","5!!","6!!")));

Parameters:: start - index; end - index
Returns:: Stream with elements removed

insertStreamAt

public static final <T> java.util.stream.Stream<T> insertStreamAt(java.util.stream.Stream<T> stream1,
                                                                  int pos,
                                                                  java.util.stream.Stream<T> insert)

Insert a Stream into the middle of this stream at the specified position

  
 List<String> result = 	StreamUtils.insertStreamAt(Stream.of(1,2,3),1,of(100,200,300))
    										.map(it ->it+"!!")
    										.collect(Collectors.toList());
    
    		assertThat(result,equalTo(Arrays.asList("1!!","100!!","200!!","300!!","2!!","3!!")));

Parameters:: pos - to insert Stream at; stream - to insert
Returns:: newly conjoined SequenceM

cycle

public static final <T> java.util.stream.Stream<T> cycle(java.util.stream.Stream<T> stream,
                                                         Monoid<T> m,
                                                         int times)

Convert to a Stream with the result of a reduction operation repeated specified times

  
   		List<Integer> list = StreamUtils.cycle(Stream.of(1,2,2),Reducers.toCountInt(),3)
 										.
 										.collect(Collectors.toList());
 	//is asList(3,3,3);

Parameters:: m - Monoid to be used in reduction; times - Number of times value should be repeated
Returns:: Stream with reduced values repeated

headAndTail

public static final <T> HeadAndTail<T> headAndTail(java.util.stream.Stream<T> stream)

extract head and tail together

  
  Stream<String> helloWorld = Stream.of("hello","world","last");
    	HeadAndTail<String> headAndTail = StreamUtils.headAndTail(helloWorld);
    	 String head = headAndTail.head();
    	 assertThat(head,equalTo("hello"));
    	
    	ReactiveSeq<String> tail =  headAndTail.tail();
    	assertThat(tail.headAndTail().head(),equalTo("world"));

Returns:

skipUntil

public static <U> java.util.stream.Stream<U> skipUntil(java.util.stream.Stream<U> stream,
                                                       java.util.function.Predicate<? super U> predicate)

skip elements in Stream until Predicate holds true

   StreamUtils.skipUntil(Stream.of(4,3,6,7),i->i==6).collect(Collectors.toList())
  // [6,7]

Parameters:: stream - Stream to skip elements from; predicate - to apply
Returns:: Stream with elements skipped

skipLast

public static <U> java.util.stream.Stream<U> skipLast(java.util.stream.Stream<U> stream,
                                                      int num)

limitLast

public static <U> java.util.stream.Stream<U> limitLast(java.util.stream.Stream<U> stream,
                                                       int num)

recover

public static <T> java.util.stream.Stream<T> recover(java.util.stream.Stream<T> stream,
                                                     java.util.function.Function<java.lang.Throwable,? extends T> fn)

recover

public static <T,EX extends java.lang.Throwable> java.util.stream.Stream<T> recover(java.util.stream.Stream<T> stream,
                                                                                    java.lang.Class<EX> type,
                                                                                    java.util.function.Function<EX,? extends T> fn)

skipWhile

public static <U> java.util.stream.Stream<U> skipWhile(java.util.stream.Stream<U> stream,
                                                       java.util.function.Predicate<? super U> predicate)

skip elements in a Stream while Predicate holds true

 
   StreamUtils.skipWhile(Stream.of(4,3,6,7).sorted(),i->i<6).collect(Collectors.toList())
  // [6,7]

Parameters:: stream -; predicate -
Returns:

limit

public static <U> java.util.stream.Stream<U> limit(java.util.stream.Stream<U> stream,
                                                   long time,
                                                   java.util.concurrent.TimeUnit unit)

skip

public static <U> java.util.stream.Stream<U> skip(java.util.stream.Stream<U> stream,
                                                  long time,
                                                  java.util.concurrent.TimeUnit unit)

combine

public static <T> java.util.stream.Stream<T> combine(java.util.stream.Stream<T> stream,
                                                     java.util.function.BiPredicate<? super T,? super T> predicate,
                                                     java.util.function.BinaryOperator<T> op)

limitWhile

public static <U> java.util.stream.Stream<U> limitWhile(java.util.stream.Stream<U> stream,
                                                        java.util.function.Predicate<? super U> predicate)

Take elements from a stream while the predicates hold

  StreamUtils.limitWhile(Stream.of(4,3,6,7).sorted(),i->i<6).collect(Collectors.toList());
 //[4,3]

Parameters:: stream -; predicate -
Returns:

limitUntil

public static <U> java.util.stream.Stream<U> limitUntil(java.util.stream.Stream<U> stream,
                                                        java.util.function.Predicate<? super U> predicate)

Take elements from a Stream until the predicate holds

  StreamUtils.limitUntil(Stream.of(4,3,6,7),i->i==6).collect(Collectors.toList());
 //[4,3]

Parameters:: stream -; predicate -
Returns:

reverse

public static <U> java.util.stream.Stream<U> reverse(java.util.stream.Stream<U> stream)

Reverse a Stream

  
 assertThat(StreamUtils.reverse(Stream.of(1,2,3)).collect(Collectors.toList())
    			,equalTo(Arrays.asList(3,2,1)));

Parameters:: stream - Stream to reverse
Returns:: Reversed stream

reversedStream

public static <U> java.util.stream.Stream<U> reversedStream(java.util.List<U> list)

Create a reversed Stream from a List

  
 StreamUtils.reversedStream(asList(1,2,3))
    			.map(i->i*100)
    			.forEach(System.out::println);
    	
    	
    	assertThat(StreamUtils.reversedStream(Arrays.asList(1,2,3)).collect(Collectors.toList())
    			,equalTo(Arrays.asList(3,2,1)));

Parameters:: list - List to create a reversed Stream from
Returns:: Reversed Stream

cycle

public static <U> java.util.stream.Stream<U> cycle(java.util.stream.Stream<U> s)

Create a new Stream that infiniteable cycles the provided Stream

  		
 assertThat(StreamUtils.cycle(Stream.of(1,2,3))
 						.limit(6)
 						.collect(Collectors.toList()),
 								equalTo(Arrays.asList(1,2,3,1,2,3)));

Parameters:: s - Stream to cycle
Returns:: New cycling stream

cycle
```
public static  java.util.stream.Stream cycle(Streamable s)
```
Create a Stream that infiniteable cycles the provided Streamable

Parameters:

s - Streamable to cycle

Returns:

New cycling stream

cycle

public static <U> java.util.stream.Stream<U> cycle(int times,
                                                   Streamable<U> s)

Create a Stream that finitely cycles the provided Streamable, provided number of times

  
 assertThat(StreamUtils.cycle(3,Streamable.of(1,2,2))
    							.collect(Collectors.toList()),
    								equalTo(Arrays.asList(1,2,2,1,2,2,1,2,2)));

Parameters:: s - Streamable to cycle
Returns:: New cycling stream

stream

public static <U> java.util.stream.Stream<U> stream(java.lang.Iterable<U> it)

Create a stream from an iterable

  
 	assertThat(StreamUtils.stream(Arrays.asList(1,2,3))
 								.collect(Collectors.toList()),
 									equalTo(Arrays.asList(1,2,3)));

Parameters:: it - Iterable to convert to a Stream
Returns:: Stream from iterable

stream

public static <U> java.util.stream.Stream<U> stream(java.util.Spliterator<U> it)

stream

public static <U> java.util.stream.Stream<U> stream(java.util.Iterator<U> it)

Create a stream from an iterator

  
 	assertThat(StreamUtils.stream(Arrays.asList(1,2,3).iterator())	
 							.collect(Collectors.toList()),
 								equalTo(Arrays.asList(1,2,3)));

Parameters:: it - Iterator to convert to a Stream
Returns:: Stream from iterator

concat
```
public static  java.util.stream.Stream concat(java.lang.Object o,
 java.util.stream.Stream stream)
```
Concat an Object and a Stream If the Object is a Stream, Streamable or Iterable will be converted (or left) in Stream form and concatonated Otherwise a new Stream.of(o) is created

Parameters:

o - Object to concat

stream - Stream to concat

Returns:

Concatonated Stream

stream

public static final <K,V> java.util.stream.Stream<java.util.Map.Entry<K,V>> stream(java.util.Map<K,V> it)

Create a stream from a map

  
 	Map<String,String> map = new HashMap<>();
    	map.put("hello","world");
    	assertThat(StreamUtils.stream(map).collect(Collectors.toList()),equalTo(Arrays.asList(new AbstractMap.SimpleEntry("hello","world"))));

Parameters:: it - Iterator to convert to a Stream
Returns:: Stream from a map

futureOperations

public static final <T> FutureOperations<T> futureOperations(java.util.stream.Stream<T> stream,
                                                             java.util.concurrent.Executor exec)

firstValue

public static final <T> T firstValue(java.util.stream.Stream<T> stream)

reduce

public static <R> ListX<R> reduce(java.util.stream.Stream<R> stream,
                                  java.lang.Iterable<? extends Monoid<R>> reducers)

Simultaneously reduce a stream with multiple reducers


 
  Monoid<Integer> sum = Monoid.of(0,(a,b)->a+b);
    	Monoid<Integer> mult = Monoid.of(1,(a,b)->a*b);
    	val result = StreamUtils.reduce(Stream.of(1,2,3,4),Arrays.asList(sum,mult));
    			
    	 
    	assertThat(result,equalTo(Arrays.asList(10,24)));

Parameters:: stream - Stream to reduce; reducers - Reducers to reduce Stream
Returns:: Reduced Stream values as List entries

reduce

public static <R> ListX<R> reduce(java.util.stream.Stream<R> stream,
                                  java.util.stream.Stream<? extends Monoid<R>> reducers)

Simultanously reduce a stream with multiple reducers

  
  Monoid<String> concat = Monoid.of("",(a,b)->a+b);
    	Monoid<String> join = Monoid.of("",(a,b)->a+","+b);
    	assertThat(StreamUtils.reduce(Stream.of("hello", "world", "woo!"),Stream.of(concat,join))
    	                 ,equalTo(Arrays.asList("helloworldwoo!",",hello,world,woo!")));

Parameters:: stream - Stream to reduce; reducers - Reducers to reduce Stream
Returns:: Reduced Stream values as List entries

cycleWhile

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

Repeat in a Stream while specified predicate holds

  
  int count =0;
  
    	assertThat(StreamUtils.cycleWhile(Stream.of(1,2,2)
    										,next -> count++<6 )
    										.collect(Collectors.toList()),equalTo(Arrays.asList(1,2,2,1,2,2)));

Parameters:: predicate - repeat while true
Returns:: Repeating Stream

cycleUntil

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

Repeat in a Stream until specified predicate holds

  
 	count =0;
    	assertThat(StreamUtils.cycleUntil(Stream.of(1,2,2,3)
    										,next -> count++>10 )
    										.collect(Collectors.toList()),equalTo(Arrays.asList(1, 2, 2, 3, 1, 2, 2, 3, 1, 2, 2)));

Parameters:: predicate - repeat while true
Returns:: Repeating Stream

zipSequence

public static final <T,S,R> java.util.stream.Stream<R> zipSequence(java.util.stream.Stream<T> stream,
                                                                   java.util.stream.Stream<? extends S> second,
                                                                   java.util.function.BiFunction<? super T,? super S,? extends R> zipper)

Generic zip function. E.g. Zipping a Stream and a Sequence

  
 Stream<List<Integer>> zipped = StreamUtils.zip(Stream.of(1,2,3)
    											,ReactiveSeq.of(2,3,4), 
    												(a,b) -> Arrays.asList(a,b));
    	
    	
    	List<Integer> zip = zipped.collect(Collectors.toList()).get(1);
    	assertThat(zip.get(0),equalTo(2));
    	assertThat(zip.get(1),equalTo(3));

Parameters:: second - Monad to zip with; zipper - Zipping function
Returns:: Stream zipping two Monads

zipAnyM

public static final <T,S,R> java.util.stream.Stream<R> zipAnyM(java.util.stream.Stream<T> stream,
                                                               AnyM<? extends S> second,
                                                               java.util.function.BiFunction<? super T,? super S,? extends R> zipper)

Generic zip function. E.g. Zipping a Stream and an Optional

 
 Stream<List<Integer>> zipped = StreamUtils.zip(Stream.of(1,2,3)
    									,anyM(Optional.of(2)), 
    										(a,b) -> Arrays.asList(a,b));
    	
    	
    	List<Integer> zip = zipped.collect(Collectors.toList()).get(0);
    	assertThat(zip.get(0),equalTo(1));
    	assertThat(zip.get(1),equalTo(2));

zipStream

public static final <T,S,R> java.util.stream.Stream<R> zipStream(java.util.stream.Stream<T> stream,
                                                                 java.util.stream.BaseStream<? extends S,? extends java.util.stream.BaseStream<? extends S,?>> second,
                                                                 java.util.function.BiFunction<? super T,? super S,? extends R> zipper)

Zip this Monad with a Stream

        
       Stream<List<Integer>> zipped = StreamUtils.zipStream(Stream.of(1,2,3)
    											,Stream.of(2,3,4), 
    												(a,b) -> Arrays.asList(a,b));
    	
    	
    	List<Integer> zip = zipped.collect(Collectors.toList()).get(1);
    	assertThat(zip.get(0),equalTo(2));
    	assertThat(zip.get(1),equalTo(3));

Parameters:: second - Stream to zip with; zipper - Zip funciton
Returns:: This monad zipped with a Stream

sliding

public static final <T> java.util.stream.Stream<ListX<T>> sliding(java.util.stream.Stream<T> stream,
                                                                  int windowSize,
                                                                  int increment)

Create a sliding view over this Stream

  
 List<List<Integer>> list = StreamUtils.sliding(Stream.of(1,2,3,4,5,6)
    											,2,1)
    								.collect(Collectors.toList());
    	
    
    	assertThat(list.get(0),hasItems(1,2));
    	assertThat(list.get(1),hasItems(2,3));

Parameters:: windowSize - Size of sliding window
Returns:: Stream with sliding view

window

public static final <T> java.util.stream.Stream<Streamable<T>> window(java.util.stream.Stream<T> stream,
                                                                      int windowSize,
                                                                      int increment)

Create a sliding view over this Stream

  
 List<List<Integer>> list = StreamUtils.sliding(Stream.of(1,2,3,4,5,6)
    											,2,1)
    								.collect(Collectors.toList());
    	
    
    	assertThat(list.get(0),hasItems(1,2));
    	assertThat(list.get(1),hasItems(2,3));

Parameters:: windowSize - Size of sliding window
Returns:: Stream with sliding view over monad

sliding

public static final <T> java.util.stream.Stream<ListX<T>> sliding(java.util.stream.Stream<T> stream,
                                                                  int windowSize)

Create a sliding view over this Stream

  
 List<List<Integer>> list = StreamUtils.sliding(Stream.of(1,2,3,4,5,6)
    											,2)
    								.collect(Collectors.toList());
    	
    
    	assertThat(list.get(0),hasItems(1,2));
    	assertThat(list.get(1),hasItems(2,3));

Parameters:: stream - Stream to create sliding view on; windowSize - size of window
Returns:

batchBySize

@Deprecated
public static final <T> java.util.stream.Stream<ListX<T>> batchBySize(java.util.stream.Stream<T> stream,
                                                                                  int groupSize)

Deprecated.

Group elements in a Stream by size

        
 	List<List<Integer>> list = StreamUtils.batchBySize(Stream.of(1,2,3,4,5,6)
    													,3)
    												.collect(Collectors.toList());
    	
    	
    	assertThat(list.get(0),hasItems(1,2,3));
    	assertThat(list.get(1),hasItems(4,5,6));

Parameters:: stream - Stream to group; groupSize - Size of each Group
Returns:: Stream with elements grouped by size

grouped

public static final <T> java.util.stream.Stream<ListX<T>> grouped(java.util.stream.Stream<T> stream,
                                                                  int groupSize)

Group elements in a Stream by size

        
  List<List<Integer>> list = StreamUtils.grouped(Stream.of(1,2,3,4,5,6)
                                                        ,3)
                                                    .collect(Collectors.toList());
        
        
        assertThat(list.get(0),hasItems(1,2,3));
        assertThat(list.get(1),hasItems(4,5,6));

Parameters:: stream - Stream to group; groupSize - Size of each Group
Returns:: Stream with elements grouped by size

batchBySize

@Deprecated
public static final <T,C extends java.util.Collection<? super T>> java.util.stream.Stream<C> batchBySize(java.util.stream.Stream<T> stream,
                                                                                                                     int groupSize,
                                                                                                                     java.util.function.Supplier<C> factory)

Deprecated.

        
  List<SetX<Integer>> list = StreamUtils.batchBySize(Stream.of(1,2,3,4,5,6)
                                                        ,3,()->SetX.empty())
                                                    .collect(Collectors.toList());
        
        
        assertThat(list.get(0),hasItems(1,2,3));
        assertThat(list.get(1),hasItems(4,5,6));

Parameters:: stream - Stream to group; groupSize - Size of each Group; factory - Supplier for creating Collections for holding grouping
Returns:: Stream with elements grouped by size

grouped

@Deprecated
public static final <T,C extends java.util.Collection<? super T>> java.util.stream.Stream<C> grouped(java.util.stream.Stream<T> stream,
                                                                                                                 int groupSize,
                                                                                                                 java.util.function.Supplier<C> factory)

Deprecated.

        
  List<SetX<Integer>> list = StreamUtils.grouped(Stream.of(1,2,3,4,5,6)
                                                        ,3,()->SetX.empty())
                                                    .collect(Collectors.toList());
        
        
        assertThat(list.get(0),hasItems(1,2,3));
        assertThat(list.get(1),hasItems(4,5,6));

Parameters:: stream - Stream to group; groupSize - Size of each Group; factory - Supplier for creating Collections for holding grouping
Returns:: Stream with elements grouped by size

shuffle

public static final <T> Streamable<T> shuffle(java.util.stream.Stream<T> stream)

toLazyStreamable

public static final <T> Streamable<T> toLazyStreamable(java.util.stream.Stream<T> stream)

toConcurrentLazyStreamable

public static final <T> Streamable<T> toConcurrentLazyStreamable(java.util.stream.Stream<T> stream)

scanRight

public static final <U,T> java.util.stream.Stream<U> scanRight(java.util.stream.Stream<T> stream,
                                                               U identity,
                                                               java.util.function.BiFunction<? super T,? super U,? extends U> combiner)

scanLeft

public static final <T> java.util.stream.Stream<T> scanLeft(java.util.stream.Stream<T> stream,
                                                            Monoid<T> monoid)

Scan left using supplied Monoid

   
 
 	assertEquals(asList("", "a", "ab", "abc"),
 					StreamUtils.scanLeft(Stream.of("a", "b", "c"),Reducers.toString(""))
 			.collect(Collectors.toList());

Parameters:: monoid -
Returns:

xMatch

public static <T> boolean xMatch(java.util.stream.Stream<T> stream,
                                 int num,
                                 java.util.function.Predicate<? super T> c)

Check that there are specified number of matches of predicate in the Stream

  
  assertTrue(StreamUtils.xMatch(Stream.of(1,2,3,5,6,7),3, i->i>4));

noneMatch

public static final <T> boolean noneMatch(java.util.stream.Stream<T> stream,
                                          java.util.function.Predicate<? super T> c)

  
 assertThat(StreamUtils.noneMatch(of(1,2,3,4,5),it-> it==5000),equalTo(true));

join

public static final <T> java.lang.String join(java.util.stream.Stream<T> stream)

join

public static final <T> java.lang.String join(java.util.stream.Stream<T> stream,
                                              java.lang.String sep)

join

public static final <T> java.lang.String join(java.util.stream.Stream<T> stream,
                                              java.lang.String sep,
                                              java.lang.String start,
                                              java.lang.String end)

minBy

public static final <T,C extends java.lang.Comparable<? super C>> java.util.Optional<T> minBy(java.util.stream.Stream<T> stream,
                                                                                              java.util.function.Function<? super T,? extends C> f)

min

public static final <T> java.util.Optional<T> min(java.util.stream.Stream<T> stream,
                                                  java.util.Comparator<? super T> comparator)

maxBy

public static final <T,C extends java.lang.Comparable<? super C>> java.util.Optional<T> maxBy(java.util.stream.Stream<T> stream,
                                                                                              java.util.function.Function<? super T,? extends C> f)

max

public static final <T> java.util.Optional<T> max(java.util.stream.Stream<T> stream,
                                                  java.util.Comparator<? super T> comparator)

mapReduce
```
public static final <T,R> R mapReduce(java.util.stream.Stream<T> stream,
 Reducer<R> reducer)
```
Attempt to map this Monad to the same type as the supplied Monoid (using mapToType on the monoid interface) Then use Monoid to reduce values

Parameters:

reducer - Monoid to reduce values

Returns:

Reduce result

mapReduce

public static final <T,R> R mapReduce(java.util.stream.Stream<T> stream,
                                      java.util.function.Function<? super T,? extends R> mapper,
                                      Monoid<R> reducer)

Attempt to map this Monad to the same type as the supplied Monoid, using supplied function Then use Monoid to reduce values

Parameters:: mapper - Function to map Monad type; reducer - Monoid to reduce values
Returns:: Reduce result

foldLeft

public static final <T> T foldLeft(java.util.stream.Stream<T> stream,
                                   Monoid<T> reducer)

Parameters:: reducer - Use supplied Monoid to reduce values starting via foldLeft
Returns:: Reduced result

foldLeftMapToType
```
public static final <T> T foldLeftMapToType(java.util.stream.Stream<T> stream,
 Reducer<T> reducer)
```
Attempt to map this Monad to the same type as the supplied Monoid (using mapToType on the monoid interface) Then use Monoid to reduce values

Parameters:

reducer - Monoid to reduce values

Returns:

Reduce result

foldRight

public static final <T> T foldRight(java.util.stream.Stream<T> stream,
                                    Monoid<T> reducer)

Parameters:: reducer - Use supplied Monoid to reduce values starting via foldRight
Returns:: Reduced result

foldRightMapToType
```
public static final <T> T foldRightMapToType(java.util.stream.Stream<T> stream,
 Reducer<T> reducer)
```
Attempt to map this Monad to the same type as the supplied Monoid (using mapToType on the monoid interface) Then use Monoid to reduce values

Parameters:

reducer - Monoid to reduce values

Returns:

Reduce result

toStreamable

public static final <T> Streamable<T> toStreamable(java.util.stream.Stream<T> stream)

Returns:: Underlying monad converted to a Streamable instance

toSet

public static final <T> java.util.Set<T> toSet(java.util.stream.Stream<T> stream)

Returns:: This monad converted to a set

toList

public static final <T> java.util.List<T> toList(java.util.stream.Stream<T> stream)

Returns:: this monad converted to a list

startsWith

public static final <T> boolean startsWith(java.util.stream.Stream<T> stream,
                                           java.lang.Iterable<T> iterable)

 
 assertTrue(StreamUtils.startsWith(Stream.of(1,2,3,4),Arrays.asList(1,2,3)));

Parameters:: iterable -
Returns:: True if Monad starts with Iterable sequence of data

endsWith

public static final <T> boolean endsWith(java.util.stream.Stream<T> stream,
                                         java.lang.Iterable<T> iterable)

startsWith

public static final <T> boolean startsWith(java.util.stream.Stream<T> stream,
                                           java.util.stream.Stream<T> stream2)

startsWith

public static final <T> boolean startsWith(java.util.stream.Stream<T> stream,
                                           java.util.Iterator<T> iterator)

 
 		 assertTrue(StreamUtils.startsWith(Stream.of(1,2,3,4),Arrays.asList(1,2,3).iterator()))

Parameters:: iterator -
Returns:: True if Monad starts with Iterators sequence of data

reactiveSeq

public static final <T> ReactiveSeq<T> reactiveSeq(java.util.stream.Stream<T> stream,
                                                   java.util.Optional<com.aol.cyclops.internal.stream.spliterators.ReversableSpliterator> rev)

intersperse

public static <T> java.util.stream.Stream<T> intersperse(java.util.stream.Stream<T> stream,
                                                         T value)

Returns a stream with a given value interspersed between any two values of this stream.

  
 assertThat(Arrays.asList(1, 0, 2, 0, 3, 0, 4),
 			equalTo( StreamUtils.intersperse(Stream.of(1, 2, 3, 4),0));

ofType
```
public static <T,U> java.util.stream.Stream ofType(java.util.stream.Stream<T> stream,
 java.lang.Class<? extends U> type)
```
Keep only those elements in a stream that are of a given type. assertThat(Arrays.asList(1, 2, 3), equalTo( StreamUtils.ofType(Stream.of(1, "a", 2, "b", 3,Integer.class));

cast

public static <T,U> java.util.stream.Stream<U> cast(java.util.stream.Stream<T> stream,
                                                    java.lang.Class<? extends U> type)

Cast all elements in a stream to a given type, possibly throwing a ClassCastException.

 
 StreamUtils.cast(Stream.of(1, "a", 2, "b", 3),Integer.class)
  // throws ClassCastException

flatMapSequenceM

public static final <T,R> java.util.stream.Stream<R> flatMapSequenceM(java.util.stream.Stream<T> stream,
                                                                      java.util.function.Function<? super T,ReactiveSeq<? extends R>> fn)

flatMap operation

  
 		assertThat(StreamUtils.flatMapSequenceM(Stream.of(1,2,3),
 							i->ReactiveSeq.of(i+2)).collect(Collectors.toList()),
 								equalTo(Arrays.asList(3,4,5)));

Parameters:: fn -
Returns:

flatMapAnyM

public static final <T,R> java.util.stream.Stream<R> flatMapAnyM(java.util.stream.Stream<T> stream,
                                                                 java.util.function.Function<? super T,AnyM<? extends R>> fn)

flatMapIterable

public static final <T,R> java.util.stream.Stream<R> flatMapIterable(java.util.stream.Stream<T> stream,
                                                                     java.util.function.Function<? super T,? extends java.lang.Iterable<? extends R>> fn)

flatMap operation that allows a Collection to be returned

  
 	assertThat(StreamUtils.flatMapCollection(Stream.of(20),i->Arrays.asList(1,2,i))
 								.collect(Collectors.toList()),
 								equalTo(Arrays.asList(1,2,20)));

flatMapStream

public static final <T,R> java.util.stream.Stream<R> flatMapStream(java.util.stream.Stream<T> stream,
                                                                   java.util.function.Function<? super T,? extends java.util.stream.BaseStream<? extends R,?>> fn)

  
 	assertThat(StreamUtils.flatMapStream(Stream.of(1,2,3),
 							i->Stream.of(i)).collect(Collectors.toList()),
 							equalTo(Arrays.asList(1,2,3)));

flatMapOptional

public static final <T,R> java.util.stream.Stream<R> flatMapOptional(java.util.stream.Stream<T> stream,
                                                                     java.util.function.Function<? super T,java.util.Optional<? extends R>> fn)

cross type flatMap, removes null entries

  
 	 assertThat(StreamUtils.flatMapOptional(Stream.of(1,2,3,null),
 										Optional::ofNullable)
 										.collect(Collectors.toList()),
 										equalTo(Arrays.asList(1,2,3)));

flatten

public static final <T,R> ReactiveSeq<R> flatten(java.util.stream.Stream<T> stream)

flatMapCompletableFuture

public static final <T,R> java.util.stream.Stream<R> flatMapCompletableFuture(java.util.stream.Stream<T> stream,
                                                                              java.util.function.Function<? super T,java.util.concurrent.CompletableFuture<? extends R>> fn)

  
 	assertThat(StreamUtils.flatMapCompletableFuture(Stream.of(1,2,3),
 								i->CompletableFuture.completedFuture(i+2))
 								.collect(Collectors.toList()),
 								equalTo(Arrays.asList(3,4,5)));

flatMapCharSequence

public static final <T> java.util.stream.Stream<java.lang.Character> flatMapCharSequence(java.util.stream.Stream<T> stream,
                                                                                         java.util.function.Function<? super T,java.lang.CharSequence> fn)

Perform a flatMap operation where the result will be a flattened stream of Characters from the CharSequence returned by the supplied function.

  
   List<Character> result = StreamUtils.liftAndBindCharSequence(Stream.of("input.file"),
    								.i->"hello world")
    								.toList();
    	
    	assertThat(result,equalTo(Arrays.asList('h','e','l','l','o',' ','w','o','r','l','d')));

Parameters:: fn -
Returns:

flatMapFile

public static final <T> java.util.stream.Stream<java.lang.String> flatMapFile(java.util.stream.Stream<T> stream,
                                                                              java.util.function.Function<? super T,java.io.File> fn)

Perform a flatMap operation where the result will be a flattened stream of Strings from the text loaded from the supplied files.

 
 
    	List<String> result = StreamUtils.liftAndBindFile(Stream.of("input.file")
    							.map(getClass().getClassLoader()::getResource)
    							.peek(System.out::println)
    							.map(URL::getFile)
    							,File::new)
    							.toList();
    	
    	assertThat(result,equalTo(Arrays.asList("hello","world")));

Parameters:: fn -
Returns:

flatMapURL

public static final <T> java.util.stream.Stream<java.lang.String> flatMapURL(java.util.stream.Stream<T> stream,
                                                                             java.util.function.Function<? super T,java.net.URL> fn)

Perform a flatMap operation where the result will be a flattened stream of Strings from the text loaded from the supplied URLs

  
 List<String> result = StreamUtils.liftAndBindURL(Stream.of("input.file")
    							,getClass().getClassLoader()::getResource)
    							.collect(Collectors.toList();
    	
    	assertThat(result,equalTo(Arrays.asList("hello","world")));

Parameters:: fn -
Returns:

flatMapBufferedReader

public static final <T> java.util.stream.Stream<java.lang.String> flatMapBufferedReader(java.util.stream.Stream<T> stream,
                                                                                        java.util.function.Function<? super T,java.io.BufferedReader> fn)

Perform a flatMap operation where the result will be a flattened stream of Strings from the text loaded from the supplied BufferedReaders

 List result = StreamUtils.liftAndBindBufferedReader(Stream.of("input.file")
                                                        .map(getClass().getClassLoader()::getResourceAsStream)
                                                        .map(InputStreamReader::new)
                                                        ,BufferedReader::new)
                                                        .collect(Collectors.toList();
        
        assertThat(result,equalTo(Arrays.asList("hello","world")));

Parameters:: fn -
Returns:

toBufferingDuplicator

public static final <A> org.jooq.lambda.tuple.Tuple2<java.util.Iterator<A>,java.util.Iterator<A>> toBufferingDuplicator(java.util.Iterator<A> iterator)

toBufferingDuplicator

public static final <A> org.jooq.lambda.tuple.Tuple2<java.util.Iterator<A>,java.util.Iterator<A>> toBufferingDuplicator(java.util.Iterator<A> iterator,
                                                                                                                        long pos)

toBufferingCopier

public static final <A> ListX<java.util.Iterator<A>> toBufferingCopier(java.util.Iterator<A> iterator,
                                                                       int copies)

toLazyCollection
```
public static final <A> CollectionX<A> toLazyCollection(java.util.stream.Stream<A> stream)
```
Projects an immutable collection of this stream. Initial iteration over the collection is not thread safe (can't be performed by multiple threads concurrently) subsequent iterations are.

Returns:

An immutable collection of this stream.

toLazyCollection

public static final <A> CollectionX<A> toLazyCollection(java.util.Iterator<A> iterator)

toConcurrentLazyCollection
```
public static final <A> CollectionX<A> toConcurrentLazyCollection(java.util.stream.Stream<A> stream)
```
Lazily constructs a Collection from specified Stream. Collections iterator may be safely used concurrently by multiple threads.

Parameters:

stream -

Returns:

toConcurrentLazyCollection

public static final <A> CollectionX<A> toConcurrentLazyCollection(java.util.Iterator<A> iterator)

windowByTime

public static final <T> java.util.stream.Stream<Streamable<T>> windowByTime(java.util.stream.Stream<T> stream,
                                                                            long time,
                                                                            java.util.concurrent.TimeUnit t)

groupedByTime

public static final <T> java.util.stream.Stream<ListX<T>> groupedByTime(java.util.stream.Stream<T> stream,
                                                                        long time,
                                                                        java.util.concurrent.TimeUnit t)

batchByTime

@Deprecated
public static final <T> java.util.stream.Stream<ListX<T>> batchByTime(java.util.stream.Stream<T> stream,
                                                                                  long time,
                                                                                  java.util.concurrent.TimeUnit t)

Deprecated.

groupedByTime

public static final <T,C extends java.util.Collection<? super T>> java.util.stream.Stream<C> groupedByTime(java.util.stream.Stream<T> stream,
                                                                                                           long time,
                                                                                                           java.util.concurrent.TimeUnit t,
                                                                                                           java.util.function.Supplier<C> factory)

batchByTime

@Deprecated
public static final <T,C extends java.util.Collection<? super T>> java.util.stream.Stream<C> batchByTime(java.util.stream.Stream<T> stream,
                                                                                                                     long time,
                                                                                                                     java.util.concurrent.TimeUnit t,
                                                                                                                     java.util.function.Supplier<C> factory)

Deprecated.

groupedStatefullyUntil
```
public static final <T> java.util.stream.Stream<ListX<T>> groupedStatefullyUntil(java.util.stream.Stream<T> stream,
 java.util.function.BiPredicate<ListX<? super T>,? super T> predicate)
```
Group data in a Stream using knowledge of the current batch and the next entry to determing grouping limits

Parameters:

stream - Stream to group

predicate - Predicate to determine grouping

Returns:

Stream grouped into Lists determined by predicate

See Also:

ReactiveSeq.groupedStatefullyUntil(BiPredicate)

groupedWhile
```
public static final <T> java.util.stream.Stream<ListX<T>> groupedWhile(java.util.stream.Stream<T> stream,
 java.util.function.Predicate<? super T> predicate)
```
Group a Stream while the supplied predicate holds

Parameters:

stream - Stream to group

predicate - Predicate to determine grouping

Returns:

Stream grouped into Lists determined by predicate

See Also:

ReactiveSeq.groupedWhile(Predicate)

batchWhile

@Deprecated
public static final <T> java.util.stream.Stream<ListX<T>> batchWhile(java.util.stream.Stream<T> stream,
                                                                                 java.util.function.Predicate<? super T> predicate)

Deprecated.

groupedWhile

public static final <T,C extends java.util.Collection<? super T>> java.util.stream.Stream<C> groupedWhile(java.util.stream.Stream<T> stream,
                                                                                                          java.util.function.Predicate<? super T> predicate,
                                                                                                          java.util.function.Supplier<C> factory)

Group a Stream while the supplied predicate holds

Parameters:: stream - Stream to group; predicate - Predicate to determine grouping; factory - Supplier to create collection for groupings
Returns:: Stream grouped into Collections determined by predicate
See Also:: ReactiveSeq.groupedWhile(Predicate, Supplier)

batchWhile

@Deprecated
public static final <T,C extends java.util.Collection<? super T>> java.util.stream.Stream<C> batchWhile(java.util.stream.Stream<T> stream,
                                                                                                                    java.util.function.Predicate<? super T> predicate,
                                                                                                                    java.util.function.Supplier<C> factory)

Deprecated.

groupedUntil
```
public static final <T> java.util.stream.Stream<ListX<T>> groupedUntil(java.util.stream.Stream<T> stream,
 java.util.function.Predicate<? super T> predicate)
```
Group a Stream until the supplied predicate holds

Parameters:

stream - Stream to group

predicate - Predicate to determine grouping

Returns:

Stream grouped into Lists determined by predicate

See Also:

ReactiveSeq.groupedUntil(Predicate)

batchUntil

@Deprecated
public static final <T> java.util.stream.Stream<ListX<T>> batchUntil(java.util.stream.Stream<T> stream,
                                                                                 java.util.function.Predicate<? super T> predicate)

Deprecated.

groupedBySizeAndTime

public static final <T> java.util.stream.Stream<ListX<T>> groupedBySizeAndTime(java.util.stream.Stream<T> stream,
                                                                               int size,
                                                                               long time,
                                                                               java.util.concurrent.TimeUnit t)

Group a Stream by size and time constraints

Parameters:: stream - Stream to group; size - Max group size; time - Max group time; t - Time unit for max group time
Returns:: Stream grouped by time and size
See Also:: ReactiveSeq.groupedBySizeAndTime(int, long, TimeUnit)

batchBySizeAndTime

@Deprecated
public static final <T> java.util.stream.Stream<ListX<T>> batchBySizeAndTime(java.util.stream.Stream<T> stream,
                                                                                         int size,
                                                                                         long time,
                                                                                         java.util.concurrent.TimeUnit t)

Deprecated.

groupedBySizeAndTime

public static final <T,C extends java.util.Collection<? super T>> java.util.stream.Stream<C> groupedBySizeAndTime(java.util.stream.Stream<T> stream,
                                                                                                                  int size,
                                                                                                                  long time,
                                                                                                                  java.util.concurrent.TimeUnit t,
                                                                                                                  java.util.function.Supplier<C> factory)

Group a Stream by size and time constraints

Parameters:: stream - Stream to group; size - Max group size; time - Max group time; t - Time unit for max group time; factory - Supplier to create collection for groupings
Returns:: Stream grouped by time and size
See Also:: ReactiveSeq.groupedBySizeAndTime(int, long, TimeUnit, Supplier)

batchBySizeAndTime

@Deprecated
public static final <T,C extends java.util.Collection<? super T>> java.util.stream.Stream<C> batchBySizeAndTime(java.util.stream.Stream<T> stream,
                                                                                                                            int size,
                                                                                                                            long time,
                                                                                                                            java.util.concurrent.TimeUnit t,
                                                                                                                            java.util.function.Supplier<C> factory)

Deprecated.

debounce
```
public static final <T> java.util.stream.Stream<T> debounce(java.util.stream.Stream<T> stream,
 long time,
 java.util.concurrent.TimeUnit t)
```
Allow one element through per time period, drop all other elements in that time period

Parameters:

stream - Stream to debounce

time - Time to apply debouncing over

t - Time unit for debounce period

Returns:

Stream with debouncing applied

See Also:

ReactiveSeq.debounce(long, TimeUnit)

onePer

public static final <T> java.util.stream.Stream<T> onePer(java.util.stream.Stream<T> stream,
                                                          long time,
                                                          java.util.concurrent.TimeUnit t)

emit one element per time period

Parameters:: stream - Stream to emit one element per time period from; time - Time period; t - Time Unit
Returns:: Stream with slowed emission
See Also:: ReactiveSeq.onePer(long, TimeUnit)

jitter
```
public static final <T> java.util.stream.Stream<T> jitter(java.util.stream.Stream<T> stream,
 long jitterInNanos)
```
Introduce a random jitter / time delay between the emission of elements

Parameters:

stream - Stream to introduce jitter to

jitterInNanos - Max jitter period - random number less than this is used for each jitter

Returns:

Jittered Stream

See Also:

ReactiveSeq.jitter(long)

fixedDelay

public static final <T> java.util.stream.Stream<T> fixedDelay(java.util.stream.Stream<T> stream,
                                                              long time,
                                                              java.util.concurrent.TimeUnit unit)

xPer

public static final <T> java.util.stream.Stream<T> xPer(java.util.stream.Stream<T> stream,
                                                        int x,
                                                        long time,
                                                        java.util.concurrent.TimeUnit t)

hotStream

public static final <T> HotStream<T> hotStream(java.util.stream.Stream<T> stream,
                                               java.util.concurrent.Executor exec)

primedHotStream

public static final <T> HotStream<T> primedHotStream(java.util.stream.Stream<T> stream,
                                                     java.util.concurrent.Executor exec)

pausableHotStream

public static final <T> PausableHotStream<T> pausableHotStream(java.util.stream.Stream<T> stream,
                                                               java.util.concurrent.Executor exec)

primedPausableHotStream

public static final <T> PausableHotStream<T> primedPausableHotStream(java.util.stream.Stream<T> stream,
                                                                     java.util.concurrent.Executor exec)

Class StreamUtils

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

StreamUtils

Method Detail

streamToOptional

optionalToStream

streamToCompletableFuture

completableFutureToStream

forEachX

forEachXWithError

forEachXEvents

forEachWithError

forEachEvent

schedule

scheduleFixedDelay

scheduleFixedRate

splitAt

splitBy

partition

duplicate

triplicate

quadruplicate

appendStream

prependStream

append

prepend

insertAt

deleteBetween

insertStreamAt

cycle

headAndTail

skipUntil

skipLast

limitLast

recover

recover

skipWhile

limit

skip

combine

limitWhile

limitUntil

reverse

reversedStream

cycle

cycle

cycle

stream

stream

stream

concat

stream

futureOperations

firstValue

reduce

reduce

cycleWhile

cycleUntil

zipSequence

zipAnyM

zipStream

sliding

window

sliding

batchBySize

grouped

batchBySize

grouped

shuffle

toLazyStreamable

toConcurrentLazyStreamable

scanRight

scanLeft

xMatch

noneMatch

join

join