public class SequenceMImpl<T>
extends java.lang.Object
implements com.aol.cyclops.sequence.Unwrapable, com.aol.cyclops.sequence.SequenceM<T>, java.lang.Iterable<T>
| Constructor and Description |
|---|
SequenceMImpl(java.util.stream.Stream<T> stream) |
SequenceMImpl(java.util.stream.Stream<T> stream,
com.aol.cyclops.sequence.spliterators.ReversableSpliterator rev) |
| Modifier and Type | Method and Description |
|---|---|
boolean |
allMatch(java.util.function.Predicate<? super T> c)
True if predicate matches all elements when Monad converted to a Stream
|
com.aol.cyclops.monad.AnyM<T> |
anyM() |
boolean |
anyMatch(java.util.function.Predicate<? super T> c)
True if a single element matches when Monad converted to a Stream
|
com.aol.cyclops.sequence.SequenceM<T> |
append(T... values)
Append values to the end of this SequenceM
|
com.aol.cyclops.sequence.SequenceM<T> |
appendStream(java.util.stream.Stream<T> stream)
Append Stream to this SequenceM
|
com.aol.cyclops.sequence.SequenceM<java.util.List<T>> |
batchBySize(int size) |
<C extends java.util.Collection<T>> |
batchBySize(int size,
java.util.function.Supplier<C> factory) |
com.aol.cyclops.sequence.SequenceM<java.util.List<T>> |
batchBySizeAndTime(int size,
long time,
java.util.concurrent.TimeUnit t) |
<C extends java.util.Collection<? super T>> |
batchBySizeAndTime(int size,
long time,
java.util.concurrent.TimeUnit unit,
java.util.function.Supplier<C> factory) |
com.aol.cyclops.sequence.SequenceM<java.util.List<T>> |
batchByTime(long time,
java.util.concurrent.TimeUnit t) |
<C extends java.util.Collection<T>> |
batchByTime(long time,
java.util.concurrent.TimeUnit unit,
java.util.function.Supplier<C> factory) |
com.aol.cyclops.sequence.SequenceM<java.util.List<T>> |
batchUntil(java.util.function.Predicate<? super T> predicate) |
<C extends java.util.Collection<? super T>> |
batchUntil(java.util.function.Predicate<? super T> predicate,
java.util.function.Supplier<C> factory) |
com.aol.cyclops.sequence.SequenceM<java.util.List<T>> |
batchWhile(java.util.function.Predicate<? super T> predicate) |
<C extends java.util.Collection<? super T>> |
batchWhile(java.util.function.Predicate<? super T> predicate,
java.util.function.Supplier<C> factory) |
<U> com.aol.cyclops.sequence.SequenceM<U> |
cast(java.lang.Class<U> type)
Cast all elements in a stream to a given type, possibly throwing a
ClassCastException. |
void |
close() |
<R,A> R |
collect(java.util.stream.Collector<? super T,A,R> collector)
Mutable reduction / collection over this Monad converted to a Stream
|
java.util.List |
collect(java.util.stream.Stream<java.util.stream.Collector> collectors)
Apply multiple collectors Simulataneously to this Monad
|
<R> R |
collect(java.util.function.Supplier<R> supplier,
java.util.function.BiConsumer<R,? super T> accumulator,
java.util.function.BiConsumer<R,R> combiner) |
<R> java.util.List<R> |
collectIterable(java.lang.Iterable<java.util.stream.Collector> collectors)
Apply multiple Collectors, simultaneously to a Stream
|
java.util.List |
collectStream(java.util.stream.Stream<java.util.stream.Collector> collectors) |
com.aol.cyclops.sequence.SequenceM<T> |
concat(java.util.stream.Stream<T> other) |
com.aol.cyclops.sequence.SequenceM<T> |
concat(T... other) |
com.aol.cyclops.sequence.SequenceM<T> |
concat(T other) |
long |
count() |
<U> com.aol.cyclops.sequence.SequenceM<org.jooq.lambda.tuple.Tuple2<T,U>> |
crossJoin(java.util.stream.Stream<U> other) |
com.aol.cyclops.sequence.SequenceM<T> |
cycle()
Convert to a Stream with the values infinitely cycled
|
<R> com.aol.cyclops.sequence.SequenceM<R> |
cycle(java.lang.Class<R> monadC,
int times)
Convert to a Stream, repeating the resulting structure specified times
and lifting all values to the specified Monad type
|
com.aol.cyclops.sequence.SequenceM<T> |
cycle(int times)
Convert to a Stream with the values repeated specified times
|
com.aol.cyclops.sequence.SequenceM<T> |
cycle(com.aol.cyclops.sequence.Monoid<T> m,
int times)
Convert to a Stream with the result of a reduction operation repeated
specified times
|
com.aol.cyclops.sequence.SequenceM<T> |
cycleUntil(java.util.function.Predicate<? super T> predicate)
Repeat in a Stream until specified predicate holds
|
com.aol.cyclops.sequence.SequenceM<T> |
cycleWhile(java.util.function.Predicate<? super T> predicate)
Repeat in a Stream while specified predicate holds
|
com.aol.cyclops.sequence.SequenceM<T> |
debounce(long time,
java.util.concurrent.TimeUnit t) |
com.aol.cyclops.sequence.SequenceM<T> |
deleteBetween(int start,
int end)
Delete elements between given indexes in a Stream
|
com.aol.cyclops.sequence.SequenceM<T> |
distinct() |
<U> com.aol.cyclops.sequence.SequenceM<T> |
distinct(java.util.function.Function<? super T,? extends U> keyExtractor) |
org.jooq.lambda.tuple.Tuple2<com.aol.cyclops.sequence.SequenceM<T>,com.aol.cyclops.sequence.SequenceM<T>> |
duplicateSequence()
Duplicate a Stream, buffers intermediate values, leaders may change positions so a limit
can be safely applied to the leading stream.
|
boolean |
endsWith(java.lang.Iterable<T> iterable) |
boolean |
endsWith(java.util.stream.Stream<T> iterable) |
com.aol.cyclops.sequence.SequenceM<T> |
filter(java.util.function.Predicate<? super T> fn) |
java.util.Optional<T> |
findAny() |
java.util.Optional<T> |
findFirst() |
T |
firstValue() |
com.aol.cyclops.sequence.SequenceM<T> |
fixedDelay(long l,
java.util.concurrent.TimeUnit unit) |
<R> com.aol.cyclops.sequence.SequenceM<R> |
flatMap(java.util.function.Function<? super T,? extends java.util.stream.Stream<? extends R>> fn)
flatMap operation
|
<R> com.aol.cyclops.sequence.SequenceM<R> |
flatMapAnyM(java.util.function.Function<? super T,com.aol.cyclops.monad.AnyM<? extends R>> fn)
Allows flatMap return type to be any Monad type
|
com.aol.cyclops.sequence.SequenceM<java.lang.String> |
flatMapBufferedReader(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
|
com.aol.cyclops.sequence.SequenceM<java.lang.Character> |
flatMapCharSequence(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.
|
<R> com.aol.cyclops.sequence.SequenceM<R> |
flatMapCollection(java.util.function.Function<? super T,java.util.Collection<? extends R>> fn)
Convenience method & performance optimisation
flatMapping to a Stream will result in the Stream being converted to a List, if the host Monad
type is not a Stream.
|
<R> com.aol.cyclops.sequence.SequenceM<R> |
flatMapCompletableFuture(java.util.function.Function<? super T,java.util.concurrent.CompletableFuture<? extends R>> fn)
flatMap to CompletableFuture - will block until Future complete, although (for non-blocking behaviour use AnyM
wrapping CompletableFuture and flatMap to Stream there)
|
com.aol.cyclops.sequence.SequenceM<java.lang.String> |
flatMapFile(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.
|
<R> com.aol.cyclops.sequence.SequenceM<R> |
flatMapOptional(java.util.function.Function<? super T,java.util.Optional<? extends R>> fn)
flatMap to optional - will result in null values being removed
|
<R> com.aol.cyclops.sequence.SequenceM<R> |
flatMapStream(java.util.function.Function<? super T,java.util.stream.BaseStream<? extends R,?>> fn)
flatMap operation
|
java.util.stream.DoubleStream |
flatMapToDouble(java.util.function.Function<? super T,? extends java.util.stream.DoubleStream> mapper) |
java.util.stream.IntStream |
flatMapToInt(java.util.function.Function<? super T,? extends java.util.stream.IntStream> mapper) |
java.util.stream.LongStream |
flatMapToLong(java.util.function.Function<? super T,? extends java.util.stream.LongStream> mapper) |
com.aol.cyclops.sequence.SequenceM<java.lang.String> |
flatMapURL(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
|
<T1> com.aol.cyclops.sequence.SequenceM<T1> |
flatten()
join / flatten one level of a nested hierarchy
|
T |
foldLeft(com.aol.cyclops.sequence.Monoid<T> reducer) |
T |
foldLeft(T identity,
java.util.function.BinaryOperator<T> accumulator)
foldLeft : immutable reduction from left to right
|
<T> T |
foldLeftMapToType(com.aol.cyclops.sequence.Monoid<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
|
T |
foldRight(com.aol.cyclops.sequence.Monoid<T> reducer) |
T |
foldRight(T identity,
java.util.function.BinaryOperator<T> accumulator) |
<U> U |
foldRight(U seed,
java.util.function.BiFunction<? super T,U,U> function)
Immutable reduction from right to left
|
<T> T |
foldRightMapToType(com.aol.cyclops.sequence.Monoid<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
|
void |
forEach(java.util.function.Consumer<? super T> action) |
<R1,R> com.aol.cyclops.sequence.SequenceM<R> |
forEach2(java.util.function.Function<? super T,? extends java.util.stream.BaseStream<R1,?>> stream1,
java.util.function.Function<? super T,java.util.function.Function<? super R1,? extends R>> yieldingFunction)
Perform a two level nested internal iteration over this Stream and the supplied stream
|
<R1,R> com.aol.cyclops.sequence.SequenceM<R> |
forEach2(java.util.function.Function<? super T,? extends java.util.stream.BaseStream<R1,?>> stream1,
java.util.function.Function<? super T,java.util.function.Function<? super R1,java.lang.Boolean>> filterFunction,
java.util.function.Function<? super T,java.util.function.Function<? super R1,? extends R>> yieldingFunction)
Perform a two level nested internal iteration over this Stream and the supplied stream
|
<R1,R2,R> com.aol.cyclops.sequence.SequenceM<R> |
forEach3(java.util.function.Function<? super T,? extends java.util.stream.BaseStream<R1,?>> stream1,
java.util.function.Function<? super T,java.util.function.Function<? super R1,? extends java.util.stream.BaseStream<R2,?>>> stream2,
java.util.function.Function<? super T,java.util.function.Function<? super R1,java.util.function.Function<? super R2,? extends R>>> yieldingFunction)
Perform a three level nested internal iteration over this Stream and the supplied streams
|
<R1,R2,R> com.aol.cyclops.sequence.SequenceM<R> |
forEach3(java.util.function.Function<? super T,? extends java.util.stream.BaseStream<R1,?>> stream1,
java.util.function.Function<? super T,java.util.function.Function<? super R1,? extends java.util.stream.BaseStream<R2,?>>> stream2,
java.util.function.Function<? super T,java.util.function.Function<? super R1,java.util.function.Function<? super R2,java.lang.Boolean>>> filterFunction,
java.util.function.Function<? super T,java.util.function.Function<? super R1,java.util.function.Function<? super R2,? extends R>>> yieldingFunction)
Perform a three level nested internal iteration over this Stream and the supplied streams
|
<X extends java.lang.Throwable> |
forEachEvent(java.util.function.Consumer<? super T> consumerElement,
java.util.function.Consumer<? super java.lang.Throwable> consumerError,
java.lang.Runnable onComplete) |
void |
forEachOrdered(java.util.function.Consumer<? super T> action) |
<X extends java.lang.Throwable> |
forEachWithError(java.util.function.Consumer<? super T> consumerElement,
java.util.function.Consumer<? super java.lang.Throwable> consumerError) |
<X extends java.lang.Throwable> |
forEachX(long numberOfElements,
java.util.function.Consumer<? super T> consumer) |
<X extends java.lang.Throwable> |
forEachXEvents(long numberOfElements,
java.util.function.Consumer<? super T> consumer,
java.util.function.Consumer<? super java.lang.Throwable> consumerError,
java.lang.Runnable onComplete) |
<X extends java.lang.Throwable> |
forEachXWithError(long numberOfElements,
java.util.function.Consumer<? super T> consumer,
java.util.function.Consumer<? super java.lang.Throwable> consumerError) |
com.aol.cyclops.sequence.future.FutureOperations<T> |
futureOperations(java.util.concurrent.Executor exec) |
<K> java.util.Map<K,java.util.List<T>> |
groupBy(java.util.function.Function<? super T,? extends K> classifier)
Use classifier function to group elements in this Sequence into a Map
|
com.aol.cyclops.sequence.SequenceM<java.util.List<T>> |
grouped(int groupSize)
Group elements in a Stream
|
com.aol.cyclops.sequence.HeadAndTail<T> |
headAndTail()
extract head and tail together, where head is expected to be present
|
java.util.Optional<com.aol.cyclops.sequence.HeadAndTail<T>> |
headAndTailOptional()
extract head and tail together, where no head or tail may be present
|
com.aol.cyclops.sequence.HotStream<T> |
hotStream(java.util.concurrent.Executor e) |
<U> com.aol.cyclops.sequence.SequenceM<org.jooq.lambda.tuple.Tuple2<T,U>> |
innerJoin(java.util.stream.Stream<U> other,
java.util.function.BiPredicate<T,U> predicate) |
com.aol.cyclops.sequence.SequenceM<T> |
insertAt(int pos,
T... values)
Insert data into a stream at given position
|
com.aol.cyclops.sequence.SequenceM<T> |
insertStreamAt(int pos,
java.util.stream.Stream<T> stream)
Insert a Stream into the middle of this stream at the specified position
|
com.aol.cyclops.sequence.SequenceM<T> |
intersperse(T value)
Returns a stream with a given value interspersed between any two values
of this stream.
|
boolean |
isParallel() |
java.util.Iterator<T> |
iterator() |
com.aol.cyclops.sequence.SequenceM<T> |
jitter(long l) |
java.lang.String |
join()
assertEquals("123".length(),of(1, 2, 3).join().length());
|
java.lang.String |
join(java.lang.String sep)
assertEquals("1, 2, 3".length(), of(1, 2, 3).join(", ").length());
|
java.lang.String |
join(java.lang.String sep,
java.lang.String start,
java.lang.String end)
assertEquals("^1|2|3$".length(), of(1, 2, 3).join("|", "^", "$").length());
|
<U> com.aol.cyclops.sequence.SequenceM<org.jooq.lambda.tuple.Tuple2<T,U>> |
leftOuterJoin(java.util.stream.Stream<U> other,
java.util.function.BiPredicate<T,U> predicate) |
com.aol.cyclops.sequence.SequenceM<T> |
limit(long num)
assertThat(anyM(Stream.of(4,3,6,7)).asSequence().limit(2).toList(),equalTo(Arrays.asList(4,3))); |
com.aol.cyclops.sequence.SequenceM<T> |
limit(long time,
java.util.concurrent.TimeUnit unit) |
com.aol.cyclops.sequence.SequenceM<T> |
limitLast(int num) |
com.aol.cyclops.sequence.SequenceM<T> |
limitUntil(java.util.function.Predicate<? super T> p)
assertThat(anyM(Stream.of(4,3,6,7)).limitUntil(i->i==6).toList(),equalTo(Arrays.asList(4,3))); |
com.aol.cyclops.sequence.SequenceM<T> |
limitWhile(java.util.function.Predicate<? super T> p)
assertThat(anyM(Stream.of(4,3,6,7)).asSequence().sorted().limitWhile(i->i<6).toList(),equalTo(Arrays.asList(3,4))); |
<R> com.aol.cyclops.sequence.SequenceM<R> |
map(java.util.function.Function<? super T,? extends R> fn) |
<R> R |
mapReduce(java.util.function.Function<? super T,? extends R> mapper,
com.aol.cyclops.sequence.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
|
<R> R |
mapReduce(com.aol.cyclops.sequence.Monoid<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
|
java.util.stream.DoubleStream |
mapToDouble(java.util.function.ToDoubleFunction<? super T> mapper) |
java.util.stream.IntStream |
mapToInt(java.util.function.ToIntFunction<? super T> mapper) |
java.util.stream.LongStream |
mapToLong(java.util.function.ToLongFunction<? super T> mapper) |
java.util.Optional<T> |
max(java.util.Comparator<? super T> comparator) |
<C extends java.lang.Comparable<C>> |
maxBy(java.util.function.Function<T,C> f)
Extract the maximum as determined by the supplied function
|
java.util.Optional<T> |
min(java.util.Comparator<? super T> comparator) |
<U extends java.lang.Comparable<U>> |
minBy(java.util.function.Function<T,U> function)
Extract the minimum as determined by supplied function
|
boolean |
noneMatch(java.util.function.Predicate<? super T> c) |
<U> com.aol.cyclops.sequence.SequenceM<U> |
ofType(java.lang.Class<U> type)
Keep only those elements in a stream that are of a given type.
|
com.aol.cyclops.sequence.SequenceM<T> |
onClose(java.lang.Runnable closeHandler) |
com.aol.cyclops.sequence.SequenceM<T> |
onEmpty(T value) |
com.aol.cyclops.sequence.SequenceM<T> |
onEmptyGet(java.util.function.Supplier<T> supplier) |
<X extends java.lang.Throwable> |
onEmptyThrow(java.util.function.Supplier<X> supplier) |
com.aol.cyclops.sequence.SequenceM<T> |
onePer(long time,
java.util.concurrent.TimeUnit t) |
com.aol.cyclops.sequence.SequenceM<T> |
parallel() |
org.jooq.lambda.tuple.Tuple2<com.aol.cyclops.sequence.SequenceM<T>,com.aol.cyclops.sequence.SequenceM<T>> |
partitionSequence(java.util.function.Predicate<T> splitter)
Partition a Stream into two one a per element basis, based on predicate's boolean value
|
com.aol.cyclops.sequence.SequenceM<T> |
peek(java.util.function.Consumer<? super T> c) |
com.aol.cyclops.sequence.SequenceM<T> |
prepend(T... values)
Prepend given values to the start of the Stream
|
com.aol.cyclops.sequence.SequenceM<T> |
prependStream(java.util.stream.Stream<T> stream)
Prepend Stream to this SequenceM
|
org.jooq.lambda.tuple.Tuple4<com.aol.cyclops.sequence.SequenceM<T>,com.aol.cyclops.sequence.SequenceM<T>,com.aol.cyclops.sequence.SequenceM<T>,com.aol.cyclops.sequence.SequenceM<T>> |
quadruplicate()
Makes four copies of a Stream
Buffers intermediate values, leaders may change positions so a limit
can be safely applied to the leading stream.
|
<EX extends java.lang.Throwable> |
recover(java.lang.Class<EX> exceptionClass,
java.util.function.Function<EX,? extends T> fn) |
com.aol.cyclops.sequence.SequenceM<T> |
recover(java.util.function.Function<java.lang.Throwable,? extends T> fn) |
java.util.Optional<T> |
reduce(java.util.function.BinaryOperator<T> accumulator) |
java.util.List<T> |
reduce(java.lang.Iterable<com.aol.cyclops.sequence.Monoid<T>> reducers)
Reduce with multiple reducers in parallel
NB if this Monad is an Optional [Arrays.asList(1,2,3)] reduce will operate on the Optional as if the list was one value
To reduce over the values on the list, called streamedStreamUtils.sequenceM() first.
|
T |
reduce(com.aol.cyclops.sequence.Monoid<T> reducer) |
java.util.List<T> |
reduce(java.util.stream.Stream<? extends com.aol.cyclops.sequence.Monoid<T>> reducers)
Reduce with multiple reducers in parallel
NB if this Monad is an Optional [Arrays.asList(1,2,3)] reduce will operate on the Optional as if the list was one value
To reduce over the values on the list, called streamedStreamUtils.sequenceM() first.
|
T |
reduce(T identity,
java.util.function.BinaryOperator<T> accumulator) |
<U> U |
reduce(U identity,
java.util.function.BiFunction<U,? super T,U> accumulator,
java.util.function.BinaryOperator<U> combiner) |
com.aol.cyclops.sequence.SequenceM<T> |
reverse() |
<U> com.aol.cyclops.sequence.SequenceM<org.jooq.lambda.tuple.Tuple2<T,U>> |
rightOuterJoin(java.util.stream.Stream<U> other,
java.util.function.BiPredicate<T,U> predicate) |
com.aol.cyclops.sequence.SequenceM<T> |
scanLeft(com.aol.cyclops.sequence.Monoid<T> monoid)
Scan left using supplied Monoid
|
<U> com.aol.cyclops.sequence.SequenceM<U> |
scanLeft(U seed,
java.util.function.BiFunction<U,? super T,U> function)
Scan left
|
com.aol.cyclops.sequence.SequenceM<T> |
scanRight(com.aol.cyclops.sequence.Monoid<T> monoid)
Scan right
|
<U> com.aol.cyclops.sequence.SequenceM<U> |
scanRight(U identity,
java.util.function.BiFunction<? super T,U,U> combiner)
Scan right
|
com.aol.cyclops.sequence.HotStream<T> |
schedule(java.lang.String cron,
java.util.concurrent.ScheduledExecutorService ex) |
com.aol.cyclops.sequence.HotStream<T> |
scheduleFixedDelay(long delay,
java.util.concurrent.ScheduledExecutorService ex) |
com.aol.cyclops.sequence.HotStream<T> |
scheduleFixedRate(long rate,
java.util.concurrent.ScheduledExecutorService ex) |
com.aol.cyclops.sequence.SequenceM<T> |
sequential() |
com.aol.cyclops.sequence.SequenceM<T> |
shuffle() |
com.aol.cyclops.sequence.SequenceM<T> |
shuffle(java.util.Random random) |
com.aol.cyclops.sequence.SequenceM<T> |
skip(long num)
assertThat(anyM(Stream.of(4,3,6,7)).asSequence().skip(2).toList(),equalTo(Arrays.asList(6,7))); |
com.aol.cyclops.sequence.SequenceM<T> |
skip(long time,
java.util.concurrent.TimeUnit unit) |
com.aol.cyclops.sequence.SequenceM<T> |
skipLast(int num) |
com.aol.cyclops.sequence.SequenceM<T> |
skipUntil(java.util.function.Predicate<? super T> p)
assertThat(anyM(Stream.of(4,3,6,7)).asSequence().skipUntil(i->i==6).toList(),equalTo(Arrays.asList(6,7))); |
com.aol.cyclops.sequence.SequenceM<T> |
skipWhile(java.util.function.Predicate<? super T> p)
assertThat(anyM(Stream.of(4,3,6,7)).asSequence().sorted().skipWhile(i->i<6).toList(),equalTo(Arrays.asList(6,7)));
|
com.aol.cyclops.sequence.SequenceM<T> |
slice(long from,
long to) |
com.aol.cyclops.sequence.SequenceM<java.util.List<T>> |
sliding(int windowSize)
Create a sliding view over this Sequence
|
com.aol.cyclops.sequence.SequenceM<java.util.List<T>> |
sliding(int windowSize,
int increment)
Create a sliding view over this Sequence
|
com.aol.cyclops.sequence.SequenceM<T> |
sorted()
assertThat(SequenceM.of(4,3,6,7)).sorted().toList(),equalTo(Arrays.asList(3,4,6,7))); |
com.aol.cyclops.sequence.SequenceM<T> |
sorted(java.util.Comparator<? super T> c)
assertThat(anyM(Stream.of(4,3,6,7)).asSequence().sorted((a,b) -> b-a).toList(),equalTo(Arrays.asList(7,6,4,3)));
|
<U extends java.lang.Comparable<? super U>> |
sorted(java.util.function.Function<? super T,? extends U> function) |
org.jooq.lambda.tuple.Tuple2<com.aol.cyclops.sequence.SequenceM<T>,com.aol.cyclops.sequence.SequenceM<T>> |
splitAt(int where)
Split at supplied location
|
org.jooq.lambda.tuple.Tuple2<com.aol.cyclops.sequence.SequenceM<T>,com.aol.cyclops.sequence.SequenceM<T>> |
splitBy(java.util.function.Predicate<T> splitter)
Split stream at point where predicate no longer holds
|
java.util.Spliterator<T> |
spliterator() |
org.jooq.lambda.tuple.Tuple2<java.util.Optional<T>,com.aol.cyclops.sequence.SequenceM<T>> |
splitSequenceAtHead()
Split a Stream at it's head (similar to headAndTail)
|
boolean |
startsWith(java.lang.Iterable<T> iterable)
assertTrue(StreamUtils.sequenceM(Stream.of(1,2,3,4)).startsWith(Arrays.asList(1,2,3)));
|
boolean |
startsWith(java.util.Iterator<T> iterator)
assertTrue(StreamUtils.sequenceM(Stream.of(1,2,3,4)).startsWith(Arrays.asList(1,2,3).iterator())) |
java.util.stream.Stream<T> |
stream()
Unwrap this Monad into a Stream.
|
void |
subscribe(org.reactivestreams.Subscriber<? super T> s) |
java.lang.Object[] |
toArray() |
<A> A[] |
toArray(java.util.function.IntFunction<A[]> generator) |
<C extends java.util.Collection<T>> |
toCollection(java.util.function.Supplier<C> collectionFactory) |
java.util.concurrent.CompletableFuture<java.util.List<T>> |
toCompletableFuture()
CompletableFuture<List<String>> cf = anyM("hello","world")
.asSequence()
.unwrapCompletableFuture();
assertThat(cf.join(),equalTo(Arrays.asList("hello","world")));
|
java.util.Collection<T> |
toConcurrentLazyCollection()
Lazily converts this SequenceM into a Collection.
|
com.aol.cyclops.sequence.streamable.Streamable<T> |
toConcurrentLazyStreamable() |
java.util.Collection<T> |
toLazyCollection()
Lazily converts this SequenceM into a Collection.
|
com.aol.cyclops.sequence.streamable.Streamable<T> |
toLazyStreamable() |
java.util.List<T> |
toList() |
java.util.Optional<java.util.List<T>> |
toOptional()
Type safe unwrap
|
java.util.Set<T> |
toSet() |
<T> java.util.stream.Stream<T> |
toStream() |
com.aol.cyclops.sequence.streamable.Streamable<T> |
toStreamable() |
org.jooq.lambda.tuple.Tuple3<com.aol.cyclops.sequence.SequenceM<T>,com.aol.cyclops.sequence.SequenceM<T>,com.aol.cyclops.sequence.SequenceM<T>> |
triplicate()
Triplicates a Stream
Buffers intermediate values, leaders may change positions so a limit
can be safely applied to the leading stream.
|
com.aol.cyclops.sequence.SequenceM<T> |
unordered() |
<R> R |
unwrap()
Deprecated.
|
java.util.stream.Stream<T> |
unwrapStream()
Type safe unwrap
|
com.aol.cyclops.sequence.SequenceM<com.aol.cyclops.sequence.streamable.Streamable<T>> |
windowBySizeAndTime(int size,
long time,
java.util.concurrent.TimeUnit t) |
com.aol.cyclops.sequence.SequenceM<com.aol.cyclops.sequence.streamable.Streamable<T>> |
windowByTime(long time,
java.util.concurrent.TimeUnit t) |
com.aol.cyclops.sequence.SequenceM<com.aol.cyclops.sequence.streamable.Streamable<T>> |
windowStatefullyWhile(java.util.function.BiPredicate<com.aol.cyclops.sequence.streamable.Streamable<? super T>,? super T> predicate) |
com.aol.cyclops.sequence.SequenceM<com.aol.cyclops.sequence.streamable.Streamable<T>> |
windowUntil(java.util.function.Predicate<? super T> predicate) |
com.aol.cyclops.sequence.SequenceM<com.aol.cyclops.sequence.streamable.Streamable<T>> |
windowWhile(java.util.function.Predicate<? super T> predicate) |
boolean |
xMatch(int num,
java.util.function.Predicate<? super T> c)
Check that there are specified number of matches of predicate in the Stream
|
com.aol.cyclops.sequence.SequenceM<T> |
xPer(int x,
long time,
java.util.concurrent.TimeUnit t) |
<S,R> com.aol.cyclops.sequence.SequenceM<R> |
zip(com.aol.cyclops.monad.AnyM<? extends S> second,
java.util.function.BiFunction<? super T,? super S,? extends R> zipper)
Zip this SequenceM against any monad type.
|
<U> com.aol.cyclops.sequence.SequenceM<org.jooq.lambda.tuple.Tuple2<T,U>> |
zip(org.jooq.lambda.Seq<U> other) |
<U,R> com.aol.cyclops.sequence.SequenceM<R> |
zip(org.jooq.lambda.Seq<U> other,
java.util.function.BiFunction<T,U,R> zipper) |
<S> com.aol.cyclops.sequence.SequenceM<org.jooq.lambda.tuple.Tuple2<T,S>> |
zip(java.util.stream.Stream<? extends S> second)
Zip 2 streams into one
|
<S,U> com.aol.cyclops.sequence.SequenceM<org.jooq.lambda.tuple.Tuple3<T,S,U>> |
zip3(java.util.stream.Stream<? extends S> second,
java.util.stream.Stream<? extends U> third)
zip 3 Streams into one
|
<T2,T3,T4> com.aol.cyclops.sequence.SequenceM<org.jooq.lambda.tuple.Tuple4<T,T2,T3,T4>> |
zip4(java.util.stream.Stream<T2> second,
java.util.stream.Stream<T3> third,
java.util.stream.Stream<T4> fourth)
zip 4 Streams into 1
|
<S,R> com.aol.cyclops.sequence.SequenceM<R> |
zipAnyM(com.aol.cyclops.monad.AnyM<? extends S> second,
java.util.function.BiFunction<? super T,? super S,? extends R> zipper) |
<S,R> com.aol.cyclops.sequence.SequenceM<R> |
zipSequence(com.aol.cyclops.sequence.SequenceM<? extends S> second,
java.util.function.BiFunction<? super T,? super S,? extends R> zipper)
Generic zip function.
|
<S,R> com.aol.cyclops.sequence.SequenceM<R> |
zipStream(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
|
<U> com.aol.cyclops.sequence.SequenceM<org.jooq.lambda.tuple.Tuple2<T,U>> |
zipStream(java.util.stream.Stream<U> other) |
com.aol.cyclops.sequence.SequenceM<org.jooq.lambda.tuple.Tuple2<T,java.lang.Long>> |
zipWithIndex()
Add an index to the current Stream
|
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, waitcombinations, combinations, elapsed, elementAt, fromDoubleStream, fromIntStream, fromIterable, fromIterator, fromList, fromLongStream, fromStream, generate, get, iterate, of, onEmptySwitch, permutations, range, rangeLong, remove, retry, reversedListOf, reversedOf, single, single, singleOptional, size, subscriber, subStream, timestamp, unzip, unzip3, unzip4cast, concat, crossJoin, crossJoin, crossJoin, crossJoin, crossJoin, crossJoin, crossJoin, cycle, duplicate, duplicate, empty, foldLeft, foldLeft, foldRight, generate, groupBy, groupBy, groupBy, groupBy, groupBy, intersperse, isEmpty, isNotEmpty, join, join, join, join, join, limit, limitUntil, limitWhile, maxBy, minBy, ofType, partition, partition, reverse, scanLeft, scanRight, seq, seq, seq, seq, seq, seq, seq, seq, seq, seq, seq, shuffle, shuffle, skip, skipUntil, skipWhile, slice, splitAt, splitAt, splitAtHead, splitAtHead, toCollection, toList, toList, toMap, toMap, toMap, toSet, toSet, toString, toString, toString, unfold, unzip, unzip, unzip, unzip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zipWithIndexpublic SequenceMImpl(java.util.stream.Stream<T> stream)
public SequenceMImpl(java.util.stream.Stream<T> stream, com.aol.cyclops.sequence.spliterators.ReversableSpliterator rev)
public com.aol.cyclops.sequence.HotStream<T> schedule(java.lang.String cron, java.util.concurrent.ScheduledExecutorService ex)
schedule in interface com.aol.cyclops.sequence.SequenceM<T>public com.aol.cyclops.sequence.HotStream<T> scheduleFixedDelay(long delay, java.util.concurrent.ScheduledExecutorService ex)
scheduleFixedDelay in interface com.aol.cyclops.sequence.SequenceM<T>public com.aol.cyclops.sequence.HotStream<T> scheduleFixedRate(long rate, java.util.concurrent.ScheduledExecutorService ex)
scheduleFixedRate in interface com.aol.cyclops.sequence.SequenceM<T>@Deprecated public final <R> R unwrap()
unwrap in interface com.aol.cyclops.sequence.SequenceM<T>unwrap in interface com.aol.cyclops.sequence.Unwrapablepublic final <T1> com.aol.cyclops.sequence.SequenceM<T1> flatten()
assertThat(SequenceM.<Integer>of(Arrays.asList(1,2)).flatten().toList().size(),equalTo(asList(1, 2).size()));
// or more advanced example
AnyM<AnyM<Integer>> applied =anyM(Optional.of(2))
.simpleFilter(anyM(Streamable.of( (Integer a)->a>5 ,(Integer a) -> a<3)));
assertThat(applied.toSequence().flatten().toList(),equalTo(Arrays.asList(2)));
flatten in interface com.aol.cyclops.sequence.SequenceM<T>public final java.util.stream.Stream<T> unwrapStream()
Stream<String> stream = anyM("hello","world").asSequence().unwrapStream();
assertThat(stream.collect(Collectors.toList()),equalTo(Arrays.asList("hello","world")));
public final java.util.Optional<java.util.List<T>> toOptional()
Optional<List<String>> stream = anyM("hello","world")
.asSequence()
.unwrapOptional();
assertThat(stream.get(),equalTo(Arrays.asList("hello","world")));
toOptional in interface com.aol.cyclops.sequence.SequenceM<T>public final java.util.concurrent.CompletableFuture<java.util.List<T>> toCompletableFuture()
CompletableFuture<List<String>> cf = anyM("hello","world")
.asSequence()
.unwrapCompletableFuture();
assertThat(cf.join(),equalTo(Arrays.asList("hello","world")));
toCompletableFuture in interface com.aol.cyclops.sequence.SequenceM<T>public final com.aol.cyclops.sequence.SequenceM<T> cycle(int times)
assertThat(anyM(Stream.of(1,2,2)).asSequence()
.cycle(3).collect(Collectors.toList()),
equalTo(Arrays.asList(1,2,2,1,2,2,1,2,2)));
cycle in interface com.aol.cyclops.sequence.SequenceM<T>times - Times values should be repeated within a Streampublic final com.aol.cyclops.sequence.SequenceM<T> cycle()
assertEquals(asList(1, 1, 1, 1, 1,1),of(1).cycle().limit(6).toList());
public final org.jooq.lambda.tuple.Tuple2<com.aol.cyclops.sequence.SequenceM<T>,com.aol.cyclops.sequence.SequenceM<T>> duplicateSequence()
Tuple2<SequenceM<Integer>, SequenceM<Integer>> copies =of(1,2,3,4,5,6).duplicate();
assertTrue(copies.v1.anyMatch(i->i==2));
assertTrue(copies.v2.anyMatch(i->i==2));
duplicateSequence in interface com.aol.cyclops.sequence.SequenceM<T>public final org.jooq.lambda.tuple.Tuple3<com.aol.cyclops.sequence.SequenceM<T>,com.aol.cyclops.sequence.SequenceM<T>,com.aol.cyclops.sequence.SequenceM<T>> triplicate()
Tuple3<SequenceM<Tuple3<T1,T2,T3>>,SequenceM<Tuple3<T1,T2,T3>>,SequenceM<Tuple3<T1,T2,T3>>> Tuple3 = sequence.triplicate();
triplicate in interface com.aol.cyclops.sequence.SequenceM<T>public final org.jooq.lambda.tuple.Tuple4<com.aol.cyclops.sequence.SequenceM<T>,com.aol.cyclops.sequence.SequenceM<T>,com.aol.cyclops.sequence.SequenceM<T>,com.aol.cyclops.sequence.SequenceM<T>> quadruplicate()
Tuple4<SequenceM<Tuple4<T1,T2,T3,T4>>,SequenceM<Tuple4<T1,T2,T3,T4>>,SequenceM<Tuple4<T1,T2,T3,T4>>,SequenceM<Tuple4<T1,T2,T3,T4>>> quad = sequence.quadruplicate();
quadruplicate in interface com.aol.cyclops.sequence.SequenceM<T>public final org.jooq.lambda.tuple.Tuple2<java.util.Optional<T>,com.aol.cyclops.sequence.SequenceM<T>> splitSequenceAtHead()
SequenceM.of(1,2,3).splitAtHead()
//Optional[1], SequenceM[2,3]
splitSequenceAtHead in interface com.aol.cyclops.sequence.SequenceM<T>public final org.jooq.lambda.tuple.Tuple2<com.aol.cyclops.sequence.SequenceM<T>,com.aol.cyclops.sequence.SequenceM<T>> splitAt(int where)
SequenceM.of(1,2,3).splitAt(1)
//SequenceM[1], SequenceM[2,3]
splitAt in interface com.aol.cyclops.sequence.SequenceM<T>public final org.jooq.lambda.tuple.Tuple2<com.aol.cyclops.sequence.SequenceM<T>,com.aol.cyclops.sequence.SequenceM<T>> splitBy(java.util.function.Predicate<T> splitter)
SequenceM.of(1, 2, 3, 4, 5, 6).splitBy(i->i<4)
//SequenceM[1,2,3] SequenceM[4,5,6]
splitBy in interface com.aol.cyclops.sequence.SequenceM<T>public final org.jooq.lambda.tuple.Tuple2<com.aol.cyclops.sequence.SequenceM<T>,com.aol.cyclops.sequence.SequenceM<T>> partitionSequence(java.util.function.Predicate<T> splitter)
SequenceM.of(1, 2, 3, 4, 5, 6).partition(i -> i % 2 != 0)
//SequenceM[1,3,5], SequenceM[2,4,6]
partitionSequence in interface com.aol.cyclops.sequence.SequenceM<T>public final com.aol.cyclops.sequence.SequenceM<T> cycle(com.aol.cyclops.sequence.Monoid<T> m, int times)
List<Integer> list = AsGenericMonad,asStreamUtils.sequenceM(Stream.of(1,2,2))
.cycle(Reducers.toCountInt(),3)
.collect(Collectors.toList());
//is asList(3,3,3);
cycle in interface com.aol.cyclops.sequence.SequenceM<T>m - Monoid to be used in reductiontimes - Number of times value should be repeatedpublic final <R> com.aol.cyclops.sequence.SequenceM<R> cycle(java.lang.Class<R> monadC,
int times)
{
@code
List<Optional<Integer>> list = StreamUtils.sequenceM(Stream.of(1, 2)).cycle(Optional.class,
2).toList();
// is asList(Optional.of(1),Optional.of(2),Optional.of(1),Optional.of(2) ));
}
cycle in interface com.aol.cyclops.sequence.SequenceM<T>monadC - class typetimes - public final com.aol.cyclops.sequence.SequenceM<T> cycleWhile(java.util.function.Predicate<? super T> predicate)
count =0;
assertThat(anyM(Stream.of(1,2,2)).asSequence()
.cycleWhile(next -> count++<6)
.collect(Collectors.toList()),equalTo(Arrays.asList(1,2,2,1,2,2)));
cycleWhile in interface com.aol.cyclops.sequence.SequenceM<T>predicate - repeat while truepublic final com.aol.cyclops.sequence.SequenceM<T> cycleUntil(java.util.function.Predicate<? super T> predicate)
count =0;
assertThat(anyM(Stream.of(1,2,2)).asSequence()
.cycleUntil(next -> count++>6)
.collect(Collectors.toList()),equalTo(Arrays.asList(1,2,2,1,2,2,1)));
cycleUntil in interface com.aol.cyclops.sequence.SequenceM<T>predicate - repeat while truepublic final <S> com.aol.cyclops.sequence.SequenceM<org.jooq.lambda.tuple.Tuple2<T,S>> zip(java.util.stream.Stream<? extends S> second)
List<Tuple2<Integer, String>> list = of(1, 2).zip(of("a", "b", "c", "d")).toList();
// [[1,"a"],[2,"b"]]
public final <S,U> com.aol.cyclops.sequence.SequenceM<org.jooq.lambda.tuple.Tuple3<T,S,U>> zip3(java.util.stream.Stream<? extends S> second, java.util.stream.Stream<? extends U> third)
List<Tuple3<Integer,Integer,Character>> list =
of(1,2,3,4,5,6).zip3(of(100,200,300,400),of('a','b','c'))
.collect(Collectors.toList());
//[[1,100,'a'],[2,200,'b'],[3,300,'c']]
zip3 in interface com.aol.cyclops.sequence.SequenceM<T>public final <T2,T3,T4> com.aol.cyclops.sequence.SequenceM<org.jooq.lambda.tuple.Tuple4<T,T2,T3,T4>> zip4(java.util.stream.Stream<T2> second, java.util.stream.Stream<T3> third, java.util.stream.Stream<T4> fourth)
List<Tuple4<Integer,Integer,Character,String>> list =
of(1,2,3,4,5,6).zip4(of(100,200,300,400),of('a','b','c'),of("hello","world"))
.collect(Collectors.toList());
//[[1,100,'a',"hello"],[2,200,'b',"world"]]
zip4 in interface com.aol.cyclops.sequence.SequenceM<T>public final com.aol.cyclops.sequence.SequenceM<org.jooq.lambda.tuple.Tuple2<T,java.lang.Long>> zipWithIndex()
assertEquals(asList(new Tuple2("a", 0L), new Tuple2("b", 1L)), of("a", "b").zipWithIndex().toList());
public final <S,R> com.aol.cyclops.sequence.SequenceM<R> zipSequence(com.aol.cyclops.sequence.SequenceM<? extends S> second,
java.util.function.BiFunction<? super T,? super S,? extends R> zipper)
{
@code
Stream<List<Integer>> zipped = asStreamUtils.sequenceM(Stream.of(1, 2, 3)).zip(
asStreamUtils.sequenceM(Optional.of(2)), (a, b) -> Arrays.asList(a, b));
// [[1,2]]
}
zipSequence in interface com.aol.cyclops.sequence.SequenceM<T>second - Monad to zip withzipper - Zipping functionpublic final <S,R> com.aol.cyclops.sequence.SequenceM<R> zip(com.aol.cyclops.monad.AnyM<? extends S> second,
java.util.function.BiFunction<? super T,? super S,? extends R> zipper)
Stream<List<Integer>> zipped = anyM(Stream.of(1,2,3))
.asSequence()
.zip(anyM(Optional.of(2)),
(a,b) -> Arrays.asList(a,b)).toStream();
List<Integer> zip = zipped.collect(Collectors.toList()).get(0);
assertThat(zip.get(0),equalTo(1));
assertThat(zip.get(1),equalTo(2));
public final <S,R> com.aol.cyclops.sequence.SequenceM<R> zipStream(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)
{
@code
Stream<List<Integer>> zipped = asStreamUtils.sequenceM(Stream.of(1, 2, 3)).zip(
Stream.of(2, 3, 4), (a, b) -> Arrays.asList(a, b));
// [[1,2][2,3][3,4]]
}
zipStream in interface com.aol.cyclops.sequence.SequenceM<T>second - Stream to zip withzipper - Zip funcitonpublic final com.aol.cyclops.sequence.SequenceM<java.util.List<T>> sliding(int windowSize)
List<List<Integer>> list = anyM(Stream.of(1,2,3,4,5,6))
.asSequence()
.sliding(2)
.collect(Collectors.toList());
assertThat(list.get(0),hasItems(1,2));
assertThat(list.get(1),hasItems(2,3));
sliding in interface com.aol.cyclops.sequence.SequenceM<T>windowSize - Size of sliding windowpublic final com.aol.cyclops.sequence.SequenceM<java.util.List<T>> sliding(int windowSize, int increment)
List<List<Integer>> list = anyM(Stream.of(1,2,3,4,5,6))
.asSequence()
.sliding(3,2)
.collect(Collectors.toList());
assertThat(list.get(0),hasItems(1,2,3));
assertThat(list.get(1),hasItems(3,4,5));
sliding in interface com.aol.cyclops.sequence.SequenceM<T>windowSize - number of elements in each batchincrement - for each windowpublic final com.aol.cyclops.sequence.SequenceM<java.util.List<T>> grouped(int groupSize)
{
@code
List<List<Integer>> list = StreamUtils.sequenceM(Stream.of(1, 2, 3, 4, 5, 6)).grouped(3)
.collect(Collectors.toList());
assertThat(list.get(0), hasItems(1, 2, 3));
assertThat(list.get(1), hasItems(4, 5, 6));
}
grouped in interface com.aol.cyclops.sequence.SequenceM<T>groupSize - Size of each Grouppublic final <K> java.util.Map<K,java.util.List<T>> groupBy(java.util.function.Function<? super T,? extends K> classifier)
Map<Integer, List<Integer>> map1 =of(1, 2, 3, 4).groupBy(i -> i % 2);
assertEquals(asList(2, 4), map1.get(0));
assertEquals(asList(1, 3), map1.get(1));
assertEquals(2, map1.size());
public final com.aol.cyclops.sequence.SequenceM<T> distinct()
public final com.aol.cyclops.sequence.SequenceM<T> scanLeft(com.aol.cyclops.sequence.Monoid<T> monoid)
assertEquals(asList("", "a", "ab", "abc"),StreamUtils.sequenceM(Stream.of("a", "b", "c")).scanLeft(Reducers.toString("")).toList());
scanLeft in interface com.aol.cyclops.sequence.SequenceM<T>monoid - public final <U> com.aol.cyclops.sequence.SequenceM<U> scanLeft(U seed,
java.util.function.BiFunction<U,? super T,U> function)
assertThat(of("a", "b", "c").scanLeft("", String::concat).toList().size(),
is(4));
public final com.aol.cyclops.sequence.SequenceM<T> scanRight(com.aol.cyclops.sequence.Monoid<T> monoid)
assertThat(of("a", "b", "c").scanRight(Monoid.of("", String::concat)).toList().size(),
is(asList("", "c", "bc", "abc").size()));
scanRight in interface com.aol.cyclops.sequence.SequenceM<T>public final <U> com.aol.cyclops.sequence.SequenceM<U> scanRight(U identity,
java.util.function.BiFunction<? super T,U,U> combiner)
assertThat(of("a", "ab", "abc").map(str->str.length()).scanRight(0, (t, u) -> u + t).toList().size(),
is(asList(0, 3, 5, 6).size()));
public final com.aol.cyclops.sequence.SequenceM<T> sorted()
assertThat(SequenceM.of(4,3,6,7)).sorted().toList(),equalTo(Arrays.asList(3,4,6,7)));
public final com.aol.cyclops.sequence.SequenceM<T> sorted(java.util.Comparator<? super T> c)
assertThat(anyM(Stream.of(4,3,6,7)).asSequence().sorted((a,b) -> b-a).toList(),equalTo(Arrays.asList(7,6,4,3)));
public final com.aol.cyclops.sequence.SequenceM<T> skip(long num)
assertThat(anyM(Stream.of(4,3,6,7)).asSequence().skip(2).toList(),equalTo(Arrays.asList(6,7)));
skip in interface com.aol.cyclops.sequence.SequenceM<T>skip in interface java.util.stream.Stream<T>skip in interface org.jooq.lambda.Seq<T>num - Number of elemenets to skippublic final com.aol.cyclops.sequence.SequenceM<T> skipWhile(java.util.function.Predicate<? super T> p)
assertThat(anyM(Stream.of(4,3,6,7)).asSequence().sorted().skipWhile(i->i<6).toList(),equalTo(Arrays.asList(6,7)));
public final com.aol.cyclops.sequence.SequenceM<T> skipUntil(java.util.function.Predicate<? super T> p)
assertThat(anyM(Stream.of(4,3,6,7)).asSequence().skipUntil(i->i==6).toList(),equalTo(Arrays.asList(6,7)));
public final com.aol.cyclops.sequence.SequenceM<T> limit(long num)
assertThat(anyM(Stream.of(4,3,6,7)).asSequence().limit(2).toList(),equalTo(Arrays.asList(4,3)));
public final com.aol.cyclops.sequence.SequenceM<T> limitWhile(java.util.function.Predicate<? super T> p)
assertThat(anyM(Stream.of(4,3,6,7)).asSequence().sorted().limitWhile(i->i<6).toList(),equalTo(Arrays.asList(3,4)));
public final com.aol.cyclops.sequence.SequenceM<T> limitUntil(java.util.function.Predicate<? super T> p)
assertThat(anyM(Stream.of(4,3,6,7)).limitUntil(i->i==6).toList(),equalTo(Arrays.asList(4,3)));
public final com.aol.cyclops.sequence.SequenceM<T> parallel()
public final boolean allMatch(java.util.function.Predicate<? super T> c)
assertThat(of(1,2,3,4,5).allMatch(it-> it>0 && it <6),equalTo(true));
public final boolean anyMatch(java.util.function.Predicate<? super T> c)
assertThat(of(1,2,3,4,5).anyMatch(it-> it.equals(3)),equalTo(true));
public boolean xMatch(int num,
java.util.function.Predicate<? super T> c)
assertTrue(SequenceM.of(1,2,3,5,6,7).xMatch(3, i-> i>4 ));
xMatch in interface com.aol.cyclops.sequence.SequenceM<T>public final boolean noneMatch(java.util.function.Predicate<? super T> c)
public final java.lang.String join()
assertEquals("123".length(),of(1, 2, 3).join().length());
public final java.lang.String join(java.lang.String sep)
assertEquals("1, 2, 3".length(), of(1, 2, 3).join(", ").length());
join in interface com.aol.cyclops.sequence.SequenceM<T>public final java.lang.String join(java.lang.String sep,
java.lang.String start,
java.lang.String end)
assertEquals("^1|2|3$".length(), of(1, 2, 3).join("|", "^", "$").length());
join in interface com.aol.cyclops.sequence.SequenceM<T>public final <U extends java.lang.Comparable<U>> java.util.Optional<T> minBy(java.util.function.Function<T,U> function)
public final <C extends java.lang.Comparable<C>> java.util.Optional<T> maxBy(java.util.function.Function<T,C> f)
public final com.aol.cyclops.sequence.HeadAndTail<T> headAndTail()
SequenceM<String> helloWorld = SequenceM.of("hello","world","last");
HeadAndTail<String> headAndTail = helloWorld.headAndTail();
String head = headAndTail.head();
assertThat(head,equalTo("hello"));
SequenceM<String> tail = headAndTail.tail();
assertThat(tail.headAndTail().head(),equalTo("world"));
headAndTail in interface com.aol.cyclops.sequence.SequenceM<T>public final java.util.Optional<com.aol.cyclops.sequence.HeadAndTail<T>> headAndTailOptional()
SequenceM<String> helloWorld = SequenceM.of();
Optional<HeadAndTail<String>> headAndTail = helloWorld.headAndTailOptional();
assertTrue(!headAndTail.isPresent());
headAndTailOptional in interface com.aol.cyclops.sequence.SequenceM<T>public final java.util.Optional<T> findFirst()
public final java.util.Optional<T> findAny()
public final <R> R mapReduce(com.aol.cyclops.sequence.Monoid<R> reducer)
mapReduce in interface com.aol.cyclops.sequence.SequenceM<T>reducer - Monoid to reduce valuespublic final <R> R mapReduce(java.util.function.Function<? super T,? extends R> mapper, com.aol.cyclops.sequence.Monoid<R> reducer)
mapReduce in interface com.aol.cyclops.sequence.SequenceM<T>mapper - Function to map Monad typereducer - Monoid to reduce valuespublic final <R,A> R collect(java.util.stream.Collector<? super T,A,R> collector)
collect in interface java.util.stream.Stream<T>collector - Collection operation definitionpublic final <R> R collect(java.util.function.Supplier<R> supplier,
java.util.function.BiConsumer<R,? super T> accumulator,
java.util.function.BiConsumer<R,R> combiner)
collect in interface java.util.stream.Stream<T>public final java.util.List collect(java.util.stream.Stream<java.util.stream.Collector> collectors)
List result =SequenceM.of(1,2,3).collect(Stream.of(Collectors.toList(),
Collectors.summingInt(Integer::intValue),
Collectors.averagingInt(Integer::intValue)));
assertThat(result.get(0),equalTo(Arrays.asList(1,2,3)));
assertThat(result.get(1),equalTo(6));
assertThat(result.get(2),equalTo(2.0));
collectors - Stream of Collectors to applypublic <R> java.util.List<R> collectIterable(java.lang.Iterable<java.util.stream.Collector> collectors)
List result = SequenceM.of(1,2,3).collect(
Arrays.asList(Collectors.toList(),
Collectors.summingInt(Integer::intValue),
Collectors.averagingInt(Integer::intValue)));
assertThat(result.get(0),equalTo(Arrays.asList(1,2,3)));
assertThat(result.get(1),equalTo(6));
assertThat(result.get(2),equalTo(2.0));
collectIterable in interface com.aol.cyclops.sequence.SequenceM<T>stream - Stream to collectcollectors - Collectors to applypublic final T reduce(com.aol.cyclops.sequence.Monoid<T> reducer)
reduce in interface com.aol.cyclops.sequence.SequenceM<T>reducer - Use supplied Monoid to reduce valuespublic final <U> U reduce(U identity,
java.util.function.BiFunction<U,? super T,U> accumulator,
java.util.function.BinaryOperator<U> combiner)
public final java.util.List<T> reduce(java.util.stream.Stream<? extends com.aol.cyclops.sequence.Monoid<T>> reducers)
reduce in interface com.aol.cyclops.sequence.SequenceM<T>reducers - public final java.util.List<T> reduce(java.lang.Iterable<com.aol.cyclops.sequence.Monoid<T>> reducers)
reduce in interface com.aol.cyclops.sequence.SequenceM<T>reducers - public final T foldLeft(com.aol.cyclops.sequence.Monoid<T> reducer)
foldLeft in interface com.aol.cyclops.sequence.SequenceM<T>reducer - Use supplied Monoid to reduce values starting via foldLeftpublic final T foldLeft(T identity, java.util.function.BinaryOperator<T> accumulator)
assertTrue(SequenceM.of("a", "b", "c").foldLeft("", String::concat).equals("abc"));
foldLeft in interface com.aol.cyclops.sequence.SequenceM<T>public final <T> T foldLeftMapToType(com.aol.cyclops.sequence.Monoid<T> reducer)
foldLeftMapToType in interface com.aol.cyclops.sequence.SequenceM<T>reducer - Monoid to reduce valuespublic final T foldRight(com.aol.cyclops.sequence.Monoid<T> reducer)
foldRight in interface com.aol.cyclops.sequence.SequenceM<T>reducer - Use supplied Monoid to reduce values starting via foldRightpublic final <U> U foldRight(U seed,
java.util.function.BiFunction<? super T,U,U> function)
assertTrue(SequenceM.of("a","b","c").foldRight("", String::concat).equals("cba"));
foldRight in interface org.jooq.lambda.Seq<T>identity - accumulator - public final <T> T foldRightMapToType(com.aol.cyclops.sequence.Monoid<T> reducer)
foldRightMapToType in interface com.aol.cyclops.sequence.SequenceM<T>reducer - Monoid to reduce valuespublic final com.aol.cyclops.sequence.streamable.Streamable<T> toStreamable()
toStreamable in interface com.aol.cyclops.sequence.SequenceM<T>public final java.util.Set<T> toSet()
public final java.util.List<T> toList()
public final <C extends java.util.Collection<T>> C toCollection(java.util.function.Supplier<C> collectionFactory)
public final <T> java.util.stream.Stream<T> toStream()
toStream in interface com.aol.cyclops.sequence.SequenceM<T>public final java.util.stream.Stream<T> stream()
public final boolean startsWith(java.lang.Iterable<T> iterable)
assertTrue(StreamUtils.sequenceM(Stream.of(1,2,3,4)).startsWith(Arrays.asList(1,2,3)));
startsWith in interface com.aol.cyclops.sequence.SequenceM<T>iterable - public final boolean startsWith(java.util.Iterator<T> iterator)
assertTrue(StreamUtils.sequenceM(Stream.of(1,2,3,4)).startsWith(Arrays.asList(1,2,3).iterator())) startsWith in interface com.aol.cyclops.sequence.SequenceM<T>iterator - public com.aol.cyclops.monad.AnyM<T> anyM()
anyM in interface com.aol.cyclops.sequence.SequenceM<T>public final <R> com.aol.cyclops.sequence.SequenceM<R> map(java.util.function.Function<? super T,? extends R> fn)
public final com.aol.cyclops.sequence.SequenceM<T> peek(java.util.function.Consumer<? super T> c)
public final <R> com.aol.cyclops.sequence.SequenceM<R> flatMap(java.util.function.Function<? super T,? extends java.util.stream.Stream<? extends R>> fn)
assertThat(this.<Integer>of(1,2).flatMap(i -> asList(i, -i).stream()).toList(),equalTo(asList(1, -1, 2, -2)));
public final <R> com.aol.cyclops.sequence.SequenceM<R> flatMapAnyM(java.util.function.Function<? super T,com.aol.cyclops.monad.AnyM<? extends R>> fn)
assertThat(anyM(Seq.of(1,2,3)).asSequence().flatMapAnyM(i-> anyM(CompletableFuture.completedFuture(i+2))).toList(),equalTo(Arrays.asList(3,4,5)));
flatMapAnyM in interface com.aol.cyclops.sequence.SequenceM<T>fn - to be appliedpublic final <R> com.aol.cyclops.sequence.SequenceM<R> flatMapCollection(java.util.function.Function<? super T,java.util.Collection<? extends R>> fn)
AnyM<Integer> opt = anyM(Optional.of(20));
Optional<List<Integer>> optionalList = opt.flatMap( i -> anyM(Stream.of(1,2,i))).unwrap();
//Optional [1,2,20]
In such cases using Arrays.asList would be more performant
AnyM<Integer> opt = anyM(Optional.of(20));
Optional<List<Integer>> optionalList = opt.flatMapCollection( i -> asList(1,2,i))).unwrap();
//Optional [1,2,20]
flatMapCollection in interface com.aol.cyclops.sequence.SequenceM<T>fn - public final <R> com.aol.cyclops.sequence.SequenceM<R> flatMapStream(java.util.function.Function<? super T,java.util.stream.BaseStream<? extends R,?>> fn)
assertThat(anyM(Stream.of(1,2,3)).asSequence().flatMapStream(i->Stream.of(i)).toList(),equalTo(Arrays.asList(1,2,3)));
flatMapStream in interface com.aol.cyclops.sequence.SequenceM<T>fn - to be appliedpublic final <R> com.aol.cyclops.sequence.SequenceM<R> flatMapOptional(java.util.function.Function<? super T,java.util.Optional<? extends R>> fn)
assertThat(SequenceM.of(1,2,3,null).flatMapOptional(Optional::ofNullable)
.collect(Collectors.toList()),
equalTo(Arrays.asList(1,2,3)));
flatMapOptional in interface com.aol.cyclops.sequence.SequenceM<T>fn - public final <R> com.aol.cyclops.sequence.SequenceM<R> flatMapCompletableFuture(java.util.function.Function<? super T,java.util.concurrent.CompletableFuture<? extends R>> fn)
assertThat(SequenceM.of(1,2,3).flatMapCompletableFuture(i->CompletableFuture.completedFuture(i+2))
.collect(Collectors.toList()),
equalTo(Arrays.asList(3,4,5)));
flatMapCompletableFuture in interface com.aol.cyclops.sequence.SequenceM<T>fn - public final com.aol.cyclops.sequence.SequenceM<java.lang.Character> flatMapCharSequence(java.util.function.Function<? super T,java.lang.CharSequence> fn)
List<Character> result = anyM("input.file")
.asSequence()
.flatMapCharSequence(i->"hello world")
.toList();
assertThat(result,equalTo(Arrays.asList('h','e','l','l','o',' ','w','o','r','l','d')));
flatMapCharSequence in interface com.aol.cyclops.sequence.SequenceM<T>fn - public final com.aol.cyclops.sequence.SequenceM<java.lang.String> flatMapFile(java.util.function.Function<? super T,java.io.File> fn)
List<String> result = anyM("input.file")
.asSequence()
.map(getClass().getClassLoader()::getResource)
.peek(System.out::println)
.map(URL::getFile)
.liftAndBindFile(File::new)
.toList();
assertThat(result,equalTo(Arrays.asList("hello","world")));
flatMapFile in interface com.aol.cyclops.sequence.SequenceM<T>fn - public final com.aol.cyclops.sequence.SequenceM<java.lang.String> flatMapURL(java.util.function.Function<? super T,java.net.URL> fn)
List<String> result = anyM("input.file")
.asSequence()
.liftAndBindURL(getClass().getClassLoader()::getResource)
.toList();
assertThat(result,equalTo(Arrays.asList("hello","world")));
flatMapURL in interface com.aol.cyclops.sequence.SequenceM<T>fn - public final com.aol.cyclops.sequence.SequenceM<java.lang.String> flatMapBufferedReader(java.util.function.Function<? super T,java.io.BufferedReader> fn)
Listresult = anyM("input.file") .asSequence() .map(getClass().getClassLoader()::getResourceAsStream) .map(InputStreamReader::new) .liftAndBindBufferedReader(BufferedReader::new) .toList(); assertThat(result,equalTo(Arrays.asList("hello","world")));
flatMapBufferedReader in interface com.aol.cyclops.sequence.SequenceM<T>fn - public final com.aol.cyclops.sequence.SequenceM<T> filter(java.util.function.Predicate<? super T> fn)
public void forEach(java.util.function.Consumer<? super T> action)
public java.util.Iterator<T> iterator()
public java.util.Spliterator<T> spliterator()
public boolean isParallel()
public com.aol.cyclops.sequence.SequenceM<T> sequential()
public com.aol.cyclops.sequence.SequenceM<T> unordered()
public java.util.stream.IntStream mapToInt(java.util.function.ToIntFunction<? super T> mapper)
public java.util.stream.LongStream mapToLong(java.util.function.ToLongFunction<? super T> mapper)
public java.util.stream.DoubleStream mapToDouble(java.util.function.ToDoubleFunction<? super T> mapper)
public java.util.stream.IntStream flatMapToInt(java.util.function.Function<? super T,? extends java.util.stream.IntStream> mapper)
public java.util.stream.LongStream flatMapToLong(java.util.function.Function<? super T,? extends java.util.stream.LongStream> mapper)
public java.util.stream.DoubleStream flatMapToDouble(java.util.function.Function<? super T,? extends java.util.stream.DoubleStream> mapper)
public void forEachOrdered(java.util.function.Consumer<? super T> action)
forEachOrdered in interface java.util.stream.Stream<T>public java.lang.Object[] toArray()
toArray in interface java.util.stream.Stream<T>public <A> A[] toArray(java.util.function.IntFunction<A[]> generator)
toArray in interface java.util.stream.Stream<T>public long count()
public com.aol.cyclops.sequence.SequenceM<T> intersperse(T value)
public <U> com.aol.cyclops.sequence.SequenceM<U> ofType(java.lang.Class<U> type)
public <U> com.aol.cyclops.sequence.SequenceM<U> cast(java.lang.Class<U> type)
ClassCastException.
// ClassCastException SequenceM.of(1, "a", 2, "b", 3).cast(Integer.class)public java.util.Collection<T> toLazyCollection()
Collection<Integer> col = SequenceM.of(1,2,3,4,5)
.peek(System.out::println)
.toLazyCollection();
System.out.println("first!");
col.forEach(System.out::println);
//Will print out "first!" before anything else
toLazyCollection in interface com.aol.cyclops.sequence.SequenceM<T>public java.util.Collection<T> toConcurrentLazyCollection()
Collection<Integer> col = SequenceM.of(1,2,3,4,5)
.peek(System.out::println)
.toConcurrentLazyCollection();
System.out.println("first!");
col.forEach(System.out::println);
//Will print out "first!" before anything else
toConcurrentLazyCollection in interface com.aol.cyclops.sequence.SequenceM<T>public com.aol.cyclops.sequence.streamable.Streamable<T> toLazyStreamable()
public com.aol.cyclops.sequence.streamable.Streamable<T> toConcurrentLazyStreamable()
toConcurrentLazyStreamable in interface com.aol.cyclops.sequence.SequenceM<T>public com.aol.cyclops.sequence.SequenceM<T> reverse()
public com.aol.cyclops.sequence.SequenceM<T> onClose(java.lang.Runnable closeHandler)
public void close()
public com.aol.cyclops.sequence.SequenceM<T> shuffle()
public com.aol.cyclops.sequence.SequenceM<T> appendStream(java.util.stream.Stream<T> stream)
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!!")));
appendStream in interface com.aol.cyclops.sequence.SequenceM<T>stream - to appendpublic com.aol.cyclops.sequence.SequenceM<T> prependStream(java.util.stream.Stream<T> stream)
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!!")));
prependStream in interface com.aol.cyclops.sequence.SequenceM<T>stream - to Prependpublic com.aol.cyclops.sequence.SequenceM<T> append(T... values)
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!!")));
append in interface com.aol.cyclops.sequence.SequenceM<T>values - to appendpublic com.aol.cyclops.sequence.SequenceM<T> prepend(T... values)
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!!")));
prepend in interface com.aol.cyclops.sequence.SequenceM<T>values - to prependpublic com.aol.cyclops.sequence.SequenceM<T> insertAt(int pos, T... values)
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!!")));
insertAt in interface com.aol.cyclops.sequence.SequenceM<T>pos - to insert data atvalues - to insertpublic com.aol.cyclops.sequence.SequenceM<T> deleteBetween(int start, int end)
List<String> result = of(1,2,3,4,5,6).deleteBetween(2,4)
.map(it ->it+"!!").collect(Collectors.toList());
assertThat(result,equalTo(Arrays.asList("1!!","2!!","5!!","6!!")));
deleteBetween in interface com.aol.cyclops.sequence.SequenceM<T>start - indexend - indexpublic com.aol.cyclops.sequence.SequenceM<T> insertStreamAt(int pos, java.util.stream.Stream<T> stream)
List<String> result = of(1,2,3).insertStreamAt(1,of(100,200,300))
.map(it ->it+"!!").collect(Collectors.toList());
assertThat(result,equalTo(Arrays.asList("1!!","100!!","200!!","300!!","2!!","3!!")));
insertStreamAt in interface com.aol.cyclops.sequence.SequenceM<T>pos - to insert Stream atstream - to insertpublic com.aol.cyclops.sequence.future.FutureOperations<T> futureOperations(java.util.concurrent.Executor exec)
futureOperations in interface com.aol.cyclops.sequence.SequenceM<T>public boolean endsWith(java.lang.Iterable<T> iterable)
endsWith in interface com.aol.cyclops.sequence.SequenceM<T>public com.aol.cyclops.sequence.HotStream<T> hotStream(java.util.concurrent.Executor e)
hotStream in interface com.aol.cyclops.sequence.SequenceM<T>public T firstValue()
firstValue in interface com.aol.cyclops.sequence.SequenceM<T>public void subscribe(org.reactivestreams.Subscriber<? super T> s)
subscribe in interface org.reactivestreams.Publisher<T>public <U> com.aol.cyclops.sequence.SequenceM<org.jooq.lambda.tuple.Tuple2<T,U>> zip(org.jooq.lambda.Seq<U> other)
public <S,R> com.aol.cyclops.sequence.SequenceM<R> zipAnyM(com.aol.cyclops.monad.AnyM<? extends S> second,
java.util.function.BiFunction<? super T,? super S,? extends R> zipper)
zipAnyM in interface com.aol.cyclops.sequence.SequenceM<T>public <U> com.aol.cyclops.sequence.SequenceM<org.jooq.lambda.tuple.Tuple2<T,U>> crossJoin(java.util.stream.Stream<U> other)
public <U> com.aol.cyclops.sequence.SequenceM<org.jooq.lambda.tuple.Tuple2<T,U>> innerJoin(java.util.stream.Stream<U> other, java.util.function.BiPredicate<T,U> predicate)
public <U> com.aol.cyclops.sequence.SequenceM<org.jooq.lambda.tuple.Tuple2<T,U>> leftOuterJoin(java.util.stream.Stream<U> other, java.util.function.BiPredicate<T,U> predicate)
public <U> com.aol.cyclops.sequence.SequenceM<org.jooq.lambda.tuple.Tuple2<T,U>> rightOuterJoin(java.util.stream.Stream<U> other, java.util.function.BiPredicate<T,U> predicate)
public com.aol.cyclops.sequence.SequenceM<T> onEmptyGet(java.util.function.Supplier<T> supplier)
public <X extends java.lang.Throwable> com.aol.cyclops.sequence.SequenceM<T> onEmptyThrow(java.util.function.Supplier<X> supplier)
public <U> com.aol.cyclops.sequence.SequenceM<T> distinct(java.util.function.Function<? super T,? extends U> keyExtractor)
public <U,R> com.aol.cyclops.sequence.SequenceM<R> zip(org.jooq.lambda.Seq<U> other,
java.util.function.BiFunction<T,U,R> zipper)
public com.aol.cyclops.sequence.SequenceM<T> shuffle(java.util.Random random)
public com.aol.cyclops.sequence.SequenceM<T> slice(long from, long to)
public <U extends java.lang.Comparable<? super U>> com.aol.cyclops.sequence.SequenceM<T> sorted(java.util.function.Function<? super T,? extends U> function)
public <U> com.aol.cyclops.sequence.SequenceM<org.jooq.lambda.tuple.Tuple2<T,U>> zipStream(java.util.stream.Stream<U> other)
zipStream in interface com.aol.cyclops.sequence.SequenceM<T>public com.aol.cyclops.sequence.SequenceM<T> xPer(int x, long time, java.util.concurrent.TimeUnit t)
xPer in interface com.aol.cyclops.sequence.SequenceM<T>public com.aol.cyclops.sequence.SequenceM<T> onePer(long time, java.util.concurrent.TimeUnit t)
onePer in interface com.aol.cyclops.sequence.SequenceM<T>public com.aol.cyclops.sequence.SequenceM<T> debounce(long time, java.util.concurrent.TimeUnit t)
debounce in interface com.aol.cyclops.sequence.SequenceM<T>public com.aol.cyclops.sequence.SequenceM<java.util.List<T>> batchBySizeAndTime(int size, long time, java.util.concurrent.TimeUnit t)
batchBySizeAndTime in interface com.aol.cyclops.sequence.SequenceM<T>public com.aol.cyclops.sequence.SequenceM<java.util.List<T>> batchByTime(long time, java.util.concurrent.TimeUnit t)
batchByTime in interface com.aol.cyclops.sequence.SequenceM<T>public T foldRight(T identity, java.util.function.BinaryOperator<T> accumulator)
foldRight in interface com.aol.cyclops.sequence.SequenceM<T>public boolean endsWith(java.util.stream.Stream<T> iterable)
endsWith in interface com.aol.cyclops.sequence.SequenceM<T>public com.aol.cyclops.sequence.SequenceM<T> skip(long time, java.util.concurrent.TimeUnit unit)
skip in interface com.aol.cyclops.sequence.SequenceM<T>public com.aol.cyclops.sequence.SequenceM<T> limit(long time, java.util.concurrent.TimeUnit unit)
limit in interface com.aol.cyclops.sequence.SequenceM<T>public com.aol.cyclops.sequence.SequenceM<java.util.List<T>> batchBySize(int size)
batchBySize in interface com.aol.cyclops.sequence.SequenceM<T>public com.aol.cyclops.sequence.SequenceM<T> fixedDelay(long l, java.util.concurrent.TimeUnit unit)
fixedDelay in interface com.aol.cyclops.sequence.SequenceM<T>public com.aol.cyclops.sequence.SequenceM<T> jitter(long l)
jitter in interface com.aol.cyclops.sequence.SequenceM<T>public com.aol.cyclops.sequence.SequenceM<com.aol.cyclops.sequence.streamable.Streamable<T>> windowBySizeAndTime(int size, long time, java.util.concurrent.TimeUnit t)
windowBySizeAndTime in interface com.aol.cyclops.sequence.SequenceM<T>public com.aol.cyclops.sequence.SequenceM<com.aol.cyclops.sequence.streamable.Streamable<T>> windowWhile(java.util.function.Predicate<? super T> predicate)
windowWhile in interface com.aol.cyclops.sequence.SequenceM<T>public com.aol.cyclops.sequence.SequenceM<com.aol.cyclops.sequence.streamable.Streamable<T>> windowUntil(java.util.function.Predicate<? super T> predicate)
windowUntil in interface com.aol.cyclops.sequence.SequenceM<T>public com.aol.cyclops.sequence.SequenceM<com.aol.cyclops.sequence.streamable.Streamable<T>> windowStatefullyWhile(java.util.function.BiPredicate<com.aol.cyclops.sequence.streamable.Streamable<? super T>,? super T> predicate)
windowStatefullyWhile in interface com.aol.cyclops.sequence.SequenceM<T>public com.aol.cyclops.sequence.SequenceM<com.aol.cyclops.sequence.streamable.Streamable<T>> windowByTime(long time, java.util.concurrent.TimeUnit t)
windowByTime in interface com.aol.cyclops.sequence.SequenceM<T>public com.aol.cyclops.sequence.SequenceM<java.util.List<T>> batchUntil(java.util.function.Predicate<? super T> predicate)
batchUntil in interface com.aol.cyclops.sequence.SequenceM<T>public com.aol.cyclops.sequence.SequenceM<java.util.List<T>> batchWhile(java.util.function.Predicate<? super T> predicate)
batchWhile in interface com.aol.cyclops.sequence.SequenceM<T>public java.util.List collectStream(java.util.stream.Stream<java.util.stream.Collector> collectors)
collectStream in interface com.aol.cyclops.sequence.SequenceM<T>public <C extends java.util.Collection<? super T>> com.aol.cyclops.sequence.SequenceM<C> batchWhile(java.util.function.Predicate<? super T> predicate, java.util.function.Supplier<C> factory)
batchWhile in interface com.aol.cyclops.sequence.SequenceM<T>public <C extends java.util.Collection<? super T>> com.aol.cyclops.sequence.SequenceM<C> batchUntil(java.util.function.Predicate<? super T> predicate, java.util.function.Supplier<C> factory)
batchUntil in interface com.aol.cyclops.sequence.SequenceM<T>public <C extends java.util.Collection<? super T>> com.aol.cyclops.sequence.SequenceM<C> batchBySizeAndTime(int size, long time, java.util.concurrent.TimeUnit unit, java.util.function.Supplier<C> factory)
batchBySizeAndTime in interface com.aol.cyclops.sequence.SequenceM<T>public <C extends java.util.Collection<T>> com.aol.cyclops.sequence.SequenceM<C> batchByTime(long time, java.util.concurrent.TimeUnit unit, java.util.function.Supplier<C> factory)
batchByTime in interface com.aol.cyclops.sequence.SequenceM<T>public <C extends java.util.Collection<T>> com.aol.cyclops.sequence.SequenceM<C> batchBySize(int size, java.util.function.Supplier<C> factory)
batchBySize in interface com.aol.cyclops.sequence.SequenceM<T>public com.aol.cyclops.sequence.SequenceM<T> skipLast(int num)
skipLast in interface com.aol.cyclops.sequence.SequenceM<T>public com.aol.cyclops.sequence.SequenceM<T> limitLast(int num)
limitLast in interface com.aol.cyclops.sequence.SequenceM<T>public com.aol.cyclops.sequence.SequenceM<T> recover(java.util.function.Function<java.lang.Throwable,? extends T> fn)
recover in interface com.aol.cyclops.sequence.SequenceM<T>public <EX extends java.lang.Throwable> com.aol.cyclops.sequence.SequenceM<T> recover(java.lang.Class<EX> exceptionClass, java.util.function.Function<EX,? extends T> fn)
recover in interface com.aol.cyclops.sequence.SequenceM<T>public <R1,R2,R> com.aol.cyclops.sequence.SequenceM<R> forEach3(java.util.function.Function<? super T,? extends java.util.stream.BaseStream<R1,?>> stream1, java.util.function.Function<? super T,java.util.function.Function<? super R1,? extends java.util.stream.BaseStream<R2,?>>> stream2, java.util.function.Function<? super T,java.util.function.Function<? super R1,java.util.function.Function<? super R2,? extends R>>> yieldingFunction)
SequenceM.of(1,2)
.forEach3(a->IntStream.range(10,13),
.a->b->Stream.of(""+(a+b),"hello world"),
a->b->c->c+":"a+":"+b);
//SequenceM[11:1:2,hello world:1:2,14:1:4,hello world:1:4,12:1:2,hello world:1:2,15:1:5,hello world:1:5]
forEach3 in interface com.aol.cyclops.sequence.SequenceM<T>stream1 - Nested Stream to iterate overstream2 - Nested Stream to iterate overyieldingFunction - Function with pointers to the current element from both Streams that generates the new elementspublic <R1,R2,R> com.aol.cyclops.sequence.SequenceM<R> forEach3(java.util.function.Function<? super T,? extends java.util.stream.BaseStream<R1,?>> stream1, java.util.function.Function<? super T,java.util.function.Function<? super R1,? extends java.util.stream.BaseStream<R2,?>>> stream2, java.util.function.Function<? super T,java.util.function.Function<? super R1,java.util.function.Function<? super R2,java.lang.Boolean>>> filterFunction, java.util.function.Function<? super T,java.util.function.Function<? super R1,java.util.function.Function<? super R2,? extends R>>> yieldingFunction)
forEach3 in interface com.aol.cyclops.sequence.SequenceM<T>stream1 - Nested Stream to iterate overstream2 - Nested Stream to iterate overfilterFunction - Filter to apply over elements before passing non-filtered values to the yielding functionyieldingFunction - Function with pointers to the current element from both Streams that generates the new elementspublic <R1,R> com.aol.cyclops.sequence.SequenceM<R> forEach2(java.util.function.Function<? super T,? extends java.util.stream.BaseStream<R1,?>> stream1, java.util.function.Function<? super T,java.util.function.Function<? super R1,? extends R>> yieldingFunction)
SequenceM.of(1,2,3)
.forEach2(a->IntStream.range(10,13),
a->b->a+b);
/SequenceM[11,14,12,15,13,16]
forEach2 in interface com.aol.cyclops.sequence.SequenceM<T>stream1 - Nested Stream to iterate overyieldingFunction - Function with pointers to the current element from both Streams that generates the new elementspublic <R1,R> com.aol.cyclops.sequence.SequenceM<R> forEach2(java.util.function.Function<? super T,? extends java.util.stream.BaseStream<R1,?>> stream1, java.util.function.Function<? super T,java.util.function.Function<? super R1,java.lang.Boolean>> filterFunction, java.util.function.Function<? super T,java.util.function.Function<? super R1,? extends R>> yieldingFunction)
SequenceM.of(1,2,3)
.forEach2(a->IntStream.range(10,13),
a->b-> a<3 && b>10,
a->b->a+b);
//SequenceM[14,15]
forEach2 in interface com.aol.cyclops.sequence.SequenceM<T>stream1 - Nested Stream to iterate overfilterFunction - Filter to apply over elements before passing non-filtered values to the yielding functionyieldingFunction - Function with pointers to the current element from both Streams that generates the new elementspublic <X extends java.lang.Throwable> org.reactivestreams.Subscription forEachX(long numberOfElements,
java.util.function.Consumer<? super T> consumer)
forEachX in interface com.aol.cyclops.sequence.reactivestreams.ReactiveStreamsTerminalOperations<T>public <X extends java.lang.Throwable> org.reactivestreams.Subscription forEachXWithError(long numberOfElements,
java.util.function.Consumer<? super T> consumer,
java.util.function.Consumer<? super java.lang.Throwable> consumerError)
forEachXWithError in interface com.aol.cyclops.sequence.reactivestreams.ReactiveStreamsTerminalOperations<T>public <X extends java.lang.Throwable> org.reactivestreams.Subscription forEachXEvents(long numberOfElements,
java.util.function.Consumer<? super T> consumer,
java.util.function.Consumer<? super java.lang.Throwable> consumerError,
java.lang.Runnable onComplete)
forEachXEvents in interface com.aol.cyclops.sequence.reactivestreams.ReactiveStreamsTerminalOperations<T>public <X extends java.lang.Throwable> void forEachWithError(java.util.function.Consumer<? super T> consumerElement, java.util.function.Consumer<? super java.lang.Throwable> consumerError)
forEachWithError in interface com.aol.cyclops.sequence.reactivestreams.ReactiveStreamsTerminalOperations<T>public <X extends java.lang.Throwable> void forEachEvent(java.util.function.Consumer<? super T> consumerElement, java.util.function.Consumer<? super java.lang.Throwable> consumerError, java.lang.Runnable onComplete)
forEachEvent in interface com.aol.cyclops.sequence.reactivestreams.ReactiveStreamsTerminalOperations<T>