T
- the type of elements held in this collectionpublic interface LazyFluentCollectionX<T> extends FluentCollectionX<T>
Fn1.µ, Fn1.FunctionalOperations<T1,R>
Modifier and Type | Method and Description |
---|---|
LazyFluentCollectionX<T> |
materialize() |
FluentCollectionX<T> |
minus(java.lang.Object e)
Remove the specified element from this collection
|
FluentCollectionX<T> |
minusAll(java.util.Collection<?> list)
Remove all the specified elements from this collection
|
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 collection
|
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 collection
|
plusLoop, plusLoop
cast, combinations, combinations, combine, cycle, cycle, cycleUntil, cycleWhile, distinct, drop, dropRight, dropUntil, dropWhile, filter, filterNot, findAny, findFirst, flatMap, flatMapP, flatMapS, forEach2, forEach2, forEach3, forEach3, forEach4, forEach4, from, fromCollection, getAtIndex, groupBy, grouped, grouped, grouped, grouped, groupedStatefullyUntil, groupedUntil, groupedUntil, groupedWhile, groupedWhile, head, headAndTail, intersperse, isEmpty, iterator, limit, limitLast, limitUntil, limitWhile, map, notNull, onEmpty, onEmptyGet, onEmptyThrow, peek, permutations, removeAllS, removeAllS, removeAllS, retainAllS, retainAllS, retainAllS, reverse, scanLeft, scanLeft, scanRight, scanRight, shuffle, shuffle, single, single, singleOptional, skip, skipLast, skipUntil, skipWhile, slice, sliding, sliding, sorted, sorted, sorted, stream, take, takeRight, takeUntil, takeWhile, trampoline, unit, zip, zip, zip3, zip4, zipS, zipS, zipWithIndex
apply, foldFuture, foldLazy, foldTry, forEach, forEach, forEach, forEach, forEach, runFuture, runLazy, seq, subscribe, subscribe, subscribe, visit
andThen, andThen, bind, compose, functionOps, lift, lift, liftF, liftOpt, liftTry, memoize, memoize, product, reader, λ, λv
apply, applyPartially, applyPartially, curry, curry, from, toFunction
allMatch, anyMatch, avg, avgDouble, avgInt, avgLong, bitAnd, bitAndInt, bitAndLong, bitOr, bitOrInt, bitOrLong, collect, collectable, 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, sumDouble, sumInt, sumLong, toCollection, toList, toList, toMap, toMap, toSet, 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, toConcurrentLazyCollection, toConcurrentLazyStreamable, toLazyCollection, xMatch
toDequeX, toFutureStream, toFutureStream, toListX, toMapX, toOptional, toPBagX, toPMapX, toPOrderedSetX, toPQueueX, toPSetX, toPStackX, toPVectorX, toQueueX, toSetX, toSimpleReact, toSimpleReact, toSortedSetX, toStreamable, toValue
append, append, deleteBetween, insertAt, insertAtS, mapToDouble, mapToInt, mapToLong, prepend, prepend, prependS, recover, recover, subscribe, traversable, unitIterator
zip, zip3, zip4, zipP, zipP, zipWith, zipWithP, zipWithS
futureStream, getStreamable, jdkStream, reactiveSeq, reveresedJDKStream, reveresedStream
retry, retry
groupedStatefullyUntilT, groupedT, groupedUntilT, groupedWhileT, slidingT, slidingT
fixedDelay, onePer, xPer
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 collection / reduction method will be used in the newly created Object. I.e. Calling reactiveStream(Flux) on
a collection which as an Immutable Collector will result in an Immutable Collection.stream
- Flux to create new collection 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 collection