public interface PBagX<T> extends org.pcollections.PBag<T>, PersistentCollectionX<T>
| Modifier and Type | Method and Description |
|---|---|
default <U> PBagX<U> |
cast(java.lang.Class<? extends U> type)
Cast all elements in a stream to a given type, possibly throwing a
ClassCastException. |
default PBagX<ReactiveSeq<T>> |
combinations()
ReactiveSeq.of(1,2,3).combinations()
//SequenceM[SequenceM[],SequenceM[1],SequenceM[2],SequenceM[3].SequenceM[1,2],SequenceM[1,3],SequenceM[2,3]
,SequenceM[1,2,3]]
|
default PBagX<ReactiveSeq<T>> |
combinations(int size)
ReactiveSeq.of(1,2,3).combinations(2)
//SequenceM[SequenceM[1,2],SequenceM[1,3],SequenceM[2,3]]
|
default PBagX<T> |
combine(java.util.function.BiPredicate<? super T,? super T> predicate,
java.util.function.BinaryOperator<T> op)
Combine two adjacent elements in a PBagX using the supplied BinaryOperator
This is a stateful grouping & reduction operation.
|
default PBagX<T> |
cycle(int times)
Convert to a Stream with the values repeated specified times
|
default PBagX<T> |
cycle(Monoid<T> m,
int times)
Convert to a Stream with the result of a reduction operation repeated
specified times
|
default PBagX<T> |
cycleUntil(java.util.function.Predicate<? super T> predicate)
Repeat in a Stream until specified predicate holds
|
default PBagX<T> |
cycleWhile(java.util.function.Predicate<? super T> predicate)
Repeat in a Stream while specified predicate holds
|
default PBagX<T> |
distinct() |
default PBagX<T> |
dropRight(int num) |
default PBagX<T> |
dropUntil(java.util.function.Predicate<? super T> p) |
default PBagX<T> |
dropWhile(java.util.function.Predicate<? super T> p) |
static <T> PBagX<T> |
empty() |
default <R> PBagX<R> |
emptyUnit() |
default PBagX<T> |
filter(java.util.function.Predicate<? super T> pred)
Keep only elements for which the supplied predicates hold
e.g.
|
default PBagX<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> PBagX<R> |
flatMap(java.util.function.Function<? super T,? extends java.lang.Iterable<? extends R>> mapper) |
default <X> PBagX<X> |
from(java.util.Collection<X> col) |
static <T> PBagX<T> |
fromCollection(java.util.Collection<T> stream)
Create a CollectionX from the supplied Collection
|
static <T> PBagX<T> |
fromIterable(java.lang.Iterable<T> iterable) |
static <T> PBagX<T> |
fromPublisher(org.reactivestreams.Publisher<? extends T> publisher)
Construct a PBagX from an Publisher
|
static <T> PBagX<T> |
fromStream(java.util.stream.Stream<T> stream) |
static <T> PBagX<T> |
generate(long limit,
java.util.function.Supplier<T> s)
Generate a PBagX from the provided Supplier up to the provided limit number of times
|
default <K> PBagX<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> PBagX<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 PBagX<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 PBagX<ListX<T>> |
groupedStatefullyWhile(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 PBagX<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 PBagX<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 PBagX<T> |
intersperse(T value)
Returns a stream with a given value interspersed between any two values
of this stream.
|
static <T> PBagX<T> |
iterate(long limit,
T seed,
java.util.function.UnaryOperator<T> f)
Create a PBagX by iterative application of a function to an initial element up to the supplied limit number of times
|
default PBagX<T> |
limit(long num)
assertThat(ReactiveSeq.of(4,3,6,7).limit(2).toList(),equalTo(Arrays.asList(4,3)); |
default PBagX<T> |
limitLast(int num)
Limit results to the last x elements in a SequenceM
|
default PBagX<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 PBagX<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> PBagX<R> |
map(java.util.function.Function<? super T,? extends R> mapper)
Transform this functor using the supplied transformation function
|
PBagX<T> |
minus(java.lang.Object e)
Remove the specified element from this collection
|
PBagX<T> |
minusAll(java.util.Collection<?> list)
Remove all the specified elements from this collection
|
default <T> Reducer<org.pcollections.PBag<T>> |
monoid() |
default PBagX<T> |
notNull()
Filter elements retaining only values which are not null
|
static <T> PBagX<T> |
of(T... values) |
default <U> PBagX<U> |
ofType(java.lang.Class<? extends U> type)
Keep only those elements in a stream that are of a given type.
|
default PBagX<T> |
onEmpty(T value) |
default PBagX<T> |
onEmptyGet(java.util.function.Supplier<? extends T> supplier) |
default <X extends java.lang.Throwable> |
onEmptyThrow(java.util.function.Supplier<? extends X> supplier) |
default <R> PBagX<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 PBagX<ReactiveSeq<T>> |
permutations()
Generate the permutations based on values in the SequenceM Makes use of
Streamable to store intermediate stages in a collection
|
PBagX<T> |
plus(T e)
Add an element to this Collection
|
PBagX<T> |
plusAll(java.util.Collection<? extends T> list)
Add all supplied elements to this Collection
|
default PBagX<T> |
plusInOrder(T e)
Add an element to the collection
|
static PBagX<java.lang.Integer> |
range(int start,
int end)
Create a PBagX that contains the Integers between start and end
|
static PBagX<java.lang.Long> |
rangeLong(long start,
long end)
Create a PBagX that contains the Longs between start and end
|
default PBagX<T> |
removeAll(java.lang.Iterable<? extends T> it)
Remove all elements in the supplied Iterable from this filterable
|
default PBagX<T> |
removeAll(org.jooq.lambda.Seq<? extends T> stream) |
default PBagX<T> |
removeAll(java.util.stream.Stream<? extends T> stream)
Remove all elements in the supplied Stream from this filterable
|
default PBagX<T> |
removeAll(T... values)
Remove all supplied elements from this filterable
|
default PBagX<T> |
retainAll(java.lang.Iterable<? extends T> it)
Retain only the supplied elements in the returned Filterable
|
default PBagX<T> |
retainAll(org.jooq.lambda.Seq<? extends T> stream) |
default PBagX<T> |
retainAll(java.util.stream.Stream<? extends T> seq)
Retain only the supplied elements in the returned Filterable
|
default PBagX<T> |
retainAll(T... values)
Retain only the supplied elements in the returned Filterable
|
default PBagX<T> |
reverse() |
default PBagX<T> |
scanLeft(Monoid<T> monoid)
Scan left using supplied Monoid
|
default <U> PBagX<U> |
scanLeft(U seed,
java.util.function.BiFunction<? super U,? super T,? extends U> function)
Scan left
|
default PBagX<T> |
scanRight(Monoid<T> monoid)
Scan right
|
default <U> PBagX<U> |
scanRight(U identity,
java.util.function.BiFunction<? super T,? super U,? extends U> combiner)
Scan right
|
default PBagX<T> |
shuffle() |
default PBagX<T> |
shuffle(java.util.Random random) |
static <T> PBagX<T> |
singleton(T value) |
default PBagX<T> |
skip(long num)
assertThat(ReactiveSeq.of(4,3,6,7).skip(2).toList(),equalTo(Arrays.asList(6,7))); |
default PBagX<T> |
skipLast(int num)
assertThat(ReactiveSeq.of(1,2,3,4,5) .skipLast(2)
.collect(Collectors.toList()),equalTo(Arrays.asList(1,2,3)));
|
default PBagX<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 PBagX<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 PBagX<T> |
slice(long from,
long to) |
default PBagX<ListX<T>> |
sliding(int windowSize)
Create a sliding view over this Sequence
|
default PBagX<ListX<T>> |
sliding(int windowSize,
int increment)
Create a sliding view over this Sequence
|
default PBagX<T> |
sorted()
assertThat(ReactiveSeq.of(4,3,6,7)).sorted().toList(),equalTo(Arrays.asList(3,4,6,7))); |
default PBagX<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 PBagX<T> |
takeRight(int num) |
default PBagX<T> |
takeUntil(java.util.function.Predicate<? super T> p) |
default PBagX<T> |
takeWhile(java.util.function.Predicate<? super T> p) |
default org.pcollections.PBag<T> |
toPBag() |
default PBagX<T> |
toPBagX() |
default <R> PBagX<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
|
static <U,T> PBagX<T> |
unfold(U seed,
java.util.function.Function<? super U,java.util.Optional<org.jooq.lambda.tuple.Tuple2<T,U>>> unfolder)
Unfold a function into a PBagX
|
default <R> PBagX<R> |
unit(java.util.Collection<R> col)
Create a new instance of the same colleciton type from the supplied collection
|
default <R> PBagX<R> |
unit(R value) |
default <R> PBagX<R> |
unitIterator(java.util.Iterator<R> it) |
default <U> PBagX<org.jooq.lambda.tuple.Tuple2<T,U>> |
zip(java.lang.Iterable<? extends U> other) |
default <U,R> PBagX<R> |
zip(java.lang.Iterable<? extends U> other,
java.util.function.BiFunction<? super T,? super U,? extends R> zipper) |
default <U> PBagX<org.jooq.lambda.tuple.Tuple2<T,U>> |
zip(org.jooq.lambda.Seq<? extends U> other) |
default <U,R> PBagX<R> |
zip(org.jooq.lambda.Seq<? extends U> other,
java.util.function.BiFunction<? super T,? super U,? extends R> zipper) |
default <U> PBagX<org.jooq.lambda.tuple.Tuple2<T,U>> |
zip(java.util.stream.Stream<? extends U> other)
Zip 2 streams into one
|
default <U,R> PBagX<R> |
zip(java.util.stream.Stream<? extends U> other,
java.util.function.BiFunction<? super T,? super U,? extends R> zipper) |
default <S,U> PBagX<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> PBagX<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 PBagX<org.jooq.lambda.tuple.Tuple2<T,java.lang.Long>> |
zipWithIndex()
Add an index to the current Stream
|
add, addAll, clear, remove, removeAll, retainAllcollectable, findAny, findFirst, forEach2, forEach2, forEach3, forEach3, getAtIndex, groupBy, head, headAndTail, peek, single, single, singleOptionalgroupedStatefullyWhileT, groupedT, groupedUntilT, groupedWhileT, slidingT, slidingTfixedDelay, onePer, xPerfoldable, visitap1, ap2, ap3, ap4, ap5, applicativesflatMapPublisher, flatMapPublisher, flatMapPublisher, mergePublisher, mergePublisherendsWith, 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, xMatchfutureOperations, lazyOperations, subscribe, traversableseq, toCompletableFuture, toDequeX, toEvalAlways, toEvalLater, toEvalNow, toFutureStream, toFutureStream, toFutureW, toIor, toIorSecondary, toListX, toMapX, toMaybe, toOptional, toPMapX, toPOrderedSetX, toPQueueX, toPSetX, toPStackX, toPVectorX, toQueueX, toSetX, toSimpleReact, toSimpleReact, toSortedSetX, toStreamable, toTry, toValue, toValueMap, toValueSet, toXor, toXorSecondarycontains, containsAll, equals, hashCode, isEmpty, iterator, parallelStream, removeIf, size, spliterator, toArray, toArrayallMatch, 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, toStringstatic PBagX<java.lang.Integer> range(int start, int end)
start - Number of range to start fromend - Number for range to end atstatic PBagX<java.lang.Long> rangeLong(long start, long end)
start - Number of range to start fromend - Number for range to end atstatic <U,T> PBagX<T> unfold(U seed, java.util.function.Function<? super U,java.util.Optional<org.jooq.lambda.tuple.Tuple2<T,U>>> unfolder)
PBagX.unfold(1,i->i<=6 ? Optional.of(Tuple.tuple(i,i+1)) : Optional.empty());
//(1,2,3,4,5)
seed - Initial valueunfolder - Iteratively applied function, terminated by an empty Optionalstatic <T> PBagX<T> generate(long limit, java.util.function.Supplier<T> s)
limit - Max number of elements to generates - Supplier to generate PBagX elementsstatic <T> PBagX<T> iterate(long limit, T seed, java.util.function.UnaryOperator<T> f)
limit - Max number of elements to generateseed - Initial elementf - Iteratively applied to each element to generate the next elementdefault 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 PersistentCollectionX<T>stream in interface Sequential<T>stream in interface TransformerTraversable<T>stream in interface Traversable<T>static <T> PBagX<T> of(T... values)
static <T> PBagX<T> empty()
static <T> PBagX<T> singleton(T value)
static <T> PBagX<T> fromPublisher(org.reactivestreams.Publisher<? extends T> publisher)
publisher - to construct PBagX fromstatic <T> PBagX<T> fromIterable(java.lang.Iterable<T> iterable)
static <T> PBagX<T> fromCollection(java.util.Collection<T> stream)
CollectionXfromCollection in interface CollectionX<T>static <T> PBagX<T> fromStream(java.util.stream.Stream<T> stream)
default PBagX<T> combine(java.util.function.BiPredicate<? super T,? super T> predicate, java.util.function.BinaryOperator<T> op)
PBagX.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 PersistentCollectionX<T>combine in interface Traversable<T>predicate - Test to see if two neighbors should be joinedop - Reducer to combine neighborsdefault PBagX<T> toPBagX()
toPBagX in interface ConvertableSequence<T>default <R> PBagX<R> unitIterator(java.util.Iterator<R> it)
unitIterator in interface IterableFunctor<T>default <R> PBagX<R> unit(java.util.Collection<R> col)
FluentCollectionXunit in interface FluentCollectionX<T>unit in interface PersistentCollectionX<T>col - Collection data to populate the new collectiondefault <R> PBagX<R> emptyUnit()
emptyUnit in interface PersistentCollectionX<T>default org.pcollections.PBag<T> toPBag()
default <X> PBagX<X> from(java.util.Collection<X> col)
from in interface CollectionX<T>from in interface PersistentCollectionX<T>default <T> Reducer<org.pcollections.PBag<T>> monoid()
monoid in interface PersistentCollectionX<T>PBagX<T> plus(T e)
FluentCollectionXplus in interface FluentCollectionX<T>plus in interface org.pcollections.PBag<T>plus in interface org.pcollections.PCollection<T>e - Element to addPBagX<T> plusAll(java.util.Collection<? extends T> list)
FluentCollectionXplusAll in interface FluentCollectionX<T>plusAll in interface org.pcollections.PBag<T>plusAll in interface org.pcollections.PCollection<T>list - of elements to addPBagX<T> minus(java.lang.Object e)
FluentCollectionXminus in interface FluentCollectionX<T>minus in interface org.pcollections.PBag<T>minus in interface org.pcollections.PCollection<T>e - Element to removePBagX<T> minusAll(java.util.Collection<?> list)
FluentCollectionXminusAll in interface FluentCollectionX<T>minusAll in interface org.pcollections.PBag<T>minusAll in interface org.pcollections.PCollection<T>list - of elements to removedefault PBagX<T> reverse()
reverse in interface CollectionX<T>reverse in interface PersistentCollectionX<T>reverse in interface Traversable<T>default PBagX<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>filter in interface PersistentCollectionX<T>pred - to filter elements by, retaining matchesdefault <R> PBagX<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>map in interface PersistentCollectionX<T>mapper - Transformation functiondefault <R> PBagX<R> flatMap(java.util.function.Function<? super T,? extends java.lang.Iterable<? extends R>> mapper)
flatMap in interface CollectionX<T>flatMap in interface PersistentCollectionX<T>default PBagX<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 PersistentCollectionX<T>limit in interface Traversable<T>num - Limit element size to numdefault PBagX<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 PersistentCollectionX<T>skip in interface Traversable<T>num - Number of elemenets to skipdefault PBagX<T> takeRight(int num)
takeRight in interface CollectionX<T>takeRight in interface PersistentCollectionX<T>takeRight in interface Traversable<T>default PBagX<T> dropRight(int num)
dropRight in interface CollectionX<T>dropRight in interface PersistentCollectionX<T>dropRight in interface Traversable<T>default PBagX<T> takeWhile(java.util.function.Predicate<? super T> p)
takeWhile in interface CollectionX<T>takeWhile in interface PersistentCollectionX<T>takeWhile in interface Traversable<T>default PBagX<T> dropWhile(java.util.function.Predicate<? super T> p)
dropWhile in interface CollectionX<T>dropWhile in interface PersistentCollectionX<T>dropWhile in interface Traversable<T>default PBagX<T> takeUntil(java.util.function.Predicate<? super T> p)
takeUntil in interface CollectionX<T>takeUntil in interface PersistentCollectionX<T>takeUntil in interface Traversable<T>default PBagX<T> dropUntil(java.util.function.Predicate<? super T> p)
dropUntil in interface CollectionX<T>dropUntil in interface PersistentCollectionX<T>dropUntil in interface Traversable<T>default <R> PBagX<R> trampoline(java.util.function.Function<? super T,? extends Trampoline<? extends R>> mapper)
PersistentCollectionX
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>trampoline in interface PersistentCollectionX<T>default PBagX<T> slice(long from, long to)
slice in interface CollectionX<T>slice in interface PersistentCollectionX<T>slice in interface Traversable<T>default <U extends java.lang.Comparable<? super U>> PBagX<T> sorted(java.util.function.Function<? super T,? extends U> function)
sorted in interface CollectionX<T>sorted in interface PersistentCollectionX<T>sorted in interface Traversable<T>default PBagX<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 PersistentCollectionX<T>grouped in interface Traversable<T>groupSize - Size of each Groupdefault <K,A,D> PBagX<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 PersistentCollectionX<T>grouped in interface Traversable<T>default <K> PBagX<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 PersistentCollectionX<T>grouped in interface Traversable<T>default <U> PBagX<org.jooq.lambda.tuple.Tuple2<T,U>> zip(java.lang.Iterable<? extends U> other)
zip in interface CollectionX<T>zip in interface PersistentCollectionX<T>zip in interface Traversable<T>default <U,R> PBagX<R> zip(java.lang.Iterable<? extends U> other, java.util.function.BiFunction<? super T,? super U,? extends R> zipper)
zip in interface CollectionX<T>zip in interface PersistentCollectionX<T>zip in interface Traversable<T>default <U,R> PBagX<R> zip(org.jooq.lambda.Seq<? extends U> other, java.util.function.BiFunction<? super T,? super U,? extends R> zipper)
zip in interface CollectionX<T>zip in interface PersistentCollectionX<T>zip in interface Traversable<T>default <U,R> PBagX<R> zip(java.util.stream.Stream<? extends U> other, java.util.function.BiFunction<? super T,? super U,? extends R> zipper)
zip in interface CollectionX<T>zip in interface PersistentCollectionX<T>zip in interface Traversable<T>default PBagX<ReactiveSeq<T>> permutations()
ExtendedTraversablepermutations in interface CollectionX<T>permutations in interface ExtendedTraversable<T>permutations in interface PersistentCollectionX<T>default PBagX<ReactiveSeq<T>> combinations(int size)
ExtendedTraversable
ReactiveSeq.of(1,2,3).combinations(2)
//SequenceM[SequenceM[1,2],SequenceM[1,3],SequenceM[2,3]]
combinations in interface CollectionX<T>combinations in interface ExtendedTraversable<T>combinations in interface PersistentCollectionX<T>size - of combinationsdefault PBagX<ReactiveSeq<T>> combinations()
ExtendedTraversable
ReactiveSeq.of(1,2,3).combinations()
//SequenceM[SequenceM[],SequenceM[1],SequenceM[2],SequenceM[3].SequenceM[1,2],SequenceM[1,3],SequenceM[2,3]
,SequenceM[1,2,3]]
combinations in interface CollectionX<T>combinations in interface ExtendedTraversable<T>combinations in interface PersistentCollectionX<T>default PBagX<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 PersistentCollectionX<T>sliding in interface Traversable<T>windowSize - Size of sliding windowdefault PBagX<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 PersistentCollectionX<T>sliding in interface Traversable<T>windowSize - number of elements in each batchincrement - for each windowdefault PBagX<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 PersistentCollectionX<T>scanLeft in interface Traversable<T>default <U> PBagX<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 PersistentCollectionX<T>scanLeft in interface Traversable<T>default PBagX<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 PersistentCollectionX<T>scanRight in interface Traversable<T>default <U> PBagX<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 PersistentCollectionX<T>scanRight in interface Traversable<T>default PBagX<T> plusInOrder(T e)
FluentCollectionXplusInOrder in interface FluentCollectionX<T>plusInOrder in interface PersistentCollectionX<T>e - Element to adddefault PBagX<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 PersistentCollectionX<T>cycle in interface Traversable<T>times - Times values should be repeated within a Streamdefault PBagX<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 PersistentCollectionX<T>cycle in interface Traversable<T>m - Monoid to be used in reductiontimes - Number of times value should be repeateddefault PBagX<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 PersistentCollectionX<T>cycleWhile in interface Traversable<T>predicate - repeat while truedefault PBagX<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 PersistentCollectionX<T>cycleUntil in interface Traversable<T>predicate - repeat while truedefault <U> PBagX<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 PersistentCollectionX<T>zip in interface Traversable<T>default <U> PBagX<org.jooq.lambda.tuple.Tuple2<T,U>> zip(org.jooq.lambda.Seq<? extends U> other)
zip in interface CollectionX<T>zip in interface PersistentCollectionX<T>zip in interface Traversable<T>default <S,U> PBagX<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 PersistentCollectionX<T>zip3 in interface Traversable<T>default <T2,T3,T4> PBagX<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 PersistentCollectionX<T>zip4 in interface Traversable<T>default PBagX<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 PersistentCollectionX<T>zipWithIndex in interface Traversable<T>default PBagX<T> distinct()
distinct in interface CollectionX<T>distinct in interface PersistentCollectionX<T>distinct in interface Traversable<T>default PBagX<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 PersistentCollectionX<T>sorted in interface Traversable<T>default PBagX<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 PersistentCollectionX<T>sorted in interface Traversable<T>c - Compartor to sort withdefault PBagX<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 PersistentCollectionX<T>skipWhile in interface Traversable<T>p - Predicate to skip while truedefault PBagX<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 PersistentCollectionX<T>skipUntil in interface Traversable<T>p - Predicate to skip until truedefault PBagX<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 PersistentCollectionX<T>limitWhile in interface Traversable<T>p - Limit while predicate is truedefault PBagX<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 PersistentCollectionX<T>limitUntil in interface Traversable<T>p - Limit until predicate is truedefault PBagX<T> intersperse(T value)
Traversableintersperse in interface CollectionX<T>intersperse in interface PersistentCollectionX<T>intersperse in interface Traversable<T>default PBagX<T> shuffle()
shuffle in interface CollectionX<T>shuffle in interface PersistentCollectionX<T>shuffle in interface Traversable<T>default PBagX<T> skipLast(int num)
TraversableskipLast in interface CollectionX<T>skipLast in interface PersistentCollectionX<T>skipLast in interface Traversable<T>default PBagX<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 PersistentCollectionX<T>limitLast in interface Traversable<T>num - of elements to return (last elements)default PBagX<T> onEmpty(T value)
onEmpty in interface CollectionX<T>onEmpty in interface PersistentCollectionX<T>onEmpty in interface Traversable<T>default PBagX<T> onEmptyGet(java.util.function.Supplier<? extends T> supplier)
onEmptyGet in interface CollectionX<T>onEmptyGet in interface PersistentCollectionX<T>onEmptyGet in interface Traversable<T>default <X extends java.lang.Throwable> PBagX<T> onEmptyThrow(java.util.function.Supplier<? extends X> supplier)
onEmptyThrow in interface CollectionX<T>onEmptyThrow in interface PersistentCollectionX<T>onEmptyThrow in interface Traversable<T>default PBagX<T> shuffle(java.util.Random random)
shuffle in interface CollectionX<T>shuffle in interface PersistentCollectionX<T>shuffle in interface Traversable<T>default <U> PBagX<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>ofType in interface PersistentCollectionX<T>default PBagX<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>filterNot in interface PersistentCollectionX<T>fn - to filter elements by, retaining matchesdefault PBagX<T> notNull()
Filterable
of(1,2,null,4).nonNull();
//[1,2,4]
notNull in interface CollectionX<T>notNull in interface Filterable<T>notNull in interface PersistentCollectionX<T>default PBagX<T> removeAll(java.util.stream.Stream<? extends T> stream)
IterableFilterableremoveAll in interface CollectionX<T>removeAll in interface IterableFilterable<T>removeAll in interface PersistentCollectionX<T>stream - of elements to removedefault PBagX<T> removeAll(java.lang.Iterable<? extends T> it)
IterableFilterableremoveAll in interface CollectionX<T>removeAll in interface IterableFilterable<T>removeAll in interface PersistentCollectionX<T>it - an Iterable of elements to removedefault PBagX<T> removeAll(T... values)
IterableFilterableremoveAll in interface CollectionX<T>removeAll in interface IterableFilterable<T>removeAll in interface PersistentCollectionX<T>values - to removedefault PBagX<T> retainAll(java.lang.Iterable<? extends T> it)
IterableFilterableretainAll in interface CollectionX<T>retainAll in interface IterableFilterable<T>retainAll in interface PersistentCollectionX<T>it - Iterable of elements to retaindefault PBagX<T> retainAll(java.util.stream.Stream<? extends T> seq)
IterableFilterableretainAll in interface CollectionX<T>retainAll in interface IterableFilterable<T>retainAll in interface PersistentCollectionX<T>seq - of elements to retaindefault PBagX<T> retainAll(T... values)
IterableFilterableretainAll in interface CollectionX<T>retainAll in interface IterableFilterable<T>retainAll in interface PersistentCollectionX<T>values - elements to retaindefault <U> PBagX<U> cast(java.lang.Class<? extends U> type)
FunctorClassCastException.
// ClassCastException ReactiveSeq.of(1, "a", 2, "b", 3).cast(Integer.class)cast in interface CollectionX<T>cast in interface Functor<T>cast in interface PersistentCollectionX<T>default <R> PBagX<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>patternMatch in interface PersistentCollectionX<T>case1 - Function to generate a case (or chain of cases as a single case)otherwise - Value if supplied case doesn't matchdefault <C extends java.util.Collection<? super T>> PBagX<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 PersistentCollectionX<T>grouped in interface Traversable<T>size - batch sizesupplier - Collection factorydefault PBagX<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 PersistentCollectionX<T>groupedUntil in interface Traversable<T>predicate - Batch until predicate holds, then open next batchdefault PBagX<ListX<T>> groupedStatefullyWhile(java.util.function.BiPredicate<ListX<? super T>,? super T> predicate)
Traversable
assertThat(ReactiveSeq.of(1,2,3,4,5,6)
.groupedStatefullyWhile((s,i)->s.contains(4) ? true : false)
.toList().size(),equalTo(5));
groupedStatefullyWhile in interface CollectionX<T>groupedStatefullyWhile in interface PersistentCollectionX<T>groupedStatefullyWhile in interface Traversable<T>predicate - Window while truedefault PBagX<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 PersistentCollectionX<T>groupedWhile in interface Traversable<T>predicate - Batch while predicate holds, then open next batchdefault <C extends java.util.Collection<? super T>> PBagX<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 PersistentCollectionX<T>groupedWhile in interface Traversable<T>predicate - Batch while predicate holds, then open next batchfactory - Collection factorydefault <C extends java.util.Collection<? super T>> PBagX<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 PersistentCollectionX<T>groupedUntil in interface Traversable<T>predicate - Batch until predicate holds, then open next batchfactory - Collection factorydefault PBagX<T> removeAll(org.jooq.lambda.Seq<? extends T> stream)
removeAll in interface CollectionX<T>removeAll in interface PersistentCollectionX<T>default PBagX<T> retainAll(org.jooq.lambda.Seq<? extends T> stream)
retainAll in interface CollectionX<T>retainAll in interface PersistentCollectionX<T>