cyclops

Class Streams

java.lang.Object

cyclops.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

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

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 function. This results in a four level nested internal iteration over the provided Publishers.

 

   import static Streams.forEach4;

    forEach4(Stream.range(1,10),
    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(Stream.range(1,10),
    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(Stream.range(1,10),
    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(Stream.range(1,10),
    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).toListX();
 
 

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(Stream.range(1, 10), i -> Stream.range(i, 10), Tuple::tuple)
    .subscribe(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(Stream.range(1, 10), i -> Stream.range(i, 10),(a,b) -> a>2 && b<10,Tuple::tuple)
    .subscribe(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 to a Stream

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

Parameters:

optional - Optional to convert to a Stream

Returns:

Stream with a single value (if present) created from an Optional

streamToCompletableFuture

public static final <T> java.util.concurrent.CompletableFuture<java.util.List<T>> streamToCompletableFuture(java.util.stream.Stream<T> stream)

Create a CompletableFuture containing a List materialized from a Stream

Parameters:

stream - To convert into an Optional

Returns:

CompletableFuture with a List of values

completableFutureToStream

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

Convert a CompletableFuture to a Stream

Parameters:

future - CompletableFuture to convert

Returns:

Stream with a single value created from a CompletableFuture

forEachX

public static <T,X extends java.lang.Throwable> org.reactivestreams.Subscription forEachX(java.util.stream.Stream<T> stream,
                                                                                          long x,
                                                                                          java.util.function.Consumer<? super T> consumerElement)

Perform a forEach operation over the Stream, without closing it, consuming only the specified number of elements from the Stream, at this time. More elements can be consumed later, by called request on the returned Subscription

Parameters:

Stream - - the Stream to consume data from

numberOfElements - To consume from the Stream at this time

consumer - To accept incoming events from the Stream

Returns:

Subscription so that further processing can be continued or cancelled.

forEachXWithError

public static <T,X extends java.lang.Throwable> org.reactivestreams.Subscription forEachXWithError(java.util.stream.Stream<T> stream,
                                                                                                   long x,
                                                                                                   java.util.function.Consumer<? super T> consumerElement,
                                                                                                   java.util.function.Consumer<? super java.lang.Throwable> consumerError)

Perform a forEach operation over the Stream without closing it, capturing any elements and errors in the supplied consumers, but only consuming the specified number of elements from the Stream, at this time. More elements can be consumed later, by called request on the returned Subscription

Parameters:

Stream - - the Stream to consume data from

numberOfElements - To consume from the Stream at this time

consumer - To accept incoming elements from the Stream

consumerError - To accept incoming processing errors from the Stream

onComplete - To run after an onComplete event

Returns:

Subscription so that further processing can be continued or cancelled.

forEachXEvents

public static <T,X extends java.lang.Throwable> org.reactivestreams.Subscription forEachXEvents(java.util.stream.Stream<T> stream,
                                                                                                long x,
                                                                                                java.util.function.Consumer<? super T> consumerElement,
                                                                                                java.util.function.Consumer<? super java.lang.Throwable> consumerError,
                                                                                                java.lang.Runnable onComplete)

Perform a forEach operation over the Stream without closing it, capturing any elements and errors in the supplied consumers, but only consuming the specified number of elements from the Stream, at this time. More elements can be consumed later, by called request on the returned Subscription, when the entire Stream has been processed an onComplete event will be recieved.

Parameters:

Stream - - the Stream to consume data from

numberOfElements - To consume from the Stream at this time

consumer - To accept incoming elements from the Stream

consumerError - To accept incoming processing errors from the Stream

onComplete - To run after an onComplete event

Returns:

Subscription so that further processing can be continued or cancelled.

forEachWithError

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

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

Parameters:

Stream - - the Stream to consume data from

consumer - To accept incoming elements from the Stream

consumerError - To accept incoming processing errors from the Stream

forEachEvent

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

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

Parameters:

Stream - - the Stream to consume data from

consumer - To accept incoming elements from the Stream

consumerError - To accept incoming processing errors from the Stream

onComplete - To run after an onComplete event

schedule

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

Execute this Stream on a schedule

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

Connect to 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 stream to schedule element processing on

cron - Expression that determines when each job will run

ex - ScheduledExecutorService

Returns:

Connectable HotStream of output from scheduled Stream

scheduleFixedDelay

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

Execute this Stream on a schedule

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

Connect to 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 stream to schedule element processing on

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

ex - ScheduledExecutorService

Returns:

Connectable HotStream of output from scheduled Stream

scheduleFixedRate

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

Execute this Stream on a schedule

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

Connect to 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 stream to schedule element processing on

rate - Time in millis between job runs

ex - ScheduledExecutorService

Returns:

Connectable HotStream of output from scheduled Stream

splitAt

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

Split at supplied location

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

splitBy

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

Split stream at point where predicate no longer holds

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

partition

public static final <T> org.jooq.lambda.tuple.Tuple2<java.util.stream.Stream<T>,java.util.stream.Stream<T>> partition(java.util.stream.Stream<T> stream,
                                                                                                                      java.util.function.Predicate<? 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) 
  
  //SequenceM[1,3,5], SequenceM[2,4,6]
 

 

duplicate

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

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

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

Returns:

duplicated stream

triplicate

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

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

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

quadruplicate

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

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

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

Returns:

appendStream

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

Append Stream to this SequenceM

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

Parameters:

stream - to append

Returns:

SequenceM with Stream appended

prependStream

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

Prepend Stream to this SequenceM

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

Parameters:

stream - to Prepend

Returns:

SequenceM with Stream prepended

append

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

Append values to the take of this SequenceM

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

Parameters:

values - to append

Returns:

SequenceM with appended values

prepend

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

Prepend given values to the skip of the Stream

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

Parameters:

values - to prepend

Returns:

SequenceM with values prepended

insertAt

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

Insert data into a stream at given position

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

Parameters:

pos - to insert data at

values - to insert

Returns:

Stream with new data inserted

deleteBetween

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

Delete elements between given indexes in a Stream

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

Parameters:

start - index

end - index

Returns:

Stream with elements removed

insertStreamAt

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

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

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

Parameters:

pos - to insert Stream at

stream - to insert

Returns:

newly conjoined SequenceM

cycle

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

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

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

Parameters:

m - Monoid to be used in reduction

times - Number of times value should be repeated

Returns:

Stream with reduced values repeated

headAndTail

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

extract head and tail together

  
  Stream<String> helloWorld = Stream.of("hello","world","last");
    	HeadAndTail<String> headAndTail = 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(Collectors.toList())
  // [6,7]
  

Parameters:

stream - Stream to skip elements from

predicate - to apply

Returns:

Stream with elements skipped

skipLast

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

limitLast

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

recover

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

recover

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

skipWhile

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

skip elements in a Stream while Predicate holds true

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

Parameters:

stream -

predicate -

Returns:

limit

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

skip

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

combine

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

limitWhile

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

Take elements from a stream while the predicates hold

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

Parameters:

stream -

predicate -

Returns:

limitUntil

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

Take elements from a Stream until the predicate holds

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

Parameters:

stream -

predicate -

Returns:

reverse

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

Reverse a Stream

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

Parameters:

stream - Stream to reverse

Returns:

Reversed stream

reversedStream

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

Create a reversed Stream from a List

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

Parameters:

list - List to create a reversed Stream from

Returns:

Reversed Stream

cycle

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

Create a new Stream that infiniteable cycles the provided Stream

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

Parameters:

s - Stream to cycle

Returns:

New cycling stream

cycle

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

Create a Stream that infiniteable cycles the provided Streamable

Parameters:

s - Streamable to cycle

Returns:

New cycling stream

cycle

public static <U> java.util.stream.Stream<U> cycle(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(Collectors.toList()),
    								equalTo(Arrays.asList(1,2,2,1,2,2,1,2,2)));
 
 

Parameters:

s - Streamable to cycle

Returns:

New cycling stream

stream

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

Create a stream from an iterable

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

Parameters:

it - Iterable to convert to a Stream

Returns:

Stream from iterable

stream

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

stream

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

Create a stream from an iterator

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

Parameters:

it - Iterator to convert to a Stream

Returns:

Stream from iterator

concat

public static <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 to concat

stream - Stream to concat

Returns:

Concatonated Stream

stream

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

Create a stream from a map

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

Parameters:

it - Iterator to convert to a Stream

Returns:

Stream from a map

firstValue

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

reduce

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

Simultaneously reduce a stream with multiple reducers

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

Parameters:

stream - Stream to reduce

reducers - Reducers to reduce Stream

Returns:

Reduced Stream values as List entries

reduce

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

Simultanously reduce a stream with multiple reducers

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

Parameters:

stream - Stream to reduce

reducers - Reducers to reduce Stream

Returns:

Reduced Stream values as List entries

cycleWhile

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

Repeat in a Stream while specified predicate holds

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

Parameters:

predicate - repeat while true

Returns:

Repeating Stream

cycleUntil

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

Repeat in a Stream until specified predicate holds

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

Parameters:

predicate - repeat while true

Returns:

Repeating Stream

zipSequence

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

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

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

Parameters:

second - Monad to zip with

zipper - Zipping function

Returns:

Stream zipping two Monads

zipAnyM

public static final <T,S,R> java.util.stream.Stream<R> zipAnyM(java.util.stream.Stream<T> stream,
                                                               AnyM<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(Collectors.toList()).get(0);
    	assertThat(zip.get(0),equalTo(1));
    	assertThat(zip.get(1),equalTo(2));
 
 
 

zipStream

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

Zip this Monad with a Stream

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

Parameters:

second - Stream to zip with

zipper - Zip funciton

Returns:

This monad zipped with a Stream

sliding

public static final <T> java.util.stream.Stream<PVectorX<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(Collectors.toList());
    	
    
    	assertThat(list.get(0),hasItems(1,2));
    	assertThat(list.get(1),hasItems(2,3));
 
 

Parameters:

windowSize - Size of sliding window

Returns:

Stream with sliding view

window

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

Create a sliding view over this Stream

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

Parameters:

windowSize - Size of sliding window

Returns:

Stream with sliding view over monad

sliding

public static final <T> java.util.stream.Stream<PVectorX<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(Collectors.toList());
    	
    
    	assertThat(list.get(0),hasItems(1,2));
    	assertThat(list.get(1),hasItems(2,3));
 
 

Parameters:

stream - Stream to create sliding view on

windowSize - size of window

Returns:

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(Collectors.toList());
        
        
        assertThat(list.get(0),hasItems(1,2,3));
        assertThat(list.get(1),hasItems(4,5,6));
        
 

Parameters:

stream - Stream to group

groupSize - Size of each Group

Returns:

Stream with elements grouped by size

grouped

public static final <T,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(Collectors.toList());
        
        
        assertThat(list.get(0),hasItems(1,2,3));
        assertThat(list.get(1),hasItems(4,5,6));
        
 

Parameters:

stream - Stream to group

groupSize - Size of each Group

factory - Supplier for creating Collections for holding grouping

Returns:

Stream with elements grouped by size

shuffle

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

toLazyStreamable

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

toConcurrentLazyStreamable

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

scanRight

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

scanLeft

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

Scan left using supplied Monoid

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

Parameters:

monoid -

Returns:

xMatch

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

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

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

Parameters:

reducer - Monoid to reduce values

Returns:

Reduce result

mapReduce

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

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

Parameters:

mapper - Function to map Monad type

reducer - Monoid to reduce values

Returns:

Reduce result

foldLeft

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

Parameters:

reducer - Use supplied Monoid to reduce values starting via foldLeft

Returns:

Reduced result

foldLeftMapToType

public static final <T> T foldLeftMapToType(java.util.stream.Stream<T> stream,
                                            Reducer<T> reducer)

Attempt to map this Monad to the same type as the supplied Monoid (using mapToType on the monoid interface) Then use Monoid to reduce values

Parameters:

reducer - Monoid to reduce values

Returns:

Reduce result

foldRight

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

Parameters:

reducer - Use supplied Monoid to reduce values starting via foldRight

Returns:

Reduced result

foldRightMapToType

public static final <T> T foldRightMapToType(java.util.stream.Stream<T> stream,
                                             Reducer<T> reducer)

Attempt to map this Monad to the same type as the supplied Monoid (using mapToType on the monoid interface) Then use Monoid to reduce values

Parameters:

reducer - Monoid to reduce values

Returns:

Reduce result

toStreamable

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

Returns:

Underlying monad converted to a Streamable instance

toSet

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

Returns:

This monad converted to a set

toList

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

Returns:

this monad converted to a list

startsWith

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

 
 assertTrue(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,
                                                   java.util.Optional<com.aol.cyclops2.internal.stream.spliterators.push.PushingSpliterator<?>> push)

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,
                                                   java.util.Optional<com.aol.cyclops2.internal.stream.spliterators.push.PushingSpliterator<?>> push)

intersperse

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

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

  
 assertThat(Arrays.asList(1, 0, 2, 0, 3, 0, 4),
 			equalTo( 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 stream 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 stream to a given type, possibly throwing a ClassCastException.

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

flatMapSequenceM

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

flatMap operation

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

Parameters:

fn -

Returns:

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 to be returned

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

flatMapStream

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

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

flatMapOptional

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

cross type flatMap, removes null entries

  
 	 assertThat(Streams.flatMapOptional(Stream.of(1,2,3,null),
 										Optional::ofNullable)
 										.collect(Collectors.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(Collectors.toList()),
 								equalTo(Arrays.asList(3,4,5)));
    
 

flatMapCharSequence

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

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

  
   List<Character> result = 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 stream 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 stream of Strings from the text loaded from the supplied URLs

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

Parameters:

fn -

Returns:

flatMapBufferedReader

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

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

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

Parameters:

fn -

Returns:

toBufferingDuplicator

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

toBufferingDuplicator

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

toBufferingCopier

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

toLazyCollection

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

Projects an immutable collection of this stream. Initial iteration over the collection is not thread safe (can't be performed by multiple threads concurrently) subsequent iterations are.

Returns:

An immutable collection of this stream.

toLazyCollection

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

toConcurrentLazyCollection

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

Lazily constructs a Collection from specified Stream. Collections iterator may be safely used concurrently by multiple threads.

Parameters:

stream -

Returns:

toConcurrentLazyCollection

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

windowByTime

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

groupedByTime

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

batchByTime

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

Deprecated.

groupedByTime

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

batchByTime

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

Deprecated.

groupedStatefullyUntil

public static final <T> java.util.stream.Stream<ListX<T>> groupedStatefullyUntil(java.util.stream.Stream<T> stream,
                                                                                 java.util.function.BiPredicate<ListX<? super T>,? super T> predicate)

Group data in a Stream using knowledge of the current batch and the next entry to determing grouping limits

Parameters:

stream - Stream to group

predicate - Predicate to determine grouping

Returns:

Stream grouped into Lists determined by predicate

See Also:

ReactiveSeq.groupedStatefullyUntil(BiPredicate)

groupedWhile

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

Group a Stream while the supplied predicate holds

Parameters:

stream - Stream to group

predicate - Predicate to determine grouping

Returns:

Stream grouped into Lists determined by predicate

See Also:

ReactiveSeq.groupedWhile(Predicate)

batchWhile

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

Deprecated.

groupedWhile

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

Group a Stream while the supplied predicate holds

Parameters:

stream - Stream to group

predicate - Predicate to determine grouping

factory - Supplier to create collection for groupings

Returns:

Stream grouped into Collections determined by predicate

See Also:

ReactiveSeq.groupedWhile(Predicate, Supplier)

batchWhile

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

Deprecated.

groupedUntil

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

Group a Stream until the supplied predicate holds

Parameters:

stream - Stream to group

predicate - Predicate to determine grouping

Returns:

Stream grouped into Lists determined by predicate

See Also:

ReactiveSeq.groupedUntil(Predicate)

batchUntil

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

Deprecated.

groupedBySizeAndTime

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

Group a Stream by size and time constraints

Parameters:

stream - Stream to group

size - Max group size

time - Max group time

t - Time unit for max group time

Returns:

Stream grouped by time and size

See Also:

ReactiveSeq.groupedBySizeAndTime(int, long, TimeUnit)

groupedBySizeAndTime

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

Group a Stream by size and time constraints

Parameters:

stream - Stream to group

size - Max group size

time - Max group time

t - Time unit for max group time

factory - Supplier to create collection for groupings

Returns:

Stream grouped by time and size

See Also:

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

debounce

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

Allow one element through per time period, drop all other elements in that time period

Parameters:

stream - Stream to debounce

time - Time to apply debouncing over

t - Time unit for debounce period

Returns:

Stream with debouncing applied

See Also:

ReactiveSeq.debounce(long, TimeUnit)

onePer

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

emit one element per time period

Parameters:

stream - Stream to emit one element per time period from

time - Time period

t - Time 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 to introduce jitter to

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

Returns:

Jittered Stream

See Also:

ReactiveSeq.jitter(long)

fixedDelay

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

xPer

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

hotStream

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

primedHotStream

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

pausableHotStream

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

primedPausableHotStream

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