Flux (Reactor Core 3.2.0.RELEASE)

java.lang.Object
- reactor.core.publisher.Flux<T>

Type Parameters:

T - the element type of this Reactive Streams Publisher

All Implemented Interfaces:

Publisher<T>

Direct Known Subclasses:

ConnectableFlux, FluxOperator, FluxProcessor, GroupedFlux
```
public abstract class Flux<T>
extends Object
implements Publisher<T>
```
A Reactive Streams Publisher with rx operators that emits 0 to N elements, and then completes (successfully or with an error).
The recommended way to learn about the Flux API and discover new operators is through the reference documentation, rather than through this javadoc (as opposed to learning more about individual operators). See the "which operator do I need?" appendix.

It is intended to be used in implementations and return types. Input parameters should keep using raw Publisher as much as possible.
If it is known that the underlying Publisher will emit 0 or 1 element, Mono should be used instead.
Note that using state in the java.util.function / lambdas used within Flux operators should be avoided, as these may be shared between several Subscribers.
subscribe(CoreSubscriber) is an internal extension to subscribe(Subscriber) used internally for Context passing. User provided Subscriber may be passed to this "subscribe" extension but will loose the available per-subscribe @link Hooks#onLastOperator}.

Author:

Sebastien Deleuze, Stephane Maldini, David Karnok, Simon Baslé

See Also:

Mono

Constructor Summary

Constructors
Constructor and Description

Flux()

Constructors
Constructor and Description
`Flux()`

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`Mono<Boolean>`	`all(Predicate<? super T> predicate)` Emit a single boolean true if all values of this sequence match the `Predicate`.
`Mono<Boolean>`	`any(Predicate<? super T> predicate)` Emit a single boolean true if any of the values of this `Flux` sequence match the predicate.
`<P> P`	`as(Function<? super Flux<T>,P> transformer)` Transform this `Flux` into a target type.
`T`	`blockFirst()` Subscribe to this `Flux` and block indefinitely until the upstream signals its first value or completes.
`T`	`blockFirst(Duration timeout)` Subscribe to this `Flux` and block until the upstream signals its first value, completes or a timeout expires.
`T`	`blockLast()` Subscribe to this `Flux` and block indefinitely until the upstream signals its last value or completes.
`T`	`blockLast(Duration timeout)` Subscribe to this `Flux` and block until the upstream signals its last value, completes or a timeout expires.
`Flux<List<T>>`	`buffer()` Collect all incoming values into a single `List` buffer that will be emitted by the returned `Flux` once this Flux completes.
`Flux<List<T>>`	`buffer(Duration bufferingTimespan)` Collect incoming values into multiple `List` buffers that will be emitted by the returned `Flux` every `bufferingTimespan`.
`Flux<List<T>>`	`buffer(Duration bufferingTimespan, Duration openBufferEvery)` Collect incoming values into multiple `List` buffers created at a given `openBufferEvery` period.
`Flux<List<T>>`	`buffer(Duration bufferingTimespan, Duration openBufferEvery, Scheduler timer)` Collect incoming values into multiple `List` buffers created at a given `openBufferEvery` period, as measured on the provided `Scheduler`.
`Flux<List<T>>`	`buffer(Duration bufferingTimespan, Scheduler timer)` Collect incoming values into multiple `List` buffers that will be emitted by the returned `Flux` every `bufferingTimespan`, as measured on the provided `Scheduler`.
`Flux<List<T>>`	`buffer(int maxSize)` Collect incoming values into multiple `List` buffers that will be emitted by the returned `Flux` each time the given max size is reached or once this Flux completes.
`Flux<List<T>>`	`buffer(int maxSize, int skip)` Collect incoming values into multiple `List` buffers that will be emitted by the returned `Flux` each time the given max size is reached or once this Flux completes.
`<C extends Collection<? super T>> Flux<C>`	`buffer(int maxSize, int skip, Supplier<C> bufferSupplier)` Collect incoming values into multiple user-defined `Collection` buffers that will be emitted by the returned `Flux` each time the given max size is reached or once this Flux completes.
`<C extends Collection<? super T>> Flux<C>`	`buffer(int maxSize, Supplier<C> bufferSupplier)` Collect incoming values into multiple user-defined `Collection` buffers that will be emitted by the returned `Flux` each time the given max size is reached or once this Flux completes.
`Flux<List<T>>`	`buffer(Publisher<?> other)` Collect incoming values into multiple `List` buffers, as delimited by the signals of a companion `Publisher` this operator will subscribe to.
`<C extends Collection<? super T>> Flux<C>`	`buffer(Publisher<?> other, Supplier<C> bufferSupplier)` Collect incoming values into multiple user-defined `Collection` buffers, as delimited by the signals of a companion `Publisher` this operator will subscribe to.
`Flux<List<T>>`	`bufferTimeout(int maxSize, Duration maxTime)` Collect incoming values into multiple `List` buffers that will be emitted by the returned `Flux` each time the buffer reaches a maximum size OR the maxTime `Duration` elapses.
`Flux<List<T>>`	`bufferTimeout(int maxSize, Duration maxTime, Scheduler timer)` Collect incoming values into multiple `List` buffers that will be emitted by the returned `Flux` each time the buffer reaches a maximum size OR the maxTime `Duration` elapses, as measured on the provided `Scheduler`.
`<C extends Collection<? super T>> Flux<C>`	`bufferTimeout(int maxSize, Duration maxTime, Scheduler timer, Supplier<C> bufferSupplier)` Collect incoming values into multiple user-defined `Collection` buffers that will be emitted by the returned `Flux` each time the buffer reaches a maximum size OR the maxTime `Duration` elapses, as measured on the provided `Scheduler`.
`<C extends Collection<? super T>> Flux<C>`	`bufferTimeout(int maxSize, Duration maxTime, Supplier<C> bufferSupplier)` Collect incoming values into multiple user-defined `Collection` buffers that will be emitted by the returned `Flux` each time the buffer reaches a maximum size OR the maxTime `Duration` elapses.
`Flux<List<T>>`	`bufferUntil(Predicate<? super T> predicate)` Collect incoming values into multiple `List` buffers that will be emitted by the resulting `Flux` each time the given predicate returns true.
`Flux<List<T>>`	`bufferUntil(Predicate<? super T> predicate, boolean cutBefore)` Collect incoming values into multiple `List` buffers that will be emitted by the resulting `Flux` each time the given predicate returns true.
`<U,V> Flux<List<T>>`	`bufferWhen(Publisher<U> bucketOpening, Function<? super U,? extends Publisher<V>> closeSelector)` Collect incoming values into multiple `List` buffers started each time an opening companion `Publisher` emits.
`<U,V,C extends Collection<? super T>> Flux<C>`	`bufferWhen(Publisher<U> bucketOpening, Function<? super U,? extends Publisher<V>> closeSelector, Supplier<C> bufferSupplier)` Collect incoming values into multiple user-defined `Collection` buffers started each time an opening companion `Publisher` emits.
`Flux<List<T>>`	`bufferWhile(Predicate<? super T> predicate)` Collect incoming values into multiple `List` buffers that will be emitted by the resulting `Flux`.
`Flux<T>`	`cache()` Turn this `Flux` into a hot source and cache last emitted signals for further `Subscriber`.
`Flux<T>`	`cache(Duration ttl)` Turn this `Flux` into a hot source and cache last emitted signals for further `Subscriber`.
`Flux<T>`	`cache(Duration ttl, Scheduler timer)` Turn this `Flux` into a hot source and cache last emitted signals for further `Subscriber`.
`Flux<T>`	`cache(int history)` Turn this `Flux` into a hot source and cache last emitted signals for further `Subscriber`.
`Flux<T>`	`cache(int history, Duration ttl)` Turn this `Flux` into a hot source and cache last emitted signals for further `Subscriber`.
`Flux<T>`	`cache(int history, Duration ttl, Scheduler timer)` Turn this `Flux` into a hot source and cache last emitted signals for further `Subscriber`.
`Flux<T>`	`cancelOn(Scheduler scheduler)` Prepare this `Flux` so that subscribers will cancel from it on a specified `Scheduler`.
`<E> Flux<E>`	`cast(Class<E> clazz)` Cast the current `Flux` produced type into a target produced type.
`Flux<T>`	`checkpoint()` Activate assembly tracing for this particular `Flux`, in case of an error upstream of the checkpoint.
`Flux<T>`	`checkpoint(String description)` Activate assembly marker for this particular `Flux` by giving it a description that will be reflected in the assembly traceback in case of an error upstream of the checkpoint.
`Flux<T>`	`checkpoint(String description, boolean forceStackTrace)` Activate assembly tracing or the lighter assembly marking depending on the `forceStackTrace` option.
`<R,A> Mono<R>`	`collect(Collector<? super T,A,? extends R> collector)` Collect all elements emitted by this `Flux` into a container, by applying a Java 8 Stream API `Collector` The collected result will be emitted when this sequence completes.
`<E> Mono<E>`	`collect(Supplier<E> containerSupplier, BiConsumer<E,? super T> collector)` Collect all elements emitted by this `Flux` into a user-defined container, by applying a collector `BiConsumer` taking the container and each element.
`Mono<List<T>>`	`collectList()` Collect all elements emitted by this `Flux` into a `List` that is emitted by the resulting `Mono` when this sequence completes.
`<K> Mono<Map<K,T>>`	`collectMap(Function<? super T,? extends K> keyExtractor)` Collect all elements emitted by this `Flux` into a hashed `Map` that is emitted by the resulting `Mono` when this sequence completes.
`<K,V> Mono<Map<K,V>>`	`collectMap(Function<? super T,? extends K> keyExtractor, Function<? super T,? extends V> valueExtractor)` Collect all elements emitted by this `Flux` into a hashed `Map` that is emitted by the resulting `Mono` when this sequence completes.
`<K,V> Mono<Map<K,V>>`	`collectMap(Function<? super T,? extends K> keyExtractor, Function<? super T,? extends V> valueExtractor, Supplier<Map<K,V>> mapSupplier)` Collect all elements emitted by this `Flux` into a user-defined `Map` that is emitted by the resulting `Mono` when this sequence completes.
`<K> Mono<Map<K,Collection<T>>>`	`collectMultimap(Function<? super T,? extends K> keyExtractor)` Collect all elements emitted by this `Flux` into a `multimap` that is emitted by the resulting `Mono` when this sequence completes.
`<K,V> Mono<Map<K,Collection<V>>>`	`collectMultimap(Function<? super T,? extends K> keyExtractor, Function<? super T,? extends V> valueExtractor)` Collect all elements emitted by this `Flux` into a `multimap` that is emitted by the resulting `Mono` when this sequence completes.
`<K,V> Mono<Map<K,Collection<V>>>`	`collectMultimap(Function<? super T,? extends K> keyExtractor, Function<? super T,? extends V> valueExtractor, Supplier<Map<K,Collection<V>>> mapSupplier)` Collect all elements emitted by this `Flux` into a user-defined `multimap` that is emitted by the resulting `Mono` when this sequence completes.
`Mono<List<T>>`	`collectSortedList()` Collect all elements emitted by this `Flux` until this sequence completes, and then sort them in natural order into a `List` that is emitted by the resulting `Mono`.
`Mono<List<T>>`	`collectSortedList(Comparator<? super T> comparator)` Collect all elements emitted by this `Flux` until this sequence completes, and then sort them using a `Comparator` into a `List` that is emitted by the resulting `Mono`.
`static <T,V> Flux<V>`	`combineLatest(Function<Object[],V> combinator, int prefetch, Publisher<? extends T>... sources)` Build a `Flux` whose data are generated by the combination of the most recently published value from each of the `Publisher` sources.
`static <T,V> Flux<V>`	`combineLatest(Function<Object[],V> combinator, Publisher<? extends T>... sources)` Build a `Flux` whose data are generated by the combination of the most recently published value from each of the `Publisher` sources.
`static <T,V> Flux<V>`	`combineLatest(Iterable<? extends Publisher<? extends T>> sources, Function<Object[],V> combinator)` Build a `Flux` whose data are generated by the combination of the most recently published value from each of the `Publisher` sources provided in an `Iterable`.
`static <T,V> Flux<V>`	`combineLatest(Iterable<? extends Publisher<? extends T>> sources, int prefetch, Function<Object[],V> combinator)` Build a `Flux` whose data are generated by the combination of the most recently published value from each of the `Publisher` sources provided in an `Iterable`.
`static <T1,T2,V> Flux<V>`	`combineLatest(Publisher<? extends T1> source1, Publisher<? extends T2> source2, BiFunction<? super T1,? super T2,? extends V> combinator)` Build a `Flux` whose data are generated by the combination of the most recently published value from each of two `Publisher` sources.
`static <T1,T2,T3,V> Flux<V>`	`combineLatest(Publisher<? extends T1> source1, Publisher<? extends T2> source2, Publisher<? extends T3> source3, Function<Object[],V> combinator)` Build a `Flux` whose data are generated by the combination of the most recently published value from each of three `Publisher` sources.
`static <T1,T2,T3,T4,V> Flux<V>`	`combineLatest(Publisher<? extends T1> source1, Publisher<? extends T2> source2, Publisher<? extends T3> source3, Publisher<? extends T4> source4, Function<Object[],V> combinator)` Build a `Flux` whose data are generated by the combination of the most recently published value from each of four `Publisher` sources.
`static <T1,T2,T3,T4,T5,V> Flux<V>`	`combineLatest(Publisher<? extends T1> source1, Publisher<? extends T2> source2, Publisher<? extends T3> source3, Publisher<? extends T4> source4, Publisher<? extends T5> source5, Function<Object[],V> combinator)` Build a `Flux` whose data are generated by the combination of the most recently published value from each of five `Publisher` sources.
`static <T1,T2,T3,T4,T5,T6,V> Flux<V>`	`combineLatest(Publisher<? extends T1> source1, Publisher<? extends T2> source2, Publisher<? extends T3> source3, Publisher<? extends T4> source4, Publisher<? extends T5> source5, Publisher<? extends T6> source6, Function<Object[],V> combinator)` Build a `Flux` whose data are generated by the combination of the most recently published value from each of six `Publisher` sources.
`<V> Flux<V>`	`compose(Function<? super Flux<T>,? extends Publisher<V>> transformer)` Defer the transformation of this `Flux` in order to generate a target `Flux` type.
`static <T> Flux<T>`	`concat(Iterable<? extends Publisher<? extends T>> sources)` Concatenate all sources provided in an `Iterable`, forwarding elements emitted by the sources downstream.
`static <T> Flux<T>`	`concat(Publisher<? extends Publisher<? extends T>> sources)` Concatenate all sources emitted as an onNext signal from a parent `Publisher`, forwarding elements emitted by the sources downstream.
`static <T> Flux<T>`	`concat(Publisher<? extends Publisher<? extends T>> sources, int prefetch)` Concatenate all sources emitted as an onNext signal from a parent `Publisher`, forwarding elements emitted by the sources downstream.
`static <T> Flux<T>`	`concat(Publisher<? extends T>... sources)` Concatenate all sources provided as a vararg, forwarding elements emitted by the sources downstream.
`static <T> Flux<T>`	`concatDelayError(Publisher<? extends Publisher<? extends T>> sources)` Concatenate all sources emitted as an onNext signal from a parent `Publisher`, forwarding elements emitted by the sources downstream.
`static <T> Flux<T>`	`concatDelayError(Publisher<? extends Publisher<? extends T>> sources, boolean delayUntilEnd, int prefetch)` Concatenate all sources emitted as an onNext signal from a parent `Publisher`, forwarding elements emitted by the sources downstream.
`static <T> Flux<T>`	`concatDelayError(Publisher<? extends Publisher<? extends T>> sources, int prefetch)` Concatenate all sources emitted as an onNext signal from a parent `Publisher`, forwarding elements emitted by the sources downstream.
`static <T> Flux<T>`	`concatDelayError(Publisher<? extends T>... sources)` Concatenate all sources provided as a vararg, forwarding elements emitted by the sources downstream.
`<V> Flux<V>`	`concatMap(Function<? super T,? extends Publisher<? extends V>> mapper)` Transform the elements emitted by this `Flux` asynchronously into Publishers, then flatten these inner publishers into a single `Flux`, sequentially and preserving order using concatenation.
`<V> Flux<V>`	`concatMap(Function<? super T,? extends Publisher<? extends V>> mapper, int prefetch)` Transform the elements emitted by this `Flux` asynchronously into Publishers, then flatten these inner publishers into a single `Flux`, sequentially and preserving order using concatenation.
`<V> Flux<V>`	`concatMapDelayError(Function<? super T,? extends Publisher<? extends V>> mapper)` Transform the elements emitted by this `Flux` asynchronously into Publishers, then flatten these inner publishers into a single `Flux`, sequentially and preserving order using concatenation.
`<V> Flux<V>`	`concatMapDelayError(Function<? super T,? extends Publisher<? extends V>> mapper, boolean delayUntilEnd, int prefetch)` Transform the elements emitted by this `Flux` asynchronously into Publishers, then flatten these inner publishers into a single `Flux`, sequentially and preserving order using concatenation.
`<V> Flux<V>`	`concatMapDelayError(Function<? super T,? extends Publisher<? extends V>> mapper, int prefetch)` Transform the elements emitted by this `Flux` asynchronously into Publishers, then flatten these inner publishers into a single `Flux`, sequentially and preserving order using concatenation.
`<R> Flux<R>`	`concatMapIterable(Function<? super T,? extends Iterable<? extends R>> mapper)` Transform the items emitted by this `Flux` into `Iterable`, then flatten the elements from those by concatenating them into a single `Flux`.
`<R> Flux<R>`	`concatMapIterable(Function<? super T,? extends Iterable<? extends R>> mapper, int prefetch)` Transform the items emitted by this `Flux` into `Iterable`, then flatten the emissions from those by concatenating them into a single `Flux`.
`Flux<T>`	`concatWith(Publisher<? extends T> other)` Concatenate emissions of this `Flux` with the provided `Publisher` (no interleave).
`Flux<T>`	`concatWithValues(T... values)` Concatenates the values to the end of the `Flux`
`Mono<Long>`	`count()` Counts the number of values in this `Flux`.
`static <T> Flux<T>`	`create(Consumer<? super FluxSink<T>> emitter)` Programmatically create a `Flux` with the capability of emitting multiple elements in a synchronous or asynchronous manner through the `FluxSink` API.
`static <T> Flux<T>`	`create(Consumer<? super FluxSink<T>> emitter, FluxSink.OverflowStrategy backpressure)` Programmatically create a `Flux` with the capability of emitting multiple elements in a synchronous or asynchronous manner through the `FluxSink` API.
`Flux<T>`	`defaultIfEmpty(T defaultV)` Provide a default unique value if this sequence is completed without any data
`static <T> Flux<T>`	`defer(Supplier<? extends Publisher<T>> supplier)` Lazily supply a `Publisher` every time a `Subscription` is made on the resulting `Flux`, so the actual source instantiation is deferred until each subscribe and the `Supplier` can create a subscriber-specific instance.
`Flux<T>`	`delayElements(Duration delay)` Delay each of this `Flux` elements (`Subscriber.onNext(T)` signals) by a given `Duration`.
`Flux<T>`	`delayElements(Duration delay, Scheduler timer)` Delay each of this `Flux` elements (`Subscriber.onNext(T)` signals) by a given `Duration`.
`Flux<T>`	`delaySequence(Duration delay)` Shift this `Flux` forward in time by a given `Duration`.
`Flux<T>`	`delaySequence(Duration delay, Scheduler timer)` Shift this `Flux` forward in time by a given `Duration`.
`Flux<T>`	`delaySubscription(Duration delay)` Delay the `subscription` to this `Flux` source until the given period elapses.
`Flux<T>`	`delaySubscription(Duration delay, Scheduler timer)` Delay the `subscription` to this `Flux` source until the given period elapses, as measured on the user-provided `Scheduler`.
`<U> Flux<T>`	`delaySubscription(Publisher<U> subscriptionDelay)` Delay the `subscription` to this `Flux` source until another `Publisher` signals a value or completes.
`Flux<T>`	`delayUntil(Function<? super T,? extends Publisher<?>> triggerProvider)` Subscribe to this `Flux` and generate a `Publisher` from each of this Flux elements, each acting as a trigger for relaying said element.
`<X> Flux<X>`	`dematerialize()` An operator working only if this `Flux` emits onNext, onError or onComplete `Signal` instances, transforming these `materialized` signals into real signals on the `Subscriber`.
`Flux<T>`	`distinct()` For each `Subscriber`, track elements from this `Flux` that have been seen and filter out duplicates.
`<V> Flux<T>`	`distinct(Function<? super T,? extends V> keySelector)` For each `Subscriber`, track elements from this `Flux` that have been seen and filter out duplicates, as compared by a key extracted through the user provided `Function`.
`<V,C extends Collection<? super V>> Flux<T>`	`distinct(Function<? super T,? extends V> keySelector, Supplier<C> distinctCollectionSupplier)` For each `Subscriber`, track elements from this `Flux` that have been seen and filter out duplicates, as compared by a key extracted through the user provided `Function` and by the `add method` of the `Collection` supplied (typically a `Set`).
`<V,C> Flux<T>`	`distinct(Function<? super T,? extends V> keySelector, Supplier<C> distinctStoreSupplier, BiPredicate<C,V> distinctPredicate, Consumer<C> cleanup)` For each `Subscriber`, track elements from this `Flux` that have been seen and filter out duplicates, as compared by applying a `BiPredicate` on an arbitrary user-supplied `<C>` store and a key extracted through the user provided `Function`.
`Flux<T>`	`distinctUntilChanged()` Filter out subsequent repetitions of an element (that is, if they arrive right after one another).
`<V> Flux<T>`	`distinctUntilChanged(Function<? super T,? extends V> keySelector)` Filter out subsequent repetitions of an element (that is, if they arrive right after one another), as compared by a key extracted through the user provided `Function` using equality.
`<V> Flux<T>`	`distinctUntilChanged(Function<? super T,? extends V> keySelector, BiPredicate<? super V,? super V> keyComparator)` Filter out subsequent repetitions of an element (that is, if they arrive right after one another), as compared by a key extracted through the user provided `Function` and then comparing keys with the supplied `BiPredicate`.
`Flux<T>`	`doAfterTerminate(Runnable afterTerminate)` Add behavior (side-effect) triggered after the `Flux` terminates, either by completing downstream successfully or with an error.
`Flux<T>`	`doFinally(Consumer<SignalType> onFinally)` Add behavior (side-effect) triggered after the `Flux` terminates for any reason, including cancellation.
`Flux<T>`	`doOnCancel(Runnable onCancel)` Add behavior (side-effect) triggered when the `Flux` is cancelled.
`Flux<T>`	`doOnComplete(Runnable onComplete)` Add behavior (side-effect) triggered when the `Flux` completes successfully.
`<R> Flux<T>`	`doOnDiscard(Class<R> type, Consumer<? super R> discardHook)` Modify the behavior of the whole chain of operators upstream of this one to conditionally clean up elements that get discarded by these operators.
`Flux<T>`	`doOnEach(Consumer<? super Signal<T>> signalConsumer)` Add behavior (side-effects) triggered when the `Flux` emits an item, fails with an error or completes successfully.
`<E extends Throwable> Flux<T>`	`doOnError(Class<E> exceptionType, Consumer<? super E> onError)` Add behavior (side-effect) triggered when the `Flux` completes with an error matching the given exception type.
`Flux<T>`	`doOnError(Consumer<? super Throwable> onError)` Add behavior (side-effect) triggered when the `Flux` completes with an error.
`Flux<T>`	`doOnError(Predicate<? super Throwable> predicate, Consumer<? super Throwable> onError)` Add behavior (side-effect) triggered when the `Flux` completes with an error matching the given exception.
`Flux<T>`	`doOnNext(Consumer<? super T> onNext)` Add behavior (side-effect) triggered when the `Flux` emits an item.
`Flux<T>`	`doOnRequest(LongConsumer consumer)` Add behavior (side-effect) triggering a `LongConsumer` when this `Flux` receives any request.
`Flux<T>`	`doOnSubscribe(Consumer<? super Subscription> onSubscribe)` Add behavior (side-effect) triggered when the `Flux` is subscribed.
`Flux<T>`	`doOnTerminate(Runnable onTerminate)` Add behavior (side-effect) triggered when the `Flux` terminates, either by completing successfully or with an error.
`Flux<Tuple2<Long,T>>`	`elapsed()` Map this `Flux` into `Tuple2<Long, T>` of timemillis and source data.
`Flux<Tuple2<Long,T>>`	`elapsed(Scheduler scheduler)` Map this `Flux` into `Tuple2<Long, T>` of timemillis and source data.
`Mono<T>`	`elementAt(int index)` Emit only the element at the given index position or `IndexOutOfBoundsException` if the sequence is shorter.
`Mono<T>`	`elementAt(int index, T defaultValue)` Emit only the element at the given index position or fall back to a default value if the sequence is shorter.
`static <T> Flux<T>`	`empty()` Create a `Flux` that completes without emitting any item.
`static <T> Flux<T>`	`error(Supplier<Throwable> errorSupplier)` Create a `Flux` that terminates with an error immediately after being subscribed to.
`static <T> Flux<T>`	`error(Throwable error)` Create a `Flux` that terminates with the specified error immediately after being subscribed to.
`static <O> Flux<O>`	`error(Throwable throwable, boolean whenRequested)` Create a `Flux` that terminates with the specified error, either immediately after being subscribed to or after being first requested.
`Flux<T>`	`expand(Function<? super T,? extends Publisher<? extends T>> expander)` Recursively expand elements into a graph and emit all the resulting element using a breadth-first traversal strategy.
`Flux<T>`	`expand(Function<? super T,? extends Publisher<? extends T>> expander, int capacityHint)` Recursively expand elements into a graph and emit all the resulting element using a breadth-first traversal strategy.
`Flux<T>`	`expandDeep(Function<? super T,? extends Publisher<? extends T>> expander)` Recursively expand elements into a graph and emit all the resulting element, in a depth-first traversal order.
`Flux<T>`	`expandDeep(Function<? super T,? extends Publisher<? extends T>> expander, int capacityHint)` Recursively expand elements into a graph and emit all the resulting element, in a depth-first traversal order.
`Flux<T>`	`filter(Predicate<? super T> p)` Evaluate each source value against the given `Predicate`.
`Flux<T>`	`filterWhen(Function<? super T,? extends Publisher<Boolean>> asyncPredicate)` Test each value emitted by this `Flux` asynchronously using a generated `Publisher<Boolean>` test.
`Flux<T>`	`filterWhen(Function<? super T,? extends Publisher<Boolean>> asyncPredicate, int bufferSize)` Test each value emitted by this `Flux` asynchronously using a generated `Publisher<Boolean>` test.
`static <I> Flux<I>`	`first(Iterable<? extends Publisher<? extends I>> sources)` Pick the first `Publisher` to emit any signal (onNext/onError/onComplete) and replay all signals from that `Publisher`, effectively behaving like the fastest of these competing sources.
`static <I> Flux<I>`	`first(Publisher<? extends I>... sources)` Pick the first `Publisher` to emit any signal (onNext/onError/onComplete) and replay all signals from that `Publisher`, effectively behaving like the fastest of these competing sources.
`<R> Flux<R>`	`flatMap(Function<? super T,? extends Publisher<? extends R>> mapper)` Transform the elements emitted by this `Flux` asynchronously into Publishers, then flatten these inner publishers into a single `Flux` through merging, which allow them to interleave.
`<R> Flux<R>`	`flatMap(Function<? super T,? extends Publisher<? extends R>> mapperOnNext, Function<? super Throwable,? extends Publisher<? extends R>> mapperOnError, Supplier<? extends Publisher<? extends R>> mapperOnComplete)` Transform the signals emitted by this `Flux` asynchronously into Publishers, then flatten these inner publishers into a single `Flux` through merging, which allow them to interleave.
`<V> Flux<V>`	`flatMap(Function<? super T,? extends Publisher<? extends V>> mapper, int concurrency)` Transform the elements emitted by this `Flux` asynchronously into Publishers, then flatten these inner publishers into a single `Flux` through merging, which allow them to interleave.
`<V> Flux<V>`	`flatMap(Function<? super T,? extends Publisher<? extends V>> mapper, int concurrency, int prefetch)` Transform the elements emitted by this `Flux` asynchronously into Publishers, then flatten these inner publishers into a single `Flux` through merging, which allow them to interleave.
`<V> Flux<V>`	`flatMapDelayError(Function<? super T,? extends Publisher<? extends V>> mapper, int concurrency, int prefetch)` Transform the elements emitted by this `Flux` asynchronously into Publishers, then flatten these inner publishers into a single `Flux` through merging, which allow them to interleave.
`<R> Flux<R>`	`flatMapIterable(Function<? super T,? extends Iterable<? extends R>> mapper)` Transform the items emitted by this `Flux` into `Iterable`, then flatten the elements from those by merging them into a single `Flux`.
`<R> Flux<R>`	`flatMapIterable(Function<? super T,? extends Iterable<? extends R>> mapper, int prefetch)` Transform the items emitted by this `Flux` into `Iterable`, then flatten the emissions from those by merging them into a single `Flux`.
`<R> Flux<R>`	`flatMapSequential(Function<? super T,? extends Publisher<? extends R>> mapper)` Transform the elements emitted by this `Flux` asynchronously into Publishers, then flatten these inner publishers into a single `Flux`, but merge them in the order of their source element.
`<R> Flux<R>`	`flatMapSequential(Function<? super T,? extends Publisher<? extends R>> mapper, int maxConcurrency)` Transform the elements emitted by this `Flux` asynchronously into Publishers, then flatten these inner publishers into a single `Flux`, but merge them in the order of their source element.
`<R> Flux<R>`	`flatMapSequential(Function<? super T,? extends Publisher<? extends R>> mapper, int maxConcurrency, int prefetch)` Transform the elements emitted by this `Flux` asynchronously into Publishers, then flatten these inner publishers into a single `Flux`, but merge them in the order of their source element.
`<R> Flux<R>`	`flatMapSequentialDelayError(Function<? super T,? extends Publisher<? extends R>> mapper, int maxConcurrency, int prefetch)` Transform the elements emitted by this `Flux` asynchronously into Publishers, then flatten these inner publishers into a single `Flux`, but merge them in the order of their source element.
`static <T> Flux<T>`	`from(Publisher<? extends T> source)` Decorate the specified `Publisher` with the `Flux` API.
`static <T> Flux<T>`	`fromArray(T[] array)` Create a `Flux` that emits the items contained in the provided array.
`static <T> Flux<T>`	`fromIterable(Iterable<? extends T> it)` Create a `Flux` that emits the items contained in the provided `Iterable`.
`static <T> Flux<T>`	`fromStream(Stream<? extends T> s)` Create a `Flux` that emits the items contained in the provided `Stream`.
`static <T> Flux<T>`	`fromStream(Supplier<Stream<? extends T>> streamSupplier)` Create a `Flux` that emits the items contained in a `Stream` created by the provided `Supplier` for each subscription.
`static <T,S> Flux<T>`	`generate(Callable<S> stateSupplier, BiFunction<S,SynchronousSink<T>,S> generator)` Programmatically create a `Flux` by generating signals one-by-one via a consumer callback and some state.
`static <T,S> Flux<T>`	`generate(Callable<S> stateSupplier, BiFunction<S,SynchronousSink<T>,S> generator, Consumer<? super S> stateConsumer)` Programmatically create a `Flux` by generating signals one-by-one via a consumer callback and some state, with a final cleanup callback.
`static <T> Flux<T>`	`generate(Consumer<SynchronousSink<T>> generator)` Programmatically create a `Flux` by generating signals one-by-one via a consumer callback.
`int`	`getPrefetch()` The prefetch configuration of the `Flux`
`<K> Flux<GroupedFlux<K,T>>`	`groupBy(Function<? super T,? extends K> keyMapper)` Divide this sequence into dynamically created `Flux` (or groups) for each unique key, as produced by the provided keyMapper `Function`.
`<K,V> Flux<GroupedFlux<K,V>>`	`groupBy(Function<? super T,? extends K> keyMapper, Function<? super T,? extends V> valueMapper)` Divide this sequence into dynamically created `Flux` (or groups) for each unique key, as produced by the provided keyMapper `Function`.
`<K,V> Flux<GroupedFlux<K,V>>`	`groupBy(Function<? super T,? extends K> keyMapper, Function<? super T,? extends V> valueMapper, int prefetch)` Divide this sequence into dynamically created `Flux` (or groups) for each unique key, as produced by the provided keyMapper `Function`.
`<K> Flux<GroupedFlux<K,T>>`	`groupBy(Function<? super T,? extends K> keyMapper, int prefetch)` Divide this sequence into dynamically created `Flux` (or groups) for each unique key, as produced by the provided keyMapper `Function`.
`<TRight,TLeftEnd,TRightEnd,R> Flux<R>`	`groupJoin(Publisher<? extends TRight> other, Function<? super T,? extends Publisher<TLeftEnd>> leftEnd, Function<? super TRight,? extends Publisher<TRightEnd>> rightEnd, BiFunction<? super T,? super Flux<TRight>,? extends R> resultSelector)` Map values from two Publishers into time windows and emit combination of values in case their windows overlap.
`<R> Flux<R>`	`handle(BiConsumer<? super T,SynchronousSink<R>> handler)` Handle the items emitted by this `Flux` by calling a biconsumer with the output sink for each onNext.
`Mono<Boolean>`	`hasElement(T value)` Emit a single boolean true if any of the elements of this `Flux` sequence is equal to the provided value.
`Mono<Boolean>`	`hasElements()` Emit a single boolean true if this `Flux` sequence has at least one element.
`Flux<T>`	`hide()` Hides the identities of this `Flux` instance.
`Mono<T>`	`ignoreElements()` Ignores onNext signals (dropping them) and only propagate termination events.
`Flux<Tuple2<Long,T>>`	`index()` Keep information about the order in which source values were received by indexing them with a 0-based incrementing long, returning a `Flux` of `Tuple2<(index, value)>`.
`<I> Flux<I>`	`index(BiFunction<? super Long,? super T,? extends I> indexMapper)` Keep information about the order in which source values were received by indexing them internally with a 0-based incrementing long then combining this information with the source value into a `I` using the provided `BiFunction`, returning a `Flux<I>`.
`static Flux<Long>`	`interval(Duration period)` Create a `Flux` that emits long values starting with 0 and incrementing at specified time intervals on the global timer.
`static Flux<Long>`	`interval(Duration delay, Duration period)` Create a `Flux` that emits long values starting with 0 and incrementing at specified time intervals, after an initial delay, on the global timer.
`static Flux<Long>`	`interval(Duration delay, Duration period, Scheduler timer)` Create a `Flux` that emits long values starting with 0 and incrementing at specified time intervals, after an initial delay, on the specified `Scheduler`.
`static Flux<Long>`	`interval(Duration period, Scheduler timer)` Create a `Flux` that emits long values starting with 0 and incrementing at specified time intervals, on the specified `Scheduler`.
`<TRight,TLeftEnd,TRightEnd,R> Flux<R>`	`join(Publisher<? extends TRight> other, Function<? super T,? extends Publisher<TLeftEnd>> leftEnd, Function<? super TRight,? extends Publisher<TRightEnd>> rightEnd, BiFunction<? super T,? super TRight,? extends R> resultSelector)` Map values from two Publishers into time windows and emit combination of values in case their windows overlap.
`static <T> Flux<T>`	`just(T... data)` Create a `Flux` that emits the provided elements and then completes.
`static <T> Flux<T>`	`just(T data)` Create a new `Flux` that will only emit a single element then onComplete.
`Mono<T>`	`last()` Emit the last element observed before complete signal as a `Mono`, or emit `NoSuchElementException` error if the source was empty.
`Mono<T>`	`last(T defaultValue)` Emit the last element observed before complete signal as a `Mono`, or emit the `defaultValue` if the source was empty.
`Flux<T>`	`limitRate(int prefetchRate)` Ensure that backpressure signals from downstream subscribers are split into batches capped at the provided `prefetchRate` when propagated upstream, effectively rate limiting the upstream `Publisher`.
`Flux<T>`	`limitRate(int highTide, int lowTide)` Ensure that backpressure signals from downstream subscribers are split into batches capped at the provided `highTide` first, then replenishing at the provided `lowTide`, effectively rate limiting the upstream `Publisher`.
`Flux<T>`	`limitRequest(long requestCap)` Ensure that the total amount requested upstream is capped at `cap`.
`Flux<T>`	`log()` Observe all Reactive Streams signals and trace them using `Logger` support.
`Flux<T>`	`log(Logger logger)` Observe Reactive Streams signals matching the passed filter `options` and trace them using a specific user-provided `Logger`, at `Level.INFO` level.
`Flux<T>`	`log(Logger logger, Level level, boolean showOperatorLine, SignalType... options)` Observe Reactive Streams signals matching the passed filter `options` and trace them using a specific user-provided `Logger`, at the given `Level`.
`Flux<T>`	`log(String category)` Observe all Reactive Streams signals and trace them using `Logger` support.
`Flux<T>`	`log(String category, Level level, boolean showOperatorLine, SignalType... options)` Observe Reactive Streams signals matching the passed filter `options` and trace them using `Logger` support.
`Flux<T>`	`log(String category, Level level, SignalType... options)` Observe Reactive Streams signals matching the passed filter `options` and trace them using `Logger` support.
`<V> Flux<V>`	`map(Function<? super T,? extends V> mapper)` Transform the items emitted by this `Flux` by applying a synchronous function to each item.
`Flux<Signal<T>>`	`materialize()` Transform incoming onNext, onError and onComplete signals into `Signal` instances, materializing these signals.
`static <I> Flux<I>`	`merge(int prefetch, Publisher<? extends I>... sources)` Merge data from `Publisher` sequences contained in an array / vararg into an interleaved merged sequence.
`static <I> Flux<I>`	`merge(Iterable<? extends Publisher<? extends I>> sources)` Merge data from `Publisher` sequences contained in an `Iterable` into an interleaved merged sequence.
`static <I> Flux<I>`	`merge(Publisher<? extends I>... sources)` Merge data from `Publisher` sequences contained in an array / vararg into an interleaved merged sequence.
`static <T> Flux<T>`	`merge(Publisher<? extends Publisher<? extends T>> source)` Merge data from `Publisher` sequences emitted by the passed `Publisher` into an interleaved merged sequence.
`static <T> Flux<T>`	`merge(Publisher<? extends Publisher<? extends T>> source, int concurrency)` Merge data from `Publisher` sequences emitted by the passed `Publisher` into an interleaved merged sequence.
`static <T> Flux<T>`	`merge(Publisher<? extends Publisher<? extends T>> source, int concurrency, int prefetch)` Merge data from `Publisher` sequences emitted by the passed `Publisher` into an interleaved merged sequence.
`static <I> Flux<I>`	`mergeDelayError(int prefetch, Publisher<? extends I>... sources)` Merge data from `Publisher` sequences contained in an array / vararg into an interleaved merged sequence.
`static <T> Flux<T>`	`mergeOrdered(Comparator<? super T> comparator, Publisher<? extends T>... sources)` Merge data from provided `Publisher` sequences into an ordered merged sequence, by picking the smallest values from each source (as defined by the provided `Comparator`).
`static <T> Flux<T>`	`mergeOrdered(int prefetch, Comparator<? super T> comparator, Publisher<? extends T>... sources)` Merge data from provided `Publisher` sequences into an ordered merged sequence, by picking the smallest values from each source (as defined by the provided `Comparator`).
`static <I extends Comparable<? super I>> Flux<I>`	`mergeOrdered(Publisher<? extends I>... sources)` Merge data from provided `Publisher` sequences into an ordered merged sequence, by picking the smallest values from each source (as defined by their natural order).
`Flux<T>`	`mergeOrderedWith(Publisher<? extends T> other, Comparator<? super T> otherComparator)` Merge data from this `Flux` and a `Publisher` into a reordered merge sequence, by picking the smallest value from each sequence as defined by a provided `Comparator`.
`static <I> Flux<I>`	`mergeSequential(int prefetch, Publisher<? extends I>... sources)` Merge data from `Publisher` sequences provided in an array/vararg into an ordered merged sequence.
`static <I> Flux<I>`	`mergeSequential(Iterable<? extends Publisher<? extends I>> sources)` Merge data from `Publisher` sequences provided in an `Iterable` into an ordered merged sequence.
`static <I> Flux<I>`	`mergeSequential(Iterable<? extends Publisher<? extends I>> sources, int maxConcurrency, int prefetch)` Merge data from `Publisher` sequences provided in an `Iterable` into an ordered merged sequence.
`static <I> Flux<I>`	`mergeSequential(Publisher<? extends I>... sources)` Merge data from `Publisher` sequences provided in an array/vararg into an ordered merged sequence.
`static <T> Flux<T>`	`mergeSequential(Publisher<? extends Publisher<? extends T>> sources)` Merge data from `Publisher` sequences emitted by the passed `Publisher` into an ordered merged sequence.
`static <T> Flux<T>`	`mergeSequential(Publisher<? extends Publisher<? extends T>> sources, int maxConcurrency, int prefetch)` Merge data from `Publisher` sequences emitted by the passed `Publisher` into an ordered merged sequence.
`static <I> Flux<I>`	`mergeSequentialDelayError(int prefetch, Publisher<? extends I>... sources)` Merge data from `Publisher` sequences provided in an array/vararg into an ordered merged sequence.
`static <I> Flux<I>`	`mergeSequentialDelayError(Iterable<? extends Publisher<? extends I>> sources, int maxConcurrency, int prefetch)` Merge data from `Publisher` sequences provided in an `Iterable` into an ordered merged sequence.
`static <T> Flux<T>`	`mergeSequentialDelayError(Publisher<? extends Publisher<? extends T>> sources, int maxConcurrency, int prefetch)` Merge data from `Publisher` sequences emitted by the passed `Publisher` into an ordered merged sequence.
`Flux<T>`	`mergeWith(Publisher<? extends T> other)` Merge data from this `Flux` and a `Publisher` into an interleaved merged sequence.
`Flux<T>`	`metrics()` Activate metrics for this sequence, provided there is an instrumentation facade on the classpath (otherwise this method is a pure no-op).
`Flux<T>`	`name(String name)` Give a name to this sequence, which can be retrieved using `Scannable.name()` as long as this is the first reachable `Scannable.parents()`.
`static <T> Flux<T>`	`never()` Create a `Flux` that will never signal any data, error or completion signal.
`Mono<T>`	`next()` Emit only the first item emitted by this `Flux`, into a new `Mono`.
`<U> Flux<U>`	`ofType(Class<U> clazz)` Evaluate each accepted value against the given `Class` type.
`protected static <T> ConnectableFlux<T>`	`onAssembly(ConnectableFlux<T> source)` To be used by custom operators: invokes assembly `Hooks` pointcut given a `ConnectableFlux`, potentially returning a new `ConnectableFlux`.
`protected static <T> Flux<T>`	`onAssembly(Flux<T> source)` To be used by custom operators: invokes assembly `Hooks` pointcut given a `Flux`, potentially returning a new `Flux`.
`Flux<T>`	`onBackpressureBuffer()` Request an unbounded demand and push to the returned `Flux`, or park the observed elements if not enough demand is requested downstream.
`Flux<T>`	`onBackpressureBuffer(Duration ttl, int maxSize, Consumer<? super T> onBufferEviction)` Request an unbounded demand and push to the returned `Flux`, or park the observed elements if not enough demand is requested downstream, within a `maxSize` limit and for a maximum `Duration` of `ttl` (as measured on the `elastic Scheduler`).
`Flux<T>`	`onBackpressureBuffer(Duration ttl, int maxSize, Consumer<? super T> onBufferEviction, Scheduler scheduler)` Request an unbounded demand and push to the returned `Flux`, or park the observed elements if not enough demand is requested downstream, within a `maxSize` limit and for a maximum `Duration` of `ttl` (as measured on the provided `Scheduler`).
`Flux<T>`	`onBackpressureBuffer(int maxSize)` Request an unbounded demand and push to the returned `Flux`, or park the observed elements if not enough demand is requested downstream.
`Flux<T>`	`onBackpressureBuffer(int maxSize, BufferOverflowStrategy bufferOverflowStrategy)` Request an unbounded demand and push to the returned `Flux`, or park the observed elements if not enough demand is requested downstream, within a `maxSize` limit.
`Flux<T>`	`onBackpressureBuffer(int maxSize, Consumer<? super T> onOverflow)` Request an unbounded demand and push to the returned `Flux`, or park the observed elements if not enough demand is requested downstream.
`Flux<T>`	`onBackpressureBuffer(int maxSize, Consumer<? super T> onBufferOverflow, BufferOverflowStrategy bufferOverflowStrategy)` Request an unbounded demand and push to the returned `Flux`, or park the observed elements if not enough demand is requested downstream, within a `maxSize` limit.
`Flux<T>`	`onBackpressureDrop()` Request an unbounded demand and push to the returned `Flux`, or drop the observed elements if not enough demand is requested downstream.
`Flux<T>`	`onBackpressureDrop(Consumer<? super T> onDropped)` Request an unbounded demand and push to the returned `Flux`, or drop and notify dropping `Consumer` with the observed elements if not enough demand is requested downstream.
`Flux<T>`	`onBackpressureError()` Request an unbounded demand and push to the returned `Flux`, or emit onError fom `Exceptions.failWithOverflow()` if not enough demand is requested downstream.
`Flux<T>`	`onBackpressureLatest()` Request an unbounded demand and push to the returned `Flux`, or only keep the most recent observed item if not enough demand is requested downstream.
`Flux<T>`	`onErrorContinue(BiConsumer<Throwable,Object> errorConsumer)` Let compatible operators upstream recover from errors by dropping the incriminating element from the sequence and continuing with subsequent elements.
`<E extends Throwable> Flux<T>`	`onErrorContinue(Class<E> type, BiConsumer<Throwable,Object> errorConsumer)` Let compatible operators upstream recover from errors by dropping the incriminating element from the sequence and continuing with subsequent elements.
`<E extends Throwable> Flux<T>`	`onErrorContinue(Predicate<E> errorPredicate, BiConsumer<Throwable,Object> errorConsumer)` Let compatible operators upstream recover from errors by dropping the incriminating element from the sequence and continuing with subsequent elements.
`<E extends Throwable> Flux<T>`	`onErrorMap(Class<E> type, Function<? super E,? extends Throwable> mapper)` Transform an error emitted by this `Flux` by synchronously applying a function to it if the error matches the given type.
`Flux<T>`	`onErrorMap(Function<? super Throwable,? extends Throwable> mapper)` Transform any error emitted by this `Flux` by synchronously applying a function to it.
`Flux<T>`	`onErrorMap(Predicate<? super Throwable> predicate, Function<? super Throwable,? extends Throwable> mapper)` Transform an error emitted by this `Flux` by synchronously applying a function to it if the error matches the given predicate.
`<E extends Throwable> Flux<T>`	`onErrorResume(Class<E> type, Function<? super E,? extends Publisher<? extends T>> fallback)` Subscribe to a fallback publisher when an error matching the given type occurs, using a function to choose the fallback depending on the error.
`Flux<T>`	`onErrorResume(Function<? super Throwable,? extends Publisher<? extends T>> fallback)` Subscribe to a returned fallback publisher when any error occurs, using a function to choose the fallback depending on the error.
`Flux<T>`	`onErrorResume(Predicate<? super Throwable> predicate, Function<? super Throwable,? extends Publisher<? extends T>> fallback)` Subscribe to a fallback publisher when an error matching a given predicate occurs.
`<E extends Throwable> Flux<T>`	`onErrorReturn(Class<E> type, T fallbackValue)` Simply emit a captured fallback value when an error of the specified type is observed on this `Flux`.
`Flux<T>`	`onErrorReturn(Predicate<? super Throwable> predicate, T fallbackValue)` Simply emit a captured fallback value when an error matching the given predicate is observed on this `Flux`.
`Flux<T>`	`onErrorReturn(T fallbackValue)` Simply emit a captured fallback value when any error is observed on this `Flux`.
`Flux<T>`	`onErrorStop()` If an `onErrorContinue(BiConsumer)` variant has been used before, reverts to the default 'STOP' mode where errors are terminal events.
`protected static <T> Flux<T>`	`onLastAssembly(Flux<T> source)` To be used by custom operators: invokes assembly `Hooks` pointcut given a `Flux`, potentially returning a new `Flux`.
`Flux<T>`	`onTerminateDetach()` Detaches both the child `Subscriber` and the `Subscription` on termination or cancellation.
`Flux<T>`	`or(Publisher<? extends T> other)` Pick the first `Publisher` between this `Flux` and another publisher to emit any signal (onNext/onError/onComplete) and replay all signals from that `Publisher`, effectively behaving like the fastest of these competing sources.
`ParallelFlux<T>`	`parallel()` Prepare this `Flux` by dividing data on a number of 'rails' matching the number of CPU cores, in a round-robin fashion.
`ParallelFlux<T>`	`parallel(int parallelism)` Prepare this `Flux` by dividing data on a number of 'rails' matching the provided `parallelism` parameter, in a round-robin fashion.
`ParallelFlux<T>`	`parallel(int parallelism, int prefetch)` Prepare this `Flux` by dividing data on a number of 'rails' matching the provided `parallelism` parameter, in a round-robin fashion and using a custom prefetch amount and queue for dealing with the source `Flux`'s values.
`ConnectableFlux<T>`	`publish()` Prepare a `ConnectableFlux` which shares this `Flux` sequence and dispatches values to subscribers in a backpressure-aware manner.
`<R> Flux<R>`	`publish(Function<? super Flux<T>,? extends Publisher<? extends R>> transform)` Shares a sequence for the duration of a function that may transform it and consume it as many times as necessary without causing multiple subscriptions to the upstream.
`<R> Flux<R>`	`publish(Function<? super Flux<T>,? extends Publisher<? extends R>> transform, int prefetch)` Shares a sequence for the duration of a function that may transform it and consume it as many times as necessary without causing multiple subscriptions to the upstream.
`ConnectableFlux<T>`	`publish(int prefetch)` Prepare a `ConnectableFlux` which shares this `Flux` sequence and dispatches values to subscribers in a backpressure-aware manner.
`Mono<T>`	`publishNext()` Prepare a `Mono` which shares this `Flux` sequence and dispatches the first observed item to subscribers in a backpressure-aware manner.
`Flux<T>`	`publishOn(Scheduler scheduler)` Run onNext, onComplete and onError on a supplied `Scheduler` `Worker`.
`Flux<T>`	`publishOn(Scheduler scheduler, boolean delayError, int prefetch)` Run onNext, onComplete and onError on a supplied `Scheduler` `Scheduler.Worker`.
`Flux<T>`	`publishOn(Scheduler scheduler, int prefetch)` Run onNext, onComplete and onError on a supplied `Scheduler` `Scheduler.Worker`.
`static <T> Flux<T>`	`push(Consumer<? super FluxSink<T>> emitter)` Programmatically create a `Flux` with the capability of emitting multiple elements from a single-threaded producer through the `FluxSink` API.
`static <T> Flux<T>`	`push(Consumer<? super FluxSink<T>> emitter, FluxSink.OverflowStrategy backpressure)` Programmatically create a `Flux` with the capability of emitting multiple elements from a single-threaded producer through the `FluxSink` API.
`static Flux<Integer>`	`range(int start, int count)` Build a `Flux` that will only emit a sequence of `count` incrementing integers, starting from `start`.
`<A> Mono<A>`	`reduce(A initial, BiFunction<A,? super T,A> accumulator)` Reduce the values from this `Flux` sequence into an single object matching the type of a seed value.
`Mono<T>`	`reduce(BiFunction<T,T,T> aggregator)` Reduce the values from this `Flux` sequence into an single object of the same type than the emitted items.
`<A> Mono<A>`	`reduceWith(Supplier<A> initial, BiFunction<A,? super T,A> accumulator)` Reduce the values from this `Flux` sequence into an single object matching the type of a lazily supplied seed value.
`Flux<T>`	`repeat()` Repeatedly and indefinitely subscribe to the source upon completion of the previous subscription.
`Flux<T>`	`repeat(BooleanSupplier predicate)` Repeatedly subscribe to the source if the predicate returns true after completion of the previous subscription.
`Flux<T>`	`repeat(long numRepeat)` Repeatedly subscribe to the source `numRepeat` times.
`Flux<T>`	`repeat(long numRepeat, BooleanSupplier predicate)` Repeatedly subscribe to the source if the predicate returns true after completion of the previous subscription.
`Flux<T>`	`repeatWhen(Function<Flux<Long>,? extends Publisher<?>> repeatFactory)` Repeatedly subscribe to this `Flux` when a companion sequence emits elements in response to the flux completion signal.
`ConnectableFlux<T>`	`replay()` Turn this `Flux` into a hot source and cache last emitted signals for further `Subscriber`.
`ConnectableFlux<T>`	`replay(Duration ttl)` Turn this `Flux` into a connectable hot source and cache last emitted signals for further `Subscriber`.
`ConnectableFlux<T>`	`replay(Duration ttl, Scheduler timer)` Turn this `Flux` into a connectable hot source and cache last emitted signals for further `Subscriber`.
`ConnectableFlux<T>`	`replay(int history)` Turn this `Flux` into a connectable hot source and cache last emitted signals for further `Subscriber`.
`ConnectableFlux<T>`	`replay(int history, Duration ttl)` Turn this `Flux` into a connectable hot source and cache last emitted signals for further `Subscriber`.
`ConnectableFlux<T>`	`replay(int history, Duration ttl, Scheduler timer)` Turn this `Flux` into a connectable hot source and cache last emitted signals for further `Subscriber`.
`Flux<T>`	`retry()` Re-subscribes to this `Flux` sequence if it signals any error, indefinitely.
`Flux<T>`	`retry(long numRetries)` Re-subscribes to this `Flux` sequence if it signals any error, for a fixed number of times.
`Flux<T>`	`retry(long numRetries, Predicate<? super Throwable> retryMatcher)` Re-subscribes to this `Flux` sequence up to the specified number of retries if it signals any error that match the given `Predicate`, otherwise push the error downstream.
`Flux<T>`	`retry(Predicate<? super Throwable> retryMatcher)` Re-subscribes to this `Flux` sequence if it signals any error that matches the given `Predicate`, otherwise push the error downstream.
`Flux<T>`	`retryBackoff(long numRetries, Duration firstBackoff)` In case of error, retry this `Flux` up to `numRetries` times using a randomized exponential backoff strategy (jitter).
`Flux<T>`	`retryBackoff(long numRetries, Duration firstBackoff, Duration maxBackoff)` In case of error, retry this `Flux` up to `numRetries` times using a randomized exponential backoff strategy.
`Flux<T>`	`retryBackoff(long numRetries, Duration firstBackoff, Duration maxBackoff, double jitterFactor)` In case of error, retry this `Flux` up to `numRetries` times using a randomized exponential backoff strategy, randomized with a user-provided jitter factor between `0.d` (no jitter) and `1.0` (default is `0.5`).
`Flux<T>`	`retryWhen(Function<Flux<Throwable>,? extends Publisher<?>> whenFactory)` Retries this `Flux` when a companion sequence signals an item in response to this `Flux` error signal
`Flux<T>`	`sample(Duration timespan)` Sample this `Flux` by periodically emitting an item corresponding to that `Flux` latest emitted value within the periodical time window.
`<U> Flux<T>`	`sample(Publisher<U> sampler)` Sample this `Flux` by emitting an item corresponding to that `Flux` latest emitted value whenever a companion sampler `Publisher` signals a value.
`Flux<T>`	`sampleFirst(Duration timespan)` Repeatedly take a value from this `Flux` then skip the values that follow within a given duration.
`<U> Flux<T>`	`sampleFirst(Function<? super T,? extends Publisher<U>> samplerFactory)` Repeatedly take a value from this `Flux` then skip the values that follow before the next signal from a companion sampler `Publisher`.
`<U> Flux<T>`	`sampleTimeout(Function<? super T,? extends Publisher<U>> throttlerFactory)` Emit the latest value from this `Flux` only if there were no new values emitted during the window defined by a companion `Publisher` derived from that particular value.
`<U> Flux<T>`	`sampleTimeout(Function<? super T,? extends Publisher<U>> throttlerFactory, int maxConcurrency)` Emit the latest value from this `Flux` only if there were no new values emitted during the window defined by a companion `Publisher` derived from that particular value.
`<A> Flux<A>`	`scan(A initial, BiFunction<A,? super T,A> accumulator)` Reduce this `Flux` values with an accumulator `BiFunction` and also emit the intermediate results of this function.
`Flux<T>`	`scan(BiFunction<T,T,T> accumulator)` Reduce this `Flux` values with an accumulator `BiFunction` and also emit the intermediate results of this function.
`<A> Flux<A>`	`scanWith(Supplier<A> initial, BiFunction<A,? super T,A> accumulator)` Reduce this `Flux` values with the help of an accumulator `BiFunction` and also emits the intermediate results.
`Flux<T>`	`share()` Returns a new `Flux` that multicasts (shares) the original `Flux`.
`Mono<T>`	`single()` Expect and emit a single item from this `Flux` source or signal `NoSuchElementException` for an empty source, or `IndexOutOfBoundsException` for a source with more than one element.
`Mono<T>`	`single(T defaultValue)` Expect and emit a single item from this `Flux` source and emit a default value for an empty source, but signal an `IndexOutOfBoundsException` for a source with more than one element.
`Mono<T>`	`singleOrEmpty()` Expect and emit a single item from this `Flux` source, and accept an empty source but signal an `IndexOutOfBoundsException` for a source with more than one element.
`Flux<T>`	`skip(Duration timespan)` Skip elements from this `Flux` emitted within the specified initial duration.
`Flux<T>`	`skip(Duration timespan, Scheduler timer)` Skip elements from this `Flux` emitted within the specified initial duration, as measured on the provided `Scheduler`.
`Flux<T>`	`skip(long skipped)` Skip the specified number of elements from the beginning of this `Flux` then emit the remaining elements.
`Flux<T>`	`skipLast(int n)` Skip a specified number of elements at the end of this `Flux` sequence.
`Flux<T>`	`skipUntil(Predicate<? super T> untilPredicate)` Skips values from this `Flux` until a `Predicate` returns true for the value.
`Flux<T>`	`skipUntilOther(Publisher<?> other)` Skip values from this `Flux` until a specified `Publisher` signals an onNext or onComplete.
`Flux<T>`	`skipWhile(Predicate<? super T> skipPredicate)` Skips values from this `Flux` while a `Predicate` returns true for the value.
`Flux<T>`	`sort()` Sort elements from this `Flux` by collecting and sorting them in the background then emitting the sorted sequence once this sequence completes.
`Flux<T>`	`sort(Comparator<? super T> sortFunction)` Sort elements from this `Flux` using a `Comparator` function, by collecting and sorting elements in the background then emitting the sorted sequence once this sequence completes.
`Flux<T>`	`startWith(Iterable<? extends T> iterable)` Prepend the given `Iterable` before this `Flux` sequence.
`Flux<T>`	`startWith(Publisher<? extends T> publisher)` Prepend the given `Publisher` sequence to this `Flux` sequence.
`Flux<T>`	`startWith(T... values)` Prepend the given values before this `Flux` sequence.
`Disposable`	`subscribe()` Subscribe to this `Flux` and request unbounded demand.
`Disposable`	`subscribe(Consumer<? super T> consumer)` Subscribe a `Consumer` to this `Flux` that will consume all the elements in the sequence.
`Disposable`	`subscribe(Consumer<? super T> consumer, Consumer<? super Throwable> errorConsumer)` Subscribe to this `Flux` with a `Consumer` that will consume all the elements in the sequence, as well as a `Consumer` that will handle errors.
`Disposable`	`subscribe(Consumer<? super T> consumer, Consumer<? super Throwable> errorConsumer, Runnable completeConsumer)` Subscribe `Consumer` to this `Flux` that will respectively consume all the elements in the sequence, handle errors and react to completion.
`Disposable`	`subscribe(Consumer<? super T> consumer, Consumer<? super Throwable> errorConsumer, Runnable completeConsumer, Consumer<? super Subscription> subscriptionConsumer)` Subscribe `Consumer` to this `Flux` that will respectively consume all the elements in the sequence, handle errors, react to completion, and request upon subscription.
`abstract void`	`subscribe(CoreSubscriber<? super T> actual)` An internal `Publisher.subscribe(Subscriber)` that will bypass `Hooks.onLastOperator(Function)` pointcut.
`void`	`subscribe(Subscriber<? super T> actual)`
`Flux<T>`	`subscribeOn(Scheduler scheduler)` Run subscribe, onSubscribe and request on a specified `Scheduler`'s `Scheduler.Worker`.
`Flux<T>`	`subscribeOn(Scheduler scheduler, boolean requestOnSeparateThread)` Run subscribe and onSubscribe on a specified `Scheduler`'s `Scheduler.Worker`.
`Flux<T>`	`subscriberContext(Context mergeContext)` Enrich a potentially empty downstream `Context` by adding all values from the given `Context`, producing a new `Context` that is propagated upstream.
`Flux<T>`	`subscriberContext(Function<Context,Context> doOnContext)` Enrich a potentially empty downstream `Context` by applying a `Function` to it, producing a new `Context` that is propagated upstream.
`<E extends Subscriber<? super T>> E`	`subscribeWith(E subscriber)` Subscribe the given `Subscriber` to this `Flux` and return said `Subscriber` (eg.
`Flux<T>`	`switchIfEmpty(Publisher<? extends T> alternate)` Switch to an alternative `Publisher` if this sequence is completed without any data.
`<V> Flux<V>`	`switchMap(Function<? super T,Publisher<? extends V>> fn)` Switch to a new `Publisher` generated via a `Function` whenever this `Flux` produces an item.
`<V> Flux<V>`	`switchMap(Function<? super T,Publisher<? extends V>> fn, int prefetch)` Switch to a new `Publisher` generated via a `Function` whenever this `Flux` produces an item.
`static <T> Flux<T>`	`switchOnNext(Publisher<? extends Publisher<? extends T>> mergedPublishers)` Creates a `Flux` that mirrors the most recently emitted `Publisher`, forwarding its data until a new `Publisher` comes in in the source.
`static <T> Flux<T>`	`switchOnNext(Publisher<? extends Publisher<? extends T>> mergedPublishers, int prefetch)` Creates a `Flux` that mirrors the most recently emitted `Publisher`, forwarding its data until a new `Publisher` comes in in the source.
`Flux<T>`	`tag(String key, String value)` Tag this flux with a key/value pair.
`Flux<T>`	`take(Duration timespan)` Relay values from this `Flux` until the specified `Duration` elapses.
`Flux<T>`	`take(Duration timespan, Scheduler timer)` Relay values from this `Flux` until the specified `Duration` elapses, as measured on the specified `Scheduler`.
`Flux<T>`	`take(long n)` Take only the first N values from this `Flux`, if available.
`Flux<T>`	`takeLast(int n)` Emit the last N values this `Flux` emitted before its completion.
`Flux<T>`	`takeUntil(Predicate<? super T> predicate)` Relay values from this `Flux` until the given `Predicate` matches.
`Flux<T>`	`takeUntilOther(Publisher<?> other)` Relay values from this `Flux` until the given `Publisher` emits.
`Flux<T>`	`takeWhile(Predicate<? super T> continuePredicate)` Relay values from this `Flux` while a predicate returns TRUE for the values (checked before each value is delivered).
`Mono<Void>`	`then()` Return a `Mono<Void>` that completes when this `Flux` completes.
`<V> Mono<V>`	`then(Mono<V> other)` Let this `Flux` complete then play signals from a provided `Mono`.
`Mono<Void>`	`thenEmpty(Publisher<Void> other)` Return a `Mono<Void>` that waits for this `Flux` to complete then for a supplied `Publisher<Void>` to also complete.
`<V> Flux<V>`	`thenMany(Publisher<V> other)` Let this `Flux` complete then play another `Publisher`.
`Flux<T>`	`timeout(Duration timeout)` Propagate a `TimeoutException` as soon as no item is emitted within the given `Duration` from the previous emission (or the subscription for the first item).
`Flux<T>`	`timeout(Duration timeout, Publisher<? extends T> fallback)` Switch to a fallback `Flux` as soon as no item is emitted within the given `Duration` from the previous emission (or the subscription for the first item).
`Flux<T>`	`timeout(Duration timeout, Publisher<? extends T> fallback, Scheduler timer)` Switch to a fallback `Flux` as soon as no item is emitted within the given `Duration` from the previous emission (or the subscription for the first item), as measured on the specified `Scheduler`.
`Flux<T>`	`timeout(Duration timeout, Scheduler timer)` Propagate a `TimeoutException` as soon as no item is emitted within the given `Duration` from the previous emission (or the subscription for the first item), as measured by the specified `Scheduler`.
`<U> Flux<T>`	`timeout(Publisher<U> firstTimeout)` Signal a `TimeoutException` in case the first item from this `Flux` has not been emitted before the given `Publisher` emits.
`<U,V> Flux<T>`	`timeout(Publisher<U> firstTimeout, Function<? super T,? extends Publisher<V>> nextTimeoutFactory)` Signal a `TimeoutException` in case the first item from this `Flux` has not been emitted before the `firstTimeout` `Publisher` emits, and whenever each subsequent elements is not emitted before a `Publisher` generated from the latest element signals.
`<U,V> Flux<T>`	`timeout(Publisher<U> firstTimeout, Function<? super T,? extends Publisher<V>> nextTimeoutFactory, Publisher<? extends T> fallback)` Switch to a fallback `Publisher` in case the first item from this `Flux` has not been emitted before the `firstTimeout` `Publisher` emits, and whenever each subsequent elements is not emitted before a `Publisher` generated from the latest element signals.
`Flux<Tuple2<Long,T>>`	`timestamp()` Emit a `Tuple2` pair of T1 the current clock time in millis (as a `Long` measured by the `parallel` Scheduler) and T2 the emitted data (as a `T`), for each item from this `Flux`.
`Flux<Tuple2<Long,T>>`	`timestamp(Scheduler scheduler)` Emit a `Tuple2` pair of T1 the current clock time in millis (as a `Long` measured by the provided `Scheduler`) and T2 the emitted data (as a `T`), for each item from this `Flux`.
`Iterable<T>`	`toIterable()` Transform this `Flux` into a lazy `Iterable` blocking on `Iterator.next()` calls.
`Iterable<T>`	`toIterable(int batchSize)` Transform this `Flux` into a lazy `Iterable` blocking on `Iterator.next()` calls.
`Iterable<T>`	`toIterable(int batchSize, Supplier<Queue<T>> queueProvider)` Transform this `Flux` into a lazy `Iterable` blocking on `Iterator.next()` calls.
`Stream<T>`	`toStream()` Transform this `Flux` into a lazy `Stream` blocking for each source `onNext` call.
`Stream<T>`	`toStream(int batchSize)` Transform this `Flux` into a lazy `Stream` blocking for each source `onNext` call.
`String`	`toString()`
`<V> Flux<V>`	`transform(Function<? super Flux<T>,? extends Publisher<V>> transformer)` Transform this `Flux` in order to generate a target `Flux`.
`static <T,D> Flux<T>`	`using(Callable<? extends D> resourceSupplier, Function<? super D,? extends Publisher<? extends T>> sourceSupplier, Consumer<? super D> resourceCleanup)` Uses a resource, generated by a supplier for each individual Subscriber, while streaming the values from a Publisher derived from the same resource and makes sure the resource is released if the sequence terminates or the Subscriber cancels.
`static <T,D> Flux<T>`	`using(Callable<? extends D> resourceSupplier, Function<? super D,? extends Publisher<? extends T>> sourceSupplier, Consumer<? super D> resourceCleanup, boolean eager)` Uses a resource, generated by a supplier for each individual Subscriber, while streaming the values from a Publisher derived from the same resource and makes sure the resource is released if the sequence terminates or the Subscriber cancels.
`static <T,D> Flux<T>`	`usingWhen(Publisher<D> resourceSupplier, Function<? super D,? extends Publisher<? extends T>> resourceClosure, Function<? super D,? extends Publisher<?>> asyncCleanup)` Uses a resource, generated by a `Publisher` for each individual `Subscriber`, while streaming the values from a `Publisher` derived from the same resource.
`static <T,D> Flux<T>`	`usingWhen(Publisher<D> resourceSupplier, Function<? super D,? extends Publisher<? extends T>> resourceClosure, Function<? super D,? extends Publisher<?>> asyncComplete, Function<? super D,? extends Publisher<?>> asyncError)` Uses a resource, generated by a `Publisher` for each individual `Subscriber`, while streaming the values from a `Publisher` derived from the same resource.
`static <T,D> Flux<T>`	`usingWhen(Publisher<D> resourceSupplier, Function<? super D,? extends Publisher<? extends T>> resourceClosure, Function<? super D,? extends Publisher<?>> asyncComplete, Function<? super D,? extends Publisher<?>> asyncError, Function<? super D,? extends Publisher<?>> asyncCancel)` Uses a resource, generated by a `Publisher` for each individual `Subscriber`, while streaming the values from a `Publisher` derived from the same resource.
`Flux<Flux<T>>`	`window(Duration windowingTimespan)` Split this `Flux` sequence into continuous, non-overlapping windows that open for a `windowingTimespan` `Duration` (as measured on the `parallel` Scheduler).
`Flux<Flux<T>>`	`window(Duration windowingTimespan, Duration openWindowEvery)` Split this `Flux` sequence into multiple `Flux` windows that open for a given `windowingTimespan` `Duration`, after which it closes with onComplete.
`Flux<Flux<T>>`	`window(Duration windowingTimespan, Duration openWindowEvery, Scheduler timer)` Split this `Flux` sequence into multiple `Flux` windows that open for a given `windowingTimespan` `Duration`, after which it closes with onComplete.
`Flux<Flux<T>>`	`window(Duration windowingTimespan, Scheduler timer)` Split this `Flux` sequence into continuous, non-overlapping windows that open for a `windowingTimespan` `Duration` (as measured on the provided `Scheduler`).
`Flux<Flux<T>>`	`window(int maxSize)` Split this `Flux` sequence into multiple `Flux` windows containing `maxSize` elements (or less for the final window) and starting from the first item.
`Flux<Flux<T>>`	`window(int maxSize, int skip)` Split this `Flux` sequence into multiple `Flux` windows of size `maxSize`, that each open every `skip` elements in the source.
`Flux<Flux<T>>`	`window(Publisher<?> boundary)` Split this `Flux` sequence into continuous, non-overlapping windows where the window boundary is signalled by another `Publisher`
`Flux<Flux<T>>`	`windowTimeout(int maxSize, Duration maxTime)` Split this `Flux` sequence into multiple `Flux` windows containing `maxSize` elements (or less for the final window) and starting from the first item.
`Flux<Flux<T>>`	`windowTimeout(int maxSize, Duration maxTime, Scheduler timer)` Split this `Flux` sequence into multiple `Flux` windows containing `maxSize` elements (or less for the final window) and starting from the first item.
`Flux<Flux<T>>`	`windowUntil(Predicate<T> boundaryTrigger)` Split this `Flux` sequence into multiple `Flux` windows delimited by the given predicate.
`Flux<Flux<T>>`	`windowUntil(Predicate<T> boundaryTrigger, boolean cutBefore)` Split this `Flux` sequence into multiple `Flux` windows delimited by the given predicate.
`Flux<Flux<T>>`	`windowUntil(Predicate<T> boundaryTrigger, boolean cutBefore, int prefetch)` Split this `Flux` sequence into multiple `Flux` windows delimited by the given predicate and using a prefetch.
`<U,V> Flux<Flux<T>>`	`windowWhen(Publisher<U> bucketOpening, Function<? super U,? extends Publisher<V>> closeSelector)` Split this `Flux` sequence into potentially overlapping windows controlled by items of a start `Publisher` and end `Publisher` derived from the start values.
`Flux<Flux<T>>`	`windowWhile(Predicate<T> inclusionPredicate)` Split this `Flux` sequence into multiple `Flux` windows that stay open while a given predicate matches the source elements.
`Flux<Flux<T>>`	`windowWhile(Predicate<T> inclusionPredicate, int prefetch)` Split this `Flux` sequence into multiple `Flux` windows that stay open while a given predicate matches the source elements.
`<U,R> Flux<R>`	`withLatestFrom(Publisher<? extends U> other, BiFunction<? super T,? super U,? extends R> resultSelector)` Combine the most recently emitted values from both this `Flux` and another `Publisher` through a `BiFunction` and emits the result.
`static <I,O> Flux<O>`	`zip(Function<? super Object[],? extends O> combinator, int prefetch, Publisher<? extends I>... sources)` Zip multiple sources together, that is to say wait for all the sources to emit one element and combine these elements once into an output value (constructed by the provided combinator).
`static <I,O> Flux<O>`	`zip(Function<? super Object[],? extends O> combinator, Publisher<? extends I>... sources)` Zip multiple sources together, that is to say wait for all the sources to emit one element and combine these elements once into an output value (constructed by the provided combinator).
`static <O> Flux<O>`	`zip(Iterable<? extends Publisher<?>> sources, Function<? super Object[],? extends O> combinator)` Zip multiple sources together, that is to say wait for all the sources to emit one element and combine these elements once into an output value (constructed by the provided combinator).
`static <O> Flux<O>`	`zip(Iterable<? extends Publisher<?>> sources, int prefetch, Function<? super Object[],? extends O> combinator)` Zip multiple sources together, that is to say wait for all the sources to emit one element and combine these elements once into an output value (constructed by the provided combinator).
`static <TUPLE extends Tuple2,V> Flux<V>`	`zip(Publisher<? extends Publisher<?>> sources, Function<? super TUPLE,? extends V> combinator)` Zip multiple sources together, that is to say wait for all the sources to emit one element and combine these elements once into an output value (constructed by the provided combinator).
`static <T1,T2> Flux<Tuple2<T1,T2>>`	`zip(Publisher<? extends T1> source1, Publisher<? extends T2> source2)` Zip two sources together, that is to say wait for all the sources to emit one element and combine these elements once into a `Tuple2`.
`static <T1,T2,O> Flux<O>`	`zip(Publisher<? extends T1> source1, Publisher<? extends T2> source2, BiFunction<? super T1,? super T2,? extends O> combinator)` Zip two sources together, that is to say wait for all the sources to emit one element and combine these elements once into an output value (constructed by the provided combinator).
`static <T1,T2,T3> Flux<Tuple3<T1,T2,T3>>`	`zip(Publisher<? extends T1> source1, Publisher<? extends T2> source2, Publisher<? extends T3> source3)` Zip three sources together, that is to say wait for all the sources to emit one element and combine these elements once into a `Tuple3`.
`static <T1,T2,T3,T4> Flux<Tuple4<T1,T2,T3,T4>>`	`zip(Publisher<? extends T1> source1, Publisher<? extends T2> source2, Publisher<? extends T3> source3, Publisher<? extends T4> source4)` Zip four sources together, that is to say wait for all the sources to emit one element and combine these elements once into a `Tuple4`.
`static <T1,T2,T3,T4,T5> Flux<Tuple5<T1,T2,T3,T4,T5>>`	`zip(Publisher<? extends T1> source1, Publisher<? extends T2> source2, Publisher<? extends T3> source3, Publisher<? extends T4> source4, Publisher<? extends T5> source5)` Zip five sources together, that is to say wait for all the sources to emit one element and combine these elements once into a `Tuple5`.
`static <T1,T2,T3,T4,T5,T6> Flux<Tuple6<T1,T2,T3,T4,T5,T6>>`	`zip(Publisher<? extends T1> source1, Publisher<? extends T2> source2, Publisher<? extends T3> source3, Publisher<? extends T4> source4, Publisher<? extends T5> source5, Publisher<? extends T6> source6)` Zip six sources together, that is to say wait for all the sources to emit one element and combine these elements once into a `Tuple6`.
`static <T1,T2,T3,T4,T5,T6,T7> Flux<Tuple7<T1,T2,T3,T4,T5,T6,T7>>`	`zip(Publisher<? extends T1> source1, Publisher<? extends T2> source2, Publisher<? extends T3> source3, Publisher<? extends T4> source4, Publisher<? extends T5> source5, Publisher<? extends T6> source6, Publisher<? extends T7> source7)` Zip seven sources together, that is to say wait for all the sources to emit one element and combine these elements once into a `Tuple7`.
`static <T1,T2,T3,T4,T5,T6,T7,T8> Flux<Tuple8<T1,T2,T3,T4,T5,T6,T7,T8>>`	`zip(Publisher<? extends T1> source1, Publisher<? extends T2> source2, Publisher<? extends T3> source3, Publisher<? extends T4> source4, Publisher<? extends T5> source5, Publisher<? extends T6> source6, Publisher<? extends T7> source7, Publisher<? extends T8> source8)` Zip eight sources together, that is to say wait for all the sources to emit one element and combine these elements once into a `Tuple8`.
`<T2> Flux<Tuple2<T,T2>>`	`zipWith(Publisher<? extends T2> source2)` Zip this `Flux` with another `Publisher` source, that is to say wait for both to emit one element and combine these elements once into a `Tuple2`.
`<T2,V> Flux<V>`	`zipWith(Publisher<? extends T2> source2, BiFunction<? super T,? super T2,? extends V> combinator)` Zip this `Flux` with another `Publisher` source, that is to say wait for both to emit one element and combine these elements using a `combinator` `BiFunction` The operator will continue doing so until any of the sources completes.
`<T2> Flux<Tuple2<T,T2>>`	`zipWith(Publisher<? extends T2> source2, int prefetch)` Zip this `Flux` with another `Publisher` source, that is to say wait for both to emit one element and combine these elements once into a `Tuple2`.
`<T2,V> Flux<V>`	`zipWith(Publisher<? extends T2> source2, int prefetch, BiFunction<? super T,? super T2,? extends V> combinator)` Zip this `Flux` with another `Publisher` source, that is to say wait for both to emit one element and combine these elements using a `combinator` `BiFunction` The operator will continue doing so until any of the sources completes.
`<T2> Flux<Tuple2<T,T2>>`	`zipWithIterable(Iterable<? extends T2> iterable)` Zip elements from this `Flux` with the content of an `Iterable`, that is to say combine one element from each, pairwise, into a `Tuple2`.
`<T2,V> Flux<V>`	`zipWithIterable(Iterable<? extends T2> iterable, BiFunction<? super T,? super T2,? extends V> zipper)` Zip elements from this `Flux` with the content of an `Iterable`, that is to say combine one element from each, pairwise, using the given zipper `BiFunction`.

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

- Constructor Detail
 - Flux
```
public Flux()
```
- Method Detail
 - combineLatest
```
@SafeVarargs
public static <T,V> Flux<V> combineLatest(Function<Object[],V> combinator,
 Publisher<? extends T>... sources)
```
 Build a Flux whose data are generated by the combination of the most recently published value from each of the Publisher sources.
 
 Type Parameters:
 
 T - type of the value from sources
 
 V - The produced output after transformation by the given combinator
 
 Parameters:
 
 sources - The Publisher sources to combine values from
 
 combinator - The aggregate function that will receive the latest value from each upstream and return the value to signal downstream
 
 Returns:
 
 a Flux based on the produced combinations
 
 onDiscard Support
 
 This operator is NOT suited for types that need guaranteed discard of unpropagated elements, as it doesn't track which elements have been used by the combinator and which haven't. Furthermore, elements can and will be passed to the combinator multiple times.
 - combineLatest
```
@SafeVarargs
public static <T,V> Flux<V> combineLatest(Function<Object[],V> combinator,
 int prefetch,
 Publisher<? extends T>... sources)
```
 Build a Flux whose data are generated by the combination of the most recently published value from each of the Publisher sources.
 
 Type Parameters:
 
 T - type of the value from sources
 
 V - The produced output after transformation by the given combinator
 
 Parameters:
 
 sources - The Publisher sources to combine values from
 
 prefetch - The demand sent to each combined source Publisher
 
 combinator - The aggregate function that will receive the latest value from each upstream and return the value to signal downstream
 
 Returns:
 
 a Flux based on the produced combinations
 
 onDiscard Support
 
 This operator is NOT suited for types that need guaranteed discard of unpropagated elements, as it doesn't track which elements have been used by the combinator and which haven't. Furthermore, elements can and will be passed to the combinator multiple times.
 - combineLatest
```
public static <T1,T2,V> Flux<V> combineLatest(Publisher<? extends T1> source1,
 Publisher<? extends T2> source2,
 BiFunction<? super T1,? super T2,? extends V> combinator)
```
 Build a Flux whose data are generated by the combination of the most recently published value from each of two Publisher sources.
 
 Type Parameters:
 
 T1 - type of the value from source1
 
 T2 - type of the value from source2
 
 V - The produced output after transformation by the given combinator
 
 Parameters:
 
 source1 - The first Publisher source to combine values from
 
 source2 - The second Publisher source to combine values from
 
 combinator - The aggregate function that will receive the latest value from each upstream and return the value to signal downstream
 
 Returns:
 
 a Flux based on the produced combinations
 
 onDiscard Support
 
 This operator is NOT suited for types that need guaranteed discard of unpropagated elements, as it doesn't track which elements have been used by the combinator and which haven't. Furthermore, elements can and will be passed to the combinator multiple times.
 - combineLatest
```
public static <T1,T2,T3,V> Flux<V> combineLatest(Publisher<? extends T1> source1,
 Publisher<? extends T2> source2,
 Publisher<? extends T3> source3,
 Function<Object[],V> combinator)
```
 Build a Flux whose data are generated by the combination of the most recently published value from each of three Publisher sources.
 
 Type Parameters:
 
 T1 - type of the value from source1
 
 T2 - type of the value from source2
 
 T3 - type of the value from source3
 
 V - The produced output after transformation by the given combinator
 
 Parameters:
 
 source1 - The first Publisher source to combine values from
 
 source2 - The second Publisher source to combine values from
 
 source3 - The third Publisher source to combine values from
 
 combinator - The aggregate function that will receive the latest value from each upstream and return the value to signal downstream
 
 Returns:
 
 a Flux based on the produced combinations
 
 onDiscard Support
 
 This operator is NOT suited for types that need guaranteed discard of unpropagated elements, as it doesn't track which elements have been used by the combinator and which haven't. Furthermore, elements can and will be passed to the combinator multiple times.
 - combineLatest
```
public static <T1,T2,T3,T4,V> Flux<V> combineLatest(Publisher<? extends T1> source1,
 Publisher<? extends T2> source2,
 Publisher<? extends T3> source3,
 Publisher<? extends T4> source4,
 Function<Object[],V> combinator)
```
 Build a Flux whose data are generated by the combination of the most recently published value from each of four Publisher sources.
 
 Type Parameters:
 
 T1 - type of the value from source1
 
 T2 - type of the value from source2
 
 T3 - type of the value from source3
 
 T4 - type of the value from source4
 
 V - The produced output after transformation by the given combinator
 
 Parameters:
 
 source1 - The first Publisher source to combine values from
 
 source2 - The second Publisher source to combine values from
 
 source3 - The third Publisher source to combine values from
 
 source4 - The fourth Publisher source to combine values from
 
 combinator - The aggregate function that will receive the latest value from each upstream and return the value to signal downstream
 
 Returns:
 
 a Flux based on the produced combinations
 
 onDiscard Support
 
 This operator is NOT suited for types that need guaranteed discard of unpropagated elements, as it doesn't track which elements have been used by the combinator and which haven't. Furthermore, elements can and will be passed to the combinator multiple times.
 - combineLatest
```
public static <T1,T2,T3,T4,T5,V> Flux<V> combineLatest(Publisher<? extends T1> source1,
 Publisher<? extends T2> source2,
 Publisher<? extends T3> source3,
 Publisher<? extends T4> source4,
 Publisher<? extends T5> source5,
 Function<Object[],V> combinator)
```
 Build a Flux whose data are generated by the combination of the most recently published value from each of five Publisher sources.
 
 Type Parameters:
 
 T1 - type of the value from source1
 
 T2 - type of the value from source2
 
 T3 - type of the value from source3
 
 T4 - type of the value from source4
 
 T5 - type of the value from source5
 
 V - The produced output after transformation by the given combinator
 
 Parameters:
 
 source1 - The first Publisher source to combine values from
 
 source2 - The second Publisher source to combine values from
 
 source3 - The third Publisher source to combine values from
 
 source4 - The fourth Publisher source to combine values from
 
 source5 - The fifth Publisher source to combine values from
 
 combinator - The aggregate function that will receive the latest value from each upstream and return the value to signal downstream
 
 Returns:
 
 a Flux based on the produced combinations
 
 onDiscard Support
 
 This operator is NOT suited for types that need guaranteed discard of unpropagated elements, as it doesn't track which elements have been used by the combinator and which haven't. Furthermore, elements can and will be passed to the combinator multiple times.
 - combineLatest
```
public static <T1,T2,T3,T4,T5,T6,V> Flux<V> combineLatest(Publisher<? extends T1> source1,
 Publisher<? extends T2> source2,
 Publisher<? extends T3> source3,
 Publisher<? extends T4> source4,
 Publisher<? extends T5> source5,
 Publisher<? extends T6> source6,
 Function<Object[],V> combinator)
```
 Build a Flux whose data are generated by the combination of the most recently published value from each of six Publisher sources.
 
 Type Parameters:
 
 T1 - type of the value from source1
 
 T2 - type of the value from source2
 
 T3 - type of the value from source3
 
 T4 - type of the value from source4
 
 T5 - type of the value from source5
 
 T6 - type of the value from source6
 
 V - The produced output after transformation by the given combinator
 
 Parameters:
 
 source1 - The first Publisher source to combine values from
 
 source2 - The second Publisher source to combine values from
 
 source3 - The third Publisher source to combine values from
 
 source4 - The fourth Publisher source to combine values from
 
 source5 - The fifth Publisher source to combine values from
 
 source6 - The sixth Publisher source to combine values from
 
 combinator - The aggregate function that will receive the latest value from each upstream and return the value to signal downstream
 
 Returns:
 
 a Flux based on the produced combinations
 
 onDiscard Support
 
 This operator is NOT suited for types that need guaranteed discard of unpropagated elements, as it doesn't track which elements have been used by the combinator and which haven't. Furthermore, elements can and will be passed to the combinator multiple times.
 - combineLatest
```
public static <T,V> Flux<V> combineLatest(Iterable<? extends Publisher<? extends T>> sources,
 Function<Object[],V> combinator)
```
 Build a Flux whose data are generated by the combination of the most recently published value from each of the Publisher sources provided in an Iterable.
 
 Type Parameters:
 
 T - The common base type of the values from sources
 
 V - The produced output after transformation by the given combinator
 
 Parameters:
 
 sources - The list of Publisher sources to combine values from
 
 combinator - The aggregate function that will receive the latest value from each upstream and return the value to signal downstream
 
 Returns:
 
 a Flux based on the produced combinations
 
 onDiscard Support
 
 This operator is NOT suited for types that need guaranteed discard of unpropagated elements, as it doesn't track which elements have been used by the combinator and which haven't. Furthermore, elements can and will be passed to the combinator multiple times.
 - combineLatest
```
public static <T,V> Flux<V> combineLatest(Iterable<? extends Publisher<? extends T>> sources,
 int prefetch,
 Function<Object[],V> combinator)
```
 Build a Flux whose data are generated by the combination of the most recently published value from each of the Publisher sources provided in an Iterable.
 
 Type Parameters:
 
 T - The common base type of the values from sources
 
 V - The produced output after transformation by the given combinator
 
 Parameters:
 
 sources - The list of Publisher sources to combine values from
 
 prefetch - demand produced to each combined source Publisher
 
 combinator - The aggregate function that will receive the latest value from each upstream and return the value to signal downstream
 
 Returns:
 
 a Flux based on the produced combinations
 
 onDiscard Support
 
 This operator is NOT suited for types that need guaranteed discard of unpropagated elements, as it doesn't track which elements have been used by the combinator and which haven't. Furthermore, elements can and will be passed to the combinator multiple times.
 - concat
```
public static <T> Flux<T> concat(Iterable<? extends Publisher<? extends T>> sources)
```
 Concatenate all sources provided in an Iterable, forwarding elements emitted by the sources downstream.
 Concatenation is achieved by sequentially subscribing to the first source then waiting for it to complete before subscribing to the next, and so on until the last source completes. Any error interrupts the sequence immediately and is forwarded downstream.
 
 Type Parameters:
 
 T - The type of values in both source and output sequences
 
 Parameters:
 
 sources - The Iterable of Publisher to concatenate
 
 Returns:
 
 a new Flux concatenating all source sequences
 - concatWithValues
```
@SafeVarargs
public final Flux<T> concatWithValues(T... values)
```
 Concatenates the values to the end of the Flux
 
 Parameters:
 
 values - The values to concatenate
 
 Returns:
 
 a new Flux concatenating all source sequences
 - concat
```
public static <T> Flux<T> concat(Publisher<? extends Publisher<? extends T>> sources)
```
 Concatenate all sources emitted as an onNext signal from a parent Publisher, forwarding elements emitted by the sources downstream.
 Concatenation is achieved by sequentially subscribing to the first source then waiting for it to complete before subscribing to the next, and so on until the last source completes. Any error interrupts the sequence immediately and is forwarded downstream.
 
 Type Parameters:
 
 T - The type of values in both source and output sequences
 
 Parameters:
 
 sources - The Publisher of Publisher to concatenate
 
 Returns:
 
 a new Flux concatenating all inner sources sequences
 
 onDiscard Support
 
 This operator discards elements it internally queued for backpressure upon cancellation.
 - concat
```
public static <T> Flux<T> concat(Publisher<? extends Publisher<? extends T>> sources,
 int prefetch)
```
 Concatenate all sources emitted as an onNext signal from a parent Publisher, forwarding elements emitted by the sources downstream.
 Concatenation is achieved by sequentially subscribing to the first source then waiting for it to complete before subscribing to the next, and so on until the last source completes. Any error interrupts the sequence immediately and is forwarded downstream.
 
 Type Parameters:
 
 T - The type of values in both source and output sequences
 
 Parameters:
 
 sources - The Publisher of Publisher to concatenate
 
 prefetch - the inner source request size
 
 Returns:
 
 a new Flux concatenating all inner sources sequences
 
 onDiscard Support
 
 This operator discards elements it internally queued for backpressure upon cancellation.
 - concat
```
@SafeVarargs
public static <T> Flux<T> concat(Publisher<? extends T>... sources)
```
 Concatenate all sources provided as a vararg, forwarding elements emitted by the sources downstream.
 Concatenation is achieved by sequentially subscribing to the first source then waiting for it to complete before subscribing to the next, and so on until the last source completes. Any error interrupts the sequence immediately and is forwarded downstream.
 
 Type Parameters:
 
 T - The type of values in both source and output sequences
 
 Parameters:
 
 sources - The Publisher of Publisher to concat
 
 Returns:
 
 a new Flux concatenating all source sequences
 - concatDelayError
```
public static <T> Flux<T> concatDelayError(Publisher<? extends Publisher<? extends T>> sources)
```
 Concatenate all sources emitted as an onNext signal from a parent Publisher, forwarding elements emitted by the sources downstream.
 Concatenation is achieved by sequentially subscribing to the first source then waiting for it to complete before subscribing to the next, and so on until the last source completes. Errors do not interrupt the main sequence but are propagated after the rest of the sources have had a chance to be concatenated.
 
 Type Parameters:
 
 T - The type of values in both source and output sequences
 
 Parameters:
 
 sources - The Publisher of Publisher to concatenate
 
 Returns:
 
 a new Flux concatenating all inner sources sequences, delaying errors
 
 onDiscard Support
 
 This operator discards elements it internally queued for backpressure upon cancellation.
 - concatDelayError
```
public static <T> Flux<T> concatDelayError(Publisher<? extends Publisher<? extends T>> sources,
 int prefetch)
```
 Concatenate all sources emitted as an onNext signal from a parent Publisher, forwarding elements emitted by the sources downstream.
 Concatenation is achieved by sequentially subscribing to the first source then waiting for it to complete before subscribing to the next, and so on until the last source completes. Errors do not interrupt the main sequence but are propagated after the rest of the sources have had a chance to be concatenated.
 
 Type Parameters:
 
 T - The type of values in both source and output sequences
 
 Parameters:
 
 sources - The Publisher of Publisher to concatenate
 
 prefetch - the inner source request size
 
 Returns:
 
 a new Flux concatenating all inner sources sequences until complete or error
 
 onDiscard Support
 
 This operator discards elements it internally queued for backpressure upon cancellation.
 - concatDelayError
```
public static <T> Flux<T> concatDelayError(Publisher<? extends Publisher<? extends T>> sources,
 boolean delayUntilEnd,
 int prefetch)
```
 Concatenate all sources emitted as an onNext signal from a parent Publisher, forwarding elements emitted by the sources downstream.
 Concatenation is achieved by sequentially subscribing to the first source then waiting for it to complete before subscribing to the next, and so on until the last source completes.
 Errors do not interrupt the main sequence but are propagated after the current concat backlog if delayUntilEnd is false or after all sources have had a chance to be concatenated if delayUntilEnd is true.
 
 Type Parameters:
 
 T - The type of values in both source and output sequences
 
 Parameters:
 
 sources - The Publisher of Publisher to concatenate
 
 delayUntilEnd - delay error until all sources have been consumed instead of after the current source
 
 prefetch - the inner source request size
 
 Returns:
 
 a new Flux concatenating all inner sources sequences until complete or error
 
 onDiscard Support
 
 This operator discards elements it internally queued for backpressure upon cancellation.
 - concatDelayError
```
@SafeVarargs
public static <T> Flux<T> concatDelayError(Publisher<? extends T>... sources)
```
 Concatenate all sources provided as a vararg, forwarding elements emitted by the sources downstream.
 Concatenation is achieved by sequentially subscribing to the first source then waiting for it to complete before subscribing to the next, and so on until the last source completes. Errors do not interrupt the main sequence but are propagated after the rest of the sources have had a chance to be concatenated.
 
 Type Parameters:
 
 T - The type of values in both source and output sequences
 
 Parameters:
 
 sources - The Publisher of Publisher to concat
 
 Returns:
 
 a new Flux concatenating all source sequences
 
 onDiscard Support
 
 This operator discards elements it internally queued for backpressure upon cancellation.
 - create
```
public static <T> Flux<T> create(Consumer<? super FluxSink<T>> emitter)
```
 Programmatically create a Flux with the capability of emitting multiple elements in a synchronous or asynchronous manner through the FluxSink API. This includes emitting elements from multiple threads.
 This Flux factory is useful if one wants to adapt some other multi-valued async API and not worry about cancellation and backpressure (which is handled by buffering all signals if the downstream can't keep up).
 For example:
```
 Flux.<String>create(emitter -> {

 ActionListener al = e -> {
 emitter.next(textField.getText());
 };
 // without cleanup support:

 button.addActionListener(al);

 // with cleanup support:

 button.addActionListener(al);
 emitter.onDispose(() -> {
 button.removeListener(al);
 });
 });
 
```
 Type Parameters:
 
 T - The type of values in the sequence
 
 Parameters:
 
 emitter - Consume the FluxSink provided per-subscriber by Reactor to generate signals.
 
 Returns:
 
 a Flux
 
 See Also:
 
 push(Consumer)
 
 onDiscard Support
 
 The FluxSink exposed by this operator buffers in case of overflow. The buffer is discarded when the main sequence is cancelled.
 - create
```
public static <T> Flux<T> create(Consumer<? super FluxSink<T>> emitter,
 FluxSink.OverflowStrategy backpressure)
```
 Programmatically create a Flux with the capability of emitting multiple elements in a synchronous or asynchronous manner through the FluxSink API. This includes emitting elements from multiple threads.
 This Flux factory is useful if one wants to adapt some other multi-valued async API and not worry about cancellation and backpressure (which is handled by buffering all signals if the downstream can't keep up).
 For example:
```
 Flux.<String>create(emitter -> {

 ActionListener al = e -> {
 emitter.next(textField.getText());
 };
 // without cleanup support:

 button.addActionListener(al);

 // with cleanup support:

 button.addActionListener(al);
 emitter.onDispose(() -> {
 button.removeListener(al);
 });
 }, FluxSink.OverflowStrategy.LATEST);
 
```
 Type Parameters:
 
 T - The type of values in the sequence
 
 Parameters:
 
 backpressure - the backpressure mode, see FluxSink.OverflowStrategy for the available backpressure modes
 
 emitter - Consume the FluxSink provided per-subscriber by Reactor to generate signals.
 
 Returns:
 
 a Flux
 
 See Also:
 
 #push(Consumer, OverflowStrategy)
 
 onDiscard Support
 
 The FluxSink exposed by this operator discards elements as relevant to the chosen FluxSink.OverflowStrategy. For example, the FluxSink.OverflowStrategy.DROP discards each items as they are being dropped, while FluxSink.OverflowStrategy.BUFFER will discard the buffer upon cancellation.
 - push
```
public static <T> Flux<T> push(Consumer<? super FluxSink<T>> emitter)
```
 Programmatically create a Flux with the capability of emitting multiple elements from a single-threaded producer through the FluxSink API. For a multi-threaded capable alternative, see create(Consumer).
 This Flux factory is useful if one wants to adapt some other single-threaded multi-valued async API and not worry about cancellation and backpressure (which is handled by buffering all signals if the downstream can't keep up).
 For example:
```
 Flux.<String>push(emitter -> {

 ActionListener al = e -> {
 emitter.next(textField.getText());
 };
 // without cleanup support:

 button.addActionListener(al);

 // with cleanup support:

 button.addActionListener(al);
 emitter.onDispose(() -> {
 button.removeListener(al);
 });
 }, FluxSink.OverflowStrategy.LATEST);
 
```
 Type Parameters:
 
 T - The type of values in the sequence
 
 Parameters:
 
 emitter - Consume the FluxSink provided per-subscriber by Reactor to generate signals.
 
 Returns:
 
 a Flux
 
 See Also:
 
 create(Consumer)
 
 onDiscard Support
 
 The FluxSink exposed by this operator buffers in case of overflow. The buffer is discarded when the main sequence is cancelled.
 - push
```
public static <T> Flux<T> push(Consumer<? super FluxSink<T>> emitter,
 FluxSink.OverflowStrategy backpressure)
```
 Programmatically create a Flux with the capability of emitting multiple elements from a single-threaded producer through the FluxSink API. For a multi-threaded capable alternative, see #create(Consumer, OverflowStrategy).
 This Flux factory is useful if one wants to adapt some other single-threaded multi-valued async API and not worry about cancellation and backpressure (which is handled by buffering all signals if the downstream can't keep up).
 For example:
```
 Flux.<String>push(emitter -> {

 ActionListener al = e -> {
 emitter.next(textField.getText());
 };
 // without cleanup support:

 button.addActionListener(al);

 // with cleanup support:

 button.addActionListener(al);
 emitter.onDispose(() -> {
 button.removeListener(al);
 });
 }, FluxSink.OverflowStrategy.LATEST);
 
```
 Type Parameters:
 
 T - The type of values in the sequence
 
 Parameters:
 
 backpressure - the backpressure mode, see FluxSink.OverflowStrategy for the available backpressure modes
 
 emitter - Consume the FluxSink provided per-subscriber by Reactor to generate signals.
 
 Returns:
 
 a Flux
 
 See Also:
 
 #create(Consumer, OverflowStrategy)
 
 onDiscard Support
 
 The FluxSink exposed by this operator discards elements as relevant to the chosen FluxSink.OverflowStrategy. For example, the FluxSink.OverflowStrategy.DROP discards each items as they are being dropped, while FluxSink.OverflowStrategy.BUFFER will discard the buffer upon cancellation.
 - defer
```
public static <T> Flux<T> defer(Supplier<? extends Publisher<T>> supplier)
```
 Lazily supply a Publisher every time a Subscription is made on the resulting Flux, so the actual source instantiation is deferred until each subscribe and the Supplier can create a subscriber-specific instance. If the supplier doesn't generate a new instance however, this operator will effectively behave like from(Publisher).
 
 Type Parameters:
 
 T - the type of values passing through the Flux
 
 Parameters:
 
 supplier - the Publisher Supplier to call on subscribe
 
 Returns:
 
 a deferred Flux
 - empty
```
public static <T> Flux<T> empty()
```
 Create a Flux that completes without emitting any item.
 
 Type Parameters:
 
 T - the reified type of the target Subscriber
 
 Returns:
 
 an empty Flux
 - error
```
public static <T> Flux<T> error(Throwable error)
```
 Create a Flux that terminates with the specified error immediately after being subscribed to.
 
 Type Parameters:
 
 T - the reified type of the target Subscriber
 
 Parameters:
 
 error - the error to signal to each Subscriber
 
 Returns:
 
 a new failing Flux
 - error
```
public static <T> Flux<T> error(Supplier<Throwable> errorSupplier)
```
 Create a Flux that terminates with an error immediately after being subscribed to. The Throwable is generated by a Supplier, invoked each time there is a subscription and allowing for lazy instantiation.
 
 Type Parameters:
 
 T - the reified type of the target Subscriber
 
 Parameters:
 
 errorSupplier - the error signal Supplier to invoke for each Subscriber
 
 Returns:
 
 a new failing Flux
 - error
```
public static <O> Flux<O> error(Throwable throwable,
 boolean whenRequested)
```
 Create a Flux that terminates with the specified error, either immediately after being subscribed to or after being first requested.
 
 Type Parameters:
 
 O - the reified type of the target Subscriber
 
 Parameters:
 
 throwable - the error to signal to each Subscriber
 
 whenRequested - if true, will onError on the first request instead of subscribe().
 
 Returns:
 
 a new failing Flux
 - first
```
@SafeVarargs
public static  Flux first(Publisher<? extends I>... sources)
```
 Pick the first Publisher to emit any signal (onNext/onError/onComplete) and replay all signals from that Publisher, effectively behaving like the fastest of these competing sources.
 
 Type Parameters:
 
 I - The type of values in both source and output sequences
 
 Parameters:
 
 sources - The competing source publishers
 
 Returns:
 
 a new Flux behaving like the fastest of its sources
 - first
```
public static  Flux first(Iterable<? extends Publisher<? extends I>> sources)
```
 Pick the first Publisher to emit any signal (onNext/onError/onComplete) and replay all signals from that Publisher, effectively behaving like the fastest of these competing sources.
 
 Type Parameters:
 
 I - The type of values in both source and output sequences
 
 Parameters:
 
 sources - The competing source publishers
 
 Returns:
 
 a new Flux behaving like the fastest of its sources
 - from
```
public static <T> Flux<T> from(Publisher<? extends T> source)
```
 Decorate the specified Publisher with the Flux API.
 
 Type Parameters:
 
 T - The type of values in both source and output sequences
 
 Parameters:
 
 source - the source to decorate
 
 Returns:
 
 a new Flux
 - fromArray
```
public static <T> Flux<T> fromArray(T[] array)
```
 Create a Flux that emits the items contained in the provided array.
 
 Type Parameters:
 
 T - The type of values in the source array and resulting Flux
 
 Parameters:
 
 array - the array to read data from
 
 Returns:
 
 a new Flux
 - fromIterable
```
public static <T> Flux<T> fromIterable(Iterable<? extends T> it)
```
 Create a Flux that emits the items contained in the provided Iterable. A new iterator will be created for each subscriber.
 
 Type Parameters:
 
 T - The type of values in the source Iterable and resulting Flux
 
 Parameters:
 
 it - the Iterable to read data from
 
 Returns:
 
 a new Flux
 - fromStream
```
public static <T> Flux<T> fromStream(Stream<? extends T> s)
```
 Create a Flux that emits the items contained in the provided Stream. Keep in mind that a Stream cannot be re-used, which can be problematic in case of multiple subscriptions or re-subscription (like with repeat() or retry()). The Stream is closed automatically by the operator on cancellation, error or completion.
 
 Type Parameters:
 
 T - The type of values in the source Stream and resulting Flux
 
 Parameters:
 
 s - the Stream to read data from
 
 Returns:
 
 a new Flux
 - fromStream
```
public static <T> Flux<T> fromStream(Supplier<Stream<? extends T>> streamSupplier)
```
 Create a Flux that emits the items contained in a Stream created by the provided Supplier for each subscription. The Stream is closed automatically by the operator on cancellation, error or completion.
 
 Type Parameters:
 
 T - The type of values in the source Stream and resulting Flux
 
 Parameters:
 
 streamSupplier - the Supplier that generates the Stream from which to read data
 
 Returns:
 
 a new Flux
 - generate
```
public static <T> Flux<T> generate(Consumer<SynchronousSink<T>> generator)
```
 Programmatically create a Flux by generating signals one-by-one via a consumer callback.
 
 Type Parameters:
 
 T - the value type emitted
 
 Parameters:
 
 generator - Consume the SynchronousSink provided per-subscriber by Reactor to generate a single signal on each pass.
 
 Returns:
 
 a Flux
 - generate
```
public static <T,S> Flux<T> generate(Callable<S> stateSupplier,
 BiFunction<S,SynchronousSink<T>,S> generator)
```
 Programmatically create a Flux by generating signals one-by-one via a consumer callback and some state. The stateSupplier may return null.
 
 Type Parameters:
 
 T - the value type emitted
 
 S - the per-subscriber custom state type
 
 Parameters:
 
 stateSupplier - called for each incoming Subscriber to provide the initial state for the generator bifunction
 
 generator - Consume the SynchronousSink provided per-subscriber by Reactor as well as the current state to generate a single signal on each pass and return a (new) state.
 
 Returns:
 
 a Flux
 - generate
```
public static <T,S> Flux<T> generate(Callable<S> stateSupplier,
 BiFunction<S,SynchronousSink<T>,S> generator,
 Consumer<? super S> stateConsumer)
```
 Programmatically create a Flux by generating signals one-by-one via a consumer callback and some state, with a final cleanup callback. The stateSupplier may return null but your cleanup stateConsumer will need to handle the null case.
 
 Type Parameters:
 
 T - the value type emitted
 
 S - the per-subscriber custom state type
 
 Parameters:
 
 stateSupplier - called for each incoming Subscriber to provide the initial state for the generator bifunction
 
 generator - Consume the SynchronousSink provided per-subscriber by Reactor as well as the current state to generate a single signal on each pass and return a (new) state.
 
 stateConsumer - called after the generator has terminated or the downstream cancelled, receiving the last state to be handled (i.e., release resources or do other cleanup).
 
 Returns:
 
 a Flux
 - interval
```
public static Flux<Long> interval(Duration period)
```
 Create a Flux that emits long values starting with 0 and incrementing at specified time intervals on the global timer. If demand is not produced in time, an onError will be signalled with an overflow IllegalStateException detailing the tick that couldn't be emitted. In normal conditions, the Flux will never complete.
 Runs on the Schedulers.parallel() Scheduler.
 
 Parameters:
 
 period - the period Duration between each increment
 
 Returns:
 
 a new Flux emitting increasing numbers at regular intervals
 - interval
```
public static Flux<Long> interval(Duration delay,
 Duration period)
```
 Create a Flux that emits long values starting with 0 and incrementing at specified time intervals, after an initial delay, on the global timer. If demand is not produced in time, an onError will be signalled with an overflow IllegalStateException detailing the tick that couldn't be emitted. In normal conditions, the Flux will never complete.
 Runs on the Schedulers.parallel() Scheduler.
 
 Parameters:
 
 delay - the Duration to wait before emitting 0l
 
 period - the period Duration before each following increment
 
 Returns:
 
 a new Flux emitting increasing numbers at regular intervals
 - interval
```
public static Flux<Long> interval(Duration period,
 Scheduler timer)
```
 Create a Flux that emits long values starting with 0 and incrementing at specified time intervals, on the specified Scheduler. If demand is not produced in time, an onError will be signalled with an overflow IllegalStateException detailing the tick that couldn't be emitted. In normal conditions, the Flux will never complete.
 
 Parameters:
 
 period - the period Duration between each increment
 
 timer - a time-capable Scheduler instance to run on
 
 Returns:
 
 a new Flux emitting increasing numbers at regular intervals
 - interval
```
public static Flux<Long> interval(Duration delay,
 Duration period,
 Scheduler timer)
```
 Create a Flux that emits long values starting with 0 and incrementing at specified time intervals, after an initial delay, on the specified Scheduler. If demand is not produced in time, an onError will be signalled with an overflow IllegalStateException detailing the tick that couldn't be emitted. In normal conditions, the Flux will never complete.
 
 Parameters:
 
 delay - the Duration to wait before emitting 0l
 
 period - the period Duration before each following increment
 
 timer - a time-capable Scheduler instance to run on
 
 Returns:
 
 a new Flux emitting increasing numbers at regular intervals
 - just
```
@SafeVarargs
public static <T> Flux<T> just(T... data)
```
 Create a Flux that emits the provided elements and then completes.
 
 Type Parameters:
 
 T - the emitted data type
 
 Parameters:
 
 data - the elements to emit, as a vararg
 
 Returns:
 
 a new Flux
 - just
```
public static <T> Flux<T> just(T data)
```
 Create a new Flux that will only emit a single element then onComplete.
 
 Type Parameters:
 
 T - the emitted data type
 
 Parameters:
 
 data - the single element to emit
 
 Returns:
 
 a new Flux
 - merge
```
public static <T> Flux<T> merge(Publisher<? extends Publisher<? extends T>> source)
```
 Merge data from Publisher sequences emitted by the passed Publisher into an interleaved merged sequence. Unlike concat, inner sources are subscribed to eagerly.
 
 Note that merge is tailored to work with asynchronous sources or finite sources. When dealing with an infinite source that doesn't already publish on a dedicated Scheduler, you must isolate that source in its own Scheduler, as merge would otherwise attempt to drain it before subscribing to another source.
 
 Type Parameters:
 
 T - the merged type
 
 Parameters:
 
 source - a Publisher of Publisher sources to merge
 
 Returns:
 
 a merged Flux
 - merge
```
public static <T> Flux<T> merge(Publisher<? extends Publisher<? extends T>> source,
 int concurrency)
```
 Merge data from Publisher sequences emitted by the passed Publisher into an interleaved merged sequence. Unlike concat, inner sources are subscribed to eagerly (but at most concurrency sources are subscribed to at the same time).
 
 Note that merge is tailored to work with asynchronous sources or finite sources. When dealing with an infinite source that doesn't already publish on a dedicated Scheduler, you must isolate that source in its own Scheduler, as merge would otherwise attempt to drain it before subscribing to another source.
 
 Type Parameters:
 
 T - the merged type
 
 Parameters:
 
 source - a Publisher of Publisher sources to merge
 
 concurrency - the request produced to the main source thus limiting concurrent merge backlog
 
 Returns:
 
 a merged Flux
 - merge
```
public static <T> Flux<T> merge(Publisher<? extends Publisher<? extends T>> source,
 int concurrency,
 int prefetch)
```
 Merge data from Publisher sequences emitted by the passed Publisher into an interleaved merged sequence. Unlike concat, inner sources are subscribed to eagerly (but at most concurrency sources are subscribed to at the same time).
 
 Note that merge is tailored to work with asynchronous sources or finite sources. When dealing with an infinite source that doesn't already publish on a dedicated Scheduler, you must isolate that source in its own Scheduler, as merge would otherwise attempt to drain it before subscribing to another source.
 
 Type Parameters:
 
 T - the merged type
 
 Parameters:
 
 source - a Publisher of Publisher sources to merge
 
 concurrency - the request produced to the main source thus limiting concurrent merge backlog
 
 prefetch - the inner source request size
 
 Returns:
 
 a merged Flux
 - merge
```
public static  Flux merge(Iterable<? extends Publisher<? extends I>> sources)
```
 Merge data from Publisher sequences contained in an Iterable into an interleaved merged sequence. Unlike concat, inner sources are subscribed to eagerly. A new Iterator will be created for each subscriber.
 
 Note that merge is tailored to work with asynchronous sources or finite sources. When dealing with an infinite source that doesn't already publish on a dedicated Scheduler, you must isolate that source in its own Scheduler, as merge would otherwise attempt to drain it before subscribing to another source.
 
 Type Parameters:
 
 I - The source type of the data sequence
 
 Parameters:
 
 sources - the Iterable of sources to merge (will be lazily iterated on subscribe)
 
 Returns:
 
 a merged Flux
 - merge
```
@SafeVarargs
public static  Flux merge(Publisher<? extends I>... sources)
```
 Merge data from Publisher sequences contained in an array / vararg into an interleaved merged sequence. Unlike concat, sources are subscribed to eagerly.
 
 Note that merge is tailored to work with asynchronous sources or finite sources. When dealing with an infinite source that doesn't already publish on a dedicated Scheduler, you must isolate that source in its own Scheduler, as merge would otherwise attempt to drain it before subscribing to another source.
 
 Type Parameters:
 
 I - The source type of the data sequence
 
 Parameters:
 
 sources - the array of Publisher sources to merge
 
 Returns:
 
 a merged Flux
 - merge
```
@SafeVarargs
public static  Flux merge(int prefetch,
 Publisher<? extends I>... sources)
```
 Merge data from Publisher sequences contained in an array / vararg into an interleaved merged sequence. Unlike concat, sources are subscribed to eagerly.
 
 Note that merge is tailored to work with asynchronous sources or finite sources. When dealing with an infinite source that doesn't already publish on a dedicated Scheduler, you must isolate that source in its own Scheduler, as merge would otherwise attempt to drain it before subscribing to another source.
 
 Type Parameters:
 
 I - The source type of the data sequence
 
 Parameters:
 
 sources - the array of Publisher sources to merge
 
 prefetch - the inner source request size
 
 Returns:
 
 a fresh Reactive Flux publisher ready to be subscribed
 - mergeDelayError
```
@SafeVarargs
public static  Flux mergeDelayError(int prefetch,
 Publisher<? extends I>... sources)
```
 Merge data from Publisher sequences contained in an array / vararg into an interleaved merged sequence. Unlike concat, sources are subscribed to eagerly. This variant will delay any error until after the rest of the merge backlog has been processed.
 
 Note that merge is tailored to work with asynchronous sources or finite sources. When dealing with an infinite source that doesn't already publish on a dedicated Scheduler, you must isolate that source in its own Scheduler, as merge would otherwise attempt to drain it before subscribing to another source.
 
 Type Parameters:
 
 I - The source type of the data sequence
 
 Parameters:
 
 sources - the array of Publisher sources to merge
 
 prefetch - the inner source request size
 
 Returns:
 
 a fresh Reactive Flux publisher ready to be subscribed
 - mergeOrdered
```
@SafeVarargs
public static > Flux mergeOrdered(Publisher<? extends I>... sources)
```
 Merge data from provided Publisher sequences into an ordered merged sequence, by picking the smallest values from each source (as defined by their natural order). This is not a sort(), as it doesn't consider the whole of each sequences.
 Instead, this operator considers only one value from each source and picks the smallest of all these values, then replenishes the slot for that picked source.
 
 Type Parameters:
 
 I - a Comparable merged type that has a natural order
 
 Parameters:
 
 sources - Publisher sources of Comparable to merge
 
 Returns:
 
 a merged Flux that , subscribing early but keeping the original ordering
 - mergeOrdered
```
@SafeVarargs
public static <T> Flux<T> mergeOrdered(Comparator<? super T> comparator,
 Publisher<? extends T>... sources)
```
 Merge data from provided Publisher sequences into an ordered merged sequence, by picking the smallest values from each source (as defined by the provided Comparator). This is not a sort(Comparator), as it doesn't consider the whole of each sequences.
 Instead, this operator considers only one value from each source and picks the smallest of all these values, then replenishes the slot for that picked source.
 
 Type Parameters:
 
 T - the merged type
 
 Parameters:
 
 comparator - the Comparator to use to find the smallest value
 
 sources - Publisher sources to merge
 
 Returns:
 
 a merged Flux that , subscribing early but keeping the original ordering
 - mergeOrdered
```
@SafeVarargs
public static <T> Flux<T> mergeOrdered(int prefetch,
 Comparator<? super T> comparator,
 Publisher<? extends T>... sources)
```
 Merge data from provided Publisher sequences into an ordered merged sequence, by picking the smallest values from each source (as defined by the provided Comparator). This is not a sort(Comparator), as it doesn't consider the whole of each sequences.
 Instead, this operator considers only one value from each source and picks the smallest of all these values, then replenishes the slot for that picked source.
 
 Type Parameters:
 
 T - the merged type
 
 Parameters:
 
 prefetch - the number of elements to prefetch from each source (avoiding too many small requests to the source when picking)
 
 comparator - the Comparator to use to find the smallest value
 
 sources - Publisher sources to merge
 
 Returns:
 
 a merged Flux that , subscribing early but keeping the original ordering
 - mergeSequential
```
public static <T> Flux<T> mergeSequential(Publisher<? extends Publisher<? extends T>> sources)
```
 Merge data from Publisher sequences emitted by the passed Publisher into an ordered merged sequence. Unlike concat, the inner publishers are subscribed to eagerly. Unlike merge, their emitted values are merged into the final sequence in subscription order.
 
 Type Parameters:
 
 T - the merged type
 
 Parameters:
 
 sources - a Publisher of Publisher sources to merge
 
 Returns:
 
 a merged Flux, subscribing early but keeping the original ordering
 - mergeSequential
```
public static <T> Flux<T> mergeSequential(Publisher<? extends Publisher<? extends T>> sources,
 int maxConcurrency,
 int prefetch)
```
 Merge data from Publisher sequences emitted by the passed Publisher into an ordered merged sequence. Unlike concat, the inner publishers are subscribed to eagerly (but at most maxConcurrency sources at a time). Unlike merge, their emitted values are merged into the final sequence in subscription order.
 
 Type Parameters:
 
 T - the merged type
 
 Parameters:
 
 sources - a Publisher of Publisher sources to merge
 
 prefetch - the inner source request size
 
 maxConcurrency - the request produced to the main source thus limiting concurrent merge backlog
 
 Returns:
 
 a merged Flux, subscribing early but keeping the original ordering
 - mergeSequentialDelayError
```
public static <T> Flux<T> mergeSequentialDelayError(Publisher<? extends Publisher<? extends T>> sources,
 int maxConcurrency,
 int prefetch)
```
 Merge data from Publisher sequences emitted by the passed Publisher into an ordered merged sequence. Unlike concat, the inner publishers are subscribed to eagerly (but at most maxConcurrency sources at a time). Unlike merge, their emitted values are merged into the final sequence in subscription order. This variant will delay any error until after the rest of the mergeSequential backlog has been processed.
 
 Type Parameters:
 
 T - the merged type
 
 Parameters:
 
 sources - a Publisher of Publisher sources to merge
 
 prefetch - the inner source request size
 
 maxConcurrency - the request produced to the main source thus limiting concurrent merge backlog
 
 Returns:
 
 a merged Flux, subscribing early but keeping the original ordering
 - mergeSequential
```
@SafeVarargs
public static  Flux mergeSequential(Publisher<? extends I>... sources)
```
 Merge data from Publisher sequences provided in an array/vararg into an ordered merged sequence. Unlike concat, sources are subscribed to eagerly. Unlike merge, their emitted values are merged into the final sequence in subscription order.
 
 Type Parameters:
 
 I - the merged type
 
 Parameters:
 
 sources - a number of Publisher sequences to merge
 
 Returns:
 
 a merged Flux, subscribing early but keeping the original ordering
 - mergeSequential
```
@SafeVarargs
public static  Flux mergeSequential(int prefetch,
 Publisher<? extends I>... sources)
```
 Merge data from Publisher sequences provided in an array/vararg into an ordered merged sequence. Unlike concat, sources are subscribed to eagerly. Unlike merge, their emitted values are merged into the final sequence in subscription order.
 
 Type Parameters:
 
 I - the merged type
 
 Parameters:
 
 prefetch - the inner source request size
 
 sources - a number of Publisher sequences to merge
 
 Returns:
 
 a merged Flux, subscribing early but keeping the original ordering
 - mergeSequentialDelayError
```
@SafeVarargs
public static  Flux mergeSequentialDelayError(int prefetch,
 Publisher<? extends I>... sources)
```
 Merge data from Publisher sequences provided in an array/vararg into an ordered merged sequence. Unlike concat, sources are subscribed to eagerly. Unlike merge, their emitted values are merged into the final sequence in subscription order. This variant will delay any error until after the rest of the mergeSequential backlog has been processed.
 
 Type Parameters:
 
 I - the merged type
 
 Parameters:
 
 prefetch - the inner source request size
 
 sources - a number of Publisher sequences to merge
 
 Returns:
 
 a merged Flux, subscribing early but keeping the original ordering
 - mergeSequential
```
public static  Flux mergeSequential(Iterable<? extends Publisher<? extends I>> sources)
```
 Merge data from Publisher sequences provided in an Iterable into an ordered merged sequence. Unlike concat, sources are subscribed to eagerly. Unlike merge, their emitted values are merged into the final sequence in subscription order.
 
 Type Parameters:
 
 I - the merged type
 
 Parameters:
 
 sources - an Iterable of Publisher sequences to merge
 
 Returns:
 
 a merged Flux, subscribing early but keeping the original ordering
 - mergeSequential
```
public static  Flux mergeSequential(Iterable<? extends Publisher<? extends I>> sources,
 int maxConcurrency,
 int prefetch)
```
 Merge data from Publisher sequences provided in an Iterable into an ordered merged sequence. Unlike concat, sources are subscribed to eagerly (but at most maxConcurrency sources at a time). Unlike merge, their emitted values are merged into the final sequence in subscription order.
 
 Type Parameters:
 
 I - the merged type
 
 Parameters:
 
 sources - an Iterable of Publisher sequences to merge
 
 maxConcurrency - the request produced to the main source thus limiting concurrent merge backlog
 
 prefetch - the inner source request size
 
 Returns:
 
 a merged Flux, subscribing early but keeping the original ordering
 - mergeSequentialDelayError
```
public static  Flux mergeSequentialDelayError(Iterable<? extends Publisher<? extends I>> sources,
 int maxConcurrency,
 int prefetch)
```
 Merge data from Publisher sequences provided in an Iterable into an ordered merged sequence. Unlike concat, sources are subscribed to eagerly (but at most maxConcurrency sources at a time). Unlike merge, their emitted values are merged into the final sequence in subscription order. This variant will delay any error until after the rest of the mergeSequential backlog has been processed.
 
 Type Parameters:
 
 I - the merged type
 
 Parameters:
 
 sources - an Iterable of Publisher sequences to merge
 
 maxConcurrency - the request produced to the main source thus limiting concurrent merge backlog
 
 prefetch - the inner source request size
 
 Returns:
 
 a merged Flux, subscribing early but keeping the original ordering
 - never
```
public static <T> Flux<T> never()
```
 Create a Flux that will never signal any data, error or completion signal.
 
 Type Parameters:
 
 T - the Subscriber type target
 
 Returns:
 
 a never completing Flux
 - range
```
public static Flux<Integer> range(int start,
 int count)
```
 Build a Flux that will only emit a sequence of count incrementing integers, starting from start. That is, emit integers between start (included) and start + count (excluded) then complete.
 
 Parameters:
 
 start - the first integer to be emit
 
 count - the total number of incrementing values to emit, including the first value
 
 Returns:
 
 a ranged Flux
 - switchOnNext
```
public static <T> Flux<T> switchOnNext(Publisher<? extends Publisher<? extends T>> mergedPublishers)
```
 Creates a Flux that mirrors the most recently emitted Publisher, forwarding its data until a new Publisher comes in in the source.
 The resulting Flux will complete once there are no new Publisher in the source (source has completed) and the last mirrored Publisher has also completed.
 
 Type Parameters:
 
 T - the produced type
 
 Parameters:
 
 mergedPublishers - The Publisher of Publisher to switch on and mirror.
 
 Returns:
 
 a FluxProcessor accepting publishers and producing T
 - switchOnNext
```
public static <T> Flux<T> switchOnNext(Publisher<? extends Publisher<? extends T>> mergedPublishers,
 int prefetch)
```
 Creates a Flux that mirrors the most recently emitted Publisher, forwarding its data until a new Publisher comes in in the source.
 The resulting Flux will complete once there are no new Publisher in the source (source has completed) and the last mirrored Publisher has also completed.
 
 Type Parameters:
 
 T - the produced type
 
 Parameters:
 
 mergedPublishers - The Publisher of Publisher to switch on and mirror.
 
 prefetch - the inner source request size
 
 Returns:
 
 a FluxProcessor accepting publishers and producing T
 - using
```
public static <T,D> Flux<T> using(Callable<? extends D> resourceSupplier,
 Function<? super D,? extends Publisher<? extends T>> sourceSupplier,
 Consumer<? super D> resourceCleanup)
```
 Uses a resource, generated by a supplier for each individual Subscriber, while streaming the values from a Publisher derived from the same resource and makes sure the resource is released if the sequence terminates or the Subscriber cancels.
 Eager resource cleanup happens just before the source termination and exceptions raised by the cleanup Consumer may override the terminal even.
 
 For an asynchronous version of the cleanup, with distinct path for onComplete, onError and cancel terminations, see usingWhen(Publisher, Function, Function, Function, Function).
 
 Type Parameters:
 
 T - emitted type
 
 D - resource type
 
 Parameters:
 
 resourceSupplier - a Callable that is called on subscribe to generate the resource
 
 sourceSupplier - a factory to derive a Publisher from the supplied resource
 
 resourceCleanup - a resource cleanup callback invoked on completion
 
 Returns:
 
 a new Flux built around a disposable resource
 
 See Also:
 
 usingWhen(Publisher, Function, Function, Function, Function), usingWhen(Publisher, Function, Function)
 - using
```
public static <T,D> Flux<T> using(Callable<? extends D> resourceSupplier,
 Function<? super D,? extends Publisher<? extends T>> sourceSupplier,
 Consumer<? super D> resourceCleanup,
 boolean eager)
```
 Uses a resource, generated by a supplier for each individual Subscriber, while streaming the values from a Publisher derived from the same resource and makes sure the resource is released if the sequence terminates or the Subscriber cancels.
 - Eager resource cleanup happens just before the source termination and exceptions raised by the cleanup Consumer may override the terminal even.
 - Non-eager cleanup will drop any exception.
 For an asynchronous version of the cleanup, with distinct path for onComplete, onError and cancel terminations, see usingWhen(Publisher, Function, Function, Function, Function).
 Type Parameters:
 
 T - emitted type
 
 D - resource type
 
 Parameters:
 
 resourceSupplier - a Callable that is called on subscribe to generate the resource
 
 sourceSupplier - a factory to derive a Publisher from the supplied resource
 
 resourceCleanup - a resource cleanup callback invoked on completion
 
 eager - true to clean before terminating downstream subscribers
 
 Returns:
 
 a new Flux built around a disposable resource
 
 See Also:
 
 usingWhen(Publisher, Function, Function, Function, Function), usingWhen(Publisher, Function, Function)
 - usingWhen
```
public static <T,D> Flux<T> usingWhen(Publisher<D> resourceSupplier,
 Function<? super D,? extends Publisher<? extends T>> resourceClosure,
 Function<? super D,? extends Publisher<?>> asyncComplete,
 Function<? super D,? extends Publisher<?>> asyncError)
```
 Uses a resource, generated by a Publisher for each individual Subscriber, while streaming the values from a Publisher derived from the same resource. Whenever the resulting sequence terminates, the relevant Function generates a "cleanup" Publisher that is invoked but doesn't change the content of the main sequence. Instead it just defers the termination (unless it errors, in which case the error suppresses the original termination signal).
 Note that if the resource supplying Publisher emits more than one resource, the subsequent resources are dropped (Operators.onNextDropped(Object, Context)). If the publisher errors AFTER having emitted one resource, the error is also silently dropped (Operators.onErrorDropped(Throwable, Context)). An empty completion or error without at least one onNext signal triggers a short-circuit of the main sequence with the same terminal signal (no resource is established, no cleanup is invoked).
 
 Type Parameters:
 
 T - the type of elements emitted by the resource closure, and thus the main sequence
 
 D - the type of the resource object
 
 Parameters:
 
 resourceSupplier - a Publisher that "generates" the resource, subscribed for each subscription to the main sequence
 
 resourceClosure - a factory to derive a Publisher from the supplied resource
 
 asyncComplete - an asynchronous resource cleanup invoked if the resource closure terminates with onComplete or is cancelled
 
 asyncError - an asynchronous resource cleanup invoked if the resource closure terminates with onError
 
 Returns:
 
 a new Flux built around a "transactional" resource, with several termination path triggering asynchronous cleanup sequences
 
 See Also:
 
 usingWhen(Publisher, Function, Function, Function, Function)
 - usingWhen
```
public static <T,D> Flux<T> usingWhen(Publisher<D> resourceSupplier,
 Function<? super D,? extends Publisher<? extends T>> resourceClosure,
 Function<? super D,? extends Publisher<?>> asyncComplete,
 Function<? super D,? extends Publisher<?>> asyncError,
 Function<? super D,? extends Publisher<?>> asyncCancel)
```
 Uses a resource, generated by a Publisher for each individual Subscriber, while streaming the values from a Publisher derived from the same resource. Whenever the resulting sequence terminates, the relevant Function generates a "cleanup" Publisher that is invoked but doesn't change the content of the main sequence. Instead it just defers the termination (unless it errors, in which case the error suppresses the original termination signal).
 Note that if the resource supplying Publisher emits more than one resource, the subsequent resources are dropped (Operators.onNextDropped(Object, Context)). If the publisher errors AFTER having emitted one resource, the error is also silently dropped (Operators.onErrorDropped(Throwable, Context)). An empty completion or error without at least one onNext signal triggers a short-circuit of the main sequence with the same terminal signal (no resource is established, no cleanup is invoked).
 
 Type Parameters:
 
 T - the type of elements emitted by the resource closure, and thus the main sequence
 
 D - the type of the resource object
 
 Parameters:
 
 resourceSupplier - a Publisher that "generates" the resource, subscribed for each subscription to the main sequence
 
 resourceClosure - a factory to derive a Publisher from the supplied resource
 
 asyncComplete - an asynchronous resource cleanup invoked if the resource closure terminates with onComplete
 
 asyncError - an asynchronous resource cleanup invoked if the resource closure terminates with onError
 
 asyncCancel - an asynchronous resource cleanup invoked if the resource closure is cancelled. When null, the asyncComplete path is used instead.
 
 Returns:
 
 a new Flux built around a "transactional" resource, with several termination path triggering asynchronous cleanup sequences
 
 See Also:
 
 usingWhen(Publisher, Function, Function, Function)
 - usingWhen
```
public static <T,D> Flux<T> usingWhen(Publisher<D> resourceSupplier,
 Function<? super D,? extends Publisher<? extends T>> resourceClosure,
 Function<? super D,? extends Publisher<?>> asyncCleanup)
```
 Uses a resource, generated by a Publisher for each individual Subscriber, while streaming the values from a Publisher derived from the same resource. Whenever the resulting sequence terminates, a provided Function generates a "cleanup" Publisher that is invoked but doesn't change the content of the main sequence. Instead it just defers the termination (unless it errors, in which case the error suppresses the original termination signal).
 Note that if the resource supplying Publisher emits more than one resource, the subsequent resources are dropped (Operators.onNextDropped(Object, Context)). If the publisher errors AFTER having emitted one resource, the error is also silently dropped (Operators.onErrorDropped(Throwable, Context)). An empty completion or error without at least one onNext signal triggers a short-circuit of the main sequence with the same terminal signal (no resource is established, no cleanup is invoked).
 
 Type Parameters:
 
 T - the type of elements emitted by the resource closure, and thus the main sequence
 
 D - the type of the resource object
 
 Parameters:
 
 resourceSupplier - a Publisher that "generates" the resource, subscribed for each subscription to the main sequence
 
 resourceClosure - a factory to derive a Publisher from the supplied resource
 
 asyncCleanup - an asynchronous resource cleanup invoked when the resource closure terminates (with onComplete, onError or cancel)
 
 Returns:
 
 a new Flux built around a "transactional" resource, with asynchronous cleanup on all terminations (onComplete, onError, cancel)
 
 See Also:
 
 usingWhen(Publisher, Function, Function, Function, Function)
 - zip
```
public static <T1,T2,O> Flux<O> zip(Publisher<? extends T1> source1,
 Publisher<? extends T2> source2,
 BiFunction<? super T1,? super T2,? extends O> combinator)
```
 Zip two sources together, that is to say wait for all the sources to emit one element and combine these elements once into an output value (constructed by the provided combinator). The operator will continue doing so until any of the sources completes. Errors will immediately be forwarded. This "Step-Merge" processing is especially useful in Scatter-Gather scenarios.
 
 Type Parameters:
 
 T1 - type of the value from source1
 
 T2 - type of the value from source2
 
 O - The produced output after transformation by the combinator
 
 Parameters:
 
 source1 - The first Publisher source to zip.
 
 source2 - The second Publisher source to zip.
 
 combinator - The aggregate function that will receive a unique value from each upstream and return the value to signal downstream
 
 Returns:
 
 a zipped Flux
 - zip
```
public static <T1,T2> Flux<Tuple2<T1,T2>> zip(Publisher<? extends T1> source1,
 Publisher<? extends T2> source2)
```
 Zip two sources together, that is to say wait for all the sources to emit one element and combine these elements once into a Tuple2. The operator will continue doing so until any of the sources completes. Errors will immediately be forwarded. This "Step-Merge" processing is especially useful in Scatter-Gather scenarios.
 
 Type Parameters:
 
 T1 - type of the value from source1
 
 T2 - type of the value from source2
 
 Parameters:
 
 source1 - The first Publisher source to zip.
 
 source2 - The second Publisher source to zip.
 
 Returns:
 
 a zipped Flux
 - zip
```
public static <T1,T2,T3> Flux<Tuple3<T1,T2,T3>> zip(Publisher<? extends T1> source1,
 Publisher<? extends T2> source2,
 Publisher<? extends T3> source3)
```
 Zip three sources together, that is to say wait for all the sources to emit one element and combine these elements once into a Tuple3. The operator will continue doing so until any of the sources completes. Errors will immediately be forwarded. This "Step-Merge" processing is especially useful in Scatter-Gather scenarios.
 
 Type Parameters:
 
 T1 - type of the value from source1
 
 T2 - type of the value from source2
 
 T3 - type of the value from source3
 
 Parameters:
 
 source1 - The first upstream Publisher to subscribe to.
 
 source2 - The second upstream Publisher to subscribe to.
 
 source3 - The third upstream Publisher to subscribe to.
 
 Returns:
 
 a zipped Flux
 - zip
```
public static <T1,T2,T3,T4> Flux<Tuple4<T1,T2,T3,T4>> zip(Publisher<? extends T1> source1,
 Publisher<? extends T2> source2,
 Publisher<? extends T3> source3,
 Publisher<? extends T4> source4)
```
 Zip four sources together, that is to say wait for all the sources to emit one element and combine these elements once into a Tuple4. The operator will continue doing so until any of the sources completes. Errors will immediately be forwarded. This "Step-Merge" processing is especially useful in Scatter-Gather scenarios.
 
 Type Parameters:
 
 T1 - type of the value from source1
 
 T2 - type of the value from source2
 
 T3 - type of the value from source3
 
 T4 - type of the value from source4
 
 Parameters:
 
 source1 - The first upstream Publisher to subscribe to.
 
 source2 - The second upstream Publisher to subscribe to.
 
 source3 - The third upstream Publisher to subscribe to.
 
 source4 - The fourth upstream Publisher to subscribe to.
 
 Returns:
 
 a zipped Flux
 - zip
```
public static <T1,T2,T3,T4,T5> Flux<Tuple5<T1,T2,T3,T4,T5>> zip(Publisher<? extends T1> source1,
 Publisher<? extends T2> source2,
 Publisher<? extends T3> source3,
 Publisher<? extends T4> source4,
 Publisher<? extends T5> source5)
```
 Zip five sources together, that is to say wait for all the sources to emit one element and combine these elements once into a Tuple5. The operator will continue doing so until any of the sources completes. Errors will immediately be forwarded. This "Step-Merge" processing is especially useful in Scatter-Gather scenarios.
 
 Type Parameters:
 
 T1 - type of the value from source1
 
 T2 - type of the value from source2
 
 T3 - type of the value from source3
 
 T4 - type of the value from source4
 
 T5 - type of the value from source5
 
 Parameters:
 
 source1 - The first upstream Publisher to subscribe to.
 
 source2 - The second upstream Publisher to subscribe to.
 
 source3 - The third upstream Publisher to subscribe to.
 
 source4 - The fourth upstream Publisher to subscribe to.
 
 source5 - The fifth upstream Publisher to subscribe to.
 
 Returns:
 
 a zipped Flux
 - zip
```
public static <T1,T2,T3,T4,T5,T6> Flux<Tuple6<T1,T2,T3,T4,T5,T6>> zip(Publisher<? extends T1> source1,
 Publisher<? extends T2> source2,
 Publisher<? extends T3> source3,
 Publisher<? extends T4> source4,
 Publisher<? extends T5> source5,
 Publisher<? extends T6> source6)
```
 Zip six sources together, that is to say wait for all the sources to emit one element and combine these elements once into a Tuple6. The operator will continue doing so until any of the sources completes. Errors will immediately be forwarded. This "Step-Merge" processing is especially useful in Scatter-Gather scenarios.
 
 Type Parameters:
 
 T1 - type of the value from source1
 
 T2 - type of the value from source2
 
 T3 - type of the value from source3
 
 T4 - type of the value from source4
 
 T5 - type of the value from source5
 
 T6 - type of the value from source6
 
 Parameters:
 
 source1 - The first upstream Publisher to subscribe to.
 
 source2 - The second upstream Publisher to subscribe to.
 
 source3 - The third upstream Publisher to subscribe to.
 
 source4 - The fourth upstream Publisher to subscribe to.
 
 source5 - The fifth upstream Publisher to subscribe to.
 
 source6 - The sixth upstream Publisher to subscribe to.
 
 Returns:
 
 a zipped Flux
 - zip
```
public static <T1,T2,T3,T4,T5,T6,T7> Flux<Tuple7<T1,T2,T3,T4,T5,T6,T7>> zip(Publisher<? extends T1> source1,
 Publisher<? extends T2> source2,
 Publisher<? extends T3> source3,
 Publisher<? extends T4> source4,
 Publisher<? extends T5> source5,
 Publisher<? extends T6> source6,
 Publisher<? extends T7> source7)
```
 Zip seven sources together, that is to say wait for all the sources to emit one element and combine these elements once into a Tuple7. The operator will continue doing so until any of the sources completes. Errors will immediately be forwarded. This "Step-Merge" processing is especially useful in Scatter-Gather scenarios.
 
 Type Parameters:
 
 T1 - type of the value from source1
 
 T2 - type of the value from source2
 
 T3 - type of the value from source3
 
 T4 - type of the value from source4
 
 T5 - type of the value from source5
 
 T6 - type of the value from source6
 
 T7 - type of the value from source7
 
 Parameters:
 
 source1 - The first upstream Publisher to subscribe to.
 
 source2 - The second upstream Publisher to subscribe to.
 
 source3 - The third upstream Publisher to subscribe to.
 
 source4 - The fourth upstream Publisher to subscribe to.
 
 source5 - The fifth upstream Publisher to subscribe to.
 
 source6 - The sixth upstream Publisher to subscribe to.
 
 source7 - The seventh upstream Publisher to subscribe to.
 
 Returns:
 
 a zipped Flux
 - zip
```
public static <T1,T2,T3,T4,T5,T6,T7,T8> Flux<Tuple8<T1,T2,T3,T4,T5,T6,T7,T8>> zip(Publisher<? extends T1> source1,
 Publisher<? extends T2> source2,
 Publisher<? extends T3> source3,
 Publisher<? extends T4> source4,
 Publisher<? extends T5> source5,
 Publisher<? extends T6> source6,
 Publisher<? extends T7> source7,
 Publisher<? extends T8> source8)
```
 Zip eight sources together, that is to say wait for all the sources to emit one element and combine these elements once into a Tuple8. The operator will continue doing so until any of the sources completes. Errors will immediately be forwarded. This "Step-Merge" processing is especially useful in Scatter-Gather scenarios.
 
 Type Parameters:
 
 T1 - type of the value from source1
 
 T2 - type of the value from source2
 
 T3 - type of the value from source3
 
 T4 - type of the value from source4
 
 T5 - type of the value from source5
 
 T6 - type of the value from source6
 
 T7 - type of the value from source7
 
 T8 - type of the value from source8
 
 Parameters:
 
 source1 - The first upstream Publisher to subscribe to.
 
 source2 - The second upstream Publisher to subscribe to.
 
 source3 - The third upstream Publisher to subscribe to.
 
 source4 - The fourth upstream Publisher to subscribe to.
 
 source5 - The fifth upstream Publisher to subscribe to.
 
 source6 - The sixth upstream Publisher to subscribe to.
 
 source7 - The seventh upstream Publisher to subscribe to.
 
 source8 - The eight upstream Publisher to subscribe to.
 
 Returns:
 
 a zipped Flux
 - zip
```
public static <O> Flux<O> zip(Iterable<? extends Publisher<?>> sources,
 Function<? super Object[],? extends O> combinator)
```
 Zip multiple sources together, that is to say wait for all the sources to emit one element and combine these elements once into an output value (constructed by the provided combinator). The operator will continue doing so until any of the sources completes. Errors will immediately be forwarded. This "Step-Merge" processing is especially useful in Scatter-Gather scenarios. The Iterable.iterator() will be called on each Publisher.subscribe(Subscriber).
 
 Type Parameters:
 
 O - the combined produced type
 
 Parameters:
 
 sources - the Iterable providing sources to zip
 
 combinator - The aggregate function that will receive a unique value from each upstream and return the value to signal downstream
 
 Returns:
 
 a zipped Flux
 - zip
```
public static <O> Flux<O> zip(Iterable<? extends Publisher<?>> sources,
 int prefetch,
 Function<? super Object[],? extends O> combinator)
```
 Zip multiple sources together, that is to say wait for all the sources to emit one element and combine these elements once into an output value (constructed by the provided combinator). The operator will continue doing so until any of the sources completes. Errors will immediately be forwarded. This "Step-Merge" processing is especially useful in Scatter-Gather scenarios. The Iterable.iterator() will be called on each Publisher.subscribe(Subscriber).
 
 Type Parameters:
 
 O - the combined produced type
 
 Parameters:
 
 sources - the Iterable providing sources to zip
 
 prefetch - the inner source request size
 
 combinator - The aggregate function that will receive a unique value from each upstream and return the value to signal downstream
 
 Returns:
 
 a zipped Flux
 - zip
```
@SafeVarargs
public static <I,O> Flux<O> zip(Function<? super Object[],? extends O> combinator,
 Publisher<? extends I>... sources)
```
 Zip multiple sources together, that is to say wait for all the sources to emit one element and combine these elements once into an output value (constructed by the provided combinator). The operator will continue doing so until any of the sources completes. Errors will immediately be forwarded. This "Step-Merge" processing is especially useful in Scatter-Gather scenarios.
 
 Type Parameters:
 
 I - the type of the input sources
 
 O - the combined produced type
 
 Parameters:
 
 combinator - The aggregate function that will receive a unique value from each upstream and return the value to signal downstream
 
 sources - the array providing sources to zip
 
 Returns:
 
 a zipped Flux
 - zip
```
@SafeVarargs
public static <I,O> Flux<O> zip(Function<? super Object[],? extends O> combinator,
 int prefetch,
 Publisher<? extends I>... sources)
```
 Zip multiple sources together, that is to say wait for all the sources to emit one element and combine these elements once into an output value (constructed by the provided combinator). The operator will continue doing so until any of the sources completes. Errors will immediately be forwarded. This "Step-Merge" processing is especially useful in Scatter-Gather scenarios.
 
 Type Parameters:
 
 I - the type of the input sources
 
 O - the combined produced type
 
 Parameters:
 
 combinator - The aggregate function that will receive a unique value from each upstream and return the value to signal downstream
 
 prefetch - individual source request size
 
 sources - the array providing sources to zip
 
 Returns:
 
 a zipped Flux
 - zip
```
public static <TUPLE extends Tuple2,V> Flux<V> zip(Publisher<? extends Publisher<?>> sources,
 Function<? super TUPLE,? extends V> combinator)
```
 Zip multiple sources together, that is to say wait for all the sources to emit one element and combine these elements once into an output value (constructed by the provided combinator). The operator will continue doing so until any of the sources completes. Errors will immediately be forwarded. This "Step-Merge" processing is especially useful in Scatter-Gather scenarios.
 Note that the Publisher sources from the outer Publisher will accumulate into an exhaustive list before starting zip operation.
 
 Type Parameters:
 
 TUPLE - the raw tuple type
 
 V - The produced output after transformation by the given combinator
 
 Parameters:
 
 sources - The Publisher of Publisher sources to zip. A finite publisher is required.
 
 combinator - The aggregate function that will receive a unique value from each upstream and return the value to signal downstream
 
 Returns:
 
 a Flux based on the produced value
 - all
```
public final Mono<Boolean> all(Predicate<? super T> predicate)
```
 Emit a single boolean true if all values of this sequence match the Predicate.
 The implementation uses short-circuit logic and completes with false if the predicate doesn't match a value.
 
 Parameters:
 
 predicate - the Predicate that needs to apply to all emitted items
 
 Returns:
 
 a new Mono with true if all values satisfies a predicate and false otherwise
 - any
```
public final Mono<Boolean> any(Predicate<? super T> predicate)
```
 Emit a single boolean true if any of the values of this Flux sequence match the predicate.
 The implementation uses short-circuit logic and completes with false if any value doesn't match the predicate.
 
 Parameters:
 
 predicate - the Predicate that needs to apply to at least one emitted item
 
 Returns:
 
 a new Mono with true if any value satisfies a predicate and false otherwise
 - as
```
public final  P as(Function<? super Flux<T>,P> transformer)
```
 Transform this Flux into a target type.
 flux.as(Mono::from).subscribe()
 Type Parameters:
 
 P - the returned instance type
 
 Parameters:
 
 transformer - the Function to immediately map this Flux into a target type instance.
 
 Returns:
 
 the Flux transformed to an instance of P
 
 See Also:
 
 for a bounded conversion to {@link Publisher}
 - blockFirst
```
@Nullable
public final T blockFirst()
```
 Subscribe to this Flux and block indefinitely until the upstream signals its first value or completes. Returns that value, or null if the Flux completes empty. In case the Flux errors, the original exception is thrown (wrapped in a RuntimeException if it was a checked exception).
 Note that each blockFirst() will trigger a new subscription: in other words, the result might miss signal from hot publishers.
 
 Returns:
 
 the first value or null
 - blockFirst
```
@Nullable
public final T blockFirst(Duration timeout)
```
 Subscribe to this Flux and block until the upstream signals its first value, completes or a timeout expires. Returns that value, or null if the Flux completes empty. In case the Flux errors, the original exception is thrown (wrapped in a RuntimeException if it was a checked exception). If the provided timeout expires,a RuntimeException is thrown.
 Note that each blockFirst() will trigger a new subscription: in other words, the result might miss signal from hot publishers.
 
 Parameters:
 
 timeout - maximum time period to wait for before raising a RuntimeException
 
 Returns:
 
 the first value or null
 - blockLast
```
@Nullable
public final T blockLast()
```
 Subscribe to this Flux and block indefinitely until the upstream signals its last value or completes. Returns that value, or null if the Flux completes empty. In case the Flux errors, the original exception is thrown (wrapped in a RuntimeException if it was a checked exception).
 Note that each blockLast() will trigger a new subscription: in other words, the result might miss signal from hot publishers.
 
 Returns:
 
 the last value or null
 - blockLast
```
@Nullable
public final T blockLast(Duration timeout)
```
 Subscribe to this Flux and block until the upstream signals its last value, completes or a timeout expires. Returns that value, or null if the Flux completes empty. In case the Flux errors, the original exception is thrown (wrapped in a RuntimeException if it was a checked exception). If the provided timeout expires,a RuntimeException is thrown.
 Note that each blockLast() will trigger a new subscription: in other words, the result might miss signal from hot publishers.
 
 Parameters:
 
 timeout - maximum time period to wait for before raising a RuntimeException
 
 Returns:
 
 the last value or null
 - buffer
```
public final Flux<List<T>> buffer()
```
 Collect all incoming values into a single List buffer that will be emitted by the returned Flux once this Flux completes.
 
 Returns:
 
 a buffered Flux of at most one List
 
 See Also:
 
 for an alternative collecting algorithm returning {@link Mono}
 
 onDiscard Support
 
 This operator discards the buffer upon cancellation or error triggered by a data signal.
 - buffer
```
public final Flux<List<T>> buffer(int maxSize)
```
 Collect incoming values into multiple List buffers that will be emitted by the returned Flux each time the given max size is reached or once this Flux completes.
 
 Parameters:
 
 maxSize - the maximum collected size
 
 Returns:
 
 a microbatched Flux of List
 
 onDiscard Support
 
 This operator discards the currently open buffer upon cancellation or error triggered by a data signal.
 - buffer
```
public final <C extends Collection<? super T>> Flux<C> buffer(int maxSize,
 Supplier<C> bufferSupplier)
```
 Collect incoming values into multiple user-defined Collection buffers that will be emitted by the returned Flux each time the given max size is reached or once this Flux completes.
 
 Type Parameters:
 
 C - the Collection buffer type
 
 Parameters:
 
 maxSize - the maximum collected size
 
 bufferSupplier - a Supplier of the concrete Collection to use for each buffer
 
 Returns:
 
 a microbatched Flux of Collection
 
 onDiscard Support
 
 This operator discards the currently open buffer upon cancellation or error triggered by a data signal, as well as latest unbuffered element if the bufferSupplier fails.
 - buffer
```
public final Flux<List<T>> buffer(int maxSize,
 int skip)
```
 Collect incoming values into multiple List buffers that will be emitted by the returned Flux each time the given max size is reached or once this Flux completes. Buffers can be created with gaps, as a new buffer will be created every time skip values have been emitted by the source.
 When maxSize < skip : dropping buffers
 
 When maxSize > skip : overlapping buffers
 
 When maxSize == skip : exact buffers
 
 Parameters:
 
 skip - the number of items to count before creating a new buffer
 
 maxSize - the max collected size
 
 Returns:
 
 a microbatched Flux of possibly overlapped or gapped List
 
 onDiscard Support
 
 This operator discards elements in between buffers (in the case of dropping buffers). It also discards the currently open buffer upon cancellation or error triggered by a data signal. Note however that overlapping buffer variant DOES NOT discard, as this might result in an element being discarded from an early buffer while it is still valid in a more recent buffer.
 - buffer
```
public final <C extends Collection<? super T>> Flux<C> buffer(int maxSize,
 int skip,
 Supplier<C> bufferSupplier)
```
 Collect incoming values into multiple user-defined Collection buffers that will be emitted by the returned Flux each time the given max size is reached or once this Flux completes. Buffers can be created with gaps, as a new buffer will be created every time skip values have been emitted by the source
 When maxSize < skip : dropping buffers
 
 When maxSize > skip : overlapping buffers
 
 When maxSize == skip : exact buffers
 
 Type Parameters:
 
 C - the Collection buffer type
 
 Parameters:
 
 skip - the number of items to count before creating a new buffer
 
 maxSize - the max collected size
 
 bufferSupplier - a Supplier of the concrete Collection to use for each buffer
 
 Returns:
 
 a microbatched Flux of possibly overlapped or gapped Collection
 
 onDiscard Support
 
 This operator discards elements in between buffers (in the case of dropping buffers). It also discards the currently open buffer upon cancellation or error triggered by a data signal. Note however that overlapping buffer variant DOES NOT discard, as this might result in an element being discarded from an early buffer while it is still valid in a more recent buffer.
 - buffer
```
public final Flux<List<T>> buffer(Publisher<?> other)
```
 Collect incoming values into multiple List buffers, as delimited by the signals of a companion Publisher this operator will subscribe to.
 
 Parameters:
 
 other - the companion Publisher whose signals trigger new buffers
 
 Returns:
 
 a microbatched Flux of List delimited by signals from a Publisher
 
 onDiscard Support
 
 This operator discards the currently open buffer upon cancellation or error triggered by a data signal.
 - buffer
```
public final <C extends Collection<? super T>> Flux<C> buffer(Publisher<?> other,
 Supplier<C> bufferSupplier)
```
 Collect incoming values into multiple user-defined Collection buffers, as delimited by the signals of a companion Publisher this operator will subscribe to.
 
 Type Parameters:
 
 C - the Collection buffer type
 
 Parameters:
 
 other - the companion Publisher whose signals trigger new buffers
 
 bufferSupplier - a Supplier of the concrete Collection to use for each buffer
 
 Returns:
 
 a microbatched Flux of Collection delimited by signals from a Publisher
 
 onDiscard Support
 
 This operator discards the currently open buffer upon cancellation or error triggered by a data signal, and the last received element when the bufferSupplier fails.
 - buffer
```
public final Flux<List<T>> buffer(Duration bufferingTimespan)
```
 Collect incoming values into multiple List buffers that will be emitted by the returned Flux every bufferingTimespan.
 
 Parameters:
 
 bufferingTimespan - the duration from buffer creation until a buffer is closed and emitted
 
 Returns:
 
 a microbatched Flux of List delimited by the given time span
 
 onDiscard Support
 
 This operator discards the currently open buffer upon cancellation or error triggered by a data signal.
 - buffer
```
public final Flux<List<T>> buffer(Duration bufferingTimespan,
 Duration openBufferEvery)
```
 Collect incoming values into multiple List buffers created at a given openBufferEvery period. Each buffer will last until the bufferingTimespan has elapsed, thus emitting the bucket in the resulting Flux.
 When bufferingTimespan < openBufferEvery : dropping buffers
 
 When bufferingTimespan > openBufferEvery : overlapping buffers
 
 When bufferingTimespan == openBufferEvery : exact buffers
 
 Parameters:
 
 bufferingTimespan - the duration from buffer creation until a buffer is closed and emitted
 
 openBufferEvery - the interval at which to create a new buffer
 
 Returns:
 
 a microbatched Flux of List delimited by the given period openBufferEvery and sized by bufferingTimespan
 
 onDiscard Support
 
 This operator discards the currently open buffer upon cancellation or error triggered by a data signal. It DOES NOT provide strong guarantees in the case of overlapping buffers, as elements might get discarded too early (from the first of two overlapping buffers for instance).
 - buffer
```
public final Flux<List<T>> buffer(Duration bufferingTimespan,
 Scheduler timer)
```
 Collect incoming values into multiple List buffers that will be emitted by the returned Flux every bufferingTimespan, as measured on the provided Scheduler.
 
 Parameters:
 
 bufferingTimespan - the duration from buffer creation until a buffer is closed and emitted
 
 timer - a time-capable Scheduler instance to run on
 
 Returns:
 
 a microbatched Flux of List delimited by the given period
 
 onDiscard Support
 
 This operator discards the currently open buffer upon cancellation or error triggered by a data signal.
 - buffer
```
public final Flux<List<T>> buffer(Duration bufferingTimespan,
 Duration openBufferEvery,
 Scheduler timer)
```
 Collect incoming values into multiple List buffers created at a given openBufferEvery period, as measured on the provided Scheduler. Each buffer will last until the bufferingTimespan has elapsed (also measured on the scheduler), thus emitting the bucket in the resulting Flux.
 When bufferingTimespan < openBufferEvery : dropping buffers
 
 When bufferingTimespan > openBufferEvery : overlapping buffers
 
 When bufferingTimespan == openBufferEvery : exact buffers
 
 Parameters:
 
 bufferingTimespan - the duration from buffer creation until a buffer is closed and emitted
 
 openBufferEvery - the interval at which to create a new buffer
 
 timer - a time-capable Scheduler instance to run on
 
 Returns:
 
 a microbatched Flux of List delimited by the given period openBufferEvery and sized by bufferingTimespan
 
 onDiscard Support
 
 This operator discards the currently open buffer upon cancellation or error triggered by a data signal. It DOES NOT provide strong guarantees in the case of overlapping buffers, as elements might get discarded too early (from the first of two overlapping buffers for instance).
 - bufferTimeout
```
public final Flux<List<T>> bufferTimeout(int maxSize,
 Duration maxTime)
```
 Collect incoming values into multiple List buffers that will be emitted by the returned Flux each time the buffer reaches a maximum size OR the maxTime Duration elapses.
 
 Parameters:
 
 maxSize - the max collected size
 
 maxTime - the timeout enforcing the release of a partial buffer
 
 Returns:
 
 a microbatched Flux of List delimited by given size or a given period timeout
 
 onDiscard Support
 
 This operator discards the currently open buffer upon cancellation or error triggered by a data signal.
 - bufferTimeout
```
public final <C extends Collection<? super T>> Flux<C> bufferTimeout(int maxSize,
 Duration maxTime,
 Supplier<C> bufferSupplier)
```
 Collect incoming values into multiple user-defined Collection buffers that will be emitted by the returned Flux each time the buffer reaches a maximum size OR the maxTime Duration elapses.
 
 Type Parameters:
 
 C - the Collection buffer type
 
 Parameters:
 
 maxSize - the max collected size
 
 maxTime - the timeout enforcing the release of a partial buffer
 
 bufferSupplier - a Supplier of the concrete Collection to use for each buffer
 
 Returns:
 
 a microbatched Flux of Collection delimited by given size or a given period timeout
 
 onDiscard Support
 
 This operator discards the currently open buffer upon cancellation or error triggered by a data signal.
 - bufferTimeout
```
public final Flux<List<T>> bufferTimeout(int maxSize,
 Duration maxTime,
 Scheduler timer)
```
 Collect incoming values into multiple List buffers that will be emitted by the returned Flux each time the buffer reaches a maximum size OR the maxTime Duration elapses, as measured on the provided Scheduler.
 
 Parameters:
 
 maxSize - the max collected size
 
 maxTime - the timeout enforcing the release of a partial buffer
 
 timer - a time-capable Scheduler instance to run on
 
 Returns:
 
 a microbatched Flux of List delimited by given size or a given period timeout
 
 onDiscard Support
 
 This operator discards the currently open buffer upon cancellation or error triggered by a data signal.
 - bufferTimeout
```
public final <C extends Collection<? super T>> Flux<C> bufferTimeout(int maxSize,
 Duration maxTime,
 Scheduler timer,
 Supplier<C> bufferSupplier)
```
 Collect incoming values into multiple user-defined Collection buffers that will be emitted by the returned Flux each time the buffer reaches a maximum size OR the maxTime Duration elapses, as measured on the provided Scheduler.
 
 Type Parameters:
 
 C - the Collection buffer type
 
 Parameters:
 
 maxSize - the max collected size
 
 maxTime - the timeout enforcing the release of a partial buffer
 
 timer - a time-capable Scheduler instance to run on
 
 bufferSupplier - a Supplier of the concrete Collection to use for each buffer
 
 Returns:
 
 a microbatched Flux of Collection delimited by given size or a given period timeout
 
 onDiscard Support
 
 This operator discards the currently open buffer upon cancellation or error triggered by a data signal.
 - bufferUntil
```
public final Flux<List<T>> bufferUntil(Predicate<? super T> predicate)
```
 Collect incoming values into multiple List buffers that will be emitted by the resulting Flux each time the given predicate returns true. Note that the element that triggers the predicate to return true (and thus closes a buffer) is included as last element in the emitted buffer.
 
 On completion, if the latest buffer is non-empty and has not been closed it is emitted. However, such a "partial" buffer isn't emitted in case of onError termination.
 
 Parameters:
 
 predicate - a predicate that triggers the next buffer when it becomes true.
 
 Returns:
 
 a microbatched Flux of List
 
 onDiscard Support
 
 This operator discards the currently open buffer upon cancellation or error triggered by a data signal.
 - bufferUntil
```
public final Flux<List<T>> bufferUntil(Predicate<? super T> predicate,
 boolean cutBefore)
```
 Collect incoming values into multiple List buffers that will be emitted by the resulting Flux each time the given predicate returns true. Note that the buffer into which the element that triggers the predicate to return true (and thus closes a buffer) is included depends on the cutBefore parameter: set it to true to include the boundary element in the newly opened buffer, false to include it in the closed buffer (as in bufferUntil(Predicate)).
 
 On completion, if the latest buffer is non-empty and has not been closed it is emitted. However, such a "partial" buffer isn't emitted in case of onError termination.
 
 Parameters:
 
 predicate - a predicate that triggers the next buffer when it becomes true.
 
 cutBefore - set to true to include the triggering element in the new buffer rather than the old.
 
 Returns:
 
 a microbatched Flux of List
 
 onDiscard Support
 
 This operator discards the currently open buffer upon cancellation or error triggered by a data signal.
 - bufferWhile
```
public final Flux<List<T>> bufferWhile(Predicate<? super T> predicate)
```
 Collect incoming values into multiple List buffers that will be emitted by the resulting Flux. Each buffer continues aggregating values while the given predicate returns true, and a new buffer is created as soon as the predicate returns false... Note that the element that triggers the predicate to return false (and thus closes a buffer) is NOT included in any emitted buffer.
 
 On completion, if the latest buffer is non-empty and has not been closed it is emitted. However, such a "partial" buffer isn't emitted in case of onError termination.
 
 Parameters:
 
 predicate - a predicate that triggers the next buffer when it becomes false.
 
 Returns:
 
 a microbatched Flux of List
 
 onDiscard Support
 
 This operator discards the currently open buffer upon cancellation or error triggered by a data signal, as well as the buffer-triggering element.
 - bufferWhen
```
public final <U,V> Flux<List<T>> bufferWhen(Publisher bucketOpening,
 Function<? super U,? extends Publisher<V>> closeSelector)
```
 Collect incoming values into multiple List buffers started each time an opening companion Publisher emits. Each buffer will last until the corresponding closing companion Publisher emits, thus releasing the buffer to the resulting Flux.
 When Open signal is strictly not overlapping Close signal : dropping buffers
 
 When Open signal is strictly more frequent than Close signal : overlapping buffers
 
 When Open signal is exactly coordinated with Close signal : exact buffers
 
 Type Parameters:
 
 U - the element type of the buffer-opening sequence
 
 V - the element type of the buffer-closing sequence
 
 Parameters:
 
 bucketOpening - a companion Publisher to subscribe for buffer creation signals.
 
 closeSelector - a factory that, given a buffer opening signal, returns a companion Publisher to subscribe to for buffer closure and emission signals.
 
 Returns:
 
 a microbatched Flux of List delimited by an opening Publisher and a relative closing Publisher
 
 onDiscard Support
 
 This operator discards the currently open buffer upon cancellation or error triggered by a data signal. It DOES NOT provide strong guarantees in the case of overlapping buffers, as elements might get discarded too early (from the first of two overlapping buffers for instance).
 - bufferWhen
```
public final <U,V,C extends Collection<? super T>> Flux<C> bufferWhen(Publisher bucketOpening,
 Function<? super U,? extends Publisher<V>> closeSelector,
 Supplier<C> bufferSupplier)
```
 Collect incoming values into multiple user-defined Collection buffers started each time an opening companion Publisher emits. Each buffer will last until the corresponding closing companion Publisher emits, thus releasing the buffer to the resulting Flux.
 When Open signal is strictly not overlapping Close signal : dropping buffers
 
 When Open signal is strictly more frequent than Close signal : overlapping buffers
 
 When Open signal is exactly coordinated with Close signal : exact buffers
 
 Type Parameters:
 
 U - the element type of the buffer-opening sequence
 
 V - the element type of the buffer-closing sequence
 
 C - the Collection buffer type
 
 Parameters:
 
 bucketOpening - a companion Publisher to subscribe for buffer creation signals.
 
 closeSelector - a factory that, given a buffer opening signal, returns a companion Publisher to subscribe to for buffer closure and emission signals.
 
 bufferSupplier - a Supplier of the concrete Collection to use for each buffer
 
 Returns:
 
 a microbatched Flux of Collection delimited by an opening Publisher and a relative closing Publisher
 
 onDiscard Support
 
 This operator discards the currently open buffer upon cancellation or error triggered by a data signal. It DOES NOT provide strong guarantees in the case of overlapping buffers, as elements might get discarded too early (from the first of two overlapping buffers for instance).
 - cache
```
public final Flux<T> cache()
```
 Turn this Flux into a hot source and cache last emitted signals for further Subscriber. Will retain an unbounded volume of onNext signals. Completion and Error will also be replayed.
 
 Returns:
 
 a replaying Flux
 - cache
```
public final Flux<T> cache(int history)
```
 Turn this Flux into a hot source and cache last emitted signals for further Subscriber. Will retain up to the given history size onNext signals. Completion and Error will also be replayed.
 Note that cache(0) will only cache the terminal signal without expiration.
 
 Parameters:
 
 history - number of elements retained in cache
 
 Returns:
 
 a replaying Flux
 - cache
```
public final Flux<T> cache(Duration ttl)
```
 Turn this Flux into a hot source and cache last emitted signals for further Subscriber. Will retain an unbounded history but apply a per-item expiry timeout
 Completion and Error will also be replayed until ttl triggers in which case the next Subscriber will start over a new subscription.
 
 Parameters:
 
 ttl - Time-to-live for each cached item and post termination.
 
 Returns:
 
 a replaying Flux
 - cache
```
public final Flux<T> cache(Duration ttl,
 Scheduler timer)
```
 Turn this Flux into a hot source and cache last emitted signals for further Subscriber. Will retain an unbounded history but apply a per-item expiry timeout
 Completion and Error will also be replayed until ttl triggers in which case the next Subscriber will start over a new subscription.
 
 Parameters:
 
 ttl - Time-to-live for each cached item and post termination.
 
 timer - the Scheduler on which to measure the duration.
 
 Returns:
 
 a replaying Flux
 - cache
```
public final Flux<T> cache(int history,
 Duration ttl)
```
 Turn this Flux into a hot source and cache last emitted signals for further Subscriber. Will retain up to the given history size and apply a per-item expiry timeout.
 Completion and Error will also be replayed until ttl triggers in which case the next Subscriber will start over a new subscription.
 
 Parameters:
 
 history - number of elements retained in cache
 
 ttl - Time-to-live for each cached item and post termination.
 
 Returns:
 
 a replaying Flux
 - cache
```
public final Flux<T> cache(int history,
 Duration ttl,
 Scheduler timer)
```
 Turn this Flux into a hot source and cache last emitted signals for further Subscriber. Will retain up to the given history size and apply a per-item expiry timeout.
 Completion and Error will also be replayed until ttl triggers in which case the next Subscriber will start over a new subscription.
 
 Parameters:
 
 history - number of elements retained in cache
 
 ttl - Time-to-live for each cached item and post termination.
 
 timer - the Scheduler on which to measure the duration.
 
 Returns:
 
 a replaying Flux
 - cast
```
public final <E> Flux<E> cast(Class<E> clazz)
```
 Cast the current Flux produced type into a target produced type.
 
 Type Parameters:
 
 E - the Flux output type
 
 Parameters:
 
 clazz - the target class to cast to
 
 Returns:
 
 a casted Flux
 - cancelOn
```
public final Flux<T> cancelOn(Scheduler scheduler)
```
 Prepare this Flux so that subscribers will cancel from it on a specified Scheduler.
 
 Parameters:
 
 scheduler - the Scheduler to signal cancel on
 
 Returns:
 
 a scheduled cancel Flux
 - checkpoint
```
public final Flux<T> checkpoint()
```
 Activate assembly tracing for this particular Flux, in case of an error upstream of the checkpoint. Tracing incurs the cost of an exception stack trace creation.
 It should be placed towards the end of the reactive chain, as errors triggered downstream of it cannot be observed and augmented with assembly trace.
 
 Returns:
 
 the assembly tracing Flux.
 - checkpoint
```
public final Flux<T> checkpoint(String description)
```
 Activate assembly marker for this particular Flux by giving it a description that will be reflected in the assembly traceback in case of an error upstream of the checkpoint. Note that unlike checkpoint(), this doesn't create a filled stack trace, avoiding the main cost of the operator. However, as a trade-off the description must be unique enough for the user to find out where this Flux was assembled. If you only want a generic description, and still rely on the stack trace to find the assembly site, use the checkpoint(String, boolean) variant.
 It should be placed towards the end of the reactive chain, as errors triggered downstream of it cannot be observed and augmented with assembly trace.
 
 Parameters:
 
 description - a unique enough description to include in the light assembly traceback.
 
 Returns:
 
 the assembly marked Flux
 - checkpoint
```
public final Flux<T> checkpoint(@Nullable
 String description,
 boolean forceStackTrace)
```
 Activate assembly tracing or the lighter assembly marking depending on the forceStackTrace option.
 By setting the forceStackTrace parameter to true, activate assembly tracing for this particular Flux and give it a description that will be reflected in the assembly traceback in case of an error upstream of the checkpoint. Note that unlike checkpoint(String), this will incur the cost of an exception stack trace creation. The description could for example be a meaningful name for the assembled flux or a wider correlation ID, since the stack trace will always provide enough information to locate where this Flux was assembled.
 By setting forceStackTrace to false, behaves like checkpoint(String) and is subject to the same caveat in choosing the description.
 It should be placed towards the end of the reactive chain, as errors triggered downstream of it cannot be observed and augmented with assembly marker.
 
 Parameters:
 
 description - a description (must be unique enough if forceStackTrace is set to false).
 
 forceStackTrace - false to make a light checkpoint without a stacktrace, true to use a stack trace.
 
 Returns:
 
 the assembly marked Flux.
 - collect
```
public final <E> Mono<E> collect(Supplier<E> containerSupplier,
 BiConsumer<E,? super T> collector)
```
 Collect all elements emitted by this Flux into a user-defined container, by applying a collector BiConsumer taking the container and each element. The collected result will be emitted when this sequence completes.
 
 Type Parameters:
 
 E - the container type
 
 Parameters:
 
 containerSupplier - the supplier of the container instance for each Subscriber
 
 collector - a consumer of both the container instance and the value being currently collected
 
 Returns:
 
 a Mono of the collected container on complete
 - collect
```
public final <R,A> Mono<R> collect(Collector<? super T,A,? extends R> collector)
```
 Collect all elements emitted by this Flux into a container, by applying a Java 8 Stream API Collector The collected result will be emitted when this sequence completes.
 
 Type Parameters:
 
 A - The mutable accumulation type
 
 R - the container type
 
 Parameters:
 
 collector - the Collector
 
 Returns:
 
 a Mono of the collected container on complete
 - collectList
```
public final Mono<List<T>> collectList()
```
 Collect all elements emitted by this Flux into a List that is emitted by the resulting Mono when this sequence completes.
 
 Returns:
 
 a Mono of a List of all values from this Flux
 - collectMap
```
public final <K> Mono<Map<K,T>> collectMap(Function<? super T,? extends K> keyExtractor)
```
 Collect all elements emitted by this Flux into a hashed Map that is emitted by the resulting Mono when this sequence completes. The key is extracted from each element by applying the keyExtractor Function. In case several elements map to the same key, the associated value will be the most recently emitted element.
 
 Type Parameters:
 
 K - the type of the key extracted from each source element
 
 Parameters:
 
 keyExtractor - a Function to map elements to a key for the Map
 
 Returns:
 
 a Mono of a Map of key-element pairs (only including latest element in case of key conflicts)
 - collectMap
```
public final <K,V> Mono<Map<K,V>> collectMap(Function<? super T,? extends K> keyExtractor,
 Function<? super T,? extends V> valueExtractor)
```
 Collect all elements emitted by this Flux into a hashed Map that is emitted by the resulting Mono when this sequence completes. The key is extracted from each element by applying the keyExtractor Function, and the value is extracted by the valueExtractor Function. In case several elements map to the same key, the associated value will be derived from the most recently emitted element.
 
 Type Parameters:
 
 K - the type of the key extracted from each source element
 
 V - the type of the value extracted from each source element
 
 Parameters:
 
 keyExtractor - a Function to map elements to a key for the Map
 
 valueExtractor - a Function to map elements to a value for the Map
 
 Returns:
 
 a Mono of a Map of key-element pairs (only including latest element's value in case of key conflicts)
 - collectMap
```
public final <K,V> Mono<Map<K,V>> collectMap(Function<? super T,? extends K> keyExtractor,
 Function<? super T,? extends V> valueExtractor,
 Supplier<Map<K,V>> mapSupplier)
```
 Collect all elements emitted by this Flux into a user-defined Map that is emitted by the resulting Mono when this sequence completes. The key is extracted from each element by applying the keyExtractor Function, and the value is extracted by the valueExtractor Function. In case several elements map to the same key, the associated value will be derived from the most recently emitted element.
 
 Type Parameters:
 
 K - the type of the key extracted from each source element
 
 V - the type of the value extracted from each source element
 
 Parameters:
 
 keyExtractor - a Function to map elements to a key for the Map
 
 valueExtractor - a Function to map elements to a value for the Map
 
 mapSupplier - a Map factory called for each Subscriber
 
 Returns:
 
 a Mono of a Map of key-value pairs (only including latest element's value in case of key conflicts)
 - collectMultimap
```
public final <K> Mono<Map<K,Collection<T>>> collectMultimap(Function<? super T,? extends K> keyExtractor)
```
 Collect all elements emitted by this Flux into a multimap that is emitted by the resulting Mono when this sequence completes. The key is extracted from each element by applying the keyExtractor Function, and every element mapping to the same key is stored in the List associated to said key.
 
 Type Parameters:
 
 K - the type of the key extracted from each source element
 
 Parameters:
 
 keyExtractor - a Function to map elements to a key for the Map
 
 Returns:
 
 a Mono of a Map of key-List(elements) pairs
 - collectMultimap
```
public final <K,V> Mono<Map<K,Collection<V>>> collectMultimap(Function<? super T,? extends K> keyExtractor,
 Function<? super T,? extends V> valueExtractor)
```
 Collect all elements emitted by this Flux into a multimap that is emitted by the resulting Mono when this sequence completes. The key is extracted from each element by applying the keyExtractor Function, and every element mapping to the same key is converted by the valueExtractor Function to a value stored in the List associated to said key.
 
 Type Parameters:
 
 K - the type of the key extracted from each source element
 
 V - the type of the value extracted from each source element
 
 Parameters:
 
 keyExtractor - a Function to map elements to a key for the Map
 
 valueExtractor - a Function to map elements to a value for the Map
 
 Returns:
 
 a Mono of a Map of key-List(values) pairs
 - collectMultimap
```
public final <K,V> Mono<Map<K,Collection<V>>> collectMultimap(Function<? super T,? extends K> keyExtractor,
 Function<? super T,? extends V> valueExtractor,
 Supplier<Map<K,Collection<V>>> mapSupplier)
```
 Collect all elements emitted by this Flux into a user-defined multimap that is emitted by the resulting Mono when this sequence completes. The key is extracted from each element by applying the keyExtractor Function, and every element mapping to the same key is converted by the valueExtractor Function to a value stored in the Collection associated to said key.
 
 Type Parameters:
 
 K - the type of the key extracted from each source element
 
 V - the type of the value extracted from each source element
 
 Parameters:
 
 keyExtractor - a Function to map elements to a key for the Map
 
 valueExtractor - a Function to map elements to a value for the Map
 
 mapSupplier - a multimap (Map of Collection) factory called for each Subscriber
 
 Returns:
 
 a Mono of a Map of key-Collection(values) pairs
 - collectSortedList
```
public final Mono<List<T>> collectSortedList()
```
 Collect all elements emitted by this Flux until this sequence completes, and then sort them in natural order into a List that is emitted by the resulting Mono.
 
 Returns:
 
 a Mono of a sorted List of all values from this Flux, in natural order
 - collectSortedList
```
public final Mono<List<T>> collectSortedList(@Nullable
 Comparator<? super T> comparator)
```
 Collect all elements emitted by this Flux until this sequence completes, and then sort them using a Comparator into a List that is emitted by the resulting Mono.
 
 Parameters:
 
 comparator - a Comparator to sort the items of this sequences
 
 Returns:
 
 a Mono of a sorted List of all values from this Flux
 - compose
```
public final <V> Flux<V> compose(Function<? super Flux<T>,? extends Publisher<V>> transformer)
```
 Defer the transformation of this Flux in order to generate a target Flux type. A transformation will occur for each Subscriber. For instance:
 flux.compose(Mono::from).subscribe()
 Type Parameters:
 
 V - the item type in the returned Publisher
 
 Parameters:
 
 transformer - the Function to lazily map this Flux into a target Publisher instance for each new subscriber
 
 Returns:
 
 a new Flux
 
 See Also:
 
 transform() for immmediate transformation of {@link Flux}, as() for a loose conversion to an arbitrary type
 - concatMap
```
public final <V> Flux<V> concatMap(Function<? super T,? extends Publisher<? extends V>> mapper)
```
 Transform the elements emitted by this Flux asynchronously into Publishers, then flatten these inner publishers into a single Flux, sequentially and preserving order using concatenation.
 There are three dimensions to this operator that can be compared with flatMap and flatMapSequential:
 - Generation of inners and subscription: this operator waits for one inner to complete before generating the next one and subscribing to it.
 - Ordering of the flattened values: this operator naturally preserves the same order as the source elements, concatenating the inners from each source element sequentially.
 - Interleaving: this operator does not let values from different inners interleave (concatenation).
 Errors will immediately short circuit current concat backlog.
 Type Parameters:
 
 V - the produced concatenated type
 
 Parameters:
 
 mapper - the function to transform this sequence of T into concatenated sequences of V
 
 Returns:
 
 a concatenated Flux
 
 onDiscard Support
 
 This operator discards elements it internally queued for backpressure upon cancellation.
 - concatMap
```
public final <V> Flux<V> concatMap(Function<? super T,? extends Publisher<? extends V>> mapper,
 int prefetch)
```
 Transform the elements emitted by this Flux asynchronously into Publishers, then flatten these inner publishers into a single Flux, sequentially and preserving order using concatenation.
 There are three dimensions to this operator that can be compared with flatMap and flatMapSequential:
 - Generation of inners and subscription: this operator waits for one inner to complete before generating the next one and subscribing to it.
 - Ordering of the flattened values: this operator naturally preserves the same order as the source elements, concatenating the inners from each source element sequentially.
 - Interleaving: this operator does not let values from different inners interleave (concatenation).
 Errors will immediately short circuit current concat backlog. The prefetch argument allows to give an arbitrary prefetch size to the inner Publisher.
 Type Parameters:
 
 V - the produced concatenated type
 
 Parameters:
 
 mapper - the function to transform this sequence of T into concatenated sequences of V
 
 prefetch - the inner source produced demand
 
 Returns:
 
 a concatenated Flux
 
 onDiscard Support
 
 This operator discards elements it internally queued for backpressure upon cancellation.
 - concatMapDelayError
```
public final <V> Flux<V> concatMapDelayError(Function<? super T,? extends Publisher<? extends V>> mapper)
```
 Transform the elements emitted by this Flux asynchronously into Publishers, then flatten these inner publishers into a single Flux, sequentially and preserving order using concatenation.
 There are three dimensions to this operator that can be compared with flatMap and flatMapSequential:
 - Generation of inners and subscription: this operator waits for one inner to complete before generating the next one and subscribing to it.
 - Ordering of the flattened values: this operator naturally preserves the same order as the source elements, concatenating the inners from each source element sequentially.
 - Interleaving: this operator does not let values from different inners interleave (concatenation).
 Errors in the individual publishers will be delayed at the end of the whole concat sequence (possibly getting combined into a composite if several sources error.
 Type Parameters:
 
 V - the produced concatenated type
 
 Parameters:
 
 mapper - the function to transform this sequence of T into concatenated sequences of V
 
 Returns:
 
 a concatenated Flux
 
 onDiscard Support
 
 This operator discards elements it internally queued for backpressure upon cancellation.
 - concatMapDelayError
```
public final <V> Flux<V> concatMapDelayError(Function<? super T,? extends Publisher<? extends V>> mapper,
 int prefetch)
```
 Transform the elements emitted by this Flux asynchronously into Publishers, then flatten these inner publishers into a single Flux, sequentially and preserving order using concatenation.
 There are three dimensions to this operator that can be compared with flatMap and flatMapSequential:
 - Generation of inners and subscription: this operator waits for one inner to complete before generating the next one and subscribing to it.
 - Ordering of the flattened values: this operator naturally preserves the same order as the source elements, concatenating the inners from each source element sequentially.
 - Interleaving: this operator does not let values from different inners interleave (concatenation).
 Errors in the individual publishers will be delayed at the end of the whole concat sequence (possibly getting combined into a composite if several sources error. The prefetch argument allows to give an arbitrary prefetch size to the inner Publisher.
 Type Parameters:
 
 V - the produced concatenated type
 
 Parameters:
 
 mapper - the function to transform this sequence of T into concatenated sequences of V
 
 prefetch - the inner source produced demand
 
 Returns:
 
 a concatenated Flux
 
 onDiscard Support
 
 This operator discards elements it internally queued for backpressure upon cancellation.
 - concatMapDelayError
```
public final <V> Flux<V> concatMapDelayError(Function<? super T,? extends Publisher<? extends V>> mapper,
 boolean delayUntilEnd,
 int prefetch)
```
 Transform the elements emitted by this Flux asynchronously into Publishers, then flatten these inner publishers into a single Flux, sequentially and preserving order using concatenation.
 There are three dimensions to this operator that can be compared with flatMap and flatMapSequential:
 - Generation of inners and subscription: this operator waits for one inner to complete before generating the next one and subscribing to it.
 - Ordering of the flattened values: this operator naturally preserves the same order as the source elements, concatenating the inners from each source element sequentially.
 - Interleaving: this operator does not let values from different inners interleave (concatenation).
 Errors in the individual publishers will be delayed after the current concat backlog if delayUntilEnd is false or after all sources if delayUntilEnd is true. The prefetch argument allows to give an arbitrary prefetch size to the inner Publisher.
 Type Parameters:
 
 V - the produced concatenated type
 
 Parameters:
 
 mapper - the function to transform this sequence of T into concatenated sequences of V
 
 delayUntilEnd - delay error until all sources have been consumed instead of after the current source
 
 prefetch - the inner source produced demand
 
 Returns:
 
 a concatenated Flux
 
 onDiscard Support
 
 This operator discards elements it internally queued for backpressure upon cancellation.
 - concatMapIterable
```
public final <R> Flux<R> concatMapIterable(Function<? super T,? extends Iterable<? extends R>> mapper)
```
 Transform the items emitted by this Flux into Iterable, then flatten the elements from those by concatenating them into a single Flux.
 
 Note that unlike flatMap(Function) and concatMap(Function), with Iterable there is no notion of eager vs lazy inner subscription. The content of the Iterables are all played sequentially. Thus flatMapIterable and concatMapIterable are equivalent offered as a discoverability improvement for users that explore the API with the concat vs flatMap expectation.
 
 Type Parameters:
 
 R - the merged output sequence type
 
 Parameters:
 
 mapper - the Function to transform input sequence into N Iterable
 
 Returns:
 
 a concatenation of the values from the Iterables obtained from each element in this Flux
 
 onDiscard Support
 
 This operator discards elements it internally queued for backpressure upon cancellation.
 - concatMapIterable
```
public final <R> Flux<R> concatMapIterable(Function<? super T,? extends Iterable<? extends R>> mapper,
 int prefetch)
```
 Transform the items emitted by this Flux into Iterable, then flatten the emissions from those by concatenating them into a single Flux. The prefetch argument allows to give an arbitrary prefetch size to the merged Iterable.
 
 Note that unlike flatMap(Function) and concatMap(Function), with Iterable there is no notion of eager vs lazy inner subscription. The content of the Iterables are all played sequentially. Thus flatMapIterable and concatMapIterable are equivalent offered as a discoverability improvement for users that explore the API with the concat vs flatMap expectation.
 
 Type Parameters:
 
 R - the merged output sequence type
 
 Parameters:
 
 mapper - the Function to transform input sequence into N Iterable
 
 prefetch - the maximum in-flight elements from each inner Iterable sequence
 
 Returns:
 
 a concatenation of the values from the Iterables obtained from each element in this Flux
 
 onDiscard Support
 
 This operator discards elements it internally queued for backpressure upon cancellation.
 - concatWith
```
public final Flux<T> concatWith(Publisher<? extends T> other)
```
 Concatenate emissions of this Flux with the provided Publisher (no interleave).
 
 Parameters:
 
 other - the Publisher sequence to concat after this Flux
 
 Returns:
 
 a concatenated Flux
 - count
```
public final Mono<Long> count()
```
 Counts the number of values in this Flux. The count will be emitted when onComplete is observed.
 
 Returns:
 
 a new Mono of Long count
 - defaultIfEmpty
```
public final Flux<T> defaultIfEmpty(T defaultV)
```
 Provide a default unique value if this sequence is completed without any data
 
 Parameters:
 
 defaultV - the alternate value if this sequence is empty
 
 Returns:
 
 a new Flux
 - delayElements
```
public final Flux<T> delayElements(Duration delay)
```
 Delay each of this Flux elements (Subscriber.onNext(T) signals) by a given Duration. Signals are delayed and continue on the parallel default Scheduler, but empty sequences or immediate error signals are not delayed.
 
 Parameters:
 
 delay - duration by which to delay each Subscriber.onNext(T) signal
 
 Returns:
 
 a delayed Flux
 
 See Also:
 
 delaySubscription to introduce a delay at the beginning of the sequence only
 - delayElements
```
public final Flux<T> delayElements(Duration delay,
 Scheduler timer)
```
 Delay each of this Flux elements (Subscriber.onNext(T) signals) by a given Duration. Signals are delayed and continue on an user-specified Scheduler, but empty sequences or immediate error signals are not delayed.
 
 Parameters:
 
 delay - period to delay each Subscriber.onNext(T) signal
 
 timer - a time-capable Scheduler instance to delay each signal on
 
 Returns:
 
 a delayed Flux
 - delaySequence
```
public final Flux<T> delaySequence(Duration delay)
```
 Shift this Flux forward in time by a given Duration. Unlike with delayElements(Duration), elements are shifted forward in time as they are emitted, always resulting in the delay between two elements being the same as in the source (only the first element is visibly delayed from the previous event, that is the subscription). Signals are delayed and continue on the parallel Scheduler, but empty sequences or immediate error signals are not delayed.
 With this operator, a source emitting at 10Hz with a delaySequence Duration of 1s will still emit at 10Hz, with an initial "hiccup" of 1s. On the other hand, delayElements(Duration) would end up emitting at 1Hz.
 This is closer to delaySubscription(Duration), except the source is subscribed to immediately.
 
 Parameters:
 
 delay - Duration to shift the sequence by
 
 Returns:
 
 an shifted Flux emitting at the same frequency as the source
 - delaySequence
```
public final Flux<T> delaySequence(Duration delay,
 Scheduler timer)
```
 Shift this Flux forward in time by a given Duration. Unlike with delayElements(Duration, Scheduler), elements are shifted forward in time as they are emitted, always resulting in the delay between two elements being the same as in the source (only the first element is visibly delayed from the previous event, that is the subscription). Signals are delayed and continue on an user-specified Scheduler, but empty sequences or immediate error signals are not delayed.
 With this operator, a source emitting at 10Hz with a delaySequence Duration of 1s will still emit at 10Hz, with an initial "hiccup" of 1s. On the other hand, delayElements(Duration, Scheduler) would end up emitting at 1Hz.
 This is closer to delaySubscription(Duration, Scheduler), except the source is subscribed to immediately.
 
 Parameters:
 
 delay - Duration to shift the sequence by
 
 timer - a time-capable Scheduler instance to delay signals on
 
 Returns:
 
 an shifted Flux emitting at the same frequency as the source
 - delayUntil
```
public final Flux<T> delayUntil(Function<? super T,? extends Publisher<?>> triggerProvider)
```
 Subscribe to this Flux and generate a Publisher from each of this Flux elements, each acting as a trigger for relaying said element.
 That is to say, the resulting Flux delays each of its emission until the associated trigger Publisher terminates.
 In case of an error either in the source or in a trigger, that error is propagated immediately downstream. Note that unlike with the Mono variant there is no fusion of subsequent calls.
 
 Parameters:
 
 triggerProvider - a Function that maps each element into a Publisher whose termination will trigger relaying the value.
 
 Returns:
 
 this Flux, but with elements delayed until their derived publisher terminates.
 - delaySubscription
```
public final Flux<T> delaySubscription(Duration delay)
```
 Delay the subscription to this Flux source until the given period elapses. The delay is introduced through the parallel default Scheduler.
 
 Parameters:
 
 delay - duration before subscribing this Flux
 
 Returns:
 
 a delayed Flux
 - delaySubscription
```
public final Flux<T> delaySubscription(Duration delay,
 Scheduler timer)
```
 Delay the subscription to this Flux source until the given period elapses, as measured on the user-provided Scheduler.
 
 Parameters:
 
 delay - Duration before subscribing this Flux
 
 timer - a time-capable Scheduler instance to run on
 
 Returns:
 
 a delayed Flux
 - delaySubscription
```
public final  Flux<T> delaySubscription(Publisher subscriptionDelay)
```
 Delay the subscription to this Flux source until another Publisher signals a value or completes.
 
 Type Parameters:
 
 U - the other source type
 
 Parameters:
 
 subscriptionDelay - a companion Publisher whose onNext/onComplete signal will trigger the subscription
 
 Returns:
 
 a delayed Flux
 - dematerialize
```
public final <X> Flux<X> dematerialize()
```
 An operator working only if this Flux emits onNext, onError or onComplete Signal instances, transforming these materialized signals into real signals on the Subscriber. The error Signal will trigger onError and complete Signal will trigger onComplete.
 
 Type Parameters:
 
 X - the dematerialized type
 
 Returns:
 
 a dematerialized Flux
 
 See Also:
 
 materialize()
 - distinct
```
public final Flux<T> distinct()
```
 For each Subscriber, track elements from this Flux that have been seen and filter out duplicates.
 The values themselves are recorded into a HashSet for distinct detection. Use distinct(Object::hashcode) if you want a more lightweight approach that doesn't retain all the objects, but is more susceptible to falsely considering two elements as distinct due to a hashcode collision.
 
 Returns:
 
 a filtering Flux only emitting distinct values
 
 onDiscard Support
 
 This operator discards elements that don't match the distinct predicate, but you should use the version with a cleanup if you need discarding of keys categorized by the operator as "seen". See distinct(Function, Supplier, BiPredicate, Consumer).
 - distinct
```
public final <V> Flux<T> distinct(Function<? super T,? extends V> keySelector)
```
 For each Subscriber, track elements from this Flux that have been seen and filter out duplicates, as compared by a key extracted through the user provided Function.
 
 Type Parameters:
 
 V - the type of the key extracted from each value in this sequence
 
 Parameters:
 
 keySelector - function to compute comparison key for each element
 
 Returns:
 
 a filtering Flux only emitting values with distinct keys
 
 onDiscard Support
 
 This operator discards elements that don't match the distinct predicate, but you should use the version with a cleanup if you need discarding of keys categorized by the operator as "seen". See distinct(Function, Supplier, BiPredicate, Consumer).
 - distinct
```
public final <V,C extends Collection<? super V>> Flux<T> distinct(Function<? super T,? extends V> keySelector,
 Supplier<C> distinctCollectionSupplier)
```
 For each Subscriber, track elements from this Flux that have been seen and filter out duplicates, as compared by a key extracted through the user provided Function and by the add method of the Collection supplied (typically a Set).
 
 Type Parameters:
 
 V - the type of the key extracted from each value in this sequence
 
 C - the type of Collection used for distinct checking of keys
 
 Parameters:
 
 keySelector - function to compute comparison key for each element
 
 distinctCollectionSupplier - supplier of the Collection used for distinct check through add of the key.
 
 Returns:
 
 a filtering Flux only emitting values with distinct keys
 
 onDiscard Support
 
 This operator discards elements that don't match the distinct predicate, but you should use the version with a cleanup if you need discarding of keys categorized by the operator as "seen". See distinct(Function, Supplier, BiPredicate, Consumer).
 - distinct
```
public final <V,C> Flux<T> distinct(Function<? super T,? extends V> keySelector,
 Supplier<C> distinctStoreSupplier,
 BiPredicate<C,V> distinctPredicate,
 Consumer<C> cleanup)
```
 For each Subscriber, track elements from this Flux that have been seen and filter out duplicates, as compared by applying a BiPredicate on an arbitrary user-supplied <C> store and a key extracted through the user provided Function. The BiPredicate should typically add the key to the arbitrary store for further comparison. A cleanup callback is also invoked on the store upon termination of the sequence.
 
 Type Parameters:
 
 V - the type of the key extracted from each value in this sequence
 
 C - the type of store backing the BiPredicate
 
 Parameters:
 
 keySelector - function to compute comparison key for each element
 
 distinctStoreSupplier - supplier of the arbitrary store object used in distinct checks along the extracted key.
 
 distinctPredicate - the BiPredicate to apply to the arbitrary store + extracted key to perform a distinct check. Since nothing is assumed of the store, this predicate should also add the key to the store as necessary.
 
 cleanup - the cleanup callback to invoke on the store upon termination.
 
 Returns:
 
 a filtering Flux only emitting values with distinct keys
 
 onDiscard Support
 
 This operator discards elements that don't match the distinct predicate, but you should use the cleanup as well if you need discarding of keys categorized by the operator as "seen".
 - distinctUntilChanged
```
public final Flux<T> distinctUntilChanged()
```
 Filter out subsequent repetitions of an element (that is, if they arrive right after one another).
 
 The last distinct value seen is retained for further comparison, which is done on the values themselves using the equals method. Use distinctUntilChanged(Object::hashcode) if you want a more lightweight approach that doesn't retain all the objects, but is more susceptible to falsely considering two elements as distinct due to a hashcode collision.
 
 Returns:
 
 a filtering Flux with only one occurrence in a row of each element (yet elements can repeat in the overall sequence)
 
 onDiscard Support
 
 Although this operator discards elements that are considered as "already seen", it is not recommended for cases where discarding is needed as the operator doesn't discard the "key" (in this context, the distinct instance that was last seen).
 - distinctUntilChanged
```
public final <V> Flux<T> distinctUntilChanged(Function<? super T,? extends V> keySelector)
```
 Filter out subsequent repetitions of an element (that is, if they arrive right after one another), as compared by a key extracted through the user provided Function using equality.
 
 Type Parameters:
 
 V - the type of the key extracted from each value in this sequence
 
 Parameters:
 
 keySelector - function to compute comparison key for each element
 
 Returns:
 
 a filtering Flux with only one occurrence in a row of each element of the same key (yet element keys can repeat in the overall sequence)
 
 onDiscard Support
 
 This operator discards elements that are considered as "already seen". The keys themselves are not discarded.
 - distinctUntilChanged
```
public final <V> Flux<T> distinctUntilChanged(Function<? super T,? extends V> keySelector,
 BiPredicate<? super V,? super V> keyComparator)
```
 Filter out subsequent repetitions of an element (that is, if they arrive right after one another), as compared by a key extracted through the user provided Function and then comparing keys with the supplied BiPredicate.
 
 Type Parameters:
 
 V - the type of the key extracted from each value in this sequence
 
 Parameters:
 
 keySelector - function to compute comparison key for each element
 
 keyComparator - predicate used to compare keys.
 
 Returns:
 
 a filtering Flux with only one occurrence in a row of each element of the same key for which the predicate returns true (yet element keys can repeat in the overall sequence)
 
 onDiscard Support
 
 This operator discards elements that are considered as "already seen" (for which the keyComparator returns true). The keys themselves are not discarded.
 - doAfterTerminate
```
public final Flux<T> doAfterTerminate(Runnable afterTerminate)
```
 Add behavior (side-effect) triggered after the Flux terminates, either by completing downstream successfully or with an error.
 
 Parameters:
 
 afterTerminate - the callback to call after Subscriber.onComplete() or Subscriber.onError(java.lang.Throwable)
 
 Returns:
 
 an observed Flux
 - doOnCancel
```
public final Flux<T> doOnCancel(Runnable onCancel)
```
 Add behavior (side-effect) triggered when the Flux is cancelled.
 
 Parameters:
 
 onCancel - the callback to call on Subscription.cancel()
 
 Returns:
 
 an observed Flux
 - doOnComplete
```
public final Flux<T> doOnComplete(Runnable onComplete)
```
 Add behavior (side-effect) triggered when the Flux completes successfully.
 
 Parameters:
 
 onComplete - the callback to call on Subscriber.onComplete()
 
 Returns:
 
 an observed Flux
 - doOnDiscard
```
public final <R> Flux<T> doOnDiscard(Class<R> type,
 Consumer<? super R> discardHook)
```
 Modify the behavior of the whole chain of operators upstream of this one to conditionally clean up elements that get discarded by these operators.
 The discardHook must be idempotent and safe to use on any instance of the desired type. Calls to this method are additive, and the order of invocation of the discardHook is the same as the order of declaration (calling .filter(...).doOnDiscard(first).doOnDiscard(second) will let the filter invoke first then second handlers).
 Two main categories of discarding operators exist:
 - filtering operators, dropping some source elements as part of their designed behavior
 - operators that prefetch a few elements and keep them around pending a request, but get cancelled/in error
 These operators are identified in the javadoc by the presence of an onDiscard Support section.
 Parameters:
 
 type - the Class of elements in the upstream chain of operators that this cleanup hook should take into account.
 
 discardHook - a Consumer of elements in the upstream chain of operators that performs the cleanup.
 
 Returns:
 
 a Flux that cleans up matching elements that get discarded upstream of it.
 - doOnEach
```
public final Flux<T> doOnEach(Consumer<? super Signal<T>> signalConsumer)
```
 Add behavior (side-effects) triggered when the Flux emits an item, fails with an error or completes successfully. All these events are represented as a Signal that is passed to the side-effect callback. Note that this is an advanced operator, typically used for monitoring of a Flux. These Signal have a Context associated to them.
 
 Parameters:
 
 signalConsumer - the mandatory callback to call on Subscriber.onNext(Object), Subscriber.onError(Throwable) and Subscriber.onComplete()
 
 Returns:
 
 an observed Flux
 
 See Also:
 
 doOnNext(Consumer), doOnError(Consumer), doOnComplete(Runnable), materialize(), Signal
 - doOnError
```
public final Flux<T> doOnError(Consumer<? super Throwable> onError)
```
 Add behavior (side-effect) triggered when the Flux completes with an error.
 
 Parameters:
 
 onError - the callback to call on Subscriber.onError(java.lang.Throwable)
 
 Returns:
 
 an observed Flux
 - doOnError
```
public final <E extends Throwable> Flux<T> doOnError(Class<E> exceptionType,
 Consumer<? super E> onError)
```
 Add behavior (side-effect) triggered when the Flux completes with an error matching the given exception type.
 
 Type Parameters:
 
 E - type of the error to handle
 
 Parameters:
 
 exceptionType - the type of exceptions to handle
 
 onError - the error handler for each error
 
 Returns:
 
 an observed Flux
 - doOnError
```
public final Flux<T> doOnError(Predicate<? super Throwable> predicate,
 Consumer<? super Throwable> onError)
```
 Add behavior (side-effect) triggered when the Flux completes with an error matching the given exception.
 
 Parameters:
 
 predicate - the matcher for exceptions to handle
 
 onError - the error handler for each error
 
 Returns:
 
 an observed Flux
 - doOnNext
```
public final Flux<T> doOnNext(Consumer<? super T> onNext)
```
 Add behavior (side-effect) triggered when the Flux emits an item.
 
 Parameters:
 
 onNext - the callback to call on Subscriber.onNext(T)
 
 Returns:
 
 an observed Flux
 
 Error Mode Support
 
 This operator supports resuming on errors (including when fusion is enabled). Exceptions thrown by the consumer are passed to the onErrorContinue(BiConsumer) error consumer (the value consumer is not invoked, as the source element will be part of the sequence). The onNext signal is then propagated as normal.
 - doOnRequest
```
public final Flux<T> doOnRequest(LongConsumer consumer)
```
 Add behavior (side-effect) triggering a LongConsumer when this Flux receives any request.
 Note that non fatal error raised in the callback will not be propagated and will simply trigger Operators.onOperatorError(Throwable, Context).
 
 Parameters:
 
 consumer - the consumer to invoke on each request
 
 Returns:
 
 an observed Flux
 - doOnSubscribe
```
public final Flux<T> doOnSubscribe(Consumer<? super Subscription> onSubscribe)
```
 Add behavior (side-effect) triggered when the Flux is subscribed.
 This method is not intended for capturing the subscription and calling its methods, but for side effects like monitoring. For instance, the correct way to cancel a subscription is to call Disposable.dispose() on the Disposable returned by subscribe().
 
 Parameters:
 
 onSubscribe - the callback to call on Subscriber.onSubscribe(org.reactivestreams.Subscription)
 
 Returns:
 
 an observed Flux
 - doOnTerminate
```
public final Flux<T> doOnTerminate(Runnable onTerminate)
```
 Add behavior (side-effect) triggered when the Flux terminates, either by completing successfully or with an error.
 
 Parameters:
 
 onTerminate - the callback to call on Subscriber.onComplete() or Subscriber.onError(java.lang.Throwable)
 
 Returns:
 
 an observed Flux
 - doFinally
```
public final Flux<T> doFinally(Consumer<SignalType> onFinally)
```
 Add behavior (side-effect) triggered after the Flux terminates for any reason, including cancellation. The terminating event (SignalType.ON_COMPLETE, SignalType.ON_ERROR and SignalType.CANCEL) is passed to the consumer, which is executed after the signal has been passed downstream.
 Note that the fact that the signal is propagated downstream before the callback is executed means that several doFinally in a row will be executed in reverse order. If you want to assert the execution of the callback please keep in mind that the Flux will complete before it is executed, so its effect might not be visible immediately after eg. a blockLast().
 
 Parameters:
 
 onFinally - the callback to execute after a terminal signal (complete, error or cancel)
 
 Returns:
 
 an observed Flux
 - elapsed
```
public final Flux<Tuple2<Long,T>> elapsed()
```
 Map this Flux into Tuple2<Long, T> of timemillis and source data. The timemillis corresponds to the elapsed time between each signal as measured by the parallel scheduler. First duration is measured between the subscription and the first element.
 
 Returns:
 
 a new Flux that emits a tuple of time elapsed in milliseconds and matching data
 - elapsed
```
public final Flux<Tuple2<Long,T>> elapsed(Scheduler scheduler)
```
 Map this Flux into Tuple2<Long, T> of timemillis and source data. The timemillis corresponds to the elapsed time between each signal as measured by the provided Scheduler. First duration is measured between the subscription and the first element.
 
 Parameters:
 
 scheduler - a Scheduler instance to read time from
 
 Returns:
 
 a new Flux that emits tuples of time elapsed in milliseconds and matching data
 - elementAt
```
public final Mono<T> elementAt(int index)
```
 Emit only the element at the given index position or IndexOutOfBoundsException if the sequence is shorter.
 
 Parameters:
 
 index - zero-based index of the only item to emit
 
 Returns:
 
 a Mono of the item at the specified zero-based index
 
 onDiscard Support
 
 This operator discards elements that appear before the requested index.
 - elementAt
```
public final Mono<T> elementAt(int index,
 T defaultValue)
```
 Emit only the element at the given index position or fall back to a default value if the sequence is shorter.
 
 Parameters:
 
 index - zero-based index of the only item to emit
 
 defaultValue - a default value to emit if the sequence is shorter
 
 Returns:
 
 a Mono of the item at the specified zero-based index or a default value
 
 onDiscard Support
 
 This operator discards elements that appear before the requested index.
 - expandDeep
```
public final Flux<T> expandDeep(Function<? super T,? extends Publisher<? extends T>> expander,
 int capacityHint)
```
 Recursively expand elements into a graph and emit all the resulting element, in a depth-first traversal order.
 That is: emit one value from this Flux, expand it and emit the first value at this first level of recursion, and so on... When no more recursion is possible, backtrack to the previous level and re-apply the strategy.
 For example, given the hierarchical structure
```
 A
 - AA
 - aa1
 B
 - BB
 - bb1
 
```
 Expands Flux.just(A, B) into
```
 A
 AA
 aa1
 B
 BB
 bb1
 
```
 Parameters:
 
 expander - the Function applied at each level of recursion to expand values into a Publisher, producing a graph.
 
 capacityHint - a capacity hint to prepare the inner queues to accommodate n elements per level of recursion.
 
 Returns:
 
 a Flux expanded depth-first
 - expandDeep
```
public final Flux<T> expandDeep(Function<? super T,? extends Publisher<? extends T>> expander)
```
 Recursively expand elements into a graph and emit all the resulting element, in a depth-first traversal order.
 That is: emit one value from this Flux, expand it and emit the first value at this first level of recursion, and so on... When no more recursion is possible, backtrack to the previous level and re-apply the strategy.
 For example, given the hierarchical structure
```
 A
 - AA
 - aa1
 B
 - BB
 - bb1
 
```
 Expands Flux.just(A, B) into
```
 A
 AA
 aa1
 B
 BB
 bb1
 
```
 Parameters:
 
 expander - the Function applied at each level of recursion to expand values into a Publisher, producing a graph.
 
 Returns:
 
 a Flux expanded depth-first
 - expand
```
public final Flux<T> expand(Function<? super T,? extends Publisher<? extends T>> expander,
 int capacityHint)
```
 Recursively expand elements into a graph and emit all the resulting element using a breadth-first traversal strategy.
 That is: emit the values from this Flux first, then expand each at a first level of recursion and emit all of the resulting values, then expand all of these at a second level and so on..
 For example, given the hierarchical structure
```
 A
 - AA
 - aa1
 B
 - BB
 - bb1
 
```
 Expands Flux.just(A, B) into
```
 A
 B
 AA
 BB
 aa1
 bb1
 
```
 Parameters:
 
 expander - the Function applied at each level of recursion to expand values into a Publisher, producing a graph.
 
 capacityHint - a capacity hint to prepare the inner queues to accommodate n elements per level of recursion.
 
 Returns:
 
 an breadth-first expanded Flux
 - expand
```
public final Flux<T> expand(Function<? super T,? extends Publisher<? extends T>> expander)
```
 Recursively expand elements into a graph and emit all the resulting element using a breadth-first traversal strategy.
 That is: emit the values from this Flux first, then expand each at a first level of recursion and emit all of the resulting values, then expand all of these at a second level and so on..
 For example, given the hierarchical structure
```
 A
 - AA
 - aa1
 B
 - BB
 - bb1
 
```
 Expands Flux.just(A, B) into
```
 A
 B
 AA
 BB
 aa1
 bb1
 
```
 Parameters:
 
 expander - the Function applied at each level of recursion to expand values into a Publisher, producing a graph.
 
 Returns:
 
 an breadth-first expanded Flux
 - filter
```
public final Flux<T> filter(Predicate<? super T> p)
```
 Evaluate each source value against the given Predicate. If the predicate test succeeds, the value is emitted. If the predicate test fails, the value is ignored and a request of 1 is made upstream.
 
 Parameters:
 
 p - the Predicate to test values against
 
 Returns:
 
 a new Flux containing only values that pass the predicate test
 
 Error Mode Support
 
 This operator supports resuming on errors (including when fusion is enabled). Exceptions thrown by the predicate are considered as if the predicate returned false: they cause the source value to be dropped and a new element (request(1)) being requested from upstream.
 
 onDiscard Support
 
 This operator discards elements that do not match the filter. It also discards elements internally queued for backpressure upon cancellation or error triggered by a data signal.
 - filterWhen
```
public final Flux<T> filterWhen(Function<? super T,? extends Publisher<Boolean>> asyncPredicate)
```
 Test each value emitted by this Flux asynchronously using a generated Publisher<Boolean> test. A value is replayed if the first item emitted by its corresponding test is true. It is dropped if its test is either empty or its first emitted value is false.
 Note that only the first value of the test publisher is considered, and unless it is a Mono, test will be cancelled after receiving that first value. Test publishers are generated and subscribed to in sequence.
 
 Parameters:
 
 asyncPredicate - the function generating a Publisher of Boolean for each value, to filter the Flux with
 
 Returns:
 
 a filtered Flux
 
 onDiscard Support
 
 This operator discards elements that do not match the filter. It also discards elements internally queued for backpressure upon cancellation or error triggered by a data signal.
 - filterWhen
```
public final Flux<T> filterWhen(Function<? super T,? extends Publisher<Boolean>> asyncPredicate,
 int bufferSize)
```
 Test each value emitted by this Flux asynchronously using a generated Publisher<Boolean> test. A value is replayed if the first item emitted by its corresponding test is true. It is dropped if its test is either empty or its first emitted value is false.
 Note that only the first value of the test publisher is considered, and unless it is a Mono, test will be cancelled after receiving that first value. Test publishers are generated and subscribed to in sequence.
 
 Parameters:
 
 asyncPredicate - the function generating a Publisher of Boolean for each value, to filter the Flux with
 
 bufferSize - the maximum expected number of values to hold pending a result of their respective asynchronous predicates, rounded to the next power of two. This is capped depending on the size of the heap and the JVM limits, so be careful with large values (although eg. 65536 should still be fine). Also serves as the initial request size for the source.
 
 Returns:
 
 a filtered Flux
 
 onDiscard Support
 
 This operator discards elements that do not match the filter. It also discards elements internally queued for backpressure upon cancellation or error triggered by a data signal.
 - flatMap
```
public final <R> Flux<R> flatMap(Function<? super T,? extends Publisher<? extends R>> mapper)
```
 Transform the elements emitted by this Flux asynchronously into Publishers, then flatten these inner publishers into a single Flux through merging, which allow them to interleave.
 There are three dimensions to this operator that can be compared with flatMapSequential and concatMap:
 - Generation of inners and subscription: this operator is eagerly subscribing to its inners.
 - Ordering of the flattened values: this operator does not necessarily preserve original ordering, as inner element are flattened as they arrive.
 - Interleaving: this operator lets values from different inners interleave (similar to merging the inner sequences).
 Type Parameters:
 
 R - the merged output sequence type
 
 Parameters:
 
 mapper - the Function to transform input sequence into N sequences Publisher
 
 Returns:
 
 a new Flux
 
 Error Mode Support
 
 This operator supports resuming on errors in the mapper Function. Exceptions thrown by the mapper then behave as if it had mapped the value to an empty publisher. If the mapper does map to a scalar publisher (an optimization in which the value can be resolved immediately without subscribing to the publisher, e.g. a Mono.fromCallable(Callable)) but said publisher throws, this can be resumed from in the same manner.
 
 onDiscard Support
 
 This operator discards elements internally queued for backpressure upon cancellation or error triggered by a data signal.
 - flatMap
```
public final <V> Flux<V> flatMap(Function<? super T,? extends Publisher<? extends V>> mapper,
 int concurrency)
```
 Transform the elements emitted by this Flux asynchronously into Publishers, then flatten these inner publishers into a single Flux through merging, which allow them to interleave.
 There are three dimensions to this operator that can be compared with flatMapSequential and concatMap:
 - Generation of inners and subscription: this operator is eagerly subscribing to its inners.
 - Ordering of the flattened values: this operator does not necessarily preserve original ordering, as inner element are flattened as they arrive.
 - Interleaving: this operator lets values from different inners interleave (similar to merging the inner sequences).
 The concurrency argument allows to control how many Publisher can be subscribed to and merged in parallel. In turn, that argument shows the size of the first Subscription.request(long) to the upstream.
 Type Parameters:
 
 V - the merged output sequence type
 
 Parameters:
 
 mapper - the Function to transform input sequence into N sequences Publisher
 
 concurrency - the maximum number of in-flight inner sequences
 
 Returns:
 
 a new Flux
 
 Error Mode Support
 
 This operator supports resuming on errors in the mapper Function. Exceptions thrown by the mapper then behave as if it had mapped the value to an empty publisher. If the mapper does map to a scalar publisher (an optimization in which the value can be resolved immediately without subscribing to the publisher, e.g. a Mono.fromCallable(Callable)) but said publisher throws, this can be resumed from in the same manner.
 
 onDiscard Support
 
 This operator discards elements internally queued for backpressure upon cancellation or error triggered by a data signal.
 - flatMap
```
public final <V> Flux<V> flatMap(Function<? super T,? extends Publisher<? extends V>> mapper,
 int concurrency,
 int prefetch)
```
 Transform the elements emitted by this Flux asynchronously into Publishers, then flatten these inner publishers into a single Flux through merging, which allow them to interleave.
 There are three dimensions to this operator that can be compared with flatMapSequential and concatMap:
 - Generation of inners and subscription: this operator is eagerly subscribing to its inners.
 - Ordering of the flattened values: this operator does not necessarily preserve original ordering, as inner element are flattened as they arrive.
 - Interleaving: this operator lets values from different inners interleave (similar to merging the inner sequences).
 The concurrency argument allows to control how many Publisher can be subscribed to and merged in parallel. In turn, that argument shows the size of the first Subscription.request(long) to the upstream. The prefetch argument allows to give an arbitrary prefetch size to the merged Publisher (in other words prefetch size means the size of the first Subscription.request(long) to the merged Publisher).
 Type Parameters:
 
 V - the merged output sequence type
 
 Parameters:
 
 mapper - the Function to transform input sequence into N sequences Publisher
 
 concurrency - the maximum number of in-flight inner sequences
 
 prefetch - the maximum in-flight elements from each inner Publisher sequence
 
 Returns:
 
 a merged Flux
 
 Error Mode Support
 
 This operator supports resuming on errors in the mapper Function. Exceptions thrown by the mapper then behave as if it had mapped the value to an empty publisher. If the mapper does map to a scalar publisher (an optimization in which the value can be resolved immediately without subscribing to the publisher, e.g. a Mono.fromCallable(Callable)) but said publisher throws, this can be resumed from in the same manner.
 
 onDiscard Support
 
 This operator discards elements internally queued for backpressure upon cancellation or error triggered by a data signal.
 - flatMapDelayError
```
public final <V> Flux<V> flatMapDelayError(Function<? super T,? extends Publisher<? extends V>> mapper,
 int concurrency,
 int prefetch)
```
 Transform the elements emitted by this Flux asynchronously into Publishers, then flatten these inner publishers into a single Flux through merging, which allow them to interleave.
 There are three dimensions to this operator that can be compared with flatMapSequential and concatMap:
 - Generation of inners and subscription: this operator is eagerly subscribing to its inners.
 - Ordering of the flattened values: this operator does not necessarily preserve original ordering, as inner element are flattened as they arrive.
 - Interleaving: this operator lets values from different inners interleave (similar to merging the inner sequences).
 The concurrency argument allows to control how many Publisher can be subscribed to and merged in parallel. The prefetch argument allows to give an arbitrary prefetch size to the merged Publisher. This variant will delay any error until after the rest of the flatMap backlog has been processed.
 Type Parameters:
 
 V - the merged output sequence type
 
 Parameters:
 
 mapper - the Function to transform input sequence into N sequences Publisher
 
 concurrency - the maximum number of in-flight inner sequences
 
 prefetch - the maximum in-flight elements from each inner Publisher sequence
 
 Returns:
 
 a merged Flux
 
 Error Mode Support
 
 This operator supports resuming on errors in the mapper Function. Exceptions thrown by the mapper then behave as if it had mapped the value to an empty publisher. If the mapper does map to a scalar publisher (an optimization in which the value can be resolved immediately without subscribing to the publisher, e.g. a Mono.fromCallable(Callable)) but said publisher throws, this can be resumed from in the same manner.
 
 onDiscard Support
 
 This operator discards elements internally queued for backpressure upon cancellation or error triggered by a data signal.
 - flatMap
```
public final <R> Flux<R> flatMap(@Nullable
 Function<? super T,? extends Publisher<? extends R>> mapperOnNext,
 @Nullable
 Function<? super Throwable,? extends Publisher<? extends R>> mapperOnError,
 @Nullable
 Supplier<? extends Publisher<? extends R>> mapperOnComplete)
```
 Transform the signals emitted by this Flux asynchronously into Publishers, then flatten these inner publishers into a single Flux through merging, which allow them to interleave. Note that at least one of the signal mappers must be provided, and all provided mappers must produce a publisher.
 There are three dimensions to this operator that can be compared with flatMapSequential and concatMap:
 - Generation of inners and subscription: this operator is eagerly subscribing to its inners.
 - Ordering of the flattened values: this operator does not necessarily preserve original ordering, as inner element are flattened as they arrive.
 - Interleaving: this operator lets values from different inners interleave (similar to merging the inner sequences).
 OnError will be transformed into completion signal after its mapping callback has been applied.
 Type Parameters:
 
 R - the output Publisher type target
 
 Parameters:
 
 mapperOnNext - the Function to call on next data and returning a sequence to merge. Use null to ignore (provided at least one other mapper is specified).
 
 mapperOnError - the Function to call on error signal and returning a sequence to merge. Use null to ignore (provided at least one other mapper is specified).
 
 mapperOnComplete - the Function to call on complete signal and returning a sequence to merge. Use null to ignore (provided at least one other mapper is specified).
 
 Returns:
 
 a new Flux
 - flatMapIterable
```
public final <R> Flux<R> flatMapIterable(Function<? super T,? extends Iterable<? extends R>> mapper)
```
 Transform the items emitted by this Flux into Iterable, then flatten the elements from those by merging them into a single Flux.
 
 Note that unlike flatMap(Function) and concatMap(Function), with Iterable there is no notion of eager vs lazy inner subscription. The content of the Iterables are all played sequentially. Thus flatMapIterable and concatMapIterable are equivalent offered as a discoverability improvement for users that explore the API with the concat vs flatMap expectation.
 
 Type Parameters:
 
 R - the merged output sequence type
 
 Parameters:
 
 mapper - the Function to transform input sequence into N Iterable
 
 Returns:
 
 a concatenation of the values from the Iterables obtained from each element in this Flux
 
 onDiscard Support
 
 This operator discards elements internally queued for backpressure upon cancellation or error triggered by a data signal.
 - flatMapIterable
```
public final <R> Flux<R> flatMapIterable(Function<? super T,? extends Iterable<? extends R>> mapper,
 int prefetch)
```
 Transform the items emitted by this Flux into Iterable, then flatten the emissions from those by merging them into a single Flux. The prefetch argument allows to give an arbitrary prefetch size to the merged Iterable.
 
 Note that unlike flatMap(Function) and concatMap(Function), with Iterable there is no notion of eager vs lazy inner subscription. The content of the Iterables are all played sequentially. Thus flatMapIterable and concatMapIterable are equivalent offered as a discoverability improvement for users that explore the API with the concat vs flatMap expectation.
 
 Type Parameters:
 
 R - the merged output sequence type
 
 Parameters:
 
 mapper - the Function to transform input sequence into N Iterable
 
 prefetch - the maximum in-flight elements from each inner Iterable sequence
 
 Returns:
 
 a concatenation of the values from the Iterables obtained from each element in this Flux
 
 onDiscard Support
 
 This operator discards elements internally queued for backpressure upon cancellation or error triggered by a data signal.
 - flatMapSequential
```
public final <R> Flux<R> flatMapSequential(Function<? super T,? extends Publisher<? extends R>> mapper)
```
 Transform the elements emitted by this Flux asynchronously into Publishers, then flatten these inner publishers into a single Flux, but merge them in the order of their source element.
 There are three dimensions to this operator that can be compared with flatMap and concatMap:
 - Generation of inners and subscription: this operator is eagerly subscribing to its inners (like flatMap).
 - Ordering of the flattened values: this operator queues elements from late inners until all elements from earlier inners have been emitted, thus emitting inner sequences as a whole, in an order that matches their source's order.
 - Interleaving: this operator does not let values from different inners interleave (similar looking result to concatMap, but due to queueing of values that would have been interleaved otherwise).
 That is to say, whenever a source element is emitted it is transformed to an inner Publisher. However, if such an early inner takes more time to complete than subsequent faster inners, the data from these faster inners will be queued until the earlier inner completes, so as to maintain source ordering.
 Type Parameters:
 
 R - the merged output sequence type
 
 Parameters:
 
 mapper - the Function to transform input sequence into N sequences Publisher
 
 Returns:
 
 a merged Flux, subscribing early but keeping the original ordering
 - flatMapSequential
```
public final <R> Flux<R> flatMapSequential(Function<? super T,? extends Publisher<? extends R>> mapper,
 int maxConcurrency)
```
 Transform the elements emitted by this Flux asynchronously into Publishers, then flatten these inner publishers into a single Flux, but merge them in the order of their source element.
 There are three dimensions to this operator that can be compared with flatMap and concatMap:
 - Generation of inners and subscription: this operator is eagerly subscribing to its inners (like flatMap).
 - Ordering of the flattened values: this operator queues elements from late inners until all elements from earlier inners have been emitted, thus emitting inner sequences as a whole, in an order that matches their source's order.
 - Interleaving: this operator does not let values from different inners interleave (similar looking result to concatMap, but due to queueing of values that would have been interleaved otherwise).
 That is to say, whenever a source element is emitted it is transformed to an inner Publisher. However, if such an early inner takes more time to complete than subsequent faster inners, the data from these faster inners will be queued until the earlier inner completes, so as to maintain source ordering.
 The concurrency argument allows to control how many merged Publisher can happen in parallel.
 Type Parameters:
 
 R - the merged output sequence type
 
 Parameters:
 
 mapper - the Function to transform input sequence into N sequences Publisher
 
 maxConcurrency - the maximum number of in-flight inner sequences
 
 Returns:
 
 a merged Flux, subscribing early but keeping the original ordering
 - flatMapSequential
```
public final <R> Flux<R> flatMapSequential(Function<? super T,? extends Publisher<? extends R>> mapper,
 int maxConcurrency,
 int prefetch)
```
 Transform the elements emitted by this Flux asynchronously into Publishers, then flatten these inner publishers into a single Flux, but merge them in the order of their source element.
 There are three dimensions to this operator that can be compared with flatMap and concatMap:
 - Generation of inners and subscription: this operator is eagerly subscribing to its inners (like flatMap).
 - Ordering of the flattened values: this operator queues elements from late inners until all elements from earlier inners have been emitted, thus emitting inner sequences as a whole, in an order that matches their source's order.
 - Interleaving: this operator does not let values from different inners interleave (similar looking result to concatMap, but due to queueing of values that would have been interleaved otherwise).
 That is to say, whenever a source element is emitted it is transformed to an inner Publisher. However, if such an early inner takes more time to complete than subsequent faster inners, the data from these faster inners will be queued until the earlier inner completes, so as to maintain source ordering.
 The concurrency argument allows to control how many merged Publisher can happen in parallel. The prefetch argument allows to give an arbitrary prefetch size to the merged Publisher.
 Type Parameters:
 
 R - the merged output sequence type
 
 Parameters:
 
 mapper - the Function to transform input sequence into N sequences Publisher
 
 maxConcurrency - the maximum number of in-flight inner sequences
 
 prefetch - the maximum in-flight elements from each inner Publisher sequence
 
 Returns:
 
 a merged Flux, subscribing early but keeping the original ordering
 - flatMapSequentialDelayError
```
public final <R> Flux<R> flatMapSequentialDelayError(Function<? super T,? extends Publisher<? extends R>> mapper,
 int maxConcurrency,
 int prefetch)
```
 Transform the elements emitted by this Flux asynchronously into Publishers, then flatten these inner publishers into a single Flux, but merge them in the order of their source element.
 There are three dimensions to this operator that can be compared with flatMap and concatMap:
 - Generation of inners and subscription: this operator is eagerly subscribing to its inners (like flatMap).
 - Ordering of the flattened values: this operator queues elements from late inners until all elements from earlier inners have been emitted, thus emitting inner sequences as a whole, in an order that matches their source's order.
 - Interleaving: this operator does not let values from different inners interleave (similar looking result to concatMap, but due to queueing of values that would have been interleaved otherwise).
 That is to say, whenever a source element is emitted it is transformed to an inner Publisher. However, if such an early inner takes more time to complete than subsequent faster inners, the data from these faster inners will be queued until the earlier inner completes, so as to maintain source ordering.
 The concurrency argument allows to control how many merged Publisher can happen in parallel. The prefetch argument allows to give an arbitrary prefetch size to the merged Publisher. This variant will delay any error until after the rest of the flatMap backlog has been processed.
 Type Parameters:
 
 R - the merged output sequence type
 
 Parameters:
 
 mapper - the Function to transform input sequence into N sequences Publisher
 
 maxConcurrency - the maximum number of in-flight inner sequences
 
 prefetch - the maximum in-flight elements from each inner Publisher sequence
 
 Returns:
 
 a merged Flux, subscribing early but keeping the original ordering
 - getPrefetch
```
public int getPrefetch()
```
 The prefetch configuration of the Flux
 
 Returns:
 
 the prefetch configuration of the Flux, -1 if unspecified
 - groupBy
```
public final <K> Flux<GroupedFlux<K,T>> groupBy(Function<? super T,? extends K> keyMapper)
```
 Divide this sequence into dynamically created Flux (or groups) for each unique key, as produced by the provided keyMapper Function. Note that groupBy works best with a low cardinality of groups, so chose your keyMapper function accordingly.
 
 The groups need to be drained and consumed downstream for groupBy to work correctly. Notably when the criteria produces a large amount of groups, it can lead to hanging if the groups are not suitably consumed downstream (eg. due to a flatMap with a maxConcurrency parameter that is set too low).
 
 Type Parameters:
 
 K - the key type extracted from each value of this sequence
 
 Parameters:
 
 keyMapper - the key mapping Function that evaluates an incoming data and returns a key.
 
 Returns:
 
 a Flux of GroupedFlux grouped sequences
 - groupBy
```
public final <K> Flux<GroupedFlux<K,T>> groupBy(Function<? super T,? extends K> keyMapper,
 int prefetch)
```
 Divide this sequence into dynamically created Flux (or groups) for each unique key, as produced by the provided keyMapper Function. Note that groupBy works best with a low cardinality of groups, so chose your keyMapper function accordingly.
 
 The groups need to be drained and consumed downstream for groupBy to work correctly. Notably when the criteria produces a large amount of groups, it can lead to hanging if the groups are not suitably consumed downstream (eg. due to a flatMap with a maxConcurrency parameter that is set too low).
 
 Type Parameters:
 
 K - the key type extracted from each value of this sequence
 
 Parameters:
 
 keyMapper - the key mapping Function that evaluates an incoming data and returns a key.
 
 prefetch - the number of values to prefetch from the source
 
 Returns:
 
 a Flux of GroupedFlux grouped sequences
 - groupBy
```
public final <K,V> Flux<GroupedFlux<K,V>> groupBy(Function<? super T,? extends K> keyMapper,
 Function<? super T,? extends V> valueMapper)
```
 Divide this sequence into dynamically created Flux (or groups) for each unique key, as produced by the provided keyMapper Function. Source elements are also mapped to a different value using the valueMapper. Note that groupBy works best with a low cardinality of groups, so chose your keyMapper function accordingly.
 
 The groups need to be drained and consumed downstream for groupBy to work correctly. Notably when the criteria produces a large amount of groups, it can lead to hanging if the groups are not suitably consumed downstream (eg. due to a flatMap with a maxConcurrency parameter that is set too low).
 
 Type Parameters:
 
 K - the key type extracted from each value of this sequence
 
 V - the value type extracted from each value of this sequence
 
 Parameters:
 
 keyMapper - the key mapping function that evaluates an incoming data and returns a key.
 
 valueMapper - the value mapping function that evaluates which data to extract for re-routing.
 
 Returns:
 
 a Flux of GroupedFlux grouped sequences
 - groupBy
```
public final <K,V> Flux<GroupedFlux<K,V>> groupBy(Function<? super T,? extends K> keyMapper,
 Function<? super T,? extends V> valueMapper,
 int prefetch)
```
 Divide this sequence into dynamically created Flux (or groups) for each unique key, as produced by the provided keyMapper Function. Source elements are also mapped to a different value using the valueMapper. Note that groupBy works best with a low cardinality of groups, so chose your keyMapper function accordingly.
 
 The groups need to be drained and consumed downstream for groupBy to work correctly. Notably when the criteria produces a large amount of groups, it can lead to hanging if the groups are not suitably consumed downstream (eg. due to a flatMap with a maxConcurrency parameter that is set too low).
 
 Type Parameters:
 
 K - the key type extracted from each value of this sequence
 
 V - the value type extracted from each value of this sequence
 
 Parameters:
 
 keyMapper - the key mapping function that evaluates an incoming data and returns a key.
 
 valueMapper - the value mapping function that evaluates which data to extract for re-routing.
 
 prefetch - the number of values to prefetch from the source
 
 Returns:
 
 a Flux of GroupedFlux grouped sequences
 - groupJoin
```
public final <TRight,TLeftEnd,TRightEnd,R> Flux<R> groupJoin(Publisher<? extends TRight> other,
 Function<? super T,? extends Publisher<TLeftEnd>> leftEnd,
 Function<? super TRight,? extends Publisher<TRightEnd>> rightEnd,
 BiFunction<? super T,? super Flux<TRight>,? extends R> resultSelector)
```
 Map values from two Publishers into time windows and emit combination of values in case their windows overlap. The emitted elements are obtained by passing the value from this Flux and a Flux emitting the value from the other Publisher to a BiFunction.
 There are no guarantees in what order the items get combined when multiple items from one or both source Publishers overlap.
 Unlike join(org.reactivestreams.Publisher<? extends TRight>, java.util.function.Function<? super T, ? extends org.reactivestreams.Publisher<TLeftEnd>>, java.util.function.Function<? super TRight, ? extends org.reactivestreams.Publisher<TRightEnd>>, java.util.function.BiFunction<? super T, ? super TRight, ? extends R>), items from the second Publisher will be provided as a Flux to the resultSelector.
 
 Type Parameters:
 
 TRight - the type of the elements from the right Publisher
 
 TLeftEnd - the type for this Flux window signals
 
 TRightEnd - the type for the right Publisher window signals
 
 R - the combined result type
 
 Parameters:
 
 other - the other Publisher to correlate items with
 
 leftEnd - a function that returns a Publisher whose emissions indicate the time window for the source value to be considered
 
 rightEnd - a function that returns a Publisher whose emissions indicate the time window for the right Publisher value to be considered
 
 resultSelector - a function that takes an item emitted by this Flux and a Flux representation of the overlapping item from the other Publisher and returns the value to be emitted by the resulting Flux
 
 Returns:
 
 a joining Flux
 
 See Also:
 
 join(Publisher, Function, Function, BiFunction)
 - handle
```
public final <R> Flux<R> handle(BiConsumer<? super T,SynchronousSink<R>> handler)
```
 Handle the items emitted by this Flux by calling a biconsumer with the output sink for each onNext. At most one SynchronousSink.next(Object) call must be performed and/or 0 or 1 SynchronousSink.error(Throwable) or SynchronousSink.complete().
 
 Type Parameters:
 
 R - the transformed type
 
 Parameters:
 
 handler - the handling BiConsumer
 
 Returns:
 
 a transformed Flux
 
 Error Mode Support
 
 This operator supports resuming on errors (including when fusion is enabled) when the BiConsumer throws an exception or if an error is signaled explicitly via SynchronousSink.error(Throwable).
 - hasElement
```
public final Mono<Boolean> hasElement(T value)
```
 Emit a single boolean true if any of the elements of this Flux sequence is equal to the provided value.
 The implementation uses short-circuit logic and completes with true if an element matches the value.
 
 Parameters:
 
 value - constant compared to incoming signals
 
 Returns:
 
 a new Flux with true if any element is equal to a given value and false otherwise
 - hasElements
```
public final Mono<Boolean> hasElements()
```
 Emit a single boolean true if this Flux sequence has at least one element.
 The implementation uses short-circuit logic and completes with true on onNext.
 
 Returns:
 
 a new Mono with true if any value is emitted and false otherwise
 - hide
```
public final Flux<T> hide()
```
 Hides the identities of this Flux instance.
 The main purpose of this operator is to prevent certain identity-based optimizations from happening, mostly for diagnostic purposes.
 
 Returns:
 
 a new Flux preventing Publisher / Subscription based Reactor optimizations
 - index
```
public final Flux<Tuple2<Long,T>> index()
```
 Keep information about the order in which source values were received by indexing them with a 0-based incrementing long, returning a Flux of

Class Flux<T>

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

Flux

Method Detail

combineLatest

combineLatest

combineLatest

combineLatest

combineLatest

combineLatest

combineLatest

combineLatest

combineLatest

concat

concatWithValues

concat

concat

concat

concatDelayError

concatDelayError

concatDelayError

concatDelayError

create

create

push

push

defer

empty

error

error

error

first

first

from

fromArray

fromIterable

fromStream

fromStream

generate

generate

generate

interval

interval

interval

interval

just

just

merge

merge

merge

merge

merge

merge

mergeDelayError

mergeOrdered

mergeOrdered

mergeOrdered

mergeSequential

mergeSequential

mergeSequentialDelayError

mergeSequential

mergeSequential

mergeSequentialDelayError

mergeSequential

mergeSequential

mergeSequentialDelayError

never

range

switchOnNext

switchOnNext

using

using

usingWhen

usingWhen

usingWhen

zip

zip