public interface OperationsOnFutures<T>
Modifier and Type | Method and Description |
---|---|
default LazyFutureStream<T> |
append(T... values)
Append values to the end of this SequenceM
|
default LazyFutureStream<T> |
appendFutures(java.util.concurrent.CompletableFuture<T>... values)
Append the provided Futures to this Stream
|
default LazyFutureStream<T> |
appendStream(java.util.stream.Stream<T> stream)
Append Stream to this Stream
|
default LazyFutureStream<T> |
appendStreamFutures(java.util.stream.Stream<java.util.concurrent.CompletableFuture<T>> stream)
Append a Stream of Futures to this Stream
|
default <R,A> R |
collect(java.util.stream.Collector<? super java.util.concurrent.CompletableFuture<T>,A,R> collector)
Collect a Stream
|
default LazyFutureStream<T> |
concat(java.util.stream.Stream<T> other) |
default LazyFutureStream<T> |
concat(T... other) |
default LazyFutureStream<T> |
concat(T other) |
default LazyFutureStream<T> |
concatFutures(java.util.concurrent.CompletableFuture<T>... other)
Concat supplied Futures to this Stream
|
default LazyFutureStream<T> |
concatStreamFutures(java.util.stream.Stream<java.util.concurrent.CompletableFuture<T>> other)
Concat supplied Futures to this Stream
|
default LazyFutureStream<T> |
cycle()
Convert to a Stream with the values infinitely cycled
|
default LazyFutureStream<T> |
cycle(int times)
Convert to a Stream with the values repeated specified times
|
default LazyFutureStream<T> |
deleteBetween(int start,
int end)
Delete elements between given indexes in a Stream
|
default org.jooq.lambda.tuple.Tuple2<LazyFutureStream<T>,LazyFutureStream<T>> |
duplicate()
Duplicate a Stream, buffers intermediate values, leaders may change
positions so a limit can be safely applied to the leading stream.
|
default java.util.Optional<T> |
elementAt(long index)
Return the elementAt index or Optional.empty
|
default java.util.concurrent.CompletableFuture<T> |
foldLeft(java.util.concurrent.CompletableFuture<T> identity,
java.util.function.BinaryOperator<java.util.concurrent.CompletableFuture<T>> accumulator)
Sequentially reduce from the left
|
default java.util.concurrent.CompletableFuture<T> |
foldRight(java.util.concurrent.CompletableFuture<T> identity,
java.util.function.BinaryOperator<java.util.concurrent.CompletableFuture<T>> accumulator)
Reduce sequentially from the right
|
LazyFutureStream<T> |
fromStreamOfFutures(java.util.stream.Stream<FastFuture<T>> stream) |
default org.jooq.lambda.tuple.Tuple2<T,LazyFutureStream<T>> |
get(long index)
Gets the element at index, and returns a Tuple containing the element (it
must be present) and a lazy copy of the Sequence for further processing.
|
LazyStreamWrapper<T> |
getLastActive() |
Continueable |
getSubscription() |
default LazyFutureStream<java.util.List<T>> |
grouped(int groupSize)
Group elements in a Stream
|
default HeadAndTail<T> |
headAndTail()
extract head and tail together, where head is expected to be present
|
default LazyFutureStream<T> |
insertAt(int pos,
T... values)
Insert data into a stream at given position
|
default LazyFutureStream<T> |
insertStreamAt(int pos,
java.util.stream.Stream<T> stream)
Insert a Stream into the middle of this stream at the specified position
|
default LazyFutureStream<T> |
insertStreamFuturesAt(int pos,
java.util.stream.Stream<java.util.concurrent.CompletableFuture<T>> stream)
Insert a Stream into the middle of this stream at the specified position
|
default LazyFutureStream<T> |
intersperse(java.util.concurrent.CompletableFuture<T> value)
Returns a stream with a given value interspersed between any two values
of this stream.
|
default LazyFutureStream<T> |
intersperse(T value)
Returns a stream with a given value interspersed between any two values
of this stream.
|
default LazyFutureStream<T> |
limit(long maxSize)
assertThat(of(1,2,3,4,5).actOnFutures().limit(2).collect(Collectors.toList()).size(),is(2)); |
default LazyFutureStream<T> |
limitLast(int num)
Limit results to the last x elements in a SequenceM
|
default LazyFutureStream<T> |
prepend(T... values)
Prepend given values to the start of the Stream
|
default LazyFutureStream<T> |
prependFutures(java.util.concurrent.CompletableFuture<T>... values)
List<String> result = of(1,2,3).actOnFutures()
.prependFutures(CompletableFuture.completedFuture(100),CompletableFuture.completedFuture(200),CompletableFuture.completedFuture(300))
.map(it ->it+"!!")
.collect(Collectors.toList());
assertThat(result,equalTo(Arrays.asList("100!!","200!!","300!!","1!!","2!!","3!!")));
|
default LazyFutureStream<T> |
prependStream(java.util.stream.Stream<T> stream)
Prepend Stream to this SequenceM
|
default LazyFutureStream<T> |
prependStreamFutures(java.util.stream.Stream<java.util.concurrent.CompletableFuture<T>> stream)
Stream<CompletableFuture<Integer>> streamOfFutures = Stream.of(CompletableFuture.completedFuture(100),CompletableFuture.completedFuture(200),CompletableFuture.completedFuture(300));
List<String> result = of(1,2,3).actOnFutures()
.prependStreamFutures(streamOfFutures)
.map(it ->it+"!!")
.collect(Collectors.toList());
assertThat(result,equalTo(Arrays.asList("100!!","200!!","300!!","1!!","2!!","3!!")));
|
default org.jooq.lambda.tuple.Tuple4<LazyFutureStream<T>,LazyFutureStream<T>,LazyFutureStream<T>,LazyFutureStream<T>> |
quadruplicate()
Makes four copies of a Stream Buffers intermediate values, leaders may
change positions so a limit can be safely applied to the leading stream.
|
default java.util.Optional<java.util.concurrent.CompletableFuture<T>> |
reduce(java.util.function.BinaryOperator<java.util.concurrent.CompletableFuture<T>> accumulator)
Reduce a Stream
|
default java.util.concurrent.CompletableFuture<T> |
reduce(java.util.concurrent.CompletableFuture<T> identity,
java.util.function.BinaryOperator<java.util.concurrent.CompletableFuture<T>> accumulator) |
default <U> java.util.concurrent.CompletableFuture<U> |
reduce(java.util.concurrent.CompletableFuture<U> identity,
java.util.function.BiFunction<java.util.concurrent.CompletableFuture<U>,? super java.util.concurrent.CompletableFuture<T>,java.util.concurrent.CompletableFuture<U>> accumulator,
java.util.function.BinaryOperator<java.util.concurrent.CompletableFuture<U>> combiner) |
default LazyFutureStream<T> |
reverse()
Reverse this Stream, by reversing the order in which the underlying Futures will be processed
|
T |
safeJoin(FastFuture<T> f) |
default LazyFutureStream<T> |
shuffle() |
default LazyFutureStream<T> |
shuffle(java.util.Random random)
Shuffle a stream using specified source of randomness
// e.g.
|
default LazyFutureStream<T> |
skip(long n)
assertThat(of(1,2,3,4,5).actOnFutures().skip(2).collect(Collectors.toList()).size(),is(3)); |
default LazyFutureStream<T> |
skipLast(int num)
Skip the last num of elements from this Stream
|
default LazyFutureStream<T> |
slice(long from,
long to)
Returns a limited interval from a given Stream.
|
default LazyFutureStream<java.util.List<T>> |
sliding(int windowSize)
Create a sliding view over this Sequence
|
default LazyFutureStream<java.util.List<T>> |
sliding(int windowSize,
int increment)
Create a sliding view over this Sequence
|
default org.jooq.lambda.tuple.Tuple2<LazyFutureStream<T>,LazyFutureStream<T>> |
splitAt(int where)
Split at supplied location
|
default org.jooq.lambda.tuple.Tuple2<java.util.Optional<T>,LazyFutureStream<T>> |
splitAtHead()
Split a Stream at it's head (similar to headAndTail)
|
default <R> LazyFutureStream<R> |
thenCombine(java.util.function.BiFunction<T,T,R> combiner)
Combines every pair of values (any odd remaining value will be dropped)
|
default <C extends java.util.Collection<java.util.concurrent.CompletableFuture<T>>> |
toCollection(java.util.function.Supplier<C> collectionFactory)
Collect a Stream into a Collection
|
default java.util.List<java.util.concurrent.CompletableFuture<T>> |
toList()
Collect a Stream into a List.
|
default java.util.Set<java.util.concurrent.CompletableFuture<T>> |
toSet()
Collect a Stream into a Set.
|
default ReactiveSeq<java.util.concurrent.CompletableFuture<T>> |
toStream()
Convert this FutureStream to a Stream of CompletableFutures
|
default org.jooq.lambda.tuple.Tuple3<LazyFutureStream<T>,LazyFutureStream<T>,LazyFutureStream<T>> |
triplicate()
Triplicates a Stream.
|
LazyFutureStream<T> |
withLastActive(LazyStreamWrapper<T> active) |
default <R> LazyFutureStream<org.jooq.lambda.tuple.Tuple2<T,R>> |
zip(java.util.stream.Stream<R> other)
Zip two Streams.
|
default <S,U> LazyFutureStream<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 <S,U> LazyFutureStream<org.jooq.lambda.tuple.Tuple3<T,S,U>> |
zip3Lfs(LazyFutureStream<? extends S> second,
LazyFutureStream<? extends U> third)
Zip 3 LazyFutureStreams based on the order of the data in the underlying Futures
|
default <T2,T3,T4> LazyFutureStream<org.jooq.lambda.tuple.Tuple4<T,T2,T3,T4>> |
zip4(java.util.stream.Stream<T2> second,
java.util.stream.Stream<T3> third,
java.util.stream.Stream<T4> fourth)
zip 4 Streams into 1
|
default <T2,T3,T4> LazyFutureStream<org.jooq.lambda.tuple.Tuple4<T,T2,T3,T4>> |
zip4Lfs(LazyFutureStream<T2> second,
LazyFutureStream<T3> third,
LazyFutureStream<T4> fourth)
Zip 4 LazyFutureStreams into 1
|
default <R> LazyFutureStream<org.jooq.lambda.tuple.Tuple2<T,R>> |
zipLfs(LazyFutureStream<R> other)
Zip two LazyFutureStreams by combining the underlying Futures
|
default <R,T2> LazyFutureStream<R> |
zipLfs(LazyFutureStream<T2> other,
java.util.function.BiFunction<java.util.concurrent.CompletableFuture<T>,java.util.concurrent.CompletableFuture<T2>,java.util.concurrent.CompletableFuture<R>> combiner)
Zip two LazyFutureStreams using the provided combiner
|
default LazyFutureStream<org.jooq.lambda.tuple.Tuple2<T,java.lang.Long>> |
zipWithIndex()
Add an index to the current Stream
|
LazyFutureStream<T> fromStreamOfFutures(java.util.stream.Stream<FastFuture<T>> stream)
LazyStreamWrapper<T> getLastActive()
LazyFutureStream<T> withLastActive(LazyStreamWrapper<T> active)
T safeJoin(FastFuture<T> f)
Continueable getSubscription()
default LazyFutureStream<T> reverse()
LazyFutureStream.of(1, 2, 3).actOnFutures()
.reverse()
.toList();
//3,2,1
default LazyFutureStream<T> cycle(int times)
assertThat(LazyFutureStream.of(1,2,2)
.actOnFutures()
.cycle(3)
.collect(Collectors.toList()),
equalTo(Arrays.asList(1,2,2,1,2,2,1,2,2)));
times
- Times values should be repeated within a Streamdefault LazyFutureStream<T> cycle()
assertEquals(asList(1, 1, 1, 1, 1,1),LazyFutureStream.of(1)
.actOnFutures()
.cycle()
.limit(6).toList());
default org.jooq.lambda.tuple.Tuple2<LazyFutureStream<T>,LazyFutureStream<T>> duplicate()
Tuple2<LazyFutureStream<<Integer>, LazyFutureStream<<Integer>> copies = of(1, 2, 3, 4, 5, 6)
actOnFutures().duplicate();
assertTrue(copies.v1.anyMatch(i -> i == 2));
assertTrue(copies.v2.anyMatch(i -> i == 2));
default org.jooq.lambda.tuple.Tuple3<LazyFutureStream<T>,LazyFutureStream<T>,LazyFutureStream<T>> triplicate()
Tuple3<LazyFutureStream<Integer>, LazyFutureStream<Integer>, LazyFutureStream<Integer>> copies =of(1,2,3,4,5,6).actOnFutures().triplicate();
assertTrue(copies.v1.anyMatch(i->i==2));
assertTrue(copies.v2.anyMatch(i->i==2));
assertTrue(copies.v3.anyMatch(i->i==2));
default org.jooq.lambda.tuple.Tuple4<LazyFutureStream<T>,LazyFutureStream<T>,LazyFutureStream<T>,LazyFutureStream<T>> quadruplicate()
Tuple4<LazyFutureStream<Integer>, LazyFutureStream<Integer>, LazyFutureStream<Integer>,LazyFutureStream<Integer>> copies =of(1,2,3,4,5,6).actOnFutures().quadruplicate();
assertTrue(copies.v1.anyMatch(i->i==2));
assertTrue(copies.v2.anyMatch(i->i==2));
assertTrue(copies.v3.anyMatch(i->i==2));
assertTrue(copies.v4.anyMatch(i->i==2));
default org.jooq.lambda.tuple.Tuple2<java.util.Optional<T>,LazyFutureStream<T>> splitAtHead()
LazyFutureStream.of(1,2,3).actOnFutures().splitAtHead()
//Optional[1], SequenceM[2,3]
default org.jooq.lambda.tuple.Tuple2<LazyFutureStream<T>,LazyFutureStream<T>> splitAt(int where)
LazyFutureStream.of(1,2,3).actOnFutures().splitAt(1)
//SequenceM[1], SequenceM[2,3]
default <R> LazyFutureStream<org.jooq.lambda.tuple.Tuple2<T,R>> zipLfs(LazyFutureStream<R> other)
List<Tuple2<Integer,Integer>> list =
of(1,2,3,4,5,6).actOnFutures().zipLfs(of(100,200,300,400))
.peek(it -> System.out.println(it)).collect(Collectors.toList());
// [1,100],[2,200],[3,300],[4,400]
other
- default <R,T2> LazyFutureStream<R> zipLfs(LazyFutureStream<T2> other, java.util.function.BiFunction<java.util.concurrent.CompletableFuture<T>,java.util.concurrent.CompletableFuture<T2>,java.util.concurrent.CompletableFuture<R>> combiner)
BiFunction<CompletableFuture<Integer>,CompletableFuture<Integer>,CompletableFuture<Tuple2<Integer,Integer>>> combiner =
(cf1,cf2)->cf1.<Integer,Tuple2<Integer,Integer>>thenCombine(cf2, (v1,v2)->Tuple.tuple(v1,v2));
List<Tuple2<Integer,Integer>> list =
of(1,2,3,4,5,6).actOnFutures().zipLfs(of(100,200,300,400), combiner)
.peek(it -> System.out.println(it)).collect(Collectors.toList());
List<Integer> right = list.stream().map(t -> t.v2).collect(Collectors.toList());
assertThat(right,hasItem(100));
assertThat(right,hasItem(200));
assertThat(right,hasItem(300));
assertThat(right,hasItem(400));
default <R> LazyFutureStream<org.jooq.lambda.tuple.Tuple2<T,R>> zip(java.util.stream.Stream<R> other)
List<Tuple2<Integer,Integer>> list =
of(1,2,3,4,5,6).actOnFutures().zip(of(100,200,300,400))
.peek(it -> System.out.println(it)).collect(Collectors.toList());
// [1,100],[2,200],[3,300],[4,400]
Example with two LazyFutureStreams
List<Tuple2<Integer,Integer>> list =
LazyFutureStream.of(slow,fast,med).actOnFutures().zip(LazyFutureStream.of(slow,fast,med))
.peek(it -> System.out.println(it)).collect(Collectors.toList());
// [slow,fast],[fast,med],[med,slow]
default <S,U> LazyFutureStream<org.jooq.lambda.tuple.Tuple3<T,S,U>> zip3(java.util.stream.Stream<? extends S> second, java.util.stream.Stream<? extends U> third)
List<Tuple3<Integer,Integer,Character>> list =
of(1,2,3,4,5,6).actOnFutures().zip3(of(100,200,300,400),of('a','b','c'))
.collect(Collectors.toList());
// [1,100,'a'],[2,200,'b'],[3,300,'c']
List<Tuple3<Integer,Integer,Character>> list =
of(slow,med,fast).actOnFutures().zip3(of(slow,med,fast),of(slow,med,fast))
.collect(Collectors.toList());
//[slow,fast,fast],[med,med,med],[fast,slow,slow]
default <S,U> LazyFutureStream<org.jooq.lambda.tuple.Tuple3<T,S,U>> zip3Lfs(LazyFutureStream<? extends S> second, LazyFutureStream<? extends U> third)
List<Tuple3<Integer,Integer,Character>> list =
of(slow,med,fast).actOnFutures().zip3Lfs(of(slow,med,fast),of(slow,med,fast))
.collect(Collectors.toList());
//[slow,slow,slow],[med,med,med],[fast,fast,fast]
default <T2,T3,T4> LazyFutureStream<org.jooq.lambda.tuple.Tuple4<T,T2,T3,T4>> zip4(java.util.stream.Stream<T2> second, java.util.stream.Stream<T3> third, java.util.stream.Stream<T4> fourth)
List<Tuple3<Integer,Integer,Character>> list =
of(slow,med,fast).actOnFutures().zip4(of(slow,med,fast),of(slow,med,fast),of(slow,med,fast))
.collect(Collectors.toList());
//[slow,fast,fast,fast],[med,med,med,med],[fast,slow,slow,slow]
default <T2,T3,T4> LazyFutureStream<org.jooq.lambda.tuple.Tuple4<T,T2,T3,T4>> zip4Lfs(LazyFutureStream<T2> second, LazyFutureStream<T3> third, LazyFutureStream<T4> fourth)
List<Tuple3<Integer,Integer,Character>> list =
of(slow,med,fast).actOnFutures().zip4(of(slow,med,fast),of(slow,med,fast),of(slow,med,fast))
.collect(Collectors.toList());
//[slow,slow,slow,slow],[med,med,med,med],[fast,fast,fast,fast]
default LazyFutureStream<org.jooq.lambda.tuple.Tuple2<T,java.lang.Long>> zipWithIndex()
assertEquals(asList(new Tuple2("a", 0L), new Tuple2("b", 1L)), of("a", "b").actOnFutures().zipWithIndex().toList());
default LazyFutureStream<java.util.List<T>> sliding(int windowSize)
List<List<Integer>> list = of(1,2,3,4,5,6).actOnFutures().sliding(2)
.collect(Collectors.toList());
assertThat(list.get(0),hasItems(1,2));
assertThat(list.get(1),hasItems(2,3));
windowSize
- Size of sliding windowdefault LazyFutureStream<java.util.List<T>> sliding(int windowSize, int increment)
List<List<Integer>> list = of(1,2,3,4,5,6).actOnFutures().sliding(3,2)
.collect(Collectors.toList());
System.out.println(list.get(0));
assertThat(list.get(0),hasItems(1,2,3));
assertThat(list.get(1),hasItems(3,4,5));
windowSize
- number of elements in each batchincrement
- for each windowdefault LazyFutureStream<java.util.List<T>> grouped(int groupSize)
assertThat(of(1,2,3,4,5,6).actOnFutures().grouped(3).collect(Collectors.toList()).size(),is(2));
groupSize
- Size of each Groupdefault LazyFutureStream<T> skip(long n)
assertThat(of(1,2,3,4,5).actOnFutures().skip(2).collect(Collectors.toList()).size(),is(3));
n
- Number of elemenets to skipdefault LazyFutureStream<T> limit(long maxSize)
assertThat(of(1,2,3,4,5).actOnFutures().limit(2).collect(Collectors.toList()).size(),is(2));
maxSize
- Limit element size to numdefault HeadAndTail<T> headAndTail()
LazyFutureStream<String> helloWorld = LazyFutureStream.of("hello",
"world", "last");
HeadAndTail<String> headAndTail = helloWorld.actOnFutures()
.headAndTail();
String head = headAndTail.head();
assertThat(head, equalTo("hello"));
ReactiveSeq<String> tail = headAndTail.tail();
assertThat(tail.headAndTail().head(), equalTo("world"));
default LazyFutureStream<T> intersperse(T value)
default LazyFutureStream<T> intersperse(java.util.concurrent.CompletableFuture<T> value)
default LazyFutureStream<T> shuffle()
default LazyFutureStream<T> appendStream(java.util.stream.Stream<T> stream)
List<String> result = of(1,2,3).actOnFutures()
.appendStream(of(100,200,300))
.map(it ->it+"!!")
.collect(Collectors.toList());
assertThat(result,equalTo(Arrays.asList("1!!","2!!","3!!","100!!","200!!","300!!")));
stream
- to appenddefault LazyFutureStream<T> appendStreamFutures(java.util.stream.Stream<java.util.concurrent.CompletableFuture<T>> stream)
List<String> result = of(1,2,3).actOnFutures()
.appendStreamFutures(Stream.of(CompletableFuture.completedFuture(100),CompletableFuture.completedFuture(200),CompletableFuture.completedFuture(300)))
.map(it ->it+"!!")
.collect(Collectors.toList());
assertThat(result,equalTo(Arrays.asList("1!!","2!!","3!!","100!!","200!!","300!!")));
stream
- default LazyFutureStream<T> prependStream(java.util.stream.Stream<T> stream)
List<String> result = of(1,2,3).actOnFutures()
.prependStream(of(100,200,300))
.map(it ->it+"!!")
.collect(Collectors.toList());
assertThat(result,equalTo(Arrays.asList("100!!","200!!","300!!","1!!","2!!","3!!")));
stream
- to Prependdefault LazyFutureStream<T> prependStreamFutures(java.util.stream.Stream<java.util.concurrent.CompletableFuture<T>> stream)
Stream<CompletableFuture<Integer>> streamOfFutures = Stream.of(CompletableFuture.completedFuture(100),CompletableFuture.completedFuture(200),CompletableFuture.completedFuture(300));
List<String> result = of(1,2,3).actOnFutures()
.prependStreamFutures(streamOfFutures)
.map(it ->it+"!!")
.collect(Collectors.toList());
assertThat(result,equalTo(Arrays.asList("100!!","200!!","300!!","1!!","2!!","3!!")));
default LazyFutureStream<T> append(T... values)
List<String> result = of(1,2,3).actOnFutures()
.append(100,200,300)
.map(it ->it+"!!")
.collect(Collectors.toList());
assertThat(result,equalTo(Arrays.asList("1!!","2!!","3!!","100!!","200!!","300!!")));
values
- to appenddefault LazyFutureStream<T> appendFutures(java.util.concurrent.CompletableFuture<T>... values)
List<String> result = of(1,2,3).actOnFutures()
.appendFutures(CompletableFuture.completedFuture(100),CompletableFuture.completedFuture(200),CompletableFuture.completedFuture(300))
.map(it ->it+"!!")
.collect(Collectors.toList());
assertThat(result,equalTo(Arrays.asList("1!!","2!!","3!!","100!!","200!!","300!!")));
values
- Futures to appenddefault LazyFutureStream<T> prepend(T... values)
List<String> result = LazyFutureStream.of(1,2,3).actOnFutures()
.prepend(100,200,300)
.map(it ->it+"!!")
.collect(Collectors.toList());
assertThat(result,equalTo(Arrays.asList("100!!","200!!","300!!","1!!","2!!","3!!")));
values
- to prependdefault LazyFutureStream<T> prependFutures(java.util.concurrent.CompletableFuture<T>... values)
List<String> result = of(1,2,3).actOnFutures()
.prependFutures(CompletableFuture.completedFuture(100),CompletableFuture.completedFuture(200),CompletableFuture.completedFuture(300))
.map(it ->it+"!!")
.collect(Collectors.toList());
assertThat(result,equalTo(Arrays.asList("100!!","200!!","300!!","1!!","2!!","3!!")));
default LazyFutureStream<T> insertAt(int pos, T... values)
List<String> result = of(1,2,3).actOnFutures()
.insertAt(1,100,200,300)
.map(it ->it+"!!")
.collect(Collectors.toList());
assertThat(result,equalTo(Arrays.asList("1!!","100!!","200!!","300!!","2!!","3!!")));
pos
- to insert data atvalues
- to insertdefault LazyFutureStream<T> deleteBetween(int start, int end)
List<String> result = of(1,2,3,4,5,6).actOnFutures()
.deleteBetween(2,4)
.map(it ->it+"!!")
.collect(Collectors.toList());
assertThat(result,equalTo(Arrays.asList("1!!","2!!","5!!","6!!")));
start
- indexend
- indexdefault LazyFutureStream<T> insertStreamAt(int pos, java.util.stream.Stream<T> stream)
List<String> result = of(1,2,3).actOnFutures()
.insertStreamAt(1,of(100,200,300))
.map(it ->it+"!!")
.collect(Collectors.toList());
assertThat(result,equalTo(Arrays.asList("1!!","100!!","200!!","300!!","2!!","3!!")));
pos
- to insert Stream atstream
- to insertdefault LazyFutureStream<T> insertStreamFuturesAt(int pos, java.util.stream.Stream<java.util.concurrent.CompletableFuture<T>> stream)
Stream<CompletableFuture<Integer>> streamOfFutures = Stream.of(CompletableFuture.completedFuture(100),CompletableFuture.completedFuture(200),CompletableFuture.completedFuture(300));
List<String> result = of(1,2,3).actOnFutures()
.insertStreamFuturesAt(1,streamOfFutures)
.map(it ->it+"!!")
.collect(Collectors.toList());
assertThat(result,equalTo(Arrays.asList("1!!","100!!","200!!","300!!","2!!","3!!")));
pos
- to insert Stream atstream
- to insertdefault LazyFutureStream<T> skipLast(int num)
assertThat(LazyFutureStream.of(1,2,3,4,5)
.actOnFutures()
.skipLast(2)
.collect(Collectors.toList()),equalTo(Arrays.asList(1,2,3)));
default LazyFutureStream<T> limitLast(int num)
assertThat(LazyFutureStream.of(1,2,3,4,5).actOnFutures()
.limitLast(2)
.collect(Collectors.toList()),equalTo(Arrays.asList(4,5)));
num
- of elements to return (last elements)default java.util.Optional<T> elementAt(long index)
assertThat(LazyFutureStream.of(1,2,3,4,5).actOnFutures().elementAt(2).get(),equalTo(3));
index
- to extract element fromdefault org.jooq.lambda.tuple.Tuple2<T,LazyFutureStream<T>> get(long index)
LazyFutureStream.of(1,2,3,4,5).actOnFutures().get(2).v1
//3
index
- to extract element fromdefault <R> LazyFutureStream<R> thenCombine(java.util.function.BiFunction<T,T,R> combiner)
assertThat(of(1,2,3,4).actOnFutures().thenCombine((a,b)->a+b).toList(),equalTo(Arrays.asList(3,7)));
combiner
- Function to Combine pairs of valuesdefault LazyFutureStream<T> concat(java.util.stream.Stream<T> other)
default LazyFutureStream<T> concat(T other)
default LazyFutureStream<T> concat(T... other)
default LazyFutureStream<T> concatFutures(java.util.concurrent.CompletableFuture<T>... other)
List<String> result = of(1,2,3).actOnFutures().concatFutures(CompletableFuture.completedFuture(100),CompletableFuture.completedFuture(200),CompletableFuture.completedFuture(300))
.map(it ->it+"!!").collect(Collectors.toList());
assertThat(result,containsInAnyOrder("1!!","2!!","100!!","200!!","3!!","300!!"));
default LazyFutureStream<T> concatStreamFutures(java.util.stream.Stream<java.util.concurrent.CompletableFuture<T>> other)
List<String> result = of(1,2,3).actOnFutures()
.concatStreamFutures(Stream.of(CompletableFuture.completedFuture(100),CompletableFuture.completedFuture(200),CompletableFuture.completedFuture(300)))
.map(it ->it+"!!")
.collect(Collectors.toList());
assertThat(result,containsInAnyOrder("1!!","2!!","100!!","200!!","3!!","300!!"));
default LazyFutureStream<T> shuffle(java.util.Random random)
default LazyFutureStream<T> slice(long from, long to)
LazyFutureStream.of(1, 2, 3, 4, 5, 6).actOnFutures().slice(3, 5)
// (4, 5)
default ReactiveSeq<java.util.concurrent.CompletableFuture<T>> toStream()
default java.util.Set<java.util.concurrent.CompletableFuture<T>> toSet()
default <R,A> R collect(java.util.stream.Collector<? super java.util.concurrent.CompletableFuture<T>,A,R> collector)
collector
- Collecto to usedefault java.util.List<java.util.concurrent.CompletableFuture<T>> toList()
default <C extends java.util.Collection<java.util.concurrent.CompletableFuture<T>>> C toCollection(java.util.function.Supplier<C> collectionFactory)
default java.util.Optional<java.util.concurrent.CompletableFuture<T>> reduce(java.util.function.BinaryOperator<java.util.concurrent.CompletableFuture<T>> accumulator)
CompletableFuture<Integer> sum = of(1, 2, 3).actOnFutures()
.reduce((cf1,cf2)-> cf1.thenCombine(cf2, (a,b)->a+b)).get();
assertThat(sum.join(),equalTo(6));
accumulator
- CompletableFuture accumulatordefault java.util.concurrent.CompletableFuture<T> foldRight(java.util.concurrent.CompletableFuture<T> identity, java.util.function.BinaryOperator<java.util.concurrent.CompletableFuture<T>> accumulator)
Supplier<LazyFutureStream<String>> s = () -> of("a", "b", "c");
CompletableFuture<String> identity = CompletableFuture.completedFuture("");
BinaryOperator<CompletableFuture<String>> concat = (cf1,cf2)-> cf1.thenCombine(cf2, String::concat);
assertTrue(s.get().actOnFutures().foldRight(identity, concat).join().contains("a"));
assertTrue(s.get().actOnFutures().foldRight(identity, concat).join().contains("b"));
assertTrue(s.get().actOnFutures().foldRight(identity, concat).join().contains("c"));
identity
- valueaccumulator
- default java.util.concurrent.CompletableFuture<T> foldLeft(java.util.concurrent.CompletableFuture<T> identity, java.util.function.BinaryOperator<java.util.concurrent.CompletableFuture<T>> accumulator)
Supplier<LazyFutureStream<String>> s = () -> of("a", "b", "c");
CompletableFuture<String> identity = CompletableFuture.completedFuture("");
BinaryOperator<CompletableFuture<String>> concat = (cf1,cf2)-> cf1.thenCombine(cf2, String::concat);
assertTrue(s.get().actOnFutures().foldLeft(identity, concat).join().contains("a"));
assertTrue(s.get().actOnFutures().foldLeft(identity, concat).join().contains("b"));
assertTrue(s.get().actOnFutures().foldLeft(identity, concat).join().contains("c"));
identity
- accumulator
- default java.util.concurrent.CompletableFuture<T> reduce(java.util.concurrent.CompletableFuture<T> identity, java.util.function.BinaryOperator<java.util.concurrent.CompletableFuture<T>> accumulator)
default <U> java.util.concurrent.CompletableFuture<U> reduce(java.util.concurrent.CompletableFuture<U> identity, java.util.function.BiFunction<java.util.concurrent.CompletableFuture<U>,? super java.util.concurrent.CompletableFuture<T>,java.util.concurrent.CompletableFuture<U>> accumulator, java.util.function.BinaryOperator<java.util.concurrent.CompletableFuture<U>> combiner)