public class Streams
extends java.lang.Object
Modifier and Type | Class and Description |
---|---|
static class |
Streams.Instances
Companion class for creating Type Class instances for working with Streams
|
static interface |
Streams.StreamKind<T>
Simulates Higher Kinded Types for Stream's
StreamKind is a Stream and a Higher Kinded Type (StreamKind.ยต,T)
|
Constructor and Description |
---|
Streams() |
Modifier and Type | Method and Description |
---|---|
static <T> java.util.stream.Stream<T> |
append(java.util.stream.Stream<T> stream,
T... values)
Append values toNested the take of this Stream
|
static <T> java.util.stream.Stream<T> |
appendStream(java.util.stream.Stream<T> stream1,
java.util.stream.Stream<T> append)
Append Stream toNested this Stream
|
static <T> java.util.stream.Stream<ListX<T>> |
batchByTime(java.util.stream.Stream<T> stream,
long time,
java.util.concurrent.TimeUnit t)
Deprecated.
|
static <T,C extends java.util.Collection<? super T>> |
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>> |
batchWhile(java.util.stream.Stream<T> stream,
java.util.function.Predicate<? super T> predicate,
java.util.function.Supplier<C> factory)
Deprecated.
|
static <T,U> java.util.stream.Stream<U> |
cast(java.util.stream.Stream<T> stream,
java.lang.Class<? extends U> type)
Cast all elements in a reactiveStream toNested a given type, possibly throwing a
ClassCastException . |
static <T> ReactiveSeq<ReactiveSeq<T>> |
combinations(int size,
java.lang.Object[] a) |
static <T> java.util.stream.Stream<T> |
combine(java.util.stream.Stream<T> stream,
java.util.function.BiPredicate<? super T,? super T> predicate,
java.util.function.BinaryOperator<T> op) |
static <T> java.lang.Iterable<java.lang.Iterable<T>> |
combineI(java.lang.Iterable<T> stream,
java.util.function.BiPredicate<? super T,? super T> predicate,
java.util.function.BinaryOperator<T> op) |
static <T> java.util.stream.Stream<T> |
completableFutureToStream(java.util.concurrent.CompletableFuture<T> future)
Convert a CompletableFuture toNested a Stream
|
static <U> java.util.stream.Stream<U> |
concat(java.lang.Object o,
java.util.stream.Stream<U> stream)
Concat an Object and a Stream
If the Object is a Stream, Streamable or Iterable will be converted (or left) in Stream form and concatonated
Otherwise a new Stream.of(o) is created
|
static <U> java.util.stream.Stream<U> |
cycle(long times,
Streamable<U> s)
Create a Stream that finitely cycles the provided Streamable, provided number of times
|
static <T> java.util.stream.Stream<T> |
cycle(java.util.stream.Stream<T> stream,
Monoid<T> m,
int times)
Convert toNested a Stream with the result of a reduction operation repeated
specified times
|
static <U> java.util.stream.Stream<U> |
cycle(java.util.stream.Stream<U> s)
Create a new Stream that infiniteable cycles the provided Stream
|
static <U> java.util.stream.Stream<U> |
cycle(Streamable<U> s)
Create a Stream that infiniteable cycles the provided Streamable
|
static <T> java.util.stream.Stream<T> |
cycleUntil(java.util.stream.Stream<T> stream,
java.util.function.Predicate<? super T> predicate)
Repeat in a Stream until specified predicate holds
|
static <T> java.util.stream.Stream<T> |
cycleWhile(java.util.stream.Stream<T> stream,
java.util.function.Predicate<? super T> predicate)
Repeat in a Stream while specified predicate holds
|
static <T> java.util.stream.Stream<T> |
debounce(java.util.stream.Stream<T> stream,
long time,
java.util.concurrent.TimeUnit t)
Allow one element through per time period, drop all other elements in
that time period
|
static <T> java.util.stream.Stream<T> |
deleteBetween(java.util.stream.Stream<T> stream,
int start,
int end)
Delete elements between given indexes in a Stream
|
static <T> org.jooq.lambda.tuple.Tuple2<java.util.stream.Stream<T>,java.util.stream.Stream<T>> |
duplicate(java.util.stream.Stream<T> stream)
Duplicate a Stream, buffers intermediate values, leaders may change positions so a limit
can be safely applied toNested the leading reactiveStream.
|
static <T> org.jooq.lambda.tuple.Tuple2<java.util.stream.Stream<T>,java.util.stream.Stream<T>> |
duplicate(java.util.stream.Stream<T> stream,
java.util.function.Supplier<java.util.Deque<T>> bufferFactory)
Duplicate a Stream, buffers intermediate values, leaders may change positions so a limit
can be safely applied toNested the leading reactiveStream.
|
static <T> boolean |
endsWith(java.util.stream.Stream<T> stream,
java.lang.Iterable<T> iterable) |
static <T> T |
firstValue(java.util.stream.Stream<T> stream) |
static <T> java.util.stream.Stream<T> |
fixedDelay(java.util.stream.Stream<T> stream,
long time,
java.util.concurrent.TimeUnit unit) |
static <T,R> java.util.stream.Stream<R> |
flatMapAnyM(java.util.stream.Stream<T> stream,
java.util.function.Function<? super T,AnyM<Witness.stream,? extends R>> fn) |
static <T> java.util.stream.Stream<java.lang.String> |
flatMapBufferedReader(java.util.stream.Stream<T> stream,
java.util.function.Function<? super T,java.io.BufferedReader> fn)
Perform a flatMap operation where the result will be a flattened reactiveStream of Strings
from the text loaded from the supplied BufferedReaders
|
static <T> java.util.stream.Stream<java.lang.Character> |
flatMapCharSequence(java.util.stream.Stream<T> stream,
java.util.function.Function<? super T,java.lang.CharSequence> fn)
Perform a flatMap operation where the result will be a flattened reactiveStream of Characters
from the CharSequence returned by the supplied function.
|
static <T,R> java.util.stream.Stream<R> |
flatMapCompletableFuture(java.util.stream.Stream<T> stream,
java.util.function.Function<? super T,java.util.concurrent.CompletableFuture<? extends R>> fn)
assertThat(Streams.flatMapCompletableFuture(Stream.of(1,2,3),
i->CompletableFuture.completedFuture(i+2))
.collect(CyclopsCollectors.toList()),
equalTo(Arrays.asList(3,4,5)));
|
static <T> java.util.stream.Stream<java.lang.String> |
flatMapFile(java.util.stream.Stream<T> stream,
java.util.function.Function<? super T,java.io.File> fn)
Perform a flatMap operation where the result will be a flattened reactiveStream of Strings
from the text loaded from the supplied files.
|
static <T,R> java.util.stream.Stream<R> |
flatMapIterable(java.util.stream.Stream<T> stream,
java.util.function.Function<? super T,? extends java.lang.Iterable<? extends R>> fn)
flatMap operation that allows a Collection toNested be returned
|
static <T,R> java.util.stream.Stream<R> |
flatMapOptional(java.util.stream.Stream<T> stream,
java.util.function.Function<? super T,java.util.Optional<? extends R>> fn)
cross type flatMap, removes null entries
|
static <T,R> java.util.stream.Stream<R> |
flatMapStream(java.util.stream.Stream<T> stream,
java.util.function.Function<? super T,? extends java.util.stream.BaseStream<? extends R,?>> fn)
assertThat(Streams.flatMapStream(Stream.of(1,2,3),
i->Stream.of(i)).collect(CyclopsCollectors.toList()),
equalTo(Arrays.asList(1,2,3)));
|
static <T> java.util.stream.Stream<java.lang.String> |
flatMapURL(java.util.stream.Stream<T> stream,
java.util.function.Function<? super T,java.net.URL> fn)
Perform a flatMap operation where the result will be a flattened reactiveStream of Strings
from the text loaded from the supplied URLs
|
static <T> java.util.stream.Stream<T> |
flatten(java.util.stream.Stream<java.util.stream.Stream<T>> stream) |
static <T> T |
foldLeft(java.util.stream.Stream<T> stream,
Monoid<T> reducer) |
static <T> T |
foldLeftMapToType(java.util.stream.Stream<T> stream,
Reducer<T> reducer)
Attempt toNested map this Monad toNested the same type as the supplied Monoid (using mapToType on the monoid interface)
Then use Monoid toNested reduce values
|
static <T> T |
foldRight(java.util.stream.Stream<T> stream,
Monoid<T> reducer) |
static <T> T |
foldRightMapToType(java.util.stream.Stream<T> stream,
Reducer<T> reducer)
Attempt toNested map this Monad toNested the same type as the supplied Monoid (using mapToType on the monoid interface)
Then use Monoid toNested reduce values
|
static <T,X extends java.lang.Throwable> |
forEach(java.util.stream.Stream<T> stream,
java.util.function.Consumer<? super T> consumerElement,
java.util.function.Consumer<? super java.lang.Throwable> consumerError)
Perform a forEach operation over the Stream capturing any elements and errors in the supplied consumers,
|
static <T,X extends java.lang.Throwable> |
forEach(java.util.stream.Stream<T> stream,
java.util.function.Consumer<? super T> consumerElement,
java.util.function.Consumer<? super java.lang.Throwable> consumerError,
java.lang.Runnable onComplete)
Perform a forEach operation over the Stream capturing any elements and errors in the supplied consumers
when the entire Stream has been processed an onComplete event will be recieved.
|
static <T,X extends java.lang.Throwable> |
forEach(java.util.stream.Stream<T> stream,
long x,
java.util.function.Consumer<? super T> consumerElement)
Perform a forEach operation over the Stream, without closing it, consuming only the specified number of elements from
the Stream, at this time.
|
static <T,X extends java.lang.Throwable> |
forEach(java.util.stream.Stream<T> stream,
long x,
java.util.function.Consumer<? super T> consumerElement,
java.util.function.Consumer<? super java.lang.Throwable> consumerError)
Perform a forEach operation over the Stream without closing it, capturing any elements and errors in the supplied consumers, but only consuming
the specified number of elements from the Stream, at this time.
|
static <T,X extends java.lang.Throwable> |
forEach(java.util.stream.Stream<T> stream,
long x,
java.util.function.Consumer<? super T> consumerElement,
java.util.function.Consumer<? super java.lang.Throwable> consumerError,
java.lang.Runnable onComplete)
Perform a forEach operation over the Stream without closing it, capturing any elements and errors in the supplied consumers, but only consuming
the specified number of elements from the Stream, at this time.
|
static <T,R1,R> java.util.stream.Stream<R> |
forEach2(java.util.stream.Stream<? extends T> value1,
java.util.function.Function<? super T,? extends java.util.stream.Stream<R1>> value2,
java.util.function.BiFunction<? super T,? super R1,java.lang.Boolean> filterFunction,
java.util.function.BiFunction<? super T,? super R1,? extends R> yieldingFunction)
{@code
import static Streams.forEach2;
forEach(IntStream.range(1, 10).boxed(),
i -> Stream.range(i, 10),
(a,b) -> a>2 && b<10,
Tuple::tuple)
.forEach(System.out::println);
//(3, 3)
(3, 4)
(3, 5)
(3, 6)
(3, 7)
(3, 8)
(3, 9)
...
|
static <T,R1,R> java.util.stream.Stream<R> |
forEach2(java.util.stream.Stream<? extends T> value1,
java.util.function.Function<? super T,java.util.stream.Stream<R1>> value2,
java.util.function.BiFunction<? super T,? super R1,? extends R> yieldingFunction)
Perform a For Comprehension over a Stream, accepting an additonal generating function.
|
static <T1,T2,R1,R2,R> |
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> |
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> |
forEach4(java.util.stream.Stream<? extends T1> value1,
java.util.function.Function<? super T1,? extends java.util.stream.Stream<R1>> value2,
java.util.function.BiFunction<? super T1,? super R1,? extends java.util.stream.Stream<R2>> value3,
Fn3<? super T1,? super R1,? super R2,? extends java.util.stream.Stream<R3>> value4,
Fn4<? super T1,? super R1,? super R2,? super R3,? extends R> yieldingFunction)
Perform a For Comprehension over a Stream, accepting 3 generating functions.
|
static <T1,T2,T3,R1,R2,R3,R> |
forEach4(java.util.stream.Stream<? extends T1> value1,
java.util.function.Function<? super T1,? extends java.util.stream.Stream<R1>> value2,
java.util.function.BiFunction<? super T1,? super R1,? extends java.util.stream.Stream<R2>> value3,
Fn3<? super T1,? super R1,? super R2,? extends java.util.stream.Stream<R3>> value4,
Fn4<? super T1,? super R1,? super R2,? super R3,java.lang.Boolean> filterFunction,
Fn4<? super T1,? super R1,? super R2,? super R3,? extends R> yieldingFunction)
Perform a For Comprehension over a Stream, accepting 3 generating function.
|
static <T> java.util.stream.Stream<ListX<T>> |
grouped(java.util.stream.Stream<T> stream,
int groupSize)
Group elements in a Stream by size
|
static <T,C extends java.util.Collection<? super T>> |
grouped(java.util.stream.Stream<T> stream,
int groupSize,
java.util.function.Supplier<C> factory)
List<SetX<Integer>> list = Streams.grouped(Stream.of(1,2,3,4,5,6)
,3,()->SetX.empty())
.collect(CyclopsCollectors.toList());
assertThat(list.get(0),hasItems(1,2,3));
assertThat(list.get(1),hasItems(4,5,6));
|
static <T> java.util.stream.Stream<ListX<T>> |
groupedBySizeAndTime(java.util.stream.Stream<T> stream,
int size,
long time,
java.util.concurrent.TimeUnit t)
Group a Stream by size and time constraints
|
static <T,C extends java.util.Collection<? super T>> |
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>> |
groupedByTime(java.util.stream.Stream<T> stream,
long time,
java.util.concurrent.TimeUnit t,
java.util.function.Supplier<C> factory) |
static <T> java.util.stream.Stream<ListX<T>> |
groupedStatefullyUntil(java.util.stream.Stream<T> stream,
java.util.function.BiPredicate<ListX<? super T>,? super T> predicate)
Group data in a Stream using knowledge of the current batch and the next entry toNested determing grouping limits
|
static <T> java.util.stream.Stream<ListX<T>> |
groupedUntil(java.util.stream.Stream<T> stream,
java.util.function.Predicate<? super T> predicate)
Group a Stream until the supplied predicate holds
|
static <T> java.util.stream.Stream<ListX<T>> |
groupedWhile(java.util.stream.Stream<T> stream,
java.util.function.Predicate<? super T> predicate)
Group a Stream while the supplied predicate holds
|
static <T,C extends java.util.Collection<? super T>> |
groupedWhile(java.util.stream.Stream<T> stream,
java.util.function.Predicate<? super T> predicate,
java.util.function.Supplier<C> factory)
Group a Stream while the supplied predicate holds
|
static <T> HeadAndTail<T> |
headAndTail(java.util.stream.Stream<T> stream)
extract head and tail together
|
static <T> HotStream<T> |
hotStream(java.util.stream.Stream<T> stream,
java.util.concurrent.Executor exec) |
static <T> java.util.stream.Stream<T> |
insertAt(java.util.stream.Stream<T> stream,
int pos,
T... values)
Insert data into a reactiveStream at given position
|
static <T> java.util.stream.Stream<T> |
insertStreamAt(java.util.stream.Stream<T> stream1,
int pos,
java.util.stream.Stream<T> insert)
Insert a Stream into the middle of this reactiveStream at the specified position
|
static <T> java.util.stream.Stream<T> |
intersperse(java.util.stream.Stream<T> stream,
T value)
Returns a reactiveStream with a given value interspersed between any two values
of this reactiveStream.
|
static <T> java.util.stream.Stream<T> |
jitter(java.util.stream.Stream<T> stream,
long jitterInNanos)
Introduce a random jitter / time delay between the emission of elements
|
static <T> java.lang.String |
join(java.util.stream.Stream<T> stream) |
static <T> java.lang.String |
join(java.util.stream.Stream<T> stream,
java.lang.String sep) |
static <T> java.lang.String |
join(java.util.stream.Stream<T> stream,
java.lang.String sep,
java.lang.String start,
java.lang.String end) |
static <U> java.util.stream.Stream<U> |
limit(java.util.stream.Stream<U> stream,
long time,
java.util.concurrent.TimeUnit unit) |
static <U> java.util.stream.Stream<U> |
limitLast(java.util.stream.Stream<U> stream,
int num) |
static <U> java.util.stream.Stream<U> |
limitUntil(java.util.stream.Stream<U> stream,
java.util.function.Predicate<? super U> predicate)
Take elements from a Stream until the predicate holds
|
static <U> java.util.stream.Stream<U> |
limitWhile(java.util.stream.Stream<U> stream,
java.util.function.Predicate<? super U> predicate)
Take elements from a reactiveStream while the predicates hold
|
static <T,R> R |
mapReduce(java.util.stream.Stream<T> stream,
java.util.function.Function<? super T,? extends R> mapper,
Monoid<R> reducer)
Attempt toNested map this Monad toNested the same type as the supplied Monoid, using supplied function
Then use Monoid toNested reduce values
|
static <T,R> R |
mapReduce(java.util.stream.Stream<T> stream,
Reducer<R> reducer)
Attempt toNested map this Monad toNested the same type as the supplied Monoid (using mapToType on the monoid interface)
Then use Monoid toNested reduce values
|
static <T> java.util.Optional<T> |
max(java.util.stream.Stream<T> stream,
java.util.Comparator<? super T> comparator) |
static <T,C extends java.lang.Comparable<? super C>> |
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>> |
minBy(java.util.stream.Stream<T> stream,
java.util.function.Function<? super T,? extends C> f) |
static <T> java.util.stream.Stream<T> |
narrow(java.util.stream.Stream<? extends T> stream) |
static <T> boolean |
noneMatch(java.util.stream.Stream<T> stream,
java.util.function.Predicate<? super T> c)
assertThat(Streams.noneMatch(of(1,2,3,4,5),it-> it==5000),equalTo(true));
|
static <T,U> java.util.stream.Stream<U> |
ofType(java.util.stream.Stream<T> stream,
java.lang.Class<? extends U> type)
Keep only those elements in a reactiveStream that are of a given type.
|
static <T> java.util.stream.Stream<T> |
onePer(java.util.stream.Stream<T> stream,
long time,
java.util.concurrent.TimeUnit t)
emit one element per time period
|
static <T> com.aol.cyclops2.internal.stream.OneShotStreamX<T> |
oneShotStream(java.util.Spliterator<T> stream,
java.util.Optional<com.aol.cyclops2.internal.stream.spliterators.ReversableSpliterator> rev) |
static <T> ReactiveSeq<T> |
oneShotStream(java.util.stream.Stream<T> stream) |
static <T> ReactiveSeq<T> |
oneShotStreamI(java.lang.Iterable<T> iterable) |
static <T> java.util.stream.Stream<T> |
optionalToStream(java.util.Optional<T> optional)
Convert an Optional toNested a Stream
|
static <T> org.jooq.lambda.tuple.Tuple2<java.util.stream.Stream<T>,java.util.stream.Stream<T>> |
partition(java.util.stream.Stream<T> stream,
java.util.function.Predicate<? super T> splitter)
Partition a Stream into two one a per element basis, based on predicate's boolean value
|
static <T> PausableHotStream<T> |
pausableHotStream(java.util.stream.Stream<T> stream,
java.util.concurrent.Executor exec) |
static <T> java.util.stream.Stream<T> |
prepend(java.util.stream.Stream<T> stream,
T... values)
Prepend given values toNested the skip of the Stream
|
static <T> java.util.stream.Stream<T> |
prependStream(java.util.stream.Stream<T> stream1,
java.util.stream.Stream<T> prepend)
Prepend Stream toNested this Stream
|
static <T> HotStream<T> |
primedHotStream(java.util.stream.Stream<T> stream,
java.util.concurrent.Executor exec) |
static <T> PausableHotStream<T> |
primedPausableHotStream(java.util.stream.Stream<T> stream,
java.util.concurrent.Executor exec) |
static <T> org.jooq.lambda.tuple.Tuple4<java.util.stream.Stream<T>,java.util.stream.Stream<T>,java.util.stream.Stream<T>,java.util.stream.Stream<T>> |
quadruplicate(java.util.stream.Stream<T> stream)
Makes four copies of a Stream
Buffers intermediate values, leaders may change positions so a limit
can be safely applied toNested the leading reactiveStream.
|
static <T> org.jooq.lambda.tuple.Tuple4<java.util.stream.Stream<T>,java.util.stream.Stream<T>,java.util.stream.Stream<T>,java.util.stream.Stream<T>> |
quadruplicate(java.util.stream.Stream<T> stream,
java.util.function.Supplier<java.util.Deque<T>> bufferFactory)
Makes four copies of a Stream
Buffers intermediate values, leaders may change positions so a limit
can be safely applied toNested the leading reactiveStream.
|
static <T> ReactiveSeq<T> |
reactiveSeq(java.lang.Iterable<T> iterable) |
static <T> ReactiveSeq<T> |
reactiveSeq(org.jooq.lambda.Seq<T> stream) |
static <T> ReactiveSeq<T> |
reactiveSeq(java.util.Spliterator<? super T> stream,
java.util.Optional<com.aol.cyclops2.internal.stream.spliterators.ReversableSpliterator> rev) |
static <T> ReactiveSeq<T> |
reactiveSeq(java.util.stream.Stream<? super T> stream,
java.util.Optional<com.aol.cyclops2.internal.stream.spliterators.ReversableSpliterator> rev) |
static <T> ReactiveSeq<T> |
reactiveSeq(java.util.stream.Stream<T> stream) |
static <T,EX extends java.lang.Throwable> |
recover(java.util.stream.Stream<T> stream,
java.lang.Class<EX> type,
java.util.function.Function<EX,? extends T> fn) |
static <T> java.util.stream.Stream<T> |
recover(java.util.stream.Stream<T> stream,
java.util.function.Function<java.lang.Throwable,? extends T> fn) |
static <R> ListX<R> |
reduce(java.util.stream.Stream<R> stream,
java.lang.Iterable<? extends Monoid<R>> reducers)
Simultaneously reduce a reactiveStream with multiple reducers
|
static <R> ListX<R> |
reduce(java.util.stream.Stream<R> stream,
java.util.stream.Stream<? extends Monoid<R>> reducers)
Simultanously reduce a reactiveStream with multiple reducers
|
static <U> java.util.stream.Stream<U> |
reverse(java.util.stream.Stream<U> stream)
Reverse a Stream
|
static <U> java.util.stream.Stream<U> |
reversedStream(java.util.List<U> list)
Create a reversed Stream from a List
|
static <T> java.util.stream.Stream<T> |
scanLeft(java.util.stream.Stream<T> stream,
Monoid<T> monoid)
Scan left using supplied Monoid
|
static <U,T> java.util.stream.Stream<U> |
scanRight(java.util.stream.Stream<T> stream,
U identity,
java.util.function.BiFunction<? super T,? super U,? extends U> combiner) |
static <T> HotStream<T> |
schedule(java.util.stream.Stream<T> stream,
java.lang.String cron,
java.util.concurrent.ScheduledExecutorService ex)
Execute this Stream on a schedule
|
static <T> HotStream<T> |
scheduleFixedDelay(java.util.stream.Stream<T> stream,
long delay,
java.util.concurrent.ScheduledExecutorService ex)
Execute this Stream on a schedule
|
static <T> HotStream<T> |
scheduleFixedRate(java.util.stream.Stream<T> stream,
long rate,
java.util.concurrent.ScheduledExecutorService ex)
Execute this Stream on a schedule
|
static <T> Streamable<T> |
shuffle(java.util.stream.Stream<T> stream) |
static <U> java.util.stream.Stream<U> |
skip(java.util.stream.Stream<U> stream,
long time,
java.util.concurrent.TimeUnit unit) |
static <U> java.util.stream.Stream<U> |
skipLast(java.util.stream.Stream<U> stream,
int num) |
static <U> java.util.stream.Stream<U> |
skipUntil(java.util.stream.Stream<U> stream,
java.util.function.Predicate<? super U> predicate)
skip elements in Stream until Predicate holds true
|
static <U> java.util.stream.Stream<U> |
skipWhile(java.util.stream.Stream<U> stream,
java.util.function.Predicate<? super U> predicate)
skip elements in a Stream while Predicate holds true
|
static <T> java.util.stream.Stream<VectorX<T>> |
sliding(java.util.stream.Stream<T> stream,
int windowSize)
Create a sliding view over this Stream
|
static <T> java.util.stream.Stream<VectorX<T>> |
sliding(java.util.stream.Stream<T> stream,
int windowSize,
int increment)
Create a sliding view over this Stream
|
static <T> org.jooq.lambda.tuple.Tuple2<java.util.stream.Stream<T>,java.util.stream.Stream<T>> |
splitAt(java.util.stream.Stream<T> stream,
int where)
Split at supplied location
|
static <T> org.jooq.lambda.tuple.Tuple2<java.util.stream.Stream<T>,java.util.stream.Stream<T>> |
splitBy(java.util.stream.Stream<T> stream,
java.util.function.Predicate<T> splitter)
Split reactiveStream at point where predicate no longer holds
|
static <T> boolean |
startsWith(java.util.stream.Stream<T> stream,
java.lang.Iterable<T> iterable)
assertTrue(Streams.startsWith(Stream.of(1,2,3,4),Arrays.asList(1,2,3)));
|
static <T> boolean |
startsWith(java.util.stream.Stream<T> stream,
java.util.Iterator<T> iterator)
assertTrue(Streams.startsWith(Stream.of(1,2,3,4),Arrays.asList(1,2,3).iterator()))
|
static <T> boolean |
startsWith(java.util.stream.Stream<T> stream,
java.util.stream.Stream<T> stream2) |
static <U> java.util.stream.Stream<U> |
stream(java.lang.Iterable<U> it)
Create a reactiveStream from an iterable
|
static <U> java.util.stream.Stream<U> |
stream(java.util.Iterator<U> it)
Create a reactiveStream from an iterator
|
static <K,V> java.util.stream.Stream<java.util.Map.Entry<K,V>> |
stream(java.util.Map<K,V> it)
Create a reactiveStream from a map
|
static <U> java.util.stream.Stream<U> |
stream(java.util.Spliterator<U> it) |
static <T> java.util.concurrent.CompletableFuture<java.util.List<T>> |
streamToCompletableFuture(java.util.stream.Stream<T> stream)
Create a CompletableFuture containing a List materialized from a Stream
|
static <T> java.util.Optional<ListX<T>> |
streamToOptional(java.util.stream.Stream<T> stream)
Create an Optional containing a List materialized from a Stream
|
static <A> ListX<java.lang.Iterable<A>> |
toBufferingCopier(java.lang.Iterable<A> it,
int copies) |
static <A> ListX<java.lang.Iterable<A>> |
toBufferingCopier(java.lang.Iterable<A> it,
int copies,
java.util.function.Supplier<java.util.Deque<A>> bufferSupplier) |
static <A> ListX<java.util.Iterator<A>> |
toBufferingCopier(java.util.Iterator<A> iterator,
int copies) |
static <A> ListX<java.util.Iterator<A>> |
toBufferingCopier(java.util.Iterator<A> iterator,
int copies,
java.util.function.Supplier<java.util.Deque<A>> bufferSupplier) |
static <A> org.jooq.lambda.tuple.Tuple2<java.lang.Iterable<A>,java.lang.Iterable<A>> |
toBufferingDuplicator(java.lang.Iterable<A> it) |
static <A> org.jooq.lambda.tuple.Tuple2<java.lang.Iterable<A>,java.lang.Iterable<A>> |
toBufferingDuplicator(java.lang.Iterable<A> it,
java.util.function.Supplier<java.util.Deque<A>> bufferFactory) |
static <A> org.jooq.lambda.tuple.Tuple2<java.util.Iterator<A>,java.util.Iterator<A>> |
toBufferingDuplicator(java.util.Iterator<A> iterator) |
static <A> org.jooq.lambda.tuple.Tuple2<java.util.Iterator<A>,java.util.Iterator<A>> |
toBufferingDuplicator(java.util.Iterator<A> iterator,
long pos) |
static <A> org.jooq.lambda.tuple.Tuple2<java.util.Iterator<A>,java.util.Iterator<A>> |
toBufferingDuplicator(java.util.Iterator<A> iterator,
long pos,
java.util.function.Supplier<java.util.Deque<A>> bufferFactory) |
static <A> org.jooq.lambda.tuple.Tuple2<java.util.Iterator<A>,java.util.Iterator<A>> |
toBufferingDuplicator(java.util.Iterator<A> iterator,
java.util.function.Supplier<java.util.Deque<A>> bufferFactory) |
static <A> CollectionX<A> |
toConcurrentLazyCollection(java.util.Iterator<A> iterator) |
static <A> CollectionX<A> |
toConcurrentLazyCollection(java.util.stream.Stream<A> stream)
Lazily constructs a Collection from specified Stream.
|
static <T> Streamable<T> |
toConcurrentLazyStreamable(java.util.stream.Stream<T> stream) |
static <A> CollectionX<A> |
toLazyCollection(java.util.Iterator<A> iterator) |
static <A> CollectionX<A> |
toLazyCollection(java.util.stream.Stream<A> stream)
Projects an immutable collection of this reactiveStream.
|
static <T> Streamable<T> |
toLazyStreamable(java.util.stream.Stream<T> stream) |
static <T> java.util.List<T> |
toList(java.util.stream.Stream<T> stream) |
static <T> java.util.Set<T> |
toSet(java.util.stream.Stream<T> stream) |
static <T> Streamable<T> |
toStreamable(java.util.stream.Stream<T> stream) |
static <T> org.jooq.lambda.tuple.Tuple3<java.util.stream.Stream<T>,java.util.stream.Stream<T>,java.util.stream.Stream<T>> |
triplicate(java.util.stream.Stream<T> stream)
Triplicates a Stream
Buffers intermediate values, leaders may change positions so a limit
can be safely applied toNested the leading reactiveStream.
|
static <T> org.jooq.lambda.tuple.Tuple3<java.util.stream.Stream<T>,java.util.stream.Stream<T>,java.util.stream.Stream<T>> |
triplicate(java.util.stream.Stream<T> stream,
java.util.function.Supplier<java.util.Deque<T>> bufferFactory)
Triplicates a Stream
Buffers intermediate values, leaders may change positions so a limit
can be safely applied toNested the leading reactiveStream.
|
static <T> java.util.stream.Stream<Streamable<T>> |
window(java.util.stream.Stream<T> stream,
int windowSize,
int increment)
Create a sliding view over this Stream
|
static <T> java.util.stream.Stream<Streamable<T>> |
windowByTime(java.util.stream.Stream<T> stream,
long time,
java.util.concurrent.TimeUnit t) |
static <T> boolean |
xMatch(java.util.stream.Stream<T> stream,
int num,
java.util.function.Predicate<? super T> c)
Check that there are specified number of matches of predicate in the Stream
|
static <T> java.util.stream.Stream<T> |
xPer(java.util.stream.Stream<T> stream,
int x,
long time,
java.util.concurrent.TimeUnit t) |
static <T,S,R> java.util.stream.Stream<R> |
zipAnyM(java.util.stream.Stream<T> stream,
AnyM<Witness.stream,? extends S> second,
java.util.function.BiFunction<? super T,? super S,? extends R> zipper)
Generic zip function.
|
static <T,S,R> java.util.stream.Stream<R> |
zipSequence(java.util.stream.Stream<T> stream,
java.util.stream.Stream<? extends S> second,
java.util.function.BiFunction<? super T,? super S,? extends R> zipper)
Generic zip function.
|
static <T,S,R> java.util.stream.Stream<R> |
zipStream(java.util.stream.Stream<T> stream,
java.util.stream.BaseStream<? extends S,? extends java.util.stream.BaseStream<? extends S,?>> second,
java.util.function.BiFunction<? super T,? super S,? extends R> zipper)
Zip this Monad with a Stream
|
public static <T> ReactiveSeq<ReactiveSeq<T>> combinations(int size, java.lang.Object[] a)
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)
import static cyclops.companion.Streams.forEach4;
forEach4(IntStream.range(1,10).boxed(),
a-> Stream.iterate(a,i->i+1).limit(10),
(a,b) -> Stream.<Integer>of(a+b),
(a,b,c) -> Stream.<Integer>just(a+b+c),
Tuple::tuple)
value1
- top level Streamvalue2
- Nested Streamvalue3
- Nested Streamvalue4
- Nested StreamyieldingFunction
- Generates a result per combinationpublic 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)
import static com.aol.cyclops2.reactor.Streames.forEach4;
forEach4(IntStream.range(1,10).boxed(),
a-> Stream.iterate(a,i->i+1).limit(10),
(a,b) -> Stream.<Integer>just(a+b),
(a,b,c) -> Stream.<Integer>just(a+b+c),
(a,b,c,d) -> a+b+c+d <100,
Tuple::tuple);
value1
- top level Streamvalue2
- Nested Streamvalue3
- Nested Streamvalue4
- Nested StreamfilterFunction
- A filtering function, keeps values where the predicate holdsyieldingFunction
- Generates a result per combinationpublic 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)
import static Streams.forEach3;
forEach(IntStream.range(1,10).boxed(),
a-> Stream.iterate(a,i->i+1).limit(10),
(a,b) -> Stream.<Integer>of(a+b),
Tuple::tuple);
value1
- top level Streamvalue2
- Nested Streamvalue3
- Nested StreamyieldingFunction
- Generates a result per combinationpublic 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)
import static Streams.forEach;
forEach(IntStream.range(1,10).boxed(),
a-> Stream.iterate(a,i->i+1).limit(10),
(a,b) -> Stream.<Integer>of(a+b),
(a,b,c) ->a+b+c<10,
Tuple::tuple)
.listX();
value1
- top level Streamvalue2
- Nested publishervalue3
- Nested publisherfilterFunction
- A filtering function, keeps values where the predicate holdsyieldingFunction
- Generates a result per combinationpublic 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)
import static Streams.forEach2;
forEach(IntStream.range(1, 10).boxed(),
i -> Stream.range(i, 10), Tuple::tuple)
.forEach(System.out::println);
//(1, 1)
(1, 2)
(1, 3)
(1, 4)
...
value1
- top level Streamvalue2
- Nested publisheryieldingFunction
- Generates a result per combinationpublic static <T,R1,R> java.util.stream.Stream<R> forEach2(java.util.stream.Stream<? extends T> value1, java.util.function.Function<? super T,? extends java.util.stream.Stream<R1>> value2, java.util.function.BiFunction<? super T,? super R1,java.lang.Boolean> filterFunction, java.util.function.BiFunction<? super T,? super R1,? extends R> yieldingFunction)
import static Streams.forEach2;
forEach(IntStream.range(1, 10).boxed(),
i -> Stream.range(i, 10),
(a,b) -> a>2 && b<10,
Tuple::tuple)
.forEach(System.out::println);
//(3, 3)
(3, 4)
(3, 5)
(3, 6)
(3, 7)
(3, 8)
(3, 9)
...
value1
- top level Streamvalue2
- Nested publisherfilterFunction
- A filtering function, keeps values where the predicate holdsyieldingFunction
- Generates a result per combinationpublic static final <T> java.util.Optional<ListX<T>> streamToOptional(java.util.stream.Stream<T> stream)
Optional<ListX<Integer>> opt = Streams.streamToOptional(Stream.of(1,2,3));
//Optional[[1,2,3]]
stream
- To convert into an Optionalpublic static final <T> java.util.stream.Stream<T> optionalToStream(java.util.Optional<T> optional)
Stream<Integer> reactiveStream = Streams.optionalToStream(Optional.of(1));
//Stream[1]
Stream<Integer> empty = Streams.optionalToStream(Optional.empty());
//Stream[]
optional
- Optional toNested convert toNested a Streampublic static final <T> java.util.concurrent.CompletableFuture<java.util.List<T>> streamToCompletableFuture(java.util.stream.Stream<T> stream)
stream
- To convert into an Optionalpublic static final <T> java.util.stream.Stream<T> completableFutureToStream(java.util.concurrent.CompletableFuture<T> future)
future
- CompletableFuture toNested convertpublic static <T,X extends java.lang.Throwable> org.reactivestreams.Subscription forEach(java.util.stream.Stream<T> stream, long x, java.util.function.Consumer<? super T> consumerElement)
Stream
- - the Stream toNested consume data fromnumberOfElements
- To consume from the Stream at this timeconsumer
- To accept incoming events from the Streampublic static <T,X extends java.lang.Throwable> org.reactivestreams.Subscription forEach(java.util.stream.Stream<T> stream, long x, java.util.function.Consumer<? super T> consumerElement, java.util.function.Consumer<? super java.lang.Throwable> consumerError)
Stream
- - the Stream toNested consume data fromnumberOfElements
- To consume from the Stream at this timeconsumer
- To accept incoming elements from the StreamconsumerError
- To accept incoming processing errors from the StreamonComplete
- To run after an onComplete eventpublic static <T,X extends java.lang.Throwable> org.reactivestreams.Subscription forEach(java.util.stream.Stream<T> stream, long x, java.util.function.Consumer<? super T> consumerElement, java.util.function.Consumer<? super java.lang.Throwable> consumerError, java.lang.Runnable onComplete)
Stream
- - the Stream toNested consume data fromnumberOfElements
- To consume from the Stream at this timeconsumer
- To accept incoming elements from the StreamconsumerError
- To accept incoming processing errors from the StreamonComplete
- To run after an onComplete eventpublic static <T,X extends java.lang.Throwable> void forEach(java.util.stream.Stream<T> stream, java.util.function.Consumer<? super T> consumerElement, java.util.function.Consumer<? super java.lang.Throwable> consumerError)
Stream
- - the Stream toNested consume data fromconsumer
- To accept incoming elements from the StreamconsumerError
- To accept incoming processing errors from the Streampublic static <T,X extends java.lang.Throwable> void forEach(java.util.stream.Stream<T> stream, java.util.function.Consumer<? super T> consumerElement, java.util.function.Consumer<? super java.lang.Throwable> consumerError, java.lang.Runnable onComplete)
Stream
- - the Stream toNested consume data fromconsumer
- To accept incoming elements from the StreamconsumerError
- To accept incoming processing errors from the StreamonComplete
- To run after an onComplete eventpublic static <T> HotStream<T> schedule(java.util.stream.Stream<T> stream, java.lang.String cron, java.util.concurrent.ScheduledExecutorService ex)
//run at 8PM every night
Streams.schedule(Stream.generate(()->"next job:"+formatDate(new Date()))
.map(this::processJob)
,"0 20 * * *",Executors.newScheduledThreadPool(1)));
Connect toNested the Scheduled Stream
HotStream<Data> dataStream = Streams.schedule(Stream.generate(()->"next job:"+formatDate(new Date()))
.map(this::processJob)
,"0 20 * * *",Executors.newScheduledThreadPool(1)));
data.connect().forEach(this::logToDB);
stream
- the reactiveStream toNested schedule element processing oncron
- Expression that determines when each job will runex
- ScheduledExecutorServicepublic static <T> HotStream<T> scheduleFixedDelay(java.util.stream.Stream<T> stream, long delay, java.util.concurrent.ScheduledExecutorService ex)
//run every 60 seconds after last job completes
Streams.scheduleFixedDelay(Stream.generate(()->"next job:"+formatDate(new Date()))
.map(this::processJob)
,60_000,Executors.newScheduledThreadPool(1)));
Connect toNested the Scheduled Stream
HotStream<Data> dataStream = Streams.scheduleFixedDelay(Stream.generate(()->"next job:"+formatDate(new Date()))
.map(this::processJob)
,60_000,Executors.newScheduledThreadPool(1)));
data.connect().forEach(this::logToDB);
stream
- the reactiveStream toNested schedule element processing ondelay
- Between last element completes passing through the Stream until the next one startsex
- ScheduledExecutorServicepublic static <T> HotStream<T> scheduleFixedRate(java.util.stream.Stream<T> stream, long rate, java.util.concurrent.ScheduledExecutorService ex)
//run every 60 seconds
Streams.scheduleFixedRate(Stream.generate(()->"next job:"+formatDate(new Date()))
.map(this::processJob),
60_000,Executors.newScheduledThreadPool(1)));
Connect toNested the Scheduled Stream
HotStream<Data> dataStream = Streams.scheduleFixedRate(Stream.generate(()->"next job:"+formatDate(new Date()))
.map(this::processJob)
,60_000,Executors.newScheduledThreadPool(1)));
data.connect().forEach(this::logToDB);
stream
- the reactiveStream toNested schedule element processing onrate
- Time in millis between job runsex
- ScheduledExecutorServicepublic 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)
ReactiveSeq.of(1,2,3).splitAt(1)
//Stream[1], Stream[2,3]
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)
ReactiveSeq.of(1, 2, 3, 4, 5, 6).splitBy(i->i<4)
//Stream[1,2,3] Stream[4,5,6]
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)
ReactiveSeq.of(1, 2, 3, 4, 5, 6).partition(i -> i % 2 != 0)
//Stream[1,3,5], Stream[2,4,6]
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)
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));
public static final <T> org.jooq.lambda.tuple.Tuple2<java.util.stream.Stream<T>,java.util.stream.Stream<T>> duplicate(java.util.stream.Stream<T> stream, java.util.function.Supplier<java.util.Deque<T>> bufferFactory)
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));
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)
Tuple3<ReactiveSeq<Tuple3<T1,T2,T3>>,ReactiveSeq<Tuple3<T1,T2,T3>>,ReactiveSeq<Tuple3<T1,T2,T3>>> Tuple3 = sequence.triplicate();
public static final <T> org.jooq.lambda.tuple.Tuple3<java.util.stream.Stream<T>,java.util.stream.Stream<T>,java.util.stream.Stream<T>> triplicate(java.util.stream.Stream<T> stream, java.util.function.Supplier<java.util.Deque<T>> bufferFactory)
Tuple3<ReactiveSeq<Tuple3<T1,T2,T3>>,ReactiveSeq<Tuple3<T1,T2,T3>>,ReactiveSeq<Tuple3<T1,T2,T3>>> Tuple3 = sequence.triplicate();
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)
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();
public static final <T> org.jooq.lambda.tuple.Tuple4<java.util.stream.Stream<T>,java.util.stream.Stream<T>,java.util.stream.Stream<T>,java.util.stream.Stream<T>> quadruplicate(java.util.stream.Stream<T> stream, java.util.function.Supplier<java.util.Deque<T>> bufferFactory)
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();
public static final <T> java.util.stream.Stream<T> appendStream(java.util.stream.Stream<T> stream1, java.util.stream.Stream<T> append)
List<String> result = of(1,2,3).appendStream(of(100,200,300))
.map(it ->it+"!!")
.collect(CyclopsCollectors.toList());
assertThat(result,equalTo(Arrays.asList("1!!","2!!","3!!","100!!","200!!","300!!")));
stream
- toNested appendpublic static final <T> java.util.stream.Stream<T> prependStream(java.util.stream.Stream<T> stream1, java.util.stream.Stream<T> prepend)
List<String> result = of(1,2,3).prependStream(of(100,200,300))
.map(it ->it+"!!").collect(CyclopsCollectors.toList());
assertThat(result,equalTo(Arrays.asList("100!!","200!!","300!!","1!!","2!!","3!!")));
stream
- toNested Prependpublic static final <T> java.util.stream.Stream<T> append(java.util.stream.Stream<T> stream, T... values)
List<String> result = of(1,2,3).append(100,200,300)
.map(it ->it+"!!")
.collect(CyclopsCollectors.toList());
assertThat(result,equalTo(Arrays.asList("1!!","2!!","3!!","100!!","200!!","300!!")));
values
- toNested appendpublic static final <T> java.util.stream.Stream<T> prepend(java.util.stream.Stream<T> stream, T... values)
List<String> result = of(1,2,3).prepend(100,200,300)
.map(it ->it+"!!").collect(CyclopsCollectors.toList());
assertThat(result,equalTo(Arrays.asList("100!!","200!!","300!!","1!!","2!!","3!!")));
values
- toNested prependpublic static final <T> java.util.stream.Stream<T> insertAt(java.util.stream.Stream<T> stream, int pos, T... values)
List<String> result = of(1,2,3).insertAt(1,100,200,300)
.map(it ->it+"!!").collect(CyclopsCollectors.toList());
assertThat(result,equalTo(Arrays.asList("1!!","100!!","200!!","300!!","2!!","3!!")));
pos
- toNested insert data atvalues
- toNested insertpublic static final <T> java.util.stream.Stream<T> deleteBetween(java.util.stream.Stream<T> stream, int start, int end)
List<String> result = Streams.deleteBetween(Stream.of(1,2,3,4,5,6),2,4)
.map(it ->it+"!!")
.collect(CyclopsCollectors.toList());
assertThat(result,equalTo(Arrays.asList("1!!","2!!","5!!","6!!")));
start
- indexend
- indexpublic static final <T> java.util.stream.Stream<T> insertStreamAt(java.util.stream.Stream<T> stream1, int pos, java.util.stream.Stream<T> insert)
List<String> result = Streams.insertAtS(Stream.of(1,2,3),1,of(100,200,300))
.map(it ->it+"!!")
.collect(CyclopsCollectors.toList());
assertThat(result,equalTo(Arrays.asList("1!!","100!!","200!!","300!!","2!!","3!!")));
pos
- toNested insert Stream atstream
- toNested insertpublic static final <T> java.util.stream.Stream<T> cycle(java.util.stream.Stream<T> stream, Monoid<T> m, int times)
List<Integer> list = Streams.cycle(Stream.of(1,2,2),Reducers.toCountInt(),3)
.
.collect(CyclopsCollectors.toList());
//is asList(3,3,3);
m
- Monoid toNested be used in reductiontimes
- Number of times value should be repeatedpublic static final <T> HeadAndTail<T> headAndTail(java.util.stream.Stream<T> stream)
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"));
public static <U> java.util.stream.Stream<U> skipUntil(java.util.stream.Stream<U> stream, java.util.function.Predicate<? super U> predicate)
Streams.skipUntil(Stream.of(4,3,6,7),i->i==6).collect(CyclopsCollectors.toList())
// [6,7]
stream
- Stream toNested skip elements frompredicate
- toNested applypublic static <U> java.util.stream.Stream<U> skipLast(java.util.stream.Stream<U> stream, int num)
public static <U> java.util.stream.Stream<U> limitLast(java.util.stream.Stream<U> stream, int num)
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)
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)
public static <U> java.util.stream.Stream<U> skipWhile(java.util.stream.Stream<U> stream, java.util.function.Predicate<? super U> predicate)
Streams.skipWhile(Stream.of(4,3,6,7).sorted(),i->i<6).collect(CyclopsCollectors.toList())
// [6,7]
stream
- predicate
- public static <U> java.util.stream.Stream<U> limit(java.util.stream.Stream<U> stream, long time, java.util.concurrent.TimeUnit unit)
public static <U> java.util.stream.Stream<U> skip(java.util.stream.Stream<U> stream, long time, java.util.concurrent.TimeUnit unit)
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)
public static <T> java.lang.Iterable<java.lang.Iterable<T>> combineI(java.lang.Iterable<T> stream, java.util.function.BiPredicate<? super T,? super T> predicate, java.util.function.BinaryOperator<T> op)
public static <U> java.util.stream.Stream<U> limitWhile(java.util.stream.Stream<U> stream, java.util.function.Predicate<? super U> predicate)
Streams.limitWhile(Stream.of(4,3,6,7).sorted(),i->i<6).collect(CyclopsCollectors.toList());
//[4,3]
stream
- predicate
- public static <U> java.util.stream.Stream<U> limitUntil(java.util.stream.Stream<U> stream, java.util.function.Predicate<? super U> predicate)
Streams.limitUntil(Stream.of(4,3,6,7),i->i==6).collect(CyclopsCollectors.toList());
//[4,3]
stream
- predicate
- public static <U> java.util.stream.Stream<U> reverse(java.util.stream.Stream<U> stream)
assertThat(Streams.reverse(Stream.of(1,2,3)).collect(CyclopsCollectors.toList())
,equalTo(Arrays.asList(3,2,1)));
stream
- Stream toNested reversepublic static <U> java.util.stream.Stream<U> reversedStream(java.util.List<U> list)
Streams.reversedStream(asList(1,2,3))
.map(i->i*100)
.forEach(System.out::println);
assertThat(Streams.reversedStream(Arrays.asList(1,2,3)).collect(CyclopsCollectors.toList())
,equalTo(Arrays.asList(3,2,1)));
list
- List toNested create a reversed Stream frompublic static <U> java.util.stream.Stream<U> cycle(java.util.stream.Stream<U> s)
assertThat(Streams.cycle(Stream.of(1,2,3))
.limit(6)
.collect(CyclopsCollectors.toList()),
equalTo(Arrays.asList(1,2,3,1,2,3)));
s
- Stream toNested cyclepublic static <U> java.util.stream.Stream<U> cycle(Streamable<U> s)
s
- Streamable toNested cyclepublic static <U> java.util.stream.Stream<U> cycle(long times, Streamable<U> s)
assertThat(Streams.cycle(3,Streamable.of(1,2,2))
.collect(CyclopsCollectors.toList()),
equalTo(Arrays.asList(1,2,2,1,2,2,1,2,2)));
s
- Streamable toNested cyclepublic static <U> java.util.stream.Stream<U> stream(java.lang.Iterable<U> it)
assertThat(Streams.reactiveStream(Arrays.asList(1,2,3))
.collect(CyclopsCollectors.toList()),
equalTo(Arrays.asList(1,2,3)));
it
- Iterable toNested convert toNested a Streampublic static <U> java.util.stream.Stream<U> stream(java.util.Spliterator<U> it)
public static <U> java.util.stream.Stream<U> stream(java.util.Iterator<U> it)
assertThat(Streams.reactiveStream(Arrays.asList(1,2,3).iterator())
.collect(CyclopsCollectors.toList()),
equalTo(Arrays.asList(1,2,3)));
it
- Iterator toNested convert toNested a Streampublic static <U> java.util.stream.Stream<U> concat(java.lang.Object o, java.util.stream.Stream<U> stream)
o
- Object toNested concatstream
- Stream toNested concatpublic static final <K,V> java.util.stream.Stream<java.util.Map.Entry<K,V>> stream(java.util.Map<K,V> it)
Map<String,String> map = new HashMap<>();
map.put("hello","world");
assertThat(Streams.reactiveStream(map).collect(CyclopsCollectors.toList()),equalTo(Arrays.asList(new AbstractMap.SimpleEntry("hello","world"))));
it
- Iterator toNested convert toNested a Streampublic static final <T> T firstValue(java.util.stream.Stream<T> stream)
public static <R> ListX<R> reduce(java.util.stream.Stream<R> stream, java.lang.Iterable<? extends Monoid<R>> 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)));
stream
- Stream toNested reducereducers
- Reducers toNested reduce Streampublic static <R> ListX<R> reduce(java.util.stream.Stream<R> stream, java.util.stream.Stream<? extends Monoid<R>> 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!")));
stream
- Stream toNested reducereducers
- Reducers toNested reduce Streampublic static final <T> java.util.stream.Stream<T> cycleWhile(java.util.stream.Stream<T> stream, java.util.function.Predicate<? super T> predicate)
int count =0;
assertThat(Streams.cycleWhile(Stream.of(1,2,2)
,next -> count++<6 )
.collect(CyclopsCollectors.toList()),equalTo(Arrays.asList(1,2,2,1,2,2)));
predicate
- repeat while truepublic static final <T> java.util.stream.Stream<T> cycleUntil(java.util.stream.Stream<T> stream, java.util.function.Predicate<? super T> predicate)
count =0;
assertThat(Streams.cycleUntil(Stream.of(1,2,2,3)
,next -> count++>10 )
.collect(CyclopsCollectors.toList()),equalTo(Arrays.asList(1, 2, 2, 3, 1, 2, 2, 3, 1, 2, 2)));
predicate
- repeat while truepublic 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)
Stream<List<Integer>> zipped = Streams.zip(Stream.of(1,2,3)
,ReactiveSeq.of(2,3,4),
(a,b) -> Arrays.asList(a,b));
List<Integer> zip = zipped.collect(CyclopsCollectors.toList()).get(1);
assertThat(zip.get(0),equalTo(2));
assertThat(zip.get(1),equalTo(3));
second
- Monad toNested zip withzipper
- Zipping functionpublic 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)
Stream<List<Integer>> zipped = Streams.zip(Stream.of(1,2,3)
,fromEither5(Optional.of(2)),
(a,b) -> Arrays.asList(a,b));
List<Integer> zip = zipped.collect(CyclopsCollectors.toList()).get(0);
assertThat(zip.get(0),equalTo(1));
assertThat(zip.get(1),equalTo(2));
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)
Stream<List<Integer>> zipped = Streams.zipStream(Stream.of(1,2,3)
,Stream.of(2,3,4),
(a,b) -> Arrays.asList(a,b));
List<Integer> zip = zipped.collect(CyclopsCollectors.toList()).get(1);
assertThat(zip.get(0),equalTo(2));
assertThat(zip.get(1),equalTo(3));
second
- Stream toNested zip withzipper
- Zip funcitonpublic static final <T> java.util.stream.Stream<VectorX<T>> sliding(java.util.stream.Stream<T> stream, int windowSize, int increment)
List<List<Integer>> list = Streams.sliding(Stream.of(1,2,3,4,5,6)
,2,1)
.collect(CyclopsCollectors.toList());
assertThat(list.get(0),hasItems(1,2));
assertThat(list.get(1),hasItems(2,3));
windowSize
- Size of sliding windowpublic static final <T> java.util.stream.Stream<Streamable<T>> window(java.util.stream.Stream<T> stream, int windowSize, int increment)
List<List<Integer>> list = Streams.sliding(Stream.of(1,2,3,4,5,6)
,2,1)
.collect(CyclopsCollectors.toList());
assertThat(list.get(0),hasItems(1,2));
assertThat(list.get(1),hasItems(2,3));
windowSize
- Size of sliding windowpublic static final <T> java.util.stream.Stream<VectorX<T>> sliding(java.util.stream.Stream<T> stream, int windowSize)
List<List<Integer>> list = Streams.sliding(Stream.of(1,2,3,4,5,6)
,2)
.collect(CyclopsCollectors.toList());
assertThat(list.get(0),hasItems(1,2));
assertThat(list.get(1),hasItems(2,3));
stream
- Stream toNested create sliding view onwindowSize
- size of windowpublic static final <T> java.util.stream.Stream<ListX<T>> grouped(java.util.stream.Stream<T> stream, int groupSize)
List<List<Integer>> list = Streams.grouped(Stream.of(1,2,3,4,5,6)
,3)
.collect(CyclopsCollectors.toList());
assertThat(list.get(0),hasItems(1,2,3));
assertThat(list.get(1),hasItems(4,5,6));
stream
- Stream toNested groupgroupSize
- Size of each Grouppublic static final <T,C extends java.util.Collection<? super T>> java.util.stream.Stream<C> grouped(java.util.stream.Stream<T> stream, int groupSize, java.util.function.Supplier<C> factory)
List<SetX<Integer>> list = Streams.grouped(Stream.of(1,2,3,4,5,6)
,3,()->SetX.empty())
.collect(CyclopsCollectors.toList());
assertThat(list.get(0),hasItems(1,2,3));
assertThat(list.get(1),hasItems(4,5,6));
stream
- Stream toNested groupgroupSize
- Size of each Groupfactory
- Supplier for creating Collections for holding groupingpublic static final <T> Streamable<T> shuffle(java.util.stream.Stream<T> stream)
public static final <T> Streamable<T> toLazyStreamable(java.util.stream.Stream<T> stream)
public static final <T> Streamable<T> toConcurrentLazyStreamable(java.util.stream.Stream<T> stream)
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)
public static final <T> java.util.stream.Stream<T> scanLeft(java.util.stream.Stream<T> stream, Monoid<T> monoid)
assertEquals(asList("", "a", "ab", "abc"),
Streams.scanLeft(Stream.of("a", "b", "c"),Reducers.toString(""))
.collect(CyclopsCollectors.toList());
monoid
- public static <T> boolean xMatch(java.util.stream.Stream<T> stream, int num, java.util.function.Predicate<? super T> c)
assertTrue(Streams.xMatch(Stream.of(1,2,3,5,6,7),3, i->i>4));
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));
public static final <T> java.lang.String join(java.util.stream.Stream<T> stream)
public static final <T> java.lang.String join(java.util.stream.Stream<T> stream, java.lang.String sep)
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)
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)
public static final <T> java.util.Optional<T> min(java.util.stream.Stream<T> stream, java.util.Comparator<? super T> comparator)
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)
public static final <T> java.util.Optional<T> max(java.util.stream.Stream<T> stream, java.util.Comparator<? super T> comparator)
public static final <T,R> R mapReduce(java.util.stream.Stream<T> stream, Reducer<R> reducer)
reducer
- Monoid toNested reduce valuespublic static final <T,R> R mapReduce(java.util.stream.Stream<T> stream, java.util.function.Function<? super T,? extends R> mapper, Monoid<R> reducer)
mapper
- Function toNested map Monad typereducer
- Monoid toNested reduce valuespublic static final <T> T foldLeft(java.util.stream.Stream<T> stream, Monoid<T> reducer)
reducer
- Use supplied Monoid toNested reduce values starting via foldLeftpublic static final <T> T foldLeftMapToType(java.util.stream.Stream<T> stream, Reducer<T> reducer)
reducer
- Monoid toNested reduce valuespublic static final <T> T foldRight(java.util.stream.Stream<T> stream, Monoid<T> reducer)
reducer
- Use supplied Monoid toNested reduce values starting via foldRightpublic static final <T> T foldRightMapToType(java.util.stream.Stream<T> stream, Reducer<T> reducer)
reducer
- Monoid toNested reduce valuespublic static final <T> Streamable<T> toStreamable(java.util.stream.Stream<T> stream)
public static final <T> java.util.Set<T> toSet(java.util.stream.Stream<T> stream)
public static final <T> java.util.List<T> toList(java.util.stream.Stream<T> stream)
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)));
iterable
- public static final <T> boolean endsWith(java.util.stream.Stream<T> stream, java.lang.Iterable<T> iterable)
public static final <T> boolean startsWith(java.util.stream.Stream<T> stream, java.util.stream.Stream<T> stream2)
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()))
iterator
- public static <T> ReactiveSeq<T> oneShotStreamI(java.lang.Iterable<T> iterable)
public static <T> ReactiveSeq<T> oneShotStream(java.util.stream.Stream<T> stream)
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)
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)
public static final <T> ReactiveSeq<T> reactiveSeq(java.lang.Iterable<T> iterable)
public static final <T> ReactiveSeq<T> reactiveSeq(java.util.stream.Stream<T> stream)
public static final <T> ReactiveSeq<T> reactiveSeq(org.jooq.lambda.Seq<T> stream)
public static final <T> ReactiveSeq<T> reactiveSeq(java.util.Spliterator<? super T> stream, java.util.Optional<com.aol.cyclops2.internal.stream.spliterators.ReversableSpliterator> rev)
public static <T> java.util.stream.Stream<T> intersperse(java.util.stream.Stream<T> stream, T value)
assertThat(Arrays.asList(1, 0, 2, 0, 3, 0, 4),
equalTo( Streams.intersperse(Stream.of(1, 2, 3, 4),0));
public static <T,U> java.util.stream.Stream<U> ofType(java.util.stream.Stream<T> stream, java.lang.Class<? extends U> type)
public static <T,U> java.util.stream.Stream<U> cast(java.util.stream.Stream<T> stream, java.lang.Class<? extends U> type)
ClassCastException
.
Streams.cast(Stream.of(1, "a", 2, "b", 3),Integer.class)
// throws ClassCastException
public static final <T> java.util.stream.Stream<T> narrow(java.util.stream.Stream<? extends T> stream)
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)
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)
assertThat(Streams.flatMapCollection(Stream.of(20),i->Arrays.asList(1,2,i))
.collect(CyclopsCollectors.toList()),
equalTo(Arrays.asList(1,2,20)));
public static final <T,R> java.util.stream.Stream<R> flatMapStream(java.util.stream.Stream<T> stream, java.util.function.Function<? super T,? extends java.util.stream.BaseStream<? extends R,?>> fn)
assertThat(Streams.flatMapStream(Stream.of(1,2,3),
i->Stream.of(i)).collect(CyclopsCollectors.toList()),
equalTo(Arrays.asList(1,2,3)));
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)
assertThat(Streams.flatMapOptional(Stream.of(1,2,3,null),
Optional::ofNullable)
.collect(CyclopsCollectors.toList()),
equalTo(Arrays.asList(1,2,3)));
public static final <T> java.util.stream.Stream<T> flatten(java.util.stream.Stream<java.util.stream.Stream<T>> stream)
public static final <T,R> java.util.stream.Stream<R> flatMapCompletableFuture(java.util.stream.Stream<T> stream, java.util.function.Function<? super T,java.util.concurrent.CompletableFuture<? extends R>> fn)
assertThat(Streams.flatMapCompletableFuture(Stream.of(1,2,3),
i->CompletableFuture.completedFuture(i+2))
.collect(CyclopsCollectors.toList()),
equalTo(Arrays.asList(3,4,5)));
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)
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')));
fn
- 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)
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")));
fn
- 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)
List<String> result = Streams.liftAndBindURL(Stream.of("input.file")
,getClass().getClassLoader()::getResource)
.collect(CyclopsCollectors.toList();
assertThat(result,equalTo(Arrays.asList("hello","world")));
fn
- 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)
Listresult = Streams.liftAndBindBufferedReader(Stream.of("input.file") .map(getClass().getClassLoader()::getResourceAsStream) .map(InputStreamReader::new) ,BufferedReader::new) .collect(CyclopsCollectors.toList(); assertThat(result,equalTo(Arrays.asList("hello","world")));
fn
- public static final <A> org.jooq.lambda.tuple.Tuple2<java.lang.Iterable<A>,java.lang.Iterable<A>> toBufferingDuplicator(java.lang.Iterable<A> it, java.util.function.Supplier<java.util.Deque<A>> bufferFactory)
public static final <A> org.jooq.lambda.tuple.Tuple2<java.lang.Iterable<A>,java.lang.Iterable<A>> toBufferingDuplicator(java.lang.Iterable<A> it)
public static final <A> org.jooq.lambda.tuple.Tuple2<java.util.Iterator<A>,java.util.Iterator<A>> toBufferingDuplicator(java.util.Iterator<A> iterator)
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)
public static final <A> org.jooq.lambda.tuple.Tuple2<java.util.Iterator<A>,java.util.Iterator<A>> toBufferingDuplicator(java.util.Iterator<A> iterator, java.util.function.Supplier<java.util.Deque<A>> bufferFactory)
public static final <A> org.jooq.lambda.tuple.Tuple2<java.util.Iterator<A>,java.util.Iterator<A>> toBufferingDuplicator(java.util.Iterator<A> iterator, long pos, java.util.function.Supplier<java.util.Deque<A>> bufferFactory)
public static final <A> ListX<java.lang.Iterable<A>> toBufferingCopier(java.lang.Iterable<A> it, int copies)
public static final <A> ListX<java.lang.Iterable<A>> toBufferingCopier(java.lang.Iterable<A> it, int copies, java.util.function.Supplier<java.util.Deque<A>> bufferSupplier)
public static final <A> ListX<java.util.Iterator<A>> toBufferingCopier(java.util.Iterator<A> iterator, int copies)
public static final <A> ListX<java.util.Iterator<A>> toBufferingCopier(java.util.Iterator<A> iterator, int copies, java.util.function.Supplier<java.util.Deque<A>> bufferSupplier)
public static final <A> CollectionX<A> toLazyCollection(java.util.stream.Stream<A> stream)
public static final <A> CollectionX<A> toLazyCollection(java.util.Iterator<A> iterator)
public static final <A> CollectionX<A> toConcurrentLazyCollection(java.util.stream.Stream<A> stream)
stream
- public static final <A> CollectionX<A> toConcurrentLazyCollection(java.util.Iterator<A> iterator)
public static final <T> java.util.stream.Stream<Streamable<T>> windowByTime(java.util.stream.Stream<T> stream, long time, java.util.concurrent.TimeUnit t)
public static final <T> java.util.stream.Stream<ListX<T>> groupedByTime(java.util.stream.Stream<T> stream, long time, java.util.concurrent.TimeUnit t)
@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)
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)
@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)
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)
stream
- Stream toNested grouppredicate
- Predicate toNested determine groupingReactiveSeq.groupedStatefullyUntil(BiPredicate)
public static final <T> java.util.stream.Stream<ListX<T>> groupedWhile(java.util.stream.Stream<T> stream, java.util.function.Predicate<? super T> predicate)
stream
- Stream toNested grouppredicate
- Predicate toNested determine groupingReactiveSeq.groupedWhile(Predicate)
@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)
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)
stream
- Stream toNested grouppredicate
- Predicate toNested determine groupingfactory
- Supplier toNested create collection for groupingsReactiveSeq.groupedWhile(Predicate, Supplier)
@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)
public static final <T> java.util.stream.Stream<ListX<T>> groupedUntil(java.util.stream.Stream<T> stream, java.util.function.Predicate<? super T> predicate)
stream
- Stream toNested grouppredicate
- Predicate toNested determine groupingReactiveSeq.groupedUntil(Predicate)
@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)
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)
stream
- Stream toNested groupsize
- Max group sizetime
- Max group timet
- Time unit for max group timeReactiveSeq.groupedBySizeAndTime(int, long, TimeUnit)
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)
stream
- Stream toNested groupsize
- Max group sizetime
- Max group timet
- Time unit for max group timefactory
- Supplier toNested create collection for groupingsReactiveSeq.groupedBySizeAndTime(int, long, TimeUnit, Supplier)
public static final <T> java.util.stream.Stream<T> debounce(java.util.stream.Stream<T> stream, long time, java.util.concurrent.TimeUnit t)
stream
- Stream toNested debouncetime
- Time toNested apply debouncing overt
- Time unit for debounce periodReactiveSeq.debounce(long, TimeUnit)
public static final <T> java.util.stream.Stream<T> onePer(java.util.stream.Stream<T> stream, long time, java.util.concurrent.TimeUnit t)
stream
- Stream toNested emit one element per time period fromtime
- Time periodt
- Time PureReactiveSeq.onePer(long, TimeUnit)
public static final <T> java.util.stream.Stream<T> jitter(java.util.stream.Stream<T> stream, long jitterInNanos)
stream
- Stream toNested introduce jitter toNestedjitterInNanos
- Max jitter period - random number less than this is used for each jitterReactiveSeq.jitter(long)
public static final <T> java.util.stream.Stream<T> fixedDelay(java.util.stream.Stream<T> stream, long time, java.util.concurrent.TimeUnit unit)
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)
public static final <T> HotStream<T> hotStream(java.util.stream.Stream<T> stream, java.util.concurrent.Executor exec)
public static final <T> HotStream<T> primedHotStream(java.util.stream.Stream<T> stream, java.util.concurrent.Executor exec)
public static final <T> PausableHotStream<T> pausableHotStream(java.util.stream.Stream<T> stream, java.util.concurrent.Executor exec)
public static final <T> PausableHotStream<T> primedPausableHotStream(java.util.stream.Stream<T> stream, java.util.concurrent.Executor exec)