FutureOperationsImpl (cyclops-streams 7.3.1 API)

java.lang.Object
- com.aol.cyclops.streams.future.FutureOperationsImpl<T>

All Implemented Interfaces:

FutureOperations<T>, ReactiveStreamsTerminalFutureOperations<T>, DoubleOperators<T>, DoubleOperatorsMixin<T>, FutureCollectable<T>, IntOperators<T>, IntOperatorsMixin<T>, LongOperators<T>, LongOperatorsMixin<T>, HasExec, HasStream<T>
```
public class FutureOperationsImpl<T>
extends java.lang.Object
implements DoubleOperatorsMixin<T>, IntOperatorsMixin<T>, LongOperatorsMixin<T>, FutureOperations<T>
```

Constructor Summary

Constructors
Constructor and Description

FutureOperationsImpl()

Constructors
Constructor and Description
`FutureOperationsImpl()`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`java.util.concurrent.CompletableFuture<java.lang.Boolean>`	`allMatch(java.util.function.Predicate<? super T> predicate)` Perform an asynchronous All Match operation
`java.util.concurrent.CompletableFuture<java.lang.Boolean>`	`anyMatch(java.util.function.Predicate<? super T> predicate)` Perform an asynchronous Any Match operation
`java.util.concurrent.CompletableFuture<java.util.OptionalDouble>`	`averageDouble(java.util.function.ToDoubleFunction<? super T> fn)` Perform an asynchronous average operation
`java.util.concurrent.CompletableFuture<java.util.OptionalDouble>`	`averageInt(java.util.function.ToIntFunction<? super T> fn)` Perform an asynchronous average operation
`java.util.concurrent.CompletableFuture<java.util.OptionalDouble>`	`averageLong(java.util.function.ToLongFunction<? super T> fn)` Perform an asynchronous average operation
`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)`
`<R,A> java.util.concurrent.CompletableFuture<R>`	`collect(java.util.stream.Collector<? super T,A,R> collector)` Asynchronously perform a Stream collection
`<R> java.util.concurrent.CompletableFuture<R>`	`collect(java.util.function.Supplier<R> supplier, java.util.function.BiConsumer<R,? super T> accumulator, java.util.function.BiConsumer<R,R> combiner)` Asynchronously perform a Stream collection
`java.util.concurrent.CompletableFuture<java.lang.Long>`	`count()` Asynchronously perform a Stream 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>>`	`findAny()` Perform an asynchronous findAny operation
`java.util.concurrent.CompletableFuture<java.util.Optional<T>>`	`findFirst()` Perform an asynchronous findAny operation
`java.util.concurrent.CompletableFuture<T>`	`firstValue()` Perform an asynchronous findAny operation
`<U> java.util.concurrent.CompletableFuture<U>`	`foldLeft(U seed, java.util.function.BiFunction<U,? super T,U> function)` Perform an asynchronous foldLeft operation
`<U> java.util.concurrent.CompletableFuture<U>`	`foldRight(U seed, java.util.function.BiFunction<? super T,U,U> function)` Perform an asynchronous foldRight operation
`void`	`forEach(java.util.function.Consumer<T> c)`
`<X extends java.lang.Throwable> ReactiveTask`	`forEachEvent(java.util.function.Consumer<? super T> consumerElement, java.util.function.Consumer<? super java.lang.Throwable> consumerError, java.lang.Runnable onComplete)` Perform a forEach operation over the Stream capturing any elements and errors in the supplied consumers when the entire Stream has been processed an onComplete event will be recieved.
`<X extends java.lang.Throwable> ReactiveTask`	`forEachWithError(java.util.function.Consumer<? super T> consumerElement, java.util.function.Consumer<? super java.lang.Throwable> consumerError)` Perform a forEach operation over the Stream capturing any elements and errors in the supplied consumers,
`<X extends java.lang.Throwable> ReactiveTask`	`forEachX(long numberOfElements, java.util.function.Consumer<? super T> consumer)` Perform a forEach operation over the Stream, without closing it, consuming only the specified number of elements from the Stream, at this time.
`<X extends java.lang.Throwable> ReactiveTask`	`forEachXEvents(long numberOfElements, java.util.function.Consumer<? super T> consumer, java.util.function.Consumer<? super java.lang.Throwable> consumerError, java.lang.Runnable onComplete)` Perform a forEach operation over the Stream without closing it, capturing any elements and errors in the supplied consumers, but only consuming the specified number of elements from the Stream, at this time.
`<X extends java.lang.Throwable> ReactiveTask`	`forEachXWithError(long numberOfElements, java.util.function.Consumer<? super T> consumer, java.util.function.Consumer<? super java.lang.Throwable> consumerError)` Perform a forEach operation over the Stream without closing it, capturing any elements and errors in the supplied consumers, but only consuming the specified number of elements from the Stream, at this time.
`<K> java.util.concurrent.CompletableFuture<java.util.Map<K,java.util.List<T>>>`	`groupBy(java.util.function.Function<? super T,? extends K> classifier)` Perform an asyncrhonous groupBy operation
`<K,A,D> java.util.concurrent.CompletableFuture<java.util.Map<K,D>>`	`groupBy(java.util.function.Function<? super T,? extends K> classifier, java.util.stream.Collector<? super T,A,D> downstream)` Perform an asyncrhonous groupBy operation
`<K,D,A,M extends java.util.Map<K,D>> java.util.concurrent.CompletableFuture<M>`	`groupBy(java.util.function.Function<? super T,? extends K> classifier, java.util.function.Supplier<M> mapFactory, java.util.stream.Collector<? super T,A,D> downstream)` Perform an asyncrhonous groupBy operation
`java.util.concurrent.CompletableFuture<java.lang.String>`	`join()` Perform an asynchronous join operation
`java.util.concurrent.CompletableFuture<java.lang.String>`	`join(java.lang.CharSequence sep)`
`java.util.concurrent.CompletableFuture<java.lang.String>`	`join(java.lang.CharSequence delimiter, java.lang.CharSequence prefix, java.lang.CharSequence suffix)` Perform an asynchronous join operation
`java.util.concurrent.CompletableFuture<T>`	`lastValue()`
`java.util.concurrent.CompletableFuture<java.util.Optional<T>>`	`max()`
`java.util.concurrent.CompletableFuture<java.util.Optional<T>>`	`max(java.util.Comparator<? super T> comparator)` Perform an asyncrhonous min operation
`<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)` Asynchronously capture the maximum value in this stream using the provided 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.OptionalDouble>`	`maxDouble(java.util.function.ToDoubleFunction<? super T> fn)` Perform an asynchronous max operation
`java.util.concurrent.CompletableFuture<java.util.OptionalInt>`	`maxInt(java.util.function.ToIntFunction<? super T> fn)` Perform an asynchronous max operation
`java.util.concurrent.CompletableFuture<java.util.OptionalLong>`	`maxLong(java.util.function.ToLongFunction<? super T> fn)` Perform an asynchronous max operation
`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)` Perform an asyncrhonous min operation
`<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)` Asynchronously capture the minimum value in this stream using the provided 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.OptionalDouble>`	`minDouble(java.util.function.ToDoubleFunction<? super T> fn)` Perform an asynchronous min operation
`java.util.concurrent.CompletableFuture<java.util.OptionalInt>`	`minInt(java.util.function.ToIntFunction<? super T> fn)` Perform an asynchronous min operation
`java.util.concurrent.CompletableFuture<java.util.OptionalLong>`	`minLong(java.util.function.ToLongFunction<? super T> fn)` Perform an asynchronous min operation
`java.util.concurrent.CompletableFuture<java.util.Optional<T>>`	`mode()`
`java.util.concurrent.CompletableFuture<java.lang.Boolean>`	`noneMatch(java.util.function.Predicate<? super T> predicate)` Perform an asynchronous Any Match operation
`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>>`	`reduce(java.util.function.BinaryOperator<T> accumulator)` Asynchronously perform a Stream reduction
`java.util.concurrent.CompletableFuture<T>`	`reduce(T identity, java.util.function.BinaryOperator<T> accumulator)` Asynchronously perform a Stream reduction
`<U> java.util.concurrent.CompletableFuture<U>`	`reduce(U identity, java.util.function.BiFunction<U,? super T,U> accumulator, java.util.function.BinaryOperator<U> combiner)` Asynchronously perform a Stream reduction
`java.util.concurrent.CompletableFuture<T>`	`single()`
`java.util.concurrent.CompletableFuture<T>`	`single(java.util.function.Predicate<T> predicate)`
`java.util.concurrent.CompletableFuture<java.util.Optional<T>>`	`singleOptional()`
`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> fn)` Perform an asynchronous sum operation
`java.util.concurrent.CompletableFuture<java.lang.Integer>`	`sumInt(java.util.function.ToIntFunction<? super T> fn)` Perform an asynchronous sum operation
`java.util.concurrent.CompletableFuture<java.lang.Long>`	`sumLong(java.util.function.ToLongFunction<? super T> fn)` Perform an asynchronous sum operation
`java.util.concurrent.CompletableFuture<java.util.DoubleSummaryStatistics>`	`summaryStatisticsDouble(java.util.function.ToDoubleFunction<? super T> fn)` Perform an asynchronous summaryStatistics operation
`java.util.concurrent.CompletableFuture<java.util.IntSummaryStatistics>`	`summaryStatisticsInt(java.util.function.ToIntFunction<? super T> fn)` Perform an asynchronous summaryStatistics operation
`java.util.concurrent.CompletableFuture<java.util.LongSummaryStatistics>`	`summaryStatisticsLong(java.util.function.ToLongFunction<? super T> fn)` Perform an asynchronous summaryStatistics operation
`java.util.concurrent.CompletableFuture<java.lang.Object[]>`	`toArray()` Asyncrhonously generate an Array
`<A> java.util.concurrent.CompletableFuture<A[]>`	`toArray(java.util.function.IntFunction<A[]> generator)` Asyncrhonously generate an Array
`<C extends java.util.Collection<T>> java.util.concurrent.CompletableFuture<C>`	`toCollection(java.util.function.Supplier<C> collectionFactory)` Asynchronously perform a Stream collection
`java.util.concurrent.CompletableFuture<java.util.List<T>>`	`toList()` Asynchronously convert this Stream into a List
`<L extends java.util.List<T>> java.util.concurrent.CompletableFuture<L>`	`toList(java.util.function.Supplier<L> factory)`
`<K,V> java.util.concurrent.CompletableFuture<java.util.Map<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()` Asynchronously convert this Stream into a List
`<S extends java.util.Set<T>> java.util.concurrent.CompletableFuture<S>`	`toSet(java.util.function.Supplier<S> factory)`

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface com.aol.cyclops.streams.HasStream
getStream

Methods inherited from interface com.aol.cyclops.streams.HasExec
getExec

Methods inherited from interface com.aol.cyclops.streams.future.FutureCollectable
collect, collect, collect, collect, collect, collect, collect

- Constructor Detail
 - FutureOperationsImpl
```
public FutureOperationsImpl()
```
- Method Detail
 - toList
```
public java.util.concurrent.CompletableFuture<java.util.List<T>> toList()
```
 Asynchronously convert this Stream into a List
```
 
 CompletableFuture<List<Data>> myList = EagerFutureStream.of(1,2,3,4)
 														.map(this::loadFromDb)
 														.withTaskExecutor(parallelBuilder().getExecutor())
 														.map(this::processOnDifferentExecutor)
 														.toList();
 
 
```
 Specified by:
 
 toList in interface FutureOperations<T>
 
 Specified by:
 
 toList in interface FutureCollectable<T>
 
 Returns:
 
 Future List
 - lastValue
```
public java.util.concurrent.CompletableFuture<T> lastValue()
```
 Specified by:
 
 lastValue in interface FutureOperations<T>
 
 Returns:
 
 Last value in this Stream (must be non-empty)
 - single
```
public java.util.concurrent.CompletableFuture<T> single()
```
 Specified by:
 
 single in interface FutureOperations<T>
 
 Returns:
 
 the only entry in this Stream if it is a single entry Stream, otherwise throws an UnsupportedOperationException
 - toSet
```
public java.util.concurrent.CompletableFuture<java.util.Set<T>> toSet()
```
 Asynchronously convert this Stream into a List
```
 
 CompletableFuture<Set<Data>> myList = LazyFutureStream.of(1,2,3,4)
 														.map(this::loadFromDb)
 														.withTaskExecutor(parallelBuilder().getExecutor())
 														.map(this::processOnDifferentExecutor)
 														.toSet();
 
 
```
 Specified by:
 
 toSet in interface FutureOperations<T>
 
 Specified by:
 
 toSet in interface FutureCollectable<T>
 
 Returns:
 
 Future Set
 - minBy
```
public > java.util.concurrent.CompletableFuture<java.util.Optional<T>> minBy(java.util.function.Function<? super T,? extends U> function)
```
 Asynchronously capture the minimum value in this stream using the provided function
 
 Specified by:
 
 minBy in interface FutureOperations<T>
 
 Specified by:
 
 minBy in interface FutureCollectable<T>
 
 See Also:
 
 Collectable.minBy(Function)
 - maxBy
```
public > java.util.concurrent.CompletableFuture<java.util.Optional<T>> maxBy(java.util.function.Function<? super T,? extends U> function)
```
 Asynchronously capture the maximum value in this stream using the provided function
 
 Specified by:
 
 maxBy in interface FutureOperations<T>
 
 Specified by:
 
 maxBy in interface FutureCollectable<T>
 
 See Also:
 
 Collectable.maxBy(Function)
 - collect
```
public <R,A> java.util.concurrent.CompletableFuture<R> collect(java.util.stream.Collector<? super T,A,R> collector)
```
 Asynchronously perform a Stream collection
 
 Specified by:
 
 collect in interface FutureOperations<T>
 
 Specified by:
 
 collect in interface FutureCollectable<T>
 
 See Also:
 
 Stream.collect(Collector)
 - toCollection
```
public <C extends java.util.Collection<T>> java.util.concurrent.CompletableFuture<C> toCollection(java.util.function.Supplier<C> collectionFactory)
```
 Asynchronously perform a Stream collection
 
 Specified by:
 
 toCollection in interface FutureOperations<T>
 
 Specified by:
 
 toCollection in interface FutureCollectable<T>
 
 See Also:
 
 Collectable.toCollection(Supplier)
 - toArray
```
public <A> java.util.concurrent.CompletableFuture<A[]> toArray(java.util.function.IntFunction<A[]> generator)
```
 Asyncrhonously generate an Array
 
 Specified by:
 
 toArray in interface FutureOperations<T>
 
 See Also:
 
 Stream.toArray(IntFunction)
 - toArray
```
public java.util.concurrent.CompletableFuture<java.lang.Object[]> toArray()
```
 Asyncrhonously generate an Array
 
 Specified by:
 
 toArray in interface FutureOperations<T>
 
 See Also:
 
 Stream.toArray(IntFunction)
 - groupBy
```
public <K> java.util.concurrent.CompletableFuture<java.util.Map<K,java.util.List<T>>> groupBy(java.util.function.Function<? super T,? extends K> classifier)
```
 Perform an asyncrhonous groupBy operation
 
 Specified by:
 
 groupBy in interface FutureOperations<T>
 
 See Also:
 
 Seq.groupBy(Function)
 - groupBy
```
public <K,A,D> java.util.concurrent.CompletableFuture<java.util.Map<K,D>> groupBy(java.util.function.Function<? super T,? extends K> classifier,
 java.util.stream.Collector<? super T,A,D> downstream)
```
 Perform an asyncrhonous groupBy operation
 
 Specified by:
 
 groupBy in interface FutureOperations<T>
 
 See Also:
 
 Seq.groupBy(Function, Collector)
 - groupBy
```
public <K,D,A,M extends java.util.Map<K,D>> java.util.concurrent.CompletableFuture<M> groupBy(java.util.function.Function<? super T,? extends K> classifier,
 java.util.function.Supplier<M> mapFactory,
 java.util.stream.Collector<? super T,A,D> downstream)
```
 Perform an asyncrhonous groupBy operation
 
 Specified by:
 
 groupBy in interface FutureOperations<T>
 
 See Also:
 
 Seq.groupBy(Function, Supplier, Collector)
 - foldLeft
```
public  java.util.concurrent.CompletableFuture foldLeft(U seed,
 java.util.function.BiFunction<U,? super T,U> function)
```
 Perform an asynchronous foldLeft operation
 
 Specified by:
 
 foldLeft in interface FutureOperations<T>
 
 See Also:
 
 Seq.foldLeft(Object,BiFunction)
 - foldRight
```
public  java.util.concurrent.CompletableFuture foldRight(U seed,
 java.util.function.BiFunction<? super T,U,U> function)
```
 Perform an asynchronous foldRight operation
 
 Specified by:
 
 foldRight in interface FutureOperations<T>
 
 See Also:
 
 Seq.foldRight(Object,BiFunction)
 - min
```
public java.util.concurrent.CompletableFuture<java.util.Optional<T>> min(java.util.Comparator<? super T> comparator)
```
 Perform an asyncrhonous min operation
 
 Specified by:
 
 min in interface FutureOperations<T>
 
 Specified by:
 
 min in interface FutureCollectable<T>
 
 See Also:
 
 Stream.min(Comparator)
 - max
```
public java.util.concurrent.CompletableFuture<java.util.Optional<T>> max(java.util.Comparator<? super T> comparator)
```
 Perform an asyncrhonous min operation
 
 Specified by:
 
 max in interface FutureOperations<T>
 
 Specified by:
 
 max in interface FutureCollectable<T>
 
 See Also:
 
 Stream.max(Comparator)
 - collect
```
public <R> java.util.concurrent.CompletableFuture<R> collect(java.util.function.Supplier<R> supplier,
 java.util.function.BiConsumer<R,? super T> accumulator,
 java.util.function.BiConsumer<R,R> combiner)
```
 Asynchronously perform a Stream collection
 
 Specified by:
 
 collect in interface FutureOperations<T>
 
 See Also:
 
 Stream.collect(Supplier, BiConsumer, BiConsumer)
 - reduce
```
public  java.util.concurrent.CompletableFuture reduce(U identity,
 java.util.function.BiFunction<U,? super T,U> accumulator,
 java.util.function.BinaryOperator combiner)
```
 Asynchronously perform a Stream reduction
 
 Specified by:
 
 reduce in interface FutureOperations<T>
 
 See Also:
 
 Stream.reduce(Object, BiFunction, BinaryOperator)
 - reduce
```
public java.util.concurrent.CompletableFuture<java.util.Optional<T>> reduce(java.util.function.BinaryOperator<T> accumulator)
```
 Asynchronously perform a Stream reduction
 
 Specified by:
 
 reduce in interface FutureOperations<T>
 
 See Also:
 
 Stream.reduce(BinaryOperator)
 - reduce
```
public java.util.concurrent.CompletableFuture<T> reduce(T identity,
 java.util.function.BinaryOperator<T> accumulator)
```
 Asynchronously perform a Stream reduction
 
 Specified by:
 
 reduce in interface FutureOperations<T>
 
 See Also:
 
 Stream.reduce(Object, BinaryOperator)
 - count
```
public java.util.concurrent.CompletableFuture<java.lang.Long> count()
```
 Asynchronously perform a Stream count
 
 Specified by:
 
 count in interface FutureOperations<T>
 
 Specified by:
 
 count in interface FutureCollectable<T>
 
 See Also:
 
 Stream.count()
 - join
```
public java.util.concurrent.CompletableFuture<java.lang.String> join(java.lang.CharSequence sep)
```
 Specified by:
 
 join in interface FutureOperations<T>
 - join
```
public java.util.concurrent.CompletableFuture<java.lang.String> join()
```
 Perform an asynchronous join operation
 
 Specified by:
 
 join in interface FutureOperations<T>
 
 See Also:
 
 Seq.join()
 - join
```
public java.util.concurrent.CompletableFuture<java.lang.String> join(java.lang.CharSequence delimiter,
 java.lang.CharSequence prefix,
 java.lang.CharSequence suffix)
```
 Perform an asynchronous join operation
 
 Specified by:
 
 join in interface FutureOperations<T>
 
 See Also:
 
 Seq.join(CharSequence)
 - findAny
```
public java.util.concurrent.CompletableFuture<java.util.Optional<T>> findAny()
```
 Perform an asynchronous findAny operation
 
 Specified by:
 
 findAny in interface FutureOperations<T>
 
 See Also:
 
 Stream.findAny()
 - findFirst
```
public java.util.concurrent.CompletableFuture<java.util.Optional<T>> findFirst()
```
 Perform an asynchronous findAny operation
 
 Specified by:
 
 findFirst in interface FutureOperations<T>
 
 See Also:
 
 Stream.findFirst()
 - firstValue
```
public java.util.concurrent.CompletableFuture<T> firstValue()
```
 Perform an asynchronous findAny operation
 
 Specified by:
 
 firstValue in interface FutureOperations<T>
 
 See Also:
 
 Stream.findFirst()
 - allMatch
```
public java.util.concurrent.CompletableFuture<java.lang.Boolean> allMatch(java.util.function.Predicate<? super T> predicate)
```
 Perform an asynchronous All Match operation
 
 Specified by:
 
 allMatch in interface FutureOperations<T>
 
 Specified by:
 
 allMatch in interface FutureCollectable<T>
 
 See Also:
 
 Stream.allMatch(Predicate)
 - anyMatch
```
public java.util.concurrent.CompletableFuture<java.lang.Boolean> anyMatch(java.util.function.Predicate<? super T> predicate)
```
 Perform an asynchronous Any Match operation
 
 Specified by:
 
 anyMatch in interface FutureOperations<T>
 
 Specified by:
 
 anyMatch in interface FutureCollectable<T>
 
 See Also:
 
 Stream.anyMatch(Predicate)
 - noneMatch
```
public java.util.concurrent.CompletableFuture<java.lang.Boolean> noneMatch(java.util.function.Predicate<? super T> predicate)
```
 Perform an asynchronous Any Match operation
 
 Specified by:
 
 noneMatch in interface FutureOperations<T>
 
 Specified by:
 
 noneMatch in interface FutureCollectable<T>
 
 See Also:
 
 Stream.noneMatch(Predicate)
 - forEach
```
public void forEach(java.util.function.Consumer<T> c)
```
 Specified by:
 
 forEach in interface FutureOperations<T>
 - forEachX
```
public <X extends java.lang.Throwable> ReactiveTask forEachX(long numberOfElements,
 java.util.function.Consumer<? super T> consumer)
```
 Description copied from interface: ReactiveStreamsTerminalFutureOperations
 Perform a forEach operation over the Stream, without closing it, consuming only the specified number of elements from the Stream, at this time. More elements can be consumed later, by called request on the returned Subscription
 Specified by:
 
 forEachX in interface ReactiveStreamsTerminalFutureOperations<T>
 
 Parameters:
 
 numberOfElements - To consume from the Stream at this time
 
 consumer - To accept incoming events from the Stream
 
 Returns:
 
 ReactiveTask so that further processing can be continued or cancelled.
 - forEachXWithError
```
public <X extends java.lang.Throwable> ReactiveTask forEachXWithError(long numberOfElements,
 java.util.function.Consumer<? super T> consumer,
 java.util.function.Consumer<? super java.lang.Throwable> consumerError)
```
 Description copied from interface: ReactiveStreamsTerminalFutureOperations
 Perform a forEach operation over the Stream without closing it, capturing any elements and errors in the supplied consumers, but only consuming the specified number of elements from the Stream, at this time. More elements can be consumed later, by called request on the returned Subscription
 Specified by:
 
 forEachXWithError in interface ReactiveStreamsTerminalFutureOperations<T>
 
 Parameters:
 
 numberOfElements - To consume from the Stream at this time
 
 consumer - To accept incoming elements from the Stream
 
 consumerError - To accept incoming processing errors from the Stream
 
 Returns:
 
 ReactiveTask so that further processing can be continued or cancelled.
 - forEachXEvents
```
public <X extends java.lang.Throwable> ReactiveTask forEachXEvents(long numberOfElements,
 java.util.function.Consumer<? super T> consumer,
 java.util.function.Consumer<? super java.lang.Throwable> consumerError,
 java.lang.Runnable onComplete)
```
 Description copied from interface: ReactiveStreamsTerminalFutureOperations
 Perform a forEach operation over the Stream without closing it, capturing any elements and errors in the supplied consumers, but only consuming the specified number of elements from the Stream, at this time. More elements can be consumed later, by called request on the returned Subscription, when the entire Stream has been processed an onComplete event will be recieved.
 Specified by:
 
 forEachXEvents in interface ReactiveStreamsTerminalFutureOperations<T>
 
 Parameters:
 
 numberOfElements - To consume from the Stream at this time
 
 consumer - To accept incoming elements from the Stream
 
 consumerError - To accept incoming processing errors from the Stream
 
 onComplete - To run after an onComplete event
 
 Returns:
 
 ReactiveTask so that further processing can be continued or cancelled.
 - forEachWithError
```
public <X extends java.lang.Throwable> ReactiveTask forEachWithError(java.util.function.Consumer<? super T> consumerElement,
 java.util.function.Consumer<? super java.lang.Throwable> consumerError)
```
 Description copied from interface: ReactiveStreamsTerminalFutureOperations
 Perform a forEach operation over the Stream capturing any elements and errors in the supplied consumers,
 Specified by:
 
 forEachWithError in interface ReactiveStreamsTerminalFutureOperations<T>
 
 consumerError - To accept incoming processing errors from the Stream
 
 Returns:
 
 ReactiveTask so that further processing can be continued or cancelled.
 - forEachEvent
```
public <X extends java.lang.Throwable> ReactiveTask forEachEvent(java.util.function.Consumer<? super T> consumerElement,
 java.util.function.Consumer<? super java.lang.Throwable> consumerError,
 java.lang.Runnable onComplete)
```
 Description copied from interface: ReactiveStreamsTerminalFutureOperations
 Perform a forEach operation over the Stream capturing any elements and errors in the supplied consumers when the entire Stream has been processed an onComplete event will be recieved.
 Specified by:
 
 forEachEvent in interface ReactiveStreamsTerminalFutureOperations<T>
 
 consumerError - To accept incoming processing errors from the Stream
 
 onComplete - To run after an onComplete event
 
 Returns:
 
 ReactiveTask so that further processing can be continued or cancelled.
 - single
```
public java.util.concurrent.CompletableFuture<T> single(java.util.function.Predicate<T> predicate)
```
 Specified by:
 
 single in interface FutureOperations<T>
 
 Returns:
 
 the only entry in this Stream if it is a single entry Stream, otherwise throws an UnsupportedOperationException
 - singleOptional
```
public java.util.concurrent.CompletableFuture<java.util.Optional<T>> singleOptional()
```
 Specified by:
 
 singleOptional in interface FutureOperations<T>
 
 Returns:
 
 the only entry in this Stream if it is a single entry Stream, otherwise throws an UnsupportedOperationException
 - countDistinct
```
public java.util.concurrent.CompletableFuture<java.lang.Long> countDistinct()
```
 Specified by:
 
 countDistinct in interface FutureCollectable<T>
 - countDistinctBy
```
public  java.util.concurrent.CompletableFuture<java.lang.Long> countDistinctBy(java.util.function.Function<? super T,? extends U> function)
```
 Specified by:
 
 countDistinctBy in interface FutureCollectable<T>
 - mode
```
public java.util.concurrent.CompletableFuture<java.util.Optional<T>> mode()
```
 Specified by:
 
 mode in interface FutureCollectable<T>
 - sum
```
public java.util.concurrent.CompletableFuture<java.util.Optional<T>> sum()
```
 Specified by:
 
 sum in interface FutureCollectable<T>
 - sum
```
public  java.util.concurrent.CompletableFuture<java.util.Optional> sum(java.util.function.Function<? super T,? extends U> function)
```
 Specified by:
 
 sum in interface FutureCollectable<T>
 - avg
```
public java.util.concurrent.CompletableFuture<java.util.Optional<T>> avg()
```
 Specified by:
 
 avg in interface FutureCollectable<T>
 - avg
```
public  java.util.concurrent.CompletableFuture<java.util.Optional> avg(java.util.function.Function<? super T,? extends U> function)
```
 Specified by:
 
 avg in interface FutureCollectable<T>
 - min
```
public java.util.concurrent.CompletableFuture<java.util.Optional<T>> min()
```
 Specified by:
 
 min in interface FutureCollectable<T>
 - min
```
public > java.util.concurrent.CompletableFuture<java.util.Optional> min(java.util.function.Function<? super T,? extends U> function)
```
 Specified by:
 
 min in interface FutureCollectable<T>
 - min
```
public  java.util.concurrent.CompletableFuture<java.util.Optional> min(java.util.function.Function<? super T,? extends U> function,
 java.util.Comparator<? super U> comparator)
```
 Specified by:
 
 min in interface FutureCollectable<T>
 - minBy
```
public  java.util.concurrent.CompletableFuture<java.util.Optional<T>> minBy(java.util.function.Function<? super T,? extends U> function,
 java.util.Comparator<? super U> comparator)
```
 Specified by:
 
 minBy in interface FutureCollectable<T>
 - max
```
public java.util.concurrent.CompletableFuture<java.util.Optional<T>> max()
```
 Specified by:
 
 max in interface FutureCollectable<T>
 - max
```
public > java.util.concurrent.CompletableFuture<java.util.Optional> max(java.util.function.Function<? super T,? extends U> function)
```
 Specified by:
 
 max in interface FutureCollectable<T>
 - max
```
public  java.util.concurrent.CompletableFuture<java.util.Optional> max(java.util.function.Function<? super T,? extends U> function,
 java.util.Comparator<? super U> comparator)
```
 Specified by:
 
 max in interface FutureCollectable<T>
 - maxBy
```
public  java.util.concurrent.CompletableFuture<java.util.Optional<T>> maxBy(java.util.function.Function<? super T,? extends U> function,
 java.util.Comparator<? super U> comparator)
```
 Specified by:
 
 maxBy in interface FutureCollectable<T>
 - median
```
public java.util.concurrent.CompletableFuture<java.util.Optional<T>> median()
```
 Specified by:
 
 median in interface FutureCollectable<T>
 - median
```
public java.util.concurrent.CompletableFuture<java.util.Optional<T>> median(java.util.Comparator<? super T> comparator)
```
 Specified by:
 
 median in interface FutureCollectable<T>
 - medianBy
```
public > java.util.concurrent.CompletableFuture<java.util.Optional<T>> medianBy(java.util.function.Function<? super T,? extends U> function)
```
 Specified by:
 
 medianBy in interface FutureCollectable<T>
 - medianBy
```
public  java.util.concurrent.CompletableFuture<java.util.Optional<T>> medianBy(java.util.function.Function<? super T,? extends U> function,
 java.util.Comparator<? super U> comparator)
```
 Specified by:
 
 medianBy in interface FutureCollectable<T>
 - percentile
```
public java.util.concurrent.CompletableFuture<java.util.Optional<T>> percentile(double percentile)
```
 Specified by:
 
 percentile in interface FutureCollectable<T>
 - percentile
```
public java.util.concurrent.CompletableFuture<java.util.Optional<T>> percentile(double percentile,
 java.util.Comparator<? super T> comparator)
```
 Specified by:
 
 percentile in interface FutureCollectable<T>
 - percentileBy
```
public > java.util.concurrent.CompletableFuture<java.util.Optional<T>> percentileBy(double percentile,
 java.util.function.Function<? super T,? extends U> function)
```
 Specified by:
 
 percentileBy in interface FutureCollectable<T>
 - percentileBy
```
public  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)
```
 Specified by:
 
 percentileBy in interface FutureCollectable<T>
 - toList
```
public <L extends java.util.List<T>> java.util.concurrent.CompletableFuture<L> toList(java.util.function.Supplier<L> factory)
```
 Specified by:
 
 toList in interface FutureCollectable<T>
 - toSet
```
public <S extends java.util.Set<T>> java.util.concurrent.CompletableFuture<S> toSet(java.util.function.Supplier<S> factory)
```
 Specified by:
 
 toSet in interface FutureCollectable<T>
 - toMap
```
public <K,V> java.util.concurrent.CompletableFuture<java.util.Map<K,V>> toMap(java.util.function.Function<? super T,? extends K> keyMapper,
 java.util.function.Function<? super T,? extends V> valueMapper)
```
 Specified by:
 
 toMap in interface FutureCollectable<T>
 - sumDouble
```
public java.util.concurrent.CompletableFuture<java.lang.Double> sumDouble(java.util.function.ToDoubleFunction<? super T> fn)
```
 Description copied from interface: DoubleOperatorsMixin
 
 Perform an asynchronous sum operation
 
 Specified by:
 
 sumDouble in interface DoubleOperators<T>
 
 Specified by:
 
 sumDouble in interface DoubleOperatorsMixin<T>
 
 Specified by:
 
 sumDouble in interface FutureCollectable<T>
 
 See Also:
 
 Stream.mapToDouble(ToDoubleFunction), DoubleStream.sum()
 - sumLong
```
public java.util.concurrent.CompletableFuture<java.lang.Long> sumLong(java.util.function.ToLongFunction<? super T> fn)
```
 Description copied from interface: LongOperatorsMixin
 
 Perform an asynchronous sum operation
 
 Specified by:
 
 sumLong in interface FutureCollectable<T>
 
 Specified by:
 
 sumLong in interface LongOperators<T>
 
 Specified by:
 
 sumLong in interface LongOperatorsMixin<T>
 
 See Also:
 
 Stream.mapToLong(ToLongFunction), LongStream.sum()
 - maxLong
```
public java.util.concurrent.CompletableFuture<java.util.OptionalLong> maxLong(java.util.function.ToLongFunction<? super T> fn)
```
 Description copied from interface: LongOperatorsMixin
 
 Perform an asynchronous max operation
 
 Specified by:
 
 maxLong in interface LongOperators<T>
 
 Specified by:
 
 maxLong in interface LongOperatorsMixin<T>
 
 See Also:
 
 Stream.mapToLong(ToLongFunction), LongStream.max()
 - minLong
```
public java.util.concurrent.CompletableFuture<java.util.OptionalLong> minLong(java.util.function.ToLongFunction<? super T> fn)
```
 Description copied from interface: LongOperatorsMixin
 
 Perform an asynchronous min operation
 
 Specified by:
 
 minLong in interface LongOperators<T>
 
 Specified by:
 
 minLong in interface LongOperatorsMixin<T>
 
 See Also:
 
 Stream.mapToLong(ToLongFunction), LongStream.min()
 - averageLong
```
public java.util.concurrent.CompletableFuture<java.util.OptionalDouble> averageLong(java.util.function.ToLongFunction<? super T> fn)
```
 Description copied from interface: LongOperatorsMixin
 
 Perform an asynchronous average operation
 
 Specified by:
 
 averageLong in interface LongOperators<T>
 
 Specified by:
 
 averageLong in interface LongOperatorsMixin<T>
 
 See Also:
 
 Stream.mapToLong(ToLongFunction), LongStream.average()
 - summaryStatisticsLong
```
public java.util.concurrent.CompletableFuture<java.util.LongSummaryStatistics> summaryStatisticsLong(java.util.function.ToLongFunction<? super T> fn)
```
 Description copied from interface: LongOperatorsMixin
 
 Perform an asynchronous summaryStatistics operation
 
 Specified by:
 
 summaryStatisticsLong in interface LongOperators<T>
 
 Specified by:
 
 summaryStatisticsLong in interface LongOperatorsMixin<T>
 
 See Also:
 
 Stream.mapToLong(ToLongFunction), LongStream.summaryStatistics()
 - sumInt
```
public java.util.concurrent.CompletableFuture<java.lang.Integer> sumInt(java.util.function.ToIntFunction<? super T> fn)
```
 Description copied from interface: IntOperatorsMixin
 
 Perform an asynchronous sum operation
 
 Specified by:
 
 sumInt in interface FutureCollectable<T>
 
 Specified by:
 
 sumInt in interface IntOperators<T>
 
 Specified by:
 
 sumInt in interface IntOperatorsMixin<T>
 
 See Also:
 
 Stream.mapToInt(ToIntFunction), IntStream.sum()
 - maxInt
```
public java.util.concurrent.CompletableFuture<java.util.OptionalInt> maxInt(java.util.function.ToIntFunction<? super T> fn)
```
 Description copied from interface: IntOperatorsMixin
 
 Perform an asynchronous max operation
 
 Specified by:
 
 maxInt in interface IntOperators<T>
 
 Specified by:
 
 maxInt in interface IntOperatorsMixin<T>
 
 See Also:
 
 Stream.mapToInt(ToIntFunction), IntStream.max()
 - minInt
```
public java.util.concurrent.CompletableFuture<java.util.OptionalInt> minInt(java.util.function.ToIntFunction<? super T> fn)
```
 Description copied from interface: IntOperatorsMixin
 
 Perform an asynchronous min operation
 
 Specified by:
 
 minInt in interface IntOperators<T>
 
 Specified by:
 
 minInt in interface IntOperatorsMixin<T>
 
 See Also:
 
 Stream.mapToInt(ToIntFunction), IntStream.min()
 - averageInt
```
public java.util.concurrent.CompletableFuture<java.util.OptionalDouble> averageInt(java.util.function.ToIntFunction<? super T> fn)
```
 Description copied from interface: IntOperatorsMixin
 
 Perform an asynchronous average operation
 
 Specified by:
 
 averageInt in interface IntOperators<T>
 
 Specified by:
 
 averageInt in interface IntOperatorsMixin<T>
 
 See Also:
 
 Stream.mapToInt(ToIntFunction), IntStream.average()
 - summaryStatisticsInt
```
public java.util.concurrent.CompletableFuture<java.util.IntSummaryStatistics> summaryStatisticsInt(java.util.function.ToIntFunction<? super T> fn)
```
 Description copied from interface: IntOperatorsMixin
 
 Perform an asynchronous summaryStatistics operation
 
 Specified by:
 
 summaryStatisticsInt in interface IntOperators<T>
 
 Specified by:
 
 summaryStatisticsInt in interface IntOperatorsMixin<T>
 
 See Also:
 
 Stream.mapToInt(ToIntFunction), IntStream.summaryStatistics()
 - maxDouble
```
public java.util.concurrent.CompletableFuture<java.util.OptionalDouble> maxDouble(java.util.function.ToDoubleFunction<? super T> fn)
```
 Description copied from interface: DoubleOperatorsMixin
 
 Perform an asynchronous max operation
 
 Specified by:
 
 maxDouble in interface DoubleOperators<T>
 
 Specified by:
 
 maxDouble in interface DoubleOperatorsMixin<T>
 
 See Also:
 
 Stream.mapToDouble(ToDoubleFunction), DoubleStream.max()
 - minDouble
```
public java.util.concurrent.CompletableFuture<java.util.OptionalDouble> minDouble(java.util.function.ToDoubleFunction<? super T> fn)
```
 Description copied from interface: DoubleOperatorsMixin
 
 Perform an asynchronous min operation
 
 Specified by:
 
 minDouble in interface DoubleOperators<T>
 
 Specified by:
 
 minDouble in interface DoubleOperatorsMixin<T>
 
 See Also:
 
 Stream.mapToDouble(ToDoubleFunction), DoubleStream.min()
 - averageDouble
```
public java.util.concurrent.CompletableFuture<java.util.OptionalDouble> averageDouble(java.util.function.ToDoubleFunction<? super T> fn)
```
 Description copied from interface: DoubleOperatorsMixin
 
 Perform an asynchronous average operation
 
 Specified by:
 
 averageDouble in interface DoubleOperators<T>
 
 Specified by:
 
 averageDouble in interface DoubleOperatorsMixin<T>
 
 See Also:
 
 Stream.mapToDouble(ToDoubleFunction), DoubleStream.average()
 - summaryStatisticsDouble
```
public java.util.concurrent.CompletableFuture<java.util.DoubleSummaryStatistics> summaryStatisticsDouble(java.util.function.ToDoubleFunction<? super T> fn)
```
 Description copied from interface: DoubleOperatorsMixin
 
 Perform an asynchronous summaryStatistics operation
 
 Specified by:
 
 summaryStatisticsDouble in interface DoubleOperators<T>
 
 Specified by:
 
 summaryStatisticsDouble in interface DoubleOperatorsMixin<T>
 
 See Also:
 
 Stream.mapToDouble(ToDoubleFunction), DoubleStream.summaryStatistics()

Class FutureOperationsImpl<T>

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface com.aol.cyclops.streams.HasStream

Methods inherited from interface com.aol.cyclops.streams.HasExec

Methods inherited from interface com.aol.cyclops.streams.future.FutureCollectable

Constructor Detail

FutureOperationsImpl

Method Detail

toList

lastValue

single

toSet

minBy

maxBy

collect

toCollection

toArray

toArray

groupBy

groupBy

groupBy

foldLeft

foldRight

min

max

collect

reduce

reduce

reduce

count

join

join

join

findAny

findFirst

firstValue

allMatch

anyMatch

noneMatch

forEach

forEachX

forEachXWithError

forEachXEvents

forEachWithError

forEachEvent

single

singleOptional

countDistinct

countDistinctBy

mode

sum

sum

avg

avg

min

min

min

minBy

max

max

max

maxBy

median

median

medianBy

medianBy

percentile

percentile

percentileBy

percentileBy

toList

toSet

toMap

sumDouble

sumLong

maxLong

minLong

averageLong