Uses of Class
reactor.core.publisher.Flux

Packages that use Flux

Package	Description
reactor.adapter	Adapt Publisher to Java 9+ Flow.Publisher.
reactor.core.publisher	Provide main Reactive APIs in Flux and Mono, as well as various helper classes, interfaces used in the composition API, variants of Flux and operator-building utilities.
reactor.test.publisher	Components supporting the creation of test-oriented Publishers.
reactor.util.retry

Uses of Flux in reactor.adapter

Methods in reactor.adapter that return Flux

Modifier and Type	Method and Description
static <T> Flux<T>	JdkFlowAdapter.flowPublisherToFlux(Flow.Publisher<T> publisher) Return a Flux from a java Flow.Publisher

Uses of Flux in reactor.core.publisher

Subclasses of Flux in reactor.core.publisher

Modifier and Type	Class and Description
class	ConnectableFlux<T> The abstract base class for connectable publishers that let subscribers pile up before they connect to their data source.
class	DirectProcessor<T> Deprecated. To be removed in 3.5, prefer clear cut usage of Sinks. Closest sink is Sinks.many().multicast().directBestEffort(), except it doesn't terminate overflowing downstreams.
class	EmitterProcessor<T> Deprecated. To be removed in 3.5. Prefer clear cut usage of Sinks through variations of Sinks.many().multicast().onBackpressureBuffer(). If you really need the subscribe-to-upstream functionality of a Processor, switch to Sinks.ManyWithUpstream with Sinks.unsafe() variants of Sinks.unsafe().manyWithUpstream(). This processor was blocking in EmitterProcessor.onNext(Object). This behaviour can be implemented with the Sinks API by calling Sinks.Many.tryEmitNext(Object) and retrying, e.g.: while (sink.tryEmitNext(v).hasFailed()) { LockSupport.parkNanos(10); }
class	FluxOperator<I,O> A decorating Flux Publisher that exposes Flux API over an arbitrary Publisher.
class	FluxProcessor<IN,OUT> Deprecated. Processors will be removed in 3.5. Prefer using Sinks.Many instead, or see https://github.com/reactor/reactor-core/issues/2431 for alternatives
class	GroupedFlux<K,V> Represents a sequence of events which has an associated key.
class	ReplayProcessor<T> Deprecated. To be removed in 3.5, prefer clear cut usage of Sinks through variations under Sinks.many().replay().
class	UnicastProcessor<T> Deprecated. to be removed in 3.5, prefer clear cut usage of Sinks through variations under Sinks.many().unicast().

Fields in reactor.core.publisher declared as Flux

Modifier and Type	Field and Description
protected Flux<? extends I>	FluxOperator.source

Methods in reactor.core.publisher that return Flux

Modifier and Type	Method and Description
Flux<T>	ReplayProcessor.asFlux() Deprecated.
Flux<T>	Sinks.Many.asFlux() Return a Flux view of this sink.
Flux<T>	UnicastProcessor.asFlux() Deprecated.
Flux<T>	EmitterProcessor.asFlux() Deprecated.
Flux<T>	ConnectableFlux.autoConnect() Connects this ConnectableFlux to the upstream source when the first Subscriber subscribes.
Flux<T>	ConnectableFlux.autoConnect(int minSubscribers) Connects this ConnectableFlux to the upstream source when the specified amount of Subscriber subscribes.
Flux<T>	ConnectableFlux.autoConnect(int minSubscribers, Consumer<? super Disposable> cancelSupport) Connects this ConnectableFlux to the upstream source when the specified amount of Subscriber subscribes and calls the supplied consumer with a Disposable that allows disconnecting.
Flux<List<T>>	Flux.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>>	Flux.buffer(Duration bufferingTimespan) Collect incoming values into multiple List buffers that will be emitted by the returned Flux every bufferingTimespan.
Flux<List<T>>	Flux.buffer(Duration bufferingTimespan, Duration openBufferEvery) Collect incoming values into multiple List buffers created at a given openBufferEvery period.
Flux<List<T>>	Flux.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>>	Flux.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>>	Flux.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>>	Flux.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>	Flux.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>	Flux.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>>	Flux.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>	Flux.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>>	Flux.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>>	Flux.bufferTimeout(int maxSize, Duration maxTime, boolean fairBackpressure) 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>>	Flux.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.
Flux<List<T>>	Flux.bufferTimeout(int maxSize, Duration maxTime, Scheduler timer, boolean fairBackpressure) 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>	Flux.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>	Flux.bufferTimeout(int maxSize, Duration maxTime, Scheduler timer, Supplier<C> bufferSupplier, boolean fairBackpressure) 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>	Flux.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.
<C extends Collection<? super T>> Flux<C>	Flux.bufferTimeout(int maxSize, Duration maxTime, Supplier<C> bufferSupplier, boolean fairBackpressure) 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>>	Flux.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>>	Flux.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.
Flux<List<T>>	Flux.bufferUntilChanged() Collect subsequent repetitions of an element (that is, if they arrive right after one another) into multiple List buffers that will be emitted by the resulting Flux.
<V> Flux<List<T>>	Flux.bufferUntilChanged(Function<? super T,? extends V> keySelector) Collect 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, into multiple List buffers that will be emitted by the resulting Flux.
<V> Flux<List<T>>	Flux.bufferUntilChanged(Function<? super T,? extends V> keySelector, BiPredicate<? super V,? super V> keyComparator) Collect 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 compared using a supplied BiPredicate, into multiple List buffers that will be emitted by the resulting Flux.
<U,V> Flux<List<T>>	Flux.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>	Flux.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>>	Flux.bufferWhile(Predicate<? super T> predicate) Collect incoming values into multiple List buffers that will be emitted by the resulting Flux.
Flux<T>	Flux.cache() Turn this Flux into a hot source and cache last emitted signals for further Subscriber.
Flux<T>	Flux.cache(Duration ttl) Turn this Flux into a hot source and cache last emitted signals for further Subscriber.
Flux<T>	Flux.cache(Duration ttl, Scheduler timer) Turn this Flux into a hot source and cache last emitted signals for further Subscriber.
Flux<T>	Flux.cache(int history) Turn this Flux into a hot source and cache last emitted signals for further Subscriber.
Flux<T>	Flux.cache(int history, Duration ttl) Turn this Flux into a hot source and cache last emitted signals for further Subscriber.
Flux<T>	Flux.cache(int history, Duration ttl, Scheduler timer) Turn this Flux into a hot source and cache last emitted signals for further Subscriber.
Flux<T>	Flux.cancelOn(Scheduler scheduler) Prepare this Flux so that subscribers will cancel from it on a specified Scheduler.
<E> Flux<E>	Flux.cast(Class<E> clazz) Cast the current Flux produced type into a target produced type.
Flux<T>	Flux.checkpoint() Activate traceback (full assembly tracing) for this particular Flux, in case of an error upstream of the checkpoint.
Flux<T>	Flux.checkpoint(String description) Activate traceback (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>	Flux.checkpoint(String description, boolean forceStackTrace) Activate traceback (full assembly tracing or the lighter assembly marking depending on the forceStackTrace option).
static <T,V> Flux<V>	Flux.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>	Flux.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>	Flux.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>	Flux.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>	Flux.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>	Flux.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>	Flux.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>	Flux.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>	Flux.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.
static <T> Flux<T>	Flux.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>	Flux.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>	Flux.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>	Flux.concat(Publisher<? extends T>... sources) Concatenate all sources provided as a vararg, forwarding elements emitted by the sources downstream.
static <T> Flux<T>	Flux.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>	Flux.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>	Flux.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>	Flux.concatDelayError(Publisher<? extends T>... sources) Concatenate all sources provided as a vararg, forwarding elements emitted by the sources downstream.
<V> Flux<V>	Flux.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>	Flux.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>	Flux.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>	Flux.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>	Flux.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>	Flux.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>	Flux.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>	Flux.concatWith(Publisher<? extends T> other) Concatenate emissions of this Flux with the provided Publisher (no interleave).
Flux<T>	Mono.concatWith(Publisher<? extends T> other) Concatenate emissions of this Mono with the provided Publisher (no interleave).
Flux<T>	Flux.concatWithValues(T... values) Concatenates the values to the end of the Flux
Flux<T>	Flux.contextCapture() If context-propagation library is on the classpath, this is a convenience shortcut to capture thread local values during the subscription phase and put them in the Context that is visible upstream of this operator.
Flux<T>	Flux.contextWrite(ContextView contextToAppend) Enrich the Context visible from downstream for the benefit of upstream operators, by making all values from the provided ContextView visible on top of pairs from downstream.
Flux<T>	Flux.contextWrite(Function<Context,Context> contextModifier) Enrich the Context visible from downstream for the benefit of upstream operators, by applying a Function to the downstream Context.
static <T> Flux<T>	Hooks.convertToFluxBypassingHooks(Publisher<T> publisher) Utility method to convert a Publisher to a Flux without applying Hooks.
static <T> Flux<T>	Flux.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>	Flux.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>	Flux.defaultIfEmpty(T defaultV) Provide a default unique value if this sequence is completed without any data
static <T> Flux<T>	Flux.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.
static <T> Flux<T>	Flux.deferContextual(Function<ContextView,? extends Publisher<T>> contextualPublisherFactory) 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 Function can create a subscriber-specific instance.
Flux<T>	Flux.delayElements(Duration delay) Delay each of this Flux elements (Subscriber.onNext(T) signals) by a given Duration.
Flux<T>	Flux.delayElements(Duration delay, Scheduler timer) Delay each of this Flux elements (Subscriber.onNext(T) signals) by a given Duration.
Flux<T>	Flux.delaySequence(Duration delay) Shift this Flux forward in time by a given Duration.
Flux<T>	Flux.delaySequence(Duration delay, Scheduler timer) Shift this Flux forward in time by a given Duration.
Flux<T>	Flux.delaySubscription(Duration delay) Delay the subscription to this Flux source until the given period elapses.
Flux<T>	Flux.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>	Flux.delaySubscription(Publisher<U> subscriptionDelay) Delay the subscription to this Flux source until another Publisher signals a value or completes.
Flux<T>	Flux.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>	Flux.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>	Flux.distinct() For each Subscriber, track elements from this Flux that have been seen and filter out duplicates.
<V> Flux<T>	Flux.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>	Flux.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>	Flux.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>	Flux.distinctUntilChanged() Filter out subsequent repetitions of an element (that is, if they arrive right after one another).
<V> Flux<T>	Flux.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>	Flux.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>	Flux.doAfterTerminate(Runnable afterTerminate) Add behavior (side-effect) triggered after the Flux terminates, either by completing downstream successfully or with an error.
Flux<T>	Flux.doFinally(Consumer<SignalType> onFinally) Add behavior (side-effect) triggered after the Flux terminates for any reason, including cancellation.
Flux<T>	Flux.doFirst(Runnable onFirst) Add behavior (side-effect) triggered before the Flux is subscribed to, which should be the first event after assembly time.
Flux<T>	Flux.doOnCancel(Runnable onCancel) Add behavior (side-effect) triggered when the Flux is cancelled.
Flux<T>	Flux.doOnComplete(Runnable onComplete) Add behavior (side-effect) triggered when the Flux completes successfully.
<R> Flux<T>	Flux.doOnDiscard(Class<R> type, Consumer<? super R> discardHook) Potentially 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>	Flux.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>	Flux.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>	Flux.doOnError(Consumer<? super Throwable> onError) Add behavior (side-effect) triggered when the Flux completes with an error.
Flux<T>	Flux.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>	Flux.doOnNext(Consumer<? super T> onNext) Add behavior (side-effect) triggered when the Flux emits an item.
Flux<T>	Flux.doOnRequest(LongConsumer consumer) Add behavior (side-effect) triggering a LongConsumer when this Flux receives any request.
Flux<T>	Flux.doOnSubscribe(Consumer<? super Subscription> onSubscribe) Add behavior (side-effect) triggered when the Flux is being subscribed, that is to say when a Subscription has been produced by the Publisher and is being passed to the Subscriber.onSubscribe(Subscription).
Flux<T>	Flux.doOnTerminate(Runnable onTerminate) Add behavior (side-effect) triggered when the Flux terminates, either by completing successfully or failing with an error.
Flux<Tuple2<Long,T>>	Flux.elapsed() Map this Flux into Tuple2<Long, T> of timemillis and source data.
Flux<Tuple2<Long,T>>	Flux.elapsed(Scheduler scheduler) Map this Flux into Tuple2<Long, T> of timemillis and source data.
static <T> Flux<T>	Flux.empty() Create a Flux that completes without emitting any item.
static <T> Flux<T>	Flux.error(Supplier<? extends Throwable> errorSupplier) Create a Flux that terminates with an error immediately after being subscribed to.
static <T> Flux<T>	Flux.error(Throwable error) Create a Flux that terminates with the specified error immediately after being subscribed to.
static <O> Flux<O>	Flux.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>	Flux.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>	Mono.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>	Flux.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>	Mono.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>	Flux.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>	Mono.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>	Flux.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>	Mono.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>	Flux.filter(Predicate<? super T> p) Evaluate each source value against the given Predicate.
Flux<T>	Flux.filterWhen(Function<? super T,? extends Publisher<Boolean>> asyncPredicate) Test each value emitted by this Flux asynchronously using a generated Publisher<Boolean> test.
Flux<T>	Flux.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>	Flux.first(Iterable<? extends Publisher<? extends I>> sources) Deprecated. use firstWithSignal(Iterable). To be removed in reactor 3.5.
static <I> Flux<I>	Flux.first(Publisher<? extends I>... sources) Deprecated. use firstWithSignal(Publisher[]). To be removed in reactor 3.5.
static <I> Flux<I>	Flux.firstWithSignal(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>	Flux.firstWithSignal(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>	Flux.firstWithValue(Iterable<? extends Publisher<? extends I>> sources) Pick the first Publisher to emit any value and replay all values from that Publisher, effectively behaving like the source that first emits an onNext.
static <I> Flux<I>	Flux.firstWithValue(Publisher<? extends I> first, Publisher<? extends I>... others) Pick the first Publisher to emit any value and replay all values from that Publisher, effectively behaving like the source that first emits an onNext.
<R> Flux<R>	Flux.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>	Flux.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>	Flux.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>	Flux.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>	Flux.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>	Flux.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>	Mono.flatMapIterable(Function<? super T,? extends Iterable<? extends R>> mapper) Transform the item emitted by this Mono into Iterable, then forward its elements into the returned Flux.
<R> Flux<R>	Flux.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>	Mono.flatMapMany(Function<? super T,? extends Publisher<? extends R>> mapper) Transform the item emitted by this Mono into a Publisher, then forward its emissions into the returned Flux.
<R> Flux<R>	Mono.flatMapMany(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 Mono into signal-specific Publishers, then forward the applicable Publisher's emissions into the returned Flux.
<R> Flux<R>	Flux.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>	Flux.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>	Flux.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>	Flux.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.
Flux<T>	Mono.flux() Convert this Mono to a Flux
static <T> Flux<T>	Flux.from(Publisher<? extends T> source) Decorate the specified Publisher with the Flux API.
static <T> Flux<T>	Flux.fromArray(T[] array) Create a Flux that emits the items contained in the provided array.
static <T> Flux<T>	Flux.fromIterable(Iterable<? extends T> it) Create a Flux that emits the items contained in the provided Iterable.
static <T> Flux<T>	Flux.fromStream(Stream<? extends T> s) Create a Flux that emits the items contained in the provided Stream.
static <T> Flux<T>	Flux.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>	Flux.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>	Flux.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>	Flux.generate(Consumer<SynchronousSink<T>> generator) Programmatically create a Flux by generating signals one-by-one via a consumer callback.
<K> Flux<GroupedFlux<K,T>>	Flux.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>>	Flux.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>>	Flux.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>>	Flux.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>	Flux.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.
Flux<GroupedFlux<Integer,T>>	ParallelFlux.groups() Exposes the 'rails' as individual GroupedFlux instances, keyed by the rail index (zero based).
<R> Flux<R>	Flux.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.
Flux<T>	Flux.hide() Hides the identities of this Flux instance.
Flux<Tuple2<Long,T>>	Flux.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>	Flux.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>	Flux.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>	Flux.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>	Flux.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>	Flux.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>	Flux.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) Combine values from two Publishers in case their windows overlap.
static <T> Flux<T>	Flux.just(T... data) Create a Flux that emits the provided elements and then completes.
static <T> Flux<T>	Flux.just(T data) Create a new Flux that will only emit a single element then onComplete.
Flux<T>	Flux.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>	Flux.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>	Flux.limitRequest(long n) Deprecated. replace with take(n, true) in 3.4.x, then take(long) in 3.5.0. To be removed in 3.6.0 at the earliest. See https://github.com/reactor/reactor-core/issues/2339
Flux<T>	Flux.log() Observe all Reactive Streams signals and trace them using Logger support.
Flux<T>	Flux.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>	Flux.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>	Flux.log(String category) Observe all Reactive Streams signals and trace them using Logger support.
Flux<T>	Flux.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>	Flux.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>	Flux.map(Function<? super T,? extends V> mapper) Transform the items emitted by this Flux by applying a synchronous function to each item.
<V> Flux<V>	Flux.mapNotNull(Function<? super T,? extends V> mapper) Transform the items emitted by this Flux by applying a synchronous function to each item, which may produce null values.
Flux<Signal<T>>	Flux.materialize() Transform incoming onNext, onError and onComplete signals into Signal instances, materializing these signals.
static <I> Flux<I>	Flux.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>	Flux.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>	Flux.merge(Publisher<? extends I>... sources) Merge data from Publisher sequences contained in an array / vararg into an interleaved merged sequence.
static <T> Flux<T>	Flux.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>	Flux.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>	Flux.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 <T> Flux<T>	Flux.mergeComparing(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>	Flux.mergeComparing(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>	Flux.mergeComparing(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).
static <T> Flux<T>	Flux.mergeComparingDelayError(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).
Flux<T>	Flux.mergeComparingWith(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>	Flux.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>	Flux.mergeOrdered(Comparator<? super T> comparator, Publisher<? extends T>... sources) Deprecated. Use mergeComparingDelayError(int, Comparator, Publisher[]) instead (as mergeComparing(Publisher[]) don't have this operator's delayError behavior). To be removed in 3.6.0 at the earliest.
static <T> Flux<T>	Flux.mergeOrdered(int prefetch, Comparator<? super T> comparator, Publisher<? extends T>... sources) Deprecated. Use mergeComparingDelayError(int, Comparator, Publisher[]) instead (as mergeComparing(Publisher[]) don't have this operator's delayError behavior). To be removed in 3.6.0 at the earliest.
static <I extends Comparable<? super I>> Flux<I>	Flux.mergeOrdered(Publisher<? extends I>... sources) Deprecated. Use mergeComparingDelayError(int, Comparator, Publisher[]) instead (as mergeComparing(Publisher[]) don't have this operator's delayError behavior). To be removed in 3.6.0 at the earliest.
Flux<T>	Flux.mergeOrderedWith(Publisher<? extends T> other, Comparator<? super T> otherComparator) Deprecated. Use mergeComparingWith(Publisher, Comparator) instead (with the caveat that it defaults to NOT delaying errors, unlike this operator). To be removed in 3.6.0 at the earliest.
static <T> Flux<T>	Flux.mergePriority(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) as they arrive.
static <T> Flux<T>	Flux.mergePriority(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) as they arrive.
static <I extends Comparable<? super I>> Flux<I>	Flux.mergePriority(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) as they arrive.
static <T> Flux<T>	Flux.mergePriorityDelayError(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) as they arrive.
static <I> Flux<I>	Flux.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>	Flux.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>	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.
static <I> Flux<I>	Flux.mergeSequential(Publisher<? extends I>... sources) Merge data from Publisher sequences provided in an array/vararg into an ordered merged sequence.
static <T> Flux<T>	Flux.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>	Flux.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>	Flux.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>	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.
static <T> Flux<T>	Flux.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>	Flux.mergeWith(Publisher<? extends T> other) Merge data from this Flux and a Publisher into an interleaved merged sequence.
Flux<T>	Mono.mergeWith(Publisher<? extends T> other) Merge emissions of this Mono with the provided Publisher.
Flux<T>	Flux.metrics() Deprecated. Prefer using the tap(SignalListenerFactory) with the SignalListenerFactory provided by the new reactor-core-micrometer module. To be removed in 3.6.0 at the earliest.
Flux<T>	Flux.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>	Flux.never() Create a Flux that will never signal any data, error or completion signal.
<U> Flux<U>	Flux.ofType(Class<U> clazz) Evaluate each accepted value against the given Class type.
protected static <T> Flux<T>	Flux.onAssembly(Flux<T> source) To be used by custom operators: invokes assembly Hooks pointcut given a Flux, potentially returning a new Flux.
Flux<T>	Flux.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>	Flux.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 parallel Scheduler).
Flux<T>	Flux.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>	Flux.onBackpressureBuffer(int maxSize) Request an unbounded demand and push to the returned Flux, or park up to maxSize elements when not enough demand is requested downstream.
Flux<T>	Flux.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>	Flux.onBackpressureBuffer(int maxSize, Consumer<? super T> onOverflow) Request an unbounded demand and push to the returned Flux, or park up to maxSize elements when not enough demand is requested downstream.
Flux<T>	Flux.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>	Flux.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>	Flux.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>	Flux.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>	Flux.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>	Flux.onErrorComplete() Simply complete the sequence by replacing an onError signal with an onComplete signal.
Flux<T>	Flux.onErrorComplete(Class<? extends Throwable> type) Simply complete the sequence by replacing an onError signal with an onComplete signal if the error matches the given Class.
Flux<T>	Flux.onErrorComplete(Predicate<? super Throwable> predicate) Simply complete the sequence by replacing an onError signal with an onComplete signal if the error matches the given Predicate.
Flux<T>	Flux.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>	Flux.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>	Flux.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>	Flux.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>	Flux.onErrorMap(Function<? super Throwable,? extends Throwable> mapper) Transform any error emitted by this Flux by synchronously applying a function to it.
Flux<T>	Flux.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>	Flux.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>	Flux.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>	Flux.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>	Flux.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>	Flux.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>	Flux.onErrorReturn(T fallbackValue) Simply emit a captured fallback value when any error is observed on this Flux.
Flux<T>	Flux.onErrorStop() If an onErrorContinue(BiConsumer) variant has been used downstream, reverts to the default 'STOP' mode where errors are terminal events upstream.
Flux<T>	Flux.onTerminateDetach() Detaches both the child Subscriber and the Subscription on termination or cancellation.
Flux<T>	Flux.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.
Flux<T>	ParallelFlux.ordered(Comparator<? super T> comparator) Merges the values from each 'rail', but choose which one to merge by way of a provided Comparator, picking the smallest of all rails.
Flux<T>	ParallelFlux.ordered(Comparator<? super T> comparator, int prefetch) Merges the values from each 'rail', but choose which one to merge by way of a provided Comparator, picking the smallest of all rails.
<R> Flux<R>	Flux.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>	Flux.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.
Flux<T>	Flux.publishOn(Scheduler scheduler) Run onNext, onComplete and onError on a supplied Scheduler Worker.
Flux<T>	Flux.publishOn(Scheduler scheduler, boolean delayError, int prefetch) Run onNext, onComplete and onError on a supplied Scheduler Scheduler.Worker.
Flux<T>	Flux.publishOn(Scheduler scheduler, int prefetch) Run onNext, onComplete and onError on a supplied Scheduler Scheduler.Worker.
static <T> Flux<T>	Flux.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>	Flux.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>	Flux.range(int start, int count) Build a Flux that will only emit a sequence of count incrementing integers, starting from start.
Flux<T>	ConnectableFlux.refCount() Connects to the upstream source when the first Subscriber subscribes and disconnects when all Subscribers cancelled or the upstream source completed.
Flux<T>	ConnectableFlux.refCount(int minSubscribers) Connects to the upstream source when the given number of Subscriber subscribes and disconnects when all Subscribers cancelled or the upstream source completed.
Flux<T>	ConnectableFlux.refCount(int minSubscribers, Duration gracePeriod) Connects to the upstream source when the given number of Subscriber subscribes.
Flux<T>	ConnectableFlux.refCount(int minSubscribers, Duration gracePeriod, Scheduler scheduler) Connects to the upstream source when the given number of Subscriber subscribes.
Flux<T>	Flux.repeat() Repeatedly and indefinitely subscribe to the source upon completion of the previous subscription.
Flux<T>	Mono.repeat() Repeatedly and indefinitely subscribe to the source upon completion of the previous subscription.
Flux<T>	Flux.repeat(BooleanSupplier predicate) Repeatedly subscribe to the source if the predicate returns true after completion of the previous subscription.
Flux<T>	Mono.repeat(BooleanSupplier predicate) Repeatedly subscribe to the source if the predicate returns true after completion of the previous subscription.
Flux<T>	Flux.repeat(long numRepeat) Repeatedly subscribe to the source numRepeat times.
Flux<T>	Mono.repeat(long numRepeat) Repeatedly subscribe to the source numRepeat times.
Flux<T>	Flux.repeat(long numRepeat, BooleanSupplier predicate) Repeatedly subscribe to the source if the predicate returns true after completion of the previous subscription.
Flux<T>	Mono.repeat(long numRepeat, BooleanSupplier predicate) Repeatedly subscribe to the source if the predicate returns true after completion of the previous subscription.
Flux<T>	Flux.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.
Flux<T>	Mono.repeatWhen(Function<Flux<Long>,? extends Publisher<?>> repeatFactory) Repeatedly subscribe to this Mono when a companion sequence emits elements in response to the flux completion signal.
Flux<T>	Flux.retry() Re-subscribes to this Flux sequence if it signals any error, indefinitely.
Flux<T>	Flux.retry(long numRetries) Re-subscribes to this Flux sequence if it signals any error, for a fixed number of times.
Flux<T>	Flux.retryWhen(Retry retrySpec) Retries this Flux in response to signals emitted by a companion Publisher.
Flux<T>	Flux.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>	Flux.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>	Flux.sampleFirst(Duration timespan) Repeatedly take a value from this Flux then skip the values that follow within a given duration.
<U> Flux<T>	Flux.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>	Flux.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>	Flux.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>	Flux.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>	Flux.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>	Flux.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>	ParallelFlux.sequential() Merges the values from each 'rail' in a round-robin or same-order fashion and exposes it as a regular Publisher sequence, running with a default prefetch value for the rails.
Flux<T>	ParallelFlux.sequential(int prefetch) Merges the values from each 'rail' in a round-robin or same-order fashion and exposes it as a regular Publisher sequence, running with a give prefetch value for the rails.
Flux<T>	Flux.share() Returns a new Flux that multicasts (shares) the original Flux.
Flux<T>	Flux.skip(Duration timespan) Skip elements from this Flux emitted within the specified initial duration.
Flux<T>	Flux.skip(Duration timespan, Scheduler timer) Skip elements from this Flux emitted within the specified initial duration, as measured on the provided Scheduler.
Flux<T>	Flux.skip(long skipped) Skip the specified number of elements from the beginning of this Flux then emit the remaining elements.
Flux<T>	Flux.skipLast(int n) Skip a specified number of elements at the end of this Flux sequence.
Flux<T>	Flux.skipUntil(Predicate<? super T> untilPredicate) Skips values from this Flux until a Predicate returns true for the value.
Flux<T>	Flux.skipUntilOther(Publisher<?> other) Skip values from this Flux until a specified Publisher signals an onNext or onComplete.
Flux<T>	Flux.skipWhile(Predicate<? super T> skipPredicate) Skips values from this Flux while a Predicate returns true for the value.
Flux<T>	Flux.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>	Flux.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>	ParallelFlux.sorted(Comparator<? super T> comparator) Sorts the 'rails' of this ParallelFlux and returns a Publisher that sequentially picks the smallest next value from the rails.
Flux<T>	ParallelFlux.sorted(Comparator<? super T> comparator, int capacityHint) Sorts the 'rails' of this ParallelFlux and returns a Publisher that sequentially picks the smallest next value from the rails.
Flux<T>	Flux.startWith(Iterable<? extends T> iterable) Prepend the given Iterable before this Flux sequence.
Flux<T>	Flux.startWith(Publisher<? extends T> publisher) Prepend the given Publisher sequence to this Flux sequence.
Flux<T>	Flux.startWith(T... values) Prepend the given values before this Flux sequence.
Flux<T>	Flux.subscribeOn(Scheduler scheduler) Run subscribe, onSubscribe and request on a specified Scheduler's Scheduler.Worker.
Flux<T>	Flux.subscribeOn(Scheduler scheduler, boolean requestOnSeparateThread) Run subscribe and onSubscribe on a specified Scheduler's Scheduler.Worker.
Flux<T>	Flux.switchIfEmpty(Publisher<? extends T> alternate) Switch to an alternative Publisher if this sequence is completed without any data.
<V> Flux<V>	Flux.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>	Flux.switchMap(Function<? super T,Publisher<? extends V>> fn, int prefetch) Deprecated. to be removed in 3.6.0 at the earliest. In 3.5.0, you should replace calls with prefetch=0 with calls to switchMap(fn), as the default behavior of the single-parameter variant will then change to prefetch=0.
<V> Flux<V>	Flux.switchOnFirst(BiFunction<Signal<? extends T>,Flux<T>,Publisher<? extends V>> transformer) Transform the current Flux once it emits its first element, making a conditional transformation possible.
<V> Flux<V>	Flux.switchOnFirst(BiFunction<Signal<? extends T>,Flux<T>,Publisher<? extends V>> transformer, boolean cancelSourceOnComplete) Transform the current Flux once it emits its first element, making a conditional transformation possible.
static <T> Flux<T>	Flux.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 the source.
static <T> Flux<T>	Flux.switchOnNext(Publisher<? extends Publisher<? extends T>> mergedPublishers, int prefetch) Deprecated. to be removed in 3.6.0 at the earliest. In 3.5.0, you should replace calls with prefetch=0 with calls to switchOnNext(mergedPublishers), as the default behavior of the single-parameter variant will then change to prefetch=0.
Flux<T>	Flux.tag(String key, String value) Tag this flux with a key/value pair.
Flux<T>	Flux.take(Duration timespan) Relay values from this Flux until the specified Duration elapses.
Flux<T>	Flux.take(Duration timespan, Scheduler timer) Relay values from this Flux until the specified Duration elapses, as measured on the specified Scheduler.
Flux<T>	Flux.take(long n) Take only the first N values from this Flux, if available.
Flux<T>	Flux.take(long n, boolean limitRequest) Take only the first N values from this Flux, if available.
Flux<T>	Flux.takeLast(int n) Emit the last N values this Flux emitted before its completion.
Flux<T>	Flux.takeUntil(Predicate<? super T> predicate) Relay values from this Flux until the given Predicate matches.
Flux<T>	Flux.takeUntilOther(Publisher<?> other) Relay values from this Flux until the given Publisher emits.
Flux<T>	Flux.takeWhile(Predicate<? super T> continuePredicate) Relay values from this Flux while a predicate returns TRUE for the values (checked before each value is delivered).
Flux<T>	Flux.tap(Function<ContextView,SignalListener<T>> listenerGenerator) Tap into Reactive Streams signals emitted or received by this Flux and notify a stateful per-Subscriber SignalListener.
Flux<T>	Flux.tap(SignalListenerFactory<T,?> listenerFactory) Tap into Reactive Streams signals emitted or received by this Flux and notify a stateful per-Subscriber SignalListener created by the provided SignalListenerFactory.
Flux<T>	Flux.tap(Supplier<SignalListener<T>> simpleListenerGenerator) Tap into Reactive Streams signals emitted or received by this Flux and notify a stateful per-Subscriber SignalListener.
<V> Flux<V>	Flux.thenMany(Publisher<V> other) Let this Flux complete then play another Publisher.
<V> Flux<V>	Mono.thenMany(Publisher<V> other) Let this Mono complete successfully then play another Publisher.
Flux<Timed<T>>	Flux.timed() Times Subscriber.onNext(Object) events, encapsulated into a Timed object that lets downstream consumer look at various time information gathered with nanosecond resolution using the default clock (Schedulers.parallel()): Timed.elapsed(): the time in nanoseconds since last event, as a Duration.
Flux<Timed<T>>	Flux.timed(Scheduler clock) Times Subscriber.onNext(Object) events, encapsulated into a Timed object that lets downstream consumer look at various time information gathered with nanosecond resolution using the provided Scheduler as a clock: Timed.elapsed(): the time in nanoseconds since last event, as a Duration.
Flux<T>	Flux.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>	Flux.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>	Flux.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>	Flux.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>	Flux.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>	Flux.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>	Flux.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>>	Flux.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>>	Flux.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.
<V> Flux<V>	Flux.transform(Function<? super Flux<T>,? extends Publisher<V>> transformer) Transform this Flux in order to generate a target Flux.
<V> Flux<V>	Flux.transformDeferred(Function<? super Flux<T>,? extends Publisher<V>> transformer) Defer the transformation of this Flux in order to generate a target Flux type.
<V> Flux<V>	Flux.transformDeferredContextual(BiFunction<? super Flux<T>,? super ContextView,? extends Publisher<V>> transformer) Defer the given transformation to this Flux in order to generate a target Flux type.
static <T,D> Flux<T>	Flux.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>	Flux.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>	Flux.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>	Flux.usingWhen(Publisher<D> resourceSupplier, Function<? super D,? extends Publisher<? extends T>> resourceClosure, Function<? super D,? extends Publisher<?>> asyncComplete, BiFunction<? super D,? super Throwable,? 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>>	Flux.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>>	Flux.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>>	Flux.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>>	Flux.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>>	Flux.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>>	Flux.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>>	Flux.window(Publisher<?> boundary) Split this Flux sequence into continuous, non-overlapping windows where the window boundary is signalled by another Publisher
Flux<Flux<T>>	Flux.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>>	Flux.windowTimeout(int maxSize, Duration maxTime, boolean fairBackpressure) 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>>	Flux.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>>	Flux.windowTimeout(int maxSize, Duration maxTime, Scheduler timer, boolean fairBackpressure) 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>>	Flux.windowUntil(Predicate<T> boundaryTrigger) Split this Flux sequence into multiple Flux windows delimited by the given predicate.
Flux<Flux<T>>	Flux.windowUntil(Predicate<T> boundaryTrigger, boolean cutBefore) Split this Flux sequence into multiple Flux windows delimited by the given predicate.
Flux<Flux<T>>	Flux.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.
Flux<Flux<T>>	Flux.windowUntilChanged() Collect subsequent repetitions of an element (that is, if they arrive right after one another) into multiple Flux windows.
<V> Flux<Flux<T>>	Flux.windowUntilChanged(Function<? super T,? extends V> keySelector, BiPredicate<? super V,? super V> keyComparator) Collect 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 compared using a supplied BiPredicate, into multiple Flux windows.
<V> Flux<Flux<T>>	Flux.windowUntilChanged(Function<? super T,? super V> keySelector) Collect 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, into multiple Flux windows.
<U,V> Flux<Flux<T>>	Flux.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>>	Flux.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>>	Flux.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>	Flux.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>	Flux.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>	Flux.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>	Flux.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>	Flux.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>	Flux.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>>	Flux.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>	Flux.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>>	Flux.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>>	Flux.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>>	Flux.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>>	Flux.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>>	Flux.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>>	Flux.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>>	Flux.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>	Flux.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>>	Flux.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>	Flux.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>>	Flux.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>	Flux.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 in reactor.core.publisher that return types with arguments of type Flux

Modifier and Type	Method and Description
Flux<Flux<T>>	Flux.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>>	Flux.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>>	Flux.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>>	Flux.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>>	Flux.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>>	Flux.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>>	Flux.window(Publisher<?> boundary) Split this Flux sequence into continuous, non-overlapping windows where the window boundary is signalled by another Publisher
Flux<Flux<T>>	Flux.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>>	Flux.windowTimeout(int maxSize, Duration maxTime, boolean fairBackpressure) 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>>	Flux.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>>	Flux.windowTimeout(int maxSize, Duration maxTime, Scheduler timer, boolean fairBackpressure) 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>>	Flux.windowUntil(Predicate<T> boundaryTrigger) Split this Flux sequence into multiple Flux windows delimited by the given predicate.
Flux<Flux<T>>	Flux.windowUntil(Predicate<T> boundaryTrigger, boolean cutBefore) Split this Flux sequence into multiple Flux windows delimited by the given predicate.
Flux<Flux<T>>	Flux.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.
Flux<Flux<T>>	Flux.windowUntilChanged() Collect subsequent repetitions of an element (that is, if they arrive right after one another) into multiple Flux windows.
<V> Flux<Flux<T>>	Flux.windowUntilChanged(Function<? super T,? extends V> keySelector, BiPredicate<? super V,? super V> keyComparator) Collect 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 compared using a supplied BiPredicate, into multiple Flux windows.
<V> Flux<Flux<T>>	Flux.windowUntilChanged(Function<? super T,? super V> keySelector) Collect 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, into multiple Flux windows.
<U,V> Flux<Flux<T>>	Flux.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>>	Flux.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>>	Flux.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.

Methods in reactor.core.publisher with parameters of type Flux

Modifier and Type	Method and Description
protected static <T> Flux<T>	Flux.onAssembly(Flux<T> source) To be used by custom operators: invokes assembly Hooks pointcut given a Flux, potentially returning a new Flux.

Method parameters in reactor.core.publisher with type arguments of type Flux

Modifier and Type	Method and Description
<P> P	Flux.as(Function<? super Flux<T>,P> transformer) Transform this Flux into a target type.
<TRight,TLeftEnd,TRightEnd,R> Flux<R>	Flux.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>	Flux.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>	Flux.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.
Flux<T>	Flux.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.
Flux<T>	Mono.repeatWhen(Function<Flux<Long>,? extends Publisher<?>> repeatFactory) Repeatedly subscribe to this Mono when a companion sequence emits elements in response to the flux completion signal.
Mono<T>	Mono.repeatWhenEmpty(Function<Flux<Long>,? extends Publisher<?>> repeatFactory) Repeatedly subscribe to this Mono as long as the current subscription to this Mono completes empty and the companion Publisher produces an onNext signal.
Mono<T>	Mono.repeatWhenEmpty(int maxRepeat, Function<Flux<Long>,? extends Publisher<?>> repeatFactory) Repeatedly subscribe to this Mono as long as the current subscription to this Mono completes empty and the companion Publisher produces an onNext signal.
<V> Flux<V>	Flux.switchOnFirst(BiFunction<Signal<? extends T>,Flux<T>,Publisher<? extends V>> transformer) Transform the current Flux once it emits its first element, making a conditional transformation possible.
<V> Flux<V>	Flux.switchOnFirst(BiFunction<Signal<? extends T>,Flux<T>,Publisher<? extends V>> transformer, boolean cancelSourceOnComplete) Transform the current Flux once it emits its first element, making a conditional transformation possible.
<V> Flux<V>	Flux.transform(Function<? super Flux<T>,? extends Publisher<V>> transformer) Transform this Flux in order to generate a target Flux.
<V> Flux<V>	Flux.transformDeferred(Function<? super Flux<T>,? extends Publisher<V>> transformer) Defer the transformation of this Flux in order to generate a target Flux type.
<V> Flux<V>	Flux.transformDeferredContextual(BiFunction<? super Flux<T>,? super ContextView,? extends Publisher<V>> transformer) Defer the given transformation to this Flux in order to generate a target Flux type.

Constructors in reactor.core.publisher with parameters of type Flux

Constructor and Description
FluxOperator(Flux<? extends I> source) Build a FluxOperator wrapper around the passed parent Publisher

Uses of Flux in reactor.test.publisher

Methods in reactor.test.publisher that return Flux

Modifier and Type	Method and Description
Flux<T>	PublisherProbe.flux() Return a Flux version of the probe.
Flux<T>	PublisherProbe.DefaultPublisherProbe.flux()
abstract Flux<T>	TestPublisher.flux() Convenience method to wrap this TestPublisher to a Flux.

Uses of Flux in reactor.util.retry

Methods in reactor.util.retry that return Flux

Modifier and Type	Method and Description
Flux<Long>	RetrySpec.generateCompanion(Flux<Retry.RetrySignal> flux)
Flux<Long>	RetryBackoffSpec.generateCompanion(Flux<Retry.RetrySignal> t)

Methods in reactor.util.retry with parameters of type Flux

Modifier and Type	Method and Description
Flux<Long>	RetrySpec.generateCompanion(Flux<Retry.RetrySignal> flux)
abstract Publisher<?>	Retry.generateCompanion(Flux<Retry.RetrySignal> retrySignals) Generates the companion publisher responsible for reacting to incoming Retry.RetrySignal emissions, effectively deciding when to retry.
Flux<Long>	RetryBackoffSpec.generateCompanion(Flux<Retry.RetrySignal> t)

Method parameters in reactor.util.retry with type arguments of type Flux

Modifier and Type	Method and Description
static Retry	Retry.from(Function<Flux<Retry.RetrySignal>,? extends Publisher<?>> function) A wrapper around Function to provide Retry by using lambda expressions.
static Retry	Retry.withThrowable(Function<Flux<Throwable>,? extends Publisher<?>> function) An adapter for Flux of Throwable-based Function to provide Retry from a legacy retryWhen Function.