public interface DequeX<T> extends java.util.Deque<T>, MutableCollectionX<T>
Modifier and Type | Method and Description |
---|---|
default <U> DequeX<U> |
cast(java.lang.Class<? extends U> type)
Cast all elements in a stream to a given type, possibly throwing a
ClassCastException . |
default DequeX<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 DequeX<ReactiveSeq<T>> |
combinations(int size)
ReactiveSeq.of(1,2,3).combinations(2)
//SequenceM[SequenceM[1,2],SequenceM[1,3],SequenceM[2,3]]
|
default DequeX<T> |
combine(java.util.function.BiPredicate<? super T,? super T> predicate,
java.util.function.BinaryOperator<T> op)
Combine two adjacent elements in a DequeX using the supplied BinaryOperator
This is a stateful grouping & reduction operation.
|
default DequeX<T> |
cycle(int times)
Convert to a Stream with the values repeated specified times
|
default DequeX<T> |
cycle(Monoid<T> m,
int times)
Convert to a Stream with the result of a reduction operation repeated
specified times
|
default DequeX<T> |
cycleUntil(java.util.function.Predicate<? super T> predicate)
Repeat in a Stream until specified predicate holds
|
default DequeX<T> |
cycleWhile(java.util.function.Predicate<? super T> predicate)
Repeat in a Stream while specified predicate holds
|
static <T> java.util.stream.Collector<T,?,java.util.Deque<T>> |
defaultCollector() |
default DequeX<T> |
distinct() |
default DequeX<T> |
dropRight(int num) |
default DequeX<T> |
dropUntil(java.util.function.Predicate<? super T> p) |
default DequeX<T> |
dropWhile(java.util.function.Predicate<? super T> p) |
static <T> DequeX<T> |
empty() |
default DequeX<T> |
filter(java.util.function.Predicate<? super T> pred)
Keep only elements for which the supplied predicates hold
e.g.
|
default DequeX<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> DequeX<R> |
flatMap(java.util.function.Function<? super T,? extends java.lang.Iterable<? extends R>> mapper) |
default <T1> DequeX<T1> |
from(java.util.Collection<T1> c) |
static <T> DequeX<T> |
fromIterable(java.util.stream.Collector<T,?,java.util.Deque<T>> collector,
java.lang.Iterable<T> it) |
static <T> DequeX<T> |
fromIterable(java.lang.Iterable<T> it) |
static <T> DequeX<T> |
fromPublisher(org.reactivestreams.Publisher<? extends T> publisher)
Construct a DequeX from an Publisher
|
default <X> DequeX<X> |
fromStream(java.util.stream.Stream<X> stream) |
static <T> DequeX<T> |
generate(long limit,
java.util.function.Supplier<T> s)
Generate a DequeX from the provided Supplier up to the provided limit number of times
|
<T> java.util.stream.Collector<T,?,java.util.Deque<T>> |
getCollector() |
default <K> DequeX<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> DequeX<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 DequeX<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 DequeX<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 DequeX<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 DequeX<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 DequeX<T> |
intersperse(T value)
Returns a stream with a given value interspersed between any two values
of this stream.
|
static <T> DequeX<T> |
iterate(long limit,
T seed,
java.util.function.UnaryOperator<T> f)
Create a DequeX by iterative application of a function to an initial element up to the supplied limit number of times
|
default DequeX<T> |
limit(long num)
assertThat(ReactiveSeq.of(4,3,6,7).limit(2).toList(),equalTo(Arrays.asList(4,3)); |
default DequeX<T> |
limitLast(int num)
Limit results to the last x elements in a SequenceM
|
default DequeX<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 DequeX<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> DequeX<R> |
map(java.util.function.Function<? super T,? extends R> mapper)
Transform this functor using the supplied transformation function
|
default DequeX<T> |
minus(java.lang.Object e)
Remove the specified element from this collection
|
default DequeX<T> |
minusAll(java.util.Collection<?> list)
Remove all the specified elements from this collection
|
default DequeX<T> |
notNull()
Filter elements retaining only values which are not null
|
static <T> DequeX<T> |
of(T... values) |
default <U> DequeX<U> |
ofType(java.lang.Class<? extends U> type)
Keep only those elements in a stream that are of a given type.
|
default DequeX<T> |
onEmpty(T value) |
default DequeX<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> DequeX<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 DequeX<T> |
peek(java.util.function.Consumer<? super T> c)
Peek at the current value of this Functor, without transforming it
|
default DequeX<ReactiveSeq<T>> |
permutations()
Generate the permutations based on values in the SequenceM Makes use of
Streamable to store intermediate stages in a collection
|
default DequeX<T> |
plus(T e)
Add an element to this Collection
|
default DequeX<T> |
plusAll(java.util.Collection<? extends T> list)
Add all supplied elements to this Collection
|
static DequeX<java.lang.Integer> |
range(int start,
int end)
Create a DequeX that contains the Integers between start and end
|
static DequeX<java.lang.Long> |
rangeLong(long start,
long end)
Create a DequeX that contains the Longs between start and end
|
default DequeX<T> |
removeAll(java.lang.Iterable<? extends T> it)
Remove all elements in the supplied Iterable from this filterable
|
default DequeX<T> |
removeAll(org.jooq.lambda.Seq<? extends T> stream) |
default DequeX<T> |
removeAll(java.util.stream.Stream<? extends T> stream)
Remove all elements in the supplied Stream from this filterable
|
default DequeX<T> |
removeAll(T... values)
Remove all supplied elements from this filterable
|
default DequeX<T> |
retainAll(java.lang.Iterable<? extends T> it)
Retain only the supplied elements in the returned Filterable
|
default DequeX<T> |
retainAll(org.jooq.lambda.Seq<? extends T> stream) |
default DequeX<T> |
retainAll(java.util.stream.Stream<? extends T> seq)
Retain only the supplied elements in the returned Filterable
|
default DequeX<T> |
retainAll(T... values)
Retain only the supplied elements in the returned Filterable
|
default DequeX<T> |
reverse() |
default DequeX<T> |
scanLeft(Monoid<T> monoid)
Scan left using supplied Monoid
|
default <U> DequeX<U> |
scanLeft(U seed,
java.util.function.BiFunction<? super U,? super T,? extends U> function)
Scan left
|
default DequeX<T> |
scanRight(Monoid<T> monoid)
Scan right
|
default <U> DequeX<U> |
scanRight(U identity,
java.util.function.BiFunction<? super T,? super U,? extends U> combiner)
Scan right
|
default DequeX<T> |
shuffle() |
default DequeX<T> |
shuffle(java.util.Random random) |
static <T> DequeX<T> |
singleton(T value) |
default DequeX<T> |
skip(long num)
assertThat(ReactiveSeq.of(4,3,6,7).skip(2).toList(),equalTo(Arrays.asList(6,7))); |
default DequeX<T> |
skipLast(int num)
assertThat(ReactiveSeq.of(1,2,3,4,5) .skipLast(2)
.collect(Collectors.toList()),equalTo(Arrays.asList(1,2,3)));
|
default DequeX<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 DequeX<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 DequeX<T> |
slice(long from,
long to) |
default DequeX<ListX<T>> |
sliding(int windowSize)
Create a sliding view over this Sequence
|
default DequeX<ListX<T>> |
sliding(int windowSize,
int increment)
Create a sliding view over this Sequence
|
default DequeX<T> |
sorted()
assertThat(ReactiveSeq.of(4,3,6,7)).sorted().toList(),equalTo(Arrays.asList(3,4,6,7))); |
default DequeX<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 DequeX<T> |
takeRight(int num) |
default DequeX<T> |
takeUntil(java.util.function.Predicate<? super T> p) |
default DequeX<T> |
takeWhile(java.util.function.Predicate<? super T> p) |
default DequeX<T> |
toDequeX() |
default <R> DequeX<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> DequeX<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 DequeX
|
default <R> DequeX<R> |
unit(java.util.Collection<R> col)
Create a new instance of the same colleciton type from the supplied collection
|
default <R> DequeX<R> |
unit(R value) |
default <R> DequeX<R> |
unitIterator(java.util.Iterator<R> it) |
default <U> DequeX<org.jooq.lambda.tuple.Tuple2<T,U>> |
zip(java.lang.Iterable<? extends U> other) |
default <U,R> DequeX<R> |
zip(java.lang.Iterable<? extends U> other,
java.util.function.BiFunction<? super T,? super U,? extends R> zipper) |
default <U> DequeX<org.jooq.lambda.tuple.Tuple2<T,U>> |
zip(org.jooq.lambda.Seq<? extends U> other) |
default <U,R> DequeX<R> |
zip(org.jooq.lambda.Seq<? extends U> other,
java.util.function.BiFunction<? super T,? super U,? extends R> zipper) |
default <U> DequeX<org.jooq.lambda.tuple.Tuple2<T,U>> |
zip(java.util.stream.Stream<? extends U> other)
Zip 2 streams into one
|
default <U,R> DequeX<R> |
zip(java.util.stream.Stream<? extends U> other,
java.util.function.BiFunction<? super T,? super U,? extends R> zipper) |
default <S,U> DequeX<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> DequeX<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 DequeX<org.jooq.lambda.tuple.Tuple2<T,java.lang.Long>> |
zipWithIndex()
Add an index to the current Stream
|
add, addFirst, addLast, contains, descendingIterator, element, getFirst, getLast, iterator, offer, offerFirst, offerLast, peek, peekFirst, peekLast, poll, pollFirst, pollLast, pop, push, remove, remove, removeFirst, removeFirstOccurrence, removeLast, removeLastOccurrence, size
reduce
plusInOrder
collectable, findAny, findFirst, forEach2, forEach2, forEach3, forEach3, fromCollection, getAtIndex, groupBy, head, headAndTail, single, single, singleOptional
groupedStatefullyWhileT, 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, schedule, scheduleFixedDelay, scheduleFixedRate, startsWith, startsWithIterable, toConcurrentLazyCollection, toConcurrentLazyStreamable, toLazyCollection, validate, xMatch
futureOperations, lazyOperations, subscribe, traversable
seq, toCompletableFuture, toEvalAlways, toEvalLater, toEvalNow, toFutureStream, toFutureStream, toFutureW, toIor, toIorSecondary, toListX, toMapX, toMaybe, toOptional, toPBagX, toPMapX, toPOrderedSetX, toPQueueX, toPSetX, toPStackX, toPVectorX, toQueueX, toSetX, toSimpleReact, toSimpleReact, toSortedSetX, toStreamable, toTry, toValue, toValueMap, toValueSet, toXor, toXorSecondary
addAll, clear, containsAll, equals, hashCode, isEmpty, parallelStream, removeAll, removeIf, retainAll, 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 DequeX<java.lang.Integer> range(int start, int end)
start
- Number of range to start fromend
- Number for range to end atstatic DequeX<java.lang.Long> rangeLong(long start, long end)
start
- Number of range to start fromend
- Number for range to end atstatic <U,T> DequeX<T> unfold(U seed, java.util.function.Function<? super U,java.util.Optional<org.jooq.lambda.tuple.Tuple2<T,U>>> unfolder)
DequeX.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> DequeX<T> generate(long limit, java.util.function.Supplier<T> s)
limit
- Max number of elements to generates
- Supplier to generate DequeX elementsstatic <T> DequeX<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 elementstatic <T> java.util.stream.Collector<T,?,java.util.Deque<T>> defaultCollector()
static <T> DequeX<T> empty()
static <T> DequeX<T> of(T... values)
static <T> DequeX<T> singleton(T value)
static <T> DequeX<T> fromPublisher(org.reactivestreams.Publisher<? extends T> publisher)
publisher
- to construct DequeX fromstatic <T> DequeX<T> fromIterable(java.lang.Iterable<T> it)
static <T> DequeX<T> fromIterable(java.util.stream.Collector<T,?,java.util.Deque<T>> collector, java.lang.Iterable<T> it)
default DequeX<T> toDequeX()
toDequeX
in interface ConvertableSequence<T>
<T> java.util.stream.Collector<T,?,java.util.Deque<T>> getCollector()
default <T1> DequeX<T1> from(java.util.Collection<T1> c)
from
in interface CollectionX<T>
default <X> DequeX<X> fromStream(java.util.stream.Stream<X> stream)
fromStream
in interface MutableCollectionX<T>
stream
- Create a MultableCollectionX from a Streamdefault DequeX<T> combine(java.util.function.BiPredicate<? super T,? super T> predicate, java.util.function.BinaryOperator<T> op)
DequeX.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 MutableCollectionX<T>
combine
in interface Traversable<T>
predicate
- Test to see if two neighbors should be joinedop
- Reducer to combine neighborsdefault <R> DequeX<R> unit(java.util.Collection<R> col)
FluentCollectionX
unit
in interface FluentCollectionX<T>
col
- Collection data to populate the new collectiondefault <R> DequeX<R> unitIterator(java.util.Iterator<R> it)
unitIterator
in interface IterableFunctor<T>
default ReactiveSeq<T> stream()
stream
in interface java.util.Collection<T>
stream
in interface CollectionX<T>
stream
in interface ConvertableSequence<T>
stream
in interface ExtendedTraversable<T>
stream
in interface Foldable<T>
stream
in interface IterableFunctor<T>
stream
in interface Sequential<T>
stream
in interface TransformerTraversable<T>
stream
in interface Traversable<T>
default DequeX<T> reverse()
reverse
in interface CollectionX<T>
reverse
in interface MutableCollectionX<T>
reverse
in interface Traversable<T>
default DequeX<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 MutableCollectionX<T>
pred
- to filter elements by, retaining matchesdefault <R> DequeX<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 MutableCollectionX<T>
mapper
- Transformation functiondefault <R> DequeX<R> flatMap(java.util.function.Function<? super T,? extends java.lang.Iterable<? extends R>> mapper)
flatMap
in interface CollectionX<T>
flatMap
in interface MutableCollectionX<T>
default DequeX<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 MutableCollectionX<T>
limit
in interface Traversable<T>
num
- Limit element size to numdefault DequeX<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 MutableCollectionX<T>
skip
in interface Traversable<T>
num
- Number of elemenets to skipdefault DequeX<T> takeWhile(java.util.function.Predicate<? super T> p)
takeWhile
in interface CollectionX<T>
takeWhile
in interface MutableCollectionX<T>
takeWhile
in interface Traversable<T>
default DequeX<T> takeRight(int num)
takeRight
in interface CollectionX<T>
takeRight
in interface MutableCollectionX<T>
takeRight
in interface Traversable<T>
default DequeX<T> dropRight(int num)
dropRight
in interface CollectionX<T>
dropRight
in interface MutableCollectionX<T>
dropRight
in interface Traversable<T>
default DequeX<T> dropWhile(java.util.function.Predicate<? super T> p)
dropWhile
in interface CollectionX<T>
dropWhile
in interface MutableCollectionX<T>
dropWhile
in interface Traversable<T>
default DequeX<T> takeUntil(java.util.function.Predicate<? super T> p)
takeUntil
in interface CollectionX<T>
takeUntil
in interface MutableCollectionX<T>
takeUntil
in interface Traversable<T>
default DequeX<T> dropUntil(java.util.function.Predicate<? super T> p)
dropUntil
in interface CollectionX<T>
dropUntil
in interface MutableCollectionX<T>
dropUntil
in interface Traversable<T>
default <R> DequeX<R> trampoline(java.util.function.Function<? super T,? extends Trampoline<? extends R>> mapper)
Functor
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 MutableCollectionX<T>
default DequeX<T> slice(long from, long to)
slice
in interface CollectionX<T>
slice
in interface MutableCollectionX<T>
slice
in interface Traversable<T>
default DequeX<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 MutableCollectionX<T>
grouped
in interface Traversable<T>
groupSize
- Size of each Groupdefault <K,A,D> DequeX<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 MutableCollectionX<T>
grouped
in interface Traversable<T>
default <K> DequeX<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 MutableCollectionX<T>
grouped
in interface Traversable<T>
default <U> DequeX<org.jooq.lambda.tuple.Tuple2<T,U>> zip(java.lang.Iterable<? extends U> other)
zip
in interface CollectionX<T>
zip
in interface MutableCollectionX<T>
zip
in interface Traversable<T>
default <U,R> DequeX<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 MutableCollectionX<T>
zip
in interface Traversable<T>
default <U,R> DequeX<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 MutableCollectionX<T>
zip
in interface Traversable<T>
default <U,R> DequeX<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 MutableCollectionX<T>
zip
in interface Traversable<T>
default DequeX<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 MutableCollectionX<T>
sliding
in interface Traversable<T>
windowSize
- Size of sliding windowdefault DequeX<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 MutableCollectionX<T>
sliding
in interface Traversable<T>
windowSize
- number of elements in each batchincrement
- for each windowdefault DequeX<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 MutableCollectionX<T>
scanLeft
in interface Traversable<T>
default <U> DequeX<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 MutableCollectionX<T>
scanLeft
in interface Traversable<T>
default DequeX<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 MutableCollectionX<T>
scanRight
in interface Traversable<T>
default <U> DequeX<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 MutableCollectionX<T>
scanRight
in interface Traversable<T>
default <U extends java.lang.Comparable<? super U>> DequeX<T> sorted(java.util.function.Function<? super T,? extends U> function)
sorted
in interface CollectionX<T>
sorted
in interface MutableCollectionX<T>
sorted
in interface Traversable<T>
default DequeX<T> plus(T e)
FluentCollectionX
plus
in interface FluentCollectionX<T>
plus
in interface MutableCollectionX<T>
e
- Element to adddefault DequeX<T> plusAll(java.util.Collection<? extends T> list)
FluentCollectionX
plusAll
in interface FluentCollectionX<T>
plusAll
in interface MutableCollectionX<T>
list
- of elements to adddefault DequeX<T> minus(java.lang.Object e)
FluentCollectionX
minus
in interface FluentCollectionX<T>
minus
in interface MutableCollectionX<T>
e
- Element to removedefault DequeX<T> minusAll(java.util.Collection<?> list)
FluentCollectionX
minusAll
in interface FluentCollectionX<T>
minusAll
in interface MutableCollectionX<T>
list
- of elements to removedefault DequeX<T> peek(java.util.function.Consumer<? super T> c)
Functor
of(1,2,3).map(System.out::println)
1
2
3
default <R> DequeX<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 MutableCollectionX<T>
case1
- Function to generate a case (or chain of cases as a single case)otherwise
- Value if supplied case doesn't matchdefault DequeX<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 MutableCollectionX<T>
cycle
in interface Traversable<T>
times
- Times values should be repeated within a Streamdefault DequeX<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 MutableCollectionX<T>
cycle
in interface Traversable<T>
m
- Monoid to be used in reductiontimes
- Number of times value should be repeateddefault DequeX<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 MutableCollectionX<T>
cycleWhile
in interface Traversable<T>
predicate
- repeat while truedefault DequeX<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 MutableCollectionX<T>
cycleUntil
in interface Traversable<T>
predicate
- repeat while truedefault <U> DequeX<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 MutableCollectionX<T>
zip
in interface Traversable<T>
default <U> DequeX<org.jooq.lambda.tuple.Tuple2<T,U>> zip(org.jooq.lambda.Seq<? extends U> other)
zip
in interface CollectionX<T>
zip
in interface MutableCollectionX<T>
zip
in interface Traversable<T>
default <S,U> DequeX<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 MutableCollectionX<T>
zip3
in interface Traversable<T>
default <T2,T3,T4> DequeX<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 MutableCollectionX<T>
zip4
in interface Traversable<T>
default DequeX<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 MutableCollectionX<T>
zipWithIndex
in interface Traversable<T>
default DequeX<T> distinct()
distinct
in interface CollectionX<T>
distinct
in interface MutableCollectionX<T>
distinct
in interface Traversable<T>
default DequeX<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 MutableCollectionX<T>
sorted
in interface Traversable<T>
default DequeX<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 MutableCollectionX<T>
sorted
in interface Traversable<T>
c
- Compartor to sort withdefault DequeX<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 MutableCollectionX<T>
skipWhile
in interface Traversable<T>
p
- Predicate to skip while truedefault DequeX<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 MutableCollectionX<T>
skipUntil
in interface Traversable<T>
p
- Predicate to skip until truedefault DequeX<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 MutableCollectionX<T>
limitWhile
in interface Traversable<T>
p
- Limit while predicate is truedefault DequeX<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 MutableCollectionX<T>
limitUntil
in interface Traversable<T>
p
- Limit until predicate is truedefault DequeX<T> intersperse(T value)
Traversable
intersperse
in interface CollectionX<T>
intersperse
in interface MutableCollectionX<T>
intersperse
in interface Traversable<T>
default DequeX<T> shuffle()
shuffle
in interface CollectionX<T>
shuffle
in interface MutableCollectionX<T>
shuffle
in interface Traversable<T>
default DequeX<T> skipLast(int num)
Traversable
skipLast
in interface CollectionX<T>
skipLast
in interface MutableCollectionX<T>
skipLast
in interface Traversable<T>
default DequeX<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 MutableCollectionX<T>
limitLast
in interface Traversable<T>
num
- of elements to return (last elements)default DequeX<T> onEmpty(T value)
onEmpty
in interface CollectionX<T>
onEmpty
in interface MutableCollectionX<T>
onEmpty
in interface Traversable<T>
default DequeX<T> onEmptyGet(java.util.function.Supplier<? extends T> supplier)
onEmptyGet
in interface CollectionX<T>
onEmptyGet
in interface MutableCollectionX<T>
onEmptyGet
in interface Traversable<T>
default <X extends java.lang.Throwable> DequeX<T> onEmptyThrow(java.util.function.Supplier<? extends X> supplier)
onEmptyThrow
in interface CollectionX<T>
onEmptyThrow
in interface MutableCollectionX<T>
onEmptyThrow
in interface Traversable<T>
default DequeX<T> shuffle(java.util.Random random)
shuffle
in interface CollectionX<T>
shuffle
in interface MutableCollectionX<T>
shuffle
in interface Traversable<T>
default DequeX<ReactiveSeq<T>> permutations()
ExtendedTraversable
permutations
in interface CollectionX<T>
permutations
in interface ExtendedTraversable<T>
permutations
in interface MutableCollectionX<T>
default DequeX<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 MutableCollectionX<T>
size
- of combinationsdefault DequeX<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 MutableCollectionX<T>
default <U> DequeX<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 MutableCollectionX<T>
default <U> DequeX<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 MutableCollectionX<T>
default DequeX<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 MutableCollectionX<T>
fn
- to filter elements by, retaining matchesdefault DequeX<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 MutableCollectionX<T>
default DequeX<T> removeAll(java.util.stream.Stream<? extends T> stream)
IterableFilterable
removeAll
in interface CollectionX<T>
removeAll
in interface IterableFilterable<T>
removeAll
in interface MutableCollectionX<T>
stream
- of elements to removedefault DequeX<T> removeAll(java.lang.Iterable<? extends T> it)
IterableFilterable
removeAll
in interface CollectionX<T>
removeAll
in interface IterableFilterable<T>
removeAll
in interface MutableCollectionX<T>
it
- an Iterable of elements to removedefault DequeX<T> removeAll(T... values)
IterableFilterable
removeAll
in interface CollectionX<T>
removeAll
in interface IterableFilterable<T>
removeAll
in interface MutableCollectionX<T>
values
- to removedefault DequeX<T> retainAll(java.lang.Iterable<? extends T> it)
IterableFilterable
retainAll
in interface CollectionX<T>
retainAll
in interface IterableFilterable<T>
retainAll
in interface MutableCollectionX<T>
it
- Iterable of elements to retaindefault DequeX<T> retainAll(java.util.stream.Stream<? extends T> seq)
IterableFilterable
retainAll
in interface CollectionX<T>
retainAll
in interface IterableFilterable<T>
retainAll
in interface MutableCollectionX<T>
seq
- of elements to retaindefault DequeX<T> retainAll(T... values)
IterableFilterable
retainAll
in interface CollectionX<T>
retainAll
in interface IterableFilterable<T>
retainAll
in interface MutableCollectionX<T>
values
- elements to retaindefault <C extends java.util.Collection<? super T>> DequeX<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 MutableCollectionX<T>
grouped
in interface Traversable<T>
size
- batch sizesupplier
- Collection factorydefault DequeX<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 MutableCollectionX<T>
groupedUntil
in interface Traversable<T>
predicate
- Batch until predicate holds, then open next batchdefault DequeX<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 MutableCollectionX<T>
groupedWhile
in interface Traversable<T>
predicate
- Batch while predicate holds, then open next batchdefault <C extends java.util.Collection<? super T>> DequeX<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 MutableCollectionX<T>
groupedWhile
in interface Traversable<T>
predicate
- Batch while predicate holds, then open next batchfactory
- Collection factorydefault <C extends java.util.Collection<? super T>> DequeX<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 MutableCollectionX<T>
groupedUntil
in interface Traversable<T>
predicate
- Batch until predicate holds, then open next batchfactory
- Collection factorydefault DequeX<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 MutableCollectionX<T>
groupedStatefullyWhile
in interface Traversable<T>
predicate
- Window while truedefault DequeX<T> removeAll(org.jooq.lambda.Seq<? extends T> stream)
removeAll
in interface CollectionX<T>
removeAll
in interface MutableCollectionX<T>
default DequeX<T> retainAll(org.jooq.lambda.Seq<? extends T> stream)
retainAll
in interface CollectionX<T>
retainAll
in interface MutableCollectionX<T>