public interface PersistentCollectionX<T> extends FluentCollectionX<T>
Modifier and Type | Method and Description |
---|---|
default <U> PersistentCollectionX<U> |
cast(java.lang.Class<? extends U> type)
Cast all elements in a stream to a given type, possibly throwing a
ClassCastException . |
default PersistentCollectionX<ReactiveSeq<T>> |
combinations()
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]]
|
default PersistentCollectionX<ReactiveSeq<T>> |
combinations(int size)
ReactiveSeq.of(1,2,3).combinations(2)
//ReactiveSeq[ReactiveSeq[1,2],ReactiveSeq[1,3],ReactiveSeq[2,3]]
|
default PersistentCollectionX<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 & reduction operation.
|
default PersistentCollectionX<T> |
cycle(int times)
Convert to a Stream with the values repeated specified times
|
default PersistentCollectionX<T> |
cycle(Monoid<T> m,
int times)
Convert to a Stream with the result of a reduction operation repeated
specified times
|
default PersistentCollectionX<T> |
cycleUntil(java.util.function.Predicate<? super T> predicate)
Repeat in a Stream until specified predicate holds
|
default PersistentCollectionX<T> |
cycleWhile(java.util.function.Predicate<? super T> predicate)
Repeat in a Stream while specified predicate holds
|
default PersistentCollectionX<T> |
distinct() |
default PersistentCollectionX<T> |
dropRight(int num) |
default PersistentCollectionX<T> |
dropUntil(java.util.function.Predicate<? super T> p) |
default PersistentCollectionX<T> |
dropWhile(java.util.function.Predicate<? super T> p) |
<R> PersistentCollectionX<R> |
emptyUnit() |
default PersistentCollectionX<T> |
filter(java.util.function.Predicate<? super T> pred)
Keep only elements for which the supplied predicates hold
e.g.
|
default PersistentCollectionX<T> |
filterNot(java.util.function.Predicate<? super T> fn)
Remove any elements for which the predicate holds (inverse operation to filter)
e.g.
|
default <R> PersistentCollectionX<R> |
flatMap(java.util.function.Function<? super T,? extends java.lang.Iterable<? extends R>> mapper) |
<T1> PersistentCollectionX<T1> |
from(java.util.Collection<T1> c) |
default <K> PersistentCollectionX<org.jooq.lambda.tuple.Tuple2<K,org.jooq.lambda.Seq<T>>> |
grouped(java.util.function.Function<? super T,? extends K> classifier) |
default <K,A,D> PersistentCollectionX<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) |
default PersistentCollectionX<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 PersistentCollectionX<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 PersistentCollectionX<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 SequenceM batched by a Collection, where each batch is populated
until the predicate holds
|
default PersistentCollectionX<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 PersistentCollectionX<T> |
intersperse(T value)
Returns a stream with a given value interspersed between any two values
of this stream.
|
default PersistentCollectionX<T> |
limit(long num)
assertThat(ReactiveSeq.of(4,3,6,7).limit(2).toList(),equalTo(Arrays.asList(4,3)); |
default PersistentCollectionX<T> |
limitLast(int num)
Limit results to the last x elements in a SequenceM
|
default PersistentCollectionX<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 PersistentCollectionX<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> PersistentCollectionX<R> |
map(java.util.function.Function<? super T,? extends R> mapper)
Transform this functor using the supplied transformation function
|
<T> Reducer<? extends java.util.Collection<T>> |
monoid() |
default PersistentCollectionX<T> |
notNull()
Filter elements retaining only values which are not null
|
default <U> PersistentCollectionX<U> |
ofType(java.lang.Class<? extends U> type)
Keep only those elements in a stream that are of a given type.
|
default PersistentCollectionX<T> |
onEmpty(T value)
If this Container instance is empty, create a new instance containing the provided value
|
default PersistentCollectionX<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 <R> PersistentCollectionX<R> |
patternMatch(java.util.function.Function<Matchable.CheckValue1<T,R>,Matchable.CheckValue1<T,R>> case1,
java.util.function.Supplier<? extends R> otherwise)
Transform the elements of this Stream with a Pattern Matching case and default value
|
default PersistentCollectionX<ReactiveSeq<T>> |
permutations()
Generate the permutations based on values in the ReactiveSeq Makes use of
Streamable to store intermediate stages in a collection
|
default PersistentCollectionX<T> |
plusInOrder(T e)
Add an element to the collection
|
default PersistentCollectionX<T> |
removeAll(java.lang.Iterable<? extends T> it)
Remove all elements in the supplied Iterable from this filterable
|
default PersistentCollectionX<T> |
removeAll(org.jooq.lambda.Seq<? extends T> stream) |
default PersistentCollectionX<T> |
removeAll(java.util.stream.Stream<? extends T> stream)
Remove all elements in the supplied Stream from this filterable
|
default PersistentCollectionX<T> |
removeAll(T... values)
Remove all supplied elements from this filterable
|
default PersistentCollectionX<T> |
retainAll(java.lang.Iterable<? extends T> it)
Retain only the supplied elements in the returned Filterable
|
default PersistentCollectionX<T> |
retainAll(org.jooq.lambda.Seq<? extends T> stream) |
default PersistentCollectionX<T> |
retainAll(java.util.stream.Stream<? extends T> seq)
Retain only the supplied elements in the returned Filterable
|
default PersistentCollectionX<T> |
retainAll(T... values)
Retain only the supplied elements in the returned Filterable
|
default CollectionX<T> |
reverse() |
default PersistentCollectionX<T> |
scanLeft(Monoid<T> monoid)
Scan left using supplied Monoid
|
default <U> PersistentCollectionX<U> |
scanLeft(U seed,
java.util.function.BiFunction<? super U,? super T,? extends U> function)
Scan left
|
default PersistentCollectionX<T> |
scanRight(Monoid<T> monoid)
Scan right
|
default <U> PersistentCollectionX<U> |
scanRight(U identity,
java.util.function.BiFunction<? super T,? super U,? extends U> combiner)
Scan right
|
default PersistentCollectionX<T> |
shuffle() |
default PersistentCollectionX<T> |
shuffle(java.util.Random random) |
default PersistentCollectionX<T> |
skip(long num)
assertThat(ReactiveSeq.of(4,3,6,7).skip(2).toList(),equalTo(Arrays.asList(6,7))); |
default PersistentCollectionX<T> |
skipLast(int num)
assertThat(ReactiveSeq.of(1,2,3,4,5) .skipLast(2)
.collect(Collectors.toList()),equalTo(Arrays.asList(1,2,3)));
|
default PersistentCollectionX<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 PersistentCollectionX<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 PersistentCollectionX<T> |
slice(long from,
long to) |
default PersistentCollectionX<ListX<T>> |
sliding(int windowSize)
Create a sliding view over this Sequence
|
default PersistentCollectionX<ListX<T>> |
sliding(int windowSize,
int increment)
Create a sliding view over this Sequence
|
default PersistentCollectionX<T> |
sorted()
assertThat(ReactiveSeq.of(4,3,6,7)).sorted().toList(),equalTo(Arrays.asList(3,4,6,7))); |
default PersistentCollectionX<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 ReactiveSeq<T> |
stream() |
default PersistentCollectionX<T> |
takeRight(int num) |
default PersistentCollectionX<T> |
takeUntil(java.util.function.Predicate<? super T> p) |
default PersistentCollectionX<T> |
takeWhile(java.util.function.Predicate<? super T> p) |
default <R> PersistentCollectionX<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> PersistentCollectionX<R> |
unit(java.util.Collection<R> col)
Create a new instance of the same colleciton type from the supplied collection
|
default <U> PersistentCollectionX<org.jooq.lambda.tuple.Tuple2<T,U>> |
zip(java.lang.Iterable<? extends U> other)
Zip (combine) this Zippable with the supplied Iterable combining both into a Tuple2
|
default <U,R> PersistentCollectionX<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 <U> PersistentCollectionX<org.jooq.lambda.tuple.Tuple2<T,U>> |
zip(org.jooq.lambda.Seq<? extends U> other)
Zip (combine) this Zippable with the supplied Seq combining both into a Tuple2
|
default <U,R> PersistentCollectionX<R> |
zip(org.jooq.lambda.Seq<? extends U> other,
java.util.function.BiFunction<? super T,? super U,? extends R> zipper)
Zip (combine) this Zippable with the supplied Seq, using the supplied combining function
|
default <U> PersistentCollectionX<org.jooq.lambda.tuple.Tuple2<T,U>> |
zip(java.util.stream.Stream<? extends U> other)
Zip 2 streams into one
|
default <U,R> PersistentCollectionX<R> |
zip(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 <S,U> PersistentCollectionX<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
|
default <T2,T3,T4> PersistentCollectionX<org.jooq.lambda.tuple.Tuple4<T,T2,T3,T4>> |
zip4(java.util.stream.Stream<? extends T2> second,
java.util.stream.Stream<? extends T3> third,
java.util.stream.Stream<? extends T4> fourth)
zip 4 Streams into 1
|
default PersistentCollectionX<org.jooq.lambda.tuple.Tuple2<T,java.lang.Long>> |
zipWithIndex()
Add an index to the current Stream
|
minus, minusAll, plus, plusAll
collectable, findAny, findFirst, forEach2, forEach2, forEach3, forEach3, fromCollection, getAtIndex, groupBy, head, headAndTail, peek, single, single, singleOptional
groupedStatefullyUntilT, groupedT, groupedUntilT, groupedWhileT, slidingT, slidingT
fixedDelay, onePer, xPer
foldable, visit
ap1, ap2, ap3, ap4, ap5, applicatives
flatMapPublisher, flatMapPublisher, flatMapPublisher, mergePublisher, mergePublisher, unitIterator
endsWith, endsWithIterable, firstValue, 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, toConcurrentLazyCollection, toConcurrentLazyStreamable, toLazyCollection, validate, xMatch
futureOperations, lazyOperations, subscribe, traversable
seq, toCompletableFuture, toDequeX, toEvalAlways, toEvalLater, toEvalNow, toFutureStream, toFutureStream, toFutureW, toIor, toIorSecondary, toListX, toMapX, toMaybe, toOptional, toPBagX, toPMapX, toPOrderedSetX, toPQueueX, toPSetX, toPStackX, toPVectorX, toQueueX, toSetX, toSimpleReact, toSimpleReact, toSortedSetX, toStreamable, toTry, toValue, toValueMap, toValueSet, toXor, toXorSecondary
add, addAll, clear, contains, containsAll, equals, hashCode, isEmpty, iterator, parallelStream, remove, removeAll, removeIf, retainAll, size, spliterator, toArray, toArray
allMatch, anyMatch, avg, avg, avgDouble, avgInt, avgLong, bitAnd, bitAnd, bitAndInt, bitAndLong, bitOr, bitOr, bitOrInt, bitOrLong, collect, commonPrefix, commonSuffix, count, count, countDistinct, countDistinct, countDistinctBy, countDistinctBy, max, max, max, max, maxAll, maxAll, maxAll, maxAll, maxAllBy, maxAllBy, maxBy, maxBy, median, median, medianBy, medianBy, min, min, min, min, minAll, minAll, minAll, minAll, minAllBy, minAllBy, minBy, minBy, mode, modeAll, modeAllBy, modeBy, noneMatch, percentile, percentile, percentileBy, percentileBy, sum, sum, sumDouble, sumInt, sumLong, toCollection, toList, toList, toMap, toMap, toSet, toSet, toString, toString
default ReactiveSeq<T> stream()
stream
in interface java.util.Collection<T>
stream
in interface CollectionX<T>
stream
in interface ConvertableSequence<T>
stream
in interface ExtendedTraversable<T>
stream
in interface Foldable<T>
stream
in interface IterableFunctor<T>
stream
in interface Sequential<T>
stream
in interface TransformerTraversable<T>
stream
in interface Traversable<T>
default PersistentCollectionX<T> plusInOrder(T e)
FluentCollectionX
plusInOrder
in interface FluentCollectionX<T>
e
- Element to add<R> PersistentCollectionX<R> unit(java.util.Collection<R> col)
FluentCollectionX
unit
in interface FluentCollectionX<T>
col
- Collection data to populate the new collection<R> PersistentCollectionX<R> emptyUnit()
<T> Reducer<? extends java.util.Collection<T>> monoid()
<T1> PersistentCollectionX<T1> from(java.util.Collection<T1> c)
from
in interface CollectionX<T>
default CollectionX<T> reverse()
reverse
in interface CollectionX<T>
reverse
in interface Traversable<T>
default PersistentCollectionX<T> filter(java.util.function.Predicate<? super T> pred)
Filterable
of(1,2,3).filter(i->i>2);
//[3]
filter
in interface CollectionX<T>
filter
in interface Filterable<T>
pred
- to filter elements by, retaining matchesdefault <R> PersistentCollectionX<R> map(java.util.function.Function<? super T,? extends R> mapper)
Functor
of(1,2,3).map(i->i*2)
//[2,4,6]
map
in interface CollectionX<T>
map
in interface Functor<T>
map
in interface IterableFunctor<T>
mapper
- Transformation functiondefault <R> PersistentCollectionX<R> flatMap(java.util.function.Function<? super T,? extends java.lang.Iterable<? extends R>> mapper)
flatMap
in interface CollectionX<T>
default PersistentCollectionX<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 to numdefault PersistentCollectionX<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 to skipdefault PersistentCollectionX<T> dropRight(int num)
dropRight
in interface CollectionX<T>
dropRight
in interface Traversable<T>
default PersistentCollectionX<T> takeRight(int num)
takeRight
in interface CollectionX<T>
takeRight
in interface Traversable<T>
default PersistentCollectionX<T> takeWhile(java.util.function.Predicate<? super T> p)
takeWhile
in interface CollectionX<T>
takeWhile
in interface Traversable<T>
default PersistentCollectionX<T> dropWhile(java.util.function.Predicate<? super T> p)
dropWhile
in interface CollectionX<T>
dropWhile
in interface Traversable<T>
default PersistentCollectionX<T> takeUntil(java.util.function.Predicate<? super T> p)
takeUntil
in interface CollectionX<T>
takeUntil
in interface Traversable<T>
default PersistentCollectionX<T> dropUntil(java.util.function.Predicate<? super T> p)
dropUntil
in interface CollectionX<T>
dropUntil
in interface Traversable<T>
default <R> PersistentCollectionX<R> trampoline(java.util.function.Function<? super T,? extends Trampoline<? extends R>> mapper)
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 Functor<T>
mapper
- default PersistentCollectionX<T> slice(long from, long to)
slice
in interface CollectionX<T>
slice
in interface Traversable<T>
default <U extends java.lang.Comparable<? super U>> PersistentCollectionX<T> sorted(java.util.function.Function<? super T,? extends U> function)
sorted
in interface CollectionX<T>
sorted
in interface Traversable<T>
default PersistentCollectionX<ListX<T>> grouped(int groupSize)
Traversable
{ @code List<List<Integer>> list = ReactiveSeq.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 CollectionX<T>
grouped
in interface Traversable<T>
groupSize
- Size of each Groupdefault <K,A,D> PersistentCollectionX<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)
grouped
in interface CollectionX<T>
grouped
in interface Traversable<T>
default <K> PersistentCollectionX<org.jooq.lambda.tuple.Tuple2<K,org.jooq.lambda.Seq<T>>> grouped(java.util.function.Function<? super T,? extends K> classifier)
grouped
in interface CollectionX<T>
grouped
in interface Traversable<T>
default <U> PersistentCollectionX<org.jooq.lambda.tuple.Tuple2<T,U>> zip(java.lang.Iterable<? extends U> other)
Zippable
zip
in interface CollectionX<T>
zip
in interface Traversable<T>
zip
in interface Zippable<T>
other
- Iterable to combine withdefault <U,R> PersistentCollectionX<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
- to zip withzipper
- Zip functiondefault <U,R> PersistentCollectionX<R> zip(org.jooq.lambda.Seq<? 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
- Seq to combine withzipper
- Zip / combining functiondefault <U,R> PersistentCollectionX<R> zip(java.util.stream.Stream<? 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
- Stream to combine withzipper
- Zip / combining functiondefault PersistentCollectionX<ListX<T>> sliding(int windowSize)
Traversable
{ @code List<List<Integer>> list = ReactiveSeq.of(1, 2, 3, 4, 5, 6).sliding(2).collect(Collectors.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 PersistentCollectionX<ListX<T>> sliding(int windowSize, int increment)
Traversable
{ @code List<List<Integer>> list = ReactiveSeq.of(1, 2, 3, 4, 5, 6).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 CollectionX<T>
sliding
in interface Traversable<T>
windowSize
- number of elements in each batchincrement
- for each windowdefault PersistentCollectionX<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 PersistentCollectionX<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> PersistentCollectionX<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 <U> PersistentCollectionX<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 PersistentCollectionX<T> cycle(int times)
Traversable
ReactiveSeq.of(1,2,2)
.cycle(3)
.collect(Collectors.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 PersistentCollectionX<T> cycle(Monoid<T> m, int times)
Traversable
List<Integer> list = ReactiveSeq.of(1,2,2))
.cycle(Reducers.toCountInt(),3)
.collect(Collectors.toList());
//List[3,3,3];
cycle
in interface CollectionX<T>
cycle
in interface Traversable<T>
m
- Monoid to be used in reductiontimes
- Number of times value should be repeateddefault PersistentCollectionX<T> cycleWhile(java.util.function.Predicate<? super T> predicate)
Traversable
{ @code MutableInt count = MutableInt.of(0); ReactiveSeq.of(1, 2, 2).cycleWhile(next -> count++ < 6).collect(Collectors.toList()); // List(1,2,2,1,2,2) }
cycleWhile
in interface CollectionX<T>
cycleWhile
in interface Traversable<T>
predicate
- repeat while truedefault PersistentCollectionX<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(Collectors.toList());
//List[1,2,2,1,2,2,1]
cycleUntil
in interface CollectionX<T>
cycleUntil
in interface Traversable<T>
predicate
- repeat while truedefault <U> PersistentCollectionX<org.jooq.lambda.tuple.Tuple2<T,U>> zip(java.util.stream.Stream<? extends U> other)
Traversable
{ @code List<Tuple2<Integer, String>> list = of(1, 2).zip(of("a", "b", "c", "d")).toList(); // [[1,"a"],[2,"b"]] }
zip
in interface CollectionX<T>
zip
in interface Traversable<T>
zip
in interface Zippable<T>
other
- Stream to combine withdefault <U> PersistentCollectionX<org.jooq.lambda.tuple.Tuple2<T,U>> zip(org.jooq.lambda.Seq<? extends U> other)
Zippable
zip
in interface CollectionX<T>
zip
in interface Traversable<T>
zip
in interface Zippable<T>
other
- Seq to combine withdefault <S,U> PersistentCollectionX<org.jooq.lambda.tuple.Tuple3<T,S,U>> zip3(java.util.stream.Stream<? extends S> second, java.util.stream.Stream<? extends U> third)
Traversable
{ @code 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 CollectionX<T>
zip3
in interface Traversable<T>
default <T2,T3,T4> PersistentCollectionX<org.jooq.lambda.tuple.Tuple4<T,T2,T3,T4>> zip4(java.util.stream.Stream<? extends T2> second, java.util.stream.Stream<? extends T3> third, java.util.stream.Stream<? extends T4> fourth)
Traversable
{ @code 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 CollectionX<T>
zip4
in interface Traversable<T>
default PersistentCollectionX<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 PersistentCollectionX<T> distinct()
distinct
in interface CollectionX<T>
distinct
in interface Traversable<T>
default PersistentCollectionX<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 PersistentCollectionX<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 to sort withdefault PersistentCollectionX<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 to skip while truedefault PersistentCollectionX<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 to skip until truedefault PersistentCollectionX<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 PersistentCollectionX<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 PersistentCollectionX<T> intersperse(T value)
Traversable
intersperse
in interface CollectionX<T>
intersperse
in interface Traversable<T>
default PersistentCollectionX<T> shuffle()
shuffle
in interface CollectionX<T>
shuffle
in interface Traversable<T>
default PersistentCollectionX<T> skipLast(int num)
Traversable
skipLast
in interface CollectionX<T>
skipLast
in interface Traversable<T>
default PersistentCollectionX<T> limitLast(int num)
Traversable
assertThat(ReactiveSeq.of(1,2,3,4,5)
.limitLast(2)
.collect(Collectors.toList()),equalTo(Arrays.asList(4,5)));
limitLast
in interface CollectionX<T>
limitLast
in interface Traversable<T>
num
- of elements to return (last elements)default PersistentCollectionX<T> onEmpty(T value)
OnEmpty
onEmpty
in interface CollectionX<T>
onEmpty
in interface OnEmpty<T>
onEmpty
in interface Traversable<T>
default PersistentCollectionX<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
- to determine new value for containerdefault <X extends java.lang.Throwable> PersistentCollectionX<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
- to create exception fromdefault PersistentCollectionX<T> shuffle(java.util.Random random)
shuffle
in interface CollectionX<T>
shuffle
in interface Traversable<T>
default <U> PersistentCollectionX<U> ofType(java.lang.Class<? extends U> type)
Filterable
// (1, 2, 3) ReactiveSeq.of(1, "a", 2, "b",3).ofType(Integer.class)
ofType
in interface Filterable<T>
default PersistentCollectionX<T> filterNot(java.util.function.Predicate<? super T> fn)
Filterable
of(1,2,3).filter(i->i>2);
//[1,2]
filterNot
in interface CollectionX<T>
filterNot
in interface Filterable<T>
fn
- to filter elements by, retaining matchesdefault PersistentCollectionX<T> notNull()
Filterable
of(1,2,null,4).nonNull();
//[1,2,4]
notNull
in interface CollectionX<T>
notNull
in interface Filterable<T>
default PersistentCollectionX<T> removeAll(java.util.stream.Stream<? extends T> stream)
IterableFilterable
removeAll
in interface CollectionX<T>
removeAll
in interface IterableFilterable<T>
stream
- of elements to removedefault PersistentCollectionX<T> removeAll(org.jooq.lambda.Seq<? extends T> stream)
removeAll
in interface CollectionX<T>
default PersistentCollectionX<T> removeAll(java.lang.Iterable<? extends T> it)
IterableFilterable
removeAll
in interface CollectionX<T>
removeAll
in interface IterableFilterable<T>
it
- an Iterable of elements to removedefault PersistentCollectionX<T> removeAll(T... values)
IterableFilterable
removeAll
in interface CollectionX<T>
removeAll
in interface IterableFilterable<T>
values
- to removedefault PersistentCollectionX<T> retainAll(java.lang.Iterable<? extends T> it)
IterableFilterable
retainAll
in interface CollectionX<T>
retainAll
in interface IterableFilterable<T>
it
- Iterable of elements to retaindefault PersistentCollectionX<T> retainAll(java.util.stream.Stream<? extends T> seq)
IterableFilterable
retainAll
in interface CollectionX<T>
retainAll
in interface IterableFilterable<T>
seq
- of elements to retaindefault PersistentCollectionX<T> retainAll(org.jooq.lambda.Seq<? extends T> stream)
retainAll
in interface CollectionX<T>
default PersistentCollectionX<T> retainAll(T... values)
IterableFilterable
retainAll
in interface CollectionX<T>
retainAll
in interface IterableFilterable<T>
values
- elements to retaindefault <U> PersistentCollectionX<U> cast(java.lang.Class<? extends U> type)
Functor
ClassCastException
.
// ClassCastException ReactiveSeq.of(1, "a", 2, "b", 3).cast(Integer.class)default <R> PersistentCollectionX<R> patternMatch(java.util.function.Function<Matchable.CheckValue1<T,R>,Matchable.CheckValue1<T,R>> case1, java.util.function.Supplier<? extends R> otherwise)
Functor
List<String> result = CollectionX.of(1,2,3,4)
.patternMatch(
c->c.valuesWhere(i->"even", (Integer i)->i%2==0 )
)
// CollectionX["odd","even","odd","even"]
patternMatch
in interface CollectionX<T>
patternMatch
in interface Functor<T>
case1
- Function to generate a case (or chain of cases as a single case)otherwise
- Value if supplied case doesn't matchdefault PersistentCollectionX<ReactiveSeq<T>> permutations()
ExtendedTraversable
permutations
in interface CollectionX<T>
permutations
in interface ExtendedTraversable<T>
default PersistentCollectionX<ReactiveSeq<T>> combinations(int size)
ExtendedTraversable
ReactiveSeq.of(1,2,3).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 PersistentCollectionX<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>> PersistentCollectionX<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 PersistentCollectionX<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, then open next batchdefault PersistentCollectionX<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 PersistentCollectionX<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)
.toListX()
//ListX(3,4)
combine
in interface CollectionX<T>
combine
in interface Traversable<T>
predicate
- Test to see if two neighbours should be joinedop
- Reducer to combine neighboursdefault PersistentCollectionX<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, then open next batchdefault <C extends java.util.Collection<? super T>> PersistentCollectionX<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, then open next batchfactory
- Collection factorydefault <C extends java.util.Collection<? super T>> PersistentCollectionX<C> groupedUntil(java.util.function.Predicate<? super T> predicate, java.util.function.Supplier<C> factory)
Traversable
assertThat(ReactiveSeq.of(1,2,3,4,5,6)
.batchUntil(i->i%3!=0)
.toList()
.size(),equalTo(2));
groupedUntil
in interface CollectionX<T>
groupedUntil
in interface Traversable<T>
predicate
- Batch until predicate holds, then open next batchfactory
- Collection factory