T
- the type of elements held in this toXpublic interface LazyFluentCollectionX<T> extends FluentCollectionX<T>
Modifier and Type | Method and Description |
---|---|
LazyFluentCollectionX<T> |
materialize() |
FluentCollectionX<T> |
minus(java.lang.Object e)
Remove the specified element from this toX
|
FluentCollectionX<T> |
minusAll(java.util.Collection<?> list)
Remove all the specified elements from this toX
|
default LazyFluentCollectionX<T> |
minusAllLazy(java.util.Collection<?> list)
Lazily remove the elements in the supplied Collection from this Collection.
|
default LazyFluentCollectionX<T> |
minusLazy(java.lang.Object e)
Lazily remove an element from this Collection.
|
FluentCollectionX<T> |
plus(T e)
Add an element to this Collection
|
FluentCollectionX<T> |
plusAll(java.util.Collection<? extends T> list)
Add all supplied elements to this Collection
|
default LazyFluentCollectionX<T> |
plusAllLazy(java.util.Collection<? extends T> col)
Lazily add all the elements in the supplied Collection to this Collection.
|
default FluentCollectionX<T> |
plusInOrder(T e)
Add an element to the toX
|
default LazyFluentCollectionX<T> |
plusLazy(T e)
Lazily add an element to this Collection.
|
<X> FluentCollectionX<X> |
stream(ReactiveSeq<X> stream)
Create a LazyFluentCollection from a Flux.
|
<R> FluentCollectionX<R> |
unit(java.util.Collection<R> col)
Create a new instance of the same colleciton type from the supplied toX
|
plusLoop, plusLoop
cast, combinations, combinations, combine, cycle, cycle, cycleUntil, cycleWhile, distinct, drop, dropRight, dropUntil, dropWhile, eager, evaluation, filter, filterNot, findAny, findFirst, flatMap, flatMapP, flatMapP, flatMapS, forEach2, forEach2, forEach3, forEach3, forEach4, forEach4, from, fromCollection, getAtIndex, groupBy, grouped, grouped, grouped, grouped, groupedStatefullyUntil, groupedUntil, groupedUntil, groupedWhile, groupedWhile, head, headAndTail, intersperse, isEager, isEmpty, isLazy, isMaterialized, iterator, lazy, limit, limitLast, limitUntil, limitWhile, map, materializeReversed, notNull, onEmpty, onEmptyGet, onEmptyThrow, peek, permutations, removeAll, removeAllI, removeAllS, retainAll, retainAllI, retainAllS, reverse, scanLeft, scanLeft, scanRight, scanRight, shuffle, shuffle, single, single, singleUnsafe, skip, skipLast, skipUntil, skipWhile, slice, sliding, sliding, sorted, sorted, sorted, stream, take, takeOne, takeRight, takeUntil, takeWhile, toX, trampoline, unit, zip, zip, zip3, zip4, zipS, zipS, zipWithIndex
asFunction, foldFuture, foldLazy, foldTry, forEach, forEach, forEach, forEach, forEach, forEachSubscribe, forEachSubscribe, forEachSubscribe, runFuture, runLazy, seq, toListX, toSetX, visit
allMatch, anyMatch, collect, collectors, commonPrefix, commonSuffix, count, count, countDistinct, countDistinct, countDistinctBy, countDistinctBy, max, maxBy, min, minBy, mode, noneMatch, sum, sumDouble, sumInt, sumLong, to, toList, toMap, toMap, toSet, toString, toString
endsWith, endsWithIterable, firstValue, foldLeft, foldLeft, foldLeft, foldLeft, foldRight, foldRight, foldRight, foldRightMapToType, get, join, join, join, mapReduce, mapReduce, print, print, printErr, printOut, reduce, reduce, reduce, reduce, reduce, reduce, reduce, schedule, scheduleFixedDelay, scheduleFixedRate, startsWith, startsWithIterable, xMatch
append, append, combine, deleteBetween, insertAt, insertAtS, mapToDouble, mapToInt, mapToLong, prepend, prepend, prependS, recover, recover, subscribe, traversable, unitIterator, zip, zip3, zip4, zipP, zipP, zipWith, zipWithP, zipWithS
retry, retry
groupedStatefullyUntilT, groupedT, groupedUntilT, groupedWhileT, slidingT, slidingT
fixedDelay, onePer, xPer
add, addAll, clear, contains, containsAll, equals, hashCode, parallelStream, remove, removeAll, removeIf, retainAll, size, spliterator, toArray, toArray
unwrap, unwrapIfInstance, unwrapNested
LazyFluentCollectionX<T> materialize()
materialize
in interface CollectionX<T>
<X> FluentCollectionX<X> stream(ReactiveSeq<X> stream)
LazyListX<Integer> lazyInts = LazyListX.of(1,2,3);
LazyListX<String> lazyStrs = lazyInts.reactiveStream(Flux.just("hello","world"));
Calling reactiveStream(Flux) on a LazySetX results in a LazySetX etc.
The same toX / reduction method will be used in the newly created Object. I.e. Calling reactiveStream(Flux) on
a toX which as an Immutable Collector will result in an Immutable Collection.stream
- Flux to create new toX fromdefault LazyFluentCollectionX<T> plusLazy(T e)
plus(Object)
LazyListX<Integer> lazy = LazyListX.of(1,2,3)
.map(i->i*2)
.plusLazy(5);
//Lazy List that will contain [2,4,6,5] when triggered
e
- Element to adddefault LazyFluentCollectionX<T> plusAllLazy(java.util.Collection<? extends T> col)
LazyFluentCollectionX#plusAll(Object)
LazyListX<Integer> lazy = LazyListX.of(1,2,3)
.map(i->i*2)
.plusAllLazy(ListX.of(5,10));
//Lazy List that will contain [2,4,6,5,10] when triggered
col
- Collection to adddefault LazyFluentCollectionX<T> minusLazy(java.lang.Object e)
minus(Object)
LazyListX<Integer> lazy = LazyListX.of(1,2,3)
.map(i->i*2)
.minusLazy(4);
//Lazy List that will contain [2,6] when triggered
This is an equivalent operation to filtering by equality e.g.
LazyListX<Integer> lazy = LazyListX.of(1,2,3)
.map(i->i*2)
.filter(i->i==4);
//Lazy List that will contain [2,6] when triggered
e
- Element to removedefault LazyFluentCollectionX<T> minusAllLazy(java.util.Collection<?> list)
minusAll(Collection)
LazyListX<Integer> lazy = LazyListX.of(1,2,3)
.map(i->i*2)
.minusAllLazy(ListX.of(4));
//Lazy List that will contain [2,6] when triggered
This is an equivalent operation to filtering by equality e.g.
LazyListX<Integer> lazy = LazyListX.of(1,2,3)
.map(i->i*2)
.filter(i->ListX.of(4).contains(i));
//Lazy List that will contain [2,6] when triggered
list
- of elements to removedefault FluentCollectionX<T> plusInOrder(T e)
FluentCollectionX
plusInOrder
in interface FluentCollectionX<T>
e
- Element to addFluentCollectionX<T> plus(T e)
FluentCollectionX
plus
in interface FluentCollectionX<T>
e
- Element to addFluentCollectionX<T> plusAll(java.util.Collection<? extends T> list)
FluentCollectionX
plusAll
in interface FluentCollectionX<T>
list
- of elements to addFluentCollectionX<T> minus(java.lang.Object e)
FluentCollectionX
minus
in interface FluentCollectionX<T>
e
- Element to removeFluentCollectionX<T> minusAll(java.util.Collection<?> list)
FluentCollectionX
minusAll
in interface FluentCollectionX<T>
list
- of elements to remove<R> FluentCollectionX<R> unit(java.util.Collection<R> col)
FluentCollectionX
unit
in interface FluentCollectionX<T>
col
- Collection data to populate the new toX