public interface PBagX<T> extends To<PBagX<T>>, org.pcollections.PBag<T>, PersistentCollectionX<T>, OnEmptySwitch<T,org.pcollections.PBag<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()
Generate the combinations based on values in the ExtendedTraversable.
|
default PBagX<ReactiveSeq<T>> |
combinations(int size)
Generate the combinations based on values in the ExtendedTraversable.
|
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)
Generate a new Traversable that drops the specified number elements from the end of this Traversable
|
default PBagX<T> |
dropUntil(java.util.function.Predicate<? super T> p)
Generate a new Traversable that drops elements from this Traversable until the predicate holds
|
default PBagX<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
|
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)
Perform a flatMap operation on this collection.
|
default <X> PBagX<X> |
from(java.util.Collection<X> col)
Conctruct an Extended Collection from a standard Collection
|
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)
Group this Traversable by the provided classifying function and collected by the provided Collector
|
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)
Group this Traversable by the provided classifying function and collected by the provided Collector
|
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>> |
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 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 ReactiveSeq 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() |
static <T> PBagX<T> |
narrow(PBagX<? extends T> bagX)
Narrow a covariant PBagX
|
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)
If this Container instance is empty, create a new instance containing the provided value
|
default PBagX<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 PBagX<T> |
onEmptySwitch(java.util.function.Supplier<? extends org.pcollections.PBag<T>> supplier)
Switch to container created by provided Supplier, if current Container empty
|
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> 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 ExtendedTraversable.
|
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)
Remove all elements from this collection that match the values in the provided Seq
|
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)
Retain all elements from this collection that match the values in the provided Seq
|
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()
Potentially efficient Stream reversal.
|
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)
Generate a new Traversable that takes the specified number elements from the end of this Traversable
|
default PBagX<T> |
takeUntil(java.util.function.Predicate<? super T> p)
Generate a new Traversable that takes elements from this Traversable until the predicate holds
|
default PBagX<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 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)
Create an IterableFunctor instance of the same type from an Iterator
|
default <U> PBagX<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> PBagX<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> PBagX<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> PBagX<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> 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)
Zip (combine) this Zippable with the supplied Stream, using the supplied combining function
|
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, retainAll
collectable, findAny, findFirst, forEach2, forEach2, forEach3, forEach3, 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
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, toPMapX, toPOrderedSetX, toPQueueX, toPSetX, toPStackX, toPVectorX, toQueueX, toSetX, toSimpleReact, toSimpleReact, toSortedSetX, toStreamable, toTry, toValue, toValueMap, toValueSet, toXor, toXorSecondary
contains, containsAll, equals, hashCode, isEmpty, iterator, parallelStream, removeIf, 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
static <T> PBagX<T> narrow(PBagX<? extends T> bagX)
PBaagX<? extends Fruit> set = PBagX.of(apple,bannana);
PBagX<Fruit> fruitSet = PBagX.narrow(set);
bagX
- to narrow generic typestatic 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)
CollectionX
fromCollection
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)
IterableFunctor
ReactiveSeq<Integer> newSeq = seq.unitIterator(myIterator);
unitIterator
in interface IterableFunctor<T>
it
- Iterator to create new IterableFunctor fromdefault <R> PBagX<R> unit(java.util.Collection<R> col)
FluentCollectionX
unit
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)
CollectionX
from
in interface CollectionX<T>
from
in interface PersistentCollectionX<T>
col
- Collection to extenddefault <T> Reducer<org.pcollections.PBag<T>> monoid()
monoid
in interface PersistentCollectionX<T>
PBagX<T> plus(T e)
FluentCollectionX
plus
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)
FluentCollectionX
plusAll
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)
FluentCollectionX
minus
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)
FluentCollectionX
minusAll
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()
Traversable
assertThat( of(1, 2, 3).reverse().toList(),
equalTo(asList(3, 2, 1)));
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)
CollectionX
flatMap
in interface CollectionX<T>
flatMap
in interface PersistentCollectionX<T>
mapper
- Transformation function to be applied (and flattened)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)
Traversable
ListX.of(1,2,3).takeRight(2);
//[2,3]
takeRight
in interface CollectionX<T>
takeRight
in interface PersistentCollectionX<T>
takeRight
in interface Traversable<T>
num
- Take this number of elements from the end of this Traversabledefault PBagX<T> dropRight(int num)
Traversable
ListX.of(1,2,3).dropRight(2);
//[1]
dropRight
in interface CollectionX<T>
dropRight
in interface PersistentCollectionX<T>
dropRight
in interface Traversable<T>
num
- Drop this number of elements from the end of this Traversabledefault PBagX<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 PersistentCollectionX<T>
takeWhile
in interface Traversable<T>
p
- Predicate to determine when values should be takendefault PBagX<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 PersistentCollectionX<T>
dropWhile
in interface Traversable<T>
p
- Predicate to determine when values should be droppeddefault PBagX<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 PersistentCollectionX<T>
takeUntil
in interface Traversable<T>
p
- Predicate to determine when values should be taken untildefault PBagX<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 PersistentCollectionX<T>
dropUntil
in interface Traversable<T>
p
- Predicate to determine when values should be droppeddefault <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>
mapper
- TCO Transformation functiondefault 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
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)
Traversable
grouped
in interface CollectionX<T>
grouped
in interface PersistentCollectionX<T>
grouped
in interface Traversable<T>
classifier
- Grouping functiondownstream
- Collector to create the grouping collectiondefault <K> PBagX<org.jooq.lambda.tuple.Tuple2<K,org.jooq.lambda.Seq<T>>> grouped(java.util.function.Function<? super T,? extends K> classifier)
Traversable
grouped
in interface CollectionX<T>
grouped
in interface PersistentCollectionX<T>
grouped
in interface Traversable<T>
classifier
- Grouping functiondefault <U> PBagX<org.jooq.lambda.tuple.Tuple2<T,U>> zip(java.lang.Iterable<? extends U> other)
CollectionX
zip
in interface CollectionX<T>
zip
in interface PersistentCollectionX<T>
zip
in interface Traversable<T>
zip
in interface Zippable<T>
other
- Collection to merge with this onedefault <U,R> PBagX<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 PersistentCollectionX<T>
zip
in interface Traversable<T>
zip
in interface Zippable<T>
other
- to zip withzipper
- Zip functiondefault <U,R> PBagX<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 PersistentCollectionX<T>
zip
in interface Traversable<T>
zip
in interface Zippable<T>
other
- Seq to combine withzipper
- Zip / combining functiondefault <U,R> PBagX<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 PersistentCollectionX<T>
zip
in interface Traversable<T>
zip
in interface Zippable<T>
other
- Stream to combine withzipper
- Zip / combining functiondefault PBagX<ReactiveSeq<T>> permutations()
ExtendedTraversable
permutations
in interface CollectionX<T>
permutations
in interface ExtendedTraversable<T>
permutations
in interface PersistentCollectionX<T>
default PBagX<ReactiveSeq<T>> combinations(int size)
ExtendedTraversable
ExtendedTraversable<Integer> stream = ReactiveSeq.of(1,2,3);
stream.combinations(2)
//ReactiveSeq[ReactiveSeq[1,2],ReactiveSeq[1,3],ReactiveSeq[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()
//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>
combinations
in interface PersistentCollectionX<T>
default PBagX<ListX<T>> sliding(int windowSize)
Traversable
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
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)
FluentCollectionX
plusInOrder
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
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
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>
zip
in interface Zippable<T>
other
- Stream to combine withdefault <U> PBagX<org.jooq.lambda.tuple.Tuple2<T,U>> zip(org.jooq.lambda.Seq<? extends U> other)
Zippable
zip
in interface CollectionX<T>
zip
in interface PersistentCollectionX<T>
zip
in interface Traversable<T>
zip
in interface Zippable<T>
other
- Seq to combine withdefault <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
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
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)
Traversable
intersperse
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)
Traversable
skipLast
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> onEmptySwitch(java.util.function.Supplier<? extends org.pcollections.PBag<T>> supplier)
OnEmptySwitch
ListX.empty().onEmptySwitch(()->ListX.of(1));
onEmptySwitch
in interface OnEmptySwitch<T,org.pcollections.PBag<T>>
supplier
- to create replacement containerdefault PBagX<T> onEmpty(T value)
OnEmpty
onEmpty
in interface CollectionX<T>
onEmpty
in interface OnEmpty<T>
onEmpty
in interface PersistentCollectionX<T>
onEmpty
in interface Traversable<T>
default PBagX<T> onEmptyGet(java.util.function.Supplier<? extends T> supplier)
OnEmpty
onEmptyGet
in interface CollectionX<T>
onEmptyGet
in interface OnEmpty<T>
onEmptyGet
in interface PersistentCollectionX<T>
onEmptyGet
in interface Traversable<T>
supplier
- to determine new value for containerdefault <X extends java.lang.Throwable> PBagX<T> onEmptyThrow(java.util.function.Supplier<? extends X> supplier)
OnEmpty
onEmptyThrow
in interface CollectionX<T>
onEmptyThrow
in interface OnEmpty<T>
onEmptyThrow
in interface PersistentCollectionX<T>
onEmptyThrow
in interface Traversable<T>
supplier
- to create exception fromdefault 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)
IterableFilterable
removeAll
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)
IterableFilterable
removeAll
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)
IterableFilterable
removeAll
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)
IterableFilterable
retainAll
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)
IterableFilterable
retainAll
in interface CollectionX<T>
retainAll
in interface IterableFilterable<T>
retainAll
in interface PersistentCollectionX<T>
seq
- of elements to retaindefault PBagX<T> retainAll(T... values)
IterableFilterable
retainAll
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)
Functor
ClassCastException
.
// 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>> 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 PersistentCollectionX<T>
groupedStatefullyUntil
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
ReactiveSeq.of(1,2,3,4,5,6)
.groupedUntil(i->i%3!=0)
.toList()
//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)
CollectionX
removeAll
in interface CollectionX<T>
removeAll
in interface PersistentCollectionX<T>
stream
- Stream of values to removedefault PBagX<T> retainAll(org.jooq.lambda.Seq<? extends T> stream)
CollectionX
retainAll
in interface CollectionX<T>
retainAll
in interface PersistentCollectionX<T>
stream
- Stream of values to retain