Uses of Class
io.reactivex.rxjava3.core.Flowable

Packages that use Flowable

Package	Description
io.reactivex.rxjava3.core	Base reactive classes: Flowable, Observable, Single, Maybe and Completable; base reactive consumers; other common base interfaces.
io.reactivex.rxjava3.flowables	Classes supporting the Flowable base reactive class: ConnectableFlowable and GroupedFlowable.
io.reactivex.rxjava3.internal.fuseable	Base interfaces and types for supporting operator-fusion.
io.reactivex.rxjava3.internal.jdk8
io.reactivex.rxjava3.internal.operators.completable
io.reactivex.rxjava3.internal.operators.flowable
io.reactivex.rxjava3.internal.operators.maybe
io.reactivex.rxjava3.internal.operators.mixed
io.reactivex.rxjava3.internal.operators.parallel
io.reactivex.rxjava3.internal.operators.single
io.reactivex.rxjava3.internal.schedulers
io.reactivex.rxjava3.parallel	Contains the base type ParallelFlowable, a sub-DSL for working with Flowable sequences in parallel.
io.reactivex.rxjava3.plugins	Contains the central plugin handler RxJavaPlugins class to hook into the lifecycle of the base reactive types and schedulers.
io.reactivex.rxjava3.processors	Classes representing so-called hot backpressure-aware sources, aka processors, that implement the FlowableProcessor class, the Reactive Streams Processor interface to allow forms of multicasting events to one or more subscribers as well as consuming another Reactive Streams Publisher.

Uses of Flowable in io.reactivex.rxjava3.core

Methods in io.reactivex.rxjava3.core that return Flowable

Modifier and Type	Method	Description
static <@NonNull T> @NonNull Flowable<T>	Flowable.amb(@NonNull Iterable<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources)	Mirrors the one Publisher in an Iterable of several Publishers that first either emits an item or sends a termination notification.
static <@NonNull T> @NonNull Flowable<T>	Flowable.ambArray(@NonNull org.reactivestreams.Publisher<? extends @NonNull T>... sources)	Mirrors the one Publisher in an array of several Publishers that first either emits an item or sends a termination notification.
final @NonNull Flowable<T>	Flowable.ambWith(@NonNull org.reactivestreams.Publisher<? extends @NonNull T> other)	Mirrors the Publisher (current or provided) that first either emits an item or sends a termination notification.
final <@NonNull T> @NonNull Flowable<T>	Completable.andThen(@NonNull org.reactivestreams.Publisher<@NonNull T> next)	Returns a Flowable which will subscribe to this Completable and once that is completed then will subscribe to the next Publisher.
final @NonNull Flowable<List<T>>	Flowable.buffer(int count)	Returns a Flowable that emits buffers of items it collects from the current Flowable.
final @NonNull Flowable<List<T>>	Flowable.buffer(int count, int skip)	Returns a Flowable that emits buffers of items it collects from the current Flowable.
final <@NonNull U extends Collection<? super @NonNull T>> @NonNull Flowable<U>	Flowable.buffer(int count, int skip, @NonNull Supplier<@NonNull U> bufferSupplier)	Returns a Flowable that emits buffers of items it collects from the current Flowable.
final <@NonNull U extends Collection<? super @NonNull T>> @NonNull Flowable<U>	Flowable.buffer(int count, @NonNull Supplier<@NonNull U> bufferSupplier)	Returns a Flowable that emits buffers of items it collects from the current Flowable.
final @NonNull Flowable<List<T>>	Flowable.buffer(long timespan, long timeskip, @NonNull TimeUnit unit)	Returns a Flowable that emits buffers of items it collects from the current Flowable.
final @NonNull Flowable<List<T>>	Flowable.buffer(long timespan, long timeskip, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)	Returns a Flowable that emits buffers of items it collects from the current Flowable.
final <@NonNull U extends Collection<? super @NonNull T>> @NonNull Flowable<U>	Flowable.buffer(long timespan, long timeskip, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, @NonNull Supplier<@NonNull U> bufferSupplier)	Returns a Flowable that emits buffers of items it collects from the current Flowable.
final @NonNull Flowable<List<T>>	Flowable.buffer(long timespan, @NonNull TimeUnit unit)	Returns a Flowable that emits buffers of items it collects from the current Flowable.
final @NonNull Flowable<List<T>>	Flowable.buffer(long timespan, @NonNull TimeUnit unit, int count)	Returns a Flowable that emits buffers of items it collects from the current Flowable.
final @NonNull Flowable<List<T>>	Flowable.buffer(long timespan, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)	Returns a Flowable that emits buffers of items it collects from the current Flowable.
final @NonNull Flowable<List<T>>	Flowable.buffer(long timespan, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, int count)	Returns a Flowable that emits buffers of items it collects from the current Flowable.
final <@NonNull U extends Collection<? super @NonNull T>> @NonNull Flowable<U>	Flowable.buffer(long timespan, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, int count, @NonNull Supplier<@NonNull U> bufferSupplier, boolean restartTimerOnMaxSize)	Returns a Flowable that emits buffers of items it collects from the current Flowable.
final <@NonNull TOpening, @NonNull TClosing> @NonNull Flowable<List<T>>	Flowable.buffer(@NonNull org.reactivestreams.Publisher<? extends @NonNull TOpening> openingIndicator, @NonNull Function<? super @NonNull TOpening,@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull TClosing>> closingIndicator)	Returns a Flowable that emits buffers of items it collects from the current Flowable.
final <@NonNull TOpening, @NonNull TClosing, @NonNull U extends Collection<? super @NonNull T>> @NonNull Flowable<U>	Flowable.buffer(@NonNull org.reactivestreams.Publisher<? extends @NonNull TOpening> openingIndicator, @NonNull Function<? super @NonNull TOpening,@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull TClosing>> closingIndicator, @NonNull Supplier<@NonNull U> bufferSupplier)	Returns a Flowable that emits buffers of items it collects from the current Flowable.
final <@NonNull B> @NonNull Flowable<List<T>>	Flowable.buffer(@NonNull org.reactivestreams.Publisher<@NonNull B> boundaryIndicator)	Returns a Flowable that emits non-overlapping buffered items from the current Flowable each time the specified boundary Publisher emits an item.
final <@NonNull B> @NonNull Flowable<List<T>>	Flowable.buffer(@NonNull org.reactivestreams.Publisher<@NonNull B> boundaryIndicator, int initialCapacity)	Returns a Flowable that emits non-overlapping buffered items from the current Flowable each time the specified boundary Publisher emits an item.
final <@NonNull B, @NonNull U extends Collection<? super @NonNull T>> @NonNull Flowable<U>	Flowable.buffer(@NonNull org.reactivestreams.Publisher<@NonNull B> boundaryIndicator, @NonNull Supplier<@NonNull U> bufferSupplier)	Returns a Flowable that emits non-overlapping buffered items from the current Flowable each time the specified boundary Publisher emits an item.
final @NonNull Flowable<T>	Flowable.cache()	Returns a Flowable that subscribes to this Publisher lazily, caches all of its events and replays them, in the same order as received, to all the downstream subscribers.
final @NonNull Flowable<T>	Flowable.cacheWithInitialCapacity(int initialCapacity)	Returns a Flowable that subscribes to this Publisher lazily, caches all of its events and replays them, in the same order as received, to all the downstream subscribers.
final <@NonNull U> @NonNull Flowable<U>	Flowable.cast(@NonNull Class<@NonNull U> clazz)	Returns a Flowable that emits the upstream items while they can be cast via Class.cast(Object) until the upstream terminates, or until the upstream signals an item which can't be cast, resulting in a ClassCastException to be signaled to the downstream.
static <@NonNull T, @NonNull R> @NonNull Flowable<R>	Flowable.combineLatest(@NonNull Iterable<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources, @NonNull Function<? super Object[],? extends @NonNull R> combiner)	Combines a collection of source Publishers by emitting an item that aggregates the latest values of each of the source Publishers each time an item is received from any of the source Publishers, where this aggregation is defined by a specified function.
static <@NonNull T, @NonNull R> @NonNull Flowable<R>	Flowable.combineLatest(@NonNull Iterable<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources, @NonNull Function<? super Object[],? extends @NonNull R> combiner, int bufferSize)	Combines a collection of source Publishers by emitting an item that aggregates the latest values of each of the source Publishers each time an item is received from any of the source Publishers, where this aggregation is defined by a specified function.
static <@NonNull T1, @NonNull T2, @NonNull R> @NonNull Flowable<R>	Flowable.combineLatest(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull BiFunction<? super @NonNull T1,? super @NonNull T2,? extends @NonNull R> combiner)	Combines two source Publishers by emitting an item that aggregates the latest values of each of the source Publishers each time an item is received from either of the source Publishers, where this aggregation is defined by a specified function.
static <@NonNull T1, @NonNull T2, @NonNull T3, @NonNull R> @NonNull Flowable<R>	Flowable.combineLatest(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T3> source3, @NonNull Function3<? super @NonNull T1,? super @NonNull T2,? super @NonNull T3,? extends @NonNull R> combiner)	Combines three source Publishers by emitting an item that aggregates the latest values of each of the source Publishers each time an item is received from any of the source Publishers, where this aggregation is defined by a specified function.
static <@NonNull T1, @NonNull T2, @NonNull T3, @NonNull T4, @NonNull R> @NonNull Flowable<R>	Flowable.combineLatest(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T3> source3, @NonNull org.reactivestreams.Publisher<? extends @NonNull T4> source4, @NonNull Function4<? super @NonNull T1,? super @NonNull T2,? super @NonNull T3,? super @NonNull T4,? extends @NonNull R> combiner)	Combines four source Publishers by emitting an item that aggregates the latest values of each of the source Publishers each time an item is received from any of the source Publishers, where this aggregation is defined by a specified function.
static <@NonNull T1, @NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull R> @NonNull Flowable<R>	Flowable.combineLatest(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T3> source3, @NonNull org.reactivestreams.Publisher<? extends @NonNull T4> source4, @NonNull org.reactivestreams.Publisher<? extends @NonNull T5> source5, @NonNull Function5<? super @NonNull T1,? super @NonNull T2,? super @NonNull T3,? super @NonNull T4,? super @NonNull T5,? extends @NonNull R> combiner)	Combines five source Publishers by emitting an item that aggregates the latest values of each of the source Publishers each time an item is received from any of the source Publishers, where this aggregation is defined by a specified function.
static <@NonNull T1, @NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull R> @NonNull Flowable<R>	Flowable.combineLatest(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T3> source3, @NonNull org.reactivestreams.Publisher<? extends @NonNull T4> source4, @NonNull org.reactivestreams.Publisher<? extends @NonNull T5> source5, @NonNull org.reactivestreams.Publisher<? extends @NonNull T6> source6, @NonNull Function6<? super @NonNull T1,? super @NonNull T2,? super @NonNull T3,? super @NonNull T4,? super @NonNull T5,? super @NonNull T6,? extends @NonNull R> combiner)	Combines six source Publishers by emitting an item that aggregates the latest values of each of the source Publishers each time an item is received from any of the source Publishers, where this aggregation is defined by a specified function.
static <@NonNull T1, @NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull R> @NonNull Flowable<R>	Flowable.combineLatest(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T3> source3, @NonNull org.reactivestreams.Publisher<? extends @NonNull T4> source4, @NonNull org.reactivestreams.Publisher<? extends @NonNull T5> source5, @NonNull org.reactivestreams.Publisher<? extends @NonNull T6> source6, @NonNull org.reactivestreams.Publisher<? extends @NonNull T7> source7, @NonNull Function7<? super @NonNull T1,? super @NonNull T2,? super @NonNull T3,? super @NonNull T4,? super @NonNull T5,? super @NonNull T6,? super @NonNull T7,? extends @NonNull R> combiner)	Combines seven source Publishers by emitting an item that aggregates the latest values of each of the source Publishers each time an item is received from any of the source Publishers, where this aggregation is defined by a specified function.
static <@NonNull T1, @NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull T8, @NonNull R> @NonNull Flowable<R>	Flowable.combineLatest(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T3> source3, @NonNull org.reactivestreams.Publisher<? extends @NonNull T4> source4, @NonNull org.reactivestreams.Publisher<? extends @NonNull T5> source5, @NonNull org.reactivestreams.Publisher<? extends @NonNull T6> source6, @NonNull org.reactivestreams.Publisher<? extends @NonNull T7> source7, @NonNull org.reactivestreams.Publisher<? extends @NonNull T8> source8, @NonNull Function8<? super @NonNull T1,? super @NonNull T2,? super @NonNull T3,? super @NonNull T4,? super @NonNull T5,? super @NonNull T6,? super @NonNull T7,? super @NonNull T8,? extends @NonNull R> combiner)	Combines eight source Publishers by emitting an item that aggregates the latest values of each of the source Publishers each time an item is received from any of the source Publishers, where this aggregation is defined by a specified function.
static <@NonNull T1, @NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull T8, @NonNull T9, @NonNull R> @NonNull Flowable<R>	Flowable.combineLatest(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T3> source3, @NonNull org.reactivestreams.Publisher<? extends @NonNull T4> source4, @NonNull org.reactivestreams.Publisher<? extends @NonNull T5> source5, @NonNull org.reactivestreams.Publisher<? extends @NonNull T6> source6, @NonNull org.reactivestreams.Publisher<? extends @NonNull T7> source7, @NonNull org.reactivestreams.Publisher<? extends @NonNull T8> source8, @NonNull org.reactivestreams.Publisher<? extends @NonNull T9> source9, @NonNull Function9<? super @NonNull T1,? super @NonNull T2,? super @NonNull T3,? super @NonNull T4,? super @NonNull T5,? super @NonNull T6,? super @NonNull T7,? super @NonNull T8,? super @NonNull T9,? extends @NonNull R> combiner)	Combines nine source Publishers by emitting an item that aggregates the latest values of each of the source Publishers each time an item is received from any of the source Publishers, where this aggregation is defined by a specified function.
static <@NonNull T, @NonNull R> @NonNull Flowable<R>	Flowable.combineLatestArray(@NonNull org.reactivestreams.Publisher<? extends @NonNull T>[] sources, @NonNull Function<? super Object[],? extends @NonNull R> combiner)	Combines a collection of source Publishers by emitting an item that aggregates the latest values of each of the source Publishers each time an item is received from any of the source Publishers, where this aggregation is defined by a specified function.
static <@NonNull T, @NonNull R> @NonNull Flowable<R>	Flowable.combineLatestArray(@NonNull org.reactivestreams.Publisher<? extends @NonNull T>[] sources, @NonNull Function<? super Object[],? extends @NonNull R> combiner, int bufferSize)	Combines a collection of source Publishers by emitting an item that aggregates the latest values of each of the source Publishers each time an item is received from any of the source Publishers, where this aggregation is defined by a specified function.
static <@NonNull T, @NonNull R> @NonNull Flowable<R>	Flowable.combineLatestArrayDelayError(@NonNull org.reactivestreams.Publisher<? extends @NonNull T>[] sources, @NonNull Function<? super Object[],? extends @NonNull R> combiner)	Combines a collection of source Publishers by emitting an item that aggregates the latest values of each of the source Publishers each time an item is received from any of the source Publishers, where this aggregation is defined by a specified function.
static <@NonNull T, @NonNull R> @NonNull Flowable<R>	Flowable.combineLatestArrayDelayError(@NonNull org.reactivestreams.Publisher<? extends @NonNull T>[] sources, @NonNull Function<? super Object[],? extends @NonNull R> combiner, int bufferSize)	Combines a collection of source Publishers by emitting an item that aggregates the latest values of each of the source Publishers each time an item is received from any of the source Publishers, where this aggregation is defined by a specified function and delays any error from the sources until all source Publishers terminate.
static <@NonNull T, @NonNull R> @NonNull Flowable<R>	Flowable.combineLatestDelayError(@NonNull Iterable<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources, @NonNull Function<? super Object[],? extends @NonNull R> combiner)	Combines a collection of source Publishers by emitting an item that aggregates the latest values of each of the source Publishers each time an item is received from any of the source Publishers, where this aggregation is defined by a specified function and delays any error from the sources until all source Publishers terminate.
static <@NonNull T, @NonNull R> @NonNull Flowable<R>	Flowable.combineLatestDelayError(@NonNull Iterable<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources, @NonNull Function<? super Object[],? extends @NonNull R> combiner, int bufferSize)	Combines a collection of source Publishers by emitting an item that aggregates the latest values of each of the source Publishers each time an item is received from any of the source Publishers, where this aggregation is defined by a specified function and delays any error from the sources until all source Publishers terminate.
final <@NonNull R> @NonNull Flowable<R>	Flowable.compose(@NonNull FlowableTransformer<? super @NonNull T,? extends @NonNull R> composer)	Transform the current Flowable by applying a particular FlowableTransformer function to it.
static <@NonNull T> @NonNull Flowable<T>	Flowable.concat(@NonNull Iterable<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources)	Concatenates elements of each Publisher provided via an Iterable sequence into a single sequence of elements without interleaving them.
static <@NonNull T> @NonNull Flowable<T>	Flowable.concat(@NonNull org.reactivestreams.Publisher<? extends @NonNull T> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T> source2)	Returns a Flowable that emits the items emitted by two Publishers, one after the other, without interleaving them.
static <@NonNull T> @NonNull Flowable<T>	Flowable.concat(@NonNull org.reactivestreams.Publisher<? extends @NonNull T> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T> source3)	Returns a Flowable that emits the items emitted by three Publishers, one after the other, without interleaving them.
static <@NonNull T> @NonNull Flowable<T>	Flowable.concat(@NonNull org.reactivestreams.Publisher<? extends @NonNull T> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T> source3, @NonNull org.reactivestreams.Publisher<? extends @NonNull T> source4)	Returns a Flowable that emits the items emitted by four Publishers, one after the other, without interleaving them.
static <@NonNull T> @NonNull Flowable<T>	Flowable.concat(@NonNull org.reactivestreams.Publisher<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources)	Returns a Flowable that emits the items emitted by each of the Publishers emitted by the source Publisher, one after the other, without interleaving them.
static <@NonNull T> @NonNull Flowable<T>	Flowable.concat(@NonNull org.reactivestreams.Publisher<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources, int prefetch)	Returns a Flowable that emits the items emitted by each of the Publishers emitted by the source Publisher, one after the other, without interleaving them.
static <@NonNull T> @NonNull Flowable<T>	Maybe.concat(@NonNull MaybeSource<? extends @NonNull T> source1, @NonNull MaybeSource<? extends @NonNull T> source2)	Returns a Flowable that emits the items emitted by two MaybeSources, one after the other.
static <@NonNull T> @NonNull Flowable<T>	Maybe.concat(@NonNull MaybeSource<? extends @NonNull T> source1, @NonNull MaybeSource<? extends @NonNull T> source2, @NonNull MaybeSource<? extends @NonNull T> source3)	Returns a Flowable that emits the items emitted by three MaybeSources, one after the other.
static <@NonNull T> @NonNull Flowable<T>	Maybe.concat(@NonNull MaybeSource<? extends @NonNull T> source1, @NonNull MaybeSource<? extends @NonNull T> source2, @NonNull MaybeSource<? extends @NonNull T> source3, @NonNull MaybeSource<? extends @NonNull T> source4)	Returns a Flowable that emits the items emitted by four MaybeSources, one after the other.
static <@NonNull T> @NonNull Flowable<T>	Maybe.concat(@NonNull Iterable<@NonNull ? extends MaybeSource<? extends @NonNull T>> sources)	Concatenate the single values, in a non-overlapping fashion, of the MaybeSource sources provided by an Iterable sequence as a Flowable sequence.
static <@NonNull T> @NonNull Flowable<T>	Maybe.concat(@NonNull org.reactivestreams.Publisher<@NonNull ? extends MaybeSource<? extends @NonNull T>> sources)	Concatenate the single values, in a non-overlapping fashion, of the MaybeSource sources provided by a Publisher sequence as a Flowable sequence.
static <@NonNull T> @NonNull Flowable<T>	Maybe.concat(@NonNull org.reactivestreams.Publisher<@NonNull ? extends MaybeSource<? extends @NonNull T>> sources, int prefetch)	Concatenate the single values, in a non-overlapping fashion, of the MaybeSource sources provided by a Publisher sequence as a Flowable sequence.
static <@NonNull T> @NonNull Flowable<T>	Single.concat(@NonNull SingleSource<? extends @NonNull T> source1, @NonNull SingleSource<? extends @NonNull T> source2)	Returns a Flowable that emits the items emitted by two SingleSources, one after the other.
static <@NonNull T> @NonNull Flowable<T>	Single.concat(@NonNull SingleSource<? extends @NonNull T> source1, @NonNull SingleSource<? extends @NonNull T> source2, @NonNull SingleSource<? extends @NonNull T> source3)	Returns a Flowable that emits the items emitted by three SingleSources, one after the other.
static <@NonNull T> @NonNull Flowable<T>	Single.concat(@NonNull SingleSource<? extends @NonNull T> source1, @NonNull SingleSource<? extends @NonNull T> source2, @NonNull SingleSource<? extends @NonNull T> source3, @NonNull SingleSource<? extends @NonNull T> source4)	Returns a Flowable that emits the items emitted by four SingleSources, one after the other.
static <@NonNull T> @NonNull Flowable<T>	Single.concat(@NonNull Iterable<@NonNull ? extends SingleSource<? extends @NonNull T>> sources)	Concatenate the single values, in a non-overlapping fashion, of the SingleSources provided by an Iterable sequence.
static <@NonNull T> @NonNull Flowable<T>	Single.concat(@NonNull org.reactivestreams.Publisher<@NonNull ? extends SingleSource<? extends @NonNull T>> sources)	Concatenate the single values, in a non-overlapping fashion, of the SingleSources provided by a Publisher sequence.
static <@NonNull T> @NonNull Flowable<T>	Single.concat(@NonNull org.reactivestreams.Publisher<@NonNull ? extends SingleSource<? extends @NonNull T>> sources, int prefetch)	Concatenate the single values, in a non-overlapping fashion, of the SingleSources provided by a Publisher sequence and prefetched by the specified amount.
static <@NonNull T> @NonNull Flowable<T>	Flowable.concatArray(@NonNull org.reactivestreams.Publisher<? extends @NonNull T>... sources)	Concatenates a variable number of Publisher sources.
static <@NonNull T> @NonNull Flowable<T>	Maybe.concatArray(@NonNull MaybeSource<? extends @NonNull T>... sources)	Concatenate the single values, in a non-overlapping fashion, of the MaybeSource sources in the array as a Flowable sequence.
static <@NonNull T> @NonNull Flowable<T>	Single.concatArray(@NonNull SingleSource<? extends @NonNull T>... sources)	Concatenate the single values, in a non-overlapping fashion, of the SingleSources provided in an array.
static <@NonNull T> @NonNull Flowable<T>	Flowable.concatArrayDelayError(@NonNull org.reactivestreams.Publisher<? extends @NonNull T>... sources)	Concatenates a variable number of Publisher sources and delays errors from any of them till all terminate.
static <@NonNull T> @NonNull Flowable<T>	Maybe.concatArrayDelayError(@NonNull MaybeSource<? extends @NonNull T>... sources)	Concatenates a variable number of MaybeSource sources and delays errors from any of them till all terminate as a Flowable sequence.
static <@NonNull T> @NonNull Flowable<T>	Single.concatArrayDelayError(@NonNull SingleSource<? extends @NonNull T>... sources)	Concatenate the single values, in a non-overlapping fashion, of the SingleSources provided in an array.
static <@NonNull T> @NonNull Flowable<T>	Flowable.concatArrayEager(int maxConcurrency, int prefetch, @NonNull org.reactivestreams.Publisher<? extends @NonNull T>... sources)	Concatenates an array of Publishers eagerly into a single stream of values.
static <@NonNull T> @NonNull Flowable<T>	Flowable.concatArrayEager(@NonNull org.reactivestreams.Publisher<? extends @NonNull T>... sources)	Concatenates an array of Publishers eagerly into a single stream of values.
static <@NonNull T> @NonNull Flowable<T>	Maybe.concatArrayEager(@NonNull MaybeSource<? extends @NonNull T>... sources)	Concatenates a sequence of MaybeSource eagerly into a Flowable sequence.
static <@NonNull T> @NonNull Flowable<T>	Single.concatArrayEager(@NonNull SingleSource<? extends @NonNull T>... sources)	Concatenates a sequence of SingleSource eagerly into a single stream of values.
static <@NonNull T> @NonNull Flowable<T>	Flowable.concatArrayEagerDelayError(int maxConcurrency, int prefetch, @NonNull org.reactivestreams.Publisher<? extends @NonNull T>... sources)	Concatenates an array of Publishers eagerly into a single stream of values and delaying any errors until all sources terminate.
static <@NonNull T> @NonNull Flowable<T>	Flowable.concatArrayEagerDelayError(@NonNull org.reactivestreams.Publisher<? extends @NonNull T>... sources)	Concatenates an array of Publishers eagerly into a single stream of values and delaying any errors until all sources terminate.
static <@NonNull T> @NonNull Flowable<T>	Maybe.concatArrayEagerDelayError(@NonNull MaybeSource<? extends @NonNull T>... sources)	Concatenates a sequence of MaybeSource eagerly into a Flowable sequence.
static <@NonNull T> @NonNull Flowable<T>	Single.concatArrayEagerDelayError(@NonNull SingleSource<? extends @NonNull T>... sources)	Concatenates a sequence of SingleSource eagerly into a single stream of values.
static <@NonNull T> @NonNull Flowable<T>	Flowable.concatDelayError(@NonNull Iterable<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources)	Concatenates the Iterable sequence of Publishers into a single sequence by subscribing to each Publisher, one after the other, one at a time and delays any errors till the all inner Publishers terminate.
static <@NonNull T> @NonNull Flowable<T>	Flowable.concatDelayError(@NonNull org.reactivestreams.Publisher<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources)	Concatenates the Publisher sequence of Publishers into a single sequence by subscribing to each inner Publisher, one after the other, one at a time and delays any errors till the all inner and the outer Publishers terminate.
static <@NonNull T> @NonNull Flowable<T>	Flowable.concatDelayError(@NonNull org.reactivestreams.Publisher<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources, int prefetch, boolean tillTheEnd)	Concatenates the Publisher sequence of Publishers into a single sequence by subscribing to each inner Publisher, one after the other, one at a time and delays any errors till the all inner and the outer Publishers terminate.
static <@NonNull T> @NonNull Flowable<T>	Maybe.concatDelayError(@NonNull Iterable<@NonNull ? extends MaybeSource<? extends @NonNull T>> sources)	Concatenates the Iterable sequence of MaybeSources into a single sequence by subscribing to each MaybeSource, one after the other, one at a time and delays any errors till the all inner MaybeSources terminate as a Flowable sequence.
static <@NonNull T> @NonNull Flowable<T>	Maybe.concatDelayError(@NonNull org.reactivestreams.Publisher<@NonNull ? extends MaybeSource<? extends @NonNull T>> sources)	Concatenates the Publisher sequence of MaybeSources into a single sequence by subscribing to each inner MaybeSource, one after the other, one at a time and delays any errors till the all inner and the outer Publisher terminate as a Flowable sequence.
static <@NonNull T> @NonNull Flowable<T>	Maybe.concatDelayError(@NonNull org.reactivestreams.Publisher<@NonNull ? extends MaybeSource<? extends @NonNull T>> sources, int prefetch)	Concatenates the Publisher sequence of MaybeSources into a single sequence by subscribing to each inner MaybeSource, one after the other, one at a time and delays any errors till the all inner and the outer Publisher terminate as a Flowable sequence.
static <@NonNull T> @NonNull Flowable<T>	Single.concatDelayError(@NonNull Iterable<@NonNull ? extends SingleSource<? extends @NonNull T>> sources)	Concatenates the Iterable sequence of SingleSources into a single sequence by subscribing to each SingleSource, one after the other, one at a time and delays any errors till the all inner SingleSources terminate as a Flowable sequence.
static <@NonNull T> @NonNull Flowable<T>	Single.concatDelayError(@NonNull org.reactivestreams.Publisher<@NonNull ? extends SingleSource<? extends @NonNull T>> sources)	Concatenates the Publisher sequence of SingleSources into a single sequence by subscribing to each inner SingleSource, one after the other, one at a time and delays any errors till the all inner and the outer Publisher terminate as a Flowable sequence.
static <@NonNull T> @NonNull Flowable<T>	Single.concatDelayError(@NonNull org.reactivestreams.Publisher<@NonNull ? extends SingleSource<? extends @NonNull T>> sources, int prefetch)	Concatenates the Publisher sequence of SingleSources into a single sequence by subscribing to each inner SingleSource, one after the other, one at a time and delays any errors till the all inner and the outer Publisher terminate as a Flowable sequence.
static <@NonNull T> @NonNull Flowable<T>	Flowable.concatEager(@NonNull Iterable<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources)	Concatenates a sequence of Publishers eagerly into a single stream of values.
static <@NonNull T> @NonNull Flowable<T>	Flowable.concatEager(@NonNull Iterable<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources, int maxConcurrency, int prefetch)	Concatenates a sequence of Publishers eagerly into a single stream of values and runs a limited number of inner sequences at once.
static <@NonNull T> @NonNull Flowable<T>	Flowable.concatEager(@NonNull org.reactivestreams.Publisher<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources)	Concatenates a Publisher sequence of Publishers eagerly into a single stream of values.
static <@NonNull T> @NonNull Flowable<T>	Flowable.concatEager(@NonNull org.reactivestreams.Publisher<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources, int maxConcurrency, int prefetch)	Concatenates a Publisher sequence of Publishers eagerly into a single stream of values and runs a limited number of inner sequences at once.
static <@NonNull T> @NonNull Flowable<T>	Maybe.concatEager(@NonNull Iterable<@NonNull ? extends MaybeSource<? extends @NonNull T>> sources)	Concatenates a sequence of MaybeSources eagerly into a Flowable sequence.
static <@NonNull T> @NonNull Flowable<T>	Maybe.concatEager(@NonNull Iterable<@NonNull ? extends MaybeSource<? extends @NonNull T>> sources, int maxConcurrency)	Concatenates a sequence of MaybeSources eagerly into a Flowable sequence and runs a limited number of the inner sequences at once.
static <@NonNull T> @NonNull Flowable<T>	Maybe.concatEager(@NonNull org.reactivestreams.Publisher<@NonNull ? extends MaybeSource<? extends @NonNull T>> sources)	Concatenates a Publisher sequence of MaybeSources eagerly into a Flowable sequence.
static <@NonNull T> @NonNull Flowable<T>	Maybe.concatEager(@NonNull org.reactivestreams.Publisher<@NonNull ? extends MaybeSource<? extends @NonNull T>> sources, int maxConcurrency)	Concatenates a Publisher sequence of MaybeSources eagerly into a Flowable sequence, running at most the given number of inner MaybeSources at once.
static <@NonNull T> @NonNull Flowable<T>	Single.concatEager(@NonNull Iterable<@NonNull ? extends SingleSource<? extends @NonNull T>> sources)	Concatenates an Iterable sequence of SingleSources eagerly into a single stream of values.
static <@NonNull T> @NonNull Flowable<T>	Single.concatEager(@NonNull Iterable<@NonNull ? extends SingleSource<? extends @NonNull T>> sources, int maxConcurrency)	Concatenates an Iterable sequence of SingleSources eagerly into a single stream of values and runs a limited number of the inner sources at once.
static <@NonNull T> @NonNull Flowable<T>	Single.concatEager(@NonNull org.reactivestreams.Publisher<@NonNull ? extends SingleSource<? extends @NonNull T>> sources)	Concatenates a Publisher sequence of SingleSources eagerly into a single stream of values.
static <@NonNull T> @NonNull Flowable<T>	Single.concatEager(@NonNull org.reactivestreams.Publisher<@NonNull ? extends SingleSource<? extends @NonNull T>> sources, int maxConcurrency)	Concatenates a Publisher sequence of SingleSources eagerly into a single stream of values and runs a limited number of those inner SingleSources at once.
static <@NonNull T> @NonNull Flowable<T>	Flowable.concatEagerDelayError(@NonNull Iterable<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources)	Concatenates a sequence of Publishers eagerly into a single stream of values, delaying errors until all the inner sequences terminate.
static <@NonNull T> @NonNull Flowable<T>	Flowable.concatEagerDelayError(@NonNull Iterable<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources, int maxConcurrency, int prefetch)	Concatenates a sequence of Publishers eagerly into a single stream of values, delaying errors until all the inner sequences terminate and runs a limited number of inner sequences at once.
static <@NonNull T> @NonNull Flowable<T>	Flowable.concatEagerDelayError(@NonNull org.reactivestreams.Publisher<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources)	Concatenates a Publisher sequence of Publishers eagerly into a single stream of values, delaying errors until all the inner and the outer sequences terminate.
static <@NonNull T> @NonNull Flowable<T>	Flowable.concatEagerDelayError(@NonNull org.reactivestreams.Publisher<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources, int maxConcurrency, int prefetch)	Concatenates a Publisher sequence of Publishers eagerly into a single stream of values, delaying errors until all the inner and outer sequences terminate and runs a limited number of inner sequences at once.
static <@NonNull T> @NonNull Flowable<T>	Maybe.concatEagerDelayError(@NonNull Iterable<@NonNull ? extends MaybeSource<? extends @NonNull T>> sources)	Concatenates a sequence of MaybeSources eagerly into a Flowable sequence, delaying errors until all inner MaybeSources terminate.
static <@NonNull T> @NonNull Flowable<T>	Maybe.concatEagerDelayError(@NonNull Iterable<@NonNull ? extends MaybeSource<? extends @NonNull T>> sources, int maxConcurrency)	Concatenates a sequence of MaybeSources eagerly into a Flowable sequence, delaying errors until all inner MaybeSources terminate and runs a limited number of inner MaybeSources at once.
static <@NonNull T> @NonNull Flowable<T>	Maybe.concatEagerDelayError(@NonNull org.reactivestreams.Publisher<@NonNull ? extends MaybeSource<? extends @NonNull T>> sources)	Concatenates a Publisher sequence of MaybeSources eagerly into a Flowable sequence, delaying errors until all the inner and the outer sequence terminate.
static <@NonNull T> @NonNull Flowable<T>	Maybe.concatEagerDelayError(@NonNull org.reactivestreams.Publisher<@NonNull ? extends MaybeSource<? extends @NonNull T>> sources, int maxConcurrency)	Concatenates a Publisher sequence of MaybeSources eagerly into a Flowable sequence, delaying errors until all the inner and the outer sequence terminate and runs a limited number of the inner MaybeSources at once.
static <@NonNull T> @NonNull Flowable<T>	Single.concatEagerDelayError(@NonNull Iterable<@NonNull ? extends SingleSource<? extends @NonNull T>> sources)	Concatenates an Iterable sequence of SingleSources eagerly into a single stream of values, delaying errors until all the inner sources terminate.
static <@NonNull T> @NonNull Flowable<T>	Single.concatEagerDelayError(@NonNull Iterable<@NonNull ? extends SingleSource<? extends @NonNull T>> sources, int maxConcurrency)	Concatenates an Iterable sequence of SingleSources eagerly into a single stream of values, delaying errors until all the inner sources terminate.
static <@NonNull T> @NonNull Flowable<T>	Single.concatEagerDelayError(@NonNull org.reactivestreams.Publisher<@NonNull ? extends SingleSource<? extends @NonNull T>> sources)	Concatenates a Publisher sequence of SingleSources eagerly into a single stream of values, delaying errors until all the inner and the outer sequence terminate.
static <@NonNull T> @NonNull Flowable<T>	Single.concatEagerDelayError(@NonNull org.reactivestreams.Publisher<@NonNull ? extends SingleSource<? extends @NonNull T>> sources, int maxConcurrency)	Concatenates a Publisher sequence of SingleSources eagerly into a single stream of values, running at most the specified number of those inner SingleSources at once and delaying errors until all the inner and the outer sequence terminate.
final <@NonNull R> @NonNull Flowable<R>	Flowable.concatMap(@NonNull Function<? super @NonNull T,@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> mapper)	Returns a new Flowable that emits items resulting from applying a function that you supply to each item emitted by the current Flowable, where that function returns a Publisher, and then emitting the items that result from concatenating those returned Publishers.
final <@NonNull R> @NonNull Flowable<R>	Flowable.concatMap(@NonNull Function<? super @NonNull T,@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> mapper, int prefetch)	Returns a new Flowable that emits items resulting from applying a function that you supply to each item emitted by the current Flowable, where that function returns a Publisher, and then emitting the items that result from concatenating those returned Publishers.
final <@NonNull R> @NonNull Flowable<R>	Flowable.concatMap(@NonNull Function<? super @NonNull T,@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> mapper, int prefetch, @NonNull Scheduler scheduler)	Returns a new Flowable that emits items resulting from applying a function (on a designated scheduler) that you supply to each item emitted by the current Flowable, where that function returns a Publisher, and then emitting the items that result from concatenating those returned Publishers.
final <@NonNull R> @NonNull Flowable<R>	Flowable.concatMapDelayError(@NonNull Function<? super @NonNull T,@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> mapper)	Maps each of the items into a Publisher, subscribes to them one after the other, one at a time and emits their values in order while delaying any error from either this or any of the inner Publishers till all of them terminate.
final <@NonNull R> @NonNull Flowable<R>	Flowable.concatMapDelayError(@NonNull Function<? super @NonNull T,@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> mapper, boolean tillTheEnd, int prefetch)	Maps each of the items into a Publisher, subscribes to them one after the other, one at a time and emits their values in order while delaying any error from either this or any of the inner Publishers till all of them terminate.
final <@NonNull R> @NonNull Flowable<R>	Flowable.concatMapDelayError(@NonNull Function<? super @NonNull T,@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> mapper, boolean tillTheEnd, int prefetch, @NonNull Scheduler scheduler)	Maps each of the upstream items into a Publisher, subscribes to them one after the other, one at a time and emits their values in order while executing the mapper function on the designated scheduler, delaying any error from either this or any of the inner Publishers till all of them terminate.
final <@NonNull R> @NonNull Flowable<R>	Flowable.concatMapEager(@NonNull Function<? super @NonNull T,@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> mapper)	Maps a sequence of values into Publishers and concatenates these Publishers eagerly into a single Publisher.
final <@NonNull R> @NonNull Flowable<R>	Flowable.concatMapEager(@NonNull Function<? super @NonNull T,@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> mapper, int maxConcurrency, int prefetch)	Maps a sequence of values into Publishers and concatenates these Publishers eagerly into a single Publisher.
final <@NonNull R> @NonNull Flowable<R>	Flowable.concatMapEagerDelayError(@NonNull Function<? super @NonNull T,@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> mapper, boolean tillTheEnd)	Maps a sequence of values into Publishers and concatenates these Publishers eagerly into a single Publisher.
final <@NonNull R> @NonNull Flowable<R>	Flowable.concatMapEagerDelayError(@NonNull Function<? super @NonNull T,@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> mapper, boolean tillTheEnd, int maxConcurrency, int prefetch)	Maps a sequence of values into Publishers and concatenates these Publishers eagerly into a single Flowable sequence.
final <@NonNull U> @NonNull Flowable<U>	Flowable.concatMapIterable(@NonNull Function<? super @NonNull T,@NonNull ? extends Iterable<? extends @NonNull U>> mapper)	Returns a Flowable that concatenate each item emitted by the current Flowable with the values in an Iterable corresponding to that item that is generated by a selector.
final <@NonNull U> @NonNull Flowable<U>	Flowable.concatMapIterable(@NonNull Function<? super @NonNull T,@NonNull ? extends Iterable<? extends @NonNull U>> mapper, int prefetch)	Returns a Flowable that concatenate each item emitted by the current Flowable with the values in an Iterable corresponding to that item that is generated by a selector.
final <@NonNull R> @NonNull Flowable<R>	Flowable.concatMapMaybe(@NonNull Function<? super @NonNull T,? extends MaybeSource<? extends @NonNull R>> mapper)	Maps the upstream items into MaybeSources and subscribes to them one after the other succeeds or completes, emits their success value if available or terminates immediately if either this Flowable or the current inner MaybeSource fail.
final <@NonNull R> @NonNull Flowable<R>	Flowable.concatMapMaybe(@NonNull Function<? super @NonNull T,? extends MaybeSource<? extends @NonNull R>> mapper, int prefetch)	Maps the upstream items into MaybeSources and subscribes to them one after the other succeeds or completes, emits their success value if available or terminates immediately if either this Flowable or the current inner MaybeSource fail.
final <@NonNull R> @NonNull Flowable<R>	Flowable.concatMapMaybeDelayError(@NonNull Function<? super @NonNull T,? extends MaybeSource<? extends @NonNull R>> mapper)	Maps the upstream items into MaybeSources and subscribes to them one after the other terminates, emits their success value if available and delaying all errors till both this Flowable and all inner MaybeSources terminate.
final <@NonNull R> @NonNull Flowable<R>	Flowable.concatMapMaybeDelayError(@NonNull Function<? super @NonNull T,? extends MaybeSource<? extends @NonNull R>> mapper, boolean tillTheEnd)	Maps the upstream items into MaybeSources and subscribes to them one after the other terminates, emits their success value if available and optionally delaying all errors till both this Flowable and all inner MaybeSources terminate.
final <@NonNull R> @NonNull Flowable<R>	Flowable.concatMapMaybeDelayError(@NonNull Function<? super @NonNull T,? extends MaybeSource<? extends @NonNull R>> mapper, boolean tillTheEnd, int prefetch)	Maps the upstream items into MaybeSources and subscribes to them one after the other terminates, emits their success value if available and optionally delaying all errors till both this Flowable and all inner MaybeSources terminate.
final <@NonNull R> @NonNull Flowable<R>	Flowable.concatMapSingle(@NonNull Function<? super @NonNull T,? extends SingleSource<? extends @NonNull R>> mapper)	Maps the upstream items into SingleSources and subscribes to them one after the other succeeds, emits their success values or terminates immediately if either this Flowable or the current inner SingleSource fail.
final <@NonNull R> @NonNull Flowable<R>	Flowable.concatMapSingle(@NonNull Function<? super @NonNull T,? extends SingleSource<? extends @NonNull R>> mapper, int prefetch)	Maps the upstream items into SingleSources and subscribes to them one after the other succeeds, emits their success values or terminates immediately if either this Flowable or the current inner SingleSource fail.
final <@NonNull R> @NonNull Flowable<R>	Flowable.concatMapSingleDelayError(@NonNull Function<? super @NonNull T,? extends SingleSource<? extends @NonNull R>> mapper)	Maps the upstream items into SingleSources and subscribes to them one after the other succeeds or fails, emits their success values and delays all errors till both this Flowable and all inner SingleSources terminate.
final <@NonNull R> @NonNull Flowable<R>	Flowable.concatMapSingleDelayError(@NonNull Function<? super @NonNull T,? extends SingleSource<? extends @NonNull R>> mapper, boolean tillTheEnd)	Maps the upstream items into SingleSources and subscribes to them one after the other succeeds or fails, emits their success values and optionally delays all errors till both this Flowable and all inner SingleSources terminate.
final <@NonNull R> @NonNull Flowable<R>	Flowable.concatMapSingleDelayError(@NonNull Function<? super @NonNull T,? extends SingleSource<? extends @NonNull R>> mapper, boolean tillTheEnd, int prefetch)	Maps the upstream items into SingleSources and subscribes to them one after the other succeeds or fails, emits their success values and optionally delays errors till both this Flowable and all inner SingleSources terminate.
final <@NonNull R> @NonNull Flowable<R>	Flowable.concatMapStream(@NonNull Function<? super @NonNull T,@NonNull ? extends Stream<? extends @NonNull R>> mapper)	Maps each upstream item into a Stream and emits the Stream's items to the downstream in a sequential fashion.
final <@NonNull R> @NonNull Flowable<R>	Flowable.concatMapStream(@NonNull Function<? super @NonNull T,@NonNull ? extends Stream<? extends @NonNull R>> mapper, int prefetch)	Maps each upstream item into a Stream and emits the Stream's items to the downstream in a sequential fashion.
final @NonNull Flowable<T>	Flowable.concatWith(@NonNull CompletableSource other)	Returns a Flowable that emits items from this Flowable and when it completes normally, the other CompletableSource is subscribed to and the returned Flowable emits its terminal events.
final @NonNull Flowable<T>	Flowable.concatWith(@NonNull MaybeSource<? extends @NonNull T> other)	Returns a Flowable that emits the items from this Flowable followed by the success item or terminal events of the other MaybeSource.
final @NonNull Flowable<T>	Flowable.concatWith(@NonNull SingleSource<? extends @NonNull T> other)	Returns a Flowable that emits the items from this Flowable followed by the success item or error event of the other SingleSource.
final @NonNull Flowable<T>	Flowable.concatWith(@NonNull org.reactivestreams.Publisher<? extends @NonNull T> other)	Returns a Flowable that emits the items emitted from the current Flowable, then the next, one after the other, without interleaving them.
final @NonNull Flowable<T>	Maybe.concatWith(@NonNull MaybeSource<? extends @NonNull T> other)	Returns a Flowable that emits the items emitted from the current Maybe, then the other MaybeSource, one after the other, without interleaving them.
final @NonNull Flowable<T>	Single.concatWith(@NonNull SingleSource<? extends @NonNull T> other)	Returns a Flowable that emits the item emitted by the current Single, then the item emitted by the specified SingleSource.
static <@NonNull T> @NonNull Flowable<T>	Flowable.create(@NonNull FlowableOnSubscribe<@NonNull T> source, @NonNull BackpressureStrategy mode)	Provides an API (via a cold Flowable) that bridges the reactive world with the callback-style, generally non-backpressured world.
final @NonNull Flowable<T>	Flowable.debounce(long timeout, @NonNull TimeUnit unit)	Returns a Flowable that mirrors the current Flowable, except that it drops items emitted by the current Flowable that are followed by newer items before a timeout value expires.
final @NonNull Flowable<T>	Flowable.debounce(long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)	Returns a Flowable that mirrors the current Flowable, except that it drops items emitted by the current Flowable that are followed by newer items before a timeout value expires on a specified Scheduler.
final @NonNull Flowable<T>	Flowable.debounce(long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, @NonNull Consumer<? super @NonNull T> onDropped)	Returns a Flowable that mirrors the current Flowable, except that it drops items emitted by the current Flowable that are followed by newer items before a timeout value expires on a specified Scheduler.
final <@NonNull U> @NonNull Flowable<T>	Flowable.debounce(@NonNull Function<? super @NonNull T,@NonNull ? extends org.reactivestreams.Publisher<@NonNull U>> debounceIndicator)	Returns a Flowable that mirrors the current Flowable, except that it drops items emitted by the current Flowable that are followed by another item within a computed debounce duration.
final @NonNull Flowable<T>	Flowable.defaultIfEmpty(@NonNull T defaultItem)	Returns a Flowable that emits the items emitted by the current Flowable or a specified default item if the current Flowable is empty.
static <@NonNull T> @NonNull Flowable<T>	Flowable.defer(@NonNull Supplier<? extends @NonNull org.reactivestreams.Publisher<? extends @NonNull T>> supplier)	Returns a Flowable that calls a Publisher factory to create a Publisher for each new Subscriber that subscribes.
final @NonNull Flowable<T>	Flowable.delay(long time, @NonNull TimeUnit unit)	Returns a Flowable that emits the items emitted by the current Flowable shifted forward in time by a specified delay.
final @NonNull Flowable<T>	Flowable.delay(long time, @NonNull TimeUnit unit, boolean delayError)	Returns a Flowable that emits the items emitted by the current Flowable shifted forward in time by a specified delay.
final @NonNull Flowable<T>	Flowable.delay(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)	Returns a Flowable that emits the items emitted by the current Flowable shifted forward in time by a specified delay.
final @NonNull Flowable<T>	Flowable.delay(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean delayError)	Returns a Flowable that emits the items emitted by the current Flowable shifted forward in time by a specified delay.
final <@NonNull U> @NonNull Flowable<T>	Flowable.delay(@NonNull Function<? super @NonNull T,@NonNull ? extends org.reactivestreams.Publisher<@NonNull U>> itemDelayIndicator)	Returns a Flowable that delays the emissions of the current Flowable via another Publisher on a per-item basis.
final <@NonNull U, @NonNull V> @NonNull Flowable<T>	Flowable.delay(@NonNull org.reactivestreams.Publisher<@NonNull U> subscriptionIndicator, @NonNull Function<? super @NonNull T,@NonNull ? extends org.reactivestreams.Publisher<@NonNull V>> itemDelayIndicator)	Returns a Flowable that delays the subscription to and emissions from the current Flowable via another Publisher on a per-item basis.
final @NonNull Flowable<T>	Flowable.delaySubscription(long time, @NonNull TimeUnit unit)	Returns a Flowable that delays the subscription to the current Flowable by a given amount of time.
final @NonNull Flowable<T>	Flowable.delaySubscription(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)	Returns a Flowable that delays the subscription to the current Flowable by a given amount of time, both waiting and subscribing on a given Scheduler.
final <@NonNull U> @NonNull Flowable<T>	Flowable.delaySubscription(@NonNull org.reactivestreams.Publisher<@NonNull U> subscriptionIndicator)	Returns a Flowable that delays the subscription to this Publisher until the other Publisher emits an element or completes normally.
final <@NonNull R> @NonNull Flowable<R>	Flowable.dematerialize(@NonNull Function<@NonNull ? super @NonNull T,@NonNull Notification<@NonNull R>> selector)	Returns a Flowable that reverses the effect of materialize by transforming the Notification objects extracted from the source items via a selector function into their respective Subscriber signal types.
final @NonNull Flowable<T>	Flowable.distinct()	Returns a Flowable that emits all items emitted by the current Flowable that are distinct based on Object.equals(Object) comparison.
final <@NonNull K> @NonNull Flowable<T>	Flowable.distinct(@NonNull Function<? super @NonNull T,@NonNull K> keySelector)	Returns a Flowable that emits all items emitted by the current Flowable that are distinct according to a key selector function and based on Object.equals(Object) comparison of the objects returned by the key selector function.
final <@NonNull K> @NonNull Flowable<T>	Flowable.distinct(@NonNull Function<? super @NonNull T,@NonNull K> keySelector, @NonNull Supplier<? extends Collection<? super @NonNull K>> collectionSupplier)	Returns a Flowable that emits all items emitted by the current Flowable that are distinct according to a key selector function and based on Object.equals(Object) comparison of the objects returned by the key selector function.
final @NonNull Flowable<T>	Flowable.distinctUntilChanged()	Returns a Flowable that emits all items emitted by the current Flowable that are distinct from their immediate predecessors based on Object.equals(Object) comparison.
final @NonNull Flowable<T>	Flowable.distinctUntilChanged(@NonNull BiPredicate<? super @NonNull T,? super @NonNull T> comparer)	Returns a Flowable that emits all items emitted by the current Flowable that are distinct from their immediate predecessors when compared with each other via the provided comparator function.
final <@NonNull K> @NonNull Flowable<T>	Flowable.distinctUntilChanged(@NonNull Function<? super @NonNull T,@NonNull K> keySelector)	Returns a Flowable that emits all items emitted by the current Flowable that are distinct from their immediate predecessors, according to a key selector function and based on Object.equals(Object) comparison of those objects returned by the key selector function.
final @NonNull Flowable<T>	Flowable.doAfterNext(@NonNull Consumer<? super @NonNull T> onAfterNext)	Calls the specified consumer with the current item after this item has been emitted to the downstream.
final @NonNull Flowable<T>	Flowable.doAfterTerminate(@NonNull Action onAfterTerminate)	Registers an Action to be called when this Publisher invokes either onComplete or onError.
final @NonNull Flowable<T>	Flowable.doFinally(@NonNull Action onFinally)	Calls the specified action after this Flowable signals onError or onComplete or gets canceled by the downstream.
final @NonNull Flowable<T>	Flowable.doOnCancel(@NonNull Action onCancel)	Calls the cancel Action if the downstream cancels the sequence.
final @NonNull Flowable<T>	Flowable.doOnComplete(@NonNull Action onComplete)	Invokes an Action just before the current Flowable calls onComplete.
private @NonNull Flowable<T>	Flowable.doOnEach(@NonNull Consumer<? super @NonNull T> onNext, @NonNull Consumer<? super Throwable> onError, Action onComplete, Action onAfterTerminate)	Calls the appropriate onXXX consumer (shared between all subscribers) whenever a signal with the same type passes through, before forwarding them to downstream.
final @NonNull Flowable<T>	Flowable.doOnEach(@NonNull Consumer<@NonNull ? super Notification<@NonNull T>> onNotification)	Invokes a Consumer with a Notification instances matching the signals emitted by the current Flowable before they are forwarded to the downstream.
final @NonNull Flowable<T>	Flowable.doOnEach(@NonNull org.reactivestreams.Subscriber<? super @NonNull T> subscriber)	Calls the appropriate methods of the given Subscriber when the current Flowable signals events before forwarding it to the downstream.
final @NonNull Flowable<T>	Flowable.doOnError(@NonNull Consumer<? super Throwable> onError)	Calls the given Consumer with the error Throwable if the current Flowable failed before forwarding it to the downstream.
final @NonNull Flowable<T>	Flowable.doOnLifecycle(@NonNull Consumer<? super org.reactivestreams.Subscription> onSubscribe, @NonNull LongConsumer onRequest, @NonNull Action onCancel)	Calls the appropriate onXXX method (shared between all Subscribers) for the lifecycle events of the sequence (subscription, cancellation, requesting).
final @NonNull Flowable<T>	Flowable.doOnNext(@NonNull Consumer<? super @NonNull T> onNext)	Calls the given Consumer with the value emitted by the current Flowable before forwarding it to the downstream.
final @NonNull Flowable<T>	Flowable.doOnRequest(@NonNull LongConsumer onRequest)	Calls the given LongConsumer with the request amount from the downstream before forwarding it to the current Flowable.
final @NonNull Flowable<T>	Flowable.doOnSubscribe(@NonNull Consumer<? super org.reactivestreams.Subscription> onSubscribe)	Calls the given Consumer with the Subscription provided by the current Flowable upon subscription from the downstream before forwarding it to the subscriber's onSubscribe method.
final @NonNull Flowable<T>	Flowable.doOnTerminate(@NonNull Action onTerminate)	Calls the given Action when the current Flowable completes normally or with an error before those signals are forwarded to the downstream.
static <@NonNull T> @NonNull Flowable<T>	Flowable.empty()	Returns a Flowable that emits no items to the Subscriber and immediately invokes its onComplete method.
static <@NonNull T> @NonNull Flowable<T>	Flowable.error(@NonNull Supplier<? extends @NonNull Throwable> supplier)	Returns a Flowable that invokes a Subscriber's onError method when the Subscriber subscribes to it.
static <@NonNull T> @NonNull Flowable<T>	Flowable.error(@NonNull Throwable throwable)	Returns a Flowable that invokes a Subscriber's onError method when the Subscriber subscribes to it.
final @NonNull Flowable<T>	Flowable.filter(@NonNull Predicate<? super @NonNull T> predicate)	Filters items emitted by the current Flowable by only emitting those that satisfy a specified predicate.
final <@NonNull R> @NonNull Flowable<R>	Flowable.flatMap(@NonNull Function<? super @NonNull T,@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> mapper)	Returns a Flowable that emits items based on applying a function that you supply to each item emitted by the current Flowable, where that function returns a Publisher, and then merging those resulting Publishers and emitting the results of this merger.
final <@NonNull R> @NonNull Flowable<R>	Flowable.flatMap(@NonNull Function<? super @NonNull T,@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> mapper, boolean delayErrors)	Returns a Flowable that emits items based on applying a function that you supply to each item emitted by the current Flowable, where that function returns a Publisher, and then merging those resulting Publishers and emitting the results of this merger.
final <@NonNull R> @NonNull Flowable<R>	Flowable.flatMap(@NonNull Function<? super @NonNull T,@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> mapper, boolean delayErrors, int maxConcurrency)	Returns a Flowable that emits items based on applying a function that you supply to each item emitted by the current Flowable, where that function returns a Publisher, and then merging those resulting Publishers and emitting the results of this merger, while limiting the maximum number of concurrent subscriptions to these Publishers.
final <@NonNull R> @NonNull Flowable<R>	Flowable.flatMap(@NonNull Function<? super @NonNull T,@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> mapper, boolean delayErrors, int maxConcurrency, int bufferSize)	Returns a Flowable that emits items based on applying a function that you supply to each item emitted by the current Flowable, where that function returns a Publisher, and then merging those resulting Publishers and emitting the results of this merger, while limiting the maximum number of concurrent subscriptions to these Publishers.
final <@NonNull R> @NonNull Flowable<R>	Flowable.flatMap(@NonNull Function<? super @NonNull T,@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> mapper, int maxConcurrency)	Returns a Flowable that emits items based on applying a function that you supply to each item emitted by the current Flowable, where that function returns a Publisher, and then merging those resulting Publishers and emitting the results of this merger, while limiting the maximum number of concurrent subscriptions to these Publishers.
final <@NonNull R> @NonNull Flowable<R>	Flowable.flatMap(@NonNull Function<? super @NonNull T,@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> onNextMapper, @NonNull Function<? super Throwable,@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> onErrorMapper, @NonNull Supplier<? extends org.reactivestreams.Publisher<? extends @NonNull R>> onCompleteSupplier)	Returns a Flowable that applies a function to each item emitted or notification raised by the current Flowable and then flattens the Publishers returned from these functions and emits the resulting items.
final <@NonNull R> @NonNull Flowable<R>	Flowable.flatMap(@NonNull Function<? super @NonNull T,@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> onNextMapper, @NonNull Function<Throwable,@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> onErrorMapper, @NonNull Supplier<? extends org.reactivestreams.Publisher<? extends @NonNull R>> onCompleteSupplier, int maxConcurrency)	Returns a Flowable that applies a function to each item emitted or notification raised by the current Flowable and then flattens the Publishers returned from these functions and emits the resulting items, while limiting the maximum number of concurrent subscriptions to these Publishers.
final <@NonNull U, @NonNull R> @NonNull Flowable<R>	Flowable.flatMap(@NonNull Function<? super @NonNull T,@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull U>> mapper, @NonNull BiFunction<? super @NonNull T,? super @NonNull U,? extends @NonNull R> combiner)	Returns a Flowable that emits the results of a specified function to the pair of values emitted by the current Flowable and a specified collection Publisher.
final <@NonNull U, @NonNull R> @NonNull Flowable<R>	Flowable.flatMap(@NonNull Function<? super @NonNull T,@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull U>> mapper, @NonNull BiFunction<? super @NonNull T,? super @NonNull U,? extends @NonNull R> combiner, boolean delayErrors)	Returns a Flowable that emits the results of a specified function to the pair of values emitted by the current Flowable and a specified inner Publisher.
final <@NonNull U, @NonNull R> @NonNull Flowable<R>	Flowable.flatMap(@NonNull Function<? super @NonNull T,@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull U>> mapper, @NonNull BiFunction<? super @NonNull T,? super @NonNull U,? extends @NonNull R> combiner, boolean delayErrors, int maxConcurrency)	Returns a Flowable that emits the results of a specified function to the pair of values emitted by the current Flowable and a specified collection Publisher, while limiting the maximum number of concurrent subscriptions to these Publishers.
final <@NonNull U, @NonNull R> @NonNull Flowable<R>	Flowable.flatMap(@NonNull Function<? super @NonNull T,@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull U>> mapper, @NonNull BiFunction<? super @NonNull T,? super @NonNull U,? extends @NonNull R> combiner, boolean delayErrors, int maxConcurrency, int bufferSize)	Returns a Flowable that emits the results of a specified function to the pair of values emitted by the current Flowable and a specified collection Publisher, while limiting the maximum number of concurrent subscriptions to these Publishers.
final <@NonNull U, @NonNull R> @NonNull Flowable<R>	Flowable.flatMap(@NonNull Function<? super @NonNull T,@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull U>> mapper, @NonNull BiFunction<? super @NonNull T,? super @NonNull U,? extends @NonNull R> combiner, int maxConcurrency)	Returns a Flowable that emits the results of a specified function to the pair of values emitted by the current Flowable and a specified collection Publisher, while limiting the maximum number of concurrent subscriptions to these Publishers.
final <@NonNull U> @NonNull Flowable<U>	Flowable.flatMapIterable(@NonNull Function<? super @NonNull T,@NonNull ? extends Iterable<? extends @NonNull U>> mapper)	Merges Iterables generated by a mapper Function for each individual item emitted by the current Flowable into a single Flowable sequence.
final <@NonNull U> @NonNull Flowable<U>	Flowable.flatMapIterable(@NonNull Function<? super @NonNull T,@NonNull ? extends Iterable<? extends @NonNull U>> mapper, int bufferSize)	Merges Iterables generated by a mapper Function for each individual item emitted by the current Flowable into a single Flowable sequence.
final <@NonNull U, @NonNull V> @NonNull Flowable<V>	Flowable.flatMapIterable(@NonNull Function<? super @NonNull T,@NonNull ? extends Iterable<? extends @NonNull U>> mapper, @NonNull BiFunction<? super @NonNull T,? super @NonNull U,? extends @NonNull V> combiner)	Merges Iterables generated by a mapper Function for each individual item emitted by the current Flowable into a single Flowable sequence where the resulting items will be the combination of the original item and each inner item of the respective Iterable as returned by the resultSelector BiFunction.
final <@NonNull U, @NonNull V> @NonNull Flowable<V>	Flowable.flatMapIterable(@NonNull Function<? super @NonNull T,@NonNull ? extends Iterable<? extends @NonNull U>> mapper, @NonNull BiFunction<? super @NonNull T,? super @NonNull U,? extends @NonNull V> combiner, int prefetch)	Merges Iterables generated by a mapper Function for each individual item emitted by the current Flowable into a single Flowable sequence where the resulting items will be the combination of the original item and each inner item of the respective Iterable as returned by the resultSelector BiFunction.
final <@NonNull R> @NonNull Flowable<R>	Flowable.flatMapMaybe(@NonNull Function<? super @NonNull T,? extends MaybeSource<? extends @NonNull R>> mapper)	Maps each element of the upstream Flowable into MaybeSources, subscribes to all of them and merges their onSuccess values, in no particular order, into a single Flowable sequence.
final <@NonNull R> @NonNull Flowable<R>	Flowable.flatMapMaybe(@NonNull Function<? super @NonNull T,? extends MaybeSource<? extends @NonNull R>> mapper, boolean delayErrors, int maxConcurrency)	Maps each element of the upstream Flowable into MaybeSources, subscribes to at most maxConcurrency MaybeSources at a time and merges their onSuccess values, in no particular order, into a single Flowable sequence, optionally delaying all errors.
final <@NonNull R> @NonNull Flowable<R>	Maybe.flatMapPublisher(@NonNull Function<? super @NonNull T,@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> mapper)	Returns a Flowable that emits items based on applying a specified function to the item emitted by the current Maybe, where that function returns a Publisher.
final <@NonNull R> @NonNull Flowable<R>	Single.flatMapPublisher(@NonNull Function<? super @NonNull T,@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> mapper)	Returns a Flowable that emits items based on applying a specified function to the item emitted by the current Single, where that function returns a Publisher.
final <@NonNull R> @NonNull Flowable<R>	Flowable.flatMapSingle(@NonNull Function<? super @NonNull T,? extends SingleSource<? extends @NonNull R>> mapper)	Maps each element of the upstream Flowable into SingleSources, subscribes to all of them and merges their onSuccess values, in no particular order, into a single Flowable sequence.
final <@NonNull R> @NonNull Flowable<R>	Flowable.flatMapSingle(@NonNull Function<? super @NonNull T,? extends SingleSource<? extends @NonNull R>> mapper, boolean delayErrors, int maxConcurrency)	Maps each element of the upstream Flowable into SingleSources, subscribes to at most maxConcurrency SingleSources at a time and merges their onSuccess values, in no particular order, into a single Flowable sequence, optionally delaying all errors.
final <@NonNull R> @NonNull Flowable<R>	Flowable.flatMapStream(@NonNull Function<? super @NonNull T,@NonNull ? extends Stream<? extends @NonNull R>> mapper)	Maps each upstream item into a Stream and emits the Stream's items to the downstream in a sequential fashion.
final <@NonNull R> @NonNull Flowable<R>	Flowable.flatMapStream(@NonNull Function<? super @NonNull T,@NonNull ? extends Stream<? extends @NonNull R>> mapper, int prefetch)	Maps each upstream item into a Stream and emits the Stream's items to the downstream in a sequential fashion.
final <@NonNull U> @NonNull Flowable<U>	Maybe.flattenAsFlowable(@NonNull Function<? super @NonNull T,@NonNull ? extends Iterable<? extends @NonNull U>> mapper)	Maps the success value of the current Maybe into an Iterable and emits its items as a Flowable sequence.
final <@NonNull U> @NonNull Flowable<U>	Single.flattenAsFlowable(@NonNull Function<? super @NonNull T,@NonNull ? extends Iterable<? extends @NonNull U>> mapper)	Maps the success value of the current Single into an Iterable and emits its items as a Flowable sequence.
final <@NonNull R> @NonNull Flowable<R>	Maybe.flattenStreamAsFlowable(@NonNull Function<? super @NonNull T,@NonNull ? extends Stream<? extends @NonNull R>> mapper)	Maps the upstream succecss value into a Java Stream and emits its items to the downstream consumer as a Flowable.
final <@NonNull R> @NonNull Flowable<R>	Single.flattenStreamAsFlowable(@NonNull Function<? super @NonNull T,@NonNull ? extends Stream<? extends @NonNull R>> mapper)	Maps the upstream succecss value into a Java Stream and emits its items to the downstream consumer as a Flowable.
static <@NonNull T> @NonNull Flowable<T>	Flowable.fromAction(@NonNull Action action)	Returns a Flowable instance that runs the given Action for each Subscriber and emits either its exception or simply completes.
static <@NonNull T> @NonNull Flowable<T>	Flowable.fromArray(@NonNull T... items)	Converts an array into a Publisher that emits the items in the array.
static <@NonNull T> @NonNull Flowable<T>	Flowable.fromCallable(@NonNull Callable<? extends @NonNull T> callable)	Returns a Flowable that, when a Subscriber subscribes to it, invokes a function you specify and then emits the value returned from that function.
static <@NonNull T> @NonNull Flowable<T>	Flowable.fromCompletable(@NonNull CompletableSource completableSource)	Wraps a CompletableSource into a Flowable.
static <@NonNull T> @NonNull Flowable<@NonNull T>	Flowable.fromCompletionStage(@NonNull CompletionStage<@NonNull T> stage)	Signals the completion value or error of the given (hot) CompletionStage-based asynchronous calculation.
static <@NonNull T> @NonNull Flowable<T>	Flowable.fromFuture(@NonNull Future<? extends @NonNull T> future)	Converts a Future into a Publisher.
static <@NonNull T> @NonNull Flowable<T>	Flowable.fromFuture(@NonNull Future<? extends @NonNull T> future, long timeout, @NonNull TimeUnit unit)	Converts a Future into a Publisher, with a timeout on the Future.
static <@NonNull T> @NonNull Flowable<T>	Flowable.fromIterable(@NonNull Iterable<? extends @NonNull T> source)	Converts an Iterable sequence into a Publisher that emits the items in the sequence.
static <@NonNull T> @NonNull Flowable<T>	Flowable.fromMaybe(@NonNull MaybeSource<@NonNull T> maybe)	Returns a Flowable instance that when subscribed to, subscribes to the MaybeSource instance and emits onSuccess as a single item or forwards any onComplete or onError signal.
static <@NonNull T> @NonNull Flowable<T>	Flowable.fromObservable(@NonNull ObservableSource<@NonNull T> source, @NonNull BackpressureStrategy strategy)	Converts the given ObservableSource into a Flowable by applying the specified backpressure strategy.
static <@NonNull T> @NonNull Flowable<@NonNull T>	Flowable.fromOptional(@NonNull Optional<@NonNull T> optional)	Converts the existing value of the provided optional into a just(Object) or an empty optional into an empty() Flowable instance.
static <@NonNull T> @NonNull Flowable<T>	Flowable.fromPublisher(@NonNull org.reactivestreams.Publisher<? extends @NonNull T> publisher)	Converts an arbitrary Reactive Streams Publisher into a Flowable if not already a Flowable.
static <@NonNull T> @NonNull Flowable<T>	Flowable.fromRunnable(@NonNull Runnable run)	Returns a Flowable instance that runs the given Runnable for each Subscriber and emits either its unchecked exception or simply completes.
static <@NonNull T> @NonNull Flowable<T>	Flowable.fromSingle(@NonNull SingleSource<@NonNull T> source)	Returns a Flowable instance that when subscribed to, subscribes to the SingleSource instance and emits onSuccess as a single item or forwards the onError signal.
static <@NonNull T> @NonNull Flowable<@NonNull T>	Flowable.fromStream(@NonNull Stream<@NonNull T> stream)	Converts a Stream into a finite Flowable and emits its items in the sequence.
static <@NonNull T> @NonNull Flowable<T>	Flowable.fromSupplier(@NonNull Supplier<? extends @NonNull T> supplier)	Returns a Flowable that, when a Subscriber subscribes to it, invokes a supplier function you specify and then emits the value returned from that function.
static <@NonNull T> @NonNull Flowable<T>	Flowable.generate(@NonNull Consumer<@NonNull Emitter<@NonNull T>> generator)	Returns a cold, synchronous, stateless and backpressure-aware generator of values.
static <@NonNull T, @NonNull S> @NonNull Flowable<T>	Flowable.generate(@NonNull Supplier<@NonNull S> initialState, @NonNull BiConsumer<@NonNull S,Emitter<@NonNull T>> generator)	Returns a cold, synchronous, stateful and backpressure-aware generator of values.
static <@NonNull T, @NonNull S> @NonNull Flowable<T>	Flowable.generate(@NonNull Supplier<@NonNull S> initialState, @NonNull BiConsumer<@NonNull S,Emitter<@NonNull T>> generator, @NonNull Consumer<? super @NonNull S> disposeState)	Returns a cold, synchronous, stateful and backpressure-aware generator of values.
static <@NonNull T, @NonNull S> @NonNull Flowable<T>	Flowable.generate(@NonNull Supplier<@NonNull S> initialState, @NonNull BiFunction<@NonNull S,@NonNull Emitter<@NonNull T>,@NonNull S> generator)	Returns a cold, synchronous, stateful and backpressure-aware generator of values.
static <@NonNull T, @NonNull S> @NonNull Flowable<T>	Flowable.generate(@NonNull Supplier<@NonNull S> initialState, @NonNull BiFunction<@NonNull S,@NonNull Emitter<@NonNull T>,@NonNull S> generator, @NonNull Consumer<? super @NonNull S> disposeState)	Returns a cold, synchronous, stateful and backpressure-aware generator of values.
final <@NonNull K> @NonNull Flowable<GroupedFlowable<K,T>>	Flowable.groupBy(@NonNull Function<? super @NonNull T,? extends @NonNull K> keySelector)	Groups the items emitted by the current Flowable according to a specified criterion, and emits these grouped items as GroupedFlowables.
final <@NonNull K> @NonNull Flowable<GroupedFlowable<K,T>>	Flowable.groupBy(@NonNull Function<? super @NonNull T,? extends @NonNull K> keySelector, boolean delayError)	Groups the items emitted by the current Flowable according to a specified criterion, and emits these grouped items as GroupedFlowables.
final <@NonNull K, @NonNull V> @NonNull Flowable<GroupedFlowable<K,V>>	Flowable.groupBy(@NonNull Function<? super @NonNull T,? extends @NonNull K> keySelector, @NonNull Function<? super @NonNull T,? extends @NonNull V> valueSelector)	Groups the items emitted by the current Flowable according to a specified criterion, and emits these grouped items as GroupedFlowables.
final <@NonNull K, @NonNull V> @NonNull Flowable<GroupedFlowable<K,V>>	Flowable.groupBy(@NonNull Function<? super @NonNull T,? extends @NonNull K> keySelector, @NonNull Function<? super @NonNull T,? extends @NonNull V> valueSelector, boolean delayError)	Groups the items emitted by the current Flowable according to a specified criterion, and emits these grouped items as GroupedFlowables.
final <@NonNull K, @NonNull V> @NonNull Flowable<GroupedFlowable<K,V>>	Flowable.groupBy(@NonNull Function<? super @NonNull T,? extends @NonNull K> keySelector, @NonNull Function<? super @NonNull T,? extends @NonNull V> valueSelector, boolean delayError, int bufferSize)	Groups the items emitted by the current Flowable according to a specified criterion, and emits these grouped items as GroupedFlowables.
final <@NonNull K, @NonNull V> @NonNull Flowable<GroupedFlowable<K,V>>	Flowable.groupBy(@NonNull Function<? super @NonNull T,? extends @NonNull K> keySelector, @NonNull Function<? super @NonNull T,? extends @NonNull V> valueSelector, boolean delayError, int bufferSize, @NonNull Function<? super Consumer<Object>,? extends Map<@NonNull K,Object>> evictingMapFactory)	Groups the items emitted by the current Flowable according to a specified criterion, and emits these grouped items as GroupedFlowables.
final <@NonNull TRight, @NonNull TLeftEnd, @NonNull TRightEnd, @NonNull R> @NonNull Flowable<R>	Flowable.groupJoin(@NonNull org.reactivestreams.Publisher<? extends @NonNull TRight> other, @NonNull Function<? super @NonNull T,@NonNull ? extends org.reactivestreams.Publisher<@NonNull TLeftEnd>> leftEnd, @NonNull Function<? super @NonNull TRight,@NonNull ? extends org.reactivestreams.Publisher<@NonNull TRightEnd>> rightEnd, @NonNull BiFunction<? super @NonNull T,? super Flowable<@NonNull TRight>,? extends @NonNull R> resultSelector)	Returns a Flowable that correlates two Publishers when they overlap in time and groups the results.
final @NonNull Flowable<T>	Flowable.hide()	Hides the identity of this Flowable and its Subscription.
static @NonNull Flowable<Long>	Flowable.interval(long initialDelay, long period, @NonNull TimeUnit unit)	Returns a Flowable that emits a 0L after the initialDelay and ever-increasing numbers after each period of time thereafter.
static @NonNull Flowable<Long>	Flowable.interval(long initialDelay, long period, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)	Returns a Flowable that emits a 0L after the initialDelay and ever-increasing numbers after each period of time thereafter, on a specified Scheduler.
static @NonNull Flowable<Long>	Flowable.interval(long period, @NonNull TimeUnit unit)	Returns a Flowable that emits a sequential number every specified interval of time.
static @NonNull Flowable<Long>	Flowable.interval(long period, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)	Returns a Flowable that emits a sequential number every specified interval of time, on a specified Scheduler.
static @NonNull Flowable<Long>	Flowable.intervalRange(long start, long count, long initialDelay, long period, @NonNull TimeUnit unit)	Signals a range of long values, the first after some initial delay and the rest periodically after.
static @NonNull Flowable<Long>	Flowable.intervalRange(long start, long count, long initialDelay, long period, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)	Signals a range of long values, the first after some initial delay and the rest periodically after.
final <@NonNull TRight, @NonNull TLeftEnd, @NonNull TRightEnd, @NonNull R> @NonNull Flowable<R>	Flowable.join(@NonNull org.reactivestreams.Publisher<? extends @NonNull TRight> other, @NonNull Function<? super @NonNull T,@NonNull ? extends org.reactivestreams.Publisher<@NonNull TLeftEnd>> leftEnd, @NonNull Function<? super @NonNull TRight,@NonNull ? extends org.reactivestreams.Publisher<@NonNull TRightEnd>> rightEnd, @NonNull BiFunction<? super @NonNull T,? super @NonNull TRight,? extends @NonNull R> resultSelector)	Correlates the items emitted by two Publishers based on overlapping durations.
static <@NonNull T> @NonNull Flowable<T>	Flowable.just(@NonNull T item)	Returns a Flowable that signals the given (constant reference) item and then completes.
static <@NonNull T> @NonNull Flowable<T>	Flowable.just(@NonNull T item1, @NonNull T item2)	Converts two items into a Publisher that emits those items.
static <@NonNull T> @NonNull Flowable<T>	Flowable.just(@NonNull T item1, @NonNull T item2, @NonNull T item3)	Converts three items into a Publisher that emits those items.
static <@NonNull T> @NonNull Flowable<T>	Flowable.just(@NonNull T item1, @NonNull T item2, @NonNull T item3, @NonNull T item4)	Converts four items into a Publisher that emits those items.
static <@NonNull T> @NonNull Flowable<T>	Flowable.just(@NonNull T item1, @NonNull T item2, @NonNull T item3, @NonNull T item4, @NonNull T item5)	Converts five items into a Publisher that emits those items.
static <@NonNull T> @NonNull Flowable<T>	Flowable.just(@NonNull T item1, @NonNull T item2, @NonNull T item3, @NonNull T item4, @NonNull T item5, @NonNull T item6)	Converts six items into a Publisher that emits those items.
static <@NonNull T> @NonNull Flowable<T>	Flowable.just(@NonNull T item1, @NonNull T item2, @NonNull T item3, @NonNull T item4, @NonNull T item5, @NonNull T item6, @NonNull T item7)	Converts seven items into a Publisher that emits those items.
static <@NonNull T> @NonNull Flowable<T>	Flowable.just(@NonNull T item1, @NonNull T item2, @NonNull T item3, @NonNull T item4, @NonNull T item5, @NonNull T item6, @NonNull T item7, @NonNull T item8)	Converts eight items into a Publisher that emits those items.
static <@NonNull T> @NonNull Flowable<T>	Flowable.just(@NonNull T item1, @NonNull T item2, @NonNull T item3, @NonNull T item4, @NonNull T item5, @NonNull T item6, @NonNull T item7, @NonNull T item8, @NonNull T item9)	Converts nine items into a Publisher that emits those items.
static <@NonNull T> @NonNull Flowable<T>	Flowable.just(@NonNull T item1, @NonNull T item2, @NonNull T item3, @NonNull T item4, @NonNull T item5, @NonNull T item6, @NonNull T item7, @NonNull T item8, @NonNull T item9, @NonNull T item10)	Converts ten items into a Publisher that emits those items.
final <@NonNull R> @NonNull Flowable<R>	Flowable.lift(@NonNull FlowableOperator<? extends @NonNull R,? super @NonNull T> lifter)	This method requires advanced knowledge about building operators, please consider other standard composition methods first; Returns a Flowable which, when subscribed to, invokes the apply(Subscriber) method of the provided FlowableOperator for each individual downstream Subscriber and allows the insertion of a custom operator by accessing the downstream's Subscriber during this subscription phase and providing a new Subscriber, containing the custom operator's intended business logic, that will be used in the subscription process going further upstream.
final <@NonNull R> @NonNull Flowable<R>	Flowable.map(@NonNull Function<? super @NonNull T,? extends @NonNull R> mapper)	Returns a Flowable that applies a specified function to each item emitted by the current Flowable and emits the results of these function applications.
final <@NonNull R> @NonNull Flowable<R>	Flowable.mapOptional(@NonNull Function<? super @NonNull T,@NonNull Optional<? extends @NonNull R>> mapper)	Maps each upstream value into an Optional and emits the contained item if not empty.
final @NonNull Flowable<Notification<T>>	Flowable.materialize()	Returns a Flowable that represents all of the emissions and notifications from the current Flowable into emissions marked with their original types within Notification objects.
static <@NonNull T> @NonNull Flowable<T>	Flowable.merge(@NonNull Iterable<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources)	Flattens an Iterable of Publishers into one Publisher, without any transformation.
static <@NonNull T> @NonNull Flowable<T>	Flowable.merge(@NonNull Iterable<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources, int maxConcurrency)	Flattens an Iterable of Publishers into one Publisher, without any transformation, while limiting the number of concurrent subscriptions to these Publishers.
static <@NonNull T> @NonNull Flowable<T>	Flowable.merge(@NonNull Iterable<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources, int maxConcurrency, int bufferSize)	Flattens an Iterable of Publishers into one Publisher, without any transformation, while limiting the number of concurrent subscriptions to these Publishers.
static <@NonNull T> @NonNull Flowable<T>	Flowable.merge(@NonNull org.reactivestreams.Publisher<? extends @NonNull T> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T> source2)	Flattens two Publishers into a single Publisher, without any transformation.
static <@NonNull T> @NonNull Flowable<T>	Flowable.merge(@NonNull org.reactivestreams.Publisher<? extends @NonNull T> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T> source3)	Flattens three Publishers into a single Publisher, without any transformation.
static <@NonNull T> @NonNull Flowable<T>	Flowable.merge(@NonNull org.reactivestreams.Publisher<? extends @NonNull T> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T> source3, @NonNull org.reactivestreams.Publisher<? extends @NonNull T> source4)	Flattens four Publishers into a single Publisher, without any transformation.
static <@NonNull T> @NonNull Flowable<T>	Flowable.merge(@NonNull org.reactivestreams.Publisher<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources)	Flattens a Publisher that emits Publishers into a single Publisher that emits the items emitted by thos Publishers , without any transformation.
static <@NonNull T> @NonNull Flowable<T>	Flowable.merge(@NonNull org.reactivestreams.Publisher<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources, int maxConcurrency)	Flattens a Publisher that emits Publishers into a single Publisher that emits the items emitted by those Publishers, without any transformation, while limiting the maximum number of concurrent subscriptions to these Publishers.
static <@NonNull T> @NonNull Flowable<T>	Maybe.merge(@NonNull MaybeSource<? extends @NonNull T> source1, @NonNull MaybeSource<? extends @NonNull T> source2)	Flattens two MaybeSources into a single Flowable, without any transformation.
static <@NonNull T> @NonNull Flowable<T>	Maybe.merge(@NonNull MaybeSource<? extends @NonNull T> source1, @NonNull MaybeSource<? extends @NonNull T> source2, @NonNull MaybeSource<? extends @NonNull T> source3)	Flattens three MaybeSources into a single Flowable, without any transformation.
static <@NonNull T> @NonNull Flowable<T>	Maybe.merge(@NonNull MaybeSource<? extends @NonNull T> source1, @NonNull MaybeSource<? extends @NonNull T> source2, @NonNull MaybeSource<? extends @NonNull T> source3, @NonNull MaybeSource<? extends @NonNull T> source4)	Flattens four MaybeSources into a single Flowable, without any transformation.
static <@NonNull T> @NonNull Flowable<T>	Maybe.merge(@NonNull Iterable<@NonNull ? extends MaybeSource<? extends @NonNull T>> sources)	Merges an Iterable sequence of MaybeSource instances into a single Flowable sequence, running all MaybeSources at once.
static <@NonNull T> @NonNull Flowable<T>	Maybe.merge(@NonNull org.reactivestreams.Publisher<@NonNull ? extends MaybeSource<? extends @NonNull T>> sources)	Merges a Publisher sequence of MaybeSource instances into a single Flowable sequence, running all MaybeSources at once.
static <@NonNull T> @NonNull Flowable<T>	Maybe.merge(@NonNull org.reactivestreams.Publisher<@NonNull ? extends MaybeSource<? extends @NonNull T>> sources, int maxConcurrency)	Merges a Publisher sequence of MaybeSource instances into a single Flowable sequence, running at most maxConcurrency MaybeSources at once.
static <@NonNull T> @NonNull Flowable<T>	Single.merge(@NonNull SingleSource<? extends @NonNull T> source1, @NonNull SingleSource<? extends @NonNull T> source2)	Flattens two SingleSources into one Flowable sequence, without any transformation.
static <@NonNull T> @NonNull Flowable<T>	Single.merge(@NonNull SingleSource<? extends @NonNull T> source1, @NonNull SingleSource<? extends @NonNull T> source2, @NonNull SingleSource<? extends @NonNull T> source3)	Flattens three SingleSources into one Flowable sequence, without any transformation.
static <@NonNull T> @NonNull Flowable<T>	Single.merge(@NonNull SingleSource<? extends @NonNull T> source1, @NonNull SingleSource<? extends @NonNull T> source2, @NonNull SingleSource<? extends @NonNull T> source3, @NonNull SingleSource<? extends @NonNull T> source4)	Flattens four SingleSources into one Flowable sequence, without any transformation.
static <@NonNull T> @NonNull Flowable<T>	Single.merge(@NonNull Iterable<@NonNull ? extends SingleSource<? extends @NonNull T>> sources)	Merges an Iterable sequence of SingleSource instances into a single Flowable sequence, running all SingleSources at once.
static <@NonNull T> @NonNull Flowable<T>	Single.merge(@NonNull org.reactivestreams.Publisher<@NonNull ? extends SingleSource<? extends @NonNull T>> sources)	Merges a sequence of SingleSource instances emitted by a Publisher into a single Flowable sequence, running all SingleSources at once.
static <@NonNull T> @NonNull Flowable<T>	Flowable.mergeArray(int maxConcurrency, int bufferSize, @NonNull org.reactivestreams.Publisher<? extends @NonNull T>... sources)	Flattens an array of Publishers into one Publisher, without any transformation, while limiting the number of concurrent subscriptions to these Publishers.
static <@NonNull T> @NonNull Flowable<T>	Flowable.mergeArray(@NonNull org.reactivestreams.Publisher<? extends @NonNull T>... sources)	Flattens an array of Publishers into one Publisher, without any transformation.
static <@NonNull T> @NonNull Flowable<T>	Maybe.mergeArray(MaybeSource<? extends @NonNull T>... sources)	Merges an array of MaybeSource instances into a single Flowable sequence, running all MaybeSources at once.
static <@NonNull T> @NonNull Flowable<T>	Single.mergeArray(SingleSource<? extends @NonNull T>... sources)	Merges an array of SingleSource instances into a single Flowable sequence, running all SingleSources at once.
static <@NonNull T> @NonNull Flowable<T>	Flowable.mergeArrayDelayError(int maxConcurrency, int bufferSize, @NonNull org.reactivestreams.Publisher<? extends @NonNull T>... sources)	Flattens an array of Publishers into one Publisher, in a way that allows a Subscriber to receive all successfully emitted items from each of the source Publishers without being interrupted by an error notification from one of them, while limiting the number of concurrent subscriptions to these Publishers.
static <@NonNull T> @NonNull Flowable<T>	Flowable.mergeArrayDelayError(@NonNull org.reactivestreams.Publisher<? extends @NonNull T>... sources)	Flattens an array of Publishers into one Flowable, in a way that allows a Subscriber to receive all successfully emitted items from each of the source Publishers without being interrupted by an error notification from one of them.
static <@NonNull T> @NonNull Flowable<T>	Maybe.mergeArrayDelayError(@NonNull MaybeSource<? extends @NonNull T>... sources)	Flattens an array of MaybeSources into one Flowable, in a way that allows a subscriber to receive all successfully emitted items from each of the source MaybeSources without being interrupted by an error notification from one of them.
static <@NonNull T> @NonNull Flowable<T>	Single.mergeArrayDelayError(@NonNull SingleSource<? extends @NonNull T>... sources)	Flattens an array of SingleSources into one Flowable, in a way that allows a subscriber to receive all successfully emitted items from each of the source SingleSources without being interrupted by an error notification from one of them.
static <@NonNull T> @NonNull Flowable<T>	Flowable.mergeDelayError(@NonNull Iterable<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources)	Flattens an Iterable of Publishers into one Publisher, in a way that allows a Subscriber to receive all successfully emitted items from each of the source Publishers without being interrupted by an error notification from one of them.
static <@NonNull T> @NonNull Flowable<T>	Flowable.mergeDelayError(@NonNull Iterable<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources, int maxConcurrency)	Flattens an Iterable of Publishers into one Publisher, in a way that allows a Subscriber to receive all successfully emitted items from each of the source Publishers without being interrupted by an error notification from one of them, while limiting the number of concurrent subscriptions to these Publishers.
static <@NonNull T> @NonNull Flowable<T>	Flowable.mergeDelayError(@NonNull Iterable<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources, int maxConcurrency, int bufferSize)	Flattens an Iterable of Publishers into one Publisher, in a way that allows a Subscriber to receive all successfully emitted items from each of the source Publishers without being interrupted by an error notification from one of them, while limiting the number of concurrent subscriptions to these Publishers.
static <@NonNull T> @NonNull Flowable<T>	Flowable.mergeDelayError(@NonNull org.reactivestreams.Publisher<? extends @NonNull T> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T> source2)	Flattens two Publishers into one Publisher, in a way that allows a Subscriber to receive all successfully emitted items from each of the source Publishers without being interrupted by an error notification from one of them.
static <@NonNull T> @NonNull Flowable<T>	Flowable.mergeDelayError(@NonNull org.reactivestreams.Publisher<? extends @NonNull T> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T> source3)	Flattens three Publishers into one Publisher, in a way that allows a Subscriber to receive all successfully emitted items from all of the source Publishers without being interrupted by an error notification from one of them.
static <@NonNull T> @NonNull Flowable<T>	Flowable.mergeDelayError(@NonNull org.reactivestreams.Publisher<? extends @NonNull T> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T> source3, @NonNull org.reactivestreams.Publisher<? extends @NonNull T> source4)	Flattens four Publishers into one Publisher, in a way that allows a Subscriber to receive all successfully emitted items from all of the source Publishers without being interrupted by an error notification from one of them.
static <@NonNull T> @NonNull Flowable<T>	Flowable.mergeDelayError(@NonNull org.reactivestreams.Publisher<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources)	Flattens a Publisher that emits Publishers into one Publisher, in a way that allows a Subscriber to receive all successfully emitted items from all of the source Publishers without being interrupted by an error notification from one of them.
static <@NonNull T> @NonNull Flowable<T>	Flowable.mergeDelayError(@NonNull org.reactivestreams.Publisher<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources, int maxConcurrency)	Flattens a Publisher that emits Publishers into one Publisher, in a way that allows a Subscriber to receive all successfully emitted items from all of the source Publishers without being interrupted by an error notification from one of them, while limiting the number of concurrent subscriptions to these Publishers.
static <@NonNull T> @NonNull Flowable<T>	Maybe.mergeDelayError(@NonNull MaybeSource<? extends @NonNull T> source1, @NonNull MaybeSource<? extends @NonNull T> source2)	Flattens two MaybeSources into one Flowable, in a way that allows a subscriber to receive all successfully emitted items from each of the source MaybeSources without being interrupted by an error notification from one of them.
static <@NonNull T> @NonNull Flowable<T>	Maybe.mergeDelayError(@NonNull MaybeSource<? extends @NonNull T> source1, @NonNull MaybeSource<? extends @NonNull T> source2, @NonNull MaybeSource<? extends @NonNull T> source3)	Flattens three MaybeSource into one Flowable, in a way that allows a subscriber to receive all successfully emitted items from all of the source MaybeSources without being interrupted by an error notification from one of them.
static <@NonNull T> @NonNull Flowable<T>	Maybe.mergeDelayError(@NonNull MaybeSource<? extends @NonNull T> source1, @NonNull MaybeSource<? extends @NonNull T> source2, @NonNull MaybeSource<? extends @NonNull T> source3, @NonNull MaybeSource<? extends @NonNull T> source4)	Flattens four MaybeSources into one Flowable, in a way that allows a subscriber to receive all successfully emitted items from all of the source MaybeSources without being interrupted by an error notification from one of them.
static <@NonNull T> @NonNull Flowable<T>	Maybe.mergeDelayError(@NonNull Iterable<@NonNull ? extends MaybeSource<? extends @NonNull T>> sources)	Flattens an Iterable sequence of MaybeSources into one Flowable, in a way that allows a subscriber to receive all successfully emitted items from each of the source MaybeSources without being interrupted by an error notification from one of them.
static <@NonNull T> @NonNull Flowable<T>	Maybe.mergeDelayError(@NonNull org.reactivestreams.Publisher<@NonNull ? extends MaybeSource<? extends @NonNull T>> sources)	Flattens a Publisher that emits MaybeSources into one Flowable, in a way that allows a subscriber to receive all successfully emitted items from all of the source MaybeSources without being interrupted by an error notification from one of them or even the main Publisher.
static <@NonNull T> @NonNull Flowable<T>	Maybe.mergeDelayError(@NonNull org.reactivestreams.Publisher<@NonNull ? extends MaybeSource<? extends @NonNull T>> sources, int maxConcurrency)	Flattens a Publisher that emits MaybeSources into one Flowable, in a way that allows a subscriber to receive all successfully emitted items from all of the source MaybeSources without being interrupted by an error notification from one of them or even the main Publisher as well as limiting the total number of active MaybeSources.
static <@NonNull T> @NonNull Flowable<T>	Single.mergeDelayError(@NonNull SingleSource<? extends @NonNull T> source1, @NonNull SingleSource<? extends @NonNull T> source2)	Flattens two SingleSources into one Flowable, without any transformation, delaying any error(s) until all sources succeed or fail.
static <@NonNull T> @NonNull Flowable<T>	Single.mergeDelayError(@NonNull SingleSource<? extends @NonNull T> source1, @NonNull SingleSource<? extends @NonNull T> source2, @NonNull SingleSource<? extends @NonNull T> source3)	Flattens two SingleSources into one Flowable, without any transformation, delaying any error(s) until all sources succeed or fail.
static <@NonNull T> @NonNull Flowable<T>	Single.mergeDelayError(@NonNull SingleSource<? extends @NonNull T> source1, @NonNull SingleSource<? extends @NonNull T> source2, @NonNull SingleSource<? extends @NonNull T> source3, @NonNull SingleSource<? extends @NonNull T> source4)	Flattens two SingleSources into one Flowable, without any transformation, delaying any error(s) until all sources succeed or fail.
static <@NonNull T> @NonNull Flowable<T>	Single.mergeDelayError(@NonNull Iterable<@NonNull ? extends SingleSource<? extends @NonNull T>> sources)	Merges an Iterable sequence of SingleSource instances into one Flowable sequence, running all SingleSources at once and delaying any error(s) until all sources succeed or fail.
static <@NonNull T> @NonNull Flowable<T>	Single.mergeDelayError(@NonNull org.reactivestreams.Publisher<@NonNull ? extends SingleSource<? extends @NonNull T>> sources)	Merges a sequence of SingleSource instances emitted by a Publisher into a Flowable sequence, running all SingleSources at once and delaying any error(s) until all sources succeed or fail.
final @NonNull Flowable<T>	Flowable.mergeWith(@NonNull CompletableSource other)	Relays the items of this Flowable and completes only when the other CompletableSource completes as well.
final @NonNull Flowable<T>	Flowable.mergeWith(@NonNull MaybeSource<? extends @NonNull T> other)	Merges the sequence of items of this Flowable with the success value of the other MaybeSource or waits for both to complete normally if the MaybeSource is empty.
final @NonNull Flowable<T>	Flowable.mergeWith(@NonNull SingleSource<? extends @NonNull T> other)	Merges the sequence of items of this Flowable with the success value of the other SingleSource.
final @NonNull Flowable<T>	Flowable.mergeWith(@NonNull org.reactivestreams.Publisher<? extends @NonNull T> other)	Flattens this and another Publisher into a single Publisher, without any transformation.
final @NonNull Flowable<T>	Maybe.mergeWith(@NonNull MaybeSource<? extends @NonNull T> other)	Flattens this Maybe and another MaybeSource into a single Flowable, without any transformation.
final @NonNull Flowable<T>	Single.mergeWith(@NonNull SingleSource<? extends @NonNull T> other)	Flattens this Single and another SingleSource into one Flowable, without any transformation.
static <@NonNull T> @NonNull Flowable<T>	Flowable.never()	Returns a Flowable that never sends any items or notifications to a Subscriber.
final @NonNull Flowable<T>	Flowable.observeOn(@NonNull Scheduler scheduler)	Signals the items and terminal signals of the current Flowable on the specified Scheduler, asynchronously with a bounded buffer of bufferSize() slots.
final @NonNull Flowable<T>	Flowable.observeOn(@NonNull Scheduler scheduler, boolean delayError)	Signals the items and terminal signals of the current Flowable on the specified Scheduler, asynchronously with a bounded buffer and optionally delays onError notifications.
final @NonNull Flowable<T>	Flowable.observeOn(@NonNull Scheduler scheduler, boolean delayError, int bufferSize)	Signals the items and terminal signals of the current Flowable on the specified Scheduler, asynchronously with a bounded buffer of configurable size and optionally delays onError notifications.
final <@NonNull U> @NonNull Flowable<U>	Flowable.ofType(@NonNull Class<@NonNull U> clazz)	Filters the items emitted by the current Flowable, only emitting those of the specified type.
final @NonNull Flowable<T>	Flowable.onBackpressureBuffer()	Buffers an unlimited number of items from the current Flowable and allows it to emit as fast it can while allowing the downstream to consume the items at its own place.
final @NonNull Flowable<T>	Flowable.onBackpressureBuffer(boolean delayError)	Buffers an unlimited number of items from the current Flowable and allows it to emit as fast it can while allowing the downstream to consume the items at its own place, optionally delaying an error until all buffered items have been consumed.
final @NonNull Flowable<T>	Flowable.onBackpressureBuffer(int capacity)	Buffers an limited number of items from the current Flowable and allows it to emit as fast it can while allowing the downstream to consume the items at its own place, however, the resulting Flowable will signal a MissingBackpressureException via onError as soon as the buffer's capacity is exceeded, dropping all undelivered items, and canceling the flow.
final @NonNull Flowable<T>	Flowable.onBackpressureBuffer(int capacity, boolean delayError)	Buffers an limited number of items from the current Flowable and allows it to emit as fast it can while allowing the downstream to consume the items at its own place, however, the resulting Flowable will signal a MissingBackpressureException via onError as soon as the buffer's capacity is exceeded, dropping all undelivered items, and canceling the flow.
final @NonNull Flowable<T>	Flowable.onBackpressureBuffer(int capacity, boolean delayError, boolean unbounded)	Buffers an optionally unlimited number of items from the current Flowable and allows it to emit as fast it can while allowing the downstream to consume the items at its own place.
final @NonNull Flowable<T>	Flowable.onBackpressureBuffer(int capacity, boolean delayError, boolean unbounded, @NonNull Action onOverflow)	Buffers an optionally unlimited number of items from the current Flowable and allows it to emit as fast it can while allowing the downstream to consume the items at its own place.
final @NonNull Flowable<T>	Flowable.onBackpressureBuffer(int capacity, boolean delayError, boolean unbounded, @NonNull Action onOverflow, @NonNull Consumer<? super @NonNull T> onDropped)	Buffers an optionally unlimited number of items from the current Flowable and allows it to emit as fast it can while allowing the downstream to consume the items at its own place.
final @NonNull Flowable<T>	Flowable.onBackpressureBuffer(int capacity, @NonNull Action onOverflow)	Buffers an limited number of items from the current Flowable and allows it to emit as fast it can while allowing the downstream to consume the items at its own place, however, the resulting Flowable will signal a MissingBackpressureException via onError as soon as the buffer's capacity is exceeded, dropping all undelivered items, canceling the flow and calling the onOverflow action.
final @NonNull Flowable<T>	Flowable.onBackpressureBuffer(long capacity, @Nullable Action onOverflow, @NonNull BackpressureOverflowStrategy overflowStrategy)	Buffers an optionally unlimited number of items from the current Flowable and allows it to emit as fast it can while allowing the downstream to consume the items at its own place.
final @NonNull Flowable<T>	Flowable.onBackpressureBuffer(long capacity, @Nullable Action onOverflow, @NonNull BackpressureOverflowStrategy overflowStrategy, @NonNull Consumer<? super @NonNull T> onDropped)	Buffers an optionally unlimited number of items from the current Flowable and allows it to emit as fast it can while allowing the downstream to consume the items at its own place.
final @NonNull Flowable<T>	Flowable.onBackpressureDrop()	Drops items from the current Flowable if the downstream is not ready to receive new items (indicated by a lack of Subscription.request(long) calls from it).
final @NonNull Flowable<T>	Flowable.onBackpressureDrop(@NonNull Consumer<? super @NonNull T> onDrop)	Drops items from the current Flowable if the downstream is not ready to receive new items (indicated by a lack of Subscription.request(long) calls from it) and calls the given Consumer with such dropped items.
final @NonNull Flowable<T>	Flowable.onBackpressureLatest()	Drops all but the latest item emitted by the current Flowable if the downstream is not ready to receive new items (indicated by a lack of Subscription.request(long) calls from it) and emits this latest item when the downstream becomes ready.
final @NonNull Flowable<T>	Flowable.onBackpressureLatest(@NonNull Consumer<? super @NonNull T> onDropped)	Drops all but the latest item emitted by the current Flowable if the downstream is not ready to receive new items (indicated by a lack of Subscription.request(long) calls from it) and emits this latest item when the downstream becomes ready.
final @NonNull Flowable<T>	Flowable.onBackpressureReduce(@NonNull BiFunction<@NonNull T,@NonNull T,@NonNull T> reducer)	Reduces a sequence of two not emitted values via a function into a single value if the downstream is not ready to receive new items (indicated by a lack of Subscription.request(long) calls from it) and emits this latest item when the downstream becomes ready.
final <@NonNull R> @NonNull Flowable<R>	Flowable.onBackpressureReduce(@NonNull Supplier<@NonNull R> supplier, @NonNull BiFunction<@NonNull R,? super @NonNull T,@NonNull R> reducer)	Reduces upstream values into an aggregate value, provided by a supplier and combined via a reducer function, while the downstream is not ready to receive items, then emits this aggregate value when the downstream becomes ready.
final @NonNull Flowable<T>	Flowable.onErrorComplete()	Returns a Flowable instance that if the current Flowable emits an error, it will emit an onComplete and swallow the throwable.
final @NonNull Flowable<T>	Flowable.onErrorComplete(@NonNull Predicate<? super Throwable> predicate)	Returns a Flowable instance that if the current Flowable emits an error and the predicate returns true, it will emit an onComplete and swallow the throwable.
final @NonNull Flowable<T>	Flowable.onErrorResumeNext(@NonNull Function<? super Throwable,@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> fallbackSupplier)	Resumes the flow with a Publisher returned for the failure Throwable of the current Flowable by a function instead of signaling the error via onError.
final @NonNull Flowable<T>	Flowable.onErrorResumeWith(@NonNull org.reactivestreams.Publisher<? extends @NonNull T> fallback)	Resumes the flow with the given Publisher when the current Flowable fails instead of signaling the error via onError.
final @NonNull Flowable<T>	Flowable.onErrorReturn(@NonNull Function<? super Throwable,? extends @NonNull T> itemSupplier)	Ends the flow with a last item returned by a function for the Throwable error signaled by the current Flowable instead of signaling the error via onError.
final @NonNull Flowable<T>	Flowable.onErrorReturnItem(@NonNull T item)	Ends the flow with the given last item when the current Flowable fails instead of signaling the error via onError.
final @NonNull Flowable<T>	Flowable.onTerminateDetach()	Nulls out references to the upstream producer and downstream Subscriber if the sequence is terminated or downstream cancels.
final <@NonNull R> @NonNull Flowable<R>	Flowable.publish(@NonNull Function<? super Flowable<@NonNull T>,@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> selector, int prefetch)	Returns a Flowable that emits the results of invoking a specified selector on items emitted by a ConnectableFlowable that shares a single subscription to the underlying sequence.
final <@NonNull R> @NonNull Flowable<R>	Flowable.publish(@NonNull Function<? super Flowable<@NonNull T>,@NonNull ? extends org.reactivestreams.Publisher<@NonNull R>> selector)	Returns a Flowable that emits the results of invoking a specified selector on items emitted by a ConnectableFlowable that shares a single subscription to the underlying sequence.
static @NonNull Flowable<Integer>	Flowable.range(int start, int count)	Returns a Flowable that emits a sequence of Integers within a specified range.
static @NonNull Flowable<Long>	Flowable.rangeLong(long start, long count)	Returns a Flowable that emits a sequence of Longs within a specified range.
final @NonNull Flowable<T>	Flowable.rebatchRequests(int n)	Requests n initially from the upstream and then 75% of n subsequently after 75% of n values have been emitted to the downstream.
final @NonNull Flowable<T>	Flowable.repeat()	Returns a Flowable that repeats the sequence of items emitted by the current Flowable indefinitely.
final @NonNull Flowable<T>	Flowable.repeat(long times)	Returns a Flowable that repeats the sequence of items emitted by the current Flowable at most count times.
final @NonNull Flowable<T>	Maybe.repeat()	Returns a Flowable that repeats the sequence of items emitted by the current Maybe indefinitely.
final @NonNull Flowable<T>	Maybe.repeat(long times)	Returns a Flowable that repeats the sequence of items emitted by the current Maybe at most count times.
final @NonNull Flowable<T>	Single.repeat()	Repeatedly re-subscribes to the current Single and emits each success value as a Flowable sequence.
final @NonNull Flowable<T>	Single.repeat(long times)	Re-subscribes to the current Single at most the given number of times and emits each success value as a Flowable sequence.
final @NonNull Flowable<T>	Flowable.repeatUntil(@NonNull BooleanSupplier stop)	Returns a Flowable that repeats the sequence of items emitted by the current Flowable until the provided stop function returns true.
final @NonNull Flowable<T>	Maybe.repeatUntil(@NonNull BooleanSupplier stop)	Returns a Flowable that repeats the sequence of items emitted by the current Maybe until the provided stop function returns true.
final @NonNull Flowable<T>	Single.repeatUntil(@NonNull BooleanSupplier stop)	Re-subscribes to the current Single until the given BooleanSupplier returns true and emits the success items as a Flowable sequence.
final @NonNull Flowable<T>	Flowable.repeatWhen(@NonNull Function<? super Flowable<Object>,@NonNull ? extends org.reactivestreams.Publisher<@NonNull ?>> handler)	Returns a Flowable that emits the same values as the current Flowable with the exception of an onComplete.
final @NonNull Flowable<T>	Maybe.repeatWhen(@NonNull Function<? super Flowable<Object>,@NonNull ? extends org.reactivestreams.Publisher<@NonNull ?>> handler)	Returns a Flowable that emits the same values as the current Maybe with the exception of an onComplete.
final @NonNull Flowable<T>	Single.repeatWhen(@NonNull Function<? super Flowable<Object>,@NonNull ? extends org.reactivestreams.Publisher<@NonNull ?>> handler)	Re-subscribes to the current Single if the Publisher returned by the handler function signals a value in response to a value signaled through the Flowable the handler receives.
final <@NonNull R> @NonNull Flowable<R>	Flowable.replay(@NonNull Function<? super Flowable<@NonNull T>,@NonNull ? extends org.reactivestreams.Publisher<@NonNull R>> selector)	Returns a Flowable that emits items that are the results of invoking a specified selector on the items emitted by a ConnectableFlowable that shares a single subscription to the current Flowable.
final <@NonNull R> @NonNull Flowable<R>	Flowable.replay(@NonNull Function<? super Flowable<@NonNull T>,@NonNull ? extends org.reactivestreams.Publisher<@NonNull R>> selector, int bufferSize)	Returns a Flowable that emits items that are the results of invoking a specified selector on items emitted by a ConnectableFlowable that shares a single subscription to the current Flowable, replaying bufferSize notifications.
final <@NonNull R> @NonNull Flowable<R>	Flowable.replay(@NonNull Function<? super Flowable<@NonNull T>,@NonNull ? extends org.reactivestreams.Publisher<@NonNull R>> selector, int bufferSize, boolean eagerTruncate)	Returns a Flowable that emits items that are the results of invoking a specified selector on items emitted by a ConnectableFlowable that shares a single subscription to the current Flowable, replaying bufferSize notifications.
final <@NonNull R> @NonNull Flowable<R>	Flowable.replay(@NonNull Function<? super Flowable<@NonNull T>,@NonNull ? extends org.reactivestreams.Publisher<@NonNull R>> selector, int bufferSize, long time, @NonNull TimeUnit unit)	Returns a Flowable that emits items that are the results of invoking a specified selector on items emitted by a ConnectableFlowable that shares a single subscription to the current Flowable, replaying no more than bufferSize items that were emitted within a specified time window.
final <@NonNull R> @NonNull Flowable<R>	Flowable.replay(@NonNull Function<? super Flowable<@NonNull T>,@NonNull ? extends org.reactivestreams.Publisher<@NonNull R>> selector, int bufferSize, long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)	Returns a Flowable that emits items that are the results of invoking a specified selector on items emitted by a ConnectableFlowable that shares a single subscription to the current Flowable, replaying no more than bufferSize items that were emitted within a specified time window.
final <@NonNull R> @NonNull Flowable<R>	Flowable.replay(@NonNull Function<? super Flowable<@NonNull T>,@NonNull ? extends org.reactivestreams.Publisher<@NonNull R>> selector, int bufferSize, long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean eagerTruncate)	Returns a Flowable that emits items that are the results of invoking a specified selector on items emitted by a ConnectableFlowable that shares a single subscription to the current Flowable, replaying no more than bufferSize items that were emitted within a specified time window.
final <@NonNull R> @NonNull Flowable<R>	Flowable.replay(@NonNull Function<? super Flowable<@NonNull T>,@NonNull ? extends org.reactivestreams.Publisher<@NonNull R>> selector, long time, @NonNull TimeUnit unit)	Returns a Flowable that emits items that are the results of invoking a specified selector on items emitted by a ConnectableFlowable that shares a single subscription to the current Flowable, replaying all items that were emitted within a specified time window.
final <@NonNull R> @NonNull Flowable<R>	Flowable.replay(@NonNull Function<? super Flowable<@NonNull T>,@NonNull ? extends org.reactivestreams.Publisher<@NonNull R>> selector, long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)	Returns a Flowable that emits items that are the results of invoking a specified selector on items emitted by a ConnectableFlowable that shares a single subscription to the current Flowable, replaying all items that were emitted within a specified time window.
final <@NonNull R> @NonNull Flowable<R>	Flowable.replay(@NonNull Function<? super Flowable<@NonNull T>,@NonNull ? extends org.reactivestreams.Publisher<@NonNull R>> selector, long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean eagerTruncate)	Returns a Flowable that emits items that are the results of invoking a specified selector on items emitted by a ConnectableFlowable that shares a single subscription to the current Flowable, replaying all items that were emitted within a specified time window.
final @NonNull Flowable<T>	Flowable.retry()	Returns a Flowable that mirrors the current Flowable, resubscribing to it if it calls onError (infinite retry count).
final @NonNull Flowable<T>	Flowable.retry(long times)	Returns a Flowable that mirrors the current Flowable, resubscribing to it if it calls onError up to a specified number of retries.
final @NonNull Flowable<T>	Flowable.retry(long times, @NonNull Predicate<@NonNull ? super Throwable> predicate)	Retries at most times or until the predicate returns false, whichever happens first.
final @NonNull Flowable<T>	Flowable.retry(@NonNull BiPredicate<@NonNull ? super Integer,@NonNull ? super Throwable> predicate)	Returns a Flowable that mirrors the current Flowable, resubscribing to it if it calls onError and the predicate returns true for that specific exception and retry count.
final @NonNull Flowable<T>	Flowable.retry(@NonNull Predicate<@NonNull ? super Throwable> predicate)	Retries the current Flowable if the predicate returns true.
final @NonNull Flowable<T>	Flowable.retryUntil(@NonNull BooleanSupplier stop)	Retries until the given stop function returns true.
final @NonNull Flowable<T>	Flowable.retryWhen(@NonNull Function<? super Flowable<Throwable>,@NonNull ? extends org.reactivestreams.Publisher<@NonNull ?>> handler)	Returns a Flowable that emits the same values as the current Flowable with the exception of an onError.
final @NonNull Flowable<T>	Flowable.sample(long period, @NonNull TimeUnit unit)	Returns a Flowable that emits the most recently emitted item (if any) emitted by the current Flowable within periodic time intervals.
final @NonNull Flowable<T>	Flowable.sample(long period, @NonNull TimeUnit unit, boolean emitLast)	Returns a Flowable that emits the most recently emitted item (if any) emitted by the current Flowable within periodic time intervals and optionally emit the very last upstream item when the upstream completes.
final @NonNull Flowable<T>	Flowable.sample(long period, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)	Returns a Flowable that emits the most recently emitted item (if any) emitted by the current Flowable within periodic time intervals, where the intervals are defined on a particular Scheduler.
final @NonNull Flowable<T>	Flowable.sample(long period, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean emitLast)	Returns a Flowable that emits the most recently emitted item (if any) emitted by the current Flowable within periodic time intervals, where the intervals are defined on a particular Scheduler and optionally emit the very last upstream item when the upstream completes.
final @NonNull Flowable<T>	Flowable.sample(long period, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean emitLast, @NonNull Consumer<? super @NonNull T> onDropped)	Returns a Flowable that emits the most recently emitted item (if any) emitted by the current Flowable within periodic time intervals, where the intervals are defined on a particular Scheduler and optionally emit the very last upstream item when the upstream completes.
final <@NonNull U> @NonNull Flowable<T>	Flowable.sample(@NonNull org.reactivestreams.Publisher<@NonNull U> sampler)	Returns a Flowable that, when the specified sampler Publisher emits an item or completes, emits the most recently emitted item (if any) emitted by the current Flowable since the previous emission from the sampler Publisher.
final <@NonNull U> @NonNull Flowable<T>	Flowable.sample(@NonNull org.reactivestreams.Publisher<@NonNull U> sampler, boolean emitLast)	Returns a Flowable that, when the specified sampler Publisher emits an item or completes, emits the most recently emitted item (if any) emitted by the current Flowable since the previous emission from the sampler Publisher and optionally emit the very last upstream item when the upstream or other Publisher complete.
final @NonNull Flowable<T>	Flowable.scan(@NonNull BiFunction<@NonNull T,@NonNull T,@NonNull T> accumulator)	Returns a Flowable that emits the first value emitted by the current Flowable, then emits one value for each subsequent value emitted by the current Flowable.
final <@NonNull R> @NonNull Flowable<R>	Flowable.scan(@NonNull R initialValue, @NonNull BiFunction<@NonNull R,? super @NonNull T,@NonNull R> accumulator)	Returns a Flowable that emits the provided initial (seed) value, then emits one value for each value emitted by the current Flowable.
final <@NonNull R> @NonNull Flowable<R>	Flowable.scanWith(@NonNull Supplier<@NonNull R> seedSupplier, @NonNull BiFunction<@NonNull R,? super @NonNull T,@NonNull R> accumulator)	Returns a Flowable that emits the provided initial (seed) value, then emits one value for each value emitted by the current Flowable.
final @NonNull Flowable<T>	Flowable.serialize()	Forces the current Flowable's emissions and notifications to be serialized and for it to obey the Publisher contract in other ways.
final @NonNull Flowable<T>	Flowable.share()	Returns a new Flowable that multicasts (and shares a single subscription to) the current Flowable.
final @NonNull Flowable<T>	Flowable.skip(long count)	Returns a Flowable that skips the first count items emitted by the current Flowable and emits the remainder.
final @NonNull Flowable<T>	Flowable.skip(long time, @NonNull TimeUnit unit)	Returns a Flowable that skips values emitted by the current Flowable before a specified time window elapses.
final @NonNull Flowable<T>	Flowable.skip(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)	Returns a Flowable that skips values emitted by the current Flowable before a specified time window on a specified Scheduler elapses.
final @NonNull Flowable<T>	Flowable.skipLast(int count)	Returns a Flowable that drops a specified number of items from the end of the sequence emitted by the current Flowable.
final @NonNull Flowable<T>	Flowable.skipLast(long time, @NonNull TimeUnit unit)	Returns a Flowable that drops items emitted by the current Flowable during a specified time window before the source completes.
final @NonNull Flowable<T>	Flowable.skipLast(long time, @NonNull TimeUnit unit, boolean delayError)	Returns a Flowable that drops items emitted by the current Flowable during a specified time window before the source completes.
final @NonNull Flowable<T>	Flowable.skipLast(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)	Returns a Flowable that drops items emitted by the current Flowable during a specified time window (defined on a specified scheduler) before the source completes.
final @NonNull Flowable<T>	Flowable.skipLast(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean delayError)	Returns a Flowable that drops items emitted by the current Flowable during a specified time window (defined on a specified scheduler) before the source completes.
final @NonNull Flowable<T>	Flowable.skipLast(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean delayError, int bufferSize)	Returns a Flowable that drops items emitted by the current Flowable during a specified time window (defined on a specified scheduler) before the source completes.
final <@NonNull U> @NonNull Flowable<T>	Flowable.skipUntil(@NonNull org.reactivestreams.Publisher<@NonNull U> other)	Returns a Flowable that skips items emitted by the current Flowable until a second Publisher emits an item.
final @NonNull Flowable<T>	Flowable.skipWhile(@NonNull Predicate<? super @NonNull T> predicate)	Returns a Flowable that skips all items emitted by the current Flowable as long as a specified condition holds true, but emits all further source items as soon as the condition becomes false.
final @NonNull Flowable<T>	Flowable.sorted()	Returns a Flowable that emits the events emitted by source Publisher, in a sorted order.
final @NonNull Flowable<T>	Flowable.sorted(@NonNull Comparator<@NonNull ? super @NonNull T> comparator)	Returns a Flowable that emits the events emitted by source Publisher, in a sorted order based on a specified comparison function.
final <@NonNull T> @NonNull Flowable<T>	Completable.startWith(@NonNull MaybeSource<@NonNull T> other)	Returns a Flowable which first runs the other MaybeSource then the current Completable if the other succeeded or completed normally.
final <@NonNull T> @NonNull Flowable<T>	Completable.startWith(@NonNull SingleSource<@NonNull T> other)	Returns a Flowable which first runs the other SingleSource then the current Completable if the other succeeded normally.
final <@NonNull T> @NonNull Flowable<T>	Completable.startWith(@NonNull org.reactivestreams.Publisher<@NonNull T> other)	Returns a Flowable which first delivers the events of the other Publisher then runs the current Completable.
final @NonNull Flowable<T>	Flowable.startWith(@NonNull CompletableSource other)	Returns a Flowable which first runs the other CompletableSource then the current Flowable if the other completed normally.
final @NonNull Flowable<T>	Flowable.startWith(@NonNull MaybeSource<@NonNull T> other)	Returns a Flowable which first runs the other MaybeSource then the current Flowable if the other succeeded or completed normally.
final @NonNull Flowable<T>	Flowable.startWith(@NonNull SingleSource<@NonNull T> other)	Returns a Flowable which first runs the other SingleSource then the current Flowable if the other succeeded normally.
final @NonNull Flowable<T>	Flowable.startWith(@NonNull org.reactivestreams.Publisher<? extends @NonNull T> other)	Returns a Flowable that emits the items in a specified Publisher before it begins to emit items emitted by the current Flowable.
final @NonNull Flowable<T>	Maybe.startWith(@NonNull CompletableSource other)	Returns a Flowable which first runs the other CompletableSource then the current Maybe if the other completed normally.
final @NonNull Flowable<T>	Maybe.startWith(@NonNull MaybeSource<@NonNull T> other)	Returns a Flowable which first runs the other MaybeSource then the current Maybe if the other succeeded or completed normally.
final @NonNull Flowable<T>	Maybe.startWith(@NonNull SingleSource<@NonNull T> other)	Returns a Flowable which first runs the other SingleSource then the current Maybe if the other succeeded normally.
final @NonNull Flowable<T>	Maybe.startWith(@NonNull org.reactivestreams.Publisher<@NonNull T> other)	Returns a Flowable which first delivers the events of the other Publisher then runs the current Maybe.
final @NonNull Flowable<T>	Single.startWith(@NonNull CompletableSource other)	Returns a Flowable which first runs the other CompletableSource then the current Single if the other completed normally.
final @NonNull Flowable<T>	Single.startWith(@NonNull MaybeSource<@NonNull T> other)	Returns a Flowable which first runs the other MaybeSource then the current Single if the other succeeded or completed normally.
final @NonNull Flowable<T>	Single.startWith(@NonNull SingleSource<@NonNull T> other)	Returns a Flowable which first runs the other SingleSource then the current Single if the other succeeded normally.
final @NonNull Flowable<T>	Single.startWith(@NonNull org.reactivestreams.Publisher<@NonNull T> other)	Returns a Flowable which first delivers the events of the other Publisher then runs the current Single.
final @NonNull Flowable<T>	Flowable.startWithArray(@NonNull T... items)	Returns a Flowable that emits the specified items before it begins to emit items emitted by the current Flowable.
final @NonNull Flowable<T>	Flowable.startWithItem(@NonNull T item)	Returns a Flowable that emits a specified item before it begins to emit items emitted by the current Flowable.
final @NonNull Flowable<T>	Flowable.startWithIterable(@NonNull Iterable<? extends @NonNull T> items)	Returns a Flowable that emits the items in a specified Iterable before it begins to emit items emitted by the current Flowable.
final @NonNull Flowable<T>	Flowable.subscribeOn(@NonNull Scheduler scheduler)	Asynchronously subscribes Subscribers to the current Flowable on the specified Scheduler.
final @NonNull Flowable<T>	Flowable.subscribeOn(@NonNull Scheduler scheduler, boolean requestOn)	Asynchronously subscribes Subscribers to the current Flowable on the specified Scheduler optionally reroutes requests from other threads to the same Scheduler thread.
final @NonNull Flowable<T>	Flowable.switchIfEmpty(@NonNull org.reactivestreams.Publisher<? extends @NonNull T> other)	Returns a Flowable that emits the items emitted by the current Flowable or the items of an alternate Publisher if the current Flowable is empty.
final <@NonNull R> @NonNull Flowable<R>	Flowable.switchMap(@NonNull Function<? super @NonNull T,@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> mapper)	Returns a new Flowable by applying a function that you supply to each item emitted by the current Flowable that returns a Publisher, and then emitting the items emitted by the most recently emitted of these Publishers.
final <@NonNull R> @NonNull Flowable<R>	Flowable.switchMap(@NonNull Function<? super @NonNull T,@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> mapper, int bufferSize)	Returns a new Flowable by applying a function that you supply to each item emitted by the current Flowable that returns a Publisher, and then emitting the items emitted by the most recently emitted of these Publishers.
(package private) <R> Flowable<R>	Flowable.switchMap0(Function<? super @NonNull T,@NonNull ? extends org.reactivestreams.Publisher<? extends R>> mapper, int bufferSize, boolean delayError)
final <@NonNull R> @NonNull Flowable<R>	Flowable.switchMapDelayError(@NonNull Function<? super @NonNull T,@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> mapper)	Returns a new Flowable by applying a function that you supply to each item emitted by the current Flowable that returns a Publisher, and then emitting the items emitted by the most recently emitted of these Publishers and delays any error until all Publishers terminate.
final <@NonNull R> @NonNull Flowable<R>	Flowable.switchMapDelayError(@NonNull Function<? super @NonNull T,@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> mapper, int bufferSize)	Returns a new Flowable by applying a function that you supply to each item emitted by the current Flowable that returns a Publisher, and then emitting the items emitted by the most recently emitted of these Publishers and delays any error until all Publishers terminate.
final <@NonNull R> @NonNull Flowable<R>	Flowable.switchMapMaybe(@NonNull Function<? super @NonNull T,? extends MaybeSource<? extends @NonNull R>> mapper)	Maps the upstream items into MaybeSources and switches (subscribes) to the newer ones while disposing the older ones (and ignoring their signals) and emits the latest success value of the current one if available while failing immediately if this Flowable or any of the active inner MaybeSources fail.
final <@NonNull R> @NonNull Flowable<R>	Flowable.switchMapMaybeDelayError(@NonNull Function<? super @NonNull T,? extends MaybeSource<? extends @NonNull R>> mapper)	Maps the upstream items into MaybeSources and switches (subscribes) to the newer ones while disposing the older ones (and ignoring their signals) and emits the latest success value of the current one if available, delaying errors from this Flowable or the inner MaybeSources until all terminate.
final <@NonNull R> @NonNull Flowable<R>	Flowable.switchMapSingle(@NonNull Function<? super @NonNull T,? extends SingleSource<? extends @NonNull R>> mapper)	Maps the upstream items into SingleSources and switches (subscribes) to the newer ones while disposing the older ones (and ignoring their signals) and emits the latest success value of the current one while failing immediately if this Flowable or any of the active inner SingleSources fail.
final <@NonNull R> @NonNull Flowable<R>	Flowable.switchMapSingleDelayError(@NonNull Function<? super @NonNull T,? extends SingleSource<? extends @NonNull R>> mapper)	Maps the upstream items into SingleSources and switches (subscribes) to the newer ones while disposing the older ones (and ignoring their signals) and emits the latest success value of the current one, delaying errors from this Flowable or the inner SingleSources until all terminate.
static <@NonNull T> @NonNull Flowable<T>	Flowable.switchOnNext(@NonNull org.reactivestreams.Publisher<? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources, int bufferSize)	Converts a Publisher that emits Publishers into a Publisher that emits the items emitted by the most recently emitted of those Publishers.
static <@NonNull T> @NonNull Flowable<T>	Flowable.switchOnNext(@NonNull org.reactivestreams.Publisher<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources)	Converts a Publisher that emits Publishers into a Publisher that emits the items emitted by the most recently emitted of those Publishers.
static <@NonNull T> @NonNull Flowable<T>	Maybe.switchOnNext(@NonNull org.reactivestreams.Publisher<@NonNull ? extends MaybeSource<? extends @NonNull T>> sources)	Switches between MaybeSources emitted by the source Publisher whenever a new MaybeSource is emitted, disposing the previously running MaybeSource, exposing the success items as a Flowable sequence.
static <@NonNull T> @NonNull Flowable<T>	Single.switchOnNext(@NonNull org.reactivestreams.Publisher<@NonNull ? extends SingleSource<? extends @NonNull T>> sources)	Switches between SingleSources emitted by the source Publisher whenever a new SingleSource is emitted, disposing the previously running SingleSource, exposing the success items as a Flowable sequence.
static <@NonNull T> @NonNull Flowable<T>	Flowable.switchOnNextDelayError(@NonNull org.reactivestreams.Publisher<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources)	Converts a Publisher that emits Publishers into a Publisher that emits the items emitted by the most recently emitted of those Publishers and delays any exception until all Publishers terminate.
static <@NonNull T> @NonNull Flowable<T>	Flowable.switchOnNextDelayError(@NonNull org.reactivestreams.Publisher<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources, int prefetch)	Converts a Publisher that emits Publishers into a Publisher that emits the items emitted by the most recently emitted of those Publishers and delays any exception until all Publishers terminate.
static <@NonNull T> @NonNull Flowable<T>	Maybe.switchOnNextDelayError(@NonNull org.reactivestreams.Publisher<@NonNull ? extends MaybeSource<? extends @NonNull T>> sources)	Switches between MaybeSources emitted by the source Publisher whenever a new MaybeSource is emitted, disposing the previously running MaybeSource, exposing the success items as a Flowable sequence and delaying all errors from all of them until all terminate.
static <@NonNull T> @NonNull Flowable<T>	Single.switchOnNextDelayError(@NonNull org.reactivestreams.Publisher<@NonNull ? extends SingleSource<? extends @NonNull T>> sources)	Switches between SingleSources emitted by the source Publisher whenever a new SingleSource is emitted, disposing the previously running SingleSource, exposing the success items as a Flowable sequence and delaying all errors from all of them until all terminate.
final @NonNull Flowable<T>	Flowable.take(long count)	Returns a Flowable that emits only the first count items emitted by the current Flowable.
final @NonNull Flowable<T>	Flowable.take(long time, @NonNull TimeUnit unit)	Returns a Flowable that emits those items emitted by source Publisher before a specified time runs out.
final @NonNull Flowable<T>	Flowable.take(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)	Returns a Flowable that emits those items emitted by source Publisher before a specified time (on a specified Scheduler) runs out.
final @NonNull Flowable<T>	Flowable.takeLast(int count)	Returns a Flowable that emits at most the last count items emitted by the current Flowable.
final @NonNull Flowable<T>	Flowable.takeLast(long count, long time, @NonNull TimeUnit unit)	Returns a Flowable that emits at most a specified number of items from the current Flowable that were emitted in a specified window of time before the current Flowable completed.
final @NonNull Flowable<T>	Flowable.takeLast(long count, long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)	Returns a Flowable that emits at most a specified number of items from the current Flowable that were emitted in a specified window of time before the current Flowable completed, where the timing information is provided by a given Scheduler.
final @NonNull Flowable<T>	Flowable.takeLast(long count, long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean delayError, int bufferSize)	Returns a Flowable that emits at most a specified number of items from the current Flowable that were emitted in a specified window of time before the current Flowable completed, where the timing information is provided by a given Scheduler.
final @NonNull Flowable<T>	Flowable.takeLast(long time, @NonNull TimeUnit unit)	Returns a Flowable that emits the items from the current Flowable that were emitted in a specified window of time before the current Flowable completed.
final @NonNull Flowable<T>	Flowable.takeLast(long time, @NonNull TimeUnit unit, boolean delayError)	Returns a Flowable that emits the items from the current Flowable that were emitted in a specified window of time before the current Flowable completed.
final @NonNull Flowable<T>	Flowable.takeLast(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)	Returns a Flowable that emits the items from the current Flowable that were emitted in a specified window of time before the current Flowable completed, where the timing information is provided by a specified Scheduler.
final @NonNull Flowable<T>	Flowable.takeLast(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean delayError)	Returns a Flowable that emits the items from the current Flowable that were emitted in a specified window of time before the current Flowable completed, where the timing information is provided by a specified Scheduler.
final @NonNull Flowable<T>	Flowable.takeLast(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean delayError, int bufferSize)	Returns a Flowable that emits the items from the current Flowable that were emitted in a specified window of time before the current Flowable completed, where the timing information is provided by a specified Scheduler.
final @NonNull Flowable<T>	Flowable.takeUntil(@NonNull Predicate<? super @NonNull T> stopPredicate)	Returns a Flowable that emits items emitted by the current Flowable, checks the specified predicate for each item, and then completes when the condition is satisfied.
final <@NonNull U> @NonNull Flowable<T>	Flowable.takeUntil(@NonNull org.reactivestreams.Publisher<@NonNull U> other)	Returns a Flowable that emits the items emitted by the current Flowable until a second Publisher emits an item or completes.
final @NonNull Flowable<T>	Flowable.takeWhile(@NonNull Predicate<? super @NonNull T> predicate)	Returns a Flowable that emits items emitted by the current Flowable so long as each item satisfied a specified condition, and then completes as soon as this condition is not satisfied.
final @NonNull Flowable<T>	Flowable.throttleFirst(long windowDuration, @NonNull TimeUnit unit)	Returns a Flowable that emits only the first item emitted by the current Flowable during sequential time windows of a specified duration.
final @NonNull Flowable<T>	Flowable.throttleFirst(long skipDuration, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)	Returns a Flowable that emits only the first item emitted by the current Flowable during sequential time windows of a specified duration, where the windows are managed by a specified Scheduler.
final @NonNull Flowable<T>	Flowable.throttleFirst(long skipDuration, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, @NonNull Consumer<? super @NonNull T> onDropped)	Returns a Flowable that emits only the first item emitted by the current Flowable during sequential time windows of a specified duration, where the windows are managed by a specified Scheduler.
final @NonNull Flowable<T>	Flowable.throttleLast(long intervalDuration, @NonNull TimeUnit unit)	Returns a Flowable that emits only the last item emitted by the current Flowable during sequential time windows of a specified duration.
final @NonNull Flowable<T>	Flowable.throttleLast(long intervalDuration, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)	Returns a Flowable that emits only the last item emitted by the current Flowable during sequential time windows of a specified duration, where the duration is governed by a specified Scheduler.
final @NonNull Flowable<T>	Flowable.throttleLast(long intervalDuration, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, @NonNull Consumer<? super @NonNull T> onDropped)	Returns a Flowable that emits only the last item emitted by the current Flowable during sequential time windows of a specified duration, where the duration is governed by a specified Scheduler.
final @NonNull Flowable<T>	Flowable.throttleLatest(long timeout, @NonNull TimeUnit unit)	Throttles items from the upstream Flowable by first emitting the next item from upstream, then periodically emitting the latest item (if any) when the specified timeout elapses between them.
final @NonNull Flowable<T>	Flowable.throttleLatest(long timeout, @NonNull TimeUnit unit, boolean emitLast)	Throttles items from the upstream Flowable by first emitting the next item from upstream, then periodically emitting the latest item (if any) when the specified timeout elapses between them.
final @NonNull Flowable<T>	Flowable.throttleLatest(long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)	Throttles items from the upstream Flowable by first emitting the next item from upstream, then periodically emitting the latest item (if any) when the specified timeout elapses between them.
final @NonNull Flowable<T>	Flowable.throttleLatest(long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean emitLast)	Throttles items from the upstream Flowable by first emitting the next item from upstream, then periodically emitting the latest item (if any) when the specified timeout elapses between them.
final @NonNull Flowable<T>	Flowable.throttleLatest(long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean emitLast, @NonNull Consumer<? super @NonNull T> onDropped)	Throttles items from the upstream Flowable by first emitting the next item from upstream, then periodically emitting the latest item (if any) when the specified timeout elapses between them, invoking the consumer for any dropped item.
final @NonNull Flowable<T>	Flowable.throttleWithTimeout(long timeout, @NonNull TimeUnit unit)	Returns a Flowable that mirrors the current Flowable, except that it drops items emitted by the current Flowable that are followed by newer items before a timeout value expires.
final @NonNull Flowable<T>	Flowable.throttleWithTimeout(long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)	Returns a Flowable that mirrors the current Flowable, except that it drops items emitted by the current Flowable that are followed by newer items before a timeout value expires on a specified Scheduler.
final @NonNull Flowable<T>	Flowable.throttleWithTimeout(long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, @NonNull Consumer<? super @NonNull T> onDropped)	Returns a Flowable that mirrors the current Flowable, except that it drops items emitted by the current Flowable that are followed by newer items before a timeout value expires on a specified Scheduler.
final @NonNull Flowable<Timed<T>>	Flowable.timeInterval()	Returns a Flowable that emits records of the time interval between consecutive items emitted by the current Flowable.
final @NonNull Flowable<Timed<T>>	Flowable.timeInterval(@NonNull Scheduler scheduler)	Returns a Flowable that emits records of the time interval between consecutive items emitted by the current Flowable, where this interval is computed on a specified Scheduler.
final @NonNull Flowable<Timed<T>>	Flowable.timeInterval(@NonNull TimeUnit unit)	Returns a Flowable that emits records of the time interval between consecutive items emitted by the current Flowable.
final @NonNull Flowable<Timed<T>>	Flowable.timeInterval(@NonNull TimeUnit unit, @NonNull Scheduler scheduler)	Returns a Flowable that emits records of the time interval between consecutive items emitted by the current Flowable, where this interval is computed on a specified Scheduler.
final @NonNull Flowable<T>	Flowable.timeout(long timeout, @NonNull TimeUnit unit)	Returns a Flowable that mirrors the current Flowable but applies a timeout policy for each emitted item.
final @NonNull Flowable<T>	Flowable.timeout(long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)	Returns a Flowable that mirrors the current Flowable but applies a timeout policy for each emitted item, where this policy is governed by a specified Scheduler.
final @NonNull Flowable<T>	Flowable.timeout(long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, @NonNull org.reactivestreams.Publisher<? extends @NonNull T> fallback)	Returns a Flowable that mirrors the current Flowable but applies a timeout policy for each emitted item using a specified Scheduler.
final @NonNull Flowable<T>	Flowable.timeout(long timeout, @NonNull TimeUnit unit, @NonNull org.reactivestreams.Publisher<? extends @NonNull T> fallback)	Returns a Flowable that mirrors the current Flowable but applies a timeout policy for each emitted item.
final <@NonNull V> @NonNull Flowable<T>	Flowable.timeout(@NonNull Function<? super @NonNull T,@NonNull ? extends org.reactivestreams.Publisher<@NonNull V>> itemTimeoutIndicator)	Returns a Flowable that mirrors the current Flowable, but notifies Subscribers of a TimeoutException if an item emitted by the current Flowable doesn't arrive within a window of time after the emission of the previous item, where that period of time is measured by a Publisher that is a function of the previous item.
final <@NonNull V> @NonNull Flowable<T>	Flowable.timeout(@NonNull Function<? super @NonNull T,@NonNull ? extends org.reactivestreams.Publisher<@NonNull V>> itemTimeoutIndicator, @NonNull org.reactivestreams.Publisher<? extends @NonNull T> fallback)	Returns a Flowable that mirrors the current Flowable, but that switches to a fallback Publisher if an item emitted by the current Flowable doesn't arrive within a window of time after the emission of the previous item, where that period of time is measured by a Publisher that is a function of the previous item.
final <@NonNull U, @NonNull V> @NonNull Flowable<T>	Flowable.timeout(@NonNull org.reactivestreams.Publisher<@NonNull U> firstTimeoutIndicator, @NonNull Function<? super @NonNull T,@NonNull ? extends org.reactivestreams.Publisher<@NonNull V>> itemTimeoutIndicator)	Returns a Flowable that mirrors the current Flowable, but notifies Subscribers of a TimeoutException if either the first item emitted by the current Flowable or any subsequent item doesn't arrive within time windows defined by other Publishers.
final <@NonNull U, @NonNull V> @NonNull Flowable<T>	Flowable.timeout(@NonNull org.reactivestreams.Publisher<@NonNull U> firstTimeoutIndicator, @NonNull Function<? super @NonNull T,@NonNull ? extends org.reactivestreams.Publisher<@NonNull V>> itemTimeoutIndicator, @NonNull org.reactivestreams.Publisher<? extends @NonNull T> fallback)	Returns a Flowable that mirrors the current Flowable, but switches to a fallback Publisher if either the first item emitted by the current Flowable or any subsequent item doesn't arrive within time windows defined by other Publishers.
private Flowable<T>	Flowable.timeout0(long timeout, TimeUnit unit, org.reactivestreams.Publisher<? extends @NonNull T> fallback, Scheduler scheduler)
private <@NonNull U, @NonNull V> Flowable<T>	Flowable.timeout0(org.reactivestreams.Publisher<@NonNull U> firstTimeoutIndicator, Function<? super @NonNull T,@NonNull ? extends org.reactivestreams.Publisher<@NonNull V>> itemTimeoutIndicator, org.reactivestreams.Publisher<? extends @NonNull T> fallback)
static @NonNull Flowable<Long>	Flowable.timer(long delay, @NonNull TimeUnit unit)	Returns a Flowable that emits 0L after a specified delay, and then completes.
static @NonNull Flowable<Long>	Flowable.timer(long delay, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)	Returns a Flowable that emits 0L after a specified delay, on a specified Scheduler, and then completes.
final @NonNull Flowable<Timed<T>>	Flowable.timestamp()	Returns a Flowable that emits each item emitted by the current Flowable, wrapped in a Timed object.
final @NonNull Flowable<Timed<T>>	Flowable.timestamp(@NonNull Scheduler scheduler)	Returns a Flowable that emits each item emitted by the current Flowable, wrapped in a Timed object whose timestamps are provided by a specified Scheduler.
final @NonNull Flowable<Timed<T>>	Flowable.timestamp(@NonNull TimeUnit unit)	Returns a Flowable that emits each item emitted by the current Flowable, wrapped in a Timed object.
final @NonNull Flowable<Timed<T>>	Flowable.timestamp(@NonNull TimeUnit unit, @NonNull Scheduler scheduler)	Returns a Flowable that emits each item emitted by the current Flowable, wrapped in a Timed object whose timestamps are provided by a specified Scheduler.
final <@NonNull T> @NonNull Flowable<T>	Completable.toFlowable()	Returns a Flowable which when subscribed to subscribes to this Completable and relays the terminal events to the downstream Subscriber.
final @NonNull Flowable<T>	Maybe.toFlowable()	Converts this Maybe into a backpressure-aware Flowable instance composing cancellation through.
final @NonNull Flowable<T>	Observable.toFlowable(@NonNull BackpressureStrategy strategy)	Converts the current Observable into a Flowable by applying the specified backpressure strategy.
final @NonNull Flowable<T>	Single.toFlowable()	Converts this Single into a Flowable.
static <@NonNull T> @NonNull Flowable<T>	Flowable.unsafeCreate(@NonNull org.reactivestreams.Publisher<@NonNull T> onSubscribe)	Create a Flowable by wrapping a Publisher which has to be implemented according to the Reactive Streams specification by handling backpressure and cancellation correctly; no safeguards are provided by the Flowable itself.
final @NonNull Flowable<T>	Flowable.unsubscribeOn(@NonNull Scheduler scheduler)	Cancels the current Flowable asynchronously by invoking Subscription.cancel() on the specified Scheduler.
static <@NonNull T, @NonNull D> @NonNull Flowable<T>	Flowable.using(@NonNull Supplier<? extends @NonNull D> resourceSupplier, @NonNull Function<? super @NonNull D,@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sourceSupplier, @NonNull Consumer<? super @NonNull D> resourceCleanup)	Constructs a Flowable that creates a dependent resource object, a Publisher with that resource and calls the provided resourceDisposer function if this inner source terminates or the downstream cancels the flow.
static <@NonNull T, @NonNull D> @NonNull Flowable<T>	Flowable.using(@NonNull Supplier<? extends @NonNull D> resourceSupplier, @NonNull Function<? super @NonNull D,@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sourceSupplier, @NonNull Consumer<? super @NonNull D> resourceCleanup, boolean eager)	Constructs a Flowable that creates a dependent resource object, a Publisher with that resource and calls the provided resourceDisposer function if this inner source terminates or the downstream disposes the flow; doing it before these end-states have been reached if eager == true, after otherwise.
final @NonNull Flowable<Flowable<T>>	Flowable.window(long count)	Returns a Flowable that emits windows of items it collects from the current Flowable.
final @NonNull Flowable<Flowable<T>>	Flowable.window(long count, long skip)	Returns a Flowable that emits windows of items it collects from the current Flowable.
final @NonNull Flowable<Flowable<T>>	Flowable.window(long count, long skip, int bufferSize)	Returns a Flowable that emits windows of items it collects from the current Flowable.
final @NonNull Flowable<Flowable<T>>	Flowable.window(long timespan, long timeskip, @NonNull TimeUnit unit)	Returns a Flowable that emits windows of items it collects from the current Flowable.
final @NonNull Flowable<Flowable<T>>	Flowable.window(long timespan, long timeskip, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)	Returns a Flowable that emits windows of items it collects from the current Flowable.
final @NonNull Flowable<Flowable<T>>	Flowable.window(long timespan, long timeskip, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, int bufferSize)	Returns a Flowable that emits windows of items it collects from the current Flowable.
final @NonNull Flowable<Flowable<T>>	Flowable.window(long timespan, @NonNull TimeUnit unit)	Returns a Flowable that emits windows of items it collects from the current Flowable.
final @NonNull Flowable<Flowable<T>>	Flowable.window(long timespan, @NonNull TimeUnit unit, long count)	Returns a Flowable that emits windows of items it collects from the current Flowable.
final @NonNull Flowable<Flowable<T>>	Flowable.window(long timespan, @NonNull TimeUnit unit, long count, boolean restart)	Returns a Flowable that emits windows of items it collects from the current Flowable.
final @NonNull Flowable<Flowable<T>>	Flowable.window(long timespan, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)	Returns a Flowable that emits windows of items it collects from the current Flowable.
final @NonNull Flowable<Flowable<T>>	Flowable.window(long timespan, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, long count)	Returns a Flowable that emits windows of items it collects from the current Flowable.
final @NonNull Flowable<Flowable<T>>	Flowable.window(long timespan, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, long count, boolean restart)	Returns a Flowable that emits windows of items it collects from the current Flowable.
final @NonNull Flowable<Flowable<T>>	Flowable.window(long timespan, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, long count, boolean restart, int bufferSize)	Returns a Flowable that emits windows of items it collects from the current Flowable.
final <@NonNull B> @NonNull Flowable<Flowable<T>>	Flowable.window(@NonNull org.reactivestreams.Publisher<@NonNull B> boundaryIndicator)	Returns a Flowable that emits non-overlapping windows of items it collects from the current Flowable where the boundary of each window is determined by the items emitted from a specified boundary-governing Publisher.
final <@NonNull B> @NonNull Flowable<Flowable<T>>	Flowable.window(@NonNull org.reactivestreams.Publisher<@NonNull B> boundaryIndicator, int bufferSize)	Returns a Flowable that emits non-overlapping windows of items it collects from the current Flowable where the boundary of each window is determined by the items emitted from a specified boundary-governing Publisher.
final <@NonNull U, @NonNull V> @NonNull Flowable<Flowable<T>>	Flowable.window(@NonNull org.reactivestreams.Publisher<@NonNull U> openingIndicator, @NonNull Function<? super @NonNull U,@NonNull ? extends org.reactivestreams.Publisher<@NonNull V>> closingIndicator)	Returns a Flowable that emits windows of items it collects from the current Flowable.
final <@NonNull U, @NonNull V> @NonNull Flowable<Flowable<T>>	Flowable.window(@NonNull org.reactivestreams.Publisher<@NonNull U> openingIndicator, @NonNull Function<? super @NonNull U,@NonNull ? extends org.reactivestreams.Publisher<@NonNull V>> closingIndicator, int bufferSize)	Returns a Flowable that emits windows of items it collects from the current Flowable.
final <@NonNull R> @NonNull Flowable<R>	Flowable.withLatestFrom(@NonNull Iterable<@NonNull ? extends org.reactivestreams.Publisher<@NonNull ?>> others, @NonNull Function<? super Object[],@NonNull R> combiner)	Combines the value emission from the current Flowable with the latest emissions from the other Publishers via a function to produce the output item.
final <@NonNull U, @NonNull R> @NonNull Flowable<R>	Flowable.withLatestFrom(@NonNull org.reactivestreams.Publisher<? extends @NonNull U> other, @NonNull BiFunction<? super @NonNull T,? super @NonNull U,? extends @NonNull R> combiner)	Merges the specified Publisher into the current Flowable sequence by using the resultSelector function only when the current Flowable (this instance) emits an item.
final <@NonNull R> @NonNull Flowable<R>	Flowable.withLatestFrom(@NonNull org.reactivestreams.Publisher<@NonNull ?>[] others, @NonNull Function<? super Object[],@NonNull R> combiner)	Combines the value emission from the current Flowable with the latest emissions from the other Publishers via a function to produce the output item.
final <@NonNull T1, @NonNull T2, @NonNull R> @NonNull Flowable<R>	Flowable.withLatestFrom(@NonNull org.reactivestreams.Publisher<@NonNull T1> source1, @NonNull org.reactivestreams.Publisher<@NonNull T2> source2, @NonNull Function3<? super @NonNull T,? super @NonNull T1,? super @NonNull T2,@NonNull R> combiner)	Combines the value emission from the current Flowable with the latest emissions from the other Publishers via a function to produce the output item.
final <@NonNull T1, @NonNull T2, @NonNull T3, @NonNull R> @NonNull Flowable<R>	Flowable.withLatestFrom(@NonNull org.reactivestreams.Publisher<@NonNull T1> source1, @NonNull org.reactivestreams.Publisher<@NonNull T2> source2, @NonNull org.reactivestreams.Publisher<@NonNull T3> source3, @NonNull Function4<? super @NonNull T,? super @NonNull T1,? super @NonNull T2,? super @NonNull T3,@NonNull R> combiner)	Combines the value emission from the current Flowable with the latest emissions from the other Publishers via a function to produce the output item.
final <@NonNull T1, @NonNull T2, @NonNull T3, @NonNull T4, @NonNull R> @NonNull Flowable<R>	Flowable.withLatestFrom(@NonNull org.reactivestreams.Publisher<@NonNull T1> source1, @NonNull org.reactivestreams.Publisher<@NonNull T2> source2, @NonNull org.reactivestreams.Publisher<@NonNull T3> source3, @NonNull org.reactivestreams.Publisher<@NonNull T4> source4, @NonNull Function5<? super @NonNull T,? super @NonNull T1,? super @NonNull T2,? super @NonNull T3,? super @NonNull T4,@NonNull R> combiner)	Combines the value emission from the current Flowable with the latest emissions from the other Publishers via a function to produce the output item.
static <@NonNull T, @NonNull R> @NonNull Flowable<R>	Flowable.zip(@NonNull Iterable<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources, @NonNull Function<? super Object[],? extends @NonNull R> zipper)	Returns a Flowable that emits the results of a specified combiner function applied to combinations of items emitted, in sequence, by an Iterable of other Publishers.
static <@NonNull T, @NonNull R> @NonNull Flowable<R>	Flowable.zip(@NonNull Iterable<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources, @NonNull Function<? super Object[],? extends @NonNull R> zipper, boolean delayError, int bufferSize)	Returns a Flowable that emits the results of a specified combiner function applied to combinations of items emitted, in sequence, by an Iterable of other Publishers.
static <@NonNull T1, @NonNull T2, @NonNull R> @NonNull Flowable<R>	Flowable.zip(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull BiFunction<? super @NonNull T1,? super @NonNull T2,? extends @NonNull R> zipper)	Returns a Flowable that emits the results of a specified combiner function applied to combinations of two items emitted, in sequence, by two other Publishers.
static <@NonNull T1, @NonNull T2, @NonNull R> @NonNull Flowable<R>	Flowable.zip(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull BiFunction<? super @NonNull T1,? super @NonNull T2,? extends @NonNull R> zipper, boolean delayError)	Returns a Flowable that emits the results of a specified combiner function applied to combinations of two items emitted, in sequence, by two other Publishers.
static <@NonNull T1, @NonNull T2, @NonNull R> @NonNull Flowable<R>	Flowable.zip(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull BiFunction<? super @NonNull T1,? super @NonNull T2,? extends @NonNull R> zipper, boolean delayError, int bufferSize)	Returns a Flowable that emits the results of a specified combiner function applied to combinations of two items emitted, in sequence, by two other Publishers.
static <@NonNull T1, @NonNull T2, @NonNull T3, @NonNull R> @NonNull Flowable<R>	Flowable.zip(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T3> source3, @NonNull Function3<? super @NonNull T1,? super @NonNull T2,? super @NonNull T3,? extends @NonNull R> zipper)	Returns a Flowable that emits the results of a specified combiner function applied to combinations of three items emitted, in sequence, by three other Publishers.
static <@NonNull T1, @NonNull T2, @NonNull T3, @NonNull T4, @NonNull R> @NonNull Flowable<R>	Flowable.zip(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T3> source3, @NonNull org.reactivestreams.Publisher<? extends @NonNull T4> source4, @NonNull Function4<? super @NonNull T1,? super @NonNull T2,? super @NonNull T3,? super @NonNull T4,? extends @NonNull R> zipper)	Returns a Flowable that emits the results of a specified combiner function applied to combinations of four items emitted, in sequence, by four other Publishers.
static <@NonNull T1, @NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull R> @NonNull Flowable<R>	Flowable.zip(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T3> source3, @NonNull org.reactivestreams.Publisher<? extends @NonNull T4> source4, @NonNull org.reactivestreams.Publisher<? extends @NonNull T5> source5, @NonNull Function5<? super @NonNull T1,? super @NonNull T2,? super @NonNull T3,? super @NonNull T4,? super @NonNull T5,? extends @NonNull R> zipper)	Returns a Flowable that emits the results of a specified combiner function applied to combinations of five items emitted, in sequence, by five other Publishers.
static <@NonNull T1, @NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull R> @NonNull Flowable<R>	Flowable.zip(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T3> source3, @NonNull org.reactivestreams.Publisher<? extends @NonNull T4> source4, @NonNull org.reactivestreams.Publisher<? extends @NonNull T5> source5, @NonNull org.reactivestreams.Publisher<? extends @NonNull T6> source6, @NonNull Function6<? super @NonNull T1,? super @NonNull T2,? super @NonNull T3,? super @NonNull T4,? super @NonNull T5,? super @NonNull T6,? extends @NonNull R> zipper)	Returns a Flowable that emits the results of a specified combiner function applied to combinations of six items emitted, in sequence, by six other Publishers.
static <@NonNull T1, @NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull R> @NonNull Flowable<R>	Flowable.zip(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T3> source3, @NonNull org.reactivestreams.Publisher<? extends @NonNull T4> source4, @NonNull org.reactivestreams.Publisher<? extends @NonNull T5> source5, @NonNull org.reactivestreams.Publisher<? extends @NonNull T6> source6, @NonNull org.reactivestreams.Publisher<? extends @NonNull T7> source7, @NonNull Function7<? super @NonNull T1,? super @NonNull T2,? super @NonNull T3,? super @NonNull T4,? super @NonNull T5,? super @NonNull T6,? super @NonNull T7,? extends @NonNull R> zipper)	Returns a Flowable that emits the results of a specified combiner function applied to combinations of seven items emitted, in sequence, by seven other Publishers.
static <@NonNull T1, @NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull T8, @NonNull R> @NonNull Flowable<R>	Flowable.zip(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T3> source3, @NonNull org.reactivestreams.Publisher<? extends @NonNull T4> source4, @NonNull org.reactivestreams.Publisher<? extends @NonNull T5> source5, @NonNull org.reactivestreams.Publisher<? extends @NonNull T6> source6, @NonNull org.reactivestreams.Publisher<? extends @NonNull T7> source7, @NonNull org.reactivestreams.Publisher<? extends @NonNull T8> source8, @NonNull Function8<? super @NonNull T1,? super @NonNull T2,? super @NonNull T3,? super @NonNull T4,? super @NonNull T5,? super @NonNull T6,? super @NonNull T7,? super @NonNull T8,? extends @NonNull R> zipper)	Returns a Flowable that emits the results of a specified combiner function applied to combinations of eight items emitted, in sequence, by eight other Publishers.
static <@NonNull T1, @NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull T8, @NonNull T9, @NonNull R> @NonNull Flowable<R>	Flowable.zip(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T3> source3, @NonNull org.reactivestreams.Publisher<? extends @NonNull T4> source4, @NonNull org.reactivestreams.Publisher<? extends @NonNull T5> source5, @NonNull org.reactivestreams.Publisher<? extends @NonNull T6> source6, @NonNull org.reactivestreams.Publisher<? extends @NonNull T7> source7, @NonNull org.reactivestreams.Publisher<? extends @NonNull T8> source8, @NonNull org.reactivestreams.Publisher<? extends @NonNull T9> source9, @NonNull Function9<? super @NonNull T1,? super @NonNull T2,? super @NonNull T3,? super @NonNull T4,? super @NonNull T5,? super @NonNull T6,? super @NonNull T7,? super @NonNull T8,? super @NonNull T9,? extends @NonNull R> zipper)	Returns a Flowable that emits the results of a specified combiner function applied to combinations of nine items emitted, in sequence, by nine other Publishers.
static <@NonNull T, @NonNull R> @NonNull Flowable<R>	Flowable.zipArray(@NonNull Function<? super Object[],? extends @NonNull R> zipper, boolean delayError, int bufferSize, @NonNull org.reactivestreams.Publisher<? extends @NonNull T>... sources)	Returns a Flowable that emits the results of a specified combiner function applied to combinations of items emitted, in sequence, by an array of other Publishers.
final <@NonNull U, @NonNull R> @NonNull Flowable<R>	Flowable.zipWith(@NonNull Iterable<@NonNull U> other, @NonNull BiFunction<? super @NonNull T,? super @NonNull U,? extends @NonNull R> zipper)	Returns a Flowable that emits items that are the result of applying a specified function to pairs of values, one each from the current Flowable and a specified Iterable sequence.
final <@NonNull U, @NonNull R> @NonNull Flowable<R>	Flowable.zipWith(@NonNull org.reactivestreams.Publisher<? extends @NonNull U> other, @NonNull BiFunction<? super @NonNull T,? super @NonNull U,? extends @NonNull R> zipper)	Returns a Flowable that emits items that are the result of applying a specified function to pairs of values, one each from the current Flowable and another specified Publisher.
final <@NonNull U, @NonNull R> @NonNull Flowable<R>	Flowable.zipWith(@NonNull org.reactivestreams.Publisher<? extends @NonNull U> other, @NonNull BiFunction<? super @NonNull T,? super @NonNull U,? extends @NonNull R> zipper, boolean delayError)	Returns a Flowable that emits items that are the result of applying a specified function to pairs of values, one each from the current Flowable and another specified Publisher.
final <@NonNull U, @NonNull R> @NonNull Flowable<R>	Flowable.zipWith(@NonNull org.reactivestreams.Publisher<? extends @NonNull U> other, @NonNull BiFunction<? super @NonNull T,? super @NonNull U,? extends @NonNull R> zipper, boolean delayError, int bufferSize)	Returns a Flowable that emits items that are the result of applying a specified function to pairs of values, one each from the current Flowable and another specified Publisher.

Methods in io.reactivex.rxjava3.core that return types with arguments of type Flowable

Modifier and Type	Method	Description
final @NonNull Flowable<Flowable<T>>	Flowable.window(long count)	Returns a Flowable that emits windows of items it collects from the current Flowable.
final @NonNull Flowable<Flowable<T>>	Flowable.window(long count, long skip)	Returns a Flowable that emits windows of items it collects from the current Flowable.
final @NonNull Flowable<Flowable<T>>	Flowable.window(long count, long skip, int bufferSize)	Returns a Flowable that emits windows of items it collects from the current Flowable.
final @NonNull Flowable<Flowable<T>>	Flowable.window(long timespan, long timeskip, @NonNull TimeUnit unit)	Returns a Flowable that emits windows of items it collects from the current Flowable.
final @NonNull Flowable<Flowable<T>>	Flowable.window(long timespan, long timeskip, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)	Returns a Flowable that emits windows of items it collects from the current Flowable.
final @NonNull Flowable<Flowable<T>>	Flowable.window(long timespan, long timeskip, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, int bufferSize)	Returns a Flowable that emits windows of items it collects from the current Flowable.
final @NonNull Flowable<Flowable<T>>	Flowable.window(long timespan, @NonNull TimeUnit unit)	Returns a Flowable that emits windows of items it collects from the current Flowable.
final @NonNull Flowable<Flowable<T>>	Flowable.window(long timespan, @NonNull TimeUnit unit, long count)	Returns a Flowable that emits windows of items it collects from the current Flowable.
final @NonNull Flowable<Flowable<T>>	Flowable.window(long timespan, @NonNull TimeUnit unit, long count, boolean restart)	Returns a Flowable that emits windows of items it collects from the current Flowable.
final @NonNull Flowable<Flowable<T>>	Flowable.window(long timespan, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)	Returns a Flowable that emits windows of items it collects from the current Flowable.
final @NonNull Flowable<Flowable<T>>	Flowable.window(long timespan, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, long count)	Returns a Flowable that emits windows of items it collects from the current Flowable.
final @NonNull Flowable<Flowable<T>>	Flowable.window(long timespan, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, long count, boolean restart)	Returns a Flowable that emits windows of items it collects from the current Flowable.
final @NonNull Flowable<Flowable<T>>	Flowable.window(long timespan, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, long count, boolean restart, int bufferSize)	Returns a Flowable that emits windows of items it collects from the current Flowable.
final <@NonNull B> @NonNull Flowable<Flowable<T>>	Flowable.window(@NonNull org.reactivestreams.Publisher<@NonNull B> boundaryIndicator)	Returns a Flowable that emits non-overlapping windows of items it collects from the current Flowable where the boundary of each window is determined by the items emitted from a specified boundary-governing Publisher.
final <@NonNull B> @NonNull Flowable<Flowable<T>>	Flowable.window(@NonNull org.reactivestreams.Publisher<@NonNull B> boundaryIndicator, int bufferSize)	Returns a Flowable that emits non-overlapping windows of items it collects from the current Flowable where the boundary of each window is determined by the items emitted from a specified boundary-governing Publisher.
final <@NonNull U, @NonNull V> @NonNull Flowable<Flowable<T>>	Flowable.window(@NonNull org.reactivestreams.Publisher<@NonNull U> openingIndicator, @NonNull Function<? super @NonNull U,@NonNull ? extends org.reactivestreams.Publisher<@NonNull V>> closingIndicator)	Returns a Flowable that emits windows of items it collects from the current Flowable.
final <@NonNull U, @NonNull V> @NonNull Flowable<Flowable<T>>	Flowable.window(@NonNull org.reactivestreams.Publisher<@NonNull U> openingIndicator, @NonNull Function<? super @NonNull U,@NonNull ? extends org.reactivestreams.Publisher<@NonNull V>> closingIndicator, int bufferSize)	Returns a Flowable that emits windows of items it collects from the current Flowable.

Methods in io.reactivex.rxjava3.core with parameters of type Flowable

Modifier and Type	Method	Description
R	FlowableConverter.apply(@NonNull Flowable<@NonNull T> upstream)	Applies a function to the upstream Flowable and returns a converted value of type R.
@NonNull org.reactivestreams.Publisher<Downstream>	FlowableTransformer.apply(@NonNull Flowable<@NonNull Upstream> upstream)	Applies a function to the upstream Flowable and returns a Publisher with optionally different element type.
private static <T> @NonNull Single<T>	Single.toSingle(@NonNull Flowable<T> source)

Method parameters in io.reactivex.rxjava3.core with type arguments of type Flowable

Modifier and Type	Method	Description
final <@NonNull TRight, @NonNull TLeftEnd, @NonNull TRightEnd, @NonNull R> @NonNull Flowable<R>	Flowable.groupJoin(@NonNull org.reactivestreams.Publisher<? extends @NonNull TRight> other, @NonNull Function<? super @NonNull T,@NonNull ? extends org.reactivestreams.Publisher<@NonNull TLeftEnd>> leftEnd, @NonNull Function<? super @NonNull TRight,@NonNull ? extends org.reactivestreams.Publisher<@NonNull TRightEnd>> rightEnd, @NonNull BiFunction<? super @NonNull T,? super Flowable<@NonNull TRight>,? extends @NonNull R> resultSelector)	Returns a Flowable that correlates two Publishers when they overlap in time and groups the results.
final <@NonNull R> @NonNull Flowable<R>	Flowable.publish(@NonNull Function<? super Flowable<@NonNull T>,@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> selector, int prefetch)	Returns a Flowable that emits the results of invoking a specified selector on items emitted by a ConnectableFlowable that shares a single subscription to the underlying sequence.
final <@NonNull R> @NonNull Flowable<R>	Flowable.publish(@NonNull Function<? super Flowable<@NonNull T>,@NonNull ? extends org.reactivestreams.Publisher<@NonNull R>> selector)	Returns a Flowable that emits the results of invoking a specified selector on items emitted by a ConnectableFlowable that shares a single subscription to the underlying sequence.
final @NonNull Completable	Completable.repeatWhen(@NonNull Function<? super Flowable<Object>,@NonNull ? extends org.reactivestreams.Publisher<@NonNull ?>> handler)	Returns a Completable instance that repeats when the Publisher returned by the handler Function emits an item or completes when this Publisher emits an onComplete event.
final @NonNull Flowable<T>	Flowable.repeatWhen(@NonNull Function<? super Flowable<Object>,@NonNull ? extends org.reactivestreams.Publisher<@NonNull ?>> handler)	Returns a Flowable that emits the same values as the current Flowable with the exception of an onComplete.
final @NonNull Flowable<T>	Maybe.repeatWhen(@NonNull Function<? super Flowable<Object>,@NonNull ? extends org.reactivestreams.Publisher<@NonNull ?>> handler)	Returns a Flowable that emits the same values as the current Maybe with the exception of an onComplete.
final @NonNull Flowable<T>	Single.repeatWhen(@NonNull Function<? super Flowable<Object>,@NonNull ? extends org.reactivestreams.Publisher<@NonNull ?>> handler)	Re-subscribes to the current Single if the Publisher returned by the handler function signals a value in response to a value signaled through the Flowable the handler receives.
final <@NonNull R> @NonNull Flowable<R>	Flowable.replay(@NonNull Function<? super Flowable<@NonNull T>,@NonNull ? extends org.reactivestreams.Publisher<@NonNull R>> selector)	Returns a Flowable that emits items that are the results of invoking a specified selector on the items emitted by a ConnectableFlowable that shares a single subscription to the current Flowable.
final <@NonNull R> @NonNull Flowable<R>	Flowable.replay(@NonNull Function<? super Flowable<@NonNull T>,@NonNull ? extends org.reactivestreams.Publisher<@NonNull R>> selector, int bufferSize)	Returns a Flowable that emits items that are the results of invoking a specified selector on items emitted by a ConnectableFlowable that shares a single subscription to the current Flowable, replaying bufferSize notifications.
final <@NonNull R> @NonNull Flowable<R>	Flowable.replay(@NonNull Function<? super Flowable<@NonNull T>,@NonNull ? extends org.reactivestreams.Publisher<@NonNull R>> selector, int bufferSize, boolean eagerTruncate)	Returns a Flowable that emits items that are the results of invoking a specified selector on items emitted by a ConnectableFlowable that shares a single subscription to the current Flowable, replaying bufferSize notifications.
final <@NonNull R> @NonNull Flowable<R>	Flowable.replay(@NonNull Function<? super Flowable<@NonNull T>,@NonNull ? extends org.reactivestreams.Publisher<@NonNull R>> selector, int bufferSize, long time, @NonNull TimeUnit unit)	Returns a Flowable that emits items that are the results of invoking a specified selector on items emitted by a ConnectableFlowable that shares a single subscription to the current Flowable, replaying no more than bufferSize items that were emitted within a specified time window.
final <@NonNull R> @NonNull Flowable<R>	Flowable.replay(@NonNull Function<? super Flowable<@NonNull T>,@NonNull ? extends org.reactivestreams.Publisher<@NonNull R>> selector, int bufferSize, long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)	Returns a Flowable that emits items that are the results of invoking a specified selector on items emitted by a ConnectableFlowable that shares a single subscription to the current Flowable, replaying no more than bufferSize items that were emitted within a specified time window.
final <@NonNull R> @NonNull Flowable<R>	Flowable.replay(@NonNull Function<? super Flowable<@NonNull T>,@NonNull ? extends org.reactivestreams.Publisher<@NonNull R>> selector, int bufferSize, long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean eagerTruncate)	Returns a Flowable that emits items that are the results of invoking a specified selector on items emitted by a ConnectableFlowable that shares a single subscription to the current Flowable, replaying no more than bufferSize items that were emitted within a specified time window.
final <@NonNull R> @NonNull Flowable<R>	Flowable.replay(@NonNull Function<? super Flowable<@NonNull T>,@NonNull ? extends org.reactivestreams.Publisher<@NonNull R>> selector, long time, @NonNull TimeUnit unit)	Returns a Flowable that emits items that are the results of invoking a specified selector on items emitted by a ConnectableFlowable that shares a single subscription to the current Flowable, replaying all items that were emitted within a specified time window.
final <@NonNull R> @NonNull Flowable<R>	Flowable.replay(@NonNull Function<? super Flowable<@NonNull T>,@NonNull ? extends org.reactivestreams.Publisher<@NonNull R>> selector, long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)	Returns a Flowable that emits items that are the results of invoking a specified selector on items emitted by a ConnectableFlowable that shares a single subscription to the current Flowable, replaying all items that were emitted within a specified time window.
final <@NonNull R> @NonNull Flowable<R>	Flowable.replay(@NonNull Function<? super Flowable<@NonNull T>,@NonNull ? extends org.reactivestreams.Publisher<@NonNull R>> selector, long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean eagerTruncate)	Returns a Flowable that emits items that are the results of invoking a specified selector on items emitted by a ConnectableFlowable that shares a single subscription to the current Flowable, replaying all items that were emitted within a specified time window.
final @NonNull Completable	Completable.retryWhen(@NonNull Function<? super Flowable<Throwable>,@NonNull ? extends org.reactivestreams.Publisher<@NonNull ?>> handler)	Returns a Completable which given a Publisher and when this Completable emits an error, delivers that error through a Flowable and the Publisher should signal a value indicating a retry in response or a terminal event indicating a termination.
final @NonNull Flowable<T>	Flowable.retryWhen(@NonNull Function<? super Flowable<Throwable>,@NonNull ? extends org.reactivestreams.Publisher<@NonNull ?>> handler)	Returns a Flowable that emits the same values as the current Flowable with the exception of an onError.
final @NonNull Maybe<T>	Maybe.retryWhen(@NonNull Function<? super Flowable<Throwable>,@NonNull ? extends org.reactivestreams.Publisher<@NonNull ?>> handler)	Returns a Maybe that emits the same values as the current Maybe with the exception of an onError.
final @NonNull Single<T>	Single.retryWhen(@NonNull Function<? super Flowable<Throwable>,@NonNull ? extends org.reactivestreams.Publisher<@NonNull ?>> handler)	Re-subscribes to the current Single if and when the Publisher returned by the handler function signals a value.
<S extends Scheduler & Disposable> S	Scheduler.when(@NonNull Function<Flowable<Flowable<Completable>>,Completable> combine)	Allows the use of operators for controlling the timing around when actions scheduled on workers are actually done.
<S extends Scheduler & Disposable> S	Scheduler.when(@NonNull Function<Flowable<Flowable<Completable>>,Completable> combine)	Allows the use of operators for controlling the timing around when actions scheduled on workers are actually done.

Uses of Flowable in io.reactivex.rxjava3.flowables

Subclasses of Flowable in io.reactivex.rxjava3.flowables

Modifier and Type	Class	Description
class	ConnectableFlowable<T>	A ConnectableFlowable resembles an ordinary Flowable, except that it does not begin emitting items when it is subscribed to, but only when its ConnectableFlowable.connect(io.reactivex.rxjava3.functions.Consumer<? super io.reactivex.rxjava3.disposables.Disposable>) method is called.
class	GroupedFlowable<K,T>	A Flowable that has been grouped by key, the value of which can be obtained with GroupedFlowable.getKey().

Methods in io.reactivex.rxjava3.flowables that return Flowable

Modifier and Type	Method	Description
@NonNull Flowable<T>	ConnectableFlowable.autoConnect()	Returns a Flowable that automatically connects (at most once) to this ConnectableFlowable when the first Subscriber subscribes.
@NonNull Flowable<T>	ConnectableFlowable.autoConnect(int numberOfSubscribers)	Returns a Flowable that automatically connects (at most once) to this ConnectableFlowable when the specified number of Subscribers subscribe to it.
@NonNull Flowable<T>	ConnectableFlowable.autoConnect(int numberOfSubscribers, @NonNull Consumer<? super Disposable> connection)	Returns a Flowable that automatically connects (at most once) to this ConnectableFlowable when the specified number of Subscribers subscribe to it and calls the specified callback with the Disposable associated with the established connection.
@NonNull Flowable<T>	ConnectableFlowable.refCount()	Returns a Flowable that stays connected to this ConnectableFlowable as long as there is at least one subscription to this ConnectableFlowable.
final @NonNull Flowable<T>	ConnectableFlowable.refCount(int subscriberCount)	Connects to the upstream ConnectableFlowable if the number of subscribed subscriber reaches the specified count and disconnect if all subscribers have unsubscribed.
final @NonNull Flowable<T>	ConnectableFlowable.refCount(int subscriberCount, long timeout, @NonNull TimeUnit unit)	Connects to the upstream ConnectableFlowable if the number of subscribed subscriber reaches the specified count and disconnect after the specified timeout if all subscribers have unsubscribed.
final @NonNull Flowable<T>	ConnectableFlowable.refCount(int subscriberCount, long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)	Connects to the upstream ConnectableFlowable if the number of subscribed subscriber reaches the specified count and disconnect after the specified timeout if all subscribers have unsubscribed.
final @NonNull Flowable<T>	ConnectableFlowable.refCount(long timeout, @NonNull TimeUnit unit)	Connects to the upstream ConnectableFlowable if the number of subscribed subscriber reaches 1 and disconnect after the specified timeout if all subscribers have unsubscribed.
final @NonNull Flowable<T>	ConnectableFlowable.refCount(long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)	Connects to the upstream ConnectableFlowable if the number of subscribed subscriber reaches 1 and disconnect after the specified timeout if all subscribers have unsubscribed.

Uses of Flowable in io.reactivex.rxjava3.internal.fuseable

Methods in io.reactivex.rxjava3.internal.fuseable that return Flowable

Modifier and Type	Method	Description
@NonNull Flowable<T>	FuseToFlowable.fuseToFlowable()	Returns a (direct) Flowable for the operator.

Uses of Flowable in io.reactivex.rxjava3.internal.jdk8

Subclasses of Flowable in io.reactivex.rxjava3.internal.jdk8

Modifier and Type	Class	Description
final class	FlowableCollectWithCollector<T,A,R>	Collect items into a container defined by a Stream Collector callback set.
final class	FlowableFlatMapStream<T,R>	Maps the upstream values onto Streams and emits their items in order to the downstream.
final class	FlowableFromCompletionStage<T>	Wrap a CompletionStage and signal its outcome.
final class	FlowableFromStream<T>	Wraps a Stream and emits its values as a Flowable sequence.
final class	FlowableMapOptional<T,R>	Map the upstream values into an Optional and emit its value if any.
final class	MaybeFlattenStreamAsFlowable<T,R>	Map the success value into a Java Stream and emits its values.
final class	ParallelCollector<T,A,R>	Reduces all 'rails' into a single via a Java 8 Collector callback set.
final class	SingleFlattenStreamAsFlowable<T,R>	Map the success value into a Java Stream and emits its values.

Fields in io.reactivex.rxjava3.internal.jdk8 declared as Flowable

Modifier and Type	Field	Description
(package private) final Flowable<T>	FlowableCollectWithCollector.source
(package private) final Flowable<T>	FlowableCollectWithCollectorSingle.source
(package private) final Flowable<T>	FlowableFlatMapStream.source
(package private) final Flowable<T>	FlowableMapOptional.source

Methods in io.reactivex.rxjava3.internal.jdk8 that return Flowable

Modifier and Type	Method	Description
Flowable<R>	FlowableCollectWithCollectorSingle.fuseToFlowable()

Constructors in io.reactivex.rxjava3.internal.jdk8 with parameters of type Flowable

Modifier	Constructor	Description
	FlowableCollectWithCollector(Flowable<T> source, Collector<? super T,A,R> collector)
	FlowableCollectWithCollectorSingle(Flowable<T> source, Collector<? super T,A,R> collector)
	FlowableFlatMapStream(Flowable<T> source, Function<? super T,? extends Stream<? extends R>> mapper, int prefetch)
	FlowableMapOptional(Flowable<T> source, Function<? super T,Optional<? extends R>> mapper)

Uses of Flowable in io.reactivex.rxjava3.internal.operators.completable

Subclasses of Flowable in io.reactivex.rxjava3.internal.operators.completable

Modifier and Type	Class	Description
final class	CompletableToFlowable<T>

Uses of Flowable in io.reactivex.rxjava3.internal.operators.flowable

Subclasses of Flowable in io.reactivex.rxjava3.internal.operators.flowable

Modifier and Type	Class	Description
(package private) class	AbstractFlowableWithUpstream<T,R>	Abstract base class for operators that take an upstream source Publisher.
final class	FlowableAll<T>
final class	FlowableAmb<T>
final class	FlowableAny<T>
final class	FlowableAutoConnect<T>	Wraps a ConnectableFlowable and calls its connect() method once the specified number of Subscribers have subscribed.
final class	FlowableBuffer<T,C extends Collection<? super T>>
final class	FlowableBufferBoundary<T,U extends Collection<? super T>,Open,Close>
final class	FlowableBufferExactBoundary<T,U extends Collection<? super T>,B>
final class	FlowableBufferTimed<T,U extends Collection<? super T>>
final class	FlowableCache<T>	An observable which auto-connects to another observable, caches the elements from that observable but allows terminating the connection and completing the cache.
final class	FlowableCollect<T,U>
final class	FlowableCombineLatest<T,R>	Combines the latest values from multiple sources through a function.
final class	FlowableConcatArray<T>
final class	FlowableConcatMap<T,R>
final class	FlowableConcatMapEager<T,R>
final class	FlowableConcatMapEagerPublisher<T,R>	ConcatMapEager which works with an arbitrary Publisher source.
final class	FlowableConcatMapScheduler<T,R>
final class	FlowableConcatWithCompletable<T>	Subscribe to a main Flowable first, then when it completes normally, subscribe to a Completable and terminate when it terminates.
final class	FlowableConcatWithMaybe<T>	Subscribe to a main Flowable first, then when it completes normally, subscribe to a Maybe, signal its success value followed by a completion or signal its error or completion signal as is.
final class	FlowableConcatWithSingle<T>	Subscribe to a main Flowable first, then when it completes normally, subscribe to a Single, signal its success value followed by a completion or signal its error as is.
final class	FlowableCount<T>
final class	FlowableCreate<T>
final class	FlowableDebounce<T,U>
final class	FlowableDebounceTimed<T>
final class	FlowableDefer<T>
final class	FlowableDelay<T>
final class	FlowableDelaySubscriptionOther<T,U>	Delays the subscription to the main source until the other observable fires an event or completes.
final class	FlowableDematerialize<T,R>
final class	FlowableDetach<T>
final class	FlowableDistinct<T,K>
final class	FlowableDistinctUntilChanged<T,K>
final class	FlowableDoAfterNext<T>	Calls a consumer after pushing the current item to the downstream.
final class	FlowableDoFinally<T>	Execute an action after an onError, onComplete or a cancel event.
final class	FlowableDoOnEach<T>
final class	FlowableDoOnLifecycle<T>
final class	FlowableElementAt<T>
final class	FlowableEmpty	A source Flowable that signals an onSubscribe() + onComplete() only.
final class	FlowableError<T>
final class	FlowableFilter<T>
final class	FlowableFlatMap<T,U>
final class	FlowableFlatMapCompletable<T>	Maps a sequence of values into CompletableSources and awaits their termination.
final class	FlowableFlatMapMaybe<T,R>	Maps upstream values into MaybeSources and merges their signals into one sequence.
final class	FlowableFlatMapMaybePublisher<T,R>	Maps upstream values into MaybeSources and merges their signals into one sequence.
final class	FlowableFlatMapSingle<T,R>	Maps upstream values into SingleSources and merges their signals into one sequence.
final class	FlowableFlatMapSinglePublisher<T,R>	Maps upstream values into SingleSources and merges their signals into one sequence.
final class	FlowableFlattenIterable<T,R>
final class	FlowableFromAction<T>	Executes an Action and signals its exception or completes normally.
final class	FlowableFromArray<T>
final class	FlowableFromCallable<T>
final class	FlowableFromCompletable<T>	Wrap a Completable into a Flowable.
final class	FlowableFromFuture<T>
final class	FlowableFromIterable<T>
final class	FlowableFromObservable<T>
final class	FlowableFromPublisher<T>
final class	FlowableFromRunnable<T>	Executes an Runnable and signals its exception or completes normally.
final class	FlowableFromSupplier<T>	Call a Supplier for each incoming Subscriber and signal the returned value or the thrown exception.
final class	FlowableGenerate<T,S>
final class	FlowableGroupBy<T,K,V>
(package private) static final class	FlowableGroupBy.GroupedUnicast<K,T>
final class	FlowableGroupJoin<TLeft,TRight,TLeftEnd,TRightEnd,R>
final class	FlowableHide<T>	Hides the identity of the wrapped Flowable and its Subscription.
final class	FlowableIgnoreElements<T>
final class	FlowableInterval
final class	FlowableIntervalRange
final class	FlowableJoin<TLeft,TRight,TLeftEnd,TRightEnd,R>
final class	FlowableJust<T>	Represents a constant scalar value.
final class	FlowableLift<R,T>	Allows lifting operators into a chain of Publishers.
final class	FlowableMap<T,U>
final class	FlowableMapNotification<T,R>
final class	FlowableMapPublisher<T,U>	Map working with an arbitrary Publisher source.
final class	FlowableMaterialize<T>
final class	FlowableMergeWithCompletable<T>	Merges a Flowable and a Completable by emitting the items of the Flowable and waiting until both the Flowable and Completable complete normally.
final class	FlowableMergeWithMaybe<T>	Merges an Observable and a Maybe by emitting the items of the Observable and the success value of the Maybe and waiting until both the Observable and Maybe terminate normally.
final class	FlowableMergeWithSingle<T>	Merges an Observable and a Maybe by emitting the items of the Observable and the success value of the Maybe and waiting until both the Observable and Maybe terminate normally.
final class	FlowableNever
final class	FlowableObserveOn<T>
final class	FlowableOnBackpressureBuffer<T>
final class	FlowableOnBackpressureBufferStrategy<T>	Handle backpressure with a bounded buffer and custom strategy.
final class	FlowableOnBackpressureDrop<T>
final class	FlowableOnBackpressureError<T>
final class	FlowableOnBackpressureLatest<T>
final class	FlowableOnBackpressureReduce<T>
final class	FlowableOnBackpressureReduceWith<T,R>
final class	FlowableOnErrorComplete<T>	Emits an onComplete if the source emits an onError and the predicate returns true for that Throwable.
final class	FlowableOnErrorNext<T>
final class	FlowableOnErrorReturn<T>
final class	FlowablePublish<T>	Shares a single underlying connection to the upstream Publisher and multicasts events to all subscribed subscribers until the upstream completes or the connection is disposed.
final class	FlowablePublishMulticast<T,R>	Multicasts a Flowable over a selector function.
(package private) static final class	FlowablePublishMulticast.MulticastProcessor<T>
final class	FlowableRange	Emits a range of integer values.
final class	FlowableRangeLong	Emits a range of long values.
final class	FlowableReduce<T>	Reduces a sequence via a function into a single value or signals NoSuchElementException for an empty source.
final class	FlowableRefCount<T>	Returns an observable sequence that stays connected to the source as long as there is at least one subscription to the observable sequence.
final class	FlowableRepeat<T>
final class	FlowableRepeatUntil<T>
final class	FlowableRepeatWhen<T>
final class	FlowableReplay<T>
(package private) static final class	FlowableReplay.MulticastFlowable<R,U>
final class	FlowableRetryBiPredicate<T>
final class	FlowableRetryPredicate<T>
final class	FlowableRetryWhen<T>
final class	FlowableSamplePublisher<T>
final class	FlowableSampleTimed<T>
(package private) static final class	FlowableScalarXMap.ScalarXMapFlowable<T,R>	Maps a scalar value to a Publisher and subscribes to it.
final class	FlowableScan<T>
final class	FlowableScanSeed<T,R>
final class	FlowableSequenceEqual<T>
final class	FlowableSerialized<T>
final class	FlowableSingle<T>
final class	FlowableSkip<T>
final class	FlowableSkipLast<T>
final class	FlowableSkipLastTimed<T>
final class	FlowableSkipUntil<T,U>
final class	FlowableSkipWhile<T>
final class	FlowableSubscribeOn<T>	Subscribes to the source Flowable on the specified Scheduler and makes sure downstream requests are scheduled there as well.
final class	FlowableSwitchIfEmpty<T>
final class	FlowableSwitchMap<T,R>
final class	FlowableTake<T>
final class	FlowableTakeLast<T>
final class	FlowableTakeLastOne<T>
final class	FlowableTakeLastTimed<T>
final class	FlowableTakePublisher<T>	Take with a generic Publisher source.
final class	FlowableTakeUntil<T,U>
final class	FlowableTakeUntilPredicate<T>
final class	FlowableTakeWhile<T>
final class	FlowableThrottleFirstTimed<T>
final class	FlowableThrottleLatest<T>	Emits the next or latest item when the given time elapses.
final class	FlowableTimeInterval<T>
final class	FlowableTimeout<T,U,V>
final class	FlowableTimeoutTimed<T>
final class	FlowableTimer
final class	FlowableToList<T,U extends Collection<? super T>>
final class	FlowableUnsubscribeOn<T>
final class	FlowableUsing<T,D>
final class	FlowableWindow<T>
final class	FlowableWindowBoundary<T,B>
final class	FlowableWindowBoundarySelector<T,B,V>
(package private) static final class	FlowableWindowBoundarySelector.WindowBoundaryMainSubscriber.WindowEndSubscriberIntercept<T,V>
(package private) final class	FlowableWindowSubscribeIntercept<T>	Wrapper for a FlowableProcessor that detects an incoming subscriber.
final class	FlowableWindowTimed<T>
final class	FlowableWithLatestFrom<T,U,R>
final class	FlowableWithLatestFromMany<T,R>	Combines a main sequence of values with the latest from multiple other sequences via a selector function.
final class	FlowableZip<T,R>
final class	FlowableZipIterable<T,U,V>

Fields in io.reactivex.rxjava3.internal.operators.flowable declared as Flowable

Modifier and Type	Field	Description
static final Flowable<Object>	FlowableEmpty.INSTANCE
static final Flowable<Object>	FlowableNever.INSTANCE
(package private) final Flowable<T>	FlowableInternalHelper.BufferedReplaySupplier.parent
(package private) final Flowable<T>	FlowableInternalHelper.BufferedTimedReplay.parent
(package private) final Flowable<T>	FlowableInternalHelper.ReplaySupplier.parent
private final Flowable<T>	FlowableInternalHelper.TimedReplay.parent
protected final Flowable<T>	AbstractFlowableWithUpstream.source	The upstream source Publisher.
(package private) final Flowable<T>	BlockingFlowableIterable.source
(package private) final Flowable<T>	BlockingFlowableMostRecent.source
(package private) final Flowable<T>	FlowableAllSingle.source
(package private) final Flowable<T>	FlowableAnySingle.source
(package private) final Flowable<T>	FlowableCollectSingle.source
(package private) final Flowable<T>	FlowableCountSingle.source
(package private) final Flowable<T>	FlowableElementAtMaybe.source
(package private) final Flowable<T>	FlowableElementAtSingle.source
(package private) final Flowable<T>	FlowableFlatMapCompletableCompletable.source
(package private) final Flowable<T>	FlowableIgnoreElementsCompletable.source
(package private) final Flowable<T>	FlowableReduceMaybe.source
(package private) final Flowable<T>	FlowableReplay.source	The source observable.
(package private) final Flowable<T>	FlowableSingleMaybe.source
(package private) final Flowable<T>	FlowableSingleSingle.source
(package private) final Flowable<T>	FlowableToListSingle.source

Fields in io.reactivex.rxjava3.internal.operators.flowable with type parameters of type Flowable

Modifier and Type	Field	Description
(package private) final org.reactivestreams.Subscriber<? super Flowable<T>>	FlowableWindow.WindowExactSubscriber.downstream
(package private) final org.reactivestreams.Subscriber<? super Flowable<T>>	FlowableWindow.WindowOverlapSubscriber.downstream
(package private) final org.reactivestreams.Subscriber<? super Flowable<T>>	FlowableWindow.WindowSkipSubscriber.downstream
(package private) final org.reactivestreams.Subscriber<? super Flowable<T>>	FlowableWindowBoundary.WindowBoundaryMainSubscriber.downstream
(package private) final org.reactivestreams.Subscriber<? super Flowable<T>>	FlowableWindowBoundarySelector.WindowBoundaryMainSubscriber.downstream
(package private) final org.reactivestreams.Subscriber<? super Flowable<T>>	FlowableWindowTimed.AbstractWindowSubscriber.downstream
(package private) final Function<? super Flowable<Object>,? extends org.reactivestreams.Publisher<?>>	FlowableRepeatWhen.handler
(package private) final Function<? super Flowable<Throwable>,? extends org.reactivestreams.Publisher<?>>	FlowableRetryWhen.handler
(package private) final BiFunction<? super TLeft,? super Flowable<TRight>,? extends R>	FlowableGroupJoin.GroupJoinSubscription.resultSelector
(package private) final BiFunction<? super TLeft,? super Flowable<TRight>,? extends R>	FlowableGroupJoin.resultSelector
(package private) final Function<? super Flowable<T>,? extends org.reactivestreams.Publisher<? extends R>>	FlowablePublishMulticast.selector
private final Function<? super Flowable<U>,? extends org.reactivestreams.Publisher<R>>	FlowableReplay.MulticastFlowable.selector

Methods in io.reactivex.rxjava3.internal.operators.flowable that return Flowable

Modifier and Type	Method	Description
Flowable<Boolean>	FlowableAllSingle.fuseToFlowable()
Flowable<Boolean>	FlowableAnySingle.fuseToFlowable()
Flowable<U>	FlowableCollectSingle.fuseToFlowable()
Flowable<Long>	FlowableCountSingle.fuseToFlowable()
Flowable<T>	FlowableElementAtMaybe.fuseToFlowable()
Flowable<T>	FlowableElementAtSingle.fuseToFlowable()
Flowable<T>	FlowableFlatMapCompletableCompletable.fuseToFlowable()
Flowable<T>	FlowableIgnoreElementsCompletable.fuseToFlowable()
Flowable<T>	FlowableReduceMaybe.fuseToFlowable()
Flowable<Boolean>	FlowableSequenceEqualSingle.fuseToFlowable()
Flowable<T>	FlowableSingleMaybe.fuseToFlowable()
Flowable<T>	FlowableSingleSingle.fuseToFlowable()
Flowable<U>	FlowableToListSingle.fuseToFlowable()
static <U, R> Flowable<R>	FlowableReplay.multicastSelector(Supplier<? extends ConnectableFlowable<U>> connectableFactory, Function<? super Flowable<U>,? extends org.reactivestreams.Publisher<R>> selector)	Given a connectable observable factory, it multicasts over the generated ConnectableObservable via a selector function.
static <T, U> Flowable<U>	FlowableScalarXMap.scalarXMap(T value, Function<? super T,? extends org.reactivestreams.Publisher<? extends U>> mapper)	Maps a scalar value into a Publisher and emits its values.

Methods in io.reactivex.rxjava3.internal.operators.flowable with parameters of type Flowable

Modifier and Type	Method	Description
static <T> ConnectableFlowable<T>	FlowableReplay.create(Flowable<T> source, int bufferSize, boolean eagerTruncate)	Creates a replaying ConnectableObservable with a size bound buffer.
static <T> ConnectableFlowable<T>	FlowableReplay.create(Flowable<T> source, long maxAge, TimeUnit unit, Scheduler scheduler, boolean eagerTruncate)	Creates a replaying ConnectableObservable with a time bound buffer.
static <T> ConnectableFlowable<T>	FlowableReplay.create(Flowable<T> source, long maxAge, TimeUnit unit, Scheduler scheduler, int bufferSize, boolean eagerTruncate)	Creates a replaying ConnectableObservable with a size and time bound buffer.
(package private) static <T> ConnectableFlowable<T>	FlowableReplay.create(Flowable<T> source, Supplier<? extends FlowableReplay.ReplayBuffer<T>> bufferFactory)	Creates a OperatorReplay instance to replay values of the given source Flowable.
static <T> ConnectableFlowable<T>	FlowableReplay.createFrom(Flowable<? extends T> source)	Creates a replaying ConnectableObservable with an unbounded buffer.
static <T> Supplier<ConnectableFlowable<T>>	FlowableInternalHelper.replaySupplier(Flowable<T> parent)
static <T> Supplier<ConnectableFlowable<T>>	FlowableInternalHelper.replaySupplier(Flowable<T> parent, int bufferSize, boolean eagerTruncate)
static <T> Supplier<ConnectableFlowable<T>>	FlowableInternalHelper.replaySupplier(Flowable<T> parent, int bufferSize, long time, TimeUnit unit, Scheduler scheduler, boolean eagerTruncate)
static <T> Supplier<ConnectableFlowable<T>>	FlowableInternalHelper.replaySupplier(Flowable<T> parent, long time, TimeUnit unit, Scheduler scheduler, boolean eagerTruncate)

Method parameters in io.reactivex.rxjava3.internal.operators.flowable with type arguments of type Flowable

Modifier and Type	Method	Description
static <U, R> Flowable<R>	FlowableReplay.multicastSelector(Supplier<? extends ConnectableFlowable<U>> connectableFactory, Function<? super Flowable<U>,? extends org.reactivestreams.Publisher<R>> selector)	Given a connectable observable factory, it multicasts over the generated ConnectableObservable via a selector function.
void	FlowableWindow.subscribeActual(org.reactivestreams.Subscriber<? super Flowable<T>> s)
protected void	FlowableWindowBoundary.subscribeActual(org.reactivestreams.Subscriber<? super Flowable<T>> subscriber)
protected void	FlowableWindowBoundarySelector.subscribeActual(org.reactivestreams.Subscriber<? super Flowable<T>> s)
protected void	FlowableWindowTimed.subscribeActual(org.reactivestreams.Subscriber<? super Flowable<T>> downstream)

Constructors in io.reactivex.rxjava3.internal.operators.flowable with parameters of type Flowable

Modifier	Constructor	Description
(package private)	AbstractFlowableWithUpstream(Flowable<T> source)	Constructs a FlowableSource wrapping the given non-null (verified) source Publisher.
	BlockingFlowableIterable(Flowable<T> source, int bufferSize)
	BlockingFlowableMostRecent(Flowable<T> source, T initialValue)
(package private)	BufferedReplaySupplier(Flowable<T> parent, int bufferSize, boolean eagerTruncate)
(package private)	BufferedTimedReplay(Flowable<T> parent, int bufferSize, long time, TimeUnit unit, Scheduler scheduler, boolean eagerTruncate)
	FlowableAll(Flowable<T> source, Predicate<? super T> predicate)
	FlowableAllSingle(Flowable<T> source, Predicate<? super T> predicate)
	FlowableAny(Flowable<T> source, Predicate<? super T> predicate)
	FlowableAnySingle(Flowable<T> source, Predicate<? super T> predicate)
	FlowableBuffer(Flowable<T> source, int size, int skip, Supplier<C> bufferSupplier)
	FlowableBufferBoundary(Flowable<T> source, org.reactivestreams.Publisher<? extends Open> bufferOpen, Function<? super Open,? extends org.reactivestreams.Publisher<? extends Close>> bufferClose, Supplier<U> bufferSupplier)
	FlowableBufferExactBoundary(Flowable<T> source, org.reactivestreams.Publisher<B> boundary, Supplier<U> bufferSupplier)
	FlowableBufferTimed(Flowable<T> source, long timespan, long timeskip, TimeUnit unit, Scheduler scheduler, Supplier<U> bufferSupplier, int maxSize, boolean restartTimerOnMaxSize)
	FlowableCache(Flowable<T> source, int capacityHint)	Constructs an empty, non-connected cache.
	FlowableCollect(Flowable<T> source, Supplier<? extends U> initialSupplier, BiConsumer<? super U,? super T> collector)
	FlowableCollectSingle(Flowable<T> source, Supplier<? extends U> initialSupplier, BiConsumer<? super U,? super T> collector)
	FlowableConcatMap(Flowable<T> source, Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> mapper, int prefetch, ErrorMode errorMode)
	FlowableConcatMapEager(Flowable<T> source, Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> mapper, int maxConcurrency, int prefetch, ErrorMode errorMode)
	FlowableConcatMapScheduler(Flowable<T> source, Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> mapper, int prefetch, ErrorMode errorMode, Scheduler scheduler)
	FlowableConcatWithCompletable(Flowable<T> source, CompletableSource other)
	FlowableConcatWithMaybe(Flowable<T> source, MaybeSource<? extends T> other)
	FlowableConcatWithSingle(Flowable<T> source, SingleSource<? extends T> other)
	FlowableCount(Flowable<T> source)
	FlowableCountSingle(Flowable<T> source)
	FlowableDebounce(Flowable<T> source, Function<? super T,? extends org.reactivestreams.Publisher<U>> debounceSelector)
	FlowableDebounceTimed(Flowable<T> source, long timeout, TimeUnit unit, Scheduler scheduler, Consumer<? super T> onDropped)
	FlowableDelay(Flowable<T> source, long delay, TimeUnit unit, Scheduler scheduler, boolean delayError)
	FlowableDematerialize(Flowable<T> source, Function<? super T,? extends Notification<R>> selector)
	FlowableDetach(Flowable<T> source)
	FlowableDistinct(Flowable<T> source, Function<? super T,K> keySelector, Supplier<? extends Collection<? super K>> collectionSupplier)
	FlowableDistinctUntilChanged(Flowable<T> source, Function<? super T,K> keySelector, BiPredicate<? super K,? super K> comparer)
	FlowableDoAfterNext(Flowable<T> source, Consumer<? super T> onAfterNext)
	FlowableDoFinally(Flowable<T> source, Action onFinally)
	FlowableDoOnEach(Flowable<T> source, Consumer<? super T> onNext, Consumer<? super Throwable> onError, Action onComplete, Action onAfterTerminate)
	FlowableDoOnLifecycle(Flowable<T> source, Consumer<? super org.reactivestreams.Subscription> onSubscribe, LongConsumer onRequest, Action onCancel)
	FlowableElementAt(Flowable<T> source, long index, T defaultValue, boolean errorOnFewer)
	FlowableElementAtMaybe(Flowable<T> source, long index)
	FlowableElementAtSingle(Flowable<T> source, long index, T defaultValue)
	FlowableFilter(Flowable<T> source, Predicate<? super T> predicate)
	FlowableFlatMap(Flowable<T> source, Function<? super T,? extends org.reactivestreams.Publisher<? extends U>> mapper, boolean delayErrors, int maxConcurrency, int bufferSize)
	FlowableFlatMapCompletable(Flowable<T> source, Function<? super T,? extends CompletableSource> mapper, boolean delayErrors, int maxConcurrency)
	FlowableFlatMapCompletableCompletable(Flowable<T> source, Function<? super T,? extends CompletableSource> mapper, boolean delayErrors, int maxConcurrency)
	FlowableFlatMapMaybe(Flowable<T> source, Function<? super T,? extends MaybeSource<? extends R>> mapper, boolean delayError, int maxConcurrency)
	FlowableFlatMapSingle(Flowable<T> source, Function<? super T,? extends SingleSource<? extends R>> mapper, boolean delayError, int maxConcurrency)
	FlowableFlattenIterable(Flowable<T> source, Function<? super T,? extends Iterable<? extends R>> mapper, int prefetch)
	FlowableGroupBy(Flowable<T> source, Function<? super T,? extends K> keySelector, Function<? super T,? extends V> valueSelector, int bufferSize, boolean delayError, Function<? super Consumer<Object>,? extends Map<K,Object>> mapFactory)
	FlowableGroupJoin(Flowable<TLeft> source, org.reactivestreams.Publisher<? extends TRight> other, Function<? super TLeft,? extends org.reactivestreams.Publisher<TLeftEnd>> leftEnd, Function<? super TRight,? extends org.reactivestreams.Publisher<TRightEnd>> rightEnd, BiFunction<? super TLeft,? super Flowable<TRight>,? extends R> resultSelector)
	FlowableHide(Flowable<T> source)
	FlowableIgnoreElements(Flowable<T> source)
	FlowableIgnoreElementsCompletable(Flowable<T> source)
	FlowableJoin(Flowable<TLeft> source, org.reactivestreams.Publisher<? extends TRight> other, Function<? super TLeft,? extends org.reactivestreams.Publisher<TLeftEnd>> leftEnd, Function<? super TRight,? extends org.reactivestreams.Publisher<TRightEnd>> rightEnd, BiFunction<? super TLeft,? super TRight,? extends R> resultSelector)
	FlowableLift(Flowable<T> source, FlowableOperator<? extends R,? super T> operator)
	FlowableMap(Flowable<T> source, Function<? super T,? extends U> mapper)
	FlowableMapNotification(Flowable<T> source, Function<? super T,? extends R> onNextMapper, Function<? super Throwable,? extends R> onErrorMapper, Supplier<? extends R> onCompleteSupplier)
	FlowableMaterialize(Flowable<T> source)
	FlowableMergeWithCompletable(Flowable<T> source, CompletableSource other)
	FlowableMergeWithMaybe(Flowable<T> source, MaybeSource<? extends T> other)
	FlowableMergeWithSingle(Flowable<T> source, SingleSource<? extends T> other)
	FlowableObserveOn(Flowable<T> source, Scheduler scheduler, boolean delayError, int prefetch)
	FlowableOnBackpressureBuffer(Flowable<T> source, int bufferSize, boolean unbounded, boolean delayError, Action onOverflow, Consumer<? super T> onDropped)
	FlowableOnBackpressureBufferStrategy(Flowable<T> source, long bufferSize, Action onOverflow, BackpressureOverflowStrategy strategy, Consumer<? super T> onDropped)
	FlowableOnBackpressureDrop(Flowable<T> source)
	FlowableOnBackpressureDrop(Flowable<T> source, Consumer<? super T> onDrop)
	FlowableOnBackpressureError(Flowable<T> source)
	FlowableOnBackpressureLatest(Flowable<T> source, Consumer<? super T> onDropped)
	FlowableOnBackpressureReduce(@NonNull Flowable<T> source, @NonNull BiFunction<T,T,T> reducer)
	FlowableOnBackpressureReduceWith(@NonNull Flowable<T> source, @NonNull Supplier<R> supplier, @NonNull BiFunction<R,? super T,R> reducer)
	FlowableOnErrorComplete(Flowable<T> source, Predicate<? super Throwable> predicate)
	FlowableOnErrorNext(Flowable<T> source, Function<? super Throwable,? extends org.reactivestreams.Publisher<? extends T>> nextSupplier)
	FlowableOnErrorReturn(Flowable<T> source, Function<? super Throwable,? extends T> valueSupplier)
	FlowablePublishMulticast(Flowable<T> source, Function<? super Flowable<T>,? extends org.reactivestreams.Publisher<? extends R>> selector, int prefetch, boolean delayError)
	FlowableReduce(Flowable<T> source, BiFunction<T,T,T> reducer)
	FlowableReduceMaybe(Flowable<T> source, BiFunction<T,T,T> reducer)
	FlowableRepeat(Flowable<T> source, long count)
	FlowableRepeatUntil(Flowable<T> source, BooleanSupplier until)
	FlowableRepeatWhen(Flowable<T> source, Function<? super Flowable<Object>,? extends org.reactivestreams.Publisher<?>> handler)
private	FlowableReplay(org.reactivestreams.Publisher<T> onSubscribe, Flowable<T> source, AtomicReference<FlowableReplay.ReplaySubscriber<T>> current, Supplier<? extends FlowableReplay.ReplayBuffer<T>> bufferFactory)
	FlowableRetryBiPredicate(Flowable<T> source, BiPredicate<? super Integer,? super Throwable> predicate)
	FlowableRetryPredicate(Flowable<T> source, long count, Predicate<? super Throwable> predicate)
	FlowableRetryWhen(Flowable<T> source, Function<? super Flowable<Throwable>,? extends org.reactivestreams.Publisher<?>> handler)
	FlowableSampleTimed(Flowable<T> source, long period, TimeUnit unit, Scheduler scheduler, boolean emitLast, Consumer<? super T> onDropped)
	FlowableScan(Flowable<T> source, BiFunction<T,T,T> accumulator)
	FlowableScanSeed(Flowable<T> source, Supplier<R> seedSupplier, BiFunction<R,? super T,R> accumulator)
	FlowableSerialized(Flowable<T> source)
	FlowableSingle(Flowable<T> source, T defaultValue, boolean failOnEmpty)
	FlowableSingleMaybe(Flowable<T> source)
	FlowableSingleSingle(Flowable<T> source, T defaultValue)
	FlowableSkip(Flowable<T> source, long n)
	FlowableSkipLast(Flowable<T> source, int skip)
	FlowableSkipLastTimed(Flowable<T> source, long time, TimeUnit unit, Scheduler scheduler, int bufferSize, boolean delayError)
	FlowableSkipUntil(Flowable<T> source, org.reactivestreams.Publisher<U> other)
	FlowableSkipWhile(Flowable<T> source, Predicate<? super T> predicate)
	FlowableSubscribeOn(Flowable<T> source, Scheduler scheduler, boolean nonScheduledRequests)
	FlowableSwitchIfEmpty(Flowable<T> source, org.reactivestreams.Publisher<? extends T> other)
	FlowableSwitchMap(Flowable<T> source, Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> mapper, int bufferSize, boolean delayErrors)
	FlowableTake(Flowable<T> source, long n)
	FlowableTakeLast(Flowable<T> source, int count)
	FlowableTakeLastOne(Flowable<T> source)
	FlowableTakeLastTimed(Flowable<T> source, long count, long time, TimeUnit unit, Scheduler scheduler, int bufferSize, boolean delayError)
	FlowableTakeUntil(Flowable<T> source, org.reactivestreams.Publisher<? extends U> other)
	FlowableTakeUntilPredicate(Flowable<T> source, Predicate<? super T> predicate)
	FlowableTakeWhile(Flowable<T> source, Predicate<? super T> predicate)
	FlowableThrottleFirstTimed(Flowable<T> source, long timeout, TimeUnit unit, Scheduler scheduler, Consumer<? super T> onDropped)
	FlowableThrottleLatest(Flowable<T> source, long timeout, TimeUnit unit, Scheduler scheduler, boolean emitLast, Consumer<? super T> onDropped)
	FlowableTimeInterval(Flowable<T> source, TimeUnit unit, Scheduler scheduler)
	FlowableTimeout(Flowable<T> source, org.reactivestreams.Publisher<U> firstTimeoutIndicator, Function<? super T,? extends org.reactivestreams.Publisher<V>> itemTimeoutIndicator, org.reactivestreams.Publisher<? extends T> other)
	FlowableTimeoutTimed(Flowable<T> source, long timeout, TimeUnit unit, Scheduler scheduler, org.reactivestreams.Publisher<? extends T> other)
	FlowableToList(Flowable<T> source, Supplier<U> collectionSupplier)
	FlowableToListSingle(Flowable<T> source)
	FlowableToListSingle(Flowable<T> source, Supplier<U> collectionSupplier)
	FlowableUnsubscribeOn(Flowable<T> source, Scheduler scheduler)
	FlowableWindow(Flowable<T> source, long size, long skip, int bufferSize)
	FlowableWindowBoundary(Flowable<T> source, org.reactivestreams.Publisher<B> other, int capacityHint)
	FlowableWindowBoundarySelector(Flowable<T> source, org.reactivestreams.Publisher<B> open, Function<? super B,? extends org.reactivestreams.Publisher<V>> closingIndicator, int bufferSize)
	FlowableWindowTimed(Flowable<T> source, long timespan, long timeskip, TimeUnit unit, Scheduler scheduler, long maxSize, int bufferSize, boolean restartTimerOnMaxSize)
	FlowableWithLatestFrom(Flowable<T> source, BiFunction<? super T,? super U,? extends R> combiner, org.reactivestreams.Publisher<? extends U> other)
	FlowableWithLatestFromMany(@NonNull Flowable<T> source, @NonNull Iterable<? extends org.reactivestreams.Publisher<?>> otherIterable, @NonNull Function<? super Object[],R> combiner)
	FlowableWithLatestFromMany(@NonNull Flowable<T> source, @NonNull org.reactivestreams.Publisher<?>[] otherArray, Function<? super Object[],R> combiner)
	FlowableZipIterable(Flowable<T> source, Iterable<U> other, BiFunction<? super T,? super U,? extends V> zipper)
(package private)	ReplaySupplier(Flowable<T> parent)
(package private)	TimedReplay(Flowable<T> parent, long time, TimeUnit unit, Scheduler scheduler, boolean eagerTruncate)

Constructor parameters in io.reactivex.rxjava3.internal.operators.flowable with type arguments of type Flowable

Modifier	Constructor	Description
(package private)	AbstractWindowSubscriber(org.reactivestreams.Subscriber<? super Flowable<T>> downstream, long timespan, TimeUnit unit, int bufferSize)
	FlowableGroupJoin(Flowable<TLeft> source, org.reactivestreams.Publisher<? extends TRight> other, Function<? super TLeft,? extends org.reactivestreams.Publisher<TLeftEnd>> leftEnd, Function<? super TRight,? extends org.reactivestreams.Publisher<TRightEnd>> rightEnd, BiFunction<? super TLeft,? super Flowable<TRight>,? extends R> resultSelector)
	FlowablePublishMulticast(Flowable<T> source, Function<? super Flowable<T>,? extends org.reactivestreams.Publisher<? extends R>> selector, int prefetch, boolean delayError)
	FlowableRepeatWhen(Flowable<T> source, Function<? super Flowable<Object>,? extends org.reactivestreams.Publisher<?>> handler)
	FlowableRetryWhen(Flowable<T> source, Function<? super Flowable<Throwable>,? extends org.reactivestreams.Publisher<?>> handler)
(package private)	GroupJoinSubscription(org.reactivestreams.Subscriber<? super R> actual, Function<? super TLeft,? extends org.reactivestreams.Publisher<TLeftEnd>> leftEnd, Function<? super TRight,? extends org.reactivestreams.Publisher<TRightEnd>> rightEnd, BiFunction<? super TLeft,? super Flowable<TRight>,? extends R> resultSelector)
(package private)	MulticastFlowable(Supplier<? extends ConnectableFlowable<U>> connectableFactory, Function<? super Flowable<U>,? extends org.reactivestreams.Publisher<R>> selector)
(package private)	WindowBoundaryMainSubscriber(org.reactivestreams.Subscriber<? super Flowable<T>> downstream, int capacityHint)
(package private)	WindowBoundaryMainSubscriber(org.reactivestreams.Subscriber<? super Flowable<T>> actual, org.reactivestreams.Publisher<B> open, Function<? super B,? extends org.reactivestreams.Publisher<V>> closingIndicator, int bufferSize)
(package private)	WindowExactBoundedSubscriber(org.reactivestreams.Subscriber<? super Flowable<T>> actual, long timespan, TimeUnit unit, Scheduler scheduler, int bufferSize, long maxSize, boolean restartTimerOnMaxSize)
(package private)	WindowExactSubscriber(org.reactivestreams.Subscriber<? super Flowable<T>> actual, long size, int bufferSize)
(package private)	WindowExactUnboundedSubscriber(org.reactivestreams.Subscriber<? super Flowable<T>> actual, long timespan, TimeUnit unit, Scheduler scheduler, int bufferSize)
(package private)	WindowOverlapSubscriber(org.reactivestreams.Subscriber<? super Flowable<T>> actual, long size, long skip, int bufferSize)
(package private)	WindowSkipSubscriber(org.reactivestreams.Subscriber<? super Flowable<T>> actual, long size, long skip, int bufferSize)
(package private)	WindowSkipSubscriber(org.reactivestreams.Subscriber<? super Flowable<T>> actual, long timespan, long timeskip, TimeUnit unit, Scheduler.Worker worker, int bufferSize)

Uses of Flowable in io.reactivex.rxjava3.internal.operators.maybe

Subclasses of Flowable in io.reactivex.rxjava3.internal.operators.maybe

Modifier and Type	Class	Description
final class	MaybeConcatArray<T>	Concatenate values of each MaybeSource provided in an array.
final class	MaybeConcatArrayDelayError<T>	Concatenate values of each MaybeSource provided in an array and delays any errors till the very end.
final class	MaybeConcatIterable<T>	Concatenate values of each MaybeSource provided by an Iterable.
final class	MaybeFlatMapIterableFlowable<T,R>	Maps a success value into an Iterable and streams it back as a Flowable.
final class	MaybeMergeArray<T>	Run all MaybeSources of an array at once and signal their values as they become available.
final class	MaybeToFlowable<T>	Wraps a MaybeSource and exposes it as a Flowable, relaying signals in a backpressure-aware manner and composes cancellation through.

Uses of Flowable in io.reactivex.rxjava3.internal.operators.mixed

Subclasses of Flowable in io.reactivex.rxjava3.internal.operators.mixed

Modifier and Type	Class	Description
final class	CompletableAndThenPublisher<R>	After Completable completes, it relays the signals of the Publisher to the downstream subscriber.
final class	FlowableConcatMapMaybe<T,R>	Maps each upstream item into a MaybeSource, subscribes to them one after the other terminates and relays their success values, optionally delaying any errors till the main and inner sources terminate.
final class	FlowableConcatMapMaybePublisher<T,R>	Maps each upstream item into a MaybeSource, subscribes to them one after the other terminates and relays their success values, optionally delaying any errors till the main and inner sources terminate.
final class	FlowableConcatMapSingle<T,R>	Maps each upstream item into a SingleSource, subscribes to them one after the other terminates and relays their success values, optionally delaying any errors till the main and inner sources terminate.
final class	FlowableConcatMapSinglePublisher<T,R>	Maps each upstream item into a SingleSource, subscribes to them one after the other terminates and relays their success values, optionally delaying any errors till the main and inner sources terminate.
final class	FlowableSwitchMapMaybe<T,R>	Maps the upstream items into MaybeSources and switches (subscribes) to the newer ones while disposing the older ones and emits the latest success value if available, optionally delaying errors from the main source or the inner sources.
final class	FlowableSwitchMapMaybePublisher<T,R>	Switch between subsequent MaybeSources emitted by a Publisher.
final class	FlowableSwitchMapSingle<T,R>	Maps the upstream items into SingleSources and switches (subscribes) to the newer ones while disposing the older ones and emits the latest success value, optionally delaying errors from the main source or the inner sources.
final class	FlowableSwitchMapSinglePublisher<T,R>	Switch between subsequent SingleSources emitted by a Publisher.
final class	MaybeFlatMapPublisher<T,R>	Maps the success value of a Maybe onto a Publisher and relays its signals to the downstream subscriber.

Fields in io.reactivex.rxjava3.internal.operators.mixed declared as Flowable

Modifier and Type	Field	Description
(package private) final Flowable<T>	FlowableConcatMapCompletable.source
(package private) final Flowable<T>	FlowableConcatMapMaybe.source
(package private) final Flowable<T>	FlowableConcatMapSingle.source
(package private) final Flowable<T>	FlowableSwitchMapCompletable.source
(package private) final Flowable<T>	FlowableSwitchMapMaybe.source
(package private) final Flowable<T>	FlowableSwitchMapSingle.source

Constructors in io.reactivex.rxjava3.internal.operators.mixed with parameters of type Flowable

Modifier	Constructor	Description
	FlowableConcatMapCompletable(Flowable<T> source, Function<? super T,? extends CompletableSource> mapper, ErrorMode errorMode, int prefetch)
	FlowableConcatMapMaybe(Flowable<T> source, Function<? super T,? extends MaybeSource<? extends R>> mapper, ErrorMode errorMode, int prefetch)
	FlowableConcatMapSingle(Flowable<T> source, Function<? super T,? extends SingleSource<? extends R>> mapper, ErrorMode errorMode, int prefetch)
	FlowableSwitchMapCompletable(Flowable<T> source, Function<? super T,? extends CompletableSource> mapper, boolean delayErrors)
	FlowableSwitchMapMaybe(Flowable<T> source, Function<? super T,? extends MaybeSource<? extends R>> mapper, boolean delayErrors)
	FlowableSwitchMapSingle(Flowable<T> source, Function<? super T,? extends SingleSource<? extends R>> mapper, boolean delayErrors)

Uses of Flowable in io.reactivex.rxjava3.internal.operators.parallel

Subclasses of Flowable in io.reactivex.rxjava3.internal.operators.parallel

Modifier and Type	Class	Description
final class	ParallelJoin<T>	Merges the individual 'rails' of the source ParallelFlowable, unordered, into a single regular Publisher sequence (exposed as Flowable).
final class	ParallelReduceFull<T>	Reduces all 'rails' into a single value which then gets reduced into a single Publisher sequence.
final class	ParallelSortedJoin<T>	Given sorted rail sequences (according to the provided comparator) as List emit the smallest item from these parallel Lists to the Subscriber.

Uses of Flowable in io.reactivex.rxjava3.internal.operators.single

Subclasses of Flowable in io.reactivex.rxjava3.internal.operators.single

Modifier and Type	Class	Description
final class	SingleFlatMapIterableFlowable<T,R>	Maps a success value into an Iterable and streams it back as a Flowable.
final class	SingleFlatMapPublisher<T,R>	A Flowable that emits items based on applying a specified function to the item emitted by the source Single, where that function returns a Publisher.
final class	SingleToFlowable<T>	Wraps a Single and exposes it as a Flowable.

Methods in io.reactivex.rxjava3.internal.operators.single that return Flowable

Modifier and Type	Method	Description
Flowable<T>	SingleInternalHelper.ToFlowableIterator.next()

Methods in io.reactivex.rxjava3.internal.operators.single that return types with arguments of type Flowable

Modifier and Type	Method	Description
static <T> Iterable<? extends Flowable<T>>	SingleInternalHelper.iterableToFlowable(Iterable<? extends SingleSource<? extends T>> sources)
Iterator<Flowable<T>>	SingleInternalHelper.ToFlowableIterable.iterator()

Uses of Flowable in io.reactivex.rxjava3.internal.schedulers

Fields in io.reactivex.rxjava3.internal.schedulers with type parameters of type Flowable

Modifier and Type	Field	Description
private final FlowableProcessor<Flowable<Completable>>	SchedulerWhen.workerProcessor

Constructor parameters in io.reactivex.rxjava3.internal.schedulers with type arguments of type Flowable

Modifier	Constructor	Description
	SchedulerWhen(Function<Flowable<Flowable<Completable>>,Completable> combine, Scheduler actualScheduler)
	SchedulerWhen(Function<Flowable<Flowable<Completable>>,Completable> combine, Scheduler actualScheduler)

Uses of Flowable in io.reactivex.rxjava3.parallel

Methods in io.reactivex.rxjava3.parallel that return Flowable

Modifier and Type	Method	Description
final <@NonNull A, @NonNull R> @NonNull Flowable<R>	ParallelFlowable.collect(@NonNull Collector<@NonNull T,@NonNull A,@NonNull R> collector)	Reduces all values within a 'rail' and across 'rails' with a callbacks of the given Collector into one Flowable containing a single value.
final @NonNull Flowable<T>	ParallelFlowable.reduce(@NonNull BiFunction<@NonNull T,@NonNull T,@NonNull T> reducer)	Reduces all values within a 'rail' and across 'rails' with a reducer function into one Flowable sequence.
final @NonNull Flowable<T>	ParallelFlowable.sequential()	Merges the values from each 'rail' in a round-robin or same-order fashion and exposes it as a regular Flowable sequence, running with a default prefetch value for the rails.
final @NonNull Flowable<T>	ParallelFlowable.sequential(int prefetch)	Merges the values from each 'rail' in a round-robin or same-order fashion and exposes it as a regular Flowable sequence, running with a give prefetch value for the rails.
final @NonNull Flowable<T>	ParallelFlowable.sequentialDelayError()	Merges the values from each 'rail' in a round-robin or same-order fashion and exposes it as a regular Flowable sequence, running with a default prefetch value for the rails and delaying errors from all rails till all terminate.
final @NonNull Flowable<T>	ParallelFlowable.sequentialDelayError(int prefetch)	Merges the values from each 'rail' in a round-robin or same-order fashion and exposes it as a regular Flowable sequence, running with a give prefetch value for the rails and delaying errors from all rails till all terminate.
final @NonNull Flowable<T>	ParallelFlowable.sorted(@NonNull Comparator<? super @NonNull T> comparator)	Sorts the 'rails' of this ParallelFlowable and returns a Flowable that sequentially picks the smallest next value from the rails.
final @NonNull Flowable<T>	ParallelFlowable.sorted(@NonNull Comparator<? super @NonNull T> comparator, int capacityHint)	Sorts the 'rails' of this ParallelFlowable and returns a Flowable that sequentially picks the smallest next value from the rails.
final @NonNull Flowable<List<T>>	ParallelFlowable.toSortedList(@NonNull Comparator<? super @NonNull T> comparator)	Sorts the 'rails' according to the comparator and returns a full sorted List as a Flowable.
final @NonNull Flowable<@NonNull List<T>>	ParallelFlowable.toSortedList(@NonNull Comparator<? super @NonNull T> comparator, int capacityHint)	Sorts the 'rails' according to the comparator and returns a full sorted List as a Flowable.

Uses of Flowable in io.reactivex.rxjava3.plugins

Fields in io.reactivex.rxjava3.plugins with type parameters of type Flowable

Modifier and Type	Field	Description
(package private) static @Nullable Function<? super Flowable,? extends Flowable>	RxJavaPlugins.onFlowableAssembly
(package private) static @Nullable Function<? super Flowable,? extends Flowable>	RxJavaPlugins.onFlowableAssembly
(package private) static @Nullable BiFunction<? super Flowable,@NonNull ? super org.reactivestreams.Subscriber,@NonNull ? extends org.reactivestreams.Subscriber>	RxJavaPlugins.onFlowableSubscribe

Methods in io.reactivex.rxjava3.plugins that return Flowable

Modifier and Type	Method	Description
static <@NonNull T> @NonNull Flowable<T>	RxJavaPlugins.onAssembly(@NonNull Flowable<@NonNull T> source)	Calls the associated hook function.

Methods in io.reactivex.rxjava3.plugins that return types with arguments of type Flowable

Modifier and Type	Method	Description
static @Nullable Function<? super Flowable,? extends Flowable>	RxJavaPlugins.getOnFlowableAssembly()	Returns the current hook function.
static @Nullable Function<? super Flowable,? extends Flowable>	RxJavaPlugins.getOnFlowableAssembly()	Returns the current hook function.
static @Nullable BiFunction<? super Flowable,@NonNull ? super org.reactivestreams.Subscriber,@NonNull ? extends org.reactivestreams.Subscriber>	RxJavaPlugins.getOnFlowableSubscribe()	Returns the current hook function.

Methods in io.reactivex.rxjava3.plugins with parameters of type Flowable

Modifier and Type	Method	Description
static <@NonNull T> @NonNull Flowable<T>	RxJavaPlugins.onAssembly(@NonNull Flowable<@NonNull T> source)	Calls the associated hook function.
static <@NonNull T> @NonNull org.reactivestreams.Subscriber<? super T>	RxJavaPlugins.onSubscribe(@NonNull Flowable<@NonNull T> source, @NonNull org.reactivestreams.Subscriber<? super @NonNull T> subscriber)	Calls the associated hook function.

Method parameters in io.reactivex.rxjava3.plugins with type arguments of type Flowable

Modifier and Type	Method	Description
static void	RxJavaPlugins.setOnFlowableAssembly(@Nullable Function<? super Flowable,? extends Flowable> onFlowableAssembly)	Sets the specific hook function.
static void	RxJavaPlugins.setOnFlowableAssembly(@Nullable Function<? super Flowable,? extends Flowable> onFlowableAssembly)	Sets the specific hook function.
static void	RxJavaPlugins.setOnFlowableSubscribe(@Nullable BiFunction<? super Flowable,@NonNull ? super org.reactivestreams.Subscriber,@NonNull ? extends org.reactivestreams.Subscriber> onFlowableSubscribe)	Sets the specific hook function.

Uses of Flowable in io.reactivex.rxjava3.processors

Subclasses of Flowable in io.reactivex.rxjava3.processors

Modifier and Type	Class	Description
final class	AsyncProcessor<T>	Processor that emits the very last value followed by a completion event or the received error to Subscribers.
final class	BehaviorProcessor<T>	Processor that emits the most recent item it has observed and all subsequent observed items to each subscribed Subscriber.
class	FlowableProcessor<T>	Represents a Subscriber and a Flowable (Publisher) at the same time, allowing multicasting events from a single source to multiple child Subscribers.
final class	MulticastProcessor<T>	A FlowableProcessor implementation that coordinates downstream requests through a front-buffer and stable-prefetching, optionally canceling the upstream if all subscribers have cancelled.
final class	PublishProcessor<T>	Processor that multicasts all subsequently observed items to its current Subscribers.
final class	ReplayProcessor<T>	Replays events to Subscribers.
(package private) final class	SerializedProcessor<T>	Serializes calls to the Subscriber methods.
final class	UnicastProcessor<T>	A FlowableProcessor variant that queues up events until a single Subscriber subscribes to it, replays those events to it until the Subscriber catches up and then switches to relaying events live to this single Subscriber until this UnicastProcessor terminates or the Subscriber cancels its subscription.