reactor.core.publisher

Class Flux<T>

java.lang.Object

reactor.core.publisher.Flux<T>

Type Parameters:

T - the element type of this Reactive Streams Publisher

All Implemented Interfaces:

org.reactivestreams.Publisher<T>

Direct Known Subclasses:

ConnectableFlux, FluxProcessor, FluxSource, GroupedFlux

public abstract class Flux<T>
extends java.lang.Object
implements org.reactivestreams.Publisher<T>

A Reactive Streams Publisher with rx operators that emits 0 to N elements, and then completes (successfully or with an error).

It is intended to be used in implementations and return types. Input parameters should keep using raw Publisher as much as possible.

If it is known that the underlying Publisher will emit 0 or 1 element, Mono should be used instead.

See Also:

Mono

Constructor Summary

Constructors

Constructor and Description
Flux()

Method Summary

Modifier and Type	Method and Description
Mono<java.lang.Boolean>	all(java.util.function.Predicate<? super T> predicate) Emit a single boolean true if all values of this sequence match the Predicate.
Mono<java.lang.Boolean>	any(java.util.function.Predicate<? super T> predicate) Emit a single boolean true if any of the values of this Flux sequence match the predicate.
<P> P	as(java.util.function.Function<? super Flux<T>,P> transformer) Immediately apply the given transformation to this Flux in order to generate a target type.
Flux<java.util.List<T>>	buffer() Collect incoming values into a List that will be pushed into the returned Mono on complete only.
Flux<java.util.List<T>>	buffer(java.time.Duration timespan) Collect incoming values into multiple List that will be pushed into the returned Flux every timespan.
Flux<java.util.List<T>>	buffer(java.time.Duration timespan, java.time.Duration timeshift) Collect incoming values into multiple List delimited by the given timeshift period.
Flux<java.util.List<T>>	buffer(int maxSize) Collect incoming values into multiple List buckets that will be pushed into the returned Flux when the given max size is reached or onComplete is received.
Flux<java.util.List<T>>	buffer(int maxSize, java.time.Duration timespan) Collect incoming values into a List that will be pushed into the returned Flux every timespan OR maxSize items.
Flux<java.util.List<T>>	buffer(int maxSize, int skip) Collect incoming values into multiple List that will be pushed into the returned Flux when the given max size is reached or onComplete is received.
Flux<java.util.List<T>>	buffer(org.reactivestreams.Publisher<?> other) Collect incoming values into multiple List delimited by the given Publisher signals.
<U,V> Flux<java.util.List<T>>	buffer(org.reactivestreams.Publisher<U> bucketOpening, java.util.function.Function<? super U,? extends org.reactivestreams.Publisher<V>> closeSelector) Collect incoming values into multiple List delimited by the given Publisher signals.
Flux<java.util.List<T>>	bufferMillis(int maxSize, long timespan) Collect incoming values into a List that will be pushed into the returned Flux every timespan OR maxSize items.
Flux<java.util.List<T>>	bufferMillis(int maxSize, long timespan, TimedScheduler timer) Collect incoming values into a List that will be pushed into the returned Flux every timespan OR maxSize items
Flux<java.util.List<T>>	bufferMillis(long timespan) Collect incoming values into multiple List that will be pushed into the returned Flux every timespan.
Flux<java.util.List<T>>	bufferMillis(long timespan, long timeshift) Collect incoming values into multiple List delimited by the given timeshift period.
Flux<java.util.List<T>>	bufferMillis(long timespan, long timeshift, TimedScheduler timer) Collect incoming values into multiple List delimited by the given timeshift period.
Flux<java.util.List<T>>	bufferMillis(long timespan, TimedScheduler timer) Collect incoming values into multiple List that will be pushed into the returned Flux every timespan.
Flux<T>	cache() Turn this Flux into a hot source and cache last emitted signals for further Subscriber.
Flux<T>	cache(int history) Turn this Flux into a hot source and cache last emitted signals for further Subscriber.
<E> Flux<E>	cast(java.lang.Class<E> stream) Cast the current Flux produced type into a target produced type.
<R,A> Mono<R>	collect(java.util.stream.Collector<T,A,R> collector) Collect the Flux sequence with the given collector and supplied container on subscribe.
<E> Mono<E>	collect(java.util.function.Supplier<E> containerSupplier, java.util.function.BiConsumer<E,? super T> collector) Collect the Flux sequence with the given collector and supplied container on subscribe.
Mono<java.util.List<T>>	collectList() Accumulate this Flux sequence in a List that is emitted to the returned Mono on onComplete.
<K> Mono<java.util.Map<K,T>>	collectMap(java.util.function.Function<? super T,? extends K> keyExtractor) Convert all this Flux sequence into a hashed map where the key is extracted by the given Function and the value will be the most recent emitted item for this key.
<K,V> Mono<java.util.Map<K,V>>	collectMap(java.util.function.Function<? super T,? extends K> keyExtractor, java.util.function.Function<? super T,? extends V> valueExtractor) Convert all this Flux sequence into a hashed map where the key is extracted by the given function and the value will be the most recent extracted item for this key.
<K,V> Mono<java.util.Map<K,V>>	collectMap(java.util.function.Function<? super T,? extends K> keyExtractor, java.util.function.Function<? super T,? extends V> valueExtractor, java.util.function.Supplier<java.util.Map<K,V>> mapSupplier) Convert all this Flux sequence into a supplied map where the key is extracted by the given function and the value will be the most recent extracted item for this key.
<K> Mono<java.util.Map<K,java.util.Collection<T>>>	collectMultimap(java.util.function.Function<? super T,? extends K> keyExtractor) Convert this Flux sequence into a hashed map where the key is extracted by the given function and the value will be all the emitted item for this key.
<K,V> Mono<java.util.Map<K,java.util.Collection<V>>>	collectMultimap(java.util.function.Function<? super T,? extends K> keyExtractor, java.util.function.Function<? super T,? extends V> valueExtractor) Convert this Flux sequence into a hashed map where the key is extracted by the given function and the value will be all the extracted items for this key.
<K,V> Mono<java.util.Map<K,java.util.Collection<V>>>	collectMultimap(java.util.function.Function<? super T,? extends K> keyExtractor, java.util.function.Function<? super T,? extends V> valueExtractor, java.util.function.Supplier<java.util.Map<K,java.util.Collection<V>>> mapSupplier) Convert this Flux sequence into a supplied map where the key is extracted by the given function and the value will be all the extracted items for this key.
Mono<java.util.List<T>>	collectSortedList() Accumulate and sort this Flux sequence in a List that is emitted to the returned Mono on onComplete.
Mono<java.util.List<T>>	collectSortedList(java.util.Comparator<? super T> comparator) Accumulate and sort using the given comparator this Flux sequence in a List that is emitted to the returned Mono on onComplete.
static <T,V> Flux<V>	combineLatest(java.util.function.Function<java.lang.Object[],V> combinator, int prefetch, org.reactivestreams.Publisher<? extends T>... sources) Build a Flux whose data are generated by the combination of the most recent published values from all publishers.
static <T,V> Flux<V>	combineLatest(java.util.function.Function<java.lang.Object[],V> combinator, org.reactivestreams.Publisher<? extends T>... sources) Build a Flux whose data are generated by the combination of the most recent published values from all publishers.
static <T,V> Flux<V>	combineLatest(java.lang.Iterable<? extends org.reactivestreams.Publisher<? extends T>> sources, java.util.function.Function<java.lang.Object[],V> combinator) Build a Flux whose data are generated by the combination of the most recent published values from all publishers.
static <T,V> Flux<V>	combineLatest(java.lang.Iterable<? extends org.reactivestreams.Publisher<? extends T>> sources, int prefetch, java.util.function.Function<java.lang.Object[],V> combinator) Build a Flux whose data are generated by the combination of the most recent published values from all publishers.
static <T1,T2,V> Flux<V>	combineLatest(org.reactivestreams.Publisher<? extends T1> source1, org.reactivestreams.Publisher<? extends T2> source2, java.util.function.BiFunction<? super T1,? super T2,? extends V> combinator) Build a Flux whose data are generated by the combination of the most recent published values from all publishers.
static <T1,T2,T3,V> Flux<V>	combineLatest(org.reactivestreams.Publisher<? extends T1> source1, org.reactivestreams.Publisher<? extends T2> source2, org.reactivestreams.Publisher<? extends T3> source3, java.util.function.Function<java.lang.Object[],V> combinator) Build a Flux whose data are generated by the combination of the most recent published values from all publishers.
static <T1,T2,T3,T4,V> Flux<V>	combineLatest(org.reactivestreams.Publisher<? extends T1> source1, org.reactivestreams.Publisher<? extends T2> source2, org.reactivestreams.Publisher<? extends T3> source3, org.reactivestreams.Publisher<? extends T4> source4, java.util.function.Function<java.lang.Object[],V> combinator) Build a Flux whose data are generated by the combination of the most recent published values from all publishers.
static <T1,T2,T3,T4,T5,V> Flux<V>	combineLatest(org.reactivestreams.Publisher<? extends T1> source1, org.reactivestreams.Publisher<? extends T2> source2, org.reactivestreams.Publisher<? extends T3> source3, org.reactivestreams.Publisher<? extends T4> source4, org.reactivestreams.Publisher<? extends T5> source5, java.util.function.Function<java.lang.Object[],V> combinator) Build a Flux whose data are generated by the combination of the most recent published values from all publishers.
static <T1,T2,T3,T4,T5,T6,V> Flux<V>	combineLatest(org.reactivestreams.Publisher<? extends T1> source1, org.reactivestreams.Publisher<? extends T2> source2, org.reactivestreams.Publisher<? extends T3> source3, org.reactivestreams.Publisher<? extends T4> source4, org.reactivestreams.Publisher<? extends T5> source5, org.reactivestreams.Publisher<? extends T6> source6, java.util.function.Function<java.lang.Object[],V> combinator) Build a Flux whose data are generated by the combination of the most recent published values from all publishers.
<V> Flux<V>	compose(java.util.function.Function<? super Flux<T>,? extends org.reactivestreams.Publisher<V>> transformer) Defer the given transformation to this Flux in order to generate a target Publisher type.
static <T> Flux<T>	concat(java.lang.Iterable<? extends org.reactivestreams.Publisher<? extends T>> sources) Concat all sources pulled from the supplied Iterator on Publisher.subscribe(org.reactivestreams.Subscriber<? super T>) from the passed Iterable until Iterator.hasNext() returns false.
static <T> Flux<T>	concat(org.reactivestreams.Publisher<? extends org.reactivestreams.Publisher<? extends T>> sources) Concat all sources emitted as an onNext signal from a parent Publisher.
static <T> Flux<T>	concat(org.reactivestreams.Publisher<? extends org.reactivestreams.Publisher<? extends T>> sources, int prefetch) Concat all sources emitted as an onNext signal from a parent Publisher.
static <T> Flux<T>	concat(org.reactivestreams.Publisher<? extends T>... sources) Concat all sources pulled from the given Publisher array.
<V> Flux<V>	concatMap(java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<? extends V>> mapper) Bind dynamic sequences given this input sequence like flatMap(Function), but preserve ordering and concatenate emissions instead of merging (no interleave).
<V> Flux<V>	concatMap(java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<? extends V>> mapper, int prefetch) Bind dynamic sequences given this input sequence like flatMap(Function), but preserve ordering and concatenate emissions instead of merging (no interleave).
<V> Flux<V>	concatMapDelayError(java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<? extends V>> mapper, boolean delayUntilEnd, int prefetch) Bind dynamic sequences given this input sequence like flatMap(Function), but preserve ordering and concatenate emissions instead of merging (no interleave).
<V> Flux<V>	concatMapDelayError(java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<? extends V>> mapper, int prefetch) Bind dynamic sequences given this input sequence like flatMap(Function), but preserve ordering and concatenate emissions instead of merging (no interleave).
<V> Flux<V>	concatMapDelayError(java.util.function.Function<? super T,org.reactivestreams.Publisher<? extends V>> mapper) Bind dynamic sequences given this input sequence like flatMap(Function), but preserve ordering and concatenate emissions instead of merging (no interleave).
<R> Flux<R>	concatMapIterable(java.util.function.Function<? super T,? extends java.lang.Iterable<? extends R>> mapper) Bind Iterable sequences given this input sequence like flatMapIterable(Function), but preserve ordering and concatenate emissions instead of merging (no interleave).
<R> Flux<R>	concatMapIterable(java.util.function.Function<? super T,? extends java.lang.Iterable<? extends R>> mapper, int prefetch) Bind Iterable sequences given this input sequence like flatMapIterable(Function), but preserve ordering and concatenate emissions instead of merging (no interleave).
Flux<T>	concatWith(org.reactivestreams.Publisher<? extends T> other) Concatenate emissions of this Flux with the provided Publisher (no interleave).
Mono<java.lang.Long>	count() Counts the number of values in this Flux.
static <T> Flux<T>	create(java.util.function.Consumer<? super FluxSink<T>> emitter) Creates a Flux with multi-emission capabilities (synchronous or asynchronous) through the FluxSink API.
static <T> Flux<T>	create(java.util.function.Consumer<? super FluxSink<T>> emitter, FluxSink.OverflowStrategy backpressure) Creates a Flux with multi-emission capabilities (synchronous or asynchronous) through the FluxSink API.
Flux<T>	defaultIfEmpty(T defaultV) Provide a default unique value if this sequence is completed without any data
static <T> Flux<T>	defer(java.util.function.Supplier<? extends org.reactivestreams.Publisher<T>> supplier) Supply a Publisher everytime subscribe is called on the returned flux.
Flux<T>	delay(java.time.Duration delay) Delay this Flux signals to Subscriber.onNext(T) until the given period elapses.
Flux<T>	delayMillis(long delay) Delay this Flux signals to Subscriber.onNext(T) until the given period in milliseconds elapses.
Flux<T>	delayMillis(long delay, TimedScheduler timer) Delay this Flux signals to Subscriber.onNext(T) until the given period in milliseconds elapses.
Flux<T>	delaySubscription(java.time.Duration delay) Delay the subscription to this Flux source until the given period elapses.
<U> Flux<T>	delaySubscription(org.reactivestreams.Publisher<U> subscriptionDelay) Delay the subscription to the main source until another Publisher signals a value or completes.
Flux<T>	delaySubscriptionMillis(long delay) Delay the subscription to this Flux source until the given period elapses.
Flux<T>	delaySubscriptionMillis(long delay, TimedScheduler timer) Delay the subscription to this Flux source until the given period elapses.
<X> Flux<X>	dematerialize() A "phantom-operator" working only if this Flux is a emits onNext, onError or onComplete Signal.
Flux<T>	distinct() For each Subscriber, tracks this Flux values that have been seen and filters out duplicates.
<V> Flux<T>	distinct(java.util.function.Function<? super T,? extends V> keySelector) For each Subscriber, tracks this Flux values that have been seen and filters out duplicates given the extracted key.
Flux<T>	distinctUntilChanged() Filters out subsequent and repeated elements.
<V> Flux<T>	distinctUntilChanged(java.util.function.Function<? super T,? extends V> keySelector) Filters out subsequent and repeated elements provided a matching extracted key.
Flux<T>	doAfterTerminate(java.lang.Runnable afterTerminate) Triggered after the Flux terminates, either by completing downstream successfully or with an error.
Flux<T>	doOnCancel(java.lang.Runnable onCancel) Triggered when the Flux is cancelled.
Flux<T>	doOnComplete(java.lang.Runnable onComplete) Triggered when the Flux completes successfully.
<E extends java.lang.Throwable> Flux<T>	doOnError(java.lang.Class<E> exceptionType, java.util.function.Consumer<? super E> onError) Triggered when the Flux completes with an error matching the given exception type.
Flux<T>	doOnError(java.util.function.Consumer<java.lang.Throwable> onError) Triggered when the Flux completes with an error.
Flux<T>	doOnError(java.util.function.Predicate<? super java.lang.Throwable> predicate, java.util.function.Consumer<? super java.lang.Throwable> onError) Triggered when the Flux completes with an error matching the given exception.
Flux<T>	doOnNext(java.util.function.Consumer<? super T> onNext) Triggered when the Flux emits an item.
Flux<T>	doOnRequest(java.util.function.LongConsumer consumer) Attach a LongConsumer to this Flux that will observe any request to this Flux.
Flux<T>	doOnSubscribe(java.util.function.Consumer<? super org.reactivestreams.Subscription> onSubscribe) Triggered when the Flux is subscribed.
Flux<T>	doOnTerminate(java.lang.Runnable onTerminate) Triggered when the Flux terminates, either by completing successfully or with an error.
Flux<Tuple2<java.lang.Long,T>>	elapsed() Map this Flux sequence into Tuple2 of T1 Long timemillis and T2 T associated data.
Mono<T>	elementAt(int index) Emit only the element at the given index position or IndexOutOfBoundsException if the sequence is shorter.
Mono<T>	elementAtOrDefault(int index, java.util.function.Supplier<? extends T> defaultValue) Emit only the element at the given index position or signals a default value if specified if the sequence is shorter.
static <T> Flux<T>	empty() Create a Flux that completes without emitting any item.
static <T> Flux<T>	error(java.lang.Throwable error) Create a Flux that completes with the specified error.
static <O> Flux<O>	error(java.lang.Throwable throwable, boolean whenRequested) Build a Flux that will only emit an error signal to any new subscriber.
Flux<T>	every(int batchSize) Emit only the last value of each batch counted from this Flux sequence.
Flux<T>	everyFirst(int batchSize) Emit only the first value of each batch counted from this Flux sequence.
Flux<T>	filter(java.util.function.Predicate<? super T> p) Evaluate each accepted value against the given Predicate.
static <I> Flux<I>	firstEmitting(java.lang.Iterable<? extends org.reactivestreams.Publisher<? extends I>> sources) Select the fastest source who won the "ambiguous" race and emitted first onNext or onComplete or onError
static <I> Flux<I>	firstEmitting(org.reactivestreams.Publisher<? extends I>... sources) Select the fastest source who emitted first onNext or onComplete or onError
Flux<T>	firstEmittingWith(org.reactivestreams.Publisher<? extends T> other) Emit from the fastest first sequence between this publisher and the given publisher
<R> Flux<R>	flatMap(java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> mapper) Transform the items emitted by this Flux into Publishers, then flatten the emissions from those by merging them into a single Flux, so that they may interleave.
<R> Flux<R>	flatMap(java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> mapperOnNext, java.util.function.Function<java.lang.Throwable,? extends org.reactivestreams.Publisher<? extends R>> mapperOnError, java.util.function.Supplier<? extends org.reactivestreams.Publisher<? extends R>> mapperOnComplete) Transform the signals emitted by this Flux into Publishers, then flatten the emissions from those by merging them into a single Flux, so that they may interleave.
<V> Flux<V>	flatMap(java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<? extends V>> mapper, boolean delayError, int concurrency, int prefetch) Transform the items emitted by this Flux into Publishers, then flatten the emissions from those by merging them into a single Flux, so that they may interleave.
<V> Flux<V>	flatMap(java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<? extends V>> mapper, int concurrency) Transform the items emitted by this Flux into Publishers, then flatten the emissions from those by merging them into a single Flux, so that they may interleave.
<V> Flux<V>	flatMap(java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<? extends V>> mapper, int concurrency, int prefetch) Transform the items emitted by this Flux into Publishers, then flatten the emissions from those by merging them into a single Flux, so that they may interleave.
<R> Flux<R>	flatMapIterable(java.util.function.Function<? super T,? extends java.lang.Iterable<? extends R>> mapper) Transform the items emitted by this Flux into Iterable, then flatten the elements from those by merging them into a single Flux.
<R> Flux<R>	flatMapIterable(java.util.function.Function<? super T,? extends java.lang.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.
static <T> Flux<T>	from(org.reactivestreams.Publisher<? extends T> source) Expose the specified Publisher with the Flux API.
static <T> Flux<T>	fromArray(T[] array) Create a Flux that emits the items contained in the provided Iterable.
static <T> Flux<T>	fromIterable(java.lang.Iterable<? extends T> it) Create a Flux that emits the items contained in the provided Iterable.
static <T> Flux<T>	fromStream(java.util.stream.Stream<? extends T> s) Create a Flux that emits the items contained in the provided Stream.
static <T,S> Flux<T>	generate(java.util.function.BiFunction<S,SynchronousSink<T>,S> generator) Generate signals one-by-one via a function callback.
static <T,S> Flux<T>	generate(java.util.concurrent.Callable<S> stateSupplier, java.util.function.BiFunction<S,SynchronousSink<T>,S> generator) Generate signals one-by-one via a function callback.
static <T,S> Flux<T>	generate(java.util.concurrent.Callable<S> stateSupplier, java.util.function.BiFunction<S,SynchronousSink<T>,S> generator, java.util.function.Consumer<? super S> stateConsumer) Generate signals one-by-one via a function callback.
long	getPrefetch() The prefetch configuration of the Flux
<K> Flux<GroupedFlux<K,T>>	groupBy(java.util.function.Function<? super T,? extends K> keyMapper) Re-route this sequence into dynamically created Flux for each unique key evaluated by the given key mapper.
<K,V> Flux<GroupedFlux<K,V>>	groupBy(java.util.function.Function<? super T,? extends K> keyMapper, java.util.function.Function<? super T,? extends V> valueMapper) Re-route this sequence into dynamically created Flux for each unique key evaluated by the given key mapper.
Mono<java.lang.Boolean>	hasElement(T value) Emit a single boolean true if any of the values of this Flux sequence match the constant.
Mono<java.lang.Boolean>	hasElements() Emit a single boolean true if this Flux sequence has at least one element.
Flux<T>	hide() Hides the identities of this Flux and its Subscription as well.
Mono<T>	ignoreElements() Ignores onNext signals (dropping them) and only reacts on termination.
static Flux<java.lang.Long>	interval(java.time.Duration period) Create a new Flux that emits an ever incrementing long starting with 0 every period on the global timer.
static Flux<java.lang.Long>	interval(java.time.Duration delay, java.time.Duration period) Create a new Flux that emits an ever incrementing long starting with 0 every N period of time unit on a global timer.
static Flux<java.lang.Long>	intervalMillis(long period) Create a new Flux that emits an ever incrementing long starting with 0 every N milliseconds on the given timer.
static Flux<java.lang.Long>	intervalMillis(long delay, long period) Create a new Flux that emits an ever incrementing long starting with 0 every N period of time unit on a global timer.
static Flux<java.lang.Long>	intervalMillis(long delay, long period, TimedScheduler timer) Create a new Flux that emits an ever incrementing long starting with 0 every N period of time unit on the given timer.
static Flux<java.lang.Long>	intervalMillis(long period, TimedScheduler timer) Create a new Flux that emits an ever incrementing long starting with 0 every N milliseconds on the given timer.
static <T> Flux<T>	just(T... data) Create a new Flux that emits the specified items and then complete.
static <T> Flux<T>	just(T data) Create a new Flux that will only emit the passed data then onComplete.
Mono<T>	last() Signal the last element observed before complete signal.
Flux<T>	log() Observe all Reactive Streams signals and use Logger support to handle trace implementation.
Flux<T>	log(java.lang.String category) Observe all Reactive Streams signals and use Logger support to handle trace implementation.
Flux<T>	log(java.lang.String category, java.util.logging.Level level, SignalType... options) Observe Reactive Streams signals matching the passed filter options and use Logger support to handle trace implementation.
<V> Flux<V>	map(java.util.function.Function<? super T,? extends V> mapper) Transform the items emitted by this Flux by applying a function to each item.
<E extends java.lang.Throwable> Flux<T>	mapError(java.lang.Class<E> type, java.util.function.Function<? super E,? extends java.lang.Throwable> mapper) Transform the error emitted by this Flux by applying a function if the error matches the given type, otherwise let the error flows.
Flux<T>	mapError(java.util.function.Function<? super java.lang.Throwable,? extends java.lang.Throwable> mapper) Transform the error emitted by this Flux by applying a function.
Flux<T>	mapError(java.util.function.Predicate<? super java.lang.Throwable> predicate, java.util.function.Function<? super java.lang.Throwable,? extends java.lang.Throwable> mapper) Transform the error emitted by this Flux by applying a function if the error matches the given predicate, otherwise let the error flows.
Flux<Signal<T>>	materialize() Transform the incoming onNext, onError and onComplete signals into Signal.
static <I> Flux<I>	merge(int prefetch, org.reactivestreams.Publisher<? extends I>... sources) Merge emitted Publisher sequences from the passed Publisher array into an interleaved merged sequence.
static <I> Flux<I>	merge(java.lang.Iterable<? extends org.reactivestreams.Publisher<? extends I>> sources) Merge emitted Publisher sequences from the passed Iterable into an interleaved merged sequence.
static <I> Flux<I>	merge(org.reactivestreams.Publisher<? extends I>... sources) Merge emitted Publisher sequences from the passed Publisher array into an interleaved merged sequence.
static <T> Flux<T>	merge(org.reactivestreams.Publisher<? extends org.reactivestreams.Publisher<? extends T>> source) Merge emitted Publisher sequences by the passed Publisher into an interleaved merged sequence.
static <T> Flux<T>	merge(org.reactivestreams.Publisher<? extends org.reactivestreams.Publisher<? extends T>> source, int concurrency) Merge emitted Publisher sequences by the passed Publisher into an interleaved merged sequence.
static <T> Flux<T>	merge(org.reactivestreams.Publisher<? extends org.reactivestreams.Publisher<? extends T>> source, int concurrency, int prefetch) Merge emitted Publisher sequences by the passed Publisher into an interleaved merged sequence.
Flux<T>	mergeWith(org.reactivestreams.Publisher<? extends T> other) Merge emissions of this Flux with the provided Publisher, so that they may interleave.
static <T> Flux<T>	never() Create a Flux that will never signal any data, error or completion signal.
Mono<T>	next() Emit only the first item emitted by this Flux.
Flux<T>	onBackpressureBuffer() Request an unbounded demand and push the returned Flux, or park the observed elements if not enough demand is requested downstream.
Flux<T>	onBackpressureDrop() Request an unbounded demand and push the returned Flux, or drop the observed elements if not enough demand is requested downstream.
Flux<T>	onBackpressureDrop(java.util.function.Consumer<? super T> onDropped) Request an unbounded demand and push the returned Flux, or drop and notify dropping Consumer with the observed elements if not enough demand is requested downstream.
Flux<T>	onBackpressureError() Request an unbounded demand and push the returned Flux, or emit onError fom Exceptions.failWithOverflow() if not enough demand is requested downstream.
Flux<T>	onBackpressureLatest() Request an unbounded demand and push the returned Flux, or only keep the most recent observed item if not enough demand is requested downstream.
<E extends java.lang.Throwable> Flux<T>	onErrorResumeWith(java.lang.Class<E> type, java.util.function.Function<? super E,? extends org.reactivestreams.Publisher<? extends T>> fallback) Subscribe to a returned fallback publisher when an error matching the given type occurs.
Flux<T>	onErrorResumeWith(java.util.function.Function<? super java.lang.Throwable,? extends org.reactivestreams.Publisher<? extends T>> fallback) Subscribe to a returned fallback publisher when any error occurs.
Flux<T>	onErrorResumeWith(java.util.function.Predicate<? super java.lang.Throwable> predicate, java.util.function.Function<? super java.lang.Throwable,? extends org.reactivestreams.Publisher<? extends T>> fallback) Subscribe to a returned fallback publisher when an error matching the given type occurs.
<E extends java.lang.Throwable> Flux<T>	onErrorReturn(java.lang.Class<E> type, T fallbackValue) Fallback to the given value if an error of a given type is observed on this Flux
<E extends java.lang.Throwable> Flux<T>	onErrorReturn(java.util.function.Predicate<? super java.lang.Throwable> predicate, T fallbackValue) Fallback to the given value if an error matching the given predicate is observed on this Flux
Flux<T>	onErrorReturn(T fallbackValue) Fallback to the given value if an error is observed on this Flux
Flux<T>	onTerminateDetach() Detaches the both the child Subscriber and the Subscription on termination or cancellation.
ParallelFlux<T>	parallel() Prepare to consume this Flux on number of 'rails' matching number of CPU in round-robin fashion.
ParallelFlux<T>	parallel(int parallelism) Prepare to consume this Flux on parallallism number of 'rails' in round-robin fashion.
ParallelFlux<T>	parallel(int parallelism, int prefetch) Prepare to consume this Flux on parallallism number of 'rails' in round-robin fashion and use custom prefetch amount and queue for dealing with the source Flux's values.
ConnectableFlux<T>	process(org.reactivestreams.Processor<? super T,? extends T> processor) Prepare a ConnectableFlux which subscribes this Flux sequence to the given Processor.
<U> ConnectableFlux<U>	process(org.reactivestreams.Processor<? super T,? extends T> processor, java.util.function.Function<Flux<T>,? extends org.reactivestreams.Publisher<? extends U>> selector) Prepare a ConnectableFlux which subscribes this Flux sequence to the given Processor.
ConnectableFlux<T>	process(java.util.function.Supplier<? extends org.reactivestreams.Processor<? super T,? extends T>> processorSupplier) Prepare a ConnectableFlux which subscribes this Flux sequence to a supplied Processor when ConnectableFlux.connect() is invoked manually or automatically via ConnectableFlux.autoConnect() and ConnectableFlux.refCount().
<U> ConnectableFlux<U>	process(java.util.function.Supplier<? extends org.reactivestreams.Processor<? super T,? extends T>> processorSupplier, java.util.function.Function<Flux<T>,? extends org.reactivestreams.Publisher<? extends U>> selector) Prepare a ConnectableFlux which subscribes this Flux sequence to a supplied Processor when ConnectableFlux.connect() is invoked manually or automatically via ConnectableFlux.autoConnect() and ConnectableFlux.refCount().
ConnectableFlux<T>	publish() Prepare a ConnectableFlux which shares this Flux sequence and dispatches values to subscribers in a backpressure-aware manner.
<R> Flux<R>	publish(java.util.function.Function<? super Flux<T>,? extends org.reactivestreams.Publisher<? extends R>> transform) Shares a sequence for the duration of a function that may transform it and consume it as many times as necessary without causing multiple subscriptions to the upstream.
<R> Flux<R>	publish(java.util.function.Function<? super Flux<T>,? extends org.reactivestreams.Publisher<? extends R>> transform, int prefetch) Shares a sequence for the duration of a function that may transform it and consume it as many times as necessary without causing multiple subscriptions to the upstream.
ConnectableFlux<T>	publish(int prefetch) Prepare a ConnectableFlux which shares this Flux sequence and dispatches values to subscribers in a backpressure-aware manner.
Mono<T>	publishNext() Prepare a Mono which shares this Flux sequence and dispatches the first observed item to subscribers in a backpressure-aware manner.
Flux<T>	publishOn(Scheduler scheduler) Run onNext, onComplete and onError on a supplied Scheduler Scheduler.Worker.
Flux<T>	publishOn(Scheduler scheduler, int prefetch) Run onNext, onComplete and onError on a supplied Scheduler Scheduler.Worker.
static Flux<java.lang.Integer>	range(int start, int count) Build a Flux that will only emit a sequence of incrementing integer from start to start + count then complete.
<A> Mono<A>	reduce(A initial, java.util.function.BiFunction<A,? super T,A> accumulator) Accumulate the values from this Flux sequence into an object matching an initial value type.
Mono<T>	reduce(java.util.function.BiFunction<T,T,T> aggregator) Aggregate the values from this Flux sequence into an object of the same type than the emitted items.
<A> Mono<A>	reduceWith(java.util.function.Supplier<A> initial, java.util.function.BiFunction<A,? super T,A> accumulator) Accumulate the values from this Flux sequence into an object matching an initial value type.
Flux<T>	repeat() Repeatedly subscribe to the source completion of the previous subscription.
Flux<T>	repeat(java.util.function.BooleanSupplier predicate) Repeatedly subscribe to the source if the predicate returns true after completion of the previous subscription.
Flux<T>	repeat(long numRepeat) Repeatedly subscribe to the source if the predicate returns true after completion of the previous subscription.
Flux<T>	repeat(long numRepeat, java.util.function.BooleanSupplier predicate) Repeatedly subscribe to the source if the predicate returns true after completion of the previous subscription.
Flux<T>	repeatWhen(java.util.function.Function<Flux<java.lang.Long>,? extends org.reactivestreams.Publisher<?>> whenFactory) Repeatedly subscribe to this Flux when a companion sequence signals a number of emitted elements in response to the flux completion signal.
ConnectableFlux<T>	replay() Turn this Flux into a hot source and cache last emitted signals for further Subscriber.
ConnectableFlux<T>	replay(int history) Turn this Flux into a hot source and cache last emitted signals for further Subscriber.
Flux<T>	retry() Re-subscribes to this Flux sequence if it signals any error either indefinitely.
Flux<T>	retry(long numRetries) Re-subscribes to this Flux sequence if it signals any error either indefinitely or a fixed number of times.
Flux<T>	retry(long numRetries, java.util.function.Predicate<java.lang.Throwable> retryMatcher) Re-subscribes to this Flux sequence up to the specified number of retries if it signals any error and the given Predicate matches otherwise push the error downstream.
Flux<T>	retry(java.util.function.Predicate<java.lang.Throwable> retryMatcher) Re-subscribes to this Flux sequence if it signals any error and the given Predicate matches otherwise push the error downstream.
Flux<T>	retryWhen(java.util.function.Function<Flux<java.lang.Throwable>,? extends org.reactivestreams.Publisher<?>> whenFactory) Retries this Flux when a companion sequence signals an item in response to this Flux error signal
Flux<T>	sample(java.time.Duration timespan) Emit latest value for every given period of time.
<U> Flux<T>	sample(org.reactivestreams.Publisher<U> sampler) Sample this Flux and emit its latest value whenever the sampler Publisher signals a value.
Flux<T>	sampleFirst(java.time.Duration timespan) Take a value from this Flux then use the duration provided to skip other values.
<U> Flux<T>	sampleFirst(java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<U>> samplerFactory) Take a value from this Flux then use the duration provided by a generated Publisher to skip other values until that sampler Publisher signals.
Flux<T>	sampleFirstMillis(long timespan) Take a value from this Flux then use the duration provided to skip other values.
Flux<T>	sampleMillis(long timespan) Emit latest value for every given period of ti,e.
<U> Flux<T>	sampleTimeout(java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<U>> throttlerFactory) Emit the last value from this Flux only if there were no new values emitted during the time window provided by a publisher for that particular last value.
<U> Flux<T>	sampleTimeout(java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<U>> throttlerFactory, int maxConcurrency) Emit the last value from this Flux only if there were no newer values emitted during the time window provided by a publisher for that particular last value.
<A> Flux<A>	scan(A initial, java.util.function.BiFunction<A,? super T,A> accumulator) Aggregate this Flux values with the help of an accumulator BiFunction and emits the intermediate results.
Flux<T>	scan(java.util.function.BiFunction<T,T,T> accumulator) Accumulate this Flux values with an accumulator BiFunction and returns the intermediate results of this function.
<A> Flux<A>	scanWith(java.util.function.Supplier<A> initial, java.util.function.BiFunction<A,? super T,A> accumulator) Aggregate this Flux values with the help of an accumulator BiFunction and emits the intermediate results.
Mono<T>	single() Expect and emit a single item from this Flux source or signal NoSuchElementException (or a default generated value) for empty source, IndexOutOfBoundsException for a multi-item source.
Mono<T>	singleOrDefault(java.util.function.Supplier<? extends T> defaultSupplier) Expect and emit a single item from this Flux source or signal NoSuchElementException (or a default generated value) for empty source, IndexOutOfBoundsException for a multi-item source.
Mono<T>	singleOrEmpty() Expect and emit a zero or single item from this Flux source or IndexOutOfBoundsException for a multi-item source.
Flux<T>	skip(java.time.Duration timespan) Skip elements from this Flux for the given time period.
Flux<T>	skip(long skipped) Skip next the specified number of elements from this Flux.
Flux<T>	skipLast(int n) Skip the last specified number of elements from this Flux.
Flux<T>	skipMillis(long timespan) Skip elements from this Flux for the given time period.
Flux<T>	skipMillis(long timespan, TimedScheduler timer) Skip elements from this Flux for the given time period.
Flux<T>	skipUntil(java.util.function.Predicate<? super T> untilPredicate) Skips values from this Flux until a Predicate returns true for the value.
Flux<T>	skipUntilOther(org.reactivestreams.Publisher<?> other) Skip values from this Flux until a specified Publisher signals an onNext or onComplete.
Flux<T>	skipWhile(java.util.function.Predicate<? super T> skipPredicate) Skips values from this Flux while a Predicate returns true for the value.
Flux<T>	startWith(java.lang.Iterable<? extends T> iterable) Prepend the given Iterable before this Flux sequence.
Flux<T>	startWith(org.reactivestreams.Publisher<? extends T> publisher) Prepend the given Publisher sequence before this Flux sequence.
Flux<T>	startWith(T... values) Prepend the given values before this Flux sequence.
Cancellation	subscribe() Start the chain and request unbounded demand.
Cancellation	subscribe(java.util.function.Consumer<? super T> consumer) Subscribe a Consumer to this Flux that will consume all the sequence.
Cancellation	subscribe(java.util.function.Consumer<? super T> consumer, java.util.function.Consumer<? super java.lang.Throwable> errorConsumer) Subscribe Consumer to this Flux that will consume all the sequence.
Cancellation	subscribe(java.util.function.Consumer<? super T> consumer, java.util.function.Consumer<? super java.lang.Throwable> errorConsumer, java.lang.Runnable completeConsumer) Subscribe Consumer to this Flux that will consume all the sequence.
Cancellation	subscribe(java.util.function.Consumer<? super T> consumer, java.util.function.Consumer<? super java.lang.Throwable> errorConsumer, java.lang.Runnable completeConsumer, int prefetch) Subscribe Consumer to this Flux that will consume all the sequence.
Cancellation	subscribe(java.util.function.Consumer<? super T> consumer, int prefetch) Subscribe a Consumer to this Flux that will consume all the sequence.
Cancellation	subscribe(int prefetch) Start the chain and request prefetch demand
Flux<T>	subscribeOn(Scheduler scheduler) Run subscribe, onSubscribe and request on a supplied Scheduler
<E extends org.reactivestreams.Subscriber<? super T>> E	subscribeWith(E subscriber) A chaining Publisher.subscribe(Subscriber) alternative to inline composition type conversion to a hot emitter (e.g.
Flux<T>	switchIfEmpty(org.reactivestreams.Publisher<? extends T> alternate) Provide an alternative if this sequence is completed without any data
<V> Flux<V>	switchMap(java.util.function.Function<? super T,org.reactivestreams.Publisher<? extends V>> fn) Switch to a new Publisher generated via a Function whenever this Flux produces an item.
<V> Flux<V>	switchMap(java.util.function.Function<? super T,org.reactivestreams.Publisher<? extends V>> fn, int prefetch) Switch to a new Publisher generated via a Function whenever this Flux produces an item.
<E extends java.lang.Throwable> Flux<T>	switchOnError(java.lang.Class<E> type, org.reactivestreams.Publisher<? extends T> fallback) Subscribe to the given fallback Publisher if an error matching the given type is observed on this Flux
Flux<T>	switchOnError(java.util.function.Predicate<? super java.lang.Throwable> predicate, org.reactivestreams.Publisher<? extends T> fallback) Subscribe to the given fallback Publisher if an error matching the given predicate is observed on this Flux
Flux<T>	switchOnError(org.reactivestreams.Publisher<? extends T> fallback) Subscribe to the given fallback Publisher if an error is observed on this Flux
static <T> Flux<T>	switchOnNext(org.reactivestreams.Publisher<? extends org.reactivestreams.Publisher<? extends T>> mergedPublishers) Build a FluxProcessor whose data are emitted by the most recent emitted Publisher.
static <T> Flux<T>	switchOnNext(org.reactivestreams.Publisher<? extends org.reactivestreams.Publisher<? extends T>> mergedPublishers, int prefetch) Build a FluxProcessor whose data are emitted by the most recent emitted Publisher.
Flux<T>	take(java.time.Duration timespan) Relay values from this Flux until the given time period elapses.
Flux<T>	take(long n) Take only the first N values from this Flux.
Flux<T>	takeLast(int n) Emit the last N values this Flux emitted before its completion.
Flux<T>	takeMillis(long timespan) Relay values from this Flux until the given time period elapses.
Flux<T>	takeMillis(long timespan, TimedScheduler timer) Relay values from this Flux until the given time period elapses.
Flux<T>	takeUntil(java.util.function.Predicate<? super T> predicate) Relay values from this Flux until the given Predicate matches.
Flux<T>	takeUntilOther(org.reactivestreams.Publisher<?> other) Relay values from this Flux until the given Publisher emits.
Flux<T>	takeWhile(java.util.function.Predicate<? super T> continuePredicate) Relay values while a predicate returns FALSE for the values (checked before each value is delivered).
Mono<java.lang.Void>	then() Return a Mono<Void> that completes when this Flux completes.
Mono<java.lang.Void>	then(org.reactivestreams.Publisher<java.lang.Void> other) Return a Flux that emits the completion of the supplied Publisher when this Flux onComplete or onError.
Mono<java.lang.Void>	then(java.util.function.Supplier<? extends org.reactivestreams.Publisher<java.lang.Void>> afterSupplier) Return a Flux that emits the completion of the supplied Publisher when this Flux onComplete or onError.
<V> Flux<V>	thenMany(org.reactivestreams.Publisher<V> other) Return a Flux that emits the sequence of the supplied Publisher when this Flux onComplete or onError.
<V> Flux<V>	thenMany(java.util.function.Supplier<? extends org.reactivestreams.Publisher<V>> afterSupplier) Return a Flux that emits the sequence of the supplied Publisher when this Flux onComplete or onError.
Flux<T>	timeout(java.time.Duration timeout) Signal a TimeoutException in case a per-item period fires before the next item arrives from this Flux.
Flux<T>	timeout(java.time.Duration timeout, org.reactivestreams.Publisher<? extends T> fallback) Switch to a fallback Publisher in case a per-item period fires before the next item arrives from this Flux.
<U> Flux<T>	timeout(org.reactivestreams.Publisher<U> firstTimeout) Signal a TimeoutException in case a first item from this Flux has not been emitted before the given Publisher emits.
<U,V> Flux<T>	timeout(org.reactivestreams.Publisher<U> firstTimeout, java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<V>> nextTimeoutFactory) Signal a TimeoutException in case a first item from this Flux has not been emitted before the given Publisher emits.
<U,V> Flux<T>	timeout(org.reactivestreams.Publisher<U> firstTimeout, java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<V>> nextTimeoutFactory, org.reactivestreams.Publisher<? extends T> fallback) Switch to a fallback Publisher in case a first item from this Flux has not been emitted before the given Publisher emits.
Flux<T>	timeoutMillis(long timeout) Signal a TimeoutException error in case a per-item period in milliseconds fires before the next item arrives from this Flux.
Flux<T>	timeoutMillis(long timeout, org.reactivestreams.Publisher<? extends T> fallback) Switch to a fallback Publisher in case a per-item period fires before the next item arrives from this Flux.
Flux<T>	timeoutMillis(long timeout, org.reactivestreams.Publisher<? extends T> fallback, TimedScheduler timer) Switch to a fallback Publisher in case a per-item period fires before the next item arrives from this Flux.
Flux<T>	timeoutMillis(long timeout, TimedScheduler timer) Signal a TimeoutException error in case a per-item period in milliseconds fires before the next item arrives from this Flux.
Flux<Tuple2<java.lang.Long,T>>	timestamp() Emit a Tuple2 pair of T1 Long current system time in millis and T2 T associated data for each item from this Flux
java.lang.Iterable<T>	toIterable() Transform this Flux into a lazy Iterable blocking on next calls.
java.lang.Iterable<T>	toIterable(long batchSize) Transform this Flux into a lazy Iterable blocking on next calls.
java.lang.Iterable<T>	toIterable(long batchSize, java.util.function.Supplier<java.util.Queue<T>> queueProvider) Transform this Flux into a lazy Iterable blocking on next calls.
java.util.stream.Stream<T>	toStream() Transform this Flux into a lazy Stream blocking on next calls.
java.util.stream.Stream<T>	toStream(int batchSize) Transform this Flux into a lazy Stream blocking on next calls.
java.lang.String	toString()
static <T,D> Flux<T>	using(java.util.concurrent.Callable<? extends D> resourceSupplier, java.util.function.Function<? super D,? extends org.reactivestreams.Publisher<? extends T>> sourceSupplier, java.util.function.Consumer<? super D> resourceCleanup) Uses a resource, generated by a supplier for each individual Subscriber, while streaming the values from a Publisher derived from the same resource and makes sure the resource is released if the sequence terminates or the Subscriber cancels.
static <T,D> Flux<T>	using(java.util.concurrent.Callable<? extends D> resourceSupplier, java.util.function.Function<? super D,? extends org.reactivestreams.Publisher<? extends T>> sourceSupplier, java.util.function.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.
Flux<Flux<T>>	window() Split this Flux sequence into multiple Flux delimited by cancel signals they receive.
Flux<Flux<T>>	window(java.time.Duration timespan) Split this Flux sequence into continuous, non-overlapping windows delimited by a given period.
Flux<Flux<T>>	window(java.time.Duration timespan, java.time.Duration timeshift) Split this Flux sequence into multiple Flux delimited by the given timeshift period, starting from the first item.
Flux<Flux<T>>	window(int maxSize) Split this Flux sequence into multiple Flux delimited by the given maxSize count and starting from the first item.
Flux<Flux<T>>	window(int maxSize, java.time.Duration timespan) Split this Flux sequence into multiple Flux delimited by the given maxSize number of items, starting from the first item.
Flux<Flux<T>>	window(int maxSize, int skip) Split this Flux sequence into multiple Flux delimited by the given skip count, starting from the first item.
Flux<Flux<T>>	window(org.reactivestreams.Publisher<?> boundary) Split this Flux sequence into continuous, non-overlapping windows where the window boundary is signalled by another Publisher
<U,V> Flux<Flux<T>>	window(org.reactivestreams.Publisher<U> bucketOpening, java.util.function.Function<? super U,? extends org.reactivestreams.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>>	windowMillis(int maxSize, long timespan) Split this Flux sequence into multiple Flux delimited by the given maxSize number of items, starting from the first item.
Flux<Flux<T>>	windowMillis(int maxSize, long timespan, TimedScheduler timer) Split this Flux sequence into multiple Flux delimited by the given maxSize number of items, starting from the first item.
Flux<Flux<T>>	windowMillis(long timespan) Split this Flux sequence into continuous, non-overlapping windows delimited by a given period.
Flux<Flux<T>>	windowMillis(long timespan, long timeshift) Split this Flux sequence into multiple Flux delimited by the given timeshift period, starting from the first item.
Flux<Flux<T>>	windowMillis(long timespan, long timeshift, TimedScheduler timer) Split this Flux sequence into multiple Flux delimited by the given timeshift period, starting from the first item.
Flux<Flux<T>>	windowMillis(long timespan, TimedScheduler timer) Split this Flux sequence into continuous, non-overlapping windows delimited by a given period.
<U,R> Flux<R>	withLatestFrom(org.reactivestreams.Publisher<? extends U> other, java.util.function.BiFunction<? super T,? super U,? extends R> resultSelector) Combine values from this Flux with values from another Publisher through a BiFunction and emits the result.
static <I,O> Flux<O>	zip(java.util.function.Function<? super java.lang.Object[],? extends O> combinator, int prefetch, org.reactivestreams.Publisher<? extends I>... sources) "Step-Merge" especially useful in Scatter-Gather scenarios.
static <I,O> Flux<O>	zip(java.util.function.Function<? super java.lang.Object[],? extends O> combinator, org.reactivestreams.Publisher<? extends I>... sources) "Step-Merge" especially useful in Scatter-Gather scenarios.
static Flux<Tuples>	zip(java.lang.Iterable<? extends org.reactivestreams.Publisher<?>> sources) "Step-Merge" especially useful in Scatter-Gather scenarios.
static <O> Flux<O>	zip(java.lang.Iterable<? extends org.reactivestreams.Publisher<?>> sources, java.util.function.Function<? super java.lang.Object[],? extends O> combinator) "Step-Merge" especially useful in Scatter-Gather scenarios.
static <O> Flux<O>	zip(java.lang.Iterable<? extends org.reactivestreams.Publisher<?>> sources, int prefetch, java.util.function.Function<? super java.lang.Object[],? extends O> combinator) "Step-Merge" especially useful in Scatter-Gather scenarios.
static <TUPLE extends Tuples,V> Flux<V>	zip(org.reactivestreams.Publisher<? extends org.reactivestreams.Publisher<?>> sources, java.util.function.Function<? super TUPLE,? extends V> combinator) "Step-Merge" especially useful in Scatter-Gather scenarios.
static <T1,T2> Flux<Tuple2<T1,T2>>	zip(org.reactivestreams.Publisher<? extends T1> source1, org.reactivestreams.Publisher<? extends T2> source2) "Step-Merge" especially useful in Scatter-Gather scenarios.
static <T1,T2,O> Flux<O>	zip(org.reactivestreams.Publisher<? extends T1> source1, org.reactivestreams.Publisher<? extends T2> source2, java.util.function.BiFunction<? super T1,? super T2,? extends O> combinator) "Step-Merge" especially useful in Scatter-Gather scenarios.
static <T1,T2,T3> Flux<Tuple3<T1,T2,T3>>	zip(org.reactivestreams.Publisher<? extends T1> source1, org.reactivestreams.Publisher<? extends T2> source2, org.reactivestreams.Publisher<? extends T3> source3) "Step-Merge" especially useful in Scatter-Gather scenarios.
static <T1,T2,T3,T4> Flux<Tuple4<T1,T2,T3,T4>>	zip(org.reactivestreams.Publisher<? extends T1> source1, org.reactivestreams.Publisher<? extends T2> source2, org.reactivestreams.Publisher<? extends T3> source3, org.reactivestreams.Publisher<? extends T4> source4) "Step-Merge" especially useful in Scatter-Gather scenarios.
static <T1,T2,T3,T4,T5> Flux<Tuple5<T1,T2,T3,T4,T5>>	zip(org.reactivestreams.Publisher<? extends T1> source1, org.reactivestreams.Publisher<? extends T2> source2, org.reactivestreams.Publisher<? extends T3> source3, org.reactivestreams.Publisher<? extends T4> source4, org.reactivestreams.Publisher<? extends T5> source5) "Step-Merge" especially useful in Scatter-Gather scenarios.
static <T1,T2,T3,T4,T5,T6> Flux<Tuple6<T1,T2,T3,T4,T5,T6>>	zip(org.reactivestreams.Publisher<? extends T1> source1, org.reactivestreams.Publisher<? extends T2> source2, org.reactivestreams.Publisher<? extends T3> source3, org.reactivestreams.Publisher<? extends T4> source4, org.reactivestreams.Publisher<? extends T5> source5, org.reactivestreams.Publisher<? extends T6> source6) "Step-Merge" especially useful in Scatter-Gather scenarios.
<T2> Flux<Tuple2<T,T2>>	zipWith(org.reactivestreams.Publisher<? extends T2> source2) "Step-Merge" especially useful in Scatter-Gather scenarios.
<T2,V> Flux<V>	zipWith(org.reactivestreams.Publisher<? extends T2> source2, java.util.function.BiFunction<? super T,? super T2,? extends V> combinator) "Step-Merge" especially useful in Scatter-Gather scenarios.
<T2> Flux<Tuple2<T,T2>>	zipWith(org.reactivestreams.Publisher<? extends T2> source2, int prefetch) "Step-Merge" especially useful in Scatter-Gather scenarios.
<T2,V> Flux<V>	zipWith(org.reactivestreams.Publisher<? extends T2> source2, int prefetch, java.util.function.BiFunction<? super T,? super T2,? extends V> combinator) "Step-Merge" especially useful in Scatter-Gather scenarios.
<T2> Flux<Tuple2<T,T2>>	zipWithIterable(java.lang.Iterable<? extends T2> iterable) Pairwise combines as Tuple2 elements of this Flux and an Iterable sequence.
<T2,V> Flux<V>	zipWithIterable(java.lang.Iterable<? extends T2> iterable, java.util.function.BiFunction<? super T,? super T2,? extends V> zipper) Pairwise combines elements of this Flux and an Iterable sequence using the given zipper BiFunction.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Methods inherited from interface org.reactivestreams.Publisher

subscribe

Constructor Detail

Flux

public Flux()

Method Detail

combineLatest

@SafeVarargs
public static <T,V> Flux<V> combineLatest(java.util.function.Function<java.lang.Object[],V> combinator,
                                                       org.reactivestreams.Publisher<? extends T>... sources)

Build a Flux whose data are generated by the combination of the most recent published values from all publishers.

Type Parameters:

T - type of the value from sources

V - The produced output after transformation by the given combinator

Parameters:

sources - The upstreams Publisher to subscribe to.

combinator - The aggregate function that will receive a unique value from each upstream and return the value to signal downstream

Returns:

a Flux based on the produced combinations , 3.0

combineLatest

@SafeVarargs
public static <T,V> Flux<V> combineLatest(java.util.function.Function<java.lang.Object[],V> combinator,
                                                       int prefetch,
                                                       org.reactivestreams.Publisher<? extends T>... sources)

Build a Flux whose data are generated by the combination of the most recent published values from all publishers.

Type Parameters:

T - type of the value from sources

V - The produced output after transformation by the given combinator

Parameters:

sources - The upstreams Publisher to subscribe to.

prefetch - demand produced to each combined source Publisher

combinator - The aggregate function that will receive a unique value from each upstream and return the value to signal downstream

Returns:

a Flux based on the produced combinations , 3.0

combineLatest

public static <T1,T2,V> Flux<V> combineLatest(org.reactivestreams.Publisher<? extends T1> source1,
                                              org.reactivestreams.Publisher<? extends T2> source2,
                                              java.util.function.BiFunction<? super T1,? super T2,? extends V> combinator)

Build a Flux whose data are generated by the combination of the most recent published values from all publishers.

Type Parameters:

T1 - type of the value from source1

T2 - type of the value from source2

V - The produced output after transformation by the given combinator

Parameters:

source1 - The first upstream Publisher to subscribe to.

source2 - The second upstream Publisher to subscribe to.

combinator - The aggregate function that will receive a unique value from each upstream and return the value to signal downstream

Returns:

a Flux based on the produced value

combineLatest

public static <T1,T2,T3,V> Flux<V> combineLatest(org.reactivestreams.Publisher<? extends T1> source1,
                                                 org.reactivestreams.Publisher<? extends T2> source2,
                                                 org.reactivestreams.Publisher<? extends T3> source3,
                                                 java.util.function.Function<java.lang.Object[],V> combinator)

Build a Flux whose data are generated by the combination of the most recent published values from all publishers.

Type Parameters:

T1 - type of the value from source1

T2 - type of the value from source2

T3 - type of the value from source3

V - The produced output after transformation by the given combinator

Parameters:

source1 - The first upstream Publisher to subscribe to.

source2 - The second upstream Publisher to subscribe to.

source3 - The third upstream Publisher to subscribe to.

combinator - The aggregate function that will receive a unique value from each upstream and return the value to signal downstream

Returns:

a Flux based on the produced value

combineLatest

public static <T1,T2,T3,T4,V> Flux<V> combineLatest(org.reactivestreams.Publisher<? extends T1> source1,
                                                    org.reactivestreams.Publisher<? extends T2> source2,
                                                    org.reactivestreams.Publisher<? extends T3> source3,
                                                    org.reactivestreams.Publisher<? extends T4> source4,
                                                    java.util.function.Function<java.lang.Object[],V> combinator)

Build a Flux whose data are generated by the combination of the most recent published values from all publishers.

Type Parameters:

T1 - type of the value from source1

T2 - type of the value from source2

T3 - type of the value from source3

T4 - type of the value from source4

V - The produced output after transformation by the given combinator

Parameters:

source1 - The first upstream Publisher to subscribe to.

source2 - The second upstream Publisher to subscribe to.

source3 - The third upstream Publisher to subscribe to.

source4 - The fourth upstream Publisher to subscribe to.

combinator - The aggregate function that will receive a unique value from each upstream and return the value to signal downstream

Returns:

a Flux based on the produced value

combineLatest

public static <T1,T2,T3,T4,T5,V> Flux<V> combineLatest(org.reactivestreams.Publisher<? extends T1> source1,
                                                       org.reactivestreams.Publisher<? extends T2> source2,
                                                       org.reactivestreams.Publisher<? extends T3> source3,
                                                       org.reactivestreams.Publisher<? extends T4> source4,
                                                       org.reactivestreams.Publisher<? extends T5> source5,
                                                       java.util.function.Function<java.lang.Object[],V> combinator)

Build a Flux whose data are generated by the combination of the most recent published values from all publishers.

Type Parameters:

T1 - type of the value from source1

T2 - type of the value from source2

T3 - type of the value from source3

T4 - type of the value from source4

T5 - type of the value from source5

V - The produced output after transformation by the given combinator

Parameters:

source1 - The first upstream Publisher to subscribe to.

source2 - The second upstream Publisher to subscribe to.

source3 - The third upstream Publisher to subscribe to.

source4 - The fourth upstream Publisher to subscribe to.

source5 - The fifth upstream Publisher to subscribe to.

combinator - The aggregate function that will receive a unique value from each upstream and return the value to signal downstream

Returns:

a Flux based on the produced value

combineLatest

public static <T1,T2,T3,T4,T5,T6,V> Flux<V> combineLatest(org.reactivestreams.Publisher<? extends T1> source1,
                                                          org.reactivestreams.Publisher<? extends T2> source2,
                                                          org.reactivestreams.Publisher<? extends T3> source3,
                                                          org.reactivestreams.Publisher<? extends T4> source4,
                                                          org.reactivestreams.Publisher<? extends T5> source5,
                                                          org.reactivestreams.Publisher<? extends T6> source6,
                                                          java.util.function.Function<java.lang.Object[],V> combinator)

Build a Flux whose data are generated by the combination of the most recent published values from all publishers.

Type Parameters:

T1 - type of the value from source1

T2 - type of the value from source2

T3 - type of the value from source3

T4 - type of the value from source4

T5 - type of the value from source5

T6 - type of the value from source6

V - The produced output after transformation by the given combinator

Parameters:

source1 - The first upstream Publisher to subscribe to.

source2 - The second upstream Publisher to subscribe to.

source3 - The third upstream Publisher to subscribe to.

source4 - The fourth upstream Publisher to subscribe to.

source5 - The fifth upstream Publisher to subscribe to.

source6 - The sixth upstream Publisher to subscribe to.

combinator - The aggregate function that will receive a unique value from each upstream and return the value to signal downstream

Returns:

a Flux based on the produced value

combineLatest

public static <T,V> Flux<V> combineLatest(java.lang.Iterable<? extends org.reactivestreams.Publisher<? extends T>> sources,
                                          java.util.function.Function<java.lang.Object[],V> combinator)

Build a Flux whose data are generated by the combination of the most recent published values from all publishers.

Type Parameters:

T - The common base type of the source sequences

V - The produced output after transformation by the given combinator

Parameters:

sources - The list of upstream Publisher to subscribe to.

combinator - The aggregate function that will receive a unique value from each upstream and return the value to signal downstream

Returns:

a Flux based on the produced value , 3.0

combineLatest

public static <T,V> Flux<V> combineLatest(java.lang.Iterable<? extends org.reactivestreams.Publisher<? extends T>> sources,
                                          int prefetch,
                                          java.util.function.Function<java.lang.Object[],V> combinator)

Build a Flux whose data are generated by the combination of the most recent published values from all publishers.

Type Parameters:

T - The common base type of the source sequences

V - The produced output after transformation by the given combinator

Parameters:

sources - The list of upstream Publisher to subscribe to.

prefetch - demand produced to each combined source Publisher

combinator - The aggregate function that will receive a unique value from each upstream and return the value to signal downstream

Returns:

a Flux based on the produced value , 3.0

concat

public static <T> Flux<T> concat(java.lang.Iterable<? extends org.reactivestreams.Publisher<? extends T>> sources)

Concat all sources pulled from the supplied Iterator on Publisher.subscribe(org.reactivestreams.Subscriber<? super T>) from the passed Iterable until Iterator.hasNext() returns false. A complete signal from each source will delimit the individual sequences and will be eventually passed to the returned Publisher.

Type Parameters:

T - The source type of the data sequence

Parameters:

sources - The Publisher of Publisher to concat

Returns:

a new Flux concatenating all source sequences

concat

public static <T> Flux<T> concat(org.reactivestreams.Publisher<? extends org.reactivestreams.Publisher<? extends T>> sources)

Concat all sources emitted as an onNext signal from a parent Publisher. A complete signal from each source will delimit the individual sequences and will be eventually passed to the returned Publisher which will stop listening if the main sequence has also completed.

Type Parameters:

T - The source type of the data sequence

Parameters:

sources - The Publisher of Publisher to concat

Returns:

a new Flux concatenating all inner sources sequences until complete or error

concat

public static <T> Flux<T> concat(org.reactivestreams.Publisher<? extends org.reactivestreams.Publisher<? extends T>> sources,
                                 int prefetch)

Concat all sources emitted as an onNext signal from a parent Publisher. A complete signal from each source will delimit the individual sequences and will be eventually passed to the returned Publisher which will stop listening if the main sequence has also completed.

Type Parameters:

T - The source type of the data sequence

Parameters:

sources - The Publisher of Publisher to concat

prefetch - the inner source request size

Returns:

a new Flux concatenating all inner sources sequences until complete or error

concat

@SafeVarargs
public static <T> Flux<T> concat(org.reactivestreams.Publisher<? extends T>... sources)

Concat all sources pulled from the given Publisher array. A complete signal from each source will delimit the individual sequences and will be eventually passed to the returned Publisher.

Type Parameters:

T - The source type of the data sequence

Parameters:

sources - The Publisher of Publisher to concat

Returns:

a new Flux concatenating all source sequences

create

public static <T> Flux<T> create(java.util.function.Consumer<? super FluxSink<T>> emitter)

Creates a Flux with multi-emission capabilities (synchronous or asynchronous) through the FluxSink API.

This Flux factory is useful if one wants to adapt some other a multi-valued async API and not worry about cancellation and backpressure. For example:

Handles backpressure by buffering all signals if the downstream can't keep up.

 Flux.<String>create(emitter -> {

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

     button.addActionListener(al);

     // with cancellation support:

     button.addActionListener(al);
     emitter.setCancellation(() -> {
         button.removeListener(al);
     });
 });
 

Type Parameters:

T - the value type

Parameters:

emitter - the consumer that will receive a FluxSink for each individual Subscriber.

Returns:

a Flux

create

public static <T> Flux<T> create(java.util.function.Consumer<? super FluxSink<T>> emitter,
                                 FluxSink.OverflowStrategy backpressure)

Creates a Flux with multi-emission capabilities (synchronous or asynchronous) through the FluxSink API.

This Flux factory is useful if one wants to adapt some other a multi-valued async API and not worry about cancellation and backpressure. For example:

 Flux.<String>create(emitter -> {

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

     button.addActionListener(al);

     // with cancellation support:

     button.addActionListener(al);
     emitter.setCancellation(() -> {
         button.removeListener(al);
     });
 }, FluxSink.OverflowStrategy.LATEST);
 

Type Parameters:

T - the value type

Parameters:

backpressure - the backpressure mode, see FluxSink.OverflowStrategy for the avilable backpressure modes

emitter - the consumer that will receive a FluxSink for each individual Subscriber.

Returns:

a Flux

defer

public static <T> Flux<T> defer(java.util.function.Supplier<? extends org.reactivestreams.Publisher<T>> supplier)

Supply a Publisher everytime subscribe is called on the returned flux. The passed Supplier will be invoked and it's up to the developer to choose to return a new instance of a Publisher or reuse one effecitvely behaving like from(Publisher).

Type Parameters:

T - the type of values passing through the Flux

Parameters:

supplier - the Publisher Supplier to call on subscribe

Returns:

a deferred Flux

empty

public static <T> Flux<T> empty()

Create a Flux that completes without emitting any item.

Type Parameters:

T - the reified type of the target Subscriber

Returns:

an empty Flux

error

public static <T> Flux<T> error(java.lang.Throwable error)

Create a Flux that completes with the specified error.

Type Parameters:

T - the reified type of the target Subscriber

Parameters:

error - the error to signal to each Subscriber

Returns:

a new failed Flux

error

public static <O> Flux<O> error(java.lang.Throwable throwable,
                                boolean whenRequested)

Build a Flux that will only emit an error signal to any new subscriber.

Type Parameters:

O - the output type

Parameters:

throwable - the error to signal to each Subscriber

whenRequested - if true, will onError on the first request instead of subscribe().

Returns:

a new failed Flux

firstEmitting

@SafeVarargs
public static <I> Flux<I> firstEmitting(org.reactivestreams.Publisher<? extends I>... sources)

Select the fastest source who emitted first onNext or onComplete or onError

Type Parameters:

I - The source type of the data sequence

Parameters:

sources - The competing source publishers

Returns:

a new Flux eventually subscribed to one of the sources or empty

firstEmitting

public static <I> Flux<I> firstEmitting(java.lang.Iterable<? extends org.reactivestreams.Publisher<? extends I>> sources)

Select the fastest source who won the "ambiguous" race and emitted first onNext or onComplete or onError

Type Parameters:

I - The source type of the data sequence

Parameters:

sources - The competing source publishers

Returns:

a new Flux eventually subscribed to one of the sources or empty

from

public static <T> Flux<T> from(org.reactivestreams.Publisher<? extends T> source)

Expose the specified Publisher with the Flux API.

Type Parameters:

T - the source sequence type

Parameters:

source - the source to decorate

Returns:

a new Flux

fromArray

public static <T> Flux<T> fromArray(T[] array)

Create a Flux that emits the items contained in the provided Iterable.

Type Parameters:

T - the Publisher type to stream

Parameters:

array - the array to read data from

Returns:

a new Flux

fromIterable

public static <T> Flux<T> fromIterable(java.lang.Iterable<? extends T> it)

Create a Flux that emits the items contained in the provided Iterable. A new iterator will be created for each subscriber.

Type Parameters:

T - the Iterable type to stream

Parameters:

it - the Iterable to read data from

Returns:

a new Flux

fromStream

public static <T> Flux<T> fromStream(java.util.stream.Stream<? extends T> s)

Create a Flux that emits the items contained in the provided Stream. A new iterator will be created for each subscriber.

Type Parameters:

T - the Stream type to flux

Parameters:

s - the Stream to read data from

Returns:

a new Flux

generate

public static <T,S> Flux<T> generate(java.util.function.BiFunction<S,SynchronousSink<T>,S> generator)

Generate signals one-by-one via a function callback.

Type Parameters:

T - the value type emitted

S - the custom state per subscriber

Parameters:

generator - the bifunction called with the current state, the SynchronousSink API instance and is expected to return a (new) state.

Returns:

a Reactive Flux publisher ready to be subscribed

generate

public static <T,S> Flux<T> generate(java.util.concurrent.Callable<S> stateSupplier,
                                     java.util.function.BiFunction<S,SynchronousSink<T>,S> generator)

Generate signals one-by-one via a function callback. The stateSupplier may return null.

Type Parameters:

T - the value type emitted

S - the custom state per subscriber

Parameters:

stateSupplier - called for each incoming Supplier to provide the initial state for the generator bifunction

generator - the bifunction called with the current state, the SynchronousSink API instance and is expected to return a (new) state.

Returns:

a Reactive Flux publisher ready to be subscribed

generate

public static <T,S> Flux<T> generate(java.util.concurrent.Callable<S> stateSupplier,
                                     java.util.function.BiFunction<S,SynchronousSink<T>,S> generator,
                                     java.util.function.Consumer<? super S> stateConsumer)

Generate signals one-by-one via a function callback. The stateSupplier may return null but your stateConsumer should be prepared to handle it.

Type Parameters:

T - the value type emitted

S - the custom state per subscriber

Parameters:

stateSupplier - called for each incoming Supplier to provide the initial state for the generator bifunction

generator - the bifunction called with the current state, the SynchronousSink API instance and is expected to return a (new) state.

stateConsumer - called after the generator has terminated or the downstream cancelled, receiving the last state to be handled (i.e., release resources or do other cleanup).

Returns:

a Reactive Flux publisher ready to be subscribed

interval

public static Flux<java.lang.Long> interval(java.time.Duration period)

Create a new Flux that emits an ever incrementing long starting with 0 every period on the global timer. If demand is not produced in time, an onError will be signalled. The Flux will never complete.

Parameters:

period - The duration to wait before the next increment

Returns:

a new timed Flux

interval

public static Flux<java.lang.Long> interval(java.time.Duration delay,
                                            java.time.Duration period)

Create a new Flux that emits an ever incrementing long starting with 0 every N period of time unit on a global timer. If demand is not produced in time, an onError will be signalled. The Flux will never complete.

Parameters:

delay - the delay to wait before emitting 0l

period - the period before each following increment

Returns:

a new timed Flux

intervalMillis

public static Flux<java.lang.Long> intervalMillis(long period)

Create a new Flux that emits an ever incrementing long starting with 0 every N milliseconds on the given timer. If demand is not produced in time, an onError will be signalled. The Flux will never complete.

Parameters:

period - The number of milliseconds to wait before the next increment

Returns:

a new timed Flux

intervalMillis

public static Flux<java.lang.Long> intervalMillis(long period,
                                                  TimedScheduler timer)

Create a new Flux that emits an ever incrementing long starting with 0 every N milliseconds on the given timer. If demand is not produced in time, an onError will be signalled. The Flux will never complete.

Parameters:

period - The duration in milliseconds to wait before the next increment

timer - a TimedScheduler instance

Returns:

a new timed Flux

intervalMillis

public static Flux<java.lang.Long> intervalMillis(long delay,
                                                  long period)

Create a new Flux that emits an ever incrementing long starting with 0 every N period of time unit on a global timer. If demand is not produced in time, an onError will be signalled. The Flux will never complete.

Parameters:

delay - the delay in milliseconds to wait before emitting 0l

period - the period in milliseconds before each following increment

Returns:

a new timed Flux

intervalMillis

public static Flux<java.lang.Long> intervalMillis(long delay,
                                                  long period,
                                                  TimedScheduler timer)

Create a new Flux that emits an ever incrementing long starting with 0 every N period of time unit on the given timer. If demand is not produced in time, an onError will be signalled. The Flux will never complete.

Parameters:

delay - the timespan in milliseconds to wait before emitting 0l

period - the period in milliseconds before each following increment

timer - the TimedScheduler to schedule on

Returns:

a new timed Flux

just

@SafeVarargs
public static <T> Flux<T> just(T... data)

Create a new Flux that emits the specified items and then complete.

Type Parameters:

T - the emitted data type

Parameters:

data - the consecutive data objects to emit

Returns:

a new Flux

just

public static <T> Flux<T> just(T data)

Create a new Flux that will only emit the passed data then onComplete.

Type Parameters:

T - the emitted data type

Parameters:

data - the unique data to emit

Returns:

a new Flux

merge

public static <T> Flux<T> merge(org.reactivestreams.Publisher<? extends org.reactivestreams.Publisher<? extends T>> source)

Merge emitted Publisher sequences by the passed Publisher into an interleaved merged sequence.

Type Parameters:

T - the merged type

Parameters:

source - a Publisher of Publisher sequence to merge

Returns:

a merged Flux

merge

public static <T> Flux<T> merge(org.reactivestreams.Publisher<? extends org.reactivestreams.Publisher<? extends T>> source,
                                int concurrency)

Merge emitted Publisher sequences by the passed Publisher into an interleaved merged sequence.

Type Parameters:

T - the merged type

Parameters:

source - a Publisher of Publisher sequence to merge

concurrency - the request produced to the main source thus limiting concurrent merge backlog

Returns:

a merged Flux

merge

public static <T> Flux<T> merge(org.reactivestreams.Publisher<? extends org.reactivestreams.Publisher<? extends T>> source,
                                int concurrency,
                                int prefetch)

Merge emitted Publisher sequences by the passed Publisher into an interleaved merged sequence.

Type Parameters:

T - the merged type

Parameters:

source - a Publisher of Publisher sequence to merge

concurrency - the request produced to the main source thus limiting concurrent merge backlog

prefetch - the inner source request size

Returns:

a merged Flux

merge

public static <I> Flux<I> merge(java.lang.Iterable<? extends org.reactivestreams.Publisher<? extends I>> sources)

Merge emitted Publisher sequences from the passed Iterable into an interleaved merged sequence. Iterable.iterator() will be called for each Publisher.subscribe(org.reactivestreams.Subscriber<? super T>).

Type Parameters:

I - The source type of the data sequence

Parameters:

sources - the Iterable to lazily iterate on Publisher.subscribe(Subscriber)

Returns:

a fresh Reactive Flux publisher ready to be subscribed

merge

@SafeVarargs
public static <I> Flux<I> merge(org.reactivestreams.Publisher<? extends I>... sources)

Merge emitted Publisher sequences from the passed Publisher array into an interleaved merged sequence.

Type Parameters:

I - The source type of the data sequence

Parameters:

sources - the Publisher array to iterate on Publisher.subscribe(Subscriber)

Returns:

a fresh Reactive Flux publisher ready to be subscribed

merge

@SafeVarargs
public static <I> Flux<I> merge(int prefetch,
                                             org.reactivestreams.Publisher<? extends I>... sources)

Merge emitted Publisher sequences from the passed Publisher array into an interleaved merged sequence.

Type Parameters:

I - The source type of the data sequence

Parameters:

sources - the Publisher array to iterate on Publisher.subscribe(Subscriber)

prefetch - the inner source request size

Returns:

a fresh Reactive Flux publisher ready to be subscribed

never

public static <T> Flux<T> never()

Create a Flux that will never signal any data, error or completion signal.

Type Parameters:

T - the Subscriber type target

Returns:

a never completing Flux

range

public static Flux<java.lang.Integer> range(int start,
                                            int count)

Build a Flux that will only emit a sequence of incrementing integer from start to start + count then complete.

Parameters:

start - the first integer to be emit

count - the number ot times to emit an increment including the first value

Returns:

a ranged Flux

switchOnNext

public static <T> Flux<T> switchOnNext(org.reactivestreams.Publisher<? extends org.reactivestreams.Publisher<? extends T>> mergedPublishers)

Build a FluxProcessor whose data are emitted by the most recent emitted Publisher. The Flux will complete once both the publishers source and the last switched to Publisher have completed.

Type Parameters:

T - the produced type

Parameters:

mergedPublishers - The Publisher of switching Publisher to subscribe to.

Returns:

a FluxProcessor accepting publishers and producing T

switchOnNext

public static <T> Flux<T> switchOnNext(org.reactivestreams.Publisher<? extends org.reactivestreams.Publisher<? extends T>> mergedPublishers,
                                       int prefetch)

Build a FluxProcessor whose data are emitted by the most recent emitted Publisher. The Flux will complete once both the publishers source and the last switched to Publisher have completed.

Type Parameters:

T - the produced type

Parameters:

mergedPublishers - The Publisher of switching Publisher to subscribe to.

prefetch - the inner source request size

Returns:

a FluxProcessor accepting publishers and producing T

using

public static <T,D> Flux<T> using(java.util.concurrent.Callable<? extends D> resourceSupplier,
                                  java.util.function.Function<? super D,? extends org.reactivestreams.Publisher<? extends T>> sourceSupplier,
                                  java.util.function.Consumer<? super D> resourceCleanup)

Uses a resource, generated by a supplier for each individual Subscriber, while streaming the values from a Publisher derived from the same resource and makes sure the resource is released if the sequence terminates or the Subscriber cancels.

Eager resource cleanup happens just before the source termination and exceptions raised by the cleanup Consumer may override the terminal even.

Type Parameters:

T - emitted type

D - resource type

Parameters:

resourceSupplier - a Callable that is called on subscribe

sourceSupplier - a Publisher factory derived from the supplied resource

resourceCleanup - invoked on completion

Returns:

new Flux

using

public static <T,D> Flux<T> using(java.util.concurrent.Callable<? extends D> resourceSupplier,
                                  java.util.function.Function<? super D,? extends org.reactivestreams.Publisher<? extends T>> sourceSupplier,
                                  java.util.function.Consumer<? super D> resourceCleanup,
                                  boolean eager)

Uses a resource, generated by a supplier for each individual Subscriber, while streaming the values from a Publisher derived from the same resource and makes sure the resource is released if the sequence terminates or the Subscriber cancels.

• Eager resource cleanup happens just before the source termination and exceptions raised by the cleanup Consumer may override the terminal even.
• Non-eager cleanup will drop any exception.

Type Parameters:

T - emitted type

D - resource type

Parameters:

resourceSupplier - a Callable that is called on subscribe

sourceSupplier - a Publisher factory derived from the supplied resource

resourceCleanup - invoked on completion

eager - true to clean before terminating downstream subscribers

Returns:

new Stream

zip

public static <T1,T2,O> Flux<O> zip(org.reactivestreams.Publisher<? extends T1> source1,
                                    org.reactivestreams.Publisher<? extends T2> source2,
                                    java.util.function.BiFunction<? super T1,? super T2,? extends O> combinator)

"Step-Merge" especially useful in Scatter-Gather scenarios. The operator will forward all combinations produced by the passed combinator function of the most recent items emitted by each source until any of them completes. Errors will immediately be forwarded.

Type Parameters:

T1 - type of the value from source1

T2 - type of the value from source2

O - The produced output after transformation by the combinator

Parameters:

source1 - The first upstream Publisher to subscribe to.

source2 - The second upstream Publisher to subscribe to.

combinator - The aggregate function that will receive a unique value from each upstream and return the value to signal downstream

Returns:

a zipped Flux

zip

public static <T1,T2> Flux<Tuple2<T1,T2>> zip(org.reactivestreams.Publisher<? extends T1> source1,
                                              org.reactivestreams.Publisher<? extends T2> source2)

"Step-Merge" especially useful in Scatter-Gather scenarios. The operator will forward all combinations of the most recent items emitted by each source until any of them completes. Errors will immediately be forwarded.

Type Parameters:

T1 - type of the value from source1

T2 - type of the value from source2

Parameters:

source1 - The first upstream Publisher to subscribe to.

source2 - The second upstream Publisher to subscribe to.

Returns:

a zipped Flux

zip

public static <T1,T2,T3> Flux<Tuple3<T1,T2,T3>> zip(org.reactivestreams.Publisher<? extends T1> source1,
                                                    org.reactivestreams.Publisher<? extends T2> source2,
                                                    org.reactivestreams.Publisher<? extends T3> source3)

"Step-Merge" especially useful in Scatter-Gather scenarios. The operator will forward all combinations of the most recent items emitted by each source until any of them completes. Errors will immediately be forwarded.

Type Parameters:

T1 - type of the value from source1

T2 - type of the value from source2

T3 - type of the value from source3

Parameters:

source1 - The first upstream Publisher to subscribe to.

source2 - The second upstream Publisher to subscribe to.

source3 - The third upstream Publisher to subscribe to.

Returns:

a zipped Flux

zip

public static <T1,T2,T3,T4> Flux<Tuple4<T1,T2,T3,T4>> zip(org.reactivestreams.Publisher<? extends T1> source1,
                                                          org.reactivestreams.Publisher<? extends T2> source2,
                                                          org.reactivestreams.Publisher<? extends T3> source3,
                                                          org.reactivestreams.Publisher<? extends T4> source4)

"Step-Merge" especially useful in Scatter-Gather scenarios. The operator will forward all combinations of the most recent items emitted by each source until any of them completes. Errors will immediately be forwarded.

Type Parameters:

T1 - type of the value from source1

T2 - type of the value from source2

T3 - type of the value from source3

T4 - type of the value from source4

Parameters:

source1 - The first upstream Publisher to subscribe to.

source2 - The second upstream Publisher to subscribe to.

source3 - The third upstream Publisher to subscribe to.

source4 - The fourth upstream Publisher to subscribe to.

Returns:

a zipped Flux

zip

public static <T1,T2,T3,T4,T5> Flux<Tuple5<T1,T2,T3,T4,T5>> zip(org.reactivestreams.Publisher<? extends T1> source1,
                                                                org.reactivestreams.Publisher<? extends T2> source2,
                                                                org.reactivestreams.Publisher<? extends T3> source3,
                                                                org.reactivestreams.Publisher<? extends T4> source4,
                                                                org.reactivestreams.Publisher<? extends T5> source5)

"Step-Merge" especially useful in Scatter-Gather scenarios. The operator will forward all combinations of the most recent items emitted by each source until any of them completes. Errors will immediately be forwarded.

Type Parameters:

T1 - type of the value from source1

T2 - type of the value from source2

T3 - type of the value from source3

T4 - type of the value from source4

T5 - type of the value from source5

Parameters:

source1 - The first upstream Publisher to subscribe to.

source2 - The second upstream Publisher to subscribe to.

source3 - The third upstream Publisher to subscribe to.

source4 - The fourth upstream Publisher to subscribe to.

source5 - The fifth upstream Publisher to subscribe to.

Returns:

a zipped Flux

zip

public static <T1,T2,T3,T4,T5,T6> Flux<Tuple6<T1,T2,T3,T4,T5,T6>> zip(org.reactivestreams.Publisher<? extends T1> source1,
                                                                      org.reactivestreams.Publisher<? extends T2> source2,
                                                                      org.reactivestreams.Publisher<? extends T3> source3,
                                                                      org.reactivestreams.Publisher<? extends T4> source4,
                                                                      org.reactivestreams.Publisher<? extends T5> source5,
                                                                      org.reactivestreams.Publisher<? extends T6> source6)

"Step-Merge" especially useful in Scatter-Gather scenarios. The operator will forward all combinations of the most recent items emitted by each source until any of them completes. Errors will immediately be forwarded.

Type Parameters:

T1 - type of the value from source1

T2 - type of the value from source2

T3 - type of the value from source3

T4 - type of the value from source4

T5 - type of the value from source5

T6 - type of the value from source6

Parameters:

source1 - The first upstream Publisher to subscribe to.

source2 - The second upstream Publisher to subscribe to.

source3 - The third upstream Publisher to subscribe to.

source4 - The fourth upstream Publisher to subscribe to.

source5 - The fifth upstream Publisher to subscribe to.

source6 - The sixth upstream Publisher to subscribe to.

Returns:

a zipped Flux

zip

public static Flux<Tuples> zip(java.lang.Iterable<? extends org.reactivestreams.Publisher<?>> sources)

"Step-Merge" especially useful in Scatter-Gather scenarios. The operator will forward all combinations of the most recent items emitted by each source until any of them completes. Errors will immediately be forwarded. The Iterable.iterator() will be called on each Publisher.subscribe(Subscriber).

Parameters:

sources - the Iterable to iterate on Publisher.subscribe(Subscriber)

Returns:

a zipped Flux

zip

public static <O> Flux<O> zip(java.lang.Iterable<? extends org.reactivestreams.Publisher<?>> sources,
                              java.util.function.Function<? super java.lang.Object[],? extends O> combinator)

"Step-Merge" especially useful in Scatter-Gather scenarios. The operator will forward all combinations produced by the passed combinator function of the most recent items emitted by each source until any of them completes. Errors will immediately be forwarded. The Iterable.iterator() will be called on each Publisher.subscribe(Subscriber).

Type Parameters:

O - the combined produced type

Parameters:

sources - the Iterable to iterate on Publisher.subscribe(Subscriber)

combinator - The aggregate function that will receive a unique value from each upstream and return the value to signal downstream

Returns:

a zipped Flux

zip

public static <O> Flux<O> zip(java.lang.Iterable<? extends org.reactivestreams.Publisher<?>> sources,
                              int prefetch,
                              java.util.function.Function<? super java.lang.Object[],? extends O> combinator)

"Step-Merge" especially useful in Scatter-Gather scenarios. The operator will forward all combinations produced by the passed combinator function of the most recent items emitted by each source until any of them completes. Errors will immediately be forwarded. The Iterable.iterator() will be called on each Publisher.subscribe(Subscriber).

Type Parameters:

O - the combined produced type

Parameters:

sources - the Iterable to iterate on Publisher.subscribe(Subscriber)

prefetch - the inner source request size

combinator - The aggregate function that will receive a unique value from each upstream and return the value to signal downstream

Returns:

a zipped Flux

zip

@SafeVarargs
public static <I,O> Flux<O> zip(java.util.function.Function<? super java.lang.Object[],? extends O> combinator,
                                             org.reactivestreams.Publisher<? extends I>... sources)

"Step-Merge" especially useful in Scatter-Gather scenarios. The operator will forward all combinations produced by the passed combinator function of the most recent items emitted by each source until any of them completes. Errors will immediately be forwarded.

Type Parameters:

I - the type of the input sources

O - the combined produced type

Parameters:

combinator - The aggregate function that will receive a unique value from each upstream and return the value to signal downstream

sources - the Publisher array to iterate on Publisher.subscribe(Subscriber)

Returns:

a zipped Flux

zip

@SafeVarargs
public static <I,O> Flux<O> zip(java.util.function.Function<? super java.lang.Object[],? extends O> combinator,
                                             int prefetch,
                                             org.reactivestreams.Publisher<? extends I>... sources)

"Step-Merge" especially useful in Scatter-Gather scenarios. The operator will forward all combinations produced by the passed combinator function of the most recent items emitted by each source until any of them completes. Errors will immediately be forwarded.

Type Parameters:

I - the type of the input sources

O - the combined produced type

Parameters:

combinator - The aggregate function that will receive a unique value from each upstream and return the value to signal downstream

prefetch - individual source request size

sources - the Publisher array to iterate on Publisher.subscribe(Subscriber)

Returns:

a zipped Flux

zip

public static <TUPLE extends Tuples,V> Flux<V> zip(org.reactivestreams.Publisher<? extends org.reactivestreams.Publisher<?>> sources,
                                                   java.util.function.Function<? super TUPLE,? extends V> combinator)

"Step-Merge" especially useful in Scatter-Gather scenarios. The Publisher of Publisher will accumulate into a list until completion before starting zip operation. The operator will forward all combinations of the most recent items emitted by each published source until any of them completes. Errors will immediately be forwarded.

Type Parameters:

TUPLE - the raw tuple type

V - The produced output after transformation by the given combinator

Parameters:

sources - The publisher of upstream Publisher to subscribe to.

combinator - The aggregate function that will receive a unique value from each upstream and return the value to signal downstream

Returns:

a Flux based on the produced value

all

public final Mono<java.lang.Boolean> all(java.util.function.Predicate<? super T> predicate)

Emit a single boolean true if all values of this sequence match the Predicate.

The implementation uses short-circuit logic and completes with false if the predicate doesn't match a value.

Parameters:

predicate - the Predicate to match all emitted items

Returns:

a Mono of all evaluations

any

public final Mono<java.lang.Boolean> any(java.util.function.Predicate<? super T> predicate)

Emit a single boolean true if any of the values of this Flux sequence match the predicate.

The implementation uses short-circuit logic and completes with true if the predicate matches a value.

Parameters:

predicate - predicate tested upon values

Returns:

a new Flux with true if any value satisfies a predicate and false otherwise

as

public final <P> P as(java.util.function.Function<? super Flux<T>,P> transformer)

Immediately apply the given transformation to this Flux in order to generate a target type. flux.as(Mono::from).subscribe(Subscribers.unbounded())

Type Parameters:

P - the returned type

Parameters:

transformer - the Function to immediately map this Flux into a target type instance.

Returns:

a an instance of P

See Also:

for a bounded conversion to {@link Publisher}

buffer

public final Flux<java.util.List<T>> buffer()

Collect incoming values into a List that will be pushed into the returned Mono on complete only.

Returns:

a buffered Mono of at most one List

buffer

public final Flux<java.util.List<T>> buffer(int maxSize)

Collect incoming values into multiple List buckets that will be pushed into the returned Flux when the given max size is reached or onComplete is received.

Parameters:

maxSize - the maximum collected size

Returns:

a microbatched Flux of List

buffer

public final Flux<java.util.List<T>> buffer(int maxSize,
                                            int skip)

Collect incoming values into multiple List that will be pushed into the returned Flux when the given max size is reached or onComplete is received. A new container List will be created every given skip count.

When Skip > Max Size : dropping buffers

When Skip < Max Size : overlapping buffers

When Skip == Max Size : exact buffers

Parameters:

skip - the number of items to skip before creating a new bucket

maxSize - the max collected size

Returns:

a microbatched Flux of possibly overlapped or gapped List

buffer

public final Flux<java.util.List<T>> buffer(org.reactivestreams.Publisher<?> other)

Collect incoming values into multiple List delimited by the given Publisher signals.

Parameters:

other - the other Publisher to subscribe to for emiting and recycling receiving bucket

Returns:

a microbatched Flux of List delimited by a Publisher

buffer

public final <U,V> Flux<java.util.List<T>> buffer(org.reactivestreams.Publisher<U> bucketOpening,
                                                  java.util.function.Function<? super U,? extends org.reactivestreams.Publisher<V>> closeSelector)

Collect incoming values into multiple List delimited by the given Publisher signals. Each List bucket will last until the mapped Publisher receiving the boundary signal emits, thus releasing the bucket to the returned Flux.

When Open signal is strictly not overlapping Close signal : dropping buffers

When Open signal is strictly more frequent than Close signal : overlapping buffers

When Open signal is exactly coordinated with Close signal : exact buffers

Type Parameters:

U - the element type of the bucket-opening sequence

V - the element type of the bucket-closing sequence

Parameters:

bucketOpening - a Publisher to subscribe to for creating new receiving bucket signals.

closeSelector - a Publisher factory provided the opening signal and returning a Publisher to subscribe to for emitting relative bucket.

Returns:

a microbatched Flux of List delimited by an opening Publisher and a relative closing Publisher

buffer

public final Flux<java.util.List<T>> buffer(java.time.Duration timespan)

Collect incoming values into multiple List that will be pushed into the returned Flux every timespan.

Parameters:

timespan - the duration to use to release a buffered list

Returns:

a microbatched Flux of List delimited by the given period

buffer

public final Flux<java.util.List<T>> buffer(java.time.Duration timespan,
                                            java.time.Duration timeshift)

Collect incoming values into multiple List delimited by the given timeshift period. Each List bucket will last until the timespan has elapsed, thus releasing the bucket to the returned Flux.

When timeshift > timestamp : dropping buffers

When timeshift < timestamp : overlapping buffers

When timeshift == timestamp : exact buffers

Parameters:

timespan - the duration to use to release buffered lists

timeshift - the duration to use to create a new bucket

Returns:

a microbatched Flux of List delimited by the given period timeshift and sized by timespan

buffer

public final Flux<java.util.List<T>> buffer(int maxSize,
                                            java.time.Duration timespan)

Collect incoming values into a List that will be pushed into the returned Flux every timespan OR maxSize items.

Parameters:

maxSize - the max collected size

timespan - the timeout to use to release a buffered list

Returns:

a microbatched Flux of List delimited by given size or a given period timeout

bufferMillis

public final Flux<java.util.List<T>> bufferMillis(long timespan)

Collect incoming values into multiple List that will be pushed into the returned Flux every timespan.

Parameters:

timespan - the duration to use to release a buffered list in milliseconds

Returns:

a microbatched Flux of List delimited by the given period

bufferMillis

public final Flux<java.util.List<T>> bufferMillis(long timespan,
                                                  TimedScheduler timer)

Collect incoming values into multiple List that will be pushed into the returned Flux every timespan.

Parameters:

timespan - theduration to use to release a buffered list in milliseconds

timer - the TimedScheduler to run on

Returns:

a microbatched Flux of List delimited by the given period

bufferMillis

public final Flux<java.util.List<T>> bufferMillis(long timespan,
                                                  long timeshift)

Collect incoming values into multiple List delimited by the given timeshift period. Each List bucket will last until the timespan has elapsed, thus releasing the bucket to the returned Flux.

When timeshift > timestamp : dropping buffers

When timeshift < timestamp : overlapping buffers

When timeshift == timestamp : exact buffers

Parameters:

timespan - the duration to use to release buffered lists

timeshift - the duration to use to create a new bucket

Returns:

a microbatched Flux of List delimited by the given period timeshift and sized by timespan

bufferMillis

public final Flux<java.util.List<T>> bufferMillis(long timespan,
                                                  long timeshift,
                                                  TimedScheduler timer)

Collect incoming values into multiple List delimited by the given timeshift period. Each List bucket will last until the timespan has elapsed, thus releasing the bucket to the returned Flux.

When timeshift > timestamp : dropping buffers

When timeshift < timestamp : overlapping buffers

When timeshift == timestamp : exact buffers

Parameters:

timespan - the duration to use to release buffered lists

timeshift - the duration to use to create a new bucket

timer - the TimedScheduler to run on

Returns:

a microbatched Flux of List delimited by the given period timeshift and sized by timespan

bufferMillis

public final Flux<java.util.List<T>> bufferMillis(int maxSize,
                                                  long timespan)

Collect incoming values into a List that will be pushed into the returned Flux every timespan OR maxSize items.

Parameters:

maxSize - the max collected size

timespan - the timeout in milliseconds to use to release a buffered list

Returns:

a microbatched Flux of List delimited by given size or a given period timeout

bufferMillis

public final Flux<java.util.List<T>> bufferMillis(int maxSize,
                                                  long timespan,
                                                  TimedScheduler timer)

Collect incoming values into a List that will be pushed into the returned Flux every timespan OR maxSize items

Parameters:

maxSize - the max collected size

timespan - the timeout to use to release a buffered list

timer - the TimedScheduler to run on

Returns:

a microbatched Flux of List delimited by given size or a given period timeout

cache

public final Flux<T> cache()

Turn this Flux into a hot source and cache last emitted signals for further Subscriber. Will retain up an unbounded volume of onNext signals. Completion and Error will also be replayed.

Returns:

a replaying Flux

cache

public final Flux<T> cache(int history)

Turn this Flux into a hot source and cache last emitted signals for further Subscriber. Will retain up to the given history size onNext signals. Completion and Error will also be replayed.

Parameters:

history - number of events retained in history excluding complete and error

Returns:

a replaying Flux

cast

public final <E> Flux<E> cast(java.lang.Class<E> stream)

Cast the current Flux produced type into a target produced type.

Type Parameters:

E - the Flux output type

Parameters:

stream - the target class to cast to

Returns:

a casted Flux

collect

public final <E> Mono<E> collect(java.util.function.Supplier<E> containerSupplier,
                                 java.util.function.BiConsumer<E,? super T> collector)

Collect the Flux sequence with the given collector and supplied container on subscribe. The collected result will be emitted when this sequence completes.

Type Parameters:

E - the Flux collected container type

Parameters:

containerSupplier - the supplier of the container instance for each Subscriber

collector - the consumer of both the container instance and the current value

Returns:

a Mono sequence of the collected value on complete

collect

public final <R,A> Mono<R> collect(java.util.stream.Collector<T,A,R> collector)

Collect the Flux sequence with the given collector and supplied container on subscribe. The collected result will be emitted when this sequence completes.

Type Parameters:

A - The mutable accumulation type

R - the Flux collected container type

Parameters:

collector - the Collector

Returns:

a Mono sequence of the collected value on complete

collectList

public final Mono<java.util.List<T>> collectList()

Accumulate this Flux sequence in a List that is emitted to the returned Mono on onComplete.

Returns:

a Mono of all values from this Flux

collectMap

public final <K> Mono<java.util.Map<K,T>> collectMap(java.util.function.Function<? super T,? extends K> keyExtractor)

Convert all this Flux sequence into a hashed map where the key is extracted by the given Function and the value will be the most recent emitted item for this key.

Type Parameters:

K - the key extracted from each value of this Flux instance

Parameters:

keyExtractor - a Function to route items into a keyed Collection

Returns:

a Mono of all last matched key-values from this Flux

collectMap

public final <K,V> Mono<java.util.Map<K,V>> collectMap(java.util.function.Function<? super T,? extends K> keyExtractor,
                                                       java.util.function.Function<? super T,? extends V> valueExtractor)

Convert all this Flux sequence into a hashed map where the key is extracted by the given function and the value will be the most recent extracted item for this key.

Type Parameters:

K - the key extracted from each value of this Flux instance

V - the value extracted from each value of this Flux instance

Parameters:

keyExtractor - a Function to route items into a keyed Collection

valueExtractor - a Function to select the data to store from each item

Returns:

a Mono of all last matched key-values from this Flux

collectMap

public final <K,V> Mono<java.util.Map<K,V>> collectMap(java.util.function.Function<? super T,? extends K> keyExtractor,
                                                       java.util.function.Function<? super T,? extends V> valueExtractor,
                                                       java.util.function.Supplier<java.util.Map<K,V>> mapSupplier)

Convert all this Flux sequence into a supplied map where the key is extracted by the given function and the value will be the most recent extracted item for this key.

Type Parameters:

K - the key extracted from each value of this Flux instance

V - the value extracted from each value of this Flux instance

Parameters:

keyExtractor - a Function to route items into a keyed Collection

valueExtractor - a Function to select the data to store from each item

mapSupplier - a Map factory called for each Subscriber

Returns:

a Mono of all last matched key-values from this Flux

collectMultimap

public final <K> Mono<java.util.Map<K,java.util.Collection<T>>> collectMultimap(java.util.function.Function<? super T,? extends K> keyExtractor)

Convert this Flux sequence into a hashed map where the key is extracted by the given function and the value will be all the emitted item for this key.

Type Parameters:

K - the key extracted from each value of this Flux instance

Parameters:

keyExtractor - a Function to route items into a keyed Collection

Returns:

a Mono of all matched key-values from this Flux

collectMultimap

public final <K,V> Mono<java.util.Map<K,java.util.Collection<V>>> collectMultimap(java.util.function.Function<? super T,? extends K> keyExtractor,
                                                                                  java.util.function.Function<? super T,? extends V> valueExtractor)

Convert this Flux sequence into a hashed map where the key is extracted by the given function and the value will be all the extracted items for this key.

Type Parameters:

K - the key extracted from each value of this Flux instance

V - the value extracted from each value of this Flux instance

Parameters:

keyExtractor - a Function to route items into a keyed Collection

valueExtractor - a Function to select the data to store from each item

Returns:

a Mono of all matched key-values from this Flux

collectMultimap

public final <K,V> Mono<java.util.Map<K,java.util.Collection<V>>> collectMultimap(java.util.function.Function<? super T,? extends K> keyExtractor,
                                                                                  java.util.function.Function<? super T,? extends V> valueExtractor,
                                                                                  java.util.function.Supplier<java.util.Map<K,java.util.Collection<V>>> mapSupplier)

Convert this Flux sequence into a supplied map where the key is extracted by the given function and the value will be all the extracted items for this key.

Type Parameters:

K - the key extracted from each value of this Flux instance

V - the value extracted from each value of this Flux instance

Parameters:

keyExtractor - a Function to route items into a keyed Collection

valueExtractor - a Function to select the data to store from each item

mapSupplier - a Map factory called for each Subscriber

Returns:

a Mono of all matched key-values from this Flux

collectSortedList

public final Mono<java.util.List<T>> collectSortedList()

Accumulate and sort this Flux sequence in a List that is emitted to the returned Mono on onComplete.

Returns:

a Mono of all sorted values from this Flux

collectSortedList

public final Mono<java.util.List<T>> collectSortedList(java.util.Comparator<? super T> comparator)

Accumulate and sort using the given comparator this Flux sequence in a List that is emitted to the returned Mono on onComplete.

Parameters:

comparator - a Comparator to sort the items of this sequences

Returns:

a Mono of all sorted values from this Flux

compose

public final <V> Flux<V> compose(java.util.function.Function<? super Flux<T>,? extends org.reactivestreams.Publisher<V>> transformer)

Defer the given transformation to this Flux in order to generate a target Publisher type. A transformation will occur for each Subscriber. flux.compose(Mono::from).subscribe(Subscribers.unbounded())

Type Parameters:

V - the item type in the returned Publisher

Parameters:

transformer - the Function to immediately map this Flux into a target Publisher instance.

Returns:

a new Flux

See Also:

for a loose conversion to an arbitrary type

concatMap

public final <V> Flux<V> concatMap(java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<? extends V>> mapper)

Bind dynamic sequences given this input sequence like flatMap(Function), but preserve ordering and concatenate emissions instead of merging (no interleave). Errors will immediately short circuit current concat backlog.

Type Parameters:

V - the produced concatenated type

Parameters:

mapper - the function to transform this sequence of T into concatenated sequences of V

Returns:

a concatenated Flux

concatMap

public final <V> Flux<V> concatMap(java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<? extends V>> mapper,
                                   int prefetch)

Bind dynamic sequences given this input sequence like flatMap(Function), but preserve ordering and concatenate emissions instead of merging (no interleave). Errors will immediately short circuit current concat backlog.

Type Parameters:

V - the produced concatenated type

Parameters:

mapper - the function to transform this sequence of T into concatenated sequences of V

prefetch - the inner source produced demand

Returns:

a concatenated Flux

concatMapDelayError

public final <V> Flux<V> concatMapDelayError(java.util.function.Function<? super T,org.reactivestreams.Publisher<? extends V>> mapper)

Bind dynamic sequences given this input sequence like flatMap(Function), but preserve ordering and concatenate emissions instead of merging (no interleave). Errors will be delayed after the current concat backlog.

Type Parameters:

V - the produced concatenated type

Parameters:

mapper - the function to transform this sequence of T into concatenated sequences of V

Returns:

a concatenated Flux

concatMapDelayError

public final <V> Flux<V> concatMapDelayError(java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<? extends V>> mapper,
                                             int prefetch)

Bind dynamic sequences given this input sequence like flatMap(Function), but preserve ordering and concatenate emissions instead of merging (no interleave). Errors will be delayed after all concated sources terminate.

Type Parameters:

V - the produced concatenated type

Parameters:

mapper - the function to transform this sequence of T into concatenated sequences of V

prefetch - the inner source produced demand

Returns:

a concatenated Flux

concatMapDelayError

public final <V> Flux<V> concatMapDelayError(java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<? extends V>> mapper,
                                             boolean delayUntilEnd,
                                             int prefetch)

Bind dynamic sequences given this input sequence like flatMap(Function), but preserve ordering and concatenate emissions instead of merging (no interleave). Errors will be delayed after the current concat backlog if delayUntilEnd is false or after all sources if delayUntilEnd is true.

Type Parameters:

V - the produced concatenated type

Parameters:

mapper - the function to transform this sequence of T into concatenated sequences of V

delayUntilEnd - delay error until all sources have been consumed instead of after the current source

prefetch - the inner source produced demand

Returns:

a concatenated Flux

concatMapIterable

public final <R> Flux<R> concatMapIterable(java.util.function.Function<? super T,? extends java.lang.Iterable<? extends R>> mapper)

Bind Iterable sequences given this input sequence like flatMapIterable(Function), but preserve ordering and concatenate emissions instead of merging (no interleave).

Errors will be delayed after the current concat backlog.

Type Parameters:

R - the produced concatenated type

Parameters:

mapper - the function to transform this sequence of T into concatenated sequences of R

Returns:

a concatenated Flux

concatMapIterable

public final <R> Flux<R> concatMapIterable(java.util.function.Function<? super T,? extends java.lang.Iterable<? extends R>> mapper,
                                           int prefetch)

Bind Iterable sequences given this input sequence like flatMapIterable(Function), but preserve ordering and concatenate emissions instead of merging (no interleave).

Errors will be delayed after the current concat backlog.

Type Parameters:

R - the produced concatenated type

Parameters:

mapper - the function to transform this sequence of T into concatenated sequences of R

prefetch - the inner source produced demand

Returns:

a concatenated Flux

concatWith

public final Flux<T> concatWith(org.reactivestreams.Publisher<? extends T> other)

Concatenate emissions of this Flux with the provided Publisher (no interleave).

Parameters:

other - the Publisher sequence to concat after this Flux

Returns:

a concatenated Flux

count

public final Mono<java.lang.Long> count()

Counts the number of values in this Flux. The count will be emitted when onComplete is observed.

Returns:

a new Mono of Long count

defaultIfEmpty

public final Flux<T> defaultIfEmpty(T defaultV)

Provide a default unique value if this sequence is completed without any data

Parameters:

defaultV - the alternate value if this sequence is empty

Returns:

a new Flux

delay

public final Flux<T> delay(java.time.Duration delay)

Delay this Flux signals to Subscriber.onNext(T) until the given period elapses.

Parameters:

delay - duration to delay each Subscriber.onNext(T) call

Returns:

a throttled Flux

delayMillis

public final Flux<T> delayMillis(long delay)

Delay this Flux signals to Subscriber.onNext(T) until the given period in milliseconds elapses.

Parameters:

delay - period to delay each Subscriber.onNext(T) call in milliseconds

Returns:

a throttled Flux

delayMillis

public final Flux<T> delayMillis(long delay,
                                 TimedScheduler timer)

Delay this Flux signals to Subscriber.onNext(T) until the given period in milliseconds elapses.

Parameters:

delay - period to delay each Subscriber.onNext(T) call in milliseconds

timer - the timed scheduler to use for delaying each signal

Returns:

a throttled Flux

delaySubscription

public final Flux<T> delaySubscription(java.time.Duration delay)

Delay the subscription to this Flux source until the given period elapses.

Parameters:

delay - duration before subscribing this Flux

Returns:

a delayed Flux

delaySubscription

public final <U> Flux<T> delaySubscription(org.reactivestreams.Publisher<U> subscriptionDelay)

Delay the subscription to the main source until another Publisher signals a value or completes.

Type Parameters:

U - the other source type

Parameters:

subscriptionDelay - a Publisher to signal by next or complete this Publisher.subscribe(Subscriber)

Returns:

a delayed Flux

delaySubscriptionMillis

public final Flux<T> delaySubscriptionMillis(long delay)

Delay the subscription to this Flux source until the given period elapses.

Parameters:

delay - period in milliseconds before subscribing this Flux

Returns:

a delayed Flux

delaySubscriptionMillis

public final Flux<T> delaySubscriptionMillis(long delay,
                                             TimedScheduler timer)

Delay the subscription to this Flux source until the given period elapses.

Parameters:

delay - period in milliseconds before subscribing this Flux

timer - the TimedScheduler to run on

Returns:

a delayed Flux

dematerialize

public final <X> Flux<X> dematerialize()

A "phantom-operator" working only if this Flux is a emits onNext, onError or onComplete Signal. The relative Subscriber callback will be invoked, error Signal will trigger onError and complete Signal will trigger onComplete.

Type Parameters:

X - the dematerialized type

Returns:

a dematerialized Flux

distinct

public final Flux<T> distinct()

For each Subscriber, tracks this Flux values that have been seen and filters out duplicates.

Returns:

a filtering Flux with unique values

distinct

public final <V> Flux<T> distinct(java.util.function.Function<? super T,? extends V> keySelector)

For each Subscriber, tracks this Flux values that have been seen and filters out duplicates given the extracted key.

Type Parameters:

V - the type of the key extracted from each value in this sequence

Parameters:

keySelector - function to compute comparison key for each element

Returns:

a filtering Flux with values having distinct keys

distinctUntilChanged

public final Flux<T> distinctUntilChanged()

Filters out subsequent and repeated elements.

Returns:

a filtering Flux with conflated repeated elements

distinctUntilChanged

public final <V> Flux<T> distinctUntilChanged(java.util.function.Function<? super T,? extends V> keySelector)

Filters out subsequent and repeated elements provided a matching extracted key.

Type Parameters:

V - the type of the key extracted from each value in this sequence

Parameters:

keySelector - function to compute comparison key for each element

Returns:

a filtering Flux with conflated repeated elements given a comparison key

doAfterTerminate

public final Flux<T> doAfterTerminate(java.lang.Runnable afterTerminate)

Triggered after the Flux terminates, either by completing downstream successfully or with an error.

Parameters:

afterTerminate - the callback to call after Subscriber.onComplete() or Subscriber.onError(java.lang.Throwable)

Returns:

an observed Flux

doOnCancel

public final Flux<T> doOnCancel(java.lang.Runnable onCancel)

Triggered when the Flux is cancelled.

Parameters:

onCancel - the callback to call on Subscription.cancel()

Returns:

an observed Flux

doOnComplete

public final Flux<T> doOnComplete(java.lang.Runnable onComplete)

Triggered when the Flux completes successfully.

Parameters:

onComplete - the callback to call on Subscriber.onComplete()

Returns:

an observed Flux

doOnError

public final Flux<T> doOnError(java.util.function.Consumer<java.lang.Throwable> onError)

Triggered when the Flux completes with an error.

Parameters:

onError - the callback to call on Subscriber.onError(java.lang.Throwable)

Returns:

an observed Flux

doOnError

public final <E extends java.lang.Throwable> Flux<T> doOnError(java.lang.Class<E> exceptionType,
                                                               java.util.function.Consumer<? super E> onError)

Triggered when the Flux completes with an error matching the given exception type.

Type Parameters:

E - type of the error to handle

Parameters:

exceptionType - the type of exceptions to handle

onError - the error handler for each error

Returns:

an observed Flux

doOnError

public final Flux<T> doOnError(java.util.function.Predicate<? super java.lang.Throwable> predicate,
                               java.util.function.Consumer<? super java.lang.Throwable> onError)

Triggered when the Flux completes with an error matching the given exception.

Parameters:

predicate - the matcher for exceptions to handle

onError - the error handler for each error

Returns:

an observed Flux

doOnNext

public final Flux<T> doOnNext(java.util.function.Consumer<? super T> onNext)

Triggered when the Flux emits an item.

Parameters:

onNext - the callback to call on Subscriber.onNext(T)

Returns:

an observed Flux

doOnRequest

public final Flux<T> doOnRequest(java.util.function.LongConsumer consumer)

Attach a LongConsumer to this Flux that will observe any request to this Flux.

Parameters:

consumer - the consumer to invoke on each request

Returns:

an observed Flux

doOnSubscribe

public final Flux<T> doOnSubscribe(java.util.function.Consumer<? super org.reactivestreams.Subscription> onSubscribe)

Triggered when the Flux is subscribed.

Parameters:

onSubscribe - the callback to call on Subscriber.onSubscribe(org.reactivestreams.Subscription)

Returns:

an observed Flux

doOnTerminate

public final Flux<T> doOnTerminate(java.lang.Runnable onTerminate)

Triggered when the Flux terminates, either by completing successfully or with an error.

Parameters:

onTerminate - the callback to call on Subscriber.onComplete() or Subscriber.onError(java.lang.Throwable)

Returns:

an observed Flux

elapsed

public final Flux<Tuple2<java.lang.Long,T>> elapsed()

Map this Flux sequence into Tuple2 of T1 Long timemillis and T2 T associated data. The timemillis corresponds to the elapsed time between the subscribe and the first next signal OR between two next signals.

Returns:

a transforming Flux that emits tuples of time elapsed in milliseconds and matching data

elementAt

public final Mono<T> elementAt(int index)

Emit only the element at the given index position or IndexOutOfBoundsException if the sequence is shorter.

Parameters:

index - index of an item

Returns:

a Mono of the item at a specified index

elementAtOrDefault

public final Mono<T> elementAtOrDefault(int index,
                                        java.util.function.Supplier<? extends T> defaultValue)

Emit only the element at the given index position or signals a default value if specified if the sequence is shorter.

Parameters:

index - index of an item

defaultValue - supply a default value if not found

Returns:

a Mono of the item at a specified index or a default value

every

public final Flux<T> every(int batchSize)

Emit only the last value of each batch counted from this Flux sequence.

Parameters:

batchSize - the batch size to count

Returns:

a new Flux whose values are the last value of each batch

everyFirst

public final Flux<T> everyFirst(int batchSize)

Emit only the first value of each batch counted from this Flux sequence.

Parameters:

batchSize - the batch size to use

Returns:

a new Flux whose values are the first value of each batch

filter

public final Flux<T> filter(java.util.function.Predicate<? super T> p)

Evaluate each accepted value against the given Predicate. If the predicate test succeeds, the value is passed into the new Flux. If the predicate test fails, the value is ignored and a request of 1 is emitted.

Parameters:

p - the Predicate to test values against

Returns:

a new Flux containing only values that pass the predicate test

firstEmittingWith

public final Flux<T> firstEmittingWith(org.reactivestreams.Publisher<? extends T> other)

Emit from the fastest first sequence between this publisher and the given publisher

Parameters:

other - the Publisher to race with

Returns:

the fastest sequence

See Also:

firstEmitting(org.reactivestreams.Publisher<? extends I>...)

flatMap

public final <R> Flux<R> flatMap(java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> mapper)

Transform the items emitted by this Flux into Publishers, then flatten the emissions from those by merging them into a single Flux, so that they may interleave.

Type Parameters:

R - the merged output sequence type

Parameters:

mapper - the Function to transform input sequence into N sequences Publisher

Returns:

a new Flux

flatMap

public final <V> Flux<V> flatMap(java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<? extends V>> mapper,
                                 int concurrency)

Transform the items emitted by this Flux into Publishers, then flatten the emissions from those by merging them into a single Flux, so that they may interleave. The concurrency argument allows to control how many merged Publisher can happen in parallel.

Type Parameters:

V - the merged output sequence type

Parameters:

mapper - the Function to transform input sequence into N sequences Publisher

concurrency - the maximum in-flight elements from this Flux sequence

Returns:

a new Flux

flatMap

public final <V> Flux<V> flatMap(java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<? extends V>> mapper,
                                 int concurrency,
                                 int prefetch)

Transform the items emitted by this Flux into Publishers, then flatten the emissions from those by merging them into a single Flux, so that they may interleave. The concurrency argument allows to control how many merged Publisher can happen in parallel. The prefetch argument allows to give an arbitrary prefetch size to the merged Publisher.

Type Parameters:

V - the merged output sequence type

Parameters:

mapper - the Function to transform input sequence into N sequences Publisher

concurrency - the maximum in-flight elements from this Flux sequence

prefetch - the maximum in-flight elements from each inner Publisher sequence

Returns:

a merged Flux

flatMap

public final <V> Flux<V> flatMap(java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<? extends V>> mapper,
                                 boolean delayError,
                                 int concurrency,
                                 int prefetch)

Transform the items emitted by this Flux into Publishers, then flatten the emissions from those by merging them into a single Flux, so that they may interleave. The concurrency argument allows to control how many merged Publisher can happen in parallel. The prefetch argument allows to give an arbitrary prefetch size to the merged Publisher.

Type Parameters:

V - the merged output sequence type

Parameters:

mapper - the Function to transform input sequence into N sequences Publisher

delayError - should any error be delayed after current merge backlog

concurrency - the maximum in-flight elements from this Flux sequence

prefetch - the maximum in-flight elements from each inner Publisher sequence

Returns:

a merged Flux

flatMap

public final <R> Flux<R> flatMap(java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> mapperOnNext,
                                 java.util.function.Function<java.lang.Throwable,? extends org.reactivestreams.Publisher<? extends R>> mapperOnError,
                                 java.util.function.Supplier<? extends org.reactivestreams.Publisher<? extends R>> mapperOnComplete)

Transform the signals emitted by this Flux into Publishers, then flatten the emissions from those by merging them into a single Flux, so that they may interleave. OnError will be transformed into completion signal after its mapping callback has been applied.

Type Parameters:

R - the output Publisher type target

Parameters:

mapperOnNext - the Function to call on next data and returning a sequence to merge

mapperOnError - the Function to call on error signal and returning a sequence to merge

mapperOnComplete - the Function to call on complete signal and returning a sequence to merge

Returns:

a new Flux

flatMapIterable

public final <R> Flux<R> flatMapIterable(java.util.function.Function<? super T,? extends java.lang.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. The prefetch argument allows to give an arbitrary prefetch size to the merged Iterable.

Type Parameters:

R - the merged output sequence type

Parameters:

mapper - the Function to transform input sequence into N sequences Iterable

Returns:

a merged Flux

flatMapIterable

public final <R> Flux<R> flatMapIterable(java.util.function.Function<? super T,? extends java.lang.Iterable<? extends R>> mapper,
                                         int prefetch)

Transform the items emitted by this Flux into Iterable, then flatten the emissions from those by merging them into a single Flux. The prefetch argument allows to give an arbitrary prefetch size to the merged Iterable.

Type Parameters:

R - the merged output sequence type

Parameters:

mapper - the Function to transform input sequence into N sequences Iterable

prefetch - the maximum in-flight elements from each inner Iterable sequence

Returns:

a merged Flux

getPrefetch

public long getPrefetch()

The prefetch configuration of the Flux

Returns:

the prefetch configuration of the Flux, -1L if unspecified

groupBy

public final <K> Flux<GroupedFlux<K,T>> groupBy(java.util.function.Function<? super T,? extends K> keyMapper)

Re-route this sequence into dynamically created Flux for each unique key evaluated by the given key mapper.

Type Parameters:

K - the key type extracted from each value of this sequence

Parameters:

keyMapper - the key mapping Function that evaluates an incoming data and returns a key.

Returns:

a Flux of GroupedFlux grouped sequences

groupBy

public final <K,V> Flux<GroupedFlux<K,V>> groupBy(java.util.function.Function<? super T,? extends K> keyMapper,
                                                  java.util.function.Function<? super T,? extends V> valueMapper)

Re-route this sequence into dynamically created Flux for each unique key evaluated by the given key mapper. It will use the given value mapper to extract the element to route.

Type Parameters:

K - the key type extracted from each value of this sequence

V - the value type extracted from each value of this sequence

Parameters:

keyMapper - the key mapping function that evaluates an incoming data and returns a key.

valueMapper - the value mapping function that evaluates which data to extract for re-routing.

Returns:

a Flux of GroupedFlux grouped sequences

hasElement

public final Mono<java.lang.Boolean> hasElement(T value)

Emit a single boolean true if any of the values of this Flux sequence match the constant.

The implementation uses short-circuit logic and completes with true if the constant matches a value.

Parameters:

value - constant compared to incoming signals

Returns:

a new Flux with true if any value satisfies a predicate and false otherwise

hasElements

public final Mono<java.lang.Boolean> hasElements()

Emit a single boolean true if this Flux sequence has at least one element.

The implementation uses short-circuit logic and completes with true on onNext.

Returns:

a new Mono with true if any value is emitted and false otherwise

hide

public final Flux<T> hide()

Hides the identities of this Flux and its Subscription as well.

Returns:

a new Flux defeating any Publisher / Subscription feature-detection

ignoreElements

public final Mono<T> ignoreElements()

Ignores onNext signals (dropping them) and only reacts on termination.

Returns:

a new completable Mono.

last

public final Mono<T> last()

Signal the last element observed before complete signal.

Returns:

a limited Flux

log

public final Flux<T> log()

Observe all Reactive Streams signals and use Logger support to handle trace implementation. Default will use Level.INFO and java.util.logging. If SLF4J is available, it will be used instead.

The default log category will be "reactor.core.publisher.FluxLog".

Returns:

a new unaltered Flux

log

public final Flux<T> log(java.lang.String category)

Observe all Reactive Streams signals and use Logger support to handle trace implementation. Default will use Level.INFO and java.util.logging. If SLF4J is available, it will be used instead.

Parameters:

category - to be mapped into logger configuration (e.g. org.springframework.reactor).

Returns:

a new unaltered Flux

log

public final Flux<T> log(java.lang.String category,
                         java.util.logging.Level level,
                         SignalType... options)

Observe Reactive Streams signals matching the passed filter options and use Logger support to handle trace implementation. Default will use the passed Level and java.util.logging. If SLF4J is available, it will be used instead. Options allow fine grained filtering of the traced signal, for instance to only capture onNext and onError:

     flux.log("category", Level.INFO, SignalType.ON_NEXT, SignalType.ON_ERROR)
 

 
 

Parameters:

category - to be mapped into logger configuration (e.g. org.springframework.reactor).

level - the level to enforce for this tracing Flux

options - a vararg SignalType option to filter log messages

Returns:

a new unaltered Flux

map

public final <V> Flux<V> map(java.util.function.Function<? super T,? extends V> mapper)

Transform the items emitted by this Flux by applying a function to each item.

Type Parameters:

V - the transformed type

Parameters:

mapper - the transforming Function

Returns:

a transformed Flux

mapError

public final Flux<T> mapError(java.util.function.Function<? super java.lang.Throwable,? extends java.lang.Throwable> mapper)

Transform the error emitted by this Flux by applying a function.

Parameters:

mapper - the error transforming Function

Returns:

a transformed Flux

mapError

public final <E extends java.lang.Throwable> Flux<T> mapError(java.lang.Class<E> type,
                                                              java.util.function.Function<? super E,? extends java.lang.Throwable> mapper)

Transform the error emitted by this Flux by applying a function if the error matches the given type, otherwise let the error flows.

Type Parameters:

E - the error type

Parameters:

type - the class of the exception type to react to

mapper - the error transforming Function

Returns:

a transformed Flux

mapError

public final Flux<T> mapError(java.util.function.Predicate<? super java.lang.Throwable> predicate,
                              java.util.function.Function<? super java.lang.Throwable,? extends java.lang.Throwable> mapper)

Transform the error emitted by this Flux by applying a function if the error matches the given predicate, otherwise let the error flows.

Parameters:

predicate - the error predicate

mapper - the error transforming Function

Returns:

a transformed Flux

materialize

public final Flux<Signal<T>> materialize()

Transform the incoming onNext, onError and onComplete signals into Signal. Since the error is materialized as a Signal, the propagation will be stopped and onComplete will be emitted. Complete signal will first emit a Signal.complete() and then effectively complete the flux.

Returns:

a Flux of materialized Signal

mergeWith

public final Flux<T> mergeWith(org.reactivestreams.Publisher<? extends T> other)

Merge emissions of this Flux with the provided Publisher, so that they may interleave.

Parameters:

other - the Publisher to merge with

Returns:

a new Flux

next

public final Mono<T> next()

Emit only the first item emitted by this Flux.

Returns:

a new Mono

onBackpressureBuffer

public final Flux<T> onBackpressureBuffer()

Request an unbounded demand and push the returned Flux, or park the observed elements if not enough demand is requested downstream.

Returns:

a buffering Flux

onBackpressureDrop

public final Flux<T> onBackpressureDrop()

Request an unbounded demand and push the returned Flux, or drop the observed elements if not enough demand is requested downstream.

Returns:

a dropping Flux

onBackpressureDrop

public final Flux<T> onBackpressureDrop(java.util.function.Consumer<? super T> onDropped)

Request an unbounded demand and push the returned Flux, or drop and notify dropping Consumer with the observed elements if not enough demand is requested downstream.

Parameters:

onDropped - the Consumer called when an value gets dropped due to lack of downstream requests

Returns:

a dropping Flux

onBackpressureError

public final Flux<T> onBackpressureError()

Request an unbounded demand and push the returned Flux, or emit onError fom Exceptions.failWithOverflow() if not enough demand is requested downstream.

Returns:

an erroring Flux on backpressure

onBackpressureLatest

public final Flux<T> onBackpressureLatest()

Request an unbounded demand and push the returned Flux, or only keep the most recent observed item if not enough demand is requested downstream.

Returns:

a dropping Flux that will only keep a reference to the last observed item

onErrorResumeWith

public final Flux<T> onErrorResumeWith(java.util.function.Function<? super java.lang.Throwable,? extends org.reactivestreams.Publisher<? extends T>> fallback)

Subscribe to a returned fallback publisher when any error occurs.

Parameters:

fallback - the Function mapping the error to a new Publisher sequence

Returns:

a new Flux

onErrorResumeWith

public final <E extends java.lang.Throwable> Flux<T> onErrorResumeWith(java.lang.Class<E> type,
                                                                       java.util.function.Function<? super E,? extends org.reactivestreams.Publisher<? extends T>> fallback)

Subscribe to a returned fallback publisher when an error matching the given type occurs.

Type Parameters:

E - the error type

Parameters:

type - the error type to match

fallback - the Function mapping the error to a new Publisher sequence

Returns:

a new Flux

onErrorResumeWith

public final Flux<T> onErrorResumeWith(java.util.function.Predicate<? super java.lang.Throwable> predicate,
                                       java.util.function.Function<? super java.lang.Throwable,? extends org.reactivestreams.Publisher<? extends T>> fallback)

Subscribe to a returned fallback publisher when an error matching the given type occurs.

Parameters:

predicate - the error predicate to match

fallback - the Function mapping the error to a new Publisher sequence

Returns:

a new Flux

onErrorReturn

public final Flux<T> onErrorReturn(T fallbackValue)

Fallback to the given value if an error is observed on this Flux

Parameters:

fallbackValue - alternate value on fallback

Returns:

a new Flux

onErrorReturn

public final <E extends java.lang.Throwable> Flux<T> onErrorReturn(java.lang.Class<E> type,
                                                                   T fallbackValue)

Fallback to the given value if an error of a given type is observed on this Flux

Type Parameters:

E - the error type

Parameters:

type - the error type to match

fallbackValue - alternate value on fallback

Returns:

a new Flux

onErrorReturn

public final <E extends java.lang.Throwable> Flux<T> onErrorReturn(java.util.function.Predicate<? super java.lang.Throwable> predicate,
                                                                   T fallbackValue)

Fallback to the given value if an error matching the given predicate is observed on this Flux

Type Parameters:

E - the error type

Parameters:

predicate - the error predicate to match

fallbackValue - alternate value on fallback

Returns:

a new Flux

onTerminateDetach

public final Flux<T> onTerminateDetach()

Detaches the both the child Subscriber and the Subscription on termination or cancellation.

This should help with odd retention scenarios when running with non-reactor Subscriber.

Returns:

a detachable Flux

parallel

public final ParallelFlux<T> parallel()

Prepare to consume this Flux on number of 'rails' matching number of CPU in round-robin fashion.

Returns:

a new ParallelFlux instance

parallel

public final ParallelFlux<T> parallel(int parallelism)

Prepare to consume this Flux on parallallism number of 'rails' in round-robin fashion.

Parameters:

parallelism - the number of parallel rails

Returns:

a new ParallelFlux instance

parallel

public final ParallelFlux<T> parallel(int parallelism,
                                      int prefetch)

Prepare to consume this Flux on parallallism number of 'rails' in round-robin fashion and use custom prefetch amount and queue for dealing with the source Flux's values.

Parameters:

parallelism - the number of parallel rails

prefetch - the number of values to prefetch from the source

Returns:

a new ParallelFlux instance

process

public final ConnectableFlux<T> process(org.reactivestreams.Processor<? super T,? extends T> processor)

Prepare a ConnectableFlux which subscribes this Flux sequence to the given Processor. The Processor will be itself subscribed by child Subscriber when ConnectableFlux.connect() is invoked manually or automatically via ConnectableFlux.autoConnect() and ConnectableFlux.refCount(). Note that some Processor do not support multi-subscribe, multicast is non opinionated in fact and focuses on subscribe lifecycle. This will effectively turn any type of sequence into a hot sequence by sharing a single Subscription.

The Processor will not be specifically reusable and multi-connect might not work as expected depending on the Processor.

Parameters:

processor - the Processor reference to subscribe to this Flux and share.

Returns:

a new ConnectableFlux whose values are broadcasted to supported subscribers once connected via Processor

process

public final ConnectableFlux<T> process(java.util.function.Supplier<? extends org.reactivestreams.Processor<? super T,? extends T>> processorSupplier)

Prepare a ConnectableFlux which subscribes this Flux sequence to a supplied Processor when ConnectableFlux.connect() is invoked manually or automatically via ConnectableFlux.autoConnect() and ConnectableFlux.refCount(). The Processor will be itself subscribed by child Subscriber. Note that some Processor do not support multi-subscribe, multicast is non opinionated in fact and focuses on subscribe lifecycle. This will effectively turn any type of sequence into a hot sequence by sharing a single Subscription.

Parameters:

processorSupplier - the Processor Supplier to call, subscribe to this Flux and share.

Returns:

a new ConnectableFlux whose values are broadcasted to supported subscribers once connected via Processor

process

public final <U> ConnectableFlux<U> process(org.reactivestreams.Processor<? super T,? extends T> processor,
                                            java.util.function.Function<Flux<T>,? extends org.reactivestreams.Publisher<? extends U>> selector)

Prepare a ConnectableFlux which subscribes this Flux sequence to the given Processor. The Processor will be itself subscribed by child Subscriber when ConnectableFlux.connect() is invoked manually or automatically via ConnectableFlux.autoConnect() and ConnectableFlux.refCount(). Note that some Processor do not support multi-subscribe, multicast is non opinionated in fact and focuses on subscribe lifecycle. This will effectively turn any type of sequence into a hot sequence by sharing a single Subscription.

The Processor will not be specifically reusable and multi-connect might not work as expected depending on the Processor.

The selector will be applied once per Subscriber and can be used to blackbox pre-processing.

Type Parameters:

U - produced type from the given selector

Parameters:

processor - the Processor reference to subscribe to this Flux and share.

selector - a Function receiving a Flux derived from the supplied Processor and returning the end Publisher subscribed by a unique Subscriber

Returns:

a new ConnectableFlux whose values are broadcasted to supported subscribers once connected via Processor

process

public final <U> ConnectableFlux<U> process(java.util.function.Supplier<? extends org.reactivestreams.Processor<? super T,? extends T>> processorSupplier,
                                            java.util.function.Function<Flux<T>,? extends org.reactivestreams.Publisher<? extends U>> selector)

Prepare a ConnectableFlux which subscribes this Flux sequence to a supplied Processor when ConnectableFlux.connect() is invoked manually or automatically via ConnectableFlux.autoConnect() and ConnectableFlux.refCount(). The Processor will be itself subscribed by child Subscriber. Note that some Processor do not support multi-subscribe, multicast is non opinionated in fact and focuses on subscribe lifecycle. This will effectively turn any type of sequence into a hot sequence by sharing a single Subscription.

The selector will be applied once per Subscriber and can be used to blackbox pre-processing.

Type Parameters:

U - produced type from the given selector

Parameters:

processorSupplier - the Processor Supplier to createWorker, subscribe to this Flux and share.

selector - a Function receiving a Flux derived from the supplied Processor and returning the end Publisher subscribed by a unique Subscriber

Returns:

a new ConnectableFlux whose values are broadcasted to supported subscribers once connected via Processor

publish

public final ConnectableFlux<T> publish()

Prepare a ConnectableFlux which shares this Flux sequence and dispatches values to subscribers in a backpressure-aware manner. Prefetch will default to QueueSupplier.SMALL_BUFFER_SIZE. This will effectively turn any type of sequence into a hot sequence.

Backpressure will be coordinated on Subscription.request(long) and if any Subscriber is missing demand (requested = 0), multicast will pause pushing/pulling.

Returns:

a new ConnectableFlux

publish

public final ConnectableFlux<T> publish(int prefetch)

Prepare a ConnectableFlux which shares this Flux sequence and dispatches values to subscribers in a backpressure-aware manner. This will effectively turn any type of sequence into a hot sequence.

Backpressure will be coordinated on Subscription.request(long) and if any Subscriber is missing demand (requested = 0), multicast will pause pushing/pulling.

Parameters:

prefetch - bounded requested demand

Returns:

a new ConnectableFlux

publish

public final <R> Flux<R> publish(java.util.function.Function<? super Flux<T>,? extends org.reactivestreams.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.

Type Parameters:

R - the output value type

Parameters:

transform -

Returns:

a new Flux

publish

public final <R> Flux<R> publish(java.util.function.Function<? super Flux<T>,? extends org.reactivestreams.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.

Type Parameters:

R - the output value type

Parameters:

transform -

prefetch -

Returns:

a new Flux

publishNext

public final Mono<T> publishNext()

Prepare a Mono which shares this Flux sequence and dispatches the first observed item to subscribers in a backpressure-aware manner. This will effectively turn any type of sequence into a hot sequence when the first Subscriber subscribes.

Returns:

a new Mono

publishOn

public final Flux<T> publishOn(Scheduler scheduler)

Run onNext, onComplete and onError on a supplied Scheduler Scheduler.Worker.

Typically used for fast publisher, slow consumer(s) scenarios.

flux.publishOn(Schedulers.single()).subscribe()

Parameters:

scheduler - a checked Scheduler.Worker factory

Returns:

a Flux producing asynchronously

publishOn

public final Flux<T> publishOn(Scheduler scheduler,
                               int prefetch)

Run onNext, onComplete and onError on a supplied Scheduler Scheduler.Worker.

Typically used for fast publisher, slow consumer(s) scenarios.

flux.publishOn(Schedulers.single()).subscribe()

Parameters:

scheduler - a checked Scheduler.Worker factory

prefetch - the asynchronous boundary capacity

Returns:

a Flux producing asynchronously

reduce

public final Mono<T> reduce(java.util.function.BiFunction<T,T,T> aggregator)

Aggregate the values from this Flux sequence into an object of the same type than the emitted items. The left/right BiFunction arguments are the N-1 and N item, ignoring sequence with 0 or 1 element only.

Parameters:

aggregator - the aggregating BiFunction

Returns:

a reduced Flux

reduce

public final <A> Mono<A> reduce(A initial,
                                java.util.function.BiFunction<A,? super T,A> accumulator)

Accumulate the values from this Flux sequence into an object matching an initial value type. The arguments are the N-1 or initial value and N current item .

Type Parameters:

A - the type of the initial and reduced object

Parameters:

accumulator - the reducing BiFunction

initial - the initial left argument to pass to the reducing BiFunction

Returns:

a reduced Flux

reduceWith

public final <A> Mono<A> reduceWith(java.util.function.Supplier<A> initial,
                                    java.util.function.BiFunction<A,? super T,A> accumulator)

Accumulate the values from this Flux sequence into an object matching an initial value type. The arguments are the N-1 or initial value and N current item .

Type Parameters:

A - the type of the initial and reduced object

Parameters:

accumulator - the reducing BiFunction

initial - the initial left argument supplied on subscription to the reducing BiFunction

Returns:

a reduced Flux

repeat

public final Flux<T> repeat()

Repeatedly subscribe to the source completion of the previous subscription.

Returns:

an indefinitively repeated Flux on onComplete

repeat

public final Flux<T> repeat(java.util.function.BooleanSupplier predicate)

Repeatedly subscribe to the source if the predicate returns true after completion of the previous subscription.

Parameters:

predicate - the boolean to evaluate on onComplete.

Returns:

an eventually repeated Flux on onComplete

repeat

public final Flux<T> repeat(long numRepeat)

Repeatedly subscribe to the source if the predicate returns true after completion of the previous subscription.

Parameters:

numRepeat - the number of times to re-subscribe on onComplete

Returns:

an eventually repeated Flux on onComplete up to number of repeat specified

repeat

public final Flux<T> repeat(long numRepeat,
                            java.util.function.BooleanSupplier predicate)

Repeatedly subscribe to the source if the predicate returns true after completion of the previous subscription. A specified maximum of repeat will limit the number of re-subscribe.

Parameters:

numRepeat - the number of times to re-subscribe on complete

predicate - the boolean to evaluate on onComplete

Returns:

an eventually repeated Flux on onComplete up to number of repeat specified OR matching predicate

repeatWhen

public final Flux<T> repeatWhen(java.util.function.Function<Flux<java.lang.Long>,? extends org.reactivestreams.Publisher<?>> whenFactory)

Repeatedly subscribe to this Flux when a companion sequence signals a number of emitted elements in response to the flux completion signal.

If the companion sequence signals when this Flux is active, the repeat attempt is suppressed and any terminal signal will terminate this Flux with the same signal immediately.

Parameters:

whenFactory - the Function providing a Flux signalling an exclusive number of emitted elements on onComplete and returning a Publisher companion.

Returns:

an eventually repeated Flux on onComplete when the companion Publisher produces an onNext signal

replay

public final ConnectableFlux<T> replay()

Turn this Flux into a hot source and cache last emitted signals for further Subscriber. Will retain up to QueueSupplier.SMALL_BUFFER_SIZE onNext signals. Completion and Error will also be replayed.

Returns:

a replaying ConnectableFlux

replay

public final ConnectableFlux<T> replay(int history)

Turn this Flux into a hot source and cache last emitted signals for further Subscriber. Will retain up to the given history size onNext signals. Completion and Error will also be replayed.

Parameters:

history - number of events retained in history excluding complete and error

Returns:

a replaying ConnectableFlux

retry

public final Flux<T> retry()

Re-subscribes to this Flux sequence if it signals any error either indefinitely.

The times == Long.MAX_VALUE is treated as infinite retry.

Returns:

a re-subscribing Flux on onError

retry

public final Flux<T> retry(long numRetries)

Re-subscribes to this Flux sequence if it signals any error either indefinitely or a fixed number of times.

The times == Long.MAX_VALUE is treated as infinite retry.

Parameters:

numRetries - the number of times to tolerate an error

Returns:

a re-subscribing Flux on onError up to the specified number of retries.

retry

public final Flux<T> retry(java.util.function.Predicate<java.lang.Throwable> retryMatcher)

Re-subscribes to this Flux sequence if it signals any error and the given Predicate matches otherwise push the error downstream.

Parameters:

retryMatcher - the predicate to evaluate if retry should occur based on a given error signal

Returns:

a re-subscribing Flux on onError if the predicates matches.

retry

public final Flux<T> retry(long numRetries,
                           java.util.function.Predicate<java.lang.Throwable> retryMatcher)

Re-subscribes to this Flux sequence up to the specified number of retries if it signals any error and the given Predicate matches otherwise push the error downstream.

Parameters:

numRetries - the number of times to tolerate an error

retryMatcher - the predicate to evaluate if retry should occur based on a given error signal

Returns:

a re-subscribing Flux on onError up to the specified number of retries and if the predicate matches.

retryWhen

public final Flux<T> retryWhen(java.util.function.Function<Flux<java.lang.Throwable>,? extends org.reactivestreams.Publisher<?>> whenFactory)

Retries this Flux when a companion sequence signals an item in response to this Flux error signal

If the companion sequence signals when the Flux is active, the retry attempt is suppressed and any terminal signal will terminate the Flux source with the same signal immediately.

Parameters:

whenFactory - the Function providing a Flux signalling any error from the source sequence and returning a Publisher companion.

Returns:

a re-subscribing Flux on onError when the companion Publisher produces an onNext signal

sample

public final Flux<T> sample(java.time.Duration timespan)

Emit latest value for every given period of time.

Parameters:

timespan - the duration to emit the latest observed item

Returns:

a sampled Flux by last item over a period of time

sample

public final <U> Flux<T> sample(org.reactivestreams.Publisher<U> sampler)

Sample this Flux and emit its latest value whenever the sampler Publisher signals a value.

Termination of either Publisher will result in termination for the Subscriber as well.

Both Publisher will run in unbounded mode because the backpressure would interfere with the sampling precision.

Type Parameters:

U - the type of the sampler sequence

Parameters:

sampler - the sampler Publisher

Returns:

a sampled Flux by last item observed when the sampler Publisher signals

sampleFirst

public final Flux<T> sampleFirst(java.time.Duration timespan)

Take a value from this Flux then use the duration provided to skip other values.

Parameters:

timespan - the duration to exclude others values from this sequence

Returns:

a sampled Flux by first item over a period of time

sampleFirst

public final <U> Flux<T> sampleFirst(java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<U>> samplerFactory)

Take a value from this Flux then use the duration provided by a generated Publisher to skip other values until that sampler Publisher signals.

Type Parameters:

U - the companion reified type

Parameters:

samplerFactory - select a Publisher companion to signal onNext or onComplete to stop excluding others values from this sequence

Returns:

a sampled Flux by last item observed when the sampler signals

sampleFirstMillis

public final Flux<T> sampleFirstMillis(long timespan)

Take a value from this Flux then use the duration provided to skip other values.

Parameters:

timespan - the period in milliseconds to exclude others values from this sequence

Returns:

a sampled Flux by first item over a period of time

sampleMillis

public final Flux<T> sampleMillis(long timespan)

Emit latest value for every given period of ti,e.

Parameters:

timespan - the period in second to emit the latest observed item

Returns:

a sampled Flux by last item over a period of time

sampleTimeout

public final <U> Flux<T> sampleTimeout(java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<U>> throttlerFactory)

Emit the last value from this Flux only if there were no new values emitted during the time window provided by a publisher for that particular last value.

Type Parameters:

U - the companion reified type

Parameters:

throttlerFactory - select a Publisher companion to signal onNext or onComplete to stop checking others values from this sequence and emit the selecting item

Returns:

a sampled Flux by last single item observed before a companion Publisher emits

sampleTimeout

public final <U> Flux<T> sampleTimeout(java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<U>> throttlerFactory,
                                       int maxConcurrency)

Emit the last value from this Flux only if there were no newer values emitted during the time window provided by a publisher for that particular last value.

The provided maxConcurrency will keep a bounded maximum of concurrent timeouts and drop any new items until at least one timeout terminates.

Type Parameters:

U - the throttling type

Parameters:

throttlerFactory - select a Publisher companion to signal onNext or onComplete to stop checking others values from this sequence and emit the selecting item

maxConcurrency - the maximum number of concurrent timeouts

Returns:

a sampled Flux by last single item observed before a companion Publisher emits

scan

public final Flux<T> scan(java.util.function.BiFunction<T,T,T> accumulator)

Accumulate this Flux values with an accumulator BiFunction and returns the intermediate results of this function.

Unlike scan(Object, BiFunction), this operator doesn't take an initial value but treats the first Flux value as initial value.
The accumulation works as follows:

 result[0] = accumulator(source[0], source[1])
 result[1] = accumulator(result[0], source[2])
 result[2] = accumulator(result[1], source[3])
 ...
 

Parameters:

accumulator - the accumulating BiFunction

Returns:

an accumulating Flux

scan

public final <A> Flux<A> scan(A initial,
                              java.util.function.BiFunction<A,? super T,A> accumulator)

Aggregate this Flux values with the help of an accumulator BiFunction and emits the intermediate results.

The accumulation works as follows:

 result[0] = initialValue;
 result[1] = accumulator(result[0], source[0])
 result[2] = accumulator(result[1], source[1])
 result[3] = accumulator(result[2], source[2])
 ...
 

Type Parameters:

A - the accumulated type

Parameters:

initial - the initial argument to pass to the reduce function

accumulator - the accumulating BiFunction

Returns:

an accumulating Flux starting with initial state

scanWith

public final <A> Flux<A> scanWith(java.util.function.Supplier<A> initial,
                                  java.util.function.BiFunction<A,? super T,A> accumulator)

Aggregate this Flux values with the help of an accumulator BiFunction and emits the intermediate results.

The accumulation works as follows:

 result[0] = initialValue;
 result[1] = accumulator(result[0], source[0])
 result[2] = accumulator(result[1], source[1])
 result[3] = accumulator(result[2], source[2])
 ...
 

Type Parameters:

A - the accumulated type

Parameters:

initial - the initial supplier to init the first value to pass to the reduce function

accumulator - the accumulating BiFunction

Returns:

an accumulating Flux starting with initial state

single

public final Mono<T> single()

Expect and emit a single item from this Flux source or signal NoSuchElementException (or a default generated value) for empty source, IndexOutOfBoundsException for a multi-item source.

Returns:

a Mono with the eventual single item or an error signal

singleOrDefault

public final Mono<T> singleOrDefault(java.util.function.Supplier<? extends T> defaultSupplier)

Expect and emit a single item from this Flux source or signal NoSuchElementException (or a default generated value) for empty source, IndexOutOfBoundsException for a multi-item source.

Parameters:

defaultSupplier - a Supplier of a single fallback item if this Flux is empty

Returns:

a Mono with the eventual single item or a supplied default value

singleOrEmpty

public final Mono<T> singleOrEmpty()

Expect and emit a zero or single item from this Flux source or IndexOutOfBoundsException for a multi-item source.

Returns:

a Mono with the eventual single item or no item

skip

public final Flux<T> skip(long skipped)

Skip next the specified number of elements from this Flux.

Parameters:

skipped - the number of times to drop

Returns:

a dropping Flux until the specified skipped number of elements

skip

public final Flux<T> skip(java.time.Duration timespan)

Skip elements from this Flux for the given time period.

Parameters:

timespan - the time window to exclude next signals

Returns:

a dropping Flux until the end of the given timespan

skipLast

public final Flux<T> skipLast(int n)

Skip the last specified number of elements from this Flux.

Parameters:

n - the number of elements to ignore before completion

Returns:

a dropping Flux for the specified skipped number of elements before termination

skipMillis

public final Flux<T> skipMillis(long timespan)

Skip elements from this Flux for the given time period.

Parameters:

timespan - the time window to exclude next signals

Returns:

a dropping Flux until the end of the given timespan

skipMillis

public final Flux<T> skipMillis(long timespan,
                                TimedScheduler timer)

Skip elements from this Flux for the given time period.

Parameters:

timespan - the time window to exclude next signals

timer - the TimedScheduler to run on

Returns:

a dropping Flux until the end of the given timespan

skipUntil

public final Flux<T> skipUntil(java.util.function.Predicate<? super T> untilPredicate)

Skips values from this Flux until a Predicate returns true for the value. Will include the matched value.

Parameters:

untilPredicate - the Predicate evaluating to true to stop skipping.

Returns:

a dropping Flux until the Predicate matches

skipUntilOther

public final Flux<T> skipUntilOther(org.reactivestreams.Publisher<?> other)

Skip values from this Flux until a specified Publisher signals an onNext or onComplete.

Parameters:

other - the Publisher companion to coordinate with to stop skipping

Returns:

a dropping Flux until the other Publisher emits

skipWhile

public final Flux<T> skipWhile(java.util.function.Predicate<? super T> skipPredicate)

Skips values from this Flux while a Predicate returns true for the value.

Parameters:

skipPredicate - the Predicate evaluating to true to keep skipping.

Returns:

a dropping Flux while the Predicate matches

startWith

public final Flux<T> startWith(java.lang.Iterable<? extends T> iterable)

Prepend the given Iterable before this Flux sequence.

Parameters:

iterable - the sequence of values to start the sequence with

Returns:

a prefixed Flux with given Iterable

startWith

@SafeVarargs
public final Flux<T> startWith(T... values)

Prepend the given values before this Flux sequence.

Parameters:

values - the array of values to start with

Returns:

a prefixed Flux with given values

startWith

public final Flux<T> startWith(org.reactivestreams.Publisher<? extends T> publisher)

Prepend the given Publisher sequence before this Flux sequence.

Parameters:

publisher - the Publisher whose values to prepend

Returns:

a prefixed Flux with given Publisher sequence

subscribe

public final Cancellation subscribe()

Start the chain and request unbounded demand.

Returns:

a Cancellation task to execute to dispose and cancel the underlying Subscription

subscribe

public final Cancellation subscribe(int prefetch)

Start the chain and request prefetch demand

Parameters:

prefetch - an arbitrary value

Returns:

a Cancellation task to execute to dispose and cancel the underlying Subscription

subscribe

public final Cancellation subscribe(java.util.function.Consumer<? super T> consumer)

Subscribe a Consumer to this Flux that will consume all the sequence. It will request an unbounded demand.

For a passive version that observe and forward incoming data see doOnNext(java.util.function.Consumer)

Parameters:

consumer - the consumer to invoke on each value

Returns:

a new Cancellation to dispose the Subscription

subscribe

public final Cancellation subscribe(java.util.function.Consumer<? super T> consumer,
                                    int prefetch)

Subscribe a Consumer to this Flux that will consume all the sequence.

If prefetch is != Long.MAX_VALUE, the Subscriber will use it as a prefetch strategy: first request N, then when 25% of N is left to be received on onNext, request N x 0.75.

For a passive version that observe and forward incoming data see doOnNext(java.util.function.Consumer).

Parameters:

consumer - the consumer to invoke on each value

prefetch - the the prefetch amount, positive

Returns:

a new Cancellation to dispose the Subscription

subscribe

public final Cancellation subscribe(java.util.function.Consumer<? super T> consumer,
                                    java.util.function.Consumer<? super java.lang.Throwable> errorConsumer)

Subscribe Consumer to this Flux that will consume all the sequence. It will request unbounded demand Long.MAX_VALUE. For a passive version that observe and forward incoming data see doOnNext(java.util.function.Consumer) and doOnError(java.util.function.Consumer).

Parameters:

consumer - the consumer to invoke on each next signal

errorConsumer - the consumer to invoke on error signal

Returns:

a new Cancellation to dispose the Subscription

subscribe

public final Cancellation subscribe(java.util.function.Consumer<? super T> consumer,
                                    java.util.function.Consumer<? super java.lang.Throwable> errorConsumer,
                                    java.lang.Runnable completeConsumer)

Subscribe Consumer to this Flux that will consume all the sequence. It will request unbounded demand Long.MAX_VALUE. For a passive version that observe and forward incoming data see doOnNext(java.util.function.Consumer), doOnError(java.util.function.Consumer) and doOnComplete(Runnable),

Parameters:

consumer - the consumer to invoke on each value

errorConsumer - the consumer to invoke on error signal

completeConsumer - the consumer to invoke on complete signal

Returns:

a new Cancellation to dispose the Subscription

subscribe

public final Cancellation subscribe(java.util.function.Consumer<? super T> consumer,
                                    java.util.function.Consumer<? super java.lang.Throwable> errorConsumer,
                                    java.lang.Runnable completeConsumer,
                                    int prefetch)

Subscribe Consumer to this Flux that will consume all the sequence.

If prefetch is != Long.MAX_VALUE, the Subscriber will use it as a prefetch strategy: first request N, then when 25% of N is left to be received on onNext, request N x 0.75.

For a passive version that observe and forward incoming data see doOnNext(java.util.function.Consumer), doOnError(java.util.function.Consumer) and doOnComplete(Runnable),

Parameters:

consumer - the consumer to invoke on each value

errorConsumer - the consumer to invoke on error signal

completeConsumer - the consumer to invoke on complete signal

prefetch - the demand to produce to this Flux

Returns:

a new Cancellation to dispose the Subscription

subscribeOn

public final Flux<T> subscribeOn(Scheduler scheduler)

Run subscribe, onSubscribe and request on a supplied Scheduler

Typically used for slow publisher e.g., blocking IO, fast consumer(s) scenarios.

flux.subscribeOn(Schedulers.single()).subscribe()

Parameters:

scheduler - a checked Scheduler.Worker factory

Returns:

a Flux requesting asynchronously

subscribeWith

public final <E extends org.reactivestreams.Subscriber<? super T>> E subscribeWith(E subscriber)

A chaining Publisher.subscribe(Subscriber) alternative to inline composition type conversion to a hot emitter (e.g. FluxProcessor or MonoProcessor). flux.subscribeWith(WorkQueueProcessor.create()).subscribe(Subscribers.unbounded())

Type Parameters:

E - the reified type from the input/output subscriber

Parameters:

subscriber - the Subscriber to subscribe and return

Returns:

the passed Subscriber

switchIfEmpty

public final Flux<T> switchIfEmpty(org.reactivestreams.Publisher<? extends T> alternate)

Provide an alternative if this sequence is completed without any data

Parameters:

alternate - the alternate publisher if this sequence is empty

Returns:

an alternating Flux on source onComplete without elements

switchMap

public final <V> Flux<V> switchMap(java.util.function.Function<? super T,org.reactivestreams.Publisher<? extends V>> fn)

Switch to a new Publisher generated via a Function whenever this Flux produces an item.

Type Parameters:

V - the type of the return value of the transformation function

Parameters:

fn - the transformation function

Returns:

an alternating Flux on source onNext

switchMap

public final <V> Flux<V> switchMap(java.util.function.Function<? super T,org.reactivestreams.Publisher<? extends V>> fn,
                                   int prefetch)

Switch to a new Publisher generated via a Function whenever this Flux produces an item.

Type Parameters:

V - the type of the return value of the transformation function

Parameters:

fn - the transformation function

prefetch - the produced demand for inner sources

Returns:

an alternating Flux on source onNext

switchOnError

public final <E extends java.lang.Throwable> Flux<T> switchOnError(java.lang.Class<E> type,
                                                                   org.reactivestreams.Publisher<? extends T> fallback)

Subscribe to the given fallback Publisher if an error matching the given type is observed on this Flux

Type Parameters:

E - the error type

Parameters:

type - the error type to match to fallback

fallback - the alternate Publisher

Returns:

an alternating Flux on source onError

switchOnError

public final Flux<T> switchOnError(java.util.function.Predicate<? super java.lang.Throwable> predicate,
                                   org.reactivestreams.Publisher<? extends T> fallback)

Subscribe to the given fallback Publisher if an error matching the given predicate is observed on this Flux

Parameters:

predicate - the predicate to match an error

fallback - the alternate Publisher

Returns:

an alternating Flux on source onError

switchOnError

public final Flux<T> switchOnError(org.reactivestreams.Publisher<? extends T> fallback)

Subscribe to the given fallback Publisher if an error is observed on this Flux

Parameters:

fallback - the alternate Publisher

Returns:

an alternating Flux on source onError

take

public final Flux<T> take(long n)

Take only the first N values from this Flux.

If N is zero, the Subscriber gets completed if this Flux completes, signals an error or signals its first value (which is not not relayed though).

Parameters:

n - the number of items to emit from this Flux

Returns:

a size limited Flux

take

public final Flux<T> take(java.time.Duration timespan)

Relay values from this Flux until the given time period elapses.

If the time period is zero, the Subscriber gets completed if this Flux completes, signals an error or signals its first value (which is not not relayed though).

Parameters:

timespan - the time window of items to emit from this Flux

Returns:

a time limited Flux

takeLast

public final Flux<T> takeLast(int n)

Emit the last N values this Flux emitted before its completion.

Parameters:

n - the number of items from this Flux to retain and emit on onComplete

Returns:

a terminating Flux sub-sequence

takeMillis

public final Flux<T> takeMillis(long timespan)

Relay values from this Flux until the given time period elapses.

If the time period is zero, the Subscriber gets completed if this Flux completes, signals an error or signals its first value (which is not not relayed though).

Parameters:

timespan - the time window of items to emit from this Flux

Returns:

a time limited Flux

takeMillis

public final Flux<T> takeMillis(long timespan,
                                TimedScheduler timer)

Relay values from this Flux until the given time period elapses.

If the time period is zero, the Subscriber gets completed if this Flux completes, signals an error or signals its first value (which is not not relayed though).

Parameters:

timespan - the time window of items to emit from this Flux

timer - the TimedScheduler to run on

Returns:

a time limited Flux

takeUntil

public final Flux<T> takeUntil(java.util.function.Predicate<? super T> predicate)

Relay values from this Flux until the given Predicate matches. Unlike takeWhile(java.util.function.Predicate<? super T>), this will include the matched data.

Parameters:

predicate - the Predicate to signal when to stop replaying signal from this Flux

Returns:

an eventually limited Flux

takeUntilOther

public final Flux<T> takeUntilOther(org.reactivestreams.Publisher<?> other)

Relay values from this Flux until the given Publisher emits.

Parameters:

other - the Publisher to signal when to stop replaying signal from this Flux

Returns:

an eventually limited Flux

takeWhile

public final Flux<T> takeWhile(java.util.function.Predicate<? super T> continuePredicate)

Relay values while a predicate returns FALSE for the values (checked before each value is delivered). Unlike takeUntilOther(org.reactivestreams.Publisher<?>), this will exclude the matched data.

Parameters:

continuePredicate - the Predicate invoked each onNext returning FALSE to terminate

Returns:

an eventually limited Flux

then

public final Mono<java.lang.Void> then()

Return a Mono<Void> that completes when this Flux completes. This will actively ignore the sequence and only replay completion or error signals.

Returns:

a new Mono

then

public final Mono<java.lang.Void> then(org.reactivestreams.Publisher<java.lang.Void> other)

Return a Flux that emits the completion of the supplied Publisher when this Flux onComplete or onError. If an error occur, append after the supplied Publisher is terminated.

Parameters:

other - a Publisher to emit from after termination

Returns:

a new Flux emitting eventually from the supplied Publisher

then

public final Mono<java.lang.Void> then(java.util.function.Supplier<? extends org.reactivestreams.Publisher<java.lang.Void>> afterSupplier)

Return a Flux that emits the completion of the supplied Publisher when this Flux onComplete or onError. If an error occur, append after the supplied Publisher is terminated.

Parameters:

afterSupplier - a Supplier of Publisher to emit from after termination

Returns:

a new Flux emitting eventually from the supplied Publisher

thenMany

public final <V> Flux<V> thenMany(org.reactivestreams.Publisher<V> other)

Return a Flux that emits the sequence of the supplied Publisher when this Flux onComplete or onError. If an error occur, append after the supplied Publisher is terminated.

Type Parameters:

V - the supplied produced type

Parameters:

other - a Publisher to emit from after termination

Returns:

a new Flux emitting eventually from the supplied Publisher

thenMany

public final <V> Flux<V> thenMany(java.util.function.Supplier<? extends org.reactivestreams.Publisher<V>> afterSupplier)

Return a Flux that emits the sequence of the supplied Publisher when this Flux onComplete or onError. If an error occur, append after the supplied Publisher is terminated.

Type Parameters:

V - the supplied produced type

Parameters:

afterSupplier - a Supplier of Publisher to emit from after termination

Returns:

a new Flux emitting eventually from the supplied Publisher

timeout

public final Flux<T> timeout(java.time.Duration timeout)

Signal a TimeoutException in case a per-item period fires before the next item arrives from this Flux.

Parameters:

timeout - the timeout between two signals from this Flux

Returns:

a per-item expirable Flux

timeout

public final Flux<T> timeout(java.time.Duration timeout,
                             org.reactivestreams.Publisher<? extends T> fallback)

Switch to a fallback Publisher in case a per-item period fires before the next item arrives from this Flux.

If the given Publisher is null, signal a TimeoutException.

Parameters:

timeout - the timeout between two signals from this Flux

fallback - the fallback Publisher to subscribe when a timeout occurs

Returns:

a per-item expirable Flux with a fallback Publisher

timeout

public final <U> Flux<T> timeout(org.reactivestreams.Publisher<U> firstTimeout)

Signal a TimeoutException in case a first item from this Flux has not been emitted before the given Publisher emits.

Type Parameters:

U - the type of the timeout Publisher

Parameters:

firstTimeout - the timeout Publisher that must not emit before the first signal from this Flux

Returns:

an expirable Flux if the first item does not come before a Publisher signal

timeout

public final <U,V> Flux<T> timeout(org.reactivestreams.Publisher<U> firstTimeout,
                                   java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<V>> nextTimeoutFactory)

Signal a TimeoutException in case a first item from this Flux has not been emitted before the given Publisher emits. The following items will be individually timed via the factory provided Publisher.

Type Parameters:

U - the type of the elements of the first timeout Publisher

V - the type of the elements of the subsequent timeout Publishers

Parameters:

firstTimeout - the timeout Publisher that must not emit before the first signal from this Flux

nextTimeoutFactory - the timeout Publisher factory for each next item

Returns:

a first then per-item expirable Flux

timeout

public final <U,V> Flux<T> timeout(org.reactivestreams.Publisher<U> firstTimeout,
                                   java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<V>> nextTimeoutFactory,
                                   org.reactivestreams.Publisher<? extends T> fallback)

Switch to a fallback Publisher in case a first item from this Flux has not been emitted before the given Publisher emits. The following items will be individually timed via the factory provided Publisher.

Type Parameters:

U - the type of the elements of the first timeout Publisher

V - the type of the elements of the subsequent timeout Publishers

Parameters:

firstTimeout - the timeout Publisher that must not emit before the first signal from this Flux

nextTimeoutFactory - the timeout Publisher factory for each next item

fallback - the fallback Publisher to subscribe when a timeout occurs

Returns:

a first then per-item expirable Flux with a fallback Publisher

timeoutMillis

public final Flux<T> timeoutMillis(long timeout)

Signal a TimeoutException error in case a per-item period in milliseconds fires before the next item arrives from this Flux.

Parameters:

timeout - the timeout in milliseconds between two signals from this Flux

Returns:

a per-item expirable Flux

timeoutMillis

public final Flux<T> timeoutMillis(long timeout,
                                   TimedScheduler timer)

Signal a TimeoutException error in case a per-item period in milliseconds fires before the next item arrives from this Flux.

Parameters:

timeout - the timeout in milliseconds between two signals from this Flux

timer - the TimedScheduler to run on

Returns:

a per-item expirable Flux

timeoutMillis

public final Flux<T> timeoutMillis(long timeout,
                                   org.reactivestreams.Publisher<? extends T> fallback)

Switch to a fallback Publisher in case a per-item period fires before the next item arrives from this Flux.

If the given Publisher is null, signal a TimeoutException.

Parameters:

timeout - the timeout between two signals from this Flux in milliseconds

fallback - the fallback Publisher to subscribe when a timeout occurs

Returns:

a per-item expirable Flux with a fallback Publisher

timeoutMillis

public final Flux<T> timeoutMillis(long timeout,
                                   org.reactivestreams.Publisher<? extends T> fallback,
                                   TimedScheduler timer)

Switch to a fallback Publisher in case a per-item period fires before the next item arrives from this Flux.

If the given Publisher is null, signal a TimeoutException.

Parameters:

timeout - the timeout between two signals from this Flux in milliseconds

fallback - the fallback Publisher to subscribe when a timeout occurs

timer - the TimedScheduler to run on

Returns:

a per-item expirable Flux with a fallback Publisher

timestamp

public final Flux<Tuple2<java.lang.Long,T>> timestamp()

Emit a Tuple2 pair of T1 Long current system time in millis and T2 T associated data for each item from this Flux

Returns:

a timestamped Flux

toIterable

public final java.lang.Iterable<T> toIterable()

Transform this Flux into a lazy Iterable blocking on next calls.

Returns:

a blocking Iterable

toIterable

public final java.lang.Iterable<T> toIterable(long batchSize)

Transform this Flux into a lazy Iterable blocking on next calls.

Parameters:

batchSize - the bounded capacity to produce to this Flux or Integer.MAX_VALUE for unbounded

Returns:

a blocking Iterable

toIterable

public final java.lang.Iterable<T> toIterable(long batchSize,
                                              java.util.function.Supplier<java.util.Queue<T>> queueProvider)

Transform this Flux into a lazy Iterable blocking on next calls.

Parameters:

batchSize - the bounded capacity to produce to this Flux or Integer.MAX_VALUE for unbounded

queueProvider - the supplier of the queue implementation to be used for transferring elements across threads.

Returns:

a blocking Iterable

toStream

public java.util.stream.Stream<T> toStream()

Transform this Flux into a lazy Stream blocking on next calls.

Returns:

a Stream of unknown size with onClose attached to Subscription.cancel()

toStream

public java.util.stream.Stream<T> toStream(int batchSize)

Transform this Flux into a lazy Stream blocking on next calls.

Parameters:

batchSize - the bounded capacity to produce to this Flux or Integer.MAX_VALUE for unbounded

Returns:

a Stream of unknown size with onClose attached to Subscription.cancel()

toString

public java.lang.String toString()

Overrides:

toString in class java.lang.Object

window

public final Flux<Flux<T>> window()

Split this Flux sequence into multiple Flux delimited by cancel signals they receive. e.g. window().flatMap(w -> w.take(3)) will delimit window every 3.

Returns:

a windowing Flux of Flux buckets delimited by cancel signals

window

public final Flux<Flux<T>> window(int maxSize)

Split this Flux sequence into multiple Flux delimited by the given maxSize count and starting from the first item. Each Flux bucket will onComplete after maxSize items have been routed.

Parameters:

maxSize - the maximum routed items before emitting onComplete per Flux bucket

Returns:

a windowing Flux of sized Flux buckets

window

public final Flux<Flux<T>> window(int maxSize,
                                  int skip)

Split this Flux sequence into multiple Flux delimited by the given skip count, starting from the first item. Each Flux bucket will onComplete after maxSize items have been routed.

When skip > maxSize : dropping windows

When maxSize < skip : overlapping windows

When skip == maxSize : exact windows

Parameters:

maxSize - the maximum routed items per Flux

skip - the number of items to count before emitting a new bucket Flux

Returns:

a windowing Flux of sized Flux buckets every skip count

window

public final Flux<Flux<T>> window(org.reactivestreams.Publisher<?> boundary)

Split this Flux sequence into continuous, non-overlapping windows where the window boundary is signalled by another Publisher

Parameters:

boundary - a Publisher to emit any item for a split signal and complete to terminate

Returns:

a windowing Flux delimiting its sub-sequences by a given Publisher

window

public final <U,V> Flux<Flux<T>> window(org.reactivestreams.Publisher<U> bucketOpening,
                                        java.util.function.Function<? super U,? extends org.reactivestreams.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.

When Open signal is strictly not overlapping Close signal : dropping windows

When Open signal is strictly more frequent than Close signal : overlapping windows

When Open signal is exactly coordinated with Close signal : exact windows

Type Parameters:

U - the type of the sequence opening windows

V - the type of the sequence closing windows opened by the bucketOpening Publisher's elements

Parameters:

bucketOpening - a Publisher to emit any item for a split signal and complete to terminate

closeSelector - a Function given an opening signal and returning a Publisher that emits to complete the window

Returns:

a windowing Flux delimiting its sub-sequences by a given Publisher and lasting until a selected Publisher emits

window

public final Flux<Flux<T>> window(java.time.Duration timespan)

Split this Flux sequence into continuous, non-overlapping windows delimited by a given period.

Parameters:

timespan - the duration to delimit Flux windows

Returns:

a windowing Flux of timed Flux buckets

window

public final Flux<Flux<T>> window(java.time.Duration timespan,
                                  java.time.Duration timeshift)

Split this Flux sequence into multiple Flux delimited by the given timeshift period, starting from the first item. Each Flux bucket will onComplete after timespan period has elpased.

When timeshift > timespan : dropping windows

When timeshift < timespan : overlapping windows

When timeshift == timespan : exact windows

Parameters:

timespan - the maximum Flux window duration

timeshift - the period of time to create new Flux windows

Returns:

a windowing Flux of Flux buckets delimited by an opening Publisher and a selected closing Publisher

window

public final Flux<Flux<T>> window(int maxSize,
                                  java.time.Duration timespan)

Split this Flux sequence into multiple Flux delimited by the given maxSize number of items, starting from the first item. Flux windows will onComplete after a given timespan occurs and the number of items has not be counted.

Parameters:

maxSize - the maximum Flux window items to count before onComplete

timespan - the timeout to use to onComplete a given window if size is not counted yet

Returns:

a windowing Flux of sized or timed Flux buckets

windowMillis

public final Flux<Flux<T>> windowMillis(long timespan)

Split this Flux sequence into continuous, non-overlapping windows delimited by a given period.

Parameters:

timespan - the duration in milliseconds to delimit Flux windows

Returns:

a windowing Flux of timed Flux buckets

windowMillis

public final Flux<Flux<T>> windowMillis(long timespan,
                                        TimedScheduler timer)

Split this Flux sequence into continuous, non-overlapping windows delimited by a given period.

Parameters:

timespan - the duration in milliseconds to delimit Flux windows

timer - the TimedScheduler to run on

Returns:

a windowing Flux of timed Flux buckets

windowMillis

public final Flux<Flux<T>> windowMillis(long timespan,
                                        long timeshift)

Split this Flux sequence into multiple Flux delimited by the given timeshift period, starting from the first item. Each Flux bucket will onComplete after timespan period has elpased.

When timeshift > timespan : dropping windows

When timeshift < timespan : overlapping windows

When timeshift == timespan : exact windows

Parameters:

timespan - the maximum Flux window duration in milliseconds

timeshift - the period of time in milliseconds to create new Flux windows

Returns:

a windowing Flux of Flux buckets delimited by an opening Publisher and a selected closing Publisher

windowMillis

public final Flux<Flux<T>> windowMillis(long timespan,
                                        long timeshift,
                                        TimedScheduler timer)

Split this Flux sequence into multiple Flux delimited by the given timeshift period, starting from the first item. Each Flux bucket will onComplete after timespan period has elpased.

When timeshift > timespan : dropping windows

When timeshift < timespan : overlapping windows

When timeshift == timespan : exact windows

Parameters:

timespan - the maximum Flux window duration in milliseconds

timeshift - the period of time in milliseconds to create new Flux windows

timer - the TimedScheduler to run on

Returns:

a windowing Flux of Flux buckets delimited by an opening Publisher and a selected closing Publisher

windowMillis

public final Flux<Flux<T>> windowMillis(int maxSize,
                                        long timespan)

Split this Flux sequence into multiple Flux delimited by the given maxSize number of items, starting from the first item. Flux windows will onComplete after a given timespan occurs and the number of items has not be counted.

Parameters:

maxSize - the maximum Flux window items to count before onComplete

timespan - the timeout to use to onComplete a given window if size is not counted yet

Returns:

a windowing Flux of sized or timed Flux buckets

windowMillis

public final Flux<Flux<T>> windowMillis(int maxSize,
                                        long timespan,
                                        TimedScheduler timer)

Split this Flux sequence into multiple Flux delimited by the given maxSize number of items, starting from the first item. Flux windows will onComplete after a given timespan occurs and the number of items has not be counted.

Parameters:

maxSize - the maximum Flux window items to count before onComplete

timespan - the timeout to use to onComplete a given window if size is not counted yet

timer - the TimedScheduler to run on

Returns:

a windowing Flux of sized or timed Flux buckets

withLatestFrom

public final <U,R> Flux<R> withLatestFrom(org.reactivestreams.Publisher<? extends U> other,
                                          java.util.function.BiFunction<? super T,? super U,? extends R> resultSelector)

Combine values from this Flux with values from another Publisher through a BiFunction and emits the result.

The operator will drop values from this Flux until the other Publisher produces any value.

If the other Publisher completes without any value, the sequence is completed.

Type Parameters:

U - the other Publisher sequence type

R - the result type

Parameters:

other - the Publisher to combine with

resultSelector - the bi-function called with each pair of source and other elements that should return a single value to be emitted

Returns:

a combined Flux gated by another Publisher

zipWith

public final <T2,V> Flux<V> zipWith(org.reactivestreams.Publisher<? extends T2> source2,
                                    java.util.function.BiFunction<? super T,? super T2,? extends V> combinator)

"Step-Merge" especially useful in Scatter-Gather scenarios. The operator will forward all combinations produced by the passed combinator from the most recent items emitted by each source until any of them completes. Errors will immediately be forwarded.

Type Parameters:

T2 - type of the value from source2

V - The produced output after transformation by the combinator

Parameters:

source2 - The second upstream Publisher to subscribe to.

combinator - The aggregate function that will receive a unique value from each upstream and return the value to signal downstream

Returns:

a zipped Flux

zipWith

public final <T2,V> Flux<V> zipWith(org.reactivestreams.Publisher<? extends T2> source2,
                                    int prefetch,
                                    java.util.function.BiFunction<? super T,? super T2,? extends V> combinator)

"Step-Merge" especially useful in Scatter-Gather scenarios. The operator will forward all combinations produced by the passed combinator from the most recent items emitted by each source until any of them completes. Errors will immediately be forwarded.

Type Parameters:

T2 - type of the value from source2

V - The produced output after transformation by the combinator

Parameters:

source2 - The second upstream Publisher to subscribe to.

prefetch - the request size to use for this Flux and the other Publisher

combinator - The aggregate function that will receive a unique value from each upstream and return the value to signal downstream

Returns:

a zipped Flux

zipWith

public final <T2> Flux<Tuple2<T,T2>> zipWith(org.reactivestreams.Publisher<? extends T2> source2)

"Step-Merge" especially useful in Scatter-Gather scenarios. The operator will forward all combinations of the most recent items emitted by each source until any of them completes. Errors will immediately be forwarded.

Type Parameters:

T2 - type of the value from source2

Parameters:

source2 - The second upstream Publisher to subscribe to.

Returns:

a zipped Flux

zipWith

public final <T2> Flux<Tuple2<T,T2>> zipWith(org.reactivestreams.Publisher<? extends T2> source2,
                                             int prefetch)

"Step-Merge" especially useful in Scatter-Gather scenarios. The operator will forward all combinations of the most recent items emitted by each source until any of them completes. Errors will immediately be forwarded.

Type Parameters:

T2 - type of the value from source2

Parameters:

source2 - The second upstream Publisher to subscribe to.

prefetch - the request size to use for this Flux and the other Publisher

Returns:

a zipped Flux

zipWithIterable

public final <T2> Flux<Tuple2<T,T2>> zipWithIterable(java.lang.Iterable<? extends T2> iterable)

Pairwise combines as Tuple2 elements of this Flux and an Iterable sequence.

Type Parameters:

T2 - the value type of the other iterable sequence

Parameters:

iterable - the Iterable to pair with

Returns:

a zipped Flux

zipWithIterable

public final <T2,V> Flux<V> zipWithIterable(java.lang.Iterable<? extends T2> iterable,
                                            java.util.function.BiFunction<? super T,? super T2,? extends V> zipper)

Pairwise combines elements of this Flux and an Iterable sequence using the given zipper BiFunction.

Type Parameters:

T2 - the value type of the other iterable sequence

V - the result type

Parameters:

iterable - the Iterable to pair with

zipper - the BiFunction combinator

Returns:

a zipped Flux