public interface ValueTransformerSeq<T> extends TransformerSeq<T>
| Modifier and Type | Method and Description |
|---|---|
default Traversable<T> |
combine(java.util.function.BiPredicate<? super T,? super T> predicate,
java.util.function.BinaryOperator<T> op)
Combine two adjacent elements in a traversable using the supplied BinaryOperator
This is a stateful grouping & reduction operation.
|
default Traversable<T> |
cycle(int times)
Convert to a Stream with the values repeated specified times
|
default Traversable<T> |
cycle(Monoid<T> m,
int times)
Convert to a Stream with the result of a reduction operation repeated
specified times
|
default Traversable<T> |
cycleUntil(java.util.function.Predicate<? super T> predicate)
Repeat in a Stream until specified predicate holds
|
default Traversable<T> |
cycleWhile(java.util.function.Predicate<? super T> predicate)
Repeat in a Stream while specified predicate holds
|
default Traversable<T> |
distinct() |
default Traversable<T> |
dropRight(int num)
Generate a new Traversable that drops the specified number elements from the end of this Traversable
|
default Traversable<T> |
dropUntil(java.util.function.Predicate<? super T> p)
Generate a new Traversable that drops elements from this Traversable until the predicate holds
|
default Traversable<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
|
default <K> Traversable<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> Traversable<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 Traversable<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 Traversable<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 Traversable<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 Traversable<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 Traversable<T> |
intersperse(T value)
Returns a stream with a given value interspersed between any two values
of this stream.
|
default Traversable<T> |
limit(long num)
assertThat(ReactiveSeq.of(4,3,6,7).limit(2).toList(),equalTo(Arrays.asList(4,3)); |
default Traversable<T> |
limitLast(int num)
Limit results to the last x elements in a SequenceM
|
default Traversable<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 Traversable<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 Traversable<T> |
onEmpty(T value)
If this Container instance is empty, create a new instance containing the provided value
|
default Traversable<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 <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 Traversable<T> |
reverse() |
default Traversable<T> |
scanLeft(Monoid<T> monoid)
Scan left using supplied Monoid
|
default <U> Traversable<U> |
scanLeft(U seed,
java.util.function.BiFunction<? super U,? super T,? extends U> function)
Scan left
|
default Traversable<T> |
scanRight(Monoid<T> monoid)
Scan right
|
default <U> Traversable<U> |
scanRight(U identity,
java.util.function.BiFunction<? super T,? super U,? extends U> combiner)
Scan right
|
default Traversable<T> |
shuffle() |
default Traversable<T> |
shuffle(java.util.Random random) |
default Traversable<T> |
skip(long num)
assertThat(ReactiveSeq.of(4,3,6,7).skip(2).toList(),equalTo(Arrays.asList(6,7))); |
default Traversable<T> |
skipLast(int num)
assertThat(ReactiveSeq.of(1,2,3,4,5) .skipLast(2)
.collect(Collectors.toList()),equalTo(Arrays.asList(1,2,3)));
|
default Traversable<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 Traversable<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 Traversable<T> |
slice(long from,
long to) |
default Traversable<ListX<T>> |
sliding(int windowSize)
Create a sliding view over this Sequence
|
default Traversable<ListX<T>> |
sliding(int windowSize,
int increment)
Create a sliding view over this Sequence
|
default Traversable<T> |
sorted()
assertThat(ReactiveSeq.of(4,3,6,7)).sorted().toList(),equalTo(Arrays.asList(3,4,6,7))); |
default Traversable<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 void |
subscribe(org.reactivestreams.Subscriber<? super T> s) |
default Traversable<T> |
takeRight(int num)
Generate a new Traversable that takes the specified number elements from the end of this Traversable
|
default Traversable<T> |
takeUntil(java.util.function.Predicate<? super T> p)
Generate a new Traversable that takes elements from this Traversable until the predicate holds
|
default Traversable<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
|
<T> TransformerSeq<T> |
unitStream(ReactiveSeq<T> traversable) |
default <U> Traversable<org.jooq.lambda.tuple.Tuple2<T,U>> |
zip(java.lang.Iterable<? extends U> other)
Zip (combine) this Zippable with the supplied Iterable combining both into a Tuple2
|
default <U,R> Traversable<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> Traversable<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> Traversable<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> Traversable<org.jooq.lambda.tuple.Tuple2<T,U>> |
zip(java.util.stream.Stream<? extends U> other)
Zip 2 streams into one
|
default <U,R> Traversable<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> Traversable<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> Traversable<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 Traversable<org.jooq.lambda.tuple.Tuple2<T,java.lang.Long>> |
zipWithIndex()
Add an index to the current Stream
|
futureOperations, isSeqPresent, lazyOperations, stream, transformerStream, unitAnyMseq, toCompletableFuture, toDequeX, 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, toXorSecondarytraversablefixedDelay, onePer, xPerfutureStream, getStreamable, isEmpty, iterator, jdkStream, reactiveSeq, reveresedJDKStream, reveresedStreamdefault Traversable<T> combine(java.util.function.BiPredicate<? super T,? super T> predicate, java.util.function.BinaryOperator<T> op)
Traversable
ReactiveSeq.of(1,1,2,3)
.combine((a, b)->a.equals(b),Semigroups.intSum)
.toListX()
//ListX(3,4)
combine in interface TransformerSeq<T>combine in interface Traversable<T>predicate - Test to see if two neighbours should be joinedop - Reducer to combine neighboursdefault void subscribe(org.reactivestreams.Subscriber<? super T> s)
subscribe in interface org.reactivestreams.Publisher<T>subscribe in interface TransformerSeq<T>subscribe in interface Traversable<T>default Traversable<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 TransformerSeq<T>cycle in interface Traversable<T>times - Times values should be repeated within a Streamdefault Traversable<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 TransformerSeq<T>cycle in interface Traversable<T>m - Monoid to be used in reductiontimes - Number of times value should be repeateddefault Traversable<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 TransformerSeq<T>cycleWhile in interface Traversable<T>predicate - repeat while truedefault Traversable<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 TransformerSeq<T>cycleUntil in interface Traversable<T>predicate - repeat while truedefault <U,R> Traversable<R> zip(java.lang.Iterable<? extends U> other, java.util.function.BiFunction<? super T,? super U,? extends R> zipper)
Zippablezip in interface TransformerSeq<T>zip in interface Traversable<T>zip in interface Zippable<T>other - to zip withzipper - Zip functiondefault <U,R> Traversable<R> zip(org.jooq.lambda.Seq<? extends U> other, java.util.function.BiFunction<? super T,? super U,? extends R> zipper)
Zippablezip in interface TransformerSeq<T>zip in interface Traversable<T>zip in interface Zippable<T>other - Seq to combine withzipper - Zip / combining functiondefault <U,R> Traversable<R> zip(java.util.stream.Stream<? extends U> other, java.util.function.BiFunction<? super T,? super U,? extends R> zipper)
Zippablezip in interface TransformerSeq<T>zip in interface Traversable<T>zip in interface Zippable<T>other - Stream to combine withzipper - Zip / combining functiondefault <U> Traversable<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 TransformerSeq<T>zip in interface Traversable<T>zip in interface Zippable<T>other - Stream to combine withdefault <U> Traversable<org.jooq.lambda.tuple.Tuple2<T,U>> zip(org.jooq.lambda.Seq<? extends U> other)
Zippablezip in interface TransformerSeq<T>zip in interface Traversable<T>zip in interface Zippable<T>other - Seq to combine withdefault <U> Traversable<org.jooq.lambda.tuple.Tuple2<T,U>> zip(java.lang.Iterable<? extends U> other)
Zippablezip in interface TransformerSeq<T>zip in interface Traversable<T>zip in interface Zippable<T>other - Iterable to combine withdefault <S,U> Traversable<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 TransformerSeq<T>zip3 in interface Traversable<T>default <T2,T3,T4> Traversable<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 TransformerSeq<T>zip4 in interface Traversable<T>default Traversable<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 TransformerSeq<T>zipWithIndex in interface Traversable<T>default Traversable<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 TransformerSeq<T>sliding in interface Traversable<T>windowSize - Size of sliding windowdefault Traversable<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 TransformerSeq<T>sliding in interface Traversable<T>windowSize - number of elements in each batchincrement - for each windowdefault <C extends java.util.Collection<? super T>> Traversable<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 TransformerSeq<T>grouped in interface Traversable<T>size - batch sizesupplier - Collection factorydefault Traversable<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 TransformerSeq<T>groupedUntil in interface Traversable<T>predicate - Batch until predicate holds, then open next batchdefault Traversable<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 TransformerSeq<T>groupedStatefullyUntil in interface Traversable<T>predicate - Window while truedefault Traversable<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 TransformerSeq<T>groupedWhile in interface Traversable<T>predicate - Batch while predicate holds, then open next batchdefault <C extends java.util.Collection<? super T>> Traversable<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 TransformerSeq<T>groupedWhile in interface Traversable<T>predicate - Batch while predicate holds, then open next batchfactory - Collection factorydefault <C extends java.util.Collection<? super T>> Traversable<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 TransformerSeq<T>groupedUntil in interface Traversable<T>predicate - Batch until predicate holds, then open next batchfactory - Collection factorydefault Traversable<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 TransformerSeq<T>grouped in interface Traversable<T>groupSize - Size of each Groupdefault <K,A,D> Traversable<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)
Traversablegrouped in interface TransformerSeq<T>grouped in interface Traversable<T>classifier - Grouping functiondownstream - Collector to create the grouping collectiondefault <K> Traversable<org.jooq.lambda.tuple.Tuple2<K,org.jooq.lambda.Seq<T>>> grouped(java.util.function.Function<? super T,? extends K> classifier)
Traversablegrouped in interface TransformerSeq<T>grouped in interface Traversable<T>classifier - Grouping functiondefault Traversable<T> distinct()
distinct in interface TransformerSeq<T>distinct in interface Traversable<T>default Traversable<T> scanLeft(Monoid<T> monoid)
Traversable
assertEquals(asList("", "a", "ab", "abc"),ReactiveSeq.of("a", "b", "c")
.scanLeft(Reducers.toString("")).toList());
scanLeft in interface TransformerSeq<T>scanLeft in interface Traversable<T>default <U> Traversable<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 TransformerSeq<T>scanLeft in interface Traversable<T>default Traversable<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 TransformerSeq<T>scanRight in interface Traversable<T>default <U> Traversable<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 TransformerSeq<T>scanRight in interface Traversable<T>default Traversable<T> sorted()
Traversable
assertThat(ReactiveSeq.of(4,3,6,7)).sorted().toList(),equalTo(Arrays.asList(3,4,6,7)));
sorted in interface TransformerSeq<T>sorted in interface Traversable<T>default Traversable<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 TransformerSeq<T>sorted in interface Traversable<T>c - Compartor to sort withdefault Traversable<T> takeWhile(java.util.function.Predicate<? super T> p)
Traversable
ListX.of(1,2,3).takeWhile(i<3);
//[1,2]
takeWhile in interface TransformerSeq<T>takeWhile in interface Traversable<T>p - Predicate to determine when values should be takendefault Traversable<T> dropWhile(java.util.function.Predicate<? super T> p)
Traversable
ListX.of(1,2,3).dropWhile(i<3);
//[3]
dropWhile in interface TransformerSeq<T>dropWhile in interface Traversable<T>p - Predicate to determine when values should be droppeddefault Traversable<T> takeUntil(java.util.function.Predicate<? super T> p)
Traversable
ListX.of(1,2,3).takeUntil(i<2);
//[1,2]
takeUntil in interface TransformerSeq<T>takeUntil in interface Traversable<T>p - Predicate to determine when values should be taken untildefault Traversable<T> dropUntil(java.util.function.Predicate<? super T> p)
Traversable
ListX.of(1,2,3).dropUntil(i>2);
//[3]
dropUntil in interface TransformerSeq<T>dropUntil in interface Traversable<T>p - Predicate to determine when values should be droppeddefault Traversable<T> dropRight(int num)
Traversable
ListX.of(1,2,3).dropRight(2);
//[1]
dropRight in interface TransformerSeq<T>dropRight in interface Traversable<T>num - Drop this number of elements from the end of this Traversabledefault Traversable<T> takeRight(int num)
Traversable
ListX.of(1,2,3).takeRight(2);
//[2,3]
takeRight in interface TransformerSeq<T>takeRight in interface Traversable<T>num - Take this number of elements from the end of this Traversabledefault Traversable<T> skip(long num)
Traversable
assertThat(ReactiveSeq.of(4,3,6,7).skip(2).toList(),equalTo(Arrays.asList(6,7)));
skip in interface TransformerSeq<T>skip in interface Traversable<T>num - Number of elemenets to skipdefault Traversable<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 TransformerSeq<T>skipWhile in interface Traversable<T>p - Predicate to skip while truedefault Traversable<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 TransformerSeq<T>skipUntil in interface Traversable<T>p - Predicate to skip until truedefault Traversable<T> limit(long num)
Traversable
assertThat(ReactiveSeq.of(4,3,6,7).limit(2).toList(),equalTo(Arrays.asList(4,3));
limit in interface TransformerSeq<T>limit in interface Traversable<T>num - Limit element size to numdefault Traversable<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 TransformerSeq<T>limitWhile in interface Traversable<T>p - Limit while predicate is truedefault Traversable<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 TransformerSeq<T>limitUntil in interface Traversable<T>p - Limit until predicate is truedefault Traversable<T> intersperse(T value)
Traversableintersperse in interface TransformerSeq<T>intersperse in interface Traversable<T>default Traversable<T> reverse()
reverse in interface TransformerSeq<T>reverse in interface Traversable<T>default Traversable<T> shuffle()
shuffle in interface TransformerSeq<T>shuffle in interface Traversable<T>default Traversable<T> skipLast(int num)
TraversableskipLast in interface TransformerSeq<T>skipLast in interface Traversable<T>default Traversable<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 TransformerSeq<T>limitLast in interface Traversable<T>num - of elements to return (last elements)default Traversable<T> onEmpty(T value)
OnEmptyonEmpty in interface OnEmpty<T>onEmpty in interface TransformerSeq<T>onEmpty in interface Traversable<T>default Traversable<T> onEmptyGet(java.util.function.Supplier<? extends T> supplier)
OnEmptyonEmptyGet in interface OnEmpty<T>onEmptyGet in interface TransformerSeq<T>onEmptyGet in interface Traversable<T>supplier - to determine new value for containerdefault <X extends java.lang.Throwable> Traversable<T> onEmptyThrow(java.util.function.Supplier<? extends X> supplier)
OnEmptyonEmptyThrow in interface OnEmpty<T>onEmptyThrow in interface TransformerSeq<T>onEmptyThrow in interface Traversable<T>supplier - to create exception fromdefault Traversable<T> shuffle(java.util.Random random)
shuffle in interface TransformerSeq<T>shuffle in interface Traversable<T>default Traversable<T> slice(long from, long to)
slice in interface TransformerSeq<T>slice in interface Traversable<T>default <U extends java.lang.Comparable<? super U>> Traversable<T> sorted(java.util.function.Function<? super T,? extends U> function)
sorted in interface TransformerSeq<T>sorted in interface Traversable<T><T> TransformerSeq<T> unitStream(ReactiveSeq<T> traversable)