T
- Data type of the elements in the nested Listspublic interface ListT<T> extends To<ListT<T>>, FoldableTransformerSeq<T>
Modifier and Type | Method and Description |
---|---|
default <B> ListT<B> |
bind(java.util.function.Function<? super T,ListT<B>> f)
Flat Map the wrapped List
|
default <U> ListT<U> |
cast(java.lang.Class<? extends U> type)
Cast all elements in a stream to a given type, possibly throwing a
ClassCastException . |
default ListT<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 and reduction operation.
|
default ListT<T> |
cycle(int times)
Convert to a Stream with the values repeated specified times
|
default ListT<T> |
cycle(Monoid<T> m,
int times)
Convert to a Stream with the result of a reduction operation repeated
specified times
|
default ListT<T> |
cycleUntil(java.util.function.Predicate<? super T> predicate)
Repeat in a Stream until specified predicate holds
|
default ListT<T> |
cycleWhile(java.util.function.Predicate<? super T> predicate)
Repeat in a Stream while specified predicate holds
|
default ListT<T> |
distinct() |
default ListT<T> |
dropRight(int num)
Generate a new Traversable that drops the specified number elements from the end of this Traversable
|
default ListT<T> |
dropUntil(java.util.function.Predicate<? super T> p)
Generate a new Traversable that drops elements from this Traversable until the predicate holds
|
default ListT<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
|
<R> ListT<R> |
empty() |
static <T> ListTSeq<T> |
emptyList() |
static <T> ListTValue<T> |
emptyOptional() |
ListT<T> |
filter(java.util.function.Predicate<? super T> test)
Filter the wrapped List
|
default ListT<T> |
filterNot(java.util.function.Predicate<? super T> fn)
Remove any elements for which the predicate holds (inverse operation to filter)
e.g.
|
<B> ListT<B> |
flatMap(java.util.function.Function<? super T,? extends java.lang.Iterable<? extends B>> f) |
static <A> ListT<A> |
fromAnyM(AnyM<A> anyM)
|
static <A> ListTSeq<A> |
fromAnyMSeq(AnyMSeq<A> anyM) |
static <A> ListTValue<A> |
fromAnyMValue(AnyMValue<A> anyM) |
static <A> ListTValue<A> |
fromFuture(java.util.concurrent.CompletableFuture<? extends java.util.List<A>> future) |
static <A> ListTSeq<A> |
fromIterable(java.lang.Iterable<? extends java.util.List<A>> iterableOfLists) |
static <A> ListTValue<A> |
fromOptional(java.util.Optional<? extends java.util.List<A>> optional) |
static <A> ListTSeq<A> |
fromPublisher(org.reactivestreams.Publisher<java.util.List<A>> publisherOfLists) |
static <A> ListTSeq<A> |
fromStream(java.util.stream.Stream<? extends java.util.List<A>> streamOfLists) |
static <A> ListT<A> |
fromStreamAnyM(AnyM<java.util.stream.Stream<A>> monads)
Create a ListT from an AnyM that wraps a monad containing a Stream
|
static <A,V extends MonadicValue<? extends java.util.List<A>>> |
fromValue(V monadicValue) |
default <K> ListT<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> ListT<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 ListT<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 ListT<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 ListT<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 ListT<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 ListT<T> |
intersperse(T value)
Returns a stream with a given value interspersed between any two values
of this stream.
|
default boolean |
isSeqPresent() |
static <U,R> java.util.function.Function<ListT<U>,ListT<R>> |
lift(java.util.function.Function<? super U,? extends R> fn)
Lift a function into one that accepts and returns an ListT
This allows multiple monad types to add functionality to existing functions and methods
e.g.
|
static <U1,U2,R> java.util.function.BiFunction<ListT<U1>,ListT<U2>,ListT<R>> |
lift2(java.util.function.BiFunction<? super U1,? super U2,? extends R> fn)
Lift a BiFunction into one that accepts and returns ListTs
This allows multiple monad types to add functionality to existing functions and methods
e.g.
|
default ListT<T> |
limit(long num)
assertThat(ReactiveSeq.of(4,3,6,7).limit(2).toList(),equalTo(Arrays.asList(4,3)); |
default ListT<T> |
limitLast(int num)
Limit results to the last x elements in a SequenceM
|
default ListT<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 ListT<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
|
<B> ListT<B> |
map(java.util.function.Function<? super T,? extends B> f)
Map the wrapped List
|
default ListT<T> |
notNull()
Filter elements retaining only values which are not null
|
static <A> ListT<A> |
of(AnyM<java.util.List<A>> monads)
Construct an ListT from an AnyM that wraps a monad containing Lists
|
default <U> ListT<U> |
ofType(java.lang.Class<? extends U> type)
Keep only those elements in a stream that are of a given type.
|
default ListT<T> |
onEmpty(T value)
If this Container instance is empty, create a new instance containing the provided value
|
default ListT<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 <R> ListT<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
|
ListT<T> |
peek(java.util.function.Consumer<? super T> peek)
Peek at the current value of the List
|
default ListT<T> |
reverse()
Potentially efficient Stream reversal.
|
default ListT<T> |
scanLeft(Monoid<T> monoid)
Scan left using supplied Monoid
|
default <U> ListT<U> |
scanLeft(U seed,
java.util.function.BiFunction<? super U,? super T,? extends U> function)
Scan left
|
default ListT<T> |
scanRight(Monoid<T> monoid)
Scan right
|
default <U> ListT<U> |
scanRight(U identity,
java.util.function.BiFunction<? super T,? super U,? extends U> combiner)
Scan right
|
default ListT<T> |
shuffle() |
default ListT<T> |
shuffle(java.util.Random random) |
default ListT<T> |
skip(long num)
assertThat(ReactiveSeq.of(4,3,6,7).skip(2).toList(),equalTo(Arrays.asList(6,7))); |
default ListT<T> |
skipLast(int num)
assertThat(ReactiveSeq.of(1,2,3,4,5) .skipLast(2)
.collect(Collectors.toList()),equalTo(Arrays.asList(1,2,3)));
|
default ListT<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 ListT<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 ListT<T> |
slice(long from,
long to) |
default ListT<ListX<T>> |
sliding(int windowSize)
Create a sliding view over this Sequence
|
default ListT<ListX<T>> |
sliding(int windowSize,
int increment)
Create a sliding view over this Sequence
|
default ListT<T> |
sorted()
assertThat(ReactiveSeq.of(4,3,6,7)).sorted().toList(),equalTo(Arrays.asList(3,4,6,7))); |
default ListT<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 ListT<T> |
takeRight(int num)
Generate a new Traversable that takes the specified number elements from the end of this Traversable
|
default ListT<T> |
takeUntil(java.util.function.Predicate<? super T> p)
Generate a new Traversable that takes elements from this Traversable until the predicate holds
|
default ListT<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 <R> ListT<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
|
<R> ListT<R> |
unit(R t) |
<R> ListT<R> |
unitIterator(java.util.Iterator<R> it) |
AnyM<ListX<T>> |
unwrap() |
default <U> ListT<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> ListT<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> ListT<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> ListT<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> ListT<org.jooq.lambda.tuple.Tuple2<T,U>> |
zip(java.util.stream.Stream<? extends U> other)
Zip 2 streams into one
|
default <U,R> ListT<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> ListT<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> ListT<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 ListT<org.jooq.lambda.tuple.Tuple2<T,java.lang.Long>> |
zipWithIndex()
Add an index to the current Stream
|
stream
futureOperations, lazyOperations, subscribe, transformerStream, unitAnyM
seq, 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, toXorSecondary
drop, take, traversable
fixedDelay, onePer, xPer
futureStream, getStreamable, isEmpty, iterator, jdkStream, reactiveSeq, reveresedJDKStream, reveresedStream
endsWith, endsWithIterable, findFirst, firstValue, foldRight, foldRight, foldRight, foldRightMapToType, get, groupBy, headAndTail, join, join, join, mapReduce, mapReduce, nestedFoldables, print, print, printErr, printOut, reduce, reduce, reduce, reduce, reduce, reduce, schedule, scheduleFixedDelay, scheduleFixedRate, single, single, singleOptional, startsWith, startsWithIterable, toConcurrentLazyCollection, toConcurrentLazyStreamable, toLazyCollection, validate, visit
allMatch, anyMatch, collect, collect, listT, nestedCollectables, noneMatch, setT, streamableT, streamT, toListOfLists, toNestedListX, toNestedSetX, toSetOfSets
<R> ListT<R> unitIterator(java.util.Iterator<R> it)
<R> ListT<R> unit(R t)
<R> ListT<R> empty()
ListT<T> peek(java.util.function.Consumer<? super T> peek)
ListT.of(AnyM.fromStream(Arrays.asList(10))
.peek(System.out::println);
//prints 10
ListT<T> filter(java.util.function.Predicate<? super T> test)
ListT.of(AnyM.fromStream(Arrays.asList(10,11))
.filter(t->t!=10);
//ListT<AnyM<Stream<List[11]>>>
filter
in interface Filterable<T>
filter
in interface FilterableFunctor<T>
test
- Predicate to filter the wrapped List<B> ListT<B> map(java.util.function.Function<? super T,? extends B> f)
ListT.of(AnyM.fromStream(Arrays.asList(10))
.map(t->t=t+1);
//ListT<AnyM<Stream<List[11]>>>
<B> ListT<B> flatMap(java.util.function.Function<? super T,? extends java.lang.Iterable<? extends B>> f)
default <B> ListT<B> bind(java.util.function.Function<? super T,ListT<B>> f)
ListT.of(AnyM.fromStream(Arrays.asList(10))
.flatMap(t->List.empty();
//ListT<AnyM<Stream<List.empty>>>
f
- FlatMap functionstatic <U,R> java.util.function.Function<ListT<U>,ListT<R>> lift(java.util.function.Function<? super U,? extends R> fn)
Function<Integer,Integer> add2 = i -> i+2;
Function<ListT<Integer>, ListT<Integer>> optTAdd2 = ListT.lift(add2);
Stream<Integer> nums = Stream.of(1,2);
AnyM<Stream<Integer>> stream = AnyM.ofMonad(Arrays.asList(nums));
List<Integer> results = optTAdd2.apply(ListT.fromStream(stream))
.unwrap()
.<Optional<List<Integer>>>unwrap().get();
//Arrays.asList(3,4);
fn
- Function to enhance with functionality from List and another monad typestatic <U1,U2,R> java.util.function.BiFunction<ListT<U1>,ListT<U2>,ListT<R>> lift2(java.util.function.BiFunction<? super U1,? super U2,? extends R> fn)
BiFunction<Integer,Integer,Integer> add = (a,b) -> a+b;
BiFunction<ListT<Integer>,ListT<Integer>, ListT<Integer>> optTAdd2 = ListT.lift2(add);
Streamable<Integer> threeValues = Streamable.of(1,2,3);
AnyM<Integer> stream = AnyM.fromStreamable(threeValues);
AnyM<List<Integer>> streamOpt = stream.map(Arrays::asList);
CompletableFuture<List<Integer>> two = CompletableFuture.completedFuture(Arrays.asList(2));
AnyM<List<Integer>> future= AnyM.fromCompletableFuture(two);
List<Integer> results = optTAdd2.apply(ListT.of(streamOpt),ListT.of(future))
.unwrap()
.<Stream<List<Integer>>>unwrap()
.flatMap(i->i.stream())
.collect(Collectors.toList());
//Arrays.asList(3,4);
fn
- BiFunction to enhance with functionality from List and another monad typestatic <A> ListT<A> fromAnyM(AnyM<A> anyM)
anyM
- AnyM that doesn't contain a monad wrapping an Liststatic <A> ListT<A> of(AnyM<java.util.List<A>> monads)
monads
- AnyM that contains a monad wrapping an Liststatic <A> ListT<A> fromStreamAnyM(AnyM<java.util.stream.Stream<A>> monads)
monads
- static <A> ListTValue<A> fromAnyMValue(AnyMValue<A> anyM)
static <A> ListTSeq<A> fromIterable(java.lang.Iterable<? extends java.util.List<A>> iterableOfLists)
static <A> ListTSeq<A> fromStream(java.util.stream.Stream<? extends java.util.List<A>> streamOfLists)
static <A> ListTSeq<A> fromPublisher(org.reactivestreams.Publisher<java.util.List<A>> publisherOfLists)
static <A,V extends MonadicValue<? extends java.util.List<A>>> ListTValue<A> fromValue(V monadicValue)
static <A> ListTValue<A> fromOptional(java.util.Optional<? extends java.util.List<A>> optional)
static <A> ListTValue<A> fromFuture(java.util.concurrent.CompletableFuture<? extends java.util.List<A>> future)
static <T> ListTValue<T> emptyOptional()
static <T> ListTSeq<T> emptyList()
default <U> ListT<U> cast(java.lang.Class<? extends U> type)
Functor
ClassCastException
.
// ClassCastException ReactiveSeq.of(1, "a", 2, "b", 3).cast(Integer.class)default <R> ListT<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 Functor<T>
mapper
- TCO Transformation functiondefault <R> ListT<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 Functor<T>
case1
- Function to generate a case (or chain of cases as a single case)otherwise
- Value if supplied case doesn't matchdefault <U> ListT<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>
default ListT<T> filterNot(java.util.function.Predicate<? super T> fn)
Filterable
of(1,2,3).filter(i->i>2);
//[1,2]
filterNot
in interface Filterable<T>
fn
- to filter elements by, retaining matchesdefault ListT<T> notNull()
Filterable
of(1,2,null,4).nonNull();
//[1,2,4]
notNull
in interface Filterable<T>
default boolean isSeqPresent()
isSeqPresent
in interface TransformerSeq<T>
default ListT<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 ListT<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 ListT<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 ListT<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 TransformerSeq<T>
cycleWhile
in interface Traversable<T>
predicate
- repeat while truedefault ListT<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> ListT<R> zip(java.lang.Iterable<? extends U> other, java.util.function.BiFunction<? super T,? super U,? extends R> zipper)
Zippable
zip
in interface TransformerSeq<T>
zip
in interface Traversable<T>
zip
in interface Zippable<T>
other
- to zip withzipper
- Zip functiondefault <U,R> ListT<R> zip(java.util.stream.Stream<? extends U> other, java.util.function.BiFunction<? super T,? super U,? extends R> zipper)
Zippable
zip
in interface TransformerSeq<T>
zip
in interface Traversable<T>
zip
in interface Zippable<T>
other
- Stream to combine withzipper
- Zip / combining functiondefault <U,R> ListT<R> zip(org.jooq.lambda.Seq<? extends U> other, java.util.function.BiFunction<? super T,? super U,? extends R> zipper)
Zippable
zip
in interface TransformerSeq<T>
zip
in interface Traversable<T>
zip
in interface Zippable<T>
other
- Seq to combine withzipper
- Zip / combining functiondefault <U> ListT<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 TransformerSeq<T>
zip
in interface Traversable<T>
zip
in interface Zippable<T>
other
- Stream to combine withdefault <U> ListT<org.jooq.lambda.tuple.Tuple2<T,U>> zip(java.lang.Iterable<? extends U> other)
Zippable
zip
in interface TransformerSeq<T>
zip
in interface Traversable<T>
zip
in interface Zippable<T>
other
- Iterable to combine withdefault <U> ListT<org.jooq.lambda.tuple.Tuple2<T,U>> zip(org.jooq.lambda.Seq<? extends U> other)
Zippable
zip
in interface TransformerSeq<T>
zip
in interface Traversable<T>
zip
in interface Zippable<T>
other
- Seq to combine withdefault <S,U> ListT<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 TransformerSeq<T>
zip3
in interface Traversable<T>
default <T2,T3,T4> ListT<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 TransformerSeq<T>
zip4
in interface Traversable<T>
default ListT<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 ListT<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 TransformerSeq<T>
sliding
in interface Traversable<T>
windowSize
- Size of sliding windowdefault ListT<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 TransformerSeq<T>
sliding
in interface Traversable<T>
windowSize
- number of elements in each batchincrement
- for each windowdefault <C extends java.util.Collection<? super T>> ListT<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 ListT<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 ListT<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 ListT<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>> ListT<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>> ListT<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 TransformerSeq<T>
groupedUntil
in interface Traversable<T>
predicate
- Batch until predicate holds, then open next batchfactory
- Collection factorydefault ListT<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 TransformerSeq<T>
grouped
in interface Traversable<T>
groupSize
- Size of each Groupdefault <K,A,D> ListT<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 TransformerSeq<T>
grouped
in interface Traversable<T>
classifier
- Grouping functiondownstream
- Collector to create the grouping collectiondefault <K> ListT<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 TransformerSeq<T>
grouped
in interface Traversable<T>
classifier
- Grouping functiondefault ListT<T> distinct()
distinct
in interface TransformerSeq<T>
distinct
in interface Traversable<T>
default ListT<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> ListT<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 ListT<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> ListT<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 ListT<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 ListT<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 ListT<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 ListT<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 ListT<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 ListT<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 ListT<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 ListT<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 ListT<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 ListT<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 ListT<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 ListT<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 ListT<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 ListT<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 ListT<T> intersperse(T value)
Traversable
intersperse
in interface TransformerSeq<T>
intersperse
in interface Traversable<T>
default ListT<T> reverse()
Traversable
assertThat( of(1, 2, 3).reverse().toList(),
equalTo(asList(3, 2, 1)));
reverse
in interface TransformerSeq<T>
reverse
in interface Traversable<T>
default ListT<T> shuffle()
shuffle
in interface TransformerSeq<T>
shuffle
in interface Traversable<T>
default ListT<T> skipLast(int num)
Traversable
skipLast
in interface TransformerSeq<T>
skipLast
in interface Traversable<T>
default ListT<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 ListT<T> onEmpty(T value)
OnEmpty
onEmpty
in interface OnEmpty<T>
onEmpty
in interface TransformerSeq<T>
onEmpty
in interface Traversable<T>
default ListT<T> onEmptyGet(java.util.function.Supplier<? extends T> supplier)
OnEmpty
onEmptyGet
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> ListT<T> onEmptyThrow(java.util.function.Supplier<? extends X> supplier)
OnEmpty
onEmptyThrow
in interface OnEmpty<T>
onEmptyThrow
in interface TransformerSeq<T>
onEmptyThrow
in interface Traversable<T>
supplier
- to create exception fromdefault ListT<T> shuffle(java.util.Random random)
shuffle
in interface TransformerSeq<T>
shuffle
in interface Traversable<T>
default ListT<T> slice(long from, long to)
slice
in interface TransformerSeq<T>
slice
in interface Traversable<T>
default <U extends java.lang.Comparable<? super U>> ListT<T> sorted(java.util.function.Function<? super T,? extends U> function)
sorted
in interface TransformerSeq<T>
sorted
in interface Traversable<T>