com.aol.cyclops.types.stream.future

Interface FutureCollectable<T>

All Known Subinterfaces:

FutureOperations<T>

All Known Implementing Classes:

BaseFutureOperationsImpl, LazyFutureStreamFutureOpterationsImpl, ReactiveSeqFutureOpterationsImpl

public interface FutureCollectable<T>

Method Summary

Modifier and Type	Method and Description
java.util.concurrent.CompletableFuture<java.lang.Boolean>	allMatch(java.util.function.Predicate<? super T> predicate)
java.util.concurrent.CompletableFuture<java.lang.Boolean>	anyMatch(java.util.function.Predicate<? super T> predicate)
java.util.concurrent.CompletableFuture<java.util.Optional<T>>	avg()
<U> java.util.concurrent.CompletableFuture<java.util.Optional<U>>	avg(java.util.function.Function<? super T,? extends U> function)
default <R1,R2,A1,A2> java.util.concurrent.CompletableFuture<org.jooq.lambda.tuple.Tuple2<R1,R2>>	collect(java.util.stream.Collector<? super T,A1,R1> collector1, java.util.stream.Collector<? super T,A2,R2> collector2) Collect this collectable into 2 Collectors.
default <R1,R2,R3,A1,A2,A3> java.util.concurrent.CompletableFuture<org.jooq.lambda.tuple.Tuple3<R1,R2,R3>>	collect(java.util.stream.Collector<? super T,A1,R1> collector1, java.util.stream.Collector<? super T,A2,R2> collector2, java.util.stream.Collector<? super T,A3,R3> collector3) Collect this collectable into 3 Collectors.
default <R1,R2,R3,R4,A1,A2,A3,A4> java.util.concurrent.CompletableFuture<org.jooq.lambda.tuple.Tuple4<R1,R2,R3,R4>>	collect(java.util.stream.Collector<? super T,A1,R1> collector1, java.util.stream.Collector<? super T,A2,R2> collector2, java.util.stream.Collector<? super T,A3,R3> collector3, java.util.stream.Collector<? super T,A4,R4> collector4) Collect this collectable into 4 Collectors.
default <R1,R2,R3,R4,R5,A1,A2,A3,A4,A5> java.util.concurrent.CompletableFuture<org.jooq.lambda.tuple.Tuple5<R1,R2,R3,R4,R5>>	collect(java.util.stream.Collector<? super T,A1,R1> collector1, java.util.stream.Collector<? super T,A2,R2> collector2, java.util.stream.Collector<? super T,A3,R3> collector3, java.util.stream.Collector<? super T,A4,R4> collector4, java.util.stream.Collector<? super T,A5,R5> collector5) Collect this collectable into 5 Collectors.
default <R1,R2,R3,R4,R5,R6,A1,A2,A3,A4,A5,A6> java.util.concurrent.CompletableFuture<org.jooq.lambda.tuple.Tuple6<R1,R2,R3,R4,R5,R6>>	collect(java.util.stream.Collector<? super T,A1,R1> collector1, java.util.stream.Collector<? super T,A2,R2> collector2, java.util.stream.Collector<? super T,A3,R3> collector3, java.util.stream.Collector<? super T,A4,R4> collector4, java.util.stream.Collector<? super T,A5,R5> collector5, java.util.stream.Collector<? super T,A6,R6> collector6) Collect this collectable into 6 Collectors.
default <R1,R2,R3,R4,R5,R6,R7,A1,A2,A3,A4,A5,A6,A7> java.util.concurrent.CompletableFuture<org.jooq.lambda.tuple.Tuple7<R1,R2,R3,R4,R5,R6,R7>>	collect(java.util.stream.Collector<? super T,A1,R1> collector1, java.util.stream.Collector<? super T,A2,R2> collector2, java.util.stream.Collector<? super T,A3,R3> collector3, java.util.stream.Collector<? super T,A4,R4> collector4, java.util.stream.Collector<? super T,A5,R5> collector5, java.util.stream.Collector<? super T,A6,R6> collector6, java.util.stream.Collector<? super T,A7,R7> collector7) Collect this collectable into 7 Collectors.
default <R1,R2,R3,R4,R5,R6,R7,R8,A1,A2,A3,A4,A5,A6,A7,A8> java.util.concurrent.CompletableFuture<org.jooq.lambda.tuple.Tuple8<R1,R2,R3,R4,R5,R6,R7,R8>>	collect(java.util.stream.Collector<? super T,A1,R1> collector1, java.util.stream.Collector<? super T,A2,R2> collector2, java.util.stream.Collector<? super T,A3,R3> collector3, java.util.stream.Collector<? super T,A4,R4> collector4, java.util.stream.Collector<? super T,A5,R5> collector5, java.util.stream.Collector<? super T,A6,R6> collector6, java.util.stream.Collector<? super T,A7,R7> collector7, java.util.stream.Collector<? super T,A8,R8> collector8) Collect this collectable into 8 Collectors.
<R,A> java.util.concurrent.CompletableFuture<R>	collect(java.util.stream.Collector<? super T,A,R> collector)
java.util.concurrent.CompletableFuture<java.lang.Long>	count()
java.util.concurrent.CompletableFuture<java.lang.Long>	countDistinct()
<U> java.util.concurrent.CompletableFuture<java.lang.Long>	countDistinctBy(java.util.function.Function<? super T,? extends U> function)
java.util.concurrent.CompletableFuture<java.util.Optional<T>>	max()
java.util.concurrent.CompletableFuture<java.util.Optional<T>>	max(java.util.Comparator<? super T> comparator)
<U extends java.lang.Comparable<? super U>> java.util.concurrent.CompletableFuture<java.util.Optional<U>>	max(java.util.function.Function<? super T,? extends U> function)
<U> java.util.concurrent.CompletableFuture<java.util.Optional<U>>	max(java.util.function.Function<? super T,? extends U> function, java.util.Comparator<? super U> comparator)
<U extends java.lang.Comparable<? super U>> java.util.concurrent.CompletableFuture<java.util.Optional<T>>	maxBy(java.util.function.Function<? super T,? extends U> function)
<U> java.util.concurrent.CompletableFuture<java.util.Optional<T>>	maxBy(java.util.function.Function<? super T,? extends U> function, java.util.Comparator<? super U> comparator)
java.util.concurrent.CompletableFuture<java.util.Optional<T>>	median()
java.util.concurrent.CompletableFuture<java.util.Optional<T>>	median(java.util.Comparator<? super T> comparator)
<U extends java.lang.Comparable<? super U>> java.util.concurrent.CompletableFuture<java.util.Optional<T>>	medianBy(java.util.function.Function<? super T,? extends U> function)
<U> java.util.concurrent.CompletableFuture<java.util.Optional<T>>	medianBy(java.util.function.Function<? super T,? extends U> function, java.util.Comparator<? super U> comparator)
java.util.concurrent.CompletableFuture<java.util.Optional<T>>	min()
java.util.concurrent.CompletableFuture<java.util.Optional<T>>	min(java.util.Comparator<? super T> comparator)
<U extends java.lang.Comparable<? super U>> java.util.concurrent.CompletableFuture<java.util.Optional<U>>	min(java.util.function.Function<? super T,? extends U> function)
<U> java.util.concurrent.CompletableFuture<java.util.Optional<U>>	min(java.util.function.Function<? super T,? extends U> function, java.util.Comparator<? super U> comparator)
<U extends java.lang.Comparable<? super U>> java.util.concurrent.CompletableFuture<java.util.Optional<T>>	minBy(java.util.function.Function<? super T,? extends U> function)
<U> java.util.concurrent.CompletableFuture<java.util.Optional<T>>	minBy(java.util.function.Function<? super T,? extends U> function, java.util.Comparator<? super U> comparator)
java.util.concurrent.CompletableFuture<java.util.Optional<T>>	mode()
java.util.concurrent.CompletableFuture<java.lang.Boolean>	noneMatch(java.util.function.Predicate<? super T> predicate)
java.util.concurrent.CompletableFuture<java.util.Optional<T>>	percentile(double percentile)
java.util.concurrent.CompletableFuture<java.util.Optional<T>>	percentile(double percentile, java.util.Comparator<? super T> comparator)
<U extends java.lang.Comparable<? super U>> java.util.concurrent.CompletableFuture<java.util.Optional<T>>	percentileBy(double percentile, java.util.function.Function<? super T,? extends U> function)
<U> java.util.concurrent.CompletableFuture<java.util.Optional<T>>	percentileBy(double percentile, java.util.function.Function<? super T,? extends U> function, java.util.Comparator<? super U> comparator)
java.util.concurrent.CompletableFuture<java.util.Optional<T>>	sum()
<U> java.util.concurrent.CompletableFuture<java.util.Optional<U>>	sum(java.util.function.Function<? super T,? extends U> function)
java.util.concurrent.CompletableFuture<java.lang.Double>	sumDouble(java.util.function.ToDoubleFunction<? super T> function)
java.util.concurrent.CompletableFuture<java.lang.Integer>	sumInt(java.util.function.ToIntFunction<? super T> function)
java.util.concurrent.CompletableFuture<java.lang.Long>	sumLong(java.util.function.ToLongFunction<? super T> function)
<C extends java.util.Collection<T>> java.util.concurrent.CompletableFuture<C>	toCollection(java.util.function.Supplier<C> factory)
java.util.concurrent.CompletableFuture<java.util.List<T>>	toList()
<L extends java.util.List<T>> java.util.concurrent.CompletableFuture<L>	toList(java.util.function.Supplier<L> factory)
<K,V> java.util.concurrent.CompletableFuture<MapX<K,V>>	toMap(java.util.function.Function<? super T,? extends K> keyMapper, java.util.function.Function<? super T,? extends V> valueMapper)
java.util.concurrent.CompletableFuture<java.util.Set<T>>	toSet()
<S extends java.util.Set<T>> java.util.concurrent.CompletableFuture<S>	toSet(java.util.function.Supplier<S> factory)

Method Detail

collect

default <R1,R2,A1,A2> java.util.concurrent.CompletableFuture<org.jooq.lambda.tuple.Tuple2<R1,R2>> collect(java.util.stream.Collector<? super T,A1,R1> collector1,
                                                                                                          java.util.stream.Collector<? super T,A2,R2> collector2)

Collect this collectable into 2 Collectors.

collect

default <R1,R2,R3,A1,A2,A3> java.util.concurrent.CompletableFuture<org.jooq.lambda.tuple.Tuple3<R1,R2,R3>> collect(java.util.stream.Collector<? super T,A1,R1> collector1,
                                                                                                                   java.util.stream.Collector<? super T,A2,R2> collector2,
                                                                                                                   java.util.stream.Collector<? super T,A3,R3> collector3)

Collect this collectable into 3 Collectors.

collect

default <R1,R2,R3,R4,A1,A2,A3,A4> java.util.concurrent.CompletableFuture<org.jooq.lambda.tuple.Tuple4<R1,R2,R3,R4>> collect(java.util.stream.Collector<? super T,A1,R1> collector1,
                                                                                                                            java.util.stream.Collector<? super T,A2,R2> collector2,
                                                                                                                            java.util.stream.Collector<? super T,A3,R3> collector3,
                                                                                                                            java.util.stream.Collector<? super T,A4,R4> collector4)

Collect this collectable into 4 Collectors.

collect

default <R1,R2,R3,R4,R5,A1,A2,A3,A4,A5> java.util.concurrent.CompletableFuture<org.jooq.lambda.tuple.Tuple5<R1,R2,R3,R4,R5>> collect(java.util.stream.Collector<? super T,A1,R1> collector1,
                                                                                                                                     java.util.stream.Collector<? super T,A2,R2> collector2,
                                                                                                                                     java.util.stream.Collector<? super T,A3,R3> collector3,
                                                                                                                                     java.util.stream.Collector<? super T,A4,R4> collector4,
                                                                                                                                     java.util.stream.Collector<? super T,A5,R5> collector5)

Collect this collectable into 5 Collectors.

collect

default <R1,R2,R3,R4,R5,R6,A1,A2,A3,A4,A5,A6> java.util.concurrent.CompletableFuture<org.jooq.lambda.tuple.Tuple6<R1,R2,R3,R4,R5,R6>> collect(java.util.stream.Collector<? super T,A1,R1> collector1,
                                                                                                                                              java.util.stream.Collector<? super T,A2,R2> collector2,
                                                                                                                                              java.util.stream.Collector<? super T,A3,R3> collector3,
                                                                                                                                              java.util.stream.Collector<? super T,A4,R4> collector4,
                                                                                                                                              java.util.stream.Collector<? super T,A5,R5> collector5,
                                                                                                                                              java.util.stream.Collector<? super T,A6,R6> collector6)

Collect this collectable into 6 Collectors.

collect

default <R1,R2,R3,R4,R5,R6,R7,A1,A2,A3,A4,A5,A6,A7> java.util.concurrent.CompletableFuture<org.jooq.lambda.tuple.Tuple7<R1,R2,R3,R4,R5,R6,R7>> collect(java.util.stream.Collector<? super T,A1,R1> collector1,
                                                                                                                                                       java.util.stream.Collector<? super T,A2,R2> collector2,
                                                                                                                                                       java.util.stream.Collector<? super T,A3,R3> collector3,
                                                                                                                                                       java.util.stream.Collector<? super T,A4,R4> collector4,
                                                                                                                                                       java.util.stream.Collector<? super T,A5,R5> collector5,
                                                                                                                                                       java.util.stream.Collector<? super T,A6,R6> collector6,
                                                                                                                                                       java.util.stream.Collector<? super T,A7,R7> collector7)

Collect this collectable into 7 Collectors.

collect

default <R1,R2,R3,R4,R5,R6,R7,R8,A1,A2,A3,A4,A5,A6,A7,A8> java.util.concurrent.CompletableFuture<org.jooq.lambda.tuple.Tuple8<R1,R2,R3,R4,R5,R6,R7,R8>> collect(java.util.stream.Collector<? super T,A1,R1> collector1,
                                                                                                                                                                java.util.stream.Collector<? super T,A2,R2> collector2,
                                                                                                                                                                java.util.stream.Collector<? super T,A3,R3> collector3,
                                                                                                                                                                java.util.stream.Collector<? super T,A4,R4> collector4,
                                                                                                                                                                java.util.stream.Collector<? super T,A5,R5> collector5,
                                                                                                                                                                java.util.stream.Collector<? super T,A6,R6> collector6,
                                                                                                                                                                java.util.stream.Collector<? super T,A7,R7> collector7,
                                                                                                                                                                java.util.stream.Collector<? super T,A8,R8> collector8)

Collect this collectable into 8 Collectors.

collect

<R,A> java.util.concurrent.CompletableFuture<R> collect(java.util.stream.Collector<? super T,A,R> collector)

count

java.util.concurrent.CompletableFuture<java.lang.Long> count()

countDistinct

java.util.concurrent.CompletableFuture<java.lang.Long> countDistinct()

countDistinctBy

<U> java.util.concurrent.CompletableFuture<java.lang.Long> countDistinctBy(java.util.function.Function<? super T,? extends U> function)

mode

java.util.concurrent.CompletableFuture<java.util.Optional<T>> mode()

sum

java.util.concurrent.CompletableFuture<java.util.Optional<T>> sum()

sum

<U> java.util.concurrent.CompletableFuture<java.util.Optional<U>> sum(java.util.function.Function<? super T,? extends U> function)

sumInt

java.util.concurrent.CompletableFuture<java.lang.Integer> sumInt(java.util.function.ToIntFunction<? super T> function)

sumLong

java.util.concurrent.CompletableFuture<java.lang.Long> sumLong(java.util.function.ToLongFunction<? super T> function)

sumDouble

java.util.concurrent.CompletableFuture<java.lang.Double> sumDouble(java.util.function.ToDoubleFunction<? super T> function)

avg

java.util.concurrent.CompletableFuture<java.util.Optional<T>> avg()

avg

<U> java.util.concurrent.CompletableFuture<java.util.Optional<U>> avg(java.util.function.Function<? super T,? extends U> function)

min

java.util.concurrent.CompletableFuture<java.util.Optional<T>> min()

min

java.util.concurrent.CompletableFuture<java.util.Optional<T>> min(java.util.Comparator<? super T> comparator)

min

<U extends java.lang.Comparable<? super U>> java.util.concurrent.CompletableFuture<java.util.Optional<U>> min(java.util.function.Function<? super T,? extends U> function)

min

<U> java.util.concurrent.CompletableFuture<java.util.Optional<U>> min(java.util.function.Function<? super T,? extends U> function,
                                                                      java.util.Comparator<? super U> comparator)

minBy

<U extends java.lang.Comparable<? super U>> java.util.concurrent.CompletableFuture<java.util.Optional<T>> minBy(java.util.function.Function<? super T,? extends U> function)

minBy

<U> java.util.concurrent.CompletableFuture<java.util.Optional<T>> minBy(java.util.function.Function<? super T,? extends U> function,
                                                                        java.util.Comparator<? super U> comparator)

max

java.util.concurrent.CompletableFuture<java.util.Optional<T>> max()

max

java.util.concurrent.CompletableFuture<java.util.Optional<T>> max(java.util.Comparator<? super T> comparator)

max

<U extends java.lang.Comparable<? super U>> java.util.concurrent.CompletableFuture<java.util.Optional<U>> max(java.util.function.Function<? super T,? extends U> function)

max

<U> java.util.concurrent.CompletableFuture<java.util.Optional<U>> max(java.util.function.Function<? super T,? extends U> function,
                                                                      java.util.Comparator<? super U> comparator)

maxBy

<U extends java.lang.Comparable<? super U>> java.util.concurrent.CompletableFuture<java.util.Optional<T>> maxBy(java.util.function.Function<? super T,? extends U> function)

maxBy

<U> java.util.concurrent.CompletableFuture<java.util.Optional<T>> maxBy(java.util.function.Function<? super T,? extends U> function,
                                                                        java.util.Comparator<? super U> comparator)

median

java.util.concurrent.CompletableFuture<java.util.Optional<T>> median()

median

java.util.concurrent.CompletableFuture<java.util.Optional<T>> median(java.util.Comparator<? super T> comparator)

medianBy

<U extends java.lang.Comparable<? super U>> java.util.concurrent.CompletableFuture<java.util.Optional<T>> medianBy(java.util.function.Function<? super T,? extends U> function)

medianBy

<U> java.util.concurrent.CompletableFuture<java.util.Optional<T>> medianBy(java.util.function.Function<? super T,? extends U> function,
                                                                           java.util.Comparator<? super U> comparator)

percentile

java.util.concurrent.CompletableFuture<java.util.Optional<T>> percentile(double percentile)

percentile

java.util.concurrent.CompletableFuture<java.util.Optional<T>> percentile(double percentile,
                                                                         java.util.Comparator<? super T> comparator)

percentileBy

<U extends java.lang.Comparable<? super U>> java.util.concurrent.CompletableFuture<java.util.Optional<T>> percentileBy(double percentile,
                                                                                                                       java.util.function.Function<? super T,? extends U> function)

percentileBy

<U> java.util.concurrent.CompletableFuture<java.util.Optional<T>> percentileBy(double percentile,
                                                                               java.util.function.Function<? super T,? extends U> function,
                                                                               java.util.Comparator<? super U> comparator)

allMatch

java.util.concurrent.CompletableFuture<java.lang.Boolean> allMatch(java.util.function.Predicate<? super T> predicate)

anyMatch

java.util.concurrent.CompletableFuture<java.lang.Boolean> anyMatch(java.util.function.Predicate<? super T> predicate)

noneMatch

java.util.concurrent.CompletableFuture<java.lang.Boolean> noneMatch(java.util.function.Predicate<? super T> predicate)

toList

java.util.concurrent.CompletableFuture<java.util.List<T>> toList()

toList

<L extends java.util.List<T>> java.util.concurrent.CompletableFuture<L> toList(java.util.function.Supplier<L> factory)

toSet

java.util.concurrent.CompletableFuture<java.util.Set<T>> toSet()

toSet

<S extends java.util.Set<T>> java.util.concurrent.CompletableFuture<S> toSet(java.util.function.Supplier<S> factory)

toCollection

<C extends java.util.Collection<T>> java.util.concurrent.CompletableFuture<C> toCollection(java.util.function.Supplier<C> factory)

toMap

<K,V> java.util.concurrent.CompletableFuture<MapX<K,V>> toMap(java.util.function.Function<? super T,? extends K> keyMapper,
                                                              java.util.function.Function<? super T,? extends V> valueMapper)