public interface LazyCollectionX<T> extends FluentCollectionX<T>
Modifier and Type | Method and Description |
---|---|
default LazyCollectionX<T> |
append(T... values)
Append values toNested the take of this ReactiveSeq
|
default LazyCollectionX<T> |
append(T value) |
default <U> LazyCollectionX<U> |
cast(java.lang.Class<? extends U> type)
Cast all elements in a reactiveStream toNested a given type, possibly throwing a
ClassCastException . |
default LazyCollectionX<ReactiveSeq<T>> |
combinations()
Generate the combinations based on values in the ExtendedTraversable.
|
default LazyCollectionX<ReactiveSeq<T>> |
combinations(int size)
Generate the combinations based on values in the ExtendedTraversable.
|
default LazyCollectionX<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.
|
default LazyCollectionX<T> |
cycle(long times)
Convert toNested a Stream with the values repeated specified times
|
default LazyCollectionX<T> |
cycle(Monoid<T> m,
long times)
Convert toNested a Stream with the result of a reduction operation repeated
specified times
|
default LazyCollectionX<T> |
cycleUntil(java.util.function.Predicate<? super T> predicate)
Repeat in a Stream until specified predicate holds
|
default LazyCollectionX<T> |
cycleWhile(java.util.function.Predicate<? super T> predicate)
Repeat in a Stream while specified predicate holds
|
default LazyCollectionX<T> |
deleteBetween(int start,
int end)
Delete elements between given indexes in a Stream
|
default LazyCollectionX<T> |
distinct() |
default LazyCollectionX<T> |
dropRight(int num)
Generate a new Traversable that drops the specified number elements from the take of this Traversable
|
default LazyCollectionX<T> |
dropUntil(java.util.function.Predicate<? super T> p)
Generate a new Traversable that drops elements from this Traversable until the predicate holds
|
default LazyCollectionX<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
|
default LazyCollectionX<T> |
filter(java.util.function.Predicate<? super T> pred)
Keep only elements for which the supplied predicates hold
e.g.
|
default LazyCollectionX<T> |
filterNot(java.util.function.Predicate<? super T> fn)
Remove any elements for which the predicate holds (inverse operation toNested filter)
e.g.
|
default <R> CollectionX<R> |
flatMap(java.util.function.Function<? super T,? extends java.lang.Iterable<? extends R>> mapper)
Perform a flatMap operation on this collection.
|
default <R> LazyCollectionX<R> |
flatMapP(java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> fn) |
default <R> LazyCollectionX<R> |
flatMapS(java.util.function.Function<? super T,? extends java.util.stream.Stream<? extends R>> fn) |
<X> LazyCollectionX<X> |
fromStream(ReactiveSeq<X> stream) |
default <K> LazyCollectionX<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
|
default <K,A,D> LazyCollectionX<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
|
default LazyCollectionX<ListX<T>> |
grouped(int groupSize)
Group elements in a Stream
|
default <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 collection created by the
supplied factory
|
default LazyCollectionX<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.
|
default LazyCollectionX<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
|
default <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
|
default LazyCollectionX<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
|
default <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 LazyCollectionX<T> |
insertAt(int pos,
T... values)
Insert data into a reactiveStream at given position
|
default LazyCollectionX<T> |
insertAtS(int pos,
java.util.stream.Stream<T> stream)
Insert a Stream into the middle of this reactiveStream at the specified position
|
default LazyCollectionX<T> |
intersperse(T value)
Returns a reactiveStream with a given value interspersed between any two values
of this reactiveStream.
|
default LazyCollectionX<T> |
limit(long num)
assertThat(ReactiveSeq.of(4,3,6,7).limit(2).toList(),equalTo(Arrays.asList(4,3)); |
default LazyCollectionX<T> |
limitLast(int num)
Limit results toNested the last x elements in a SequenceM
|
default LazyCollectionX<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.
|
default LazyCollectionX<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
|
default <R> CollectionX<R> |
map(java.util.function.Function<? super T,? extends R> mapper)
Transform this functor using the supplied transformation function
|
default LazyCollectionX<T> |
minus(java.lang.Object e)
Remove the specified element from this collection
|
default LazyCollectionX<T> |
minusAll(java.util.Collection<?> list)
Remove all the specified elements from this collection
|
default LazyCollectionX<T> |
notNull()
Filter elements retaining only values which are not null
|
default <U> LazyCollectionX<U> |
ofType(java.lang.Class<? extends U> type)
Keep only those elements in a reactiveStream that are of a given type.
|
default LazyCollectionX<T> |
onEmpty(T value)
If this Container instance is empty, create a new instance containing the provided value
|
default LazyCollectionX<T> |
onEmptyGet(java.util.function.Supplier<? extends T> supplier)
If this Container instance is empty, create a new instance containing the value returned from the provided Supplier
|
default <X extends java.lang.Throwable> |
onEmptyThrow(java.util.function.Supplier<? extends X> supplier)
If this container instance is empty, throw the exception returned by the provided Supplier
|
default LazyCollectionX<ReactiveSeq<T>> |
permutations()
Generate the permutations based on values in the ExtendedTraversable.
|
default LazyCollectionX<T> |
plus(T e)
Add an element to this Collection
|
default LazyCollectionX<T> |
plusAll(java.util.Collection<? extends T> list)
Add all supplied elements to this Collection
|
default LazyCollectionX<T> |
prepend(T... values)
Prepend given values toNested the skip of the Stream
|
default LazyCollectionX<T> |
prepend(T value) |
default LazyCollectionX<T> |
prependS(java.util.stream.Stream<? extends T> stream)
Prepend Stream toNested this ReactiveSeq
|
default <U> U |
reduce(U identity,
java.util.function.BiFunction<U,? super T,U> accumulator)
An equivalent function toNested
Stream.reduce(Object, BinaryOperator) |
default LazyCollectionX<T> |
removeAll(T... values)
Remove all supplied elements from this filterable
|
default LazyCollectionX<T> |
removeAllI(java.lang.Iterable<? extends T> it)
Remove all elements in the supplied Iterable from this filterable
|
default LazyCollectionX<T> |
removeAllS(java.util.stream.Stream<? extends T> stream)
Remove all elements in the supplied Stream from this filterable
|
default LazyCollectionX<T> |
retainAll(T... values)
Retain only the supplied elements in the returned Filters
|
default LazyCollectionX<T> |
retainAllI(java.lang.Iterable<? extends T> it)
Retain only the supplied elements in the returned Filters
|
default LazyCollectionX<T> |
retainAllS(java.util.stream.Stream<? extends T> stream)
Retain only the supplied elements in the returned Filters
|
default LazyCollectionX<T> |
reverse()
Potentially efficient Stream reversal.
|
default LazyCollectionX<T> |
scanLeft(Monoid<T> monoid)
Scan left using supplied Monoid
|
default <U> LazyCollectionX<U> |
scanLeft(U seed,
java.util.function.BiFunction<? super U,? super T,? extends U> function)
Scan left
|
default LazyCollectionX<T> |
scanRight(Monoid<T> monoid)
Scan right
|
default <U> LazyCollectionX<U> |
scanRight(U identity,
java.util.function.BiFunction<? super T,? super U,? extends U> combiner)
Scan right
|
default LazyCollectionX<T> |
shuffle() |
default LazyCollectionX<T> |
shuffle(java.util.Random random) |
default LazyCollectionX<T> |
skip(long num)
assertThat(ReactiveSeq.of(4,3,6,7).skip(2).toList(),equalTo(Arrays.asList(6,7))); |
default LazyCollectionX<T> |
skipLast(int num)
assertThat(ReactiveSeq.of(1,2,3,4,5) .skipLast(2)
.collect(CyclopsCollectors.toList()),equalTo(Arrays.asList(1,2,3)));
|
default LazyCollectionX<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
|
default LazyCollectionX<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 *
|
default LazyCollectionX<T> |
slice(long from,
long to) |
default LazyCollectionX<VectorX<T>> |
sliding(int windowSize)
Create a sliding view over this Sequence
|
default LazyCollectionX<VectorX<T>> |
sliding(int windowSize,
int increment)
Create a sliding view over this Sequence
|
default LazyCollectionX<T> |
sorted()
assertThat(ReactiveSeq.of(4,3,6,7)).sorted().toList(),equalTo(Arrays.asList(3,4,6,7))); |
default LazyCollectionX<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)));
|
default <U extends java.lang.Comparable<? super U>> |
sorted(java.util.function.Function<? super T,? extends U> function) |
default LazyCollectionX<T> |
takeRight(int num)
Generate a new Traversable that takes the specified number elements from the take of this Traversable
|
default LazyCollectionX<T> |
takeUntil(java.util.function.Predicate<? super T> p)
Generate a new Traversable that takes elements from this Traversable until the predicate holds
|
default LazyCollectionX<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> LazyCollectionX<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
|
default <U> LazyCollectionX<org.jooq.lambda.tuple.Tuple2<T,U>> |
zip(java.lang.Iterable<? extends U> other)
Zip (merge) this collection with the supplied Iterable into a Colleciton containing Tuples
Each Tuple contains one element from this collection and one from the other
|
default <U,R> LazyCollectionX<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
|
default <S,U> LazyCollectionX<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
|
default <T2,T3,T4> LazyCollectionX<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
|
default <U> LazyCollectionX<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
|
default <U,R> LazyCollectionX<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
|
default LazyCollectionX<org.jooq.lambda.tuple.Tuple2<T,java.lang.Long>> |
zipWithIndex()
Add an index toNested the current Stream
|
plusInOrder, plusLoop, plusLoop, unit
collection, drop, findAny, findFirst, forEach2, forEach2, forEach3, forEach3, forEach4, forEach4, from, fromCollection, getAtIndex, groupBy, head, headAndTail, isEmpty, iterator, materialize, materializeReversed, peek, single, single, singleOptional, stream, take, unit
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, schedule, scheduleFixedDelay, scheduleFixedRate, startsWith, startsWithIterable, xMatch
combine, mapToDouble, mapToInt, mapToLong, 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
default <U> U reduce(U identity, java.util.function.BiFunction<U,? super T,U> accumulator)
Folds
Stream.reduce(Object, BinaryOperator)
reduce
in interface Folds<T>
identity
- Identity value for the combiner function (leaves the input unchanged)accumulator
- Combiner function<X> LazyCollectionX<X> fromStream(ReactiveSeq<X> stream)
stream
- Create a MultableCollectionX from a Streamdefault LazyCollectionX<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),Semigroups.intSum)
.listX()
//ListX(3,4)
combine
in interface CollectionX<T>
combine
in interface Traversable<T>
predicate
- Test toNested see if two neighbours should be joined. The first parameter toNested the bi-predicate is the currently
accumulated result and the second is the next elementop
- BinaryOperator toNested combine neighboursdefault LazyCollectionX<T> reverse()
Traversable
assertThat( of(1, 2, 3).reverse().toList(),
equalTo(asList(3, 2, 1)));
reverse
in interface CollectionX<T>
reverse
in interface Traversable<T>
default LazyCollectionX<T> filter(java.util.function.Predicate<? super T> pred)
Filters
of(1,2,3).filter(i->i>2);
//[3]
filter
in interface CollectionX<T>
filter
in interface FilterableTransformable<T>
filter
in interface Filters<T>
pred
- toNested filter elements by, retaining matchesdefault <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 CollectionX<T>
map
in interface FilterableTransformable<T>
map
in interface Transformable<T>
mapper
- Transformation functiondefault <R> CollectionX<R> flatMap(java.util.function.Function<? super T,? extends java.lang.Iterable<? extends R>> mapper)
CollectionX
flatMap
in interface CollectionX<T>
mapper
- Transformation function toNested be applied (and flattened)default LazyCollectionX<T> limit(long num)
Traversable
assertThat(ReactiveSeq.of(4,3,6,7).limit(2).toList(),equalTo(Arrays.asList(4,3));
limit
in interface CollectionX<T>
limit
in interface Traversable<T>
num
- Limit element size toNested numdefault LazyCollectionX<T> skip(long num)
Traversable
assertThat(ReactiveSeq.of(4,3,6,7).skip(2).toList(),equalTo(Arrays.asList(6,7)));
skip
in interface CollectionX<T>
skip
in interface Traversable<T>
num
- Number of elemenets toNested skipdefault LazyCollectionX<T> takeRight(int num)
Traversable
ListX.of(1,2,3).takeRight(2);
//[2,3]
takeRight
in interface CollectionX<T>
takeRight
in interface Traversable<T>
num
- Take this number of elements from the take of this Traversabledefault LazyCollectionX<T> dropRight(int num)
Traversable
ListX.of(1,2,3).dropRight(2);
//[1]
dropRight
in interface CollectionX<T>
dropRight
in interface Traversable<T>
num
- Drop this number of elements from the take of this Traversabledefault LazyCollectionX<T> takeWhile(java.util.function.Predicate<? super T> p)
Traversable
ListX.of(1,2,3).takeWhile(i<3);
//[1,2]
takeWhile
in interface CollectionX<T>
takeWhile
in interface Traversable<T>
p
- Predicate toNested determine when values should be takendefault LazyCollectionX<T> dropWhile(java.util.function.Predicate<? super T> p)
Traversable
ListX.of(1,2,3).dropWhile(i<3);
//[3]
dropWhile
in interface CollectionX<T>
dropWhile
in interface Traversable<T>
p
- Predicate toNested determine when values should be droppeddefault LazyCollectionX<T> takeUntil(java.util.function.Predicate<? super T> p)
Traversable
ListX.of(1,2,3).takeUntil(i<2);
//[1,2]
takeUntil
in interface CollectionX<T>
takeUntil
in interface Traversable<T>
p
- Predicate toNested determine when values should be taken untildefault LazyCollectionX<T> dropUntil(java.util.function.Predicate<? super T> p)
Traversable
ListX.of(1,2,3).dropUntil(i>2);
//[3]
dropUntil
in interface CollectionX<T>
dropUntil
in interface Traversable<T>
p
- Predicate toNested determine when values should be droppeddefault <R> LazyCollectionX<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 CollectionX<T>
trampoline
in interface Transformable<T>
mapper
- TCO Transformation functiondefault LazyCollectionX<T> slice(long from, long to)
slice
in interface CollectionX<T>
slice
in interface Traversable<T>
default LazyCollectionX<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 CollectionX<T>
grouped
in interface Traversable<T>
groupSize
- Size of each Groupdefault <K,A,D> LazyCollectionX<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 CollectionX<T>
grouped
in interface Traversable<T>
classifier
- Grouping functiondownstream
- Collector toNested create the grouping collectiondefault <K> LazyCollectionX<org.jooq.lambda.tuple.Tuple2<K,ReactiveSeq<T>>> grouped(java.util.function.Function<? super T,? extends K> classifier)
Traversable
grouped
in interface CollectionX<T>
grouped
in interface Traversable<T>
classifier
- Grouping functiondefault <U> LazyCollectionX<org.jooq.lambda.tuple.Tuple2<T,U>> zip(java.lang.Iterable<? extends U> other)
CollectionX
default <U,R> LazyCollectionX<R> zip(java.lang.Iterable<? extends U> other, java.util.function.BiFunction<? super T,? super U,? extends R> zipper)
Zippable
zip
in interface CollectionX<T>
zip
in interface Traversable<T>
zip
in interface Zippable<T>
other
- toNested zip withzipper
- Zip functiondefault <U,R> LazyCollectionX<R> zipS(java.util.stream.Stream<? extends U> other, java.util.function.BiFunction<? super T,? super U,? extends R> zipper)
Zippable
default LazyCollectionX<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 CollectionX<T>
sliding
in interface Traversable<T>
windowSize
- Size of sliding windowdefault LazyCollectionX<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 CollectionX<T>
sliding
in interface Traversable<T>
windowSize
- number of elements in each batchincrement
- for each windowdefault LazyCollectionX<T> scanLeft(Monoid<T> monoid)
Traversable
assertEquals(asList("", "a", "ab", "abc"),ReactiveSeq.of("a", "b", "c")
.scanLeft(Reducers.toString("")).toList());
scanLeft
in interface CollectionX<T>
scanLeft
in interface Traversable<T>
default <U> LazyCollectionX<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 CollectionX<T>
scanLeft
in interface Traversable<T>
default LazyCollectionX<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 CollectionX<T>
scanRight
in interface Traversable<T>
default <U> LazyCollectionX<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 CollectionX<T>
scanRight
in interface Traversable<T>
default <U extends java.lang.Comparable<? super U>> LazyCollectionX<T> sorted(java.util.function.Function<? super T,? extends U> function)
sorted
in interface CollectionX<T>
sorted
in interface Traversable<T>
default LazyCollectionX<T> plus(T e)
FluentCollectionX
plus
in interface FluentCollectionX<T>
e
- Element to adddefault LazyCollectionX<T> plusAll(java.util.Collection<? extends T> list)
FluentCollectionX
plusAll
in interface FluentCollectionX<T>
list
- of elements to adddefault LazyCollectionX<T> minus(java.lang.Object e)
FluentCollectionX
minus
in interface FluentCollectionX<T>
e
- Element to removedefault LazyCollectionX<T> minusAll(java.util.Collection<?> list)
FluentCollectionX
minusAll
in interface FluentCollectionX<T>
list
- of elements to removedefault LazyCollectionX<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 CollectionX<T>
cycle
in interface Traversable<T>
times
- Times values should be repeated within a Streamdefault LazyCollectionX<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 CollectionX<T>
cycle
in interface Traversable<T>
m
- Monoid toNested be used in reductiontimes
- Number of times value should be repeateddefault LazyCollectionX<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 CollectionX<T>
cycleWhile
in interface Traversable<T>
predicate
- repeat while truedefault LazyCollectionX<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 CollectionX<T>
cycleUntil
in interface Traversable<T>
predicate
- repeat while truedefault <U> LazyCollectionX<org.jooq.lambda.tuple.Tuple2<T,U>> zipS(java.util.stream.Stream<? extends U> other)
Traversable
zipS
in interface CollectionX<T>
zipS
in interface Traversable<T>
zipS
in interface Zippable<T>
other
- Stream toNested combine withdefault <S,U> LazyCollectionX<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']]
zip3
in interface CollectionX<T>
zip3
in interface Traversable<T>
zip3
in interface Zippable<T>
default <T2,T3,T4> LazyCollectionX<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"]]
zip4
in interface CollectionX<T>
zip4
in interface Traversable<T>
zip4
in interface Zippable<T>
default LazyCollectionX<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 CollectionX<T>
zipWithIndex
in interface Traversable<T>
default LazyCollectionX<T> distinct()
distinct
in interface CollectionX<T>
distinct
in interface Traversable<T>
default LazyCollectionX<T> sorted()
Traversable
assertThat(ReactiveSeq.of(4,3,6,7)).sorted().toList(),equalTo(Arrays.asList(3,4,6,7)));
sorted
in interface CollectionX<T>
sorted
in interface Traversable<T>
default LazyCollectionX<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 CollectionX<T>
sorted
in interface Traversable<T>
c
- Compartor toNested sort withdefault LazyCollectionX<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 CollectionX<T>
skipWhile
in interface Traversable<T>
p
- Predicate toNested skip while truedefault LazyCollectionX<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 CollectionX<T>
skipUntil
in interface Traversable<T>
p
- Predicate toNested skip until truedefault LazyCollectionX<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 CollectionX<T>
limitWhile
in interface Traversable<T>
p
- Limit while predicate is truedefault LazyCollectionX<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 CollectionX<T>
limitUntil
in interface Traversable<T>
p
- Limit until predicate is truedefault LazyCollectionX<T> intersperse(T value)
Traversable
intersperse
in interface CollectionX<T>
intersperse
in interface Traversable<T>
default LazyCollectionX<T> shuffle()
shuffle
in interface CollectionX<T>
shuffle
in interface Traversable<T>
default LazyCollectionX<T> skipLast(int num)
Traversable
skipLast
in interface CollectionX<T>
skipLast
in interface Traversable<T>
default LazyCollectionX<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 CollectionX<T>
limitLast
in interface Traversable<T>
num
- of elements toNested return (last elements)default LazyCollectionX<T> onEmpty(T value)
OnEmpty
onEmpty
in interface CollectionX<T>
onEmpty
in interface OnEmpty<T>
onEmpty
in interface Traversable<T>
default LazyCollectionX<T> onEmptyGet(java.util.function.Supplier<? extends T> supplier)
OnEmpty
onEmptyGet
in interface CollectionX<T>
onEmptyGet
in interface OnEmpty<T>
onEmptyGet
in interface Traversable<T>
supplier
- toNested determine new value for containerdefault <X extends java.lang.Throwable> LazyCollectionX<T> onEmptyThrow(java.util.function.Supplier<? extends X> supplier)
OnEmpty
onEmptyThrow
in interface CollectionX<T>
onEmptyThrow
in interface OnEmpty<T>
onEmptyThrow
in interface Traversable<T>
supplier
- toNested create exception fromdefault LazyCollectionX<T> shuffle(java.util.Random random)
shuffle
in interface CollectionX<T>
shuffle
in interface Traversable<T>
default <U> LazyCollectionX<U> ofType(java.lang.Class<? extends U> type)
Filters
// (1, 2, 3) ReactiveSeq.of(1, "a", 2, "b",3).ofType(Integer.class)
default LazyCollectionX<T> filterNot(java.util.function.Predicate<? super T> fn)
Filters
of(1,2,3).filter(i->i>2);
//[1,2]
default LazyCollectionX<T> notNull()
Filters
of(1,2,null,4).nonNull();
//[1,2,4]
default LazyCollectionX<T> removeAllS(java.util.stream.Stream<? extends T> stream)
IterableFilterable
removeAllS
in interface CollectionX<T>
removeAllS
in interface IterableFilterable<T>
stream
- of elements toNested removedefault LazyCollectionX<T> removeAllI(java.lang.Iterable<? extends T> it)
IterableFilterable
removeAllI
in interface CollectionX<T>
removeAllI
in interface IterableFilterable<T>
it
- an Iterable of elements toNested removedefault LazyCollectionX<T> removeAll(T... values)
IterableFilterable
removeAll
in interface CollectionX<T>
removeAll
in interface IterableFilterable<T>
values
- toNested removedefault LazyCollectionX<T> retainAllI(java.lang.Iterable<? extends T> it)
IterableFilterable
retainAllI
in interface CollectionX<T>
retainAllI
in interface IterableFilterable<T>
it
- Iterable of elements toNested retaindefault LazyCollectionX<T> retainAllS(java.util.stream.Stream<? extends T> stream)
IterableFilterable
retainAllS
in interface CollectionX<T>
retainAllS
in interface IterableFilterable<T>
stream
- of elements toNested retaindefault LazyCollectionX<T> retainAll(T... values)
IterableFilterable
retainAll
in interface CollectionX<T>
retainAll
in interface IterableFilterable<T>
values
- elements toNested retaindefault <U> LazyCollectionX<U> cast(java.lang.Class<? extends U> type)
Transformable
ClassCastException
.
// ClassCastException ReactiveSeq.of(1, "a", 2, "b", 3).cast(Integer.class)cast
in interface CollectionX<T>
cast
in interface Transformable<T>
default LazyCollectionX<ReactiveSeq<T>> permutations()
ExtendedTraversable
permutations
in interface CollectionX<T>
permutations
in interface ExtendedTraversable<T>
default LazyCollectionX<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 CollectionX<T>
combinations
in interface ExtendedTraversable<T>
size
- of combinationsdefault LazyCollectionX<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 CollectionX<T>
combinations
in interface ExtendedTraversable<T>
default <C extends java.util.Collection<? super T>> LazyCollectionX<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 CollectionX<T>
grouped
in interface Traversable<T>
size
- batch sizesupplier
- Collection factorydefault LazyCollectionX<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 CollectionX<T>
groupedUntil
in interface Traversable<T>
predicate
- Batch until predicate holds, apply open next batchdefault LazyCollectionX<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 CollectionX<T>
groupedWhile
in interface Traversable<T>
predicate
- Batch while predicate holds, apply open next batchdefault <C extends java.util.Collection<? super T>> LazyCollectionX<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 CollectionX<T>
groupedWhile
in interface Traversable<T>
predicate
- Batch while predicate holds, apply open next batchfactory
- Collection factorydefault <C extends java.util.Collection<? super T>> LazyCollectionX<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 CollectionX<T>
groupedUntil
in interface Traversable<T>
predicate
- Batch until predicate holds, apply open next batchfactory
- Collection factorydefault LazyCollectionX<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 CollectionX<T>
groupedStatefullyUntil
in interface Traversable<T>
predicate
- Window while truedefault <R> LazyCollectionX<R> flatMapS(java.util.function.Function<? super T,? extends java.util.stream.Stream<? extends R>> fn)
flatMapS
in interface CollectionX<T>
default <R> LazyCollectionX<R> flatMapP(java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> fn)
flatMapP
in interface CollectionX<T>
default LazyCollectionX<T> prependS(java.util.stream.Stream<? extends T> stream)
Traversable
List<String> result = ReactiveSeq.of(1, 2, 3)
.prependS(of(100, 200, 300))
.map(it -> it + "!!")
.collect(CyclopsCollectors.toList());
assertThat(result, equalTo(Arrays.asList("100!!", "200!!", "300!!", "1!!", "2!!", "3!!")));
prependS
in interface Traversable<T>
stream
- toNested Prependdefault LazyCollectionX<T> append(T... values)
Traversable
List<String> result = ReactiveSeq.of(1, 2, 3).append(100, 200, 300).map(it -> it + "!!").collect(CyclopsCollectors.toList());
assertThat(result, equalTo(Arrays.asList("1!!", "2!!", "3!!", "100!!", "200!!", "300!!"))); *
append
in interface Traversable<T>
values
- toNested appenddefault LazyCollectionX<T> append(T value)
append
in interface Traversable<T>
default LazyCollectionX<T> prepend(T value)
prepend
in interface Traversable<T>
default LazyCollectionX<T> prepend(T... values)
Traversable
List<String> result = ReactiveSeq.of(1,2,3)
.prepend(100,200,300)
.map(it ->it+"!!")
.collect(CyclopsCollectors.toList());
assertThat(result,equalTo(Arrays.asList("100!!","200!!","300!!","1!!","2!!","3!!")));
prepend
in interface Traversable<T>
values
- toNested prependdefault LazyCollectionX<T> insertAt(int pos, T... values)
Traversable
List<String> result = ReactiveSeq.of(1, 2, 3).insertAt(1, 100, 200, 300).map(it -> it + "!!").collect(CyclopsCollectors.toList());
assertThat(result, equalTo(Arrays.asList("1!!", "100!!", "200!!", "300!!", "2!!", "3!!"))); *
insertAt
in interface Traversable<T>
pos
- toNested insert data atvalues
- toNested insertdefault LazyCollectionX<T> deleteBetween(int start, int end)
Traversable
List<String> result = ReactiveSeq.of(1, 2, 3, 4, 5, 6).deleteBetween(2, 4).map(it -> it + "!!").collect(CyclopsCollectors.toList());
assertThat(result, equalTo(Arrays.asList("1!!", "2!!", "5!!", "6!!"))); *
deleteBetween
in interface Traversable<T>
start
- indexend
- indexdefault LazyCollectionX<T> insertAtS(int pos, java.util.stream.Stream<T> stream)
Traversable
List<String> result = ReactiveSeq.of(1, 2, 3).insertAtS(1, of(100, 200, 300)).map(it -> it + "!!").collect(CyclopsCollectors.toList());
assertThat(result, equalTo(Arrays.asList("1!!", "100!!", "200!!", "300!!", "2!!", "3!!")));
insertAtS
in interface Traversable<T>
pos
- toNested insert Stream atstream
- toNested insert