T
- public interface CollectionX<T> extends FoldableTraversable<T>, java.util.Collection<T>, Unwrapable, Unit<T>
Modifier and Type | Method and Description |
---|---|
default <U> CollectionX<U> |
cast(java.lang.Class<? extends U> type)
Cast all elements in a reactiveStream to a given type, possibly throwing a
ClassCastException . |
CollectionX<ReactiveSeq<T>> |
combinations()
Generate the combinations based on values in the ExtendedTraversable.
|
CollectionX<ReactiveSeq<T>> |
combinations(int size)
Generate the combinations based on values in the ExtendedTraversable.
|
CollectionX<T> |
combine(java.util.function.BiPredicate<? super T,? super T> predicate,
java.util.function.BinaryOperator<T> op)
Combine two adjacent elements in a traversable using the supplied BinaryOperator
This is a stateful grouping and reduction operation.
|
CollectionX<T> |
cycle(long times)
Convert to a Stream with the values repeated specified times
|
CollectionX<T> |
cycle(Monoid<T> m,
long times)
Convert to a Stream with the result of a reduction operation repeated
specified times
|
CollectionX<T> |
cycleUntil(java.util.function.Predicate<? super T> predicate)
Repeat in a Stream until specified predicate holds
|
CollectionX<T> |
cycleWhile(java.util.function.Predicate<? super T> predicate)
Repeat in a Stream while specified predicate holds
|
CollectionX<T> |
distinct() |
default CollectionX<T> |
drop(long num)
assertThat(ReactiveSeq.of(4,3,6,7).drop(2).toList(),equalTo(Arrays.asList(6,7))); |
CollectionX<T> |
dropRight(int num)
Generate a new Traversable that drops the specified number elements from the take of this Traversable
|
CollectionX<T> |
dropUntil(java.util.function.Predicate<? super T> p)
Generate a new Traversable that drops elements from this Traversable until the predicate holds
|
CollectionX<T> |
dropWhile(java.util.function.Predicate<? super T> p)
Generate a new Traversable that drops elements from this Traversable as long as the predicate holds
|
CollectionX<T> |
eager() |
Evaluation |
evaluation() |
CollectionX<T> |
filter(java.util.function.Predicate<? super T> pred)
Keep only elements for which the supplied predicates hold
e.g.
|
CollectionX<T> |
filterNot(java.util.function.Predicate<? super T> fn)
Remove any elements for which the predicate holds (inverse operation to filter)
e.g.
|
default java.util.Optional<T> |
findAny() |
default java.util.Optional<T> |
findFirst() |
<R> CollectionX<R> |
flatMap(java.util.function.Function<? super T,? extends java.lang.Iterable<? extends R>> mapper)
Perform a flatMap operation on this toX.
|
<R> CollectionX<R> |
flatMapP(java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> fn) |
<R> CollectionX<R> |
flatMapP(int maxConcurecy,
java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> fn) |
default <R> CollectionX<R> |
flatMapS(java.util.function.Function<? super T,? extends java.util.stream.Stream<? extends R>> fn) |
default <R1,R> CollectionX<R> |
forEach2(java.util.function.Function<? super T,? extends java.lang.Iterable<R1>> iterable1,
java.util.function.BiFunction<? super T,? super R1,? extends R> yieldingFunction)
Perform a two level nested internal iteration over this Stream and the
supplied reactiveStream
|
default <R1,R> CollectionX<R> |
forEach2(java.util.function.Function<? super T,? extends java.lang.Iterable<R1>> iterable1,
java.util.function.BiFunction<? super T,? super R1,java.lang.Boolean> filterFunction,
java.util.function.BiFunction<? super T,? super R1,? extends R> yieldingFunction)
Perform a two level nested internal iteration over this Stream and the
supplied reactiveStream
|
default <R1,R2,R> CollectionX<R> |
forEach3(java.util.function.Function<? super T,? extends java.lang.Iterable<R1>> iterable1,
java.util.function.BiFunction<? super T,? super R1,? extends java.lang.Iterable<R2>> iterable2,
Fn3<? super T,? super R1,? super R2,? extends R> yieldingFunction)
Perform a three level nested internal iteration over this Stream and the
supplied streams
|
default <R1,R2,R> CollectionX<R> |
forEach3(java.util.function.Function<? super T,? extends java.lang.Iterable<R1>> iterable1,
java.util.function.BiFunction<? super T,? super R1,? extends java.lang.Iterable<R2>> iterable2,
Fn3<? super T,? super R1,? super R2,java.lang.Boolean> filterFunction,
Fn3<? super T,? super R1,? super R2,? extends R> yieldingFunction)
Perform a three level nested internal iteration over this Stream and the
supplied streams
|
default <R1,R2,R3,R> |
forEach4(java.util.function.Function<? super T,? extends java.lang.Iterable<R1>> iterable1,
java.util.function.BiFunction<? super T,? super R1,? extends java.lang.Iterable<R2>> iterable2,
Fn3<? super T,? super R1,? super R2,? extends java.lang.Iterable<R3>> iterable3,
Fn4<? super T,? super R1,? super R2,? super R3,? extends R> yieldingFunction)
Perform a three level nested internal iteration over this Stream and the
supplied streams
|
default <R1,R2,R3,R> |
forEach4(java.util.function.Function<? super T,? extends java.lang.Iterable<R1>> iterable1,
java.util.function.BiFunction<? super T,? super R1,? extends java.lang.Iterable<R2>> iterable2,
Fn3<? super T,? super R1,? super R2,? extends java.lang.Iterable<R3>> iterable3,
Fn4<? super T,? super R1,? super R2,? super R3,java.lang.Boolean> filterFunction,
Fn4<? super T,? super R1,? super R2,? super R3,? extends R> yieldingFunction)
Perform a three level nested internal iteration over this Stream and the
supplied streams
|
<T1> CollectionX<T1> |
from(java.util.Collection<T1> c)
Conctruct an Extended Collection from a standard Collection
|
static <T> CollectionX<T> |
fromCollection(java.util.Collection<T> col)
Create a CollectionX from the supplied Collection
|
default Maybe<T> |
getAtIndex(int index)
Get the element at the specified index (if it exists)
|
default <K> MapX<K,ListX<T>> |
groupBy(java.util.function.Function<? super T,? extends K> classifier)
Use classifier function to group elements in this Sequence into a Map
|
<K> CollectionX<org.jooq.lambda.tuple.Tuple2<K,ReactiveSeq<T>>> |
grouped(java.util.function.Function<? super T,? extends K> classifier)
Group this Traversable by the provided classifying function and collected by the provided Collector
|
<K,A,D> CollectionX<org.jooq.lambda.tuple.Tuple2<K,D>> |
grouped(java.util.function.Function<? super T,? extends K> classifier,
java.util.stream.Collector<? super T,A,D> downstream)
Group this Traversable by the provided classifying function and collected by the provided Collector
|
CollectionX<ListX<T>> |
grouped(int groupSize)
Group elements in a Stream
|
<C extends java.util.Collection<? super T>> |
grouped(int size,
java.util.function.Supplier<C> supplier)
Batch elements in a Stream by size into a toX created by the
supplied factory
|
CollectionX<ListX<T>> |
groupedStatefullyUntil(java.util.function.BiPredicate<ListX<? super T>,? super T> predicate)
Create Travesable of Lists where
each List is populated while the supplied bipredicate holds.
|
CollectionX<ListX<T>> |
groupedUntil(java.util.function.Predicate<? super T> predicate)
Create a Traversable batched by List, where each batch is populated until
the predicate holds
|
<C extends java.util.Collection<? super T>> |
groupedUntil(java.util.function.Predicate<? super T> predicate,
java.util.function.Supplier<C> factory)
Create a ReactiveSeq batched by a Collection, where each batch is populated
until the predicate holds
|
CollectionX<ListX<T>> |
groupedWhile(java.util.function.Predicate<? super T> predicate)
Create a Traversable batched by List, where each batch is populated while
the predicate holds
|
<C extends java.util.Collection<? super T>> |
groupedWhile(java.util.function.Predicate<? super T> predicate,
java.util.function.Supplier<C> factory)
Create a SequenceM batched by a Collection, where each batch is populated
while the predicate holds
|
default T |
head() |
default HeadAndTail<T> |
headAndTail()
extract head and tail together, where head is expected to be present
Example :
|
CollectionX<T> |
intersperse(T value)
Returns a reactiveStream with a given value interspersed between any two values
of this reactiveStream.
|
boolean |
isEager() |
boolean |
isEmpty() |
boolean |
isLazy() |
boolean |
isMaterialized() |
java.util.Iterator<T> |
iterator() |
CollectionX<T> |
lazy() |
CollectionX<T> |
limit(long num)
assertThat(ReactiveSeq.of(4,3,6,7).limit(2).toList(),equalTo(Arrays.asList(4,3)); |
CollectionX<T> |
limitLast(int num)
Limit results to the last x elements in a SequenceM
|
CollectionX<T> |
limitUntil(java.util.function.Predicate<? super T> p)
Take elements from the Stream until the predicate returns true, after
which all elements are excluded.
|
CollectionX<T> |
limitWhile(java.util.function.Predicate<? super T> p)
Take elements from the Stream while the predicate holds, once the
predicate returns false all subsequent elements are excluded
|
<R> CollectionX<R> |
map(java.util.function.Function<? super T,? extends R> mapper)
Transform this functor using the supplied transformation function
|
default CollectionX<T> |
materialize() |
default CollectionX<T> |
materializeReversed() |
CollectionX<T> |
notNull()
Filter elements retaining only values which are not null
|
CollectionX<T> |
onEmpty(T value)
If this Container instance is zero, create a new instance containing the provided value
|
CollectionX<T> |
onEmptyGet(java.util.function.Supplier<? extends T> supplier)
If this Container instance is zero, create a new instance containing the value returned from the provided Supplier
|
<X extends java.lang.Throwable> |
onEmptyThrow(java.util.function.Supplier<? extends X> supplier)
If this container instance is zero, throw the exception returned by the provided Supplier
|
default CollectionX<T> |
peek(java.util.function.Consumer<? super T> c)
Peek at the current value of this Transformable, without transforming it
|
CollectionX<ReactiveSeq<T>> |
permutations()
Generate the permutations based on values in the ExtendedTraversable.
|
CollectionX<T> |
removeAll(T... values)
Remove all supplied elements from this filterable
|
CollectionX<T> |
removeAllI(java.lang.Iterable<? extends T> it)
Remove all elements in the supplied Iterable from this filterable
|
CollectionX<T> |
removeAllS(java.util.stream.Stream<? extends T> stream)
Remove all elements in the supplied Stream from this filterable
|
CollectionX<T> |
retainAll(T... values)
Retain only the supplied elements in the returned Filters
|
CollectionX<T> |
retainAllI(java.lang.Iterable<? extends T> it)
Retain only the supplied elements in the returned Filters
|
CollectionX<T> |
retainAllS(java.util.stream.Stream<? extends T> seq)
Retain only the supplied elements in the returned Filters
|
CollectionX<T> |
reverse()
Potentially efficient Stream reversal.
|
CollectionX<T> |
scanLeft(Monoid<T> monoid)
Scan left using supplied Monoid
|
<U> CollectionX<U> |
scanLeft(U seed,
java.util.function.BiFunction<? super U,? super T,? extends U> function)
Scan left
|
CollectionX<T> |
scanRight(Monoid<T> monoid)
Scan right
|
<U> CollectionX<U> |
scanRight(U identity,
java.util.function.BiFunction<? super T,? super U,? extends U> combiner)
Scan right
|
CollectionX<T> |
shuffle() |
CollectionX<T> |
shuffle(java.util.Random random) |
default Maybe<T> |
single()
//Optional[1]
ReactiveSeq.of(1).singleUnsafe();
//Optional.zero
ReactiveSeq.of().singleOpional();
//Optional.zero
ReactiveSeq.of(1,2,3).singleUnsafe();
|
default Maybe<T> |
single(java.util.function.Predicate<? super T> predicate) |
default T |
singleUnsafe()
//1
ReactiveSeq.of(1).singleUnsafe();
//UnsupportedOperationException
ReactiveSeq.of().singleUnsafe();
//UnsupportedOperationException
ReactiveSeq.of(1,2,3).singleUnsafe();
|
CollectionX<T> |
skip(long num)
assertThat(ReactiveSeq.of(4,3,6,7).skip(2).toList(),equalTo(Arrays.asList(6,7))); |
CollectionX<T> |
skipLast(int num)
assertThat(ReactiveSeq.of(1,2,3,4,5) .skipLast(2)
.collect(CyclopsCollectors.toList()),equalTo(Arrays.asList(1,2,3)));
|
CollectionX<T> |
skipUntil(java.util.function.Predicate<? super T> p)
Drop elements from the Stream until the predicate returns true, after
which all elements are included
|
CollectionX<T> |
skipWhile(java.util.function.Predicate<? super T> p)
SkipWhile drops elements from the Stream while the predicate holds, once
the predicte returns true all subsequent elements are included *
|
CollectionX<T> |
slice(long from,
long to) |
CollectionX<VectorX<T>> |
sliding(int windowSize)
Create a sliding view over this Sequence
|
CollectionX<VectorX<T>> |
sliding(int windowSize,
int increment)
Create a sliding view over this Sequence
|
CollectionX<T> |
sorted()
assertThat(ReactiveSeq.of(4,3,6,7)).sorted().toList(),equalTo(Arrays.asList(3,4,6,7))); |
CollectionX<T> |
sorted(java.util.Comparator<? super T> c)
assertThat(ReactiveSeq.of(4,3,6,7).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) |
default ReactiveSeq<T> |
stream() |
default CollectionX<T> |
take(long num)
assertThat(ReactiveSeq.of(4,3,6,7).take(2).toList(),equalTo(Arrays.asList(4,3)); |
default Maybe<T> |
takeOne() |
CollectionX<T> |
takeRight(int num)
Generate a new Traversable that takes the specified number elements from the take of this Traversable
|
CollectionX<T> |
takeUntil(java.util.function.Predicate<? super T> p)
Generate a new Traversable that takes elements from this Traversable until the predicate holds
|
CollectionX<T> |
takeWhile(java.util.function.Predicate<? super T> p)
Generate a new Traversable that takes elements from this Traversable as long as the predicate holds
|
default <R> R |
toX(java.util.function.Function<? super CollectionX<T>,? extends R> fn) |
<R> CollectionX<R> |
trampoline(java.util.function.Function<? super T,? extends Trampoline<? extends R>> mapper)
Performs a map operation that can call a recursive method without running out of stack space
|
<R> CollectionX<R> |
unit(R r) |
<U> CollectionX<org.jooq.lambda.tuple.Tuple2<T,U>> |
zip(java.lang.Iterable<? extends U> other)
Zip (merge) this toX with the supplied Iterable into a Colleciton containing Tuples
Each Tuple contains one element from this toX and one from the other
|
<U,R> CollectionX<R> |
zip(java.lang.Iterable<? extends U> other,
java.util.function.BiFunction<? super T,? super U,? extends R> zipper)
Zip (combine) this Zippable with the supplied Iterable using the supplied combining function
|
<S,U> CollectionX<org.jooq.lambda.tuple.Tuple3<T,S,U>> |
zip3(java.lang.Iterable<? extends S> second,
java.lang.Iterable<? extends U> third)
zip 3 Streams into one
|
<T2,T3,T4> CollectionX<org.jooq.lambda.tuple.Tuple4<T,T2,T3,T4>> |
zip4(java.lang.Iterable<? extends T2> second,
java.lang.Iterable<? extends T3> third,
java.lang.Iterable<? extends T4> fourth)
zip 4 Streams into 1
|
<U> CollectionX<org.jooq.lambda.tuple.Tuple2<T,U>> |
zipS(java.util.stream.Stream<? extends U> other)
Zip (combine) this Zippable with the supplied Stream combining both into a Tuple2
|
<U,R> CollectionX<R> |
zipS(java.util.stream.Stream<? extends U> other,
java.util.function.BiFunction<? super T,? super U,? extends R> zipper)
Zip (combine) this Zippable with the supplied Stream, using the supplied combining function
|
CollectionX<org.jooq.lambda.tuple.Tuple2<T,java.lang.Long>> |
zipWithIndex()
Add an index to the current Stream
|
asFunction, foldFuture, foldLazy, foldTry, forEach, forEach, forEach, forEach, forEach, forEachSubscribe, forEachSubscribe, forEachSubscribe, runFuture, runLazy, seq, toListX, toSetX, visit
allMatch, anyMatch, collect, collectors, commonPrefix, commonSuffix, count, count, countDistinct, countDistinct, countDistinctBy, countDistinctBy, max, maxBy, min, minBy, mode, noneMatch, sum, sumDouble, sumInt, sumLong, to, toList, toMap, toMap, toSet, toString, toString
endsWith, endsWithIterable, firstValue, foldLeft, foldLeft, foldLeft, foldLeft, foldRight, foldRight, foldRight, foldRightMapToType, get, join, join, join, mapReduce, mapReduce, print, print, printErr, printOut, reduce, reduce, reduce, reduce, reduce, reduce, reduce, schedule, scheduleFixedDelay, scheduleFixedRate, startsWith, startsWithIterable, xMatch
append, append, combine, deleteBetween, insertAt, insertAtS, mapToDouble, mapToInt, mapToLong, prepend, prepend, prependS, recover, recover, subscribe, traversable, unitIterator, zip, zip3, zip4, zipP, zipP, zipWith, zipWithP, zipWithS
retry, retry
groupedStatefullyUntilT, groupedT, groupedUntilT, groupedWhileT, slidingT, slidingT
fixedDelay, onePer, xPer
add, addAll, clear, contains, containsAll, equals, hashCode, parallelStream, remove, removeAll, removeIf, retainAll, size, spliterator, toArray, toArray
unwrap, unwrapIfInstance, unwrapNested
boolean isLazy()
boolean isEager()
Evaluation evaluation()
CollectionX<T> lazy()
CollectionX<T> eager()
default <R> R toX(java.util.function.Function<? super CollectionX<T>,? extends R> fn)
java.util.Iterator<T> iterator()
boolean isEmpty()
isEmpty
in interface java.util.Collection<T>
default <R> CollectionX<R> flatMapS(java.util.function.Function<? super T,? extends java.util.stream.Stream<? extends R>> fn)
<R> CollectionX<R> flatMapP(java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> fn)
<R> CollectionX<R> flatMapP(int maxConcurecy, java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> fn)
static <T> CollectionX<T> fromCollection(java.util.Collection<T> col)
col
- <R> CollectionX<R> unit(R r)
<C extends java.util.Collection<? super T>> CollectionX<C> grouped(int size, java.util.function.Supplier<C> supplier)
Traversable
assertThat(ReactiveSeq.of(1,1,1,1,1,1)
.batchBySize(3,()->new TreeSet<>())
.toList()
.get(0)
.size(),is(1));
grouped
in interface Traversable<T>
size
- batch sizesupplier
- Collection factoryCollectionX<ListX<T>> groupedUntil(java.util.function.Predicate<? super T> predicate)
Traversable
assertThat(ReactiveSeq.of(1,2,3,4,5,6)
.groupedUntil(i->i%3==0)
.toList()
.size(),equalTo(2));
groupedUntil
in interface Traversable<T>
predicate
- Batch until predicate holds, applyHKT open next batchCollectionX<ListX<T>> groupedStatefullyUntil(java.util.function.BiPredicate<ListX<? super T>,? super T> predicate)
Traversable
assertThat(ReactiveSeq.of(1,2,3,4,5,6)
.groupedStatefullyUntil((s,i)->s.contains(4) ? true : false)
.toList().size(),equalTo(5));
groupedStatefullyUntil
in interface Traversable<T>
predicate
- Window while trueCollectionX<ListX<T>> groupedWhile(java.util.function.Predicate<? super T> predicate)
Traversable
assertThat(ReactiveSeq.of(1,2,3,4,5,6)
.groupedWhile(i->i%3!=0)
.toList().size(),equalTo(2));
groupedWhile
in interface Traversable<T>
predicate
- Batch while predicate holds, applyHKT open next batch<C extends java.util.Collection<? super T>> CollectionX<C> groupedWhile(java.util.function.Predicate<? super T> predicate, java.util.function.Supplier<C> factory)
Traversable
assertThat(ReactiveSeq.of(1,2,3,4,5,6)
.batchWhile(i->i%3!=0)
.toList()
.size(),equalTo(2));
groupedWhile
in interface Traversable<T>
predicate
- Batch while predicate holds, applyHKT open next batchfactory
- Collection factory<C extends java.util.Collection<? super T>> CollectionX<C> groupedUntil(java.util.function.Predicate<? super T> predicate, java.util.function.Supplier<C> factory)
Traversable
ReactiveSeq.of(1,2,3,4,5,6)
.groupedUntil(i->i%3!=0)
.toList()
//2
groupedUntil
in interface Traversable<T>
predicate
- Batch until predicate holds, applyHKT open next batchfactory
- Collection factoryCollectionX<T> intersperse(T value)
Traversable
intersperse
in interface Traversable<T>
CollectionX<T> shuffle()
shuffle
in interface Traversable<T>
CollectionX<T> shuffle(java.util.Random random)
shuffle
in interface Traversable<T>
<S,U> CollectionX<org.jooq.lambda.tuple.Tuple3<T,S,U>> zip3(java.lang.Iterable<? extends S> second, java.lang.Iterable<? extends U> third)
Traversable
List<Tuple3<Integer, Integer, Character>> list = of(1, 2, 3, 4, 5, 6).zip3(of(100, 200, 300, 400), of('a', 'b', 'c')).collect(CyclopsCollectors.toList());
// [[1,100,'a'],[2,200,'b'],[3,300,'c']]
<T2,T3,T4> CollectionX<org.jooq.lambda.tuple.Tuple4<T,T2,T3,T4>> zip4(java.lang.Iterable<? extends T2> second, java.lang.Iterable<? extends T3> third, java.lang.Iterable<? extends T4> fourth)
Traversable
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(CyclopsCollectors.toList());
// [[1,100,'a',"hello"],[2,200,'b',"world"]]
CollectionX<T> limitWhile(java.util.function.Predicate<? super T> p)
Traversable
assertThat(ReactiveSeq.of(4,3,6,7).sorted().limitWhile(i->i<6).toList(),equalTo(Arrays.asList(3,4)));
limitWhile
in interface Traversable<T>
p
- Limit while predicate is trueCollectionX<T> limitUntil(java.util.function.Predicate<? super T> p)
Traversable
assertThat(ReactiveSeq.of(4,3,6,7).limitUntil(i->i==6).toList(),equalTo(Arrays.asList(4,3)));
limitUntil
in interface Traversable<T>
p
- Limit until predicate is trueCollectionX<T> limitLast(int num)
Traversable
assertThat(ReactiveSeq.of(1,2,3,4,5)
.limitLast(2)
.collect(CyclopsCollectors.toList()),equalTo(Arrays.asList(4,5)));
limitLast
in interface Traversable<T>
num
- of elements to return (last elements)CollectionX<T> skipWhile(java.util.function.Predicate<? super T> p)
Traversable
assertThat(ReactiveSeq.of(4,3,6,7).sorted().skipWhile(i->i<6).toList(),equalTo(Arrays.asList(6,7)));
skipWhile
in interface Traversable<T>
p
- Predicate to skip while trueCollectionX<T> skipUntil(java.util.function.Predicate<? super T> p)
Traversable
assertThat(ReactiveSeq.of(4,3,6,7).skipUntil(i->i==6).toList(),equalTo(Arrays.asList(6,7)));
skipUntil
in interface Traversable<T>
p
- Predicate to skip until trueCollectionX<T> skipLast(int num)
Traversable
skipLast
in interface Traversable<T>
CollectionX<T> cycle(long times)
Traversable
ReactiveSeq.of(1,2,2)
.cycle(3)
.collect(CyclopsCollectors.toList());
//List[1,2,2,1,2,2,1,2,2]
cycle
in interface Traversable<T>
times
- Times values should be repeated within a StreamCollectionX<T> cycle(Monoid<T> m, long times)
Traversable
List<Integer> list = ReactiveSeq.of(1,2,2))
.cycle(Reducers.toCountInt(),3)
.collect(CyclopsCollectors.toList());
//List[3,3,3];
cycle
in interface Traversable<T>
m
- Monoid to be used in reductiontimes
- Number of times value should be repeatedCollectionX<T> cycleWhile(java.util.function.Predicate<? super T> predicate)
Traversable
MutableInt count = MutableInt.of(0);
ReactiveSeq.of(1, 2, 2).cycleWhile(next -> count++ < 6).collect(CyclopsCollectors.toList());
// List(1,2,2,1,2,2)
cycleWhile
in interface Traversable<T>
predicate
- repeat while trueCollectionX<T> cycleUntil(java.util.function.Predicate<? super T> predicate)
Traversable
MutableInt count =MutableInt.of(0);
ReactiveSeq.of(1,2,2)
.cycleUntil(next -> count.get()>6)
.peek(i-> count.mutate(i->i+1))
.collect(CyclopsCollectors.toList());
//List[1,2,2,1,2,2,1]
cycleUntil
in interface Traversable<T>
predicate
- repeat while trueCollectionX<T> onEmpty(T value)
OnEmpty
CollectionX<T> onEmptyGet(java.util.function.Supplier<? extends T> supplier)
OnEmpty
onEmptyGet
in interface OnEmpty<T>
onEmptyGet
in interface Traversable<T>
supplier
- to determine new value for container<X extends java.lang.Throwable> CollectionX<T> onEmptyThrow(java.util.function.Supplier<? extends X> supplier)
OnEmpty
onEmptyThrow
in interface OnEmpty<T>
onEmptyThrow
in interface Traversable<T>
supplier
- to create exception fromdefault ReactiveSeq<T> stream()
stream
in interface java.util.Collection<T>
stream
in interface ExtendedTraversable<T>
stream
in interface FoldableTraversable<T>
stream
in interface Folds<T>
stream
in interface Sequential<T>
stream
in interface TransformerTraversable<T>
stream
in interface Traversable<T>
boolean isMaterialized()
default CollectionX<T> materialize()
default CollectionX<T> materializeReversed()
default Maybe<T> getAtIndex(int index)
index
- to look up elementdefault HeadAndTail<T> headAndTail()
FoldableTraversable
ReactiveSeq<String> helloWorld = ReactiveSeq.Of("hello","world","last");
HeadAndTail<String> headAndTail = helloWorld.headAndTail();
String head = headAndTail.head();
//head == "hello"
ReactiveSeq<String> tail = headAndTail.tail();
//["world","last]
headAndTail
in interface FoldableTraversable<T>
default T head()
<T1> CollectionX<T1> from(java.util.Collection<T1> c)
c
- Collection to extendCollectionX<T> reverse()
Traversable
assertThat( of(1, 2, 3).reverse().toList(),
equalTo(asList(3, 2, 1)));
reverse
in interface Traversable<T>
default T singleUnsafe()
Folds
//1
ReactiveSeq.of(1).singleUnsafe();
//UnsupportedOperationException
ReactiveSeq.of().singleUnsafe();
//UnsupportedOperationException
ReactiveSeq.of(1,2,3).singleUnsafe();
singleUnsafe
in interface Folds<T>
default Maybe<T> single()
Folds
//Optional[1]
ReactiveSeq.of(1).singleUnsafe();
//Optional.zero
ReactiveSeq.of().singleOpional();
//Optional.zero
ReactiveSeq.of(1,2,3).singleUnsafe();
default java.util.Optional<T> findFirst()
default java.util.Optional<T> findAny()
default <K> MapX<K,ListX<T>> groupBy(java.util.function.Function<? super T,? extends K> classifier)
Folds
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());
CollectionX<T> filter(java.util.function.Predicate<? super T> pred)
Filters
of(1,2,3).filter(i->i>2);
//[3]
<R> CollectionX<R> map(java.util.function.Function<? super T,? extends R> mapper)
Transformable
of(1,2,3).map(i->i*2)
//[2,4,6]
map
in interface FilterableTransformable<T>
map
in interface Transformable<T>
mapper
- Transformation function<R> CollectionX<R> flatMap(java.util.function.Function<? super T,? extends java.lang.Iterable<? extends R>> mapper)
mapper
- Transformation function to be applied (and flattened)CollectionX<T> limit(long num)
Traversable
assertThat(ReactiveSeq.of(4,3,6,7).limit(2).toList(),equalTo(Arrays.asList(4,3));
limit
in interface Traversable<T>
num
- Limit element size to numdefault CollectionX<T> take(long num)
Traversable
assertThat(ReactiveSeq.of(4,3,6,7).take(2).toList(),equalTo(Arrays.asList(4,3));
take
in interface Traversable<T>
num
- Limit element size to numdefault CollectionX<T> drop(long num)
Traversable
assertThat(ReactiveSeq.of(4,3,6,7).drop(2).toList(),equalTo(Arrays.asList(6,7)));
drop
in interface Traversable<T>
num
- Number of elemenets to dropCollectionX<T> skip(long num)
Traversable
assertThat(ReactiveSeq.of(4,3,6,7).skip(2).toList(),equalTo(Arrays.asList(6,7)));
skip
in interface Traversable<T>
num
- Number of elemenets to skipCollectionX<T> takeWhile(java.util.function.Predicate<? super T> p)
Traversable
ListX.of(1,2,3).takeWhile(i<3);
//[1,2]
takeWhile
in interface Traversable<T>
p
- Predicate to determine when values should be takenCollectionX<T> dropWhile(java.util.function.Predicate<? super T> p)
Traversable
ListX.of(1,2,3).dropWhile(i<3);
//[3]
dropWhile
in interface Traversable<T>
p
- Predicate to determine when values should be droppedCollectionX<T> takeUntil(java.util.function.Predicate<? super T> p)
Traversable
ListX.of(1,2,3).takeUntil(i<2);
//[1,2]
takeUntil
in interface Traversable<T>
p
- Predicate to determine when values should be taken untilCollectionX<T> dropUntil(java.util.function.Predicate<? super T> p)
Traversable
ListX.of(1,2,3).dropUntil(i>2);
//[3]
dropUntil
in interface Traversable<T>
p
- Predicate to determine when values should be droppedCollectionX<T> dropRight(int num)
Traversable
ListX.of(1,2,3).dropRight(2);
//[1]
dropRight
in interface Traversable<T>
num
- Drop this number of elements from the take of this TraversableCollectionX<T> takeRight(int num)
Traversable
ListX.of(1,2,3).takeRight(2);
//[2,3]
takeRight
in interface Traversable<T>
num
- Take this number of elements from the take of this Traversabledefault CollectionX<T> peek(java.util.function.Consumer<? super T> c)
Transformable
of(1,2,3).map(System.out::println)
1
2
3
peek
in interface Transformable<T>
c
- Consumer that recieves each element from this TransformableCollectionX<ListX<T>> grouped(int groupSize)
Traversable
List<List<Integer>> list = ReactiveSeq.of(1, 2, 3, 4, 5, 6).grouped(3).collect(CyclopsCollectors.toList());
assertThat(list.get(0), hasItems(1, 2, 3));
assertThat(list.get(1), hasItems(4, 5, 6));
grouped
in interface Traversable<T>
groupSize
- Size of each Group<K,A,D> CollectionX<org.jooq.lambda.tuple.Tuple2<K,D>> grouped(java.util.function.Function<? super T,? extends K> classifier, java.util.stream.Collector<? super T,A,D> downstream)
Traversable
grouped
in interface Traversable<T>
classifier
- Grouping functiondownstream
- Collector to create the grouping toX<K> CollectionX<org.jooq.lambda.tuple.Tuple2<K,ReactiveSeq<T>>> grouped(java.util.function.Function<? super T,? extends K> classifier)
Traversable
grouped
in interface Traversable<T>
classifier
- Grouping functionCollectionX<T> combine(java.util.function.BiPredicate<? super T,? super T> predicate, java.util.function.BinaryOperator<T> op)
Traversable
ReactiveSeq.of(1,1,2,3)
.combine((a, b)->a.equals(b),SemigroupK.intSum)
.listX()
//ListX(3,4)
combine
in interface Traversable<T>
predicate
- Test to see if two neighbours should be joined. The first parameter to the bi-predicate is the currently
accumulated result and the second is the next elementop
- BinaryOperator to combine neighbours<U> CollectionX<org.jooq.lambda.tuple.Tuple2<T,U>> zip(java.lang.Iterable<? extends U> other)
<U,R> CollectionX<R> zip(java.lang.Iterable<? extends U> other, java.util.function.BiFunction<? super T,? super U,? extends R> zipper)
Zippable
<U,R> CollectionX<R> zipS(java.util.stream.Stream<? extends U> other, java.util.function.BiFunction<? super T,? super U,? extends R> zipper)
Zippable
<U> CollectionX<org.jooq.lambda.tuple.Tuple2<T,U>> zipS(java.util.stream.Stream<? extends U> other)
Traversable
CollectionX<org.jooq.lambda.tuple.Tuple2<T,java.lang.Long>> zipWithIndex()
Traversable
assertEquals(asList(new Tuple2("a", 0L), new Tuple2("b", 1L)), of("a", "b").zipWithIndex().toList());
zipWithIndex
in interface Traversable<T>
CollectionX<VectorX<T>> sliding(int windowSize)
Traversable
List<List<Integer>> list = ReactiveSeq.of(1, 2, 3, 4, 5, 6).sliding(2).collect(CyclopsCollectors.toList());
assertThat(list.get(0), hasItems(1, 2));
assertThat(list.get(1), hasItems(2, 3));
sliding
in interface Traversable<T>
windowSize
- Size of sliding windowCollectionX<VectorX<T>> sliding(int windowSize, int increment)
Traversable
List<List<Integer>> list = ReactiveSeq.of(1, 2, 3, 4, 5, 6).sliding(3, 2).collect(CyclopsCollectors.toList());
assertThat(list.get(0), hasItems(1, 2, 3));
assertThat(list.get(1), hasItems(3, 4, 5));
sliding
in interface Traversable<T>
windowSize
- number of elements in each batchincrement
- for each windowCollectionX<T> scanLeft(Monoid<T> monoid)
Traversable
assertEquals(asList("", "a", "ab", "abc"),ReactiveSeq.of("a", "b", "c")
.scanLeft(Reducers.toString("")).toList());
scanLeft
in interface Traversable<T>
<U> CollectionX<U> scanLeft(U seed, java.util.function.BiFunction<? super U,? super T,? extends U> function)
Traversable
assertThat(of("a", "b", "c").scanLeft("", String::concat).toList().size(),
is(4));
scanLeft
in interface Traversable<T>
CollectionX<T> scanRight(Monoid<T> monoid)
Traversable
assertThat(of("a", "b", "c").scanRight(Monoid.of("", String::concat)).toList().size(),
is(asList("", "c", "bc", "abc").size()));
scanRight
in interface Traversable<T>
<U> CollectionX<U> scanRight(U identity, java.util.function.BiFunction<? super T,? super U,? extends U> combiner)
Traversable
assertThat(of("a", "ab", "abc").map(str->str.length()).scanRight(0, (t, u) -> u + t).toList().size(),
is(asList(0, 3, 5, 6).size()));
scanRight
in interface Traversable<T>
CollectionX<T> distinct()
distinct
in interface Traversable<T>
CollectionX<T> sorted()
Traversable
assertThat(ReactiveSeq.of(4,3,6,7)).sorted().toList(),equalTo(Arrays.asList(3,4,6,7)));
sorted
in interface Traversable<T>
CollectionX<T> removeAllS(java.util.stream.Stream<? extends T> stream)
IterableFilterable
removeAllS
in interface IterableFilterable<T>
stream
- of elements to removeCollectionX<T> removeAllI(java.lang.Iterable<? extends T> it)
IterableFilterable
removeAllI
in interface IterableFilterable<T>
it
- an Iterable of elements to removeCollectionX<T> removeAll(T... values)
IterableFilterable
removeAll
in interface IterableFilterable<T>
values
- to removeCollectionX<T> retainAllI(java.lang.Iterable<? extends T> it)
IterableFilterable
retainAllI
in interface IterableFilterable<T>
it
- Iterable of elements to retainCollectionX<T> retainAllS(java.util.stream.Stream<? extends T> seq)
IterableFilterable
retainAllS
in interface IterableFilterable<T>
seq
- of elements to retainCollectionX<T> retainAll(T... values)
IterableFilterable
retainAll
in interface IterableFilterable<T>
values
- elements to retainCollectionX<T> filterNot(java.util.function.Predicate<? super T> fn)
Filters
of(1,2,3).filter(i->i>2);
//[1,2]
CollectionX<T> notNull()
Filters
of(1,2,null,4).nonNull();
//[1,2,4]
<R> CollectionX<R> trampoline(java.util.function.Function<? super T,? extends Trampoline<? extends R>> mapper)
Transformable
ReactiveSeq.of(10,20,30,40)
.trampoline(i-> fibonacci(i))
.forEach(System.out::println);
Trampoline<Long> fibonacci(int i){
return fibonacci(i,1,0);
}
Trampoline<Long> fibonacci(int n, long a, long b) {
return n == 0 ? Trampoline.done(b) : Trampoline.more( ()->fibonacci(n-1, a+b, a));
}
55
6765
832040
102334155
ReactiveSeq.of(10_000,200_000,3_000_000,40_000_000)
.trampoline(i-> fibonacci(i))
.forEach(System.out::println);
completes successfully
trampoline
in interface Transformable<T>
mapper
- TCO Transformation functiondefault <R1,R2,R3,R> CollectionX<R> forEach4(java.util.function.Function<? super T,? extends java.lang.Iterable<R1>> iterable1, java.util.function.BiFunction<? super T,? super R1,? extends java.lang.Iterable<R2>> iterable2, Fn3<? super T,? super R1,? super R2,? extends java.lang.Iterable<R3>> iterable3, Fn4<? super T,? super R1,? super R2,? super R3,? extends R> yieldingFunction)
//collectionX [1,2]
collectionX.forEach4(a->ListX.range(10,13),
(a,b)->ListX.of(""+(a+b),"hello world"),
(a,b,c)->ListX.of(a,b,c)),
(a,b,c,d)->c+":"a+":"+b);
iterable1
- Nested Stream to iterate overiterable2
- Nested Stream to iterate overiterable3
- Nested Stream to iterate overyieldingFunction
- Function with pointers to the current element from both
Streams that generates the new elementsdefault <R1,R2,R3,R> CollectionX<R> forEach4(java.util.function.Function<? super T,? extends java.lang.Iterable<R1>> iterable1, java.util.function.BiFunction<? super T,? super R1,? extends java.lang.Iterable<R2>> iterable2, Fn3<? super T,? super R1,? super R2,? extends java.lang.Iterable<R3>> iterable3, Fn4<? super T,? super R1,? super R2,? super R3,java.lang.Boolean> filterFunction, Fn4<? super T,? super R1,? super R2,? super R3,? extends R> yieldingFunction)
//collectionX [1,2,3]
collectionX.forEach4(a->ListX.range(10,13),
(a,b)->ListX.of(""+(a+b),"hello world"),
(a,b,c)->ListX.of(a,b,c),
(a,b,c,d)-> c!=3,
(a,b,c)->c+":"a+":"+b);
iterable1
- Nested Stream to iterate overiterable2
- Nested Stream to iterate overiterable3
- Nested Stream to iterate overfilterFunction
- Filter to applyHKT 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 elementsdefault <R1,R2,R> CollectionX<R> forEach3(java.util.function.Function<? super T,? extends java.lang.Iterable<R1>> iterable1, java.util.function.BiFunction<? super T,? super R1,? extends java.lang.Iterable<R2>> iterable2, Fn3<? super T,? super R1,? super R2,? extends R> yieldingFunction)
//collectionX [1,2]
collectionX.forEach3(a->IntStream.range(10,13),
(a,b)->Stream.of(""+(a+b),"hello world"),
(a,b,c)->c+":"a+":"+b);
//CollectionX[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]
iterable1
- Nested Stream to iterate overiterable2
- Nested Stream to iterate overyieldingFunction
- Function with pointers to the current element from both
Streams that generates the new elementsdefault <R1,R2,R> CollectionX<R> forEach3(java.util.function.Function<? super T,? extends java.lang.Iterable<R1>> iterable1, java.util.function.BiFunction<? super T,? super R1,? extends java.lang.Iterable<R2>> iterable2, Fn3<? super T,? super R1,? super R2,java.lang.Boolean> filterFunction, Fn3<? super T,? super R1,? super R2,? extends R> yieldingFunction)
//collectionX [1,2,3]
collectionX.forEach3(a->ListX.range(10,13),
(a,b)->Stream.of(""+(a+b),"hello world"),
(a,b,c)-> c!=3,
(a,b,c)->c+":"a+":"+b);
//CollectionX[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]
iterable1
- Nested Stream to iterate overiterable2
- Nested Stream to iterate overfilterFunction
- Filter to applyHKT 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 elementsdefault <R1,R> CollectionX<R> forEach2(java.util.function.Function<? super T,? extends java.lang.Iterable<R1>> iterable1, java.util.function.BiFunction<? super T,? super R1,? extends R> yieldingFunction)
//collectionX [1,2,3]
collectionX.of(1,2,3).forEach2(a->ListX.range(10,13),
(a,b)->a+b);
//ReactiveSeq[11,14,12,15,13,16]
iterable1
- Nested Iterable to iterate overyieldingFunction
- Function with pointers to the current element from both
Streams that generates the new elementsdefault <R1,R> CollectionX<R> forEach2(java.util.function.Function<? super T,? extends java.lang.Iterable<R1>> iterable1, java.util.function.BiFunction<? super T,? super R1,java.lang.Boolean> filterFunction, java.util.function.BiFunction<? super T,? super R1,? extends R> yieldingFunction)
//collectionX [1,2,3]
collectionX.of(1,2,3).forEach2(a->ListX.range(10,13),
(a,b)-> a<3 && b>10,
(a,b)->a+b);
//CollectionX[14,15]
iterable1
- Nested Stream to iterate overfilterFunction
- Filter to applyHKT 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 elementsCollectionX<T> slice(long from, long to)
slice
in interface Traversable<T>
<U extends java.lang.Comparable<? super U>> CollectionX<T> sorted(java.util.function.Function<? super T,? extends U> function)
sorted
in interface Traversable<T>
CollectionX<T> sorted(java.util.Comparator<? super T> c)
Traversable
assertThat(ReactiveSeq.of(4,3,6,7).sorted((a,b) -> b-a).toList(),equalTo(Arrays.asList(7,6,4,3)));
sorted
in interface Traversable<T>
c
- Compartor to sort withCollectionX<ReactiveSeq<T>> permutations()
ExtendedTraversable
permutations
in interface ExtendedTraversable<T>
CollectionX<ReactiveSeq<T>> combinations(int size)
ExtendedTraversable
ExtendedTraversable<Integer> reactiveStream = ReactiveSeq.of(1,2,3);
reactiveStream.combinations(2)
//ReactiveSeq[ReactiveSeq[1,2],ReactiveSeq[1,3],ReactiveSeq[2,3]]
combinations
in interface ExtendedTraversable<T>
size
- of combinationsCollectionX<ReactiveSeq<T>> combinations()
ExtendedTraversable
ReactiveSeq.of(1,2,3).combinations()
//ReactiveSeq[ReactiveSeq[],ReactiveSeq[1],ReactiveSeq[2],ReactiveSeq[3].ReactiveSeq[1,2],ReactiveSeq[1,3],ReactiveSeq[2,3]
,ReactiveSeq[1,2,3]]
combinations
in interface ExtendedTraversable<T>
default <U> CollectionX<U> cast(java.lang.Class<? extends U> type)
Transformable
ClassCastException
.
// ClassCastException ReactiveSeq.of(1, "a", 2, "b", 3).cast(Integer.class)cast
in interface Transformable<T>