cyclops.companion

Class Streams

java.lang.Object

cyclops.companion.Streams

public class Streams
extends java.lang.Object

Static utility methods for working with Java 8 Streams

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	Streams.Instances Companion class for creating Type Class instances for working with Streams
static interface	Streams.StreamKind<T> Simulates Higher Kinded Types for Stream's StreamKind is a Stream and a Higher Kinded Type (StreamKind.µ,T)

Constructor Summary

Constructors

Constructor and Description
Streams()

Method Summary

Modifier and Type	Method and Description
static <T> java.util.stream.Stream<T>	append(java.util.stream.Stream<T> stream, T... values) Append values toNested the take of this Stream
static <T> java.util.stream.Stream<T>	appendStream(java.util.stream.Stream<T> stream1, java.util.stream.Stream<T> append) Append Stream toNested this Stream
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 reactiveStream toNested a given type, possibly throwing a ClassCastException.
static <T> ReactiveSeq<ReactiveSeq<T>>	combinations(int size, java.lang.Object[] a)
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.lang.Iterable<java.lang.Iterable<T>>	combineI(java.lang.Iterable<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 toNested 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(long 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 toNested 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 toNested the leading reactiveStream.
static <T> org.jooq.lambda.tuple.Tuple2<java.util.stream.Stream<T>,java.util.stream.Stream<T>>	duplicate(java.util.stream.Stream<T> stream, java.util.function.Supplier<java.util.Deque<T>> bufferFactory) Duplicate a Stream, buffers intermediate values, leaders may change positions so a limit can be safely applied toNested the leading reactiveStream.
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<Witness.stream,? 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 reactiveStream 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 reactiveStream 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(Streams.flatMapCompletableFuture(Stream.of(1,2,3), i->CompletableFuture.completedFuture(i+2)) .collect(CyclopsCollectors.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 reactiveStream 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 toNested 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>	flatMapStream(java.util.stream.Stream<T> stream, java.util.function.Function<? super T,? extends java.util.stream.BaseStream<? extends R,?>> fn) assertThat(Streams.flatMapStream(Stream.of(1,2,3), i->Stream.of(i)).collect(CyclopsCollectors.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 reactiveStream of Strings from the text loaded from the supplied URLs
static <T> java.util.stream.Stream<T>	flatten(java.util.stream.Stream<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 toNested map this Monad toNested the same type as the supplied Monoid (using mapToType on the monoid interface) Then use Monoid toNested 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 toNested map this Monad toNested the same type as the supplied Monoid (using mapToType on the monoid interface) Then use Monoid toNested reduce values
static <T,X extends java.lang.Throwable> void	forEach(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> void	forEach(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> org.reactivestreams.Subscription	forEach(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	forEach(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,X extends java.lang.Throwable> org.reactivestreams.Subscription	forEach(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,R1,R> java.util.stream.Stream<R>	forEach2(java.util.stream.Stream<? extends T> value1, java.util.function.Function<? super T,? extends java.util.stream.Stream<R1>> value2, java.util.function.BiFunction<? super T,? super R1,java.lang.Boolean> filterFunction, java.util.function.BiFunction<? super T,? super R1,? extends R> yieldingFunction) {@code import static Streams.forEach2; forEach(IntStream.range(1, 10).boxed(), i -> Stream.range(i, 10), (a,b) -> a>2 && b<10, Tuple::tuple) .forEach(System.out::println); //(3, 3) (3, 4) (3, 5) (3, 6) (3, 7) (3, 8) (3, 9) ...
static <T,R1,R> java.util.stream.Stream<R>	forEach2(java.util.stream.Stream<? extends T> value1, java.util.function.Function<? super T,java.util.stream.Stream<R1>> value2, java.util.function.BiFunction<? super T,? super R1,? extends R> yieldingFunction) Perform a For Comprehension over a Stream, accepting an additonal generating function.
static <T1,T2,R1,R2,R> java.util.stream.Stream<R>	forEach3(java.util.stream.Stream<? extends T1> value1, java.util.function.Function<? super T1,? extends java.util.stream.Stream<R1>> value2, java.util.function.BiFunction<? super T1,? super R1,? extends java.util.stream.Stream<R2>> value3, Fn3<? super T1,? super R1,? super R2,? extends R> yieldingFunction) Perform a For Comprehension over a Stream, accepting 2 generating function.
static <T1,T2,R1,R2,R> java.util.stream.Stream<R>	forEach3(java.util.stream.Stream<? extends T1> value1, java.util.function.Function<? super T1,? extends java.util.stream.Stream<R1>> value2, java.util.function.BiFunction<? super T1,? super R1,? extends java.util.stream.Stream<R2>> value3, Fn3<? super T1,? super R1,? super R2,java.lang.Boolean> filterFunction, Fn3<? super T1,? super R1,? super R2,? extends R> yieldingFunction) Perform a For Comprehension over a Stream, accepting 2 generating function.
static <T1,T2,T3,R1,R2,R3,R> java.util.stream.Stream<R>	forEach4(java.util.stream.Stream<? extends T1> value1, java.util.function.Function<? super T1,? extends java.util.stream.Stream<R1>> value2, java.util.function.BiFunction<? super T1,? super R1,? extends java.util.stream.Stream<R2>> value3, Fn3<? super T1,? super R1,? super R2,? extends java.util.stream.Stream<R3>> value4, Fn4<? super T1,? super R1,? super R2,? super R3,? extends R> yieldingFunction) Perform a For Comprehension over a Stream, accepting 3 generating functions.
static <T1,T2,T3,R1,R2,R3,R> java.util.stream.Stream<R>	forEach4(java.util.stream.Stream<? extends T1> value1, java.util.function.Function<? super T1,? extends java.util.stream.Stream<R1>> value2, java.util.function.BiFunction<? super T1,? super R1,? extends java.util.stream.Stream<R2>> value3, Fn3<? super T1,? super R1,? super R2,? extends java.util.stream.Stream<R3>> value4, Fn4<? super T1,? super R1,? super R2,? super R3,java.lang.Boolean> filterFunction, Fn4<? super T1,? super R1,? super R2,? super R3,? extends R> yieldingFunction) Perform a For Comprehension over a Stream, accepting 3 generating function.
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) List<SetX<Integer>> list = Streams.grouped(Stream.of(1,2,3,4,5,6) ,3,()->SetX.empty()) .collect(CyclopsCollectors.toList()); assertThat(list.get(0),hasItems(1,2,3)); assertThat(list.get(1),hasItems(4,5,6));
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 toNested 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 reactiveStream 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 reactiveStream at the specified position
static <T> java.util.stream.Stream<T>	intersperse(java.util.stream.Stream<T> stream, T value) Returns a reactiveStream with a given value interspersed between any two values of this reactiveStream.
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 reactiveStream 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 toNested map this Monad toNested the same type as the supplied Monoid, using supplied function Then use Monoid toNested reduce values
static <T,R> R	mapReduce(java.util.stream.Stream<T> stream, Reducer<R> reducer) Attempt toNested map this Monad toNested the same type as the supplied Monoid (using mapToType on the monoid interface) Then use Monoid toNested 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> java.util.stream.Stream<T>	narrow(java.util.stream.Stream<? extends T> stream)
static <T> boolean	noneMatch(java.util.stream.Stream<T> stream, java.util.function.Predicate<? super T> c) assertThat(Streams.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 reactiveStream 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> com.aol.cyclops2.internal.stream.OneShotStreamX<T>	oneShotStream(java.util.Spliterator<T> stream, java.util.Optional<com.aol.cyclops2.internal.stream.spliterators.ReversableSpliterator> rev)
static <T> ReactiveSeq<T>	oneShotStream(java.util.stream.Stream<T> stream)
static <T> ReactiveSeq<T>	oneShotStreamI(java.lang.Iterable<T> iterable)
static <T> java.util.stream.Stream<T>	optionalToStream(java.util.Optional<T> optional) Convert an Optional toNested 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<? super 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 toNested the skip 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 toNested this Stream
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 toNested the leading reactiveStream.
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, java.util.function.Supplier<java.util.Deque<T>> bufferFactory) Makes four copies of a Stream Buffers intermediate values, leaders may change positions so a limit can be safely applied toNested the leading reactiveStream.
static <T> ReactiveSeq<T>	reactiveSeq(java.lang.Iterable<T> iterable)
static <T> ReactiveSeq<T>	reactiveSeq(org.jooq.lambda.Seq<T> stream)
static <T> ReactiveSeq<T>	reactiveSeq(java.util.Spliterator<? super T> stream, java.util.Optional<com.aol.cyclops2.internal.stream.spliterators.ReversableSpliterator> rev)
static <T> ReactiveSeq<T>	reactiveSeq(java.util.stream.Stream<? super T> stream, java.util.Optional<com.aol.cyclops2.internal.stream.spliterators.ReversableSpliterator> rev)
static <T> ReactiveSeq<T>	reactiveSeq(java.util.stream.Stream<T> stream)
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 reactiveStream 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 reactiveStream 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<VectorX<T>>	sliding(java.util.stream.Stream<T> stream, int windowSize) Create a sliding view over this Stream
static <T> java.util.stream.Stream<VectorX<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 reactiveStream at point where predicate no longer holds
static <T> boolean	startsWith(java.util.stream.Stream<T> stream, java.lang.Iterable<T> iterable) assertTrue(Streams.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(Streams.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 reactiveStream from an iterable
static <U> java.util.stream.Stream<U>	stream(java.util.Iterator<U> it) Create a reactiveStream 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 reactiveStream 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.lang.Iterable<A>>	toBufferingCopier(java.lang.Iterable<A> it, int copies)
static <A> ListX<java.lang.Iterable<A>>	toBufferingCopier(java.lang.Iterable<A> it, int copies, java.util.function.Supplier<java.util.Deque<A>> bufferSupplier)
static <A> ListX<java.util.Iterator<A>>	toBufferingCopier(java.util.Iterator<A> iterator, int copies)
static <A> ListX<java.util.Iterator<A>>	toBufferingCopier(java.util.Iterator<A> iterator, int copies, java.util.function.Supplier<java.util.Deque<A>> bufferSupplier)
static <A> org.jooq.lambda.tuple.Tuple2<java.lang.Iterable<A>,java.lang.Iterable<A>>	toBufferingDuplicator(java.lang.Iterable<A> it)
static <A> org.jooq.lambda.tuple.Tuple2<java.lang.Iterable<A>,java.lang.Iterable<A>>	toBufferingDuplicator(java.lang.Iterable<A> it, java.util.function.Supplier<java.util.Deque<A>> bufferFactory)
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> org.jooq.lambda.tuple.Tuple2<java.util.Iterator<A>,java.util.Iterator<A>>	toBufferingDuplicator(java.util.Iterator<A> iterator, long pos, java.util.function.Supplier<java.util.Deque<A>> bufferFactory)
static <A> org.jooq.lambda.tuple.Tuple2<java.util.Iterator<A>,java.util.Iterator<A>>	toBufferingDuplicator(java.util.Iterator<A> iterator, java.util.function.Supplier<java.util.Deque<A>> bufferFactory)
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 reactiveStream.
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 toNested the leading reactiveStream.
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, java.util.function.Supplier<java.util.Deque<T>> bufferFactory) Triplicates a Stream Buffers intermediate values, leaders may change positions so a limit can be safely applied toNested the leading reactiveStream.
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<Witness.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>	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

Streams

public Streams()

Method Detail

combinations

public static <T> ReactiveSeq<ReactiveSeq<T>> combinations(int size,
                                                           java.lang.Object[] a)

forEach4

public static <T1,T2,T3,R1,R2,R3,R> java.util.stream.Stream<R> forEach4(java.util.stream.Stream<? extends T1> value1,
                                                                        java.util.function.Function<? super T1,? extends java.util.stream.Stream<R1>> value2,
                                                                        java.util.function.BiFunction<? super T1,? super R1,? extends java.util.stream.Stream<R2>> value3,
                                                                        Fn3<? super T1,? super R1,? super R2,? extends java.util.stream.Stream<R3>> value4,
                                                                        Fn4<? super T1,? super R1,? super R2,? super R3,? extends R> yieldingFunction)

Perform a For Comprehension over a Stream, accepting 3 generating functions. This results in a four level nested internal iteration over the provided Publishers.

 

   import static cyclops.companion.Streams.forEach4;

          forEach4(IntStream.range(1,10).boxed(),
                   a-> Stream.iterate(a,i->i+1).limit(10),
                  (a,b) -> Stream.<Integer>of(a+b),
                  (a,b,c) -> Stream.<Integer>just(a+b+c),
                  Tuple::tuple)

 
 

Parameters:

value1 - top level Stream

value2 - Nested Stream

value3 - Nested Stream

value4 - Nested Stream

yieldingFunction - Generates a result per combination

Returns:

Stream with an element per combination of nested publishers generated by the yielding function

forEach4

public static <T1,T2,T3,R1,R2,R3,R> java.util.stream.Stream<R> forEach4(java.util.stream.Stream<? extends T1> value1,
                                                                        java.util.function.Function<? super T1,? extends java.util.stream.Stream<R1>> value2,
                                                                        java.util.function.BiFunction<? super T1,? super R1,? extends java.util.stream.Stream<R2>> value3,
                                                                        Fn3<? super T1,? super R1,? super R2,? extends java.util.stream.Stream<R3>> value4,
                                                                        Fn4<? super T1,? super R1,? super R2,? super R3,java.lang.Boolean> filterFunction,
                                                                        Fn4<? super T1,? super R1,? super R2,? super R3,? extends R> yieldingFunction)

Perform a For Comprehension over a Stream, accepting 3 generating function. This results in a four level nested internal iteration over the provided Publishers.

 

  import static com.aol.cyclops2.reactor.Streames.forEach4;

  forEach4(IntStream.range(1,10).boxed(),
                 a-> Stream.iterate(a,i->i+1).limit(10),
                 (a,b) -> Stream.<Integer>just(a+b),
                 (a,b,c) -> Stream.<Integer>just(a+b+c),
                 (a,b,c,d) -> a+b+c+d <100,
                 Tuple::tuple);

 
 

Parameters:

value1 - top level Stream

value2 - Nested Stream

value3 - Nested Stream

value4 - Nested Stream

filterFunction - A filtering function, keeps values where the predicate holds

yieldingFunction - Generates a result per combination

Returns:

Stream with an element per combination of nested publishers generated by the yielding function

forEach3

public static <T1,T2,R1,R2,R> java.util.stream.Stream<R> forEach3(java.util.stream.Stream<? extends T1> value1,
                                                                  java.util.function.Function<? super T1,? extends java.util.stream.Stream<R1>> value2,
                                                                  java.util.function.BiFunction<? super T1,? super R1,? extends java.util.stream.Stream<R2>> value3,
                                                                  Fn3<? super T1,? super R1,? super R2,? extends R> yieldingFunction)

Perform a For Comprehension over a Stream, accepting 2 generating function. This results in a three level nested internal iteration over the provided Publishers.

 

 import static Streams.forEach3;

 forEach(IntStream.range(1,10).boxed(),
                a-> Stream.iterate(a,i->i+1).limit(10),
                (a,b) -> Stream.<Integer>of(a+b),
                Tuple::tuple);

 
 

Parameters:

value1 - top level Stream

value2 - Nested Stream

value3 - Nested Stream

yieldingFunction - Generates a result per combination

Returns:

Stream with an element per combination of nested publishers generated by the yielding function

forEach3

public static <T1,T2,R1,R2,R> java.util.stream.Stream<R> forEach3(java.util.stream.Stream<? extends T1> value1,
                                                                  java.util.function.Function<? super T1,? extends java.util.stream.Stream<R1>> value2,
                                                                  java.util.function.BiFunction<? super T1,? super R1,? extends java.util.stream.Stream<R2>> value3,
                                                                  Fn3<? super T1,? super R1,? super R2,java.lang.Boolean> filterFunction,
                                                                  Fn3<? super T1,? super R1,? super R2,? extends R> yieldingFunction)

Perform a For Comprehension over a Stream, accepting 2 generating function. This results in a three level nested internal iteration over the provided Publishers.

 

 import static Streams.forEach;

 forEach(IntStream.range(1,10).boxed(),
               a-> Stream.iterate(a,i->i+1).limit(10),
              (a,b) -> Stream.<Integer>of(a+b),
              (a,b,c) ->a+b+c<10,
              Tuple::tuple)
                .listX();
 
 

Parameters:

value1 - top level Stream

value2 - Nested publisher

value3 - Nested publisher

filterFunction - A filtering function, keeps values where the predicate holds

yieldingFunction - Generates a result per combination

Returns:

forEach2

public static <T,R1,R> java.util.stream.Stream<R> forEach2(java.util.stream.Stream<? extends T> value1,
                                                           java.util.function.Function<? super T,java.util.stream.Stream<R1>> value2,
                                                           java.util.function.BiFunction<? super T,? super R1,? extends R> yieldingFunction)

Perform a For Comprehension over a Stream, accepting an additonal generating function. This results in a two level nested internal iteration over the provided Publishers.

 

  import static Streams.forEach2;
  forEach(IntStream.range(1, 10).boxed(),
          i -> Stream.range(i, 10), Tuple::tuple)
            .forEach(System.out::println);

    //(1, 1)
    (1, 2)
    (1, 3)
    (1, 4)
    ...

 

Parameters:

value1 - top level Stream

value2 - Nested publisher

yieldingFunction - Generates a result per combination

Returns:

forEach2

public static <T,R1,R> java.util.stream.Stream<R> forEach2(java.util.stream.Stream<? extends T> value1,
                                                           java.util.function.Function<? super T,? extends java.util.stream.Stream<R1>> value2,
                                                           java.util.function.BiFunction<? super T,? super R1,java.lang.Boolean> filterFunction,
                                                           java.util.function.BiFunction<? super T,? super R1,? extends R> yieldingFunction)

 

   import static Streams.forEach2;

   forEach(IntStream.range(1, 10).boxed(),
           i -> Stream.range(i, 10),
           (a,b) -> a>2 && b<10,
           Tuple::tuple)
           .forEach(System.out::println);

    //(3, 3)
    (3, 4)
    (3, 5)
    (3, 6)
    (3, 7)
    (3, 8)
    (3, 9)
    ...


 

Parameters:

value1 - top level Stream

value2 - Nested publisher

filterFunction - A filtering function, keeps values where the predicate holds

yieldingFunction - Generates a result per combination

Returns:

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 = Streams.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 toNested a Stream

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

Parameters:

optional - Optional toNested convert toNested 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 toNested a Stream

Parameters:

future - CompletableFuture toNested convert

Returns:

Stream with a single value created from a CompletableFuture

forEach

public static <T,X extends java.lang.Throwable> org.reactivestreams.Subscription forEach(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 toNested 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.

forEach

public static <T,X extends java.lang.Throwable> org.reactivestreams.Subscription forEach(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 toNested 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.

forEach

public static <T,X extends java.lang.Throwable> org.reactivestreams.Subscription forEach(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 toNested 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.

forEach

public static <T,X extends java.lang.Throwable> void forEach(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 toNested consume data from

consumer - To accept incoming elements from the Stream

consumerError - To accept incoming processing errors from the Stream

forEach

public static <T,X extends java.lang.Throwable> void forEach(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 toNested 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
 Streams.schedule(Stream.generate(()->"next job:"+formatDate(new Date()))
            .map(this::processJob)
            ,"0 20 * * *",Executors.newScheduledThreadPool(1)));
 
 

Connect toNested the Scheduled Stream

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

Parameters:

stream - the reactiveStream toNested schedule element processing on

cron - Expression that determines when each job will run

ex - ScheduledExecutorService

Returns:

Connectable HotStream of emitted 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
  Streams.scheduleFixedDelay(Stream.generate(()->"next job:"+formatDate(new Date()))
            .map(this::processJob)
            ,60_000,Executors.newScheduledThreadPool(1)));
 
 

Connect toNested the Scheduled Stream

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

Parameters:

stream - the reactiveStream toNested schedule element processing on

delay - Between last element completes passing through the Stream until the next one starts

ex - ScheduledExecutorService

Returns:

Connectable HotStream of emitted 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
  Streams.scheduleFixedRate(Stream.generate(()->"next job:"+formatDate(new Date()))
            .map(this::processJob),
            60_000,Executors.newScheduledThreadPool(1)));
 
 

Connect toNested the Scheduled Stream

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

Parameters:

stream - the reactiveStream toNested schedule element processing on

rate - Time in millis between job runs

ex - ScheduledExecutorService

Returns:

Connectable HotStream of emitted 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)
 
  //Stream[1], Stream[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 reactiveStream at point where predicate no longer holds

 
   ReactiveSeq.of(1, 2, 3, 4, 5, 6).splitBy(i->i<4)
   
   //Stream[1,2,3] Stream[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<? super 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) 
  
  //Stream[1,3,5], Stream[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 toNested the leading reactiveStream. 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 reactiveStream

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,
                                                                                                                      java.util.function.Supplier<java.util.Deque<T>> bufferFactory)

Duplicate a Stream, buffers intermediate values, leaders may change positions so a limit can be safely applied toNested the leading reactiveStream. 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 reactiveStream

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 toNested the leading reactiveStream. Not thread-safe.

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

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,
                                                                                                                                                  java.util.function.Supplier<java.util.Deque<T>> bufferFactory)

Triplicates a Stream Buffers intermediate values, leaders may change positions so a limit can be safely applied toNested the leading reactiveStream. 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 toNested the leading reactiveStream. 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:

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,
                                                                                                                                                                                java.util.function.Supplier<java.util.Deque<T>> bufferFactory)

Makes four copies of a Stream Buffers intermediate values, leaders may change positions so a limit can be safely applied toNested the leading reactiveStream. 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 toNested this Stream

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

Parameters:

stream - toNested append

Returns:

Stream 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 toNested this Stream

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

Parameters:

stream - toNested Prepend

Returns:

Stream with Stream prepended

append

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

Append values toNested the take of this Stream

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

Parameters:

values - toNested append

Returns:

Stream 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 toNested the skip of the Stream

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

Parameters:

values - toNested prepend

Returns:

Stream 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 reactiveStream at given position

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

Parameters:

pos - toNested insert data at

values - toNested 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 = 	Streams.deleteBetween(Stream.of(1,2,3,4,5,6),2,4)
    										.map(it ->it+"!!")
    										.collect(CyclopsCollectors.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 reactiveStream at the specified position

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

Parameters:

pos - toNested insert Stream at

stream - toNested insert

Returns:

newly conjoined Stream

cycle

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

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

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

Parameters:

m - Monoid toNested 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 = Streams.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

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

Parameters:

stream - Stream toNested skip elements from

predicate - toNested 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

 
   Streams.skipWhile(Stream.of(4,3,6,7).sorted(),i->i<6).collect(CyclopsCollectors.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)

combineI

public static <T> java.lang.Iterable<java.lang.Iterable<T>> combineI(java.lang.Iterable<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 reactiveStream while the predicates hold

  Streams.limitWhile(Stream.of(4,3,6,7).sorted(),i->i<6).collect(CyclopsCollectors.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

  Streams.limitUntil(Stream.of(4,3,6,7),i->i==6).collect(CyclopsCollectors.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(Streams.reverse(Stream.of(1,2,3)).collect(CyclopsCollectors.toList())
    			,equalTo(Arrays.asList(3,2,1)));
 
 

Parameters:

stream - Stream toNested reverse

Returns:

Reversed reactiveStream

reversedStream

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

Create a reversed Stream from a List

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

Parameters:

list - List toNested 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(Streams.cycle(Stream.of(1,2,3))
 						.limit(6)
 						.collect(CyclopsCollectors.toList()),
 								equalTo(Arrays.asList(1,2,3,1,2,3)));
    	
 

Parameters:

s - Stream toNested cycle

Returns:

New cycling reactiveStream

cycle

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

Create a Stream that infiniteable cycles the provided Streamable

Parameters:

s - Streamable toNested cycle

Returns:

New cycling reactiveStream

cycle

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

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

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

Parameters:

s - Streamable toNested cycle

Returns:

New cycling reactiveStream

stream

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

Create a reactiveStream from an iterable

  
 	assertThat(Streams.reactiveStream(Arrays.asList(1,2,3))
 								.collect(CyclopsCollectors.toList()),
 									equalTo(Arrays.asList(1,2,3)));
    
 
 
 

Parameters:

it - Iterable toNested convert toNested 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 reactiveStream from an iterator

  
 	assertThat(Streams.reactiveStream(Arrays.asList(1,2,3).iterator())
 							.collect(CyclopsCollectors.toList()),
 								equalTo(Arrays.asList(1,2,3)));
    
 
 

Parameters:

it - Iterator toNested convert toNested a Stream

Returns:

Stream from iterator

concat

public 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

Parameters:

o - Object toNested concat

stream - Stream toNested 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 reactiveStream from a map

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

Parameters:

it - Iterator toNested convert toNested a Stream

Returns:

Stream from a map

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 reactiveStream 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 = Streams.reduce(Stream.of(1,2,3,4),Arrays.asList(sum,mult));
    			
    	 
    	assertThat(result,equalTo(Arrays.asList(10,24)));
    	

Parameters:

stream - Stream toNested reduce

reducers - Reducers toNested 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 reactiveStream with multiple reducers

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

Parameters:

stream - Stream toNested reduce

reducers - Reducers toNested 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(Streams.cycleWhile(Stream.of(1,2,2)
    										,next -> count++<6 )
    										.collect(CyclopsCollectors.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(Streams.cycleUntil(Stream.of(1,2,2,3)
    										,next -> count++>10 )
    										.collect(CyclopsCollectors.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 = Streams.zip(Stream.of(1,2,3)
    											,ReactiveSeq.of(2,3,4), 
    												(a,b) -> Arrays.asList(a,b));
    	
    	
    	List<Integer> zip = zipped.collect(CyclopsCollectors.toList()).get(1);
    	assertThat(zip.get(0),equalTo(2));
    	assertThat(zip.get(1),equalTo(3));
 
 

Parameters:

second - Monad toNested 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<Witness.stream,? 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 = Streams.zip(Stream.of(1,2,3)
    									,fromEither5(Optional.of(2)),
    										(a,b) -> Arrays.asList(a,b));
    	
    	
    	List<Integer> zip = zipped.collect(CyclopsCollectors.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 = Streams.zipStream(Stream.of(1,2,3)
    											,Stream.of(2,3,4), 
    												(a,b) -> Arrays.asList(a,b));
    	
    	
    	List<Integer> zip = zipped.collect(CyclopsCollectors.toList()).get(1);
    	assertThat(zip.get(0),equalTo(2));
    	assertThat(zip.get(1),equalTo(3));
       
       

Parameters:

second - Stream toNested zip with

zipper - Zip funciton

Returns:

This monad zipped with a Stream

sliding

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

Create a sliding view over this Stream

  
 List<List<Integer>> list = Streams.sliding(Stream.of(1,2,3,4,5,6)
    											,2,1)
    								.collect(CyclopsCollectors.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 = Streams.sliding(Stream.of(1,2,3,4,5,6)
    											,2,1)
    								.collect(CyclopsCollectors.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<VectorX<T>> sliding(java.util.stream.Stream<T> stream,
                                                                    int windowSize)

Create a sliding view over this Stream

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

Parameters:

stream - Stream toNested create sliding view on

windowSize - size of window

Returns:

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 = Streams.grouped(Stream.of(1,2,3,4,5,6)
                                                        ,3)
                                                    .collect(CyclopsCollectors.toList());
        
        
        assertThat(list.get(0),hasItems(1,2,3));
        assertThat(list.get(1),hasItems(4,5,6));
        
 

Parameters:

stream - Stream toNested group

groupSize - Size of each Group

Returns:

Stream with elements grouped by size

grouped

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)

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

Parameters:

stream - Stream toNested 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"),
 					Streams.scanLeft(Stream.of("a", "b", "c"),Reducers.toString(""))
 			.collect(CyclopsCollectors.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(Streams.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(Streams.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 toNested map this Monad toNested the same type as the supplied Monoid (using mapToType on the monoid interface) Then use Monoid toNested reduce values

Parameters:

reducer - Monoid toNested 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 toNested map this Monad toNested the same type as the supplied Monoid, using supplied function Then use Monoid toNested reduce values

Parameters:

mapper - Function toNested map Monad type

reducer - Monoid toNested 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 toNested 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 toNested map this Monad toNested the same type as the supplied Monoid (using mapToType on the monoid interface) Then use Monoid toNested reduce values

Parameters:

reducer - Monoid toNested 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 toNested 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 toNested map this Monad toNested the same type as the supplied Monoid (using mapToType on the monoid interface) Then use Monoid toNested reduce values

Parameters:

reducer - Monoid toNested reduce values

Returns:

Reduce result

toStreamable

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

Returns:

Underlying monad converted toNested a Streamable instance

toSet

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

Returns:

This monad converted toNested a set

toList

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

Returns:

this monad converted toNested a list

startsWith

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

 
 assertTrue(Streams.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(Streams.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

oneShotStreamI

public static <T> ReactiveSeq<T> oneShotStreamI(java.lang.Iterable<T> iterable)

oneShotStream

public static <T> ReactiveSeq<T> oneShotStream(java.util.stream.Stream<T> stream)

oneShotStream

public static <T> com.aol.cyclops2.internal.stream.OneShotStreamX<T> oneShotStream(java.util.Spliterator<T> stream,
                                                                                   java.util.Optional<com.aol.cyclops2.internal.stream.spliterators.ReversableSpliterator> rev)

reactiveSeq

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

reactiveSeq

public static final <T> ReactiveSeq<T> reactiveSeq(java.lang.Iterable<T> iterable)

reactiveSeq

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

reactiveSeq

public static final <T> ReactiveSeq<T> reactiveSeq(org.jooq.lambda.Seq<T> stream)

reactiveSeq

public static final <T> ReactiveSeq<T> reactiveSeq(java.util.Spliterator<? super T> stream,
                                                   java.util.Optional<com.aol.cyclops2.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 reactiveStream with a given value interspersed between any two values of this reactiveStream.

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

ofType

public 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 reactiveStream that are of a given type. assertThat(Arrays.asList(1, 2, 3), equalTo( Streams.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 reactiveStream toNested a given type, possibly throwing a ClassCastException.

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

narrow

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

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<Witness.stream,? 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 toNested be returned

  
 	assertThat(Streams.flatMapCollection(Stream.of(20),i->Arrays.asList(1,2,i))
 								.collect(CyclopsCollectors.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(Streams.flatMapStream(Stream.of(1,2,3),
 							i->Stream.of(i)).collect(CyclopsCollectors.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(Streams.flatMapOptional(Stream.of(1,2,3,null),
 										Optional::ofNullable)
 										.collect(CyclopsCollectors.toList()),
 										equalTo(Arrays.asList(1,2,3)));
    
 
 

flatten

public static final <T> java.util.stream.Stream<T> flatten(java.util.stream.Stream<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(Streams.flatMapCompletableFuture(Stream.of(1,2,3),
 								i->CompletableFuture.completedFuture(i+2))
 								.collect(CyclopsCollectors.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 reactiveStream of Characters from the CharSequence returned by the supplied function.

  
   List<Character> result = Streams.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 reactiveStream of Strings from the text loaded from the supplied files.

 
 
    	List<String> result = Streams.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 reactiveStream of Strings from the text loaded from the supplied URLs

  
 List<String> result = Streams.liftAndBindURL(Stream.of("input.file")
    							,getClass().getClassLoader()::getResource)
    							.collect(CyclopsCollectors.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 reactiveStream of Strings from the text loaded from the supplied BufferedReaders

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

Parameters:

fn -

Returns:

toBufferingDuplicator

public static final <A> org.jooq.lambda.tuple.Tuple2<java.lang.Iterable<A>,java.lang.Iterable<A>> toBufferingDuplicator(java.lang.Iterable<A> it,
                                                                                                                        java.util.function.Supplier<java.util.Deque<A>> bufferFactory)

toBufferingDuplicator

public static final <A> org.jooq.lambda.tuple.Tuple2<java.lang.Iterable<A>,java.lang.Iterable<A>> toBufferingDuplicator(java.lang.Iterable<A> it)

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)

toBufferingDuplicator

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

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,
                                                                                                                        java.util.function.Supplier<java.util.Deque<A>> bufferFactory)

toBufferingCopier

public static final <A> ListX<java.lang.Iterable<A>> toBufferingCopier(java.lang.Iterable<A> it,
                                                                       int copies)

toBufferingCopier

public static final <A> ListX<java.lang.Iterable<A>> toBufferingCopier(java.lang.Iterable<A> it,
                                                                       int copies,
                                                                       java.util.function.Supplier<java.util.Deque<A>> bufferSupplier)

toBufferingCopier

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

toBufferingCopier

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

toLazyCollection

public static final <A> CollectionX<A> toLazyCollection(java.util.stream.Stream<A> stream)

Projects an immutable collection of this reactiveStream. 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 reactiveStream.

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 toNested determing grouping limits

Parameters:

stream - Stream toNested group

predicate - Predicate toNested 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 toNested group

predicate - Predicate toNested 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 toNested group

predicate - Predicate toNested determine grouping

factory - Supplier toNested 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 toNested group

predicate - Predicate toNested 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 toNested 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)

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 toNested group

size - Max group size

time - Max group time

t - Time unit for max group time

factory - Supplier toNested create collection for groupings

Returns:

Stream grouped by time and size

See Also:

ReactiveSeq.groupedBySizeAndTime(int, long, TimeUnit, Supplier)

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 toNested debounce

time - Time toNested 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 toNested emit one element per time period from

time - Time period

t - Time Pure

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 toNested introduce jitter toNested

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)