Uses of Class
io.reactivex.rxjava3.core.Flowable
Packages that use Flowable
Package
Description
Base reactive classes:
Flowable
, Observable
,
Single
, Maybe
and
Completable
; base reactive consumers;
other common base interfaces.Classes supporting the Flowable base reactive class:
ConnectableFlowable
and
GroupedFlowable
.Base interfaces and types for supporting operator-fusion.
Contains the base type
ParallelFlowable
,
a sub-DSL for working with Flowable
sequences in parallel.Contains the central plugin handler
RxJavaPlugins
class to hook into the lifecycle of the base reactive types and schedulers.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 FlowableModifier and TypeMethodDescriptionFlowable.amb
(@NonNull Iterable<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources) Mirrors the onePublisher
in anIterable
of severalPublisher
s that first either emits an item or sends a termination notification.Mirrors the onePublisher
in an array of severalPublisher
s that first either emits an item or sends a termination notification.Mirrors thePublisher
(current or provided) that first either emits an item or sends a termination notification.Returns aFlowable
which will subscribe to thisCompletable
and once that is completed then will subscribe to thenext
Publisher
.Flowable.buffer
(int count) Returns aFlowable
that emits buffers of items it collects from the currentFlowable
.Flowable.buffer
(int count, int skip) Returns aFlowable
that emits buffers of items it collects from the currentFlowable
.Returns aFlowable
that emits buffers of items it collects from the currentFlowable
.Returns aFlowable
that emits buffers of items it collects from the currentFlowable
.Returns aFlowable
that emits buffers of items it collects from the currentFlowable
.Returns aFlowable
that emits buffers of items it collects from the currentFlowable
.Flowable.buffer
(long timespan, long timeskip, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, @NonNull Supplier<@NonNull U> bufferSupplier) Returns aFlowable
that emits buffers of items it collects from the currentFlowable
.Returns aFlowable
that emits buffers of items it collects from the currentFlowable
.Returns aFlowable
that emits buffers of items it collects from the currentFlowable
.Returns aFlowable
that emits buffers of items it collects from the currentFlowable
.Returns aFlowable
that emits buffers of items it collects from the currentFlowable
.Flowable.buffer
(long timespan, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, int count, @NonNull Supplier<@NonNull U> bufferSupplier, boolean restartTimerOnMaxSize) Returns aFlowable
that emits buffers of items it collects from the currentFlowable
.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 aFlowable
that emits buffers of items it collects from the currentFlowable
.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 aFlowable
that emits buffers of items it collects from the currentFlowable
.Returns aFlowable
that emits non-overlapping buffered items from the currentFlowable
each time the specified boundaryPublisher
emits an item.Flowable.buffer
(@NonNull org.reactivestreams.Publisher<@NonNull B> boundaryIndicator, int initialCapacity) Returns aFlowable
that emits non-overlapping buffered items from the currentFlowable
each time the specified boundaryPublisher
emits an item.Flowable.buffer
(@NonNull org.reactivestreams.Publisher<@NonNull B> boundaryIndicator, @NonNull Supplier<@NonNull U> bufferSupplier) Returns aFlowable
that emits non-overlapping buffered items from the currentFlowable
each time the specified boundaryPublisher
emits an item.Flowable.cache()
Returns aFlowable
that subscribes to thisPublisher
lazily, caches all of its events and replays them, in the same order as received, to all the downstream subscribers.Flowable.cacheWithInitialCapacity
(int initialCapacity) Returns aFlowable
that subscribes to thisPublisher
lazily, caches all of its events and replays them, in the same order as received, to all the downstream subscribers.Returns aFlowable
that emits the upstream items while they can be cast viaClass.cast(Object)
until the upstream terminates, or until the upstream signals an item which can't be cast, resulting in aClassCastException
to be signaled to the downstream.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 sourcePublisher
s by emitting an item that aggregates the latest values of each of the sourcePublisher
s each time an item is received from any of the sourcePublisher
s, where this aggregation is defined by a specified function.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 sourcePublisher
s by emitting an item that aggregates the latest values of each of the sourcePublisher
s each time an item is received from any of the sourcePublisher
s, where this aggregation is defined by a specified function.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 sourcePublisher
s by emitting an item that aggregates the latest values of each of the sourcePublisher
s each time an item is received from either of the sourcePublisher
s, where this aggregation is defined by a specified function.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 sourcePublisher
s by emitting an item that aggregates the latest values of each of the sourcePublisher
s each time an item is received from any of the sourcePublisher
s, where this aggregation is defined by a specified function.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 sourcePublisher
s by emitting an item that aggregates the latest values of each of the sourcePublisher
s each time an item is received from any of the sourcePublisher
s, 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 sourcePublisher
s by emitting an item that aggregates the latest values of each of the sourcePublisher
s each time an item is received from any of the sourcePublisher
s, 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 sourcePublisher
s by emitting an item that aggregates the latest values of each of the sourcePublisher
s each time an item is received from any of the sourcePublisher
s, 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 sourcePublisher
s by emitting an item that aggregates the latest values of each of the sourcePublisher
s each time an item is received from any of the sourcePublisher
s, 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 sourcePublisher
s by emitting an item that aggregates the latest values of each of the sourcePublisher
s each time an item is received from any of the sourcePublisher
s, 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 sourcePublisher
s by emitting an item that aggregates the latest values of each of the sourcePublisher
s each time an item is received from any of the sourcePublisher
s, where this aggregation is defined by a specified function.Flowable.combineLatestArray
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T>[] sources, @NonNull Function<? super Object[], ? extends @NonNull R> combiner) Combines a collection of sourcePublisher
s by emitting an item that aggregates the latest values of each of the sourcePublisher
s each time an item is received from any of the sourcePublisher
s, where this aggregation is defined by a specified function.Flowable.combineLatestArray
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T>[] sources, @NonNull Function<? super Object[], ? extends @NonNull R> combiner, int bufferSize) Combines a collection of sourcePublisher
s by emitting an item that aggregates the latest values of each of the sourcePublisher
s each time an item is received from any of the sourcePublisher
s, where this aggregation is defined by a specified function.Flowable.combineLatestArrayDelayError
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T>[] sources, @NonNull Function<? super Object[], ? extends @NonNull R> combiner) Combines a collection of sourcePublisher
s by emitting an item that aggregates the latest values of each of the sourcePublisher
s each time an item is received from any of the sourcePublisher
s, where this aggregation is defined by a specified function.Flowable.combineLatestArrayDelayError
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T>[] sources, @NonNull Function<? super Object[], ? extends @NonNull R> combiner, int bufferSize) Combines a collection of sourcePublisher
s by emitting an item that aggregates the latest values of each of the sourcePublisher
s each time an item is received from any of the sourcePublisher
s, where this aggregation is defined by a specified function and delays any error from the sources until all sourcePublisher
s terminate.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 sourcePublisher
s by emitting an item that aggregates the latest values of each of the sourcePublisher
s each time an item is received from any of the sourcePublisher
s, where this aggregation is defined by a specified function and delays any error from the sources until all sourcePublisher
s terminate.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 sourcePublisher
s by emitting an item that aggregates the latest values of each of the sourcePublisher
s each time an item is received from any of the sourcePublisher
s, where this aggregation is defined by a specified function and delays any error from the sources until all sourcePublisher
s terminate.Transform the currentFlowable
by applying a particularFlowableTransformer
function to it.Flowable.concat
(@NonNull Iterable<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources) Concatenates elements of eachPublisher
provided via anIterable
sequence into a single sequence of elements without interleaving them.Flowable.concat
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T> source2) Returns aFlowable
that emits the items emitted by twoPublisher
s, one after the other, without interleaving them.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 aFlowable
that emits the items emitted by threePublisher
s, one after the other, without interleaving them.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 aFlowable
that emits the items emitted by fourPublisher
s, one after the other, without interleaving them.Flowable.concat
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources) Returns aFlowable
that emits the items emitted by each of thePublisher
s emitted by the sourcePublisher
, one after the other, without interleaving them.Flowable.concat
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources, int prefetch) Returns aFlowable
that emits the items emitted by each of thePublisher
s emitted by the sourcePublisher
, one after the other, without interleaving them.Maybe.concat
(@NonNull MaybeSource<? extends @NonNull T> source1, @NonNull MaybeSource<? extends @NonNull T> source2) Returns aFlowable
that emits the items emitted by twoMaybeSource
s, one after the other.Maybe.concat
(@NonNull MaybeSource<? extends @NonNull T> source1, @NonNull MaybeSource<? extends @NonNull T> source2, @NonNull MaybeSource<? extends @NonNull T> source3) Returns aFlowable
that emits the items emitted by threeMaybeSource
s, one after the other.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 aFlowable
that emits the items emitted by fourMaybeSource
s, one after the other.Concatenate the single values, in a non-overlapping fashion, of theMaybeSource
sources provided by anIterable
sequence as aFlowable
sequence.Maybe.concat
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends MaybeSource<? extends @NonNull T>> sources) Concatenate the single values, in a non-overlapping fashion, of theMaybeSource
sources provided by aPublisher
sequence as aFlowable
sequence.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 theMaybeSource
sources provided by aPublisher
sequence as aFlowable
sequence.Single.concat
(@NonNull SingleSource<? extends @NonNull T> source1, @NonNull SingleSource<? extends @NonNull T> source2) Returns aFlowable
that emits the items emitted by twoSingleSource
s, one after the other.Single.concat
(@NonNull SingleSource<? extends @NonNull T> source1, @NonNull SingleSource<? extends @NonNull T> source2, @NonNull SingleSource<? extends @NonNull T> source3) Returns aFlowable
that emits the items emitted by threeSingleSource
s, one after the other.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 aFlowable
that emits the items emitted by fourSingleSource
s, one after the other.Concatenate the single values, in a non-overlapping fashion, of theSingleSource
s provided by anIterable
sequence.Single.concat
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends SingleSource<? extends @NonNull T>> sources) Concatenate the single values, in a non-overlapping fashion, of theSingleSource
s provided by aPublisher
sequence.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 theSingleSource
s provided by aPublisher
sequence and prefetched by the specified amount.Flowable.concatArray
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T>... sources) Concatenates a variable number ofPublisher
sources.Maybe.concatArray
(@NonNull MaybeSource<? extends @NonNull T>... sources) Concatenate the single values, in a non-overlapping fashion, of theMaybeSource
sources in the array as aFlowable
sequence.Single.concatArray
(@NonNull SingleSource<? extends @NonNull T>... sources) Concatenate the single values, in a non-overlapping fashion, of theSingleSource
s provided in an array.Flowable.concatArrayDelayError
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T>... sources) Concatenates a variable number ofPublisher
sources and delays errors from any of them till all terminate.Maybe.concatArrayDelayError
(@NonNull MaybeSource<? extends @NonNull T>... sources) Concatenates a variable number ofMaybeSource
sources and delays errors from any of them till all terminate as aFlowable
sequence.Single.concatArrayDelayError
(@NonNull SingleSource<? extends @NonNull T>... sources) Concatenate the single values, in a non-overlapping fashion, of theSingleSource
s provided in an array.Flowable.concatArrayEager
(int maxConcurrency, int prefetch, @NonNull org.reactivestreams.Publisher<? extends @NonNull T>... sources) Concatenates an array ofPublisher
s eagerly into a single stream of values.Flowable.concatArrayEager
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T>... sources) Concatenates an array ofPublisher
s eagerly into a single stream of values.Maybe.concatArrayEager
(@NonNull MaybeSource<? extends @NonNull T>... sources) Concatenates a sequence ofMaybeSource
eagerly into aFlowable
sequence.Single.concatArrayEager
(@NonNull SingleSource<? extends @NonNull T>... sources) Concatenates a sequence ofSingleSource
eagerly into a single stream of values.Flowable.concatArrayEagerDelayError
(int maxConcurrency, int prefetch, @NonNull org.reactivestreams.Publisher<? extends @NonNull T>... sources) Concatenates an array ofPublisher
s eagerly into a single stream of values and delaying any errors until all sources terminate.Flowable.concatArrayEagerDelayError
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T>... sources) Concatenates an array ofPublisher
s eagerly into a single stream of values and delaying any errors until all sources terminate.Maybe.concatArrayEagerDelayError
(@NonNull MaybeSource<? extends @NonNull T>... sources) Concatenates a sequence ofMaybeSource
eagerly into aFlowable
sequence.Single.concatArrayEagerDelayError
(@NonNull SingleSource<? extends @NonNull T>... sources) Concatenates a sequence ofSingleSource
eagerly into a single stream of values.Flowable.concatDelayError
(@NonNull Iterable<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources) Concatenates theIterable
sequence ofPublisher
s into a single sequence by subscribing to eachPublisher
, one after the other, one at a time and delays any errors till the all innerPublisher
s terminate.Flowable.concatDelayError
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources) Concatenates thePublisher
sequence ofPublisher
s into a single sequence by subscribing to each innerPublisher
, one after the other, one at a time and delays any errors till the all inner and the outerPublisher
s terminate.Flowable.concatDelayError
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources, int prefetch, boolean tillTheEnd) Concatenates thePublisher
sequence ofPublisher
s into a single sequence by subscribing to each innerPublisher
, one after the other, one at a time and delays any errors till the all inner and the outerPublisher
s terminate.Maybe.concatDelayError
(@NonNull Iterable<@NonNull ? extends MaybeSource<? extends @NonNull T>> sources) Concatenates theIterable
sequence ofMaybeSource
s into a single sequence by subscribing to eachMaybeSource
, one after the other, one at a time and delays any errors till the all innerMaybeSource
s terminate as aFlowable
sequence.Maybe.concatDelayError
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends MaybeSource<? extends @NonNull T>> sources) Concatenates thePublisher
sequence ofMaybeSource
s into a single sequence by subscribing to each innerMaybeSource
, one after the other, one at a time and delays any errors till the all inner and the outerPublisher
terminate as aFlowable
sequence.Maybe.concatDelayError
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends MaybeSource<? extends @NonNull T>> sources, int prefetch) Concatenates thePublisher
sequence ofMaybeSource
s into a single sequence by subscribing to each innerMaybeSource
, one after the other, one at a time and delays any errors till the all inner and the outerPublisher
terminate as aFlowable
sequence.Single.concatDelayError
(@NonNull Iterable<@NonNull ? extends SingleSource<? extends @NonNull T>> sources) Concatenates theIterable
sequence ofSingleSource
s into a single sequence by subscribing to eachSingleSource
, one after the other, one at a time and delays any errors till the all innerSingleSource
s terminate as aFlowable
sequence.Single.concatDelayError
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends SingleSource<? extends @NonNull T>> sources) Concatenates thePublisher
sequence ofSingleSource
s into a single sequence by subscribing to each innerSingleSource
, one after the other, one at a time and delays any errors till the all inner and the outerPublisher
terminate as aFlowable
sequence.Single.concatDelayError
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends SingleSource<? extends @NonNull T>> sources, int prefetch) Concatenates thePublisher
sequence ofSingleSource
s into a single sequence by subscribing to each innerSingleSource
, one after the other, one at a time and delays any errors till the all inner and the outerPublisher
terminate as aFlowable
sequence.Flowable.concatEager
(@NonNull Iterable<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources) Concatenates a sequence ofPublisher
s eagerly into a single stream of values.Flowable.concatEager
(@NonNull Iterable<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources, int maxConcurrency, int prefetch) Concatenates a sequence ofPublisher
s eagerly into a single stream of values and runs a limited number of inner sequences at once.Flowable.concatEager
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources) Concatenates aPublisher
sequence ofPublisher
s eagerly into a single stream of values.Flowable.concatEager
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources, int maxConcurrency, int prefetch) Concatenates aPublisher
sequence ofPublisher
s eagerly into a single stream of values and runs a limited number of inner sequences at once.Maybe.concatEager
(@NonNull Iterable<@NonNull ? extends MaybeSource<? extends @NonNull T>> sources) Concatenates a sequence ofMaybeSource
s eagerly into aFlowable
sequence.Maybe.concatEager
(@NonNull Iterable<@NonNull ? extends MaybeSource<? extends @NonNull T>> sources, int maxConcurrency) Concatenates a sequence ofMaybeSource
s eagerly into aFlowable
sequence and runs a limited number of the inner sequences at once.Maybe.concatEager
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends MaybeSource<? extends @NonNull T>> sources) Maybe.concatEager
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends MaybeSource<? extends @NonNull T>> sources, int maxConcurrency) Concatenates aPublisher
sequence ofMaybeSource
s eagerly into aFlowable
sequence, running at most the given number of innerMaybeSource
s at once.Single.concatEager
(@NonNull Iterable<@NonNull ? extends SingleSource<? extends @NonNull T>> sources) Concatenates anIterable
sequence ofSingleSource
s eagerly into a single stream of values.Single.concatEager
(@NonNull Iterable<@NonNull ? extends SingleSource<? extends @NonNull T>> sources, int maxConcurrency) Concatenates anIterable
sequence ofSingleSource
s eagerly into a single stream of values and runs a limited number of the inner sources at once.Single.concatEager
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends SingleSource<? extends @NonNull T>> sources) Concatenates aPublisher
sequence ofSingleSource
s eagerly into a single stream of values.Single.concatEager
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends SingleSource<? extends @NonNull T>> sources, int maxConcurrency) Concatenates aPublisher
sequence ofSingleSource
s eagerly into a single stream of values and runs a limited number of those innerSingleSource
s at once.Flowable.concatEagerDelayError
(@NonNull Iterable<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources) Concatenates a sequence ofPublisher
s eagerly into a single stream of values, delaying errors until all the inner sequences terminate.Flowable.concatEagerDelayError
(@NonNull Iterable<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources, int maxConcurrency, int prefetch) Concatenates a sequence ofPublisher
s 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.Flowable.concatEagerDelayError
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources) Concatenates aPublisher
sequence ofPublisher
s eagerly into a single stream of values, delaying errors until all the inner and the outer sequences terminate.Flowable.concatEagerDelayError
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources, int maxConcurrency, int prefetch) Concatenates aPublisher
sequence ofPublisher
s 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.Maybe.concatEagerDelayError
(@NonNull Iterable<@NonNull ? extends MaybeSource<? extends @NonNull T>> sources) Concatenates a sequence ofMaybeSource
s eagerly into aFlowable
sequence, delaying errors until all innerMaybeSource
s terminate.Maybe.concatEagerDelayError
(@NonNull Iterable<@NonNull ? extends MaybeSource<? extends @NonNull T>> sources, int maxConcurrency) Concatenates a sequence ofMaybeSource
s eagerly into aFlowable
sequence, delaying errors until all innerMaybeSource
s terminate and runs a limited number of innerMaybeSource
s at once.Maybe.concatEagerDelayError
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends MaybeSource<? extends @NonNull T>> sources) Concatenates aPublisher
sequence ofMaybeSource
s eagerly into aFlowable
sequence, delaying errors until all the inner and the outer sequence terminate.Maybe.concatEagerDelayError
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends MaybeSource<? extends @NonNull T>> sources, int maxConcurrency) Concatenates aPublisher
sequence ofMaybeSource
s eagerly into aFlowable
sequence, delaying errors until all the inner and the outer sequence terminate and runs a limited number of the innerMaybeSource
s at once.Single.concatEagerDelayError
(@NonNull Iterable<@NonNull ? extends SingleSource<? extends @NonNull T>> sources) Concatenates anIterable
sequence ofSingleSource
s eagerly into a single stream of values, delaying errors until all the inner sources terminate.Single.concatEagerDelayError
(@NonNull Iterable<@NonNull ? extends SingleSource<? extends @NonNull T>> sources, int maxConcurrency) Concatenates anIterable
sequence ofSingleSource
s eagerly into a single stream of values, delaying errors until all the inner sources terminate.Single.concatEagerDelayError
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends SingleSource<? extends @NonNull T>> sources) Concatenates aPublisher
sequence ofSingleSource
s eagerly into a single stream of values, delaying errors until all the inner and the outer sequence terminate.Single.concatEagerDelayError
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends SingleSource<? extends @NonNull T>> sources, int maxConcurrency) Concatenates aPublisher
sequence ofSingleSource
s eagerly into a single stream of values, running at most the specified number of those innerSingleSource
s at once and delaying errors until all the inner and the outer sequence terminate.Flowable.concatMap
(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> mapper) Returns a newFlowable
that emits items resulting from applying a function that you supply to each item emitted by the currentFlowable
, where that function returns aPublisher
, and then emitting the items that result from concatenating those returnedPublisher
s.Flowable.concatMap
(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> mapper, int prefetch) Returns a newFlowable
that emits items resulting from applying a function that you supply to each item emitted by the currentFlowable
, where that function returns aPublisher
, and then emitting the items that result from concatenating those returnedPublisher
s.Flowable.concatMap
(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> mapper, int prefetch, @NonNull Scheduler scheduler) Returns a newFlowable
that emits items resulting from applying a function (on a designated scheduler) that you supply to each item emitted by the currentFlowable
, where that function returns aPublisher
, and then emitting the items that result from concatenating those returnedPublisher
s.Flowable.concatMapDelayError
(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> mapper) Maps each of the items into aPublisher
, 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 innerPublisher
s till all of them terminate.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 aPublisher
, 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 innerPublisher
s till all of them terminate.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 aPublisher
, 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 innerPublisher
s till all of them terminate.Flowable.concatMapEager
(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> mapper) Maps a sequence of values intoPublisher
s and concatenates thesePublisher
s eagerly into a singlePublisher
.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 intoPublisher
s and concatenates thesePublisher
s eagerly into a singlePublisher
.Flowable.concatMapEagerDelayError
(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> mapper, boolean tillTheEnd) Maps a sequence of values intoPublisher
s and concatenates thesePublisher
s eagerly into a singlePublisher
.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 intoPublisher
s and concatenates thesePublisher
s eagerly into a singleFlowable
sequence.Flowable.concatMapIterable
(@NonNull Function<? super @NonNull T, @NonNull ? extends Iterable<? extends @NonNull U>> mapper) Returns aFlowable
that concatenate each item emitted by the currentFlowable
with the values in anIterable
corresponding to that item that is generated by a selector.Flowable.concatMapIterable
(@NonNull Function<? super @NonNull T, @NonNull ? extends Iterable<? extends @NonNull U>> mapper, int prefetch) Returns aFlowable
that concatenate each item emitted by the currentFlowable
with the values in anIterable
corresponding to that item that is generated by a selector.Flowable.concatMapMaybe
(@NonNull Function<? super @NonNull T, ? extends MaybeSource<? extends @NonNull R>> mapper) Maps the upstream items intoMaybeSource
s and subscribes to them one after the other succeeds or completes, emits their success value if available or terminates immediately if either thisFlowable
or the current innerMaybeSource
fail.Flowable.concatMapMaybe
(@NonNull Function<? super @NonNull T, ? extends MaybeSource<? extends @NonNull R>> mapper, int prefetch) Maps the upstream items intoMaybeSource
s and subscribes to them one after the other succeeds or completes, emits their success value if available or terminates immediately if either thisFlowable
or the current innerMaybeSource
fail.Flowable.concatMapMaybeDelayError
(@NonNull Function<? super @NonNull T, ? extends MaybeSource<? extends @NonNull R>> mapper) Maps the upstream items intoMaybeSource
s and subscribes to them one after the other terminates, emits their success value if available and delaying all errors till both thisFlowable
and all innerMaybeSource
s terminate.Flowable.concatMapMaybeDelayError
(@NonNull Function<? super @NonNull T, ? extends MaybeSource<? extends @NonNull R>> mapper, boolean tillTheEnd) Maps the upstream items intoMaybeSource
s and subscribes to them one after the other terminates, emits their success value if available and optionally delaying all errors till both thisFlowable
and all innerMaybeSource
s terminate.Flowable.concatMapMaybeDelayError
(@NonNull Function<? super @NonNull T, ? extends MaybeSource<? extends @NonNull R>> mapper, boolean tillTheEnd, int prefetch) Maps the upstream items intoMaybeSource
s and subscribes to them one after the other terminates, emits their success value if available and optionally delaying all errors till both thisFlowable
and all innerMaybeSource
s terminate.Flowable.concatMapSingle
(@NonNull Function<? super @NonNull T, ? extends SingleSource<? extends @NonNull R>> mapper) Maps the upstream items intoSingleSource
s and subscribes to them one after the other succeeds, emits their success values or terminates immediately if either thisFlowable
or the current innerSingleSource
fail.Flowable.concatMapSingle
(@NonNull Function<? super @NonNull T, ? extends SingleSource<? extends @NonNull R>> mapper, int prefetch) Maps the upstream items intoSingleSource
s and subscribes to them one after the other succeeds, emits their success values or terminates immediately if either thisFlowable
or the current innerSingleSource
fail.Flowable.concatMapSingleDelayError
(@NonNull Function<? super @NonNull T, ? extends SingleSource<? extends @NonNull R>> mapper) Maps the upstream items intoSingleSource
s and subscribes to them one after the other succeeds or fails, emits their success values and delays all errors till both thisFlowable
and all innerSingleSource
s terminate.Flowable.concatMapSingleDelayError
(@NonNull Function<? super @NonNull T, ? extends SingleSource<? extends @NonNull R>> mapper, boolean tillTheEnd) Maps the upstream items intoSingleSource
s and subscribes to them one after the other succeeds or fails, emits their success values and optionally delays all errors till both thisFlowable
and all innerSingleSource
s terminate.Flowable.concatMapSingleDelayError
(@NonNull Function<? super @NonNull T, ? extends SingleSource<? extends @NonNull R>> mapper, boolean tillTheEnd, int prefetch) Maps the upstream items intoSingleSource
s and subscribes to them one after the other succeeds or fails, emits their success values and optionally delays errors till both thisFlowable
and all innerSingleSource
s terminate.Flowable.concatMapStream
(@NonNull Function<? super @NonNull T, @NonNull ? extends Stream<? extends @NonNull R>> mapper) Maps each upstream item into aStream
and emits theStream
's items to the downstream in a sequential fashion.Flowable.concatMapStream
(@NonNull Function<? super @NonNull T, @NonNull ? extends Stream<? extends @NonNull R>> mapper, int prefetch) Maps each upstream item into aStream
and emits theStream
's items to the downstream in a sequential fashion.Flowable.concatWith
(@NonNull CompletableSource other) Returns aFlowable
that emits items from thisFlowable
and when it completes normally, the otherCompletableSource
is subscribed to and the returnedFlowable
emits its terminal events.Flowable.concatWith
(@NonNull MaybeSource<? extends @NonNull T> other) Returns aFlowable
that emits the items from thisFlowable
followed by the success item or terminal events of the otherMaybeSource
.Flowable.concatWith
(@NonNull SingleSource<? extends @NonNull T> other) Returns aFlowable
that emits the items from thisFlowable
followed by the success item or error event of the otherSingleSource
.Flowable.concatWith
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T> other) Returns aFlowable
that emits the items emitted from the currentFlowable
, then the next, one after the other, without interleaving them.Maybe.concatWith
(@NonNull MaybeSource<? extends @NonNull T> other) Returns aFlowable
that emits the items emitted from the currentMaybe
, then theother
MaybeSource
, one after the other, without interleaving them.Single.concatWith
(@NonNull SingleSource<? extends @NonNull T> other) Returns aFlowable
that emits the item emitted by the currentSingle
, then the item emitted by the specifiedSingleSource
.Flowable.create
(@NonNull FlowableOnSubscribe<@NonNull T> source, @NonNull BackpressureStrategy mode) Provides an API (via a coldFlowable
) that bridges the reactive world with the callback-style, generally non-backpressured world.Returns aFlowable
that mirrors the currentFlowable
, except that it drops items emitted by the currentFlowable
that are followed by newer items before a timeout value expires.Returns aFlowable
that mirrors the currentFlowable
, except that it drops items emitted by the currentFlowable
that are followed by newer items before a timeout value expires on a specifiedScheduler
.Flowable.debounce
(long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, @NonNull Consumer<? super @NonNull T> onDropped) Returns aFlowable
that mirrors the currentFlowable
, except that it drops items emitted by the currentFlowable
that are followed by newer items before a timeout value expires on a specifiedScheduler
.Flowable.debounce
(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<@NonNull U>> debounceIndicator) Returns aFlowable
that mirrors the currentFlowable
, except that it drops items emitted by the currentFlowable
that are followed by another item within a computed debounce duration.Flowable.defaultIfEmpty
(@NonNull T defaultItem) Returns aFlowable
that emits the items emitted by the currentFlowable
or a specified default item if the currentFlowable
is empty.Flowable.defer
(@NonNull Supplier<? extends @NonNull org.reactivestreams.Publisher<? extends @NonNull T>> supplier) Returns aFlowable
that calls aPublisher
factory to create aPublisher
for each newSubscriber
that subscribes.Returns aFlowable
that emits the items emitted by the currentFlowable
shifted forward in time by a specified delay.Returns aFlowable
that emits the items emitted by the currentFlowable
shifted forward in time by a specified delay.Returns aFlowable
that emits the items emitted by the currentFlowable
shifted forward in time by a specified delay.Returns aFlowable
that emits the items emitted by the currentFlowable
shifted forward in time by a specified delay.Flowable.delay
(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<@NonNull U>> itemDelayIndicator) Returns aFlowable
that delays the emissions of the currentFlowable
via anotherPublisher
on a per-item basis.Flowable.delay
(@NonNull org.reactivestreams.Publisher<@NonNull U> subscriptionIndicator, @NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<@NonNull V>> itemDelayIndicator) Returns aFlowable
that delays the subscription to and emissions from the currentFlowable
via anotherPublisher
on a per-item basis.Flowable.delaySubscription
(long time, @NonNull TimeUnit unit) Returns aFlowable
that delays the subscription to the currentFlowable
by a given amount of time.Flowable.delaySubscription
(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler) Returns aFlowable
that delays the subscription to the currentFlowable
by a given amount of time, both waiting and subscribing on a givenScheduler
.Flowable.delaySubscription
(@NonNull org.reactivestreams.Publisher<@NonNull U> subscriptionIndicator) Returns aFlowable
that delays the subscription to thisPublisher
until the otherPublisher
emits an element or completes normally.Flowable.dematerialize
(@NonNull Function<@NonNull ? super @NonNull T, @NonNull Notification<@NonNull R>> selector) Returns aFlowable
that reverses the effect ofmaterialize
by transforming theNotification
objects extracted from the source items via a selector function into their respectiveSubscriber
signal types.Flowable.distinct()
Returns aFlowable
that emits all items emitted by the currentFlowable
that are distinct based onObject.equals(Object)
comparison.Returns aFlowable
that emits all items emitted by the currentFlowable
that are distinct according to a key selector function and based onObject.equals(Object)
comparison of the objects returned by the key selector function.Flowable.distinct
(@NonNull Function<? super @NonNull T, @NonNull K> keySelector, @NonNull Supplier<? extends Collection<? super @NonNull K>> collectionSupplier) Returns aFlowable
that emits all items emitted by the currentFlowable
that are distinct according to a key selector function and based onObject.equals(Object)
comparison of the objects returned by the key selector function.Flowable.distinctUntilChanged()
Returns aFlowable
that emits all items emitted by the currentFlowable
that are distinct from their immediate predecessors based onObject.equals(Object)
comparison.Flowable.distinctUntilChanged
(@NonNull BiPredicate<? super @NonNull T, ? super @NonNull T> comparer) Returns aFlowable
that emits all items emitted by the currentFlowable
that are distinct from their immediate predecessors when compared with each other via the provided comparator function.Returns aFlowable
that emits all items emitted by the currentFlowable
that are distinct from their immediate predecessors, according to a key selector function and based onObject.equals(Object)
comparison of those objects returned by the key selector function.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.Flowable.doAfterTerminate
(@NonNull Action onAfterTerminate) Calls the specified action after thisFlowable
signalsonError
oronComplete
or gets canceled by the downstream.Flowable.doOnCancel
(@NonNull Action onCancel) Calls the cancelAction
if the downstream cancels the sequence.Flowable.doOnComplete
(@NonNull Action onComplete) 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.Invokes aConsumer
with aNotification
instances matching the signals emitted by the currentFlowable
before they are forwarded to the downstream.Calls the appropriate methods of the givenSubscriber
when the currentFlowable
signals events before forwarding it to the downstream.Flowable.doOnLifecycle
(@NonNull Consumer<? super org.reactivestreams.Subscription> onSubscribe, @NonNull LongConsumer onRequest, @NonNull Action onCancel) Calls the appropriateonXXX
method (shared between allSubscriber
s) for the lifecycle events of the sequence (subscription, cancellation, requesting).Calls the givenConsumer
with the value emitted by the currentFlowable
before forwarding it to the downstream.Flowable.doOnRequest
(@NonNull LongConsumer onRequest) Calls the givenLongConsumer
with the request amount from the downstream before forwarding it to the currentFlowable
.Flowable.doOnSubscribe
(@NonNull Consumer<? super org.reactivestreams.Subscription> onSubscribe) Calls the givenConsumer
with theSubscription
provided by the currentFlowable
upon subscription from the downstream before forwarding it to the subscriber'sonSubscribe
method.Flowable.doOnTerminate
(@NonNull Action onTerminate) Calls the givenAction
when the currentFlowable
completes normally or with an error before those signals are forwarded to the downstream.Flowable.empty()
Returns aFlowable
that emits no items to theSubscriber
and immediately invokes itsonComplete
method.Returns aFlowable
that invokes aSubscriber
'sonError
method when theSubscriber
subscribes to it.Returns aFlowable
that invokes aSubscriber
'sonError
method when theSubscriber
subscribes to it.Filters items emitted by the currentFlowable
by only emitting those that satisfy a specified predicate.Flowable.flatMap
(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> mapper) Returns aFlowable
that emits items based on applying a function that you supply to each item emitted by the currentFlowable
, where that function returns aPublisher
, and then merging those resultingPublisher
s and emitting the results of this merger.Flowable.flatMap
(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> mapper, boolean delayErrors) Returns aFlowable
that emits items based on applying a function that you supply to each item emitted by the currentFlowable
, where that function returns aPublisher
, and then merging those resultingPublisher
s and emitting the results of this merger.Flowable.flatMap
(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> mapper, boolean delayErrors, int maxConcurrency) Returns aFlowable
that emits items based on applying a function that you supply to each item emitted by the currentFlowable
, where that function returns aPublisher
, and then merging those resultingPublisher
s and emitting the results of this merger, while limiting the maximum number of concurrent subscriptions to thesePublisher
s.Flowable.flatMap
(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> mapper, boolean delayErrors, int maxConcurrency, int bufferSize) Returns aFlowable
that emits items based on applying a function that you supply to each item emitted by the currentFlowable
, where that function returns aPublisher
, and then merging those resultingPublisher
s and emitting the results of this merger, while limiting the maximum number of concurrent subscriptions to thesePublisher
s.Flowable.flatMap
(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> mapper, int maxConcurrency) Returns aFlowable
that emits items based on applying a function that you supply to each item emitted by the currentFlowable
, where that function returns aPublisher
, and then merging those resultingPublisher
s and emitting the results of this merger, while limiting the maximum number of concurrent subscriptions to thesePublisher
s.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 aFlowable
that applies a function to each item emitted or notification raised by the currentFlowable
and then flattens thePublisher
s returned from these functions and emits the resulting items.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 aFlowable
that applies a function to each item emitted or notification raised by the currentFlowable
and then flattens thePublisher
s returned from these functions and emits the resulting items, while limiting the maximum number of concurrent subscriptions to thesePublisher
s.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 aFlowable
that emits the results of a specified function to the pair of values emitted by the currentFlowable
and a specified collectionPublisher
.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 aFlowable
that emits the results of a specified function to the pair of values emitted by the currentFlowable
and a specified innerPublisher
.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 aFlowable
that emits the results of a specified function to the pair of values emitted by the currentFlowable
and a specified collectionPublisher
, while limiting the maximum number of concurrent subscriptions to thesePublisher
s.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 aFlowable
that emits the results of a specified function to the pair of values emitted by the currentFlowable
and a specified collectionPublisher
, while limiting the maximum number of concurrent subscriptions to thesePublisher
s.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 aFlowable
that emits the results of a specified function to the pair of values emitted by the currentFlowable
and a specified collectionPublisher
, while limiting the maximum number of concurrent subscriptions to thesePublisher
s.Flowable.flatMapIterable
(@NonNull Function<? super @NonNull T, @NonNull ? extends Iterable<? extends @NonNull U>> mapper) Flowable.flatMapIterable
(@NonNull Function<? super @NonNull T, @NonNull ? extends Iterable<? extends @NonNull U>> mapper, int bufferSize) 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) MergesIterable
s generated by a mapperFunction
for each individual item emitted by the currentFlowable
into a singleFlowable
sequence where the resulting items will be the combination of the original item and each inner item of the respectiveIterable
as returned by theresultSelector
BiFunction
.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) MergesIterable
s generated by a mapperFunction
for each individual item emitted by the currentFlowable
into a singleFlowable
sequence where the resulting items will be the combination of the original item and each inner item of the respectiveIterable
as returned by theresultSelector
BiFunction
.Flowable.flatMapMaybe
(@NonNull Function<? super @NonNull T, ? extends MaybeSource<? extends @NonNull R>> mapper) Maps each element of the upstreamFlowable
intoMaybeSource
s, subscribes to all of them and merges theironSuccess
values, in no particular order, into a singleFlowable
sequence.Flowable.flatMapMaybe
(@NonNull Function<? super @NonNull T, ? extends MaybeSource<? extends @NonNull R>> mapper, boolean delayErrors, int maxConcurrency) Maps each element of the upstreamFlowable
intoMaybeSource
s, subscribes to at mostmaxConcurrency
MaybeSource
s at a time and merges theironSuccess
values, in no particular order, into a singleFlowable
sequence, optionally delaying all errors.Maybe.flatMapPublisher
(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> mapper) Returns aFlowable
that emits items based on applying a specified function to the item emitted by the currentMaybe
, where that function returns aPublisher
.Single.flatMapPublisher
(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> mapper) Returns aFlowable
that emits items based on applying a specified function to the item emitted by the currentSingle
, where that function returns aPublisher
.Flowable.flatMapSingle
(@NonNull Function<? super @NonNull T, ? extends SingleSource<? extends @NonNull R>> mapper) Maps each element of the upstreamFlowable
intoSingleSource
s, subscribes to all of them and merges theironSuccess
values, in no particular order, into a singleFlowable
sequence.Flowable.flatMapSingle
(@NonNull Function<? super @NonNull T, ? extends SingleSource<? extends @NonNull R>> mapper, boolean delayErrors, int maxConcurrency) Maps each element of the upstreamFlowable
intoSingleSource
s, subscribes to at mostmaxConcurrency
SingleSource
s at a time and merges theironSuccess
values, in no particular order, into a singleFlowable
sequence, optionally delaying all errors.Flowable.flatMapStream
(@NonNull Function<? super @NonNull T, @NonNull ? extends Stream<? extends @NonNull R>> mapper) Maps each upstream item into aStream
and emits theStream
's items to the downstream in a sequential fashion.Flowable.flatMapStream
(@NonNull Function<? super @NonNull T, @NonNull ? extends Stream<? extends @NonNull R>> mapper, int prefetch) Maps each upstream item into aStream
and emits theStream
's items to the downstream in a sequential fashion.Maybe.flattenAsFlowable
(@NonNull Function<? super @NonNull T, @NonNull ? extends Iterable<? extends @NonNull U>> mapper) Single.flattenAsFlowable
(@NonNull Function<? super @NonNull T, @NonNull ? extends Iterable<? extends @NonNull U>> mapper) Maybe.flattenStreamAsFlowable
(@NonNull Function<? super @NonNull T, @NonNull ? extends Stream<? extends @NonNull R>> mapper) Single.flattenStreamAsFlowable
(@NonNull Function<? super @NonNull T, @NonNull ? extends Stream<? extends @NonNull R>> mapper) Flowable.fromAction
(@NonNull Action action) Returns aFlowable
instance that runs the givenAction
for eachSubscriber
and emits either its exception or simply completes.Converts an array into aPublisher
that emits the items in the array.Flowable.fromCallable
(@NonNull Callable<? extends @NonNull T> callable) Returns aFlowable
that, when aSubscriber
subscribes to it, invokes a function you specify and then emits the value returned from that function.Flowable.fromCompletable
(@NonNull CompletableSource completableSource) Wraps aCompletableSource
into aFlowable
.Flowable.fromCompletionStage
(@NonNull CompletionStage<@NonNull T> stage) Signals the completion value or error of the given (hot)CompletionStage
-based asynchronous calculation.Flowable.fromFuture
(@NonNull Future<? extends @NonNull T> future) Converts aFuture
into aPublisher
.Flowable.fromFuture
(@NonNull Future<? extends @NonNull T> future, long timeout, @NonNull TimeUnit unit) Flowable.fromIterable
(@NonNull Iterable<? extends @NonNull T> source) Converts anIterable
sequence into aPublisher
that emits the items in the sequence.Flowable.fromMaybe
(@NonNull MaybeSource<@NonNull T> maybe) Returns aFlowable
instance that when subscribed to, subscribes to theMaybeSource
instance and emitsonSuccess
as a single item or forwards anyonComplete
oronError
signal.Flowable.fromObservable
(@NonNull ObservableSource<@NonNull T> source, @NonNull BackpressureStrategy strategy) Converts the givenObservableSource
into aFlowable
by applying the specified backpressure strategy.Flowable.fromOptional
(@NonNull Optional<@NonNull T> optional) Converts the existing value of the provided optional into ajust(Object)
or an empty optional into anempty()
Flowable
instance.Flowable.fromPublisher
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T> publisher) Converts an arbitrary Reactive StreamsPublisher
into aFlowable
if not already aFlowable
.Flowable.fromRunnable
(@NonNull Runnable run) Returns aFlowable
instance that runs the givenRunnable
for eachSubscriber
and emits either its unchecked exception or simply completes.Flowable.fromSingle
(@NonNull SingleSource<@NonNull T> source) Returns aFlowable
instance that when subscribed to, subscribes to theSingleSource
instance and emitsonSuccess
as a single item or forwards theonError
signal.Flowable.fromStream
(@NonNull Stream<@NonNull T> stream) Converts aStream
into a finiteFlowable
and emits its items in the sequence.Flowable.fromSupplier
(@NonNull Supplier<? extends @NonNull T> supplier) Returns aFlowable
that, when aSubscriber
subscribes to it, invokes a supplier function you specify and then emits the value returned from that function.Returns a cold, synchronous, stateless and backpressure-aware generator of values.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.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.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.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>> Groups the items emitted by the currentFlowable
according to a specified criterion, and emits these grouped items asGroupedFlowable
s.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 currentFlowable
according to a specified criterion, and emits these grouped items asGroupedFlowable
s.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 currentFlowable
according to a specified criterion, and emits these grouped items asGroupedFlowable
s.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 currentFlowable
according to a specified criterion, and emits these grouped items asGroupedFlowable
s.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 currentFlowable
according to a specified criterion, and emits these grouped items asGroupedFlowable
s.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 currentFlowable
according to a specified criterion, and emits these grouped items asGroupedFlowable
s.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 aFlowable
that correlates twoPublisher
s when they overlap in time and groups the results.Flowable.hide()
Hides the identity of thisFlowable
and itsSubscription
.Returns aFlowable
that emits a0L
after theinitialDelay
and ever-increasing numbers after eachperiod
of time thereafter.Flowable.interval
(long initialDelay, long period, @NonNull TimeUnit unit, @NonNull Scheduler scheduler) Returns aFlowable
that emits a0L
after theinitialDelay
and ever-increasing numbers after eachperiod
of time thereafter, on a specifiedScheduler
.Returns aFlowable
that emits a sequential number every specified interval of time.Returns aFlowable
that emits a sequential number every specified interval of time, on a specifiedScheduler
.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.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.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 twoPublisher
s based on overlapping durations.Returns aFlowable
that signals the given (constant reference) item and then completes.Converts two items into aPublisher
that emits those items.Converts three items into aPublisher
that emits those items.Converts four items into aPublisher
that emits those items.Flowable.just
(@NonNull T item1, @NonNull T item2, @NonNull T item3, @NonNull T item4, @NonNull T item5) Converts five items into aPublisher
that emits those items.Flowable.just
(@NonNull T item1, @NonNull T item2, @NonNull T item3, @NonNull T item4, @NonNull T item5, @NonNull T item6) Converts six items into aPublisher
that emits those items.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 aPublisher
that emits those items.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 aPublisher
that emits those items.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 aPublisher
that emits those items.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 aPublisher
that emits those items.This method requires advanced knowledge about building operators, please consider other standard composition methods first; Returns aFlowable
which, when subscribed to, invokes theapply(Subscriber)
method of the providedFlowableOperator
for each individual downstreamSubscriber
and allows the insertion of a custom operator by accessing the downstream'sSubscriber
during this subscription phase and providing a newSubscriber
, containing the custom operator's intended business logic, that will be used in the subscription process going further upstream.Returns aFlowable
that applies a specified function to each item emitted by the currentFlowable
and emits the results of these function applications.Flowable.mapOptional
(@NonNull Function<? super @NonNull T, @NonNull Optional<? extends @NonNull R>> mapper) Maps each upstream value into anOptional
and emits the contained item if not empty.final @NonNull Flowable
<Notification<T>> Flowable.materialize()
Returns aFlowable
that represents all of the emissions and notifications from the currentFlowable
into emissions marked with their original types withinNotification
objects.Flowable.merge
(@NonNull Iterable<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources) Flowable.merge
(@NonNull Iterable<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources, int maxConcurrency) Flattens anIterable
ofPublisher
s into onePublisher
, without any transformation, while limiting the number of concurrent subscriptions to thesePublisher
s.Flowable.merge
(@NonNull Iterable<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources, int maxConcurrency, int bufferSize) Flattens anIterable
ofPublisher
s into onePublisher
, without any transformation, while limiting the number of concurrent subscriptions to thesePublisher
s.Flowable.merge
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T> source2) Flattens twoPublisher
s into a singlePublisher
, without any transformation.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 threePublisher
s into a singlePublisher
, without any transformation.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 fourPublisher
s into a singlePublisher
, without any transformation.Flowable.merge
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources) Flattens aPublisher
that emitsPublisher
s into a singlePublisher
that emits the items emitted by thosPublisher
s , without any transformation.Flowable.merge
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources, int maxConcurrency) Flattens aPublisher
that emitsPublisher
s into a singlePublisher
that emits the items emitted by thosePublisher
s, without any transformation, while limiting the maximum number of concurrent subscriptions to thesePublisher
s.Maybe.merge
(@NonNull MaybeSource<? extends @NonNull T> source1, @NonNull MaybeSource<? extends @NonNull T> source2) Flattens twoMaybeSource
s into a singleFlowable
, without any transformation.Maybe.merge
(@NonNull MaybeSource<? extends @NonNull T> source1, @NonNull MaybeSource<? extends @NonNull T> source2, @NonNull MaybeSource<? extends @NonNull T> source3) Flattens threeMaybeSource
s into a singleFlowable
, without any transformation.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 fourMaybeSource
s into a singleFlowable
, without any transformation.Merges anIterable
sequence ofMaybeSource
instances into a singleFlowable
sequence, running allMaybeSource
s at once.Maybe.merge
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends MaybeSource<? extends @NonNull T>> sources) Merges aPublisher
sequence ofMaybeSource
instances into a singleFlowable
sequence, running allMaybeSource
s at once.Maybe.merge
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends MaybeSource<? extends @NonNull T>> sources, int maxConcurrency) Merges aPublisher
sequence ofMaybeSource
instances into a singleFlowable
sequence, running at most maxConcurrencyMaybeSource
s at once.Single.merge
(@NonNull SingleSource<? extends @NonNull T> source1, @NonNull SingleSource<? extends @NonNull T> source2) Flattens twoSingleSource
s into oneFlowable
sequence, without any transformation.Single.merge
(@NonNull SingleSource<? extends @NonNull T> source1, @NonNull SingleSource<? extends @NonNull T> source2, @NonNull SingleSource<? extends @NonNull T> source3) Flattens threeSingleSource
s into oneFlowable
sequence, without any transformation.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 fourSingleSource
s into oneFlowable
sequence, without any transformation.Merges anIterable
sequence ofSingleSource
instances into a singleFlowable
sequence, running allSingleSource
s at once.Single.merge
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends SingleSource<? extends @NonNull T>> sources) Merges a sequence ofSingleSource
instances emitted by aPublisher
into a singleFlowable
sequence, running allSingleSource
s at once.Flowable.mergeArray
(int maxConcurrency, int bufferSize, @NonNull org.reactivestreams.Publisher<? extends @NonNull T>... sources) Flattens an array ofPublisher
s into onePublisher
, without any transformation, while limiting the number of concurrent subscriptions to thesePublisher
s.Flowable.mergeArray
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T>... sources) Flattens an array ofPublisher
s into onePublisher
, without any transformation.Maybe.mergeArray
(MaybeSource<? extends @NonNull T>... sources) Merges an array ofMaybeSource
instances into a singleFlowable
sequence, running allMaybeSource
s at once.Single.mergeArray
(SingleSource<? extends @NonNull T>... sources) Merges an array ofSingleSource
instances into a singleFlowable
sequence, running allSingleSource
s at once.Flowable.mergeArrayDelayError
(int maxConcurrency, int bufferSize, @NonNull org.reactivestreams.Publisher<? extends @NonNull T>... sources) Flattens an array ofPublisher
s into onePublisher
, in a way that allows aSubscriber
to receive all successfully emitted items from each of the sourcePublisher
s without being interrupted by an error notification from one of them, while limiting the number of concurrent subscriptions to thesePublisher
s.Flowable.mergeArrayDelayError
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T>... sources) Flattens an array ofPublisher
s into oneFlowable
, in a way that allows aSubscriber
to receive all successfully emitted items from each of the sourcePublisher
s without being interrupted by an error notification from one of them.Maybe.mergeArrayDelayError
(@NonNull MaybeSource<? extends @NonNull T>... sources) Flattens an array ofMaybeSource
s into oneFlowable
, in a way that allows a subscriber to receive all successfully emitted items from each of the sourceMaybeSource
s without being interrupted by an error notification from one of them.Single.mergeArrayDelayError
(@NonNull SingleSource<? extends @NonNull T>... sources) Flattens an array ofSingleSource
s into oneFlowable
, in a way that allows a subscriber to receive all successfully emitted items from each of the sourceSingleSource
s without being interrupted by an error notification from one of them.Flowable.mergeDelayError
(@NonNull Iterable<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources) Flattens anIterable
ofPublisher
s into onePublisher
, in a way that allows aSubscriber
to receive all successfully emitted items from each of the sourcePublisher
s without being interrupted by an error notification from one of them.Flowable.mergeDelayError
(@NonNull Iterable<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources, int maxConcurrency) Flattens anIterable
ofPublisher
s into onePublisher
, in a way that allows aSubscriber
to receive all successfully emitted items from each of the sourcePublisher
s without being interrupted by an error notification from one of them, while limiting the number of concurrent subscriptions to thesePublisher
s.Flowable.mergeDelayError
(@NonNull Iterable<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources, int maxConcurrency, int bufferSize) Flattens anIterable
ofPublisher
s into onePublisher
, in a way that allows aSubscriber
to receive all successfully emitted items from each of the sourcePublisher
s without being interrupted by an error notification from one of them, while limiting the number of concurrent subscriptions to thesePublisher
s.Flowable.mergeDelayError
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T> source2) Flattens twoPublisher
s into onePublisher
, in a way that allows aSubscriber
to receive all successfully emitted items from each of the sourcePublisher
s without being interrupted by an error notification from one of them.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 threePublisher
s into onePublisher
, in a way that allows aSubscriber
to receive all successfully emitted items from all of the sourcePublisher
s without being interrupted by an error notification from one of them.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 fourPublisher
s into onePublisher
, in a way that allows aSubscriber
to receive all successfully emitted items from all of the sourcePublisher
s without being interrupted by an error notification from one of them.Flowable.mergeDelayError
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources) Flattens aPublisher
that emitsPublisher
s into onePublisher
, in a way that allows aSubscriber
to receive all successfully emitted items from all of the sourcePublisher
s without being interrupted by an error notification from one of them.Flowable.mergeDelayError
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources, int maxConcurrency) Flattens aPublisher
that emitsPublisher
s into onePublisher
, in a way that allows aSubscriber
to receive all successfully emitted items from all of the sourcePublisher
s without being interrupted by an error notification from one of them, while limiting the number of concurrent subscriptions to thesePublisher
s.Maybe.mergeDelayError
(@NonNull MaybeSource<? extends @NonNull T> source1, @NonNull MaybeSource<? extends @NonNull T> source2) Flattens twoMaybeSource
s into oneFlowable
, in a way that allows a subscriber to receive all successfully emitted items from each of the sourceMaybeSource
s without being interrupted by an error notification from one of them.Maybe.mergeDelayError
(@NonNull MaybeSource<? extends @NonNull T> source1, @NonNull MaybeSource<? extends @NonNull T> source2, @NonNull MaybeSource<? extends @NonNull T> source3) Flattens threeMaybeSource
into oneFlowable
, in a way that allows a subscriber to receive all successfully emitted items from all of the sourceMaybeSource
s without being interrupted by an error notification from one of them.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 fourMaybeSource
s into oneFlowable
, in a way that allows a subscriber to receive all successfully emitted items from all of the sourceMaybeSource
s without being interrupted by an error notification from one of them.Maybe.mergeDelayError
(@NonNull Iterable<@NonNull ? extends MaybeSource<? extends @NonNull T>> sources) Flattens anIterable
sequence ofMaybeSource
s into oneFlowable
, in a way that allows a subscriber to receive all successfully emitted items from each of the sourceMaybeSource
s without being interrupted by an error notification from one of them.Maybe.mergeDelayError
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends MaybeSource<? extends @NonNull T>> sources) Flattens aPublisher
that emitsMaybeSource
s into oneFlowable
, in a way that allows a subscriber to receive all successfully emitted items from all of the sourceMaybeSource
s without being interrupted by an error notification from one of them or even the mainPublisher
.Maybe.mergeDelayError
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends MaybeSource<? extends @NonNull T>> sources, int maxConcurrency) Flattens aPublisher
that emitsMaybeSource
s into oneFlowable
, in a way that allows a subscriber to receive all successfully emitted items from all of the sourceMaybeSource
s without being interrupted by an error notification from one of them or even the mainPublisher
as well as limiting the total number of activeMaybeSource
s.Single.mergeDelayError
(@NonNull SingleSource<? extends @NonNull T> source1, @NonNull SingleSource<? extends @NonNull T> source2) Flattens twoSingleSource
s into oneFlowable
, without any transformation, delaying any error(s) until all sources succeed or fail.Single.mergeDelayError
(@NonNull SingleSource<? extends @NonNull T> source1, @NonNull SingleSource<? extends @NonNull T> source2, @NonNull SingleSource<? extends @NonNull T> source3) Flattens twoSingleSource
s into oneFlowable
, without any transformation, delaying any error(s) until all sources succeed or fail.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 twoSingleSource
s into oneFlowable
, without any transformation, delaying any error(s) until all sources succeed or fail.Single.mergeDelayError
(@NonNull Iterable<@NonNull ? extends SingleSource<? extends @NonNull T>> sources) Merges anIterable
sequence ofSingleSource
instances into oneFlowable
sequence, running allSingleSource
s at once and delaying any error(s) until all sources succeed or fail.Single.mergeDelayError
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends SingleSource<? extends @NonNull T>> sources) Merges a sequence ofSingleSource
instances emitted by aPublisher
into aFlowable
sequence, running allSingleSource
s at once and delaying any error(s) until all sources succeed or fail.Flowable.mergeWith
(@NonNull CompletableSource other) Relays the items of thisFlowable
and completes only when the otherCompletableSource
completes as well.Flowable.mergeWith
(@NonNull MaybeSource<? extends @NonNull T> other) Merges the sequence of items of thisFlowable
with the success value of the otherMaybeSource
or waits for both to complete normally if theMaybeSource
is empty.Flowable.mergeWith
(@NonNull SingleSource<? extends @NonNull T> other) Merges the sequence of items of thisFlowable
with the success value of the otherSingleSource
.Flattens this and anotherPublisher
into a singlePublisher
, without any transformation.Maybe.mergeWith
(@NonNull MaybeSource<? extends @NonNull T> other) Single.mergeWith
(@NonNull SingleSource<? extends @NonNull T> other) Flowable.never()
Returns aFlowable
that never sends any items or notifications to aSubscriber
.Signals the items and terminal signals of the currentFlowable
on the specifiedScheduler
, asynchronously with a bounded buffer ofbufferSize()
slots.Signals the items and terminal signals of the currentFlowable
on the specifiedScheduler
, asynchronously with a bounded buffer and optionally delaysonError
notifications.Signals the items and terminal signals of the currentFlowable
on the specifiedScheduler
, asynchronously with a bounded buffer of configurable size and optionally delaysonError
notifications.Filters the items emitted by the currentFlowable
, only emitting those of the specified type.Flowable.onBackpressureBuffer()
Buffers an unlimited number of items from the currentFlowable
and allows it to emit as fast it can while allowing the downstream to consume the items at its own place.Flowable.onBackpressureBuffer
(boolean delayError) Buffers an unlimited number of items from the currentFlowable
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.Flowable.onBackpressureBuffer
(int capacity) Buffers an limited number of items from the currentFlowable
and allows it to emit as fast it can while allowing the downstream to consume the items at its own place, however, the resultingFlowable
will signal aMissingBackpressureException
viaonError
as soon as the buffer's capacity is exceeded, dropping all undelivered items, and canceling the flow.Flowable.onBackpressureBuffer
(int capacity, boolean delayError) Buffers an limited number of items from the currentFlowable
and allows it to emit as fast it can while allowing the downstream to consume the items at its own place, however, the resultingFlowable
will signal aMissingBackpressureException
viaonError
as soon as the buffer's capacity is exceeded, dropping all undelivered items, and canceling the flow.Flowable.onBackpressureBuffer
(int capacity, boolean delayError, boolean unbounded) Buffers an optionally unlimited number of items from the currentFlowable
and allows it to emit as fast it can while allowing the downstream to consume the items at its own place.Flowable.onBackpressureBuffer
(int capacity, boolean delayError, boolean unbounded, @NonNull Action onOverflow) Buffers an optionally unlimited number of items from the currentFlowable
and allows it to emit as fast it can while allowing the downstream to consume the items at its own place.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 currentFlowable
and allows it to emit as fast it can while allowing the downstream to consume the items at its own place.Flowable.onBackpressureBuffer
(int capacity, @NonNull Action onOverflow) Buffers an limited number of items from the currentFlowable
and allows it to emit as fast it can while allowing the downstream to consume the items at its own place, however, the resultingFlowable
will signal aMissingBackpressureException
viaonError
as soon as the buffer's capacity is exceeded, dropping all undelivered items, canceling the flow and calling theonOverflow
action.Flowable.onBackpressureBuffer
(long capacity, @Nullable Action onOverflow, @NonNull BackpressureOverflowStrategy overflowStrategy) Buffers an optionally unlimited number of items from the currentFlowable
and allows it to emit as fast it can while allowing the downstream to consume the items at its own place.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 currentFlowable
and allows it to emit as fast it can while allowing the downstream to consume the items at its own place.Flowable.onBackpressureDrop()
Drops items from the currentFlowable
if the downstream is not ready to receive new items (indicated by a lack ofSubscription.request(long)
calls from it).Flowable.onBackpressureDrop
(@NonNull Consumer<? super @NonNull T> onDrop) Drops items from the currentFlowable
if the downstream is not ready to receive new items (indicated by a lack ofSubscription.request(long)
calls from it) and calls the givenConsumer
with such dropped items.Flowable.onBackpressureLatest()
Drops all but the latest item emitted by the currentFlowable
if the downstream is not ready to receive new items (indicated by a lack ofSubscription.request(long)
calls from it) and emits this latest item when the downstream becomes ready.Flowable.onBackpressureLatest
(@NonNull Consumer<? super @NonNull T> onDropped) Drops all but the latest item emitted by the currentFlowable
if the downstream is not ready to receive new items (indicated by a lack ofSubscription.request(long)
calls from it) and emits this latest item when the downstream becomes ready.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 ofSubscription.request(long)
calls from it) and emits this latest item when the downstream becomes ready.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.Flowable.onErrorComplete()
Returns aFlowable
instance that if the currentFlowable
emits an error, it will emit anonComplete
and swallow the throwable.Flowable.onErrorComplete
(@NonNull Predicate<? super Throwable> predicate) Returns aFlowable
instance that if the currentFlowable
emits an error and the predicate returnstrue
, it will emit anonComplete
and swallow the throwable.Flowable.onErrorResumeNext
(@NonNull Function<? super Throwable, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> fallbackSupplier) Resumes the flow with aPublisher
returned for the failureThrowable
of the currentFlowable
by a function instead of signaling the error viaonError
.Flowable.onErrorResumeWith
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T> fallback) Resumes the flow with the givenPublisher
when the currentFlowable
fails instead of signaling the error viaonError
.Ends the flow with a last item returned by a function for theThrowable
error signaled by the currentFlowable
instead of signaling the error viaonError
.Flowable.onErrorReturnItem
(@NonNull T item) Ends the flow with the given last item when the currentFlowable
fails instead of signaling the error viaonError
.Flowable.onTerminateDetach()
Nulls out references to the upstream producer and downstreamSubscriber
if the sequence is terminated or downstream cancels.Flowable.publish
(@NonNull Function<? super Flowable<@NonNull T>, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> selector, int prefetch) Returns aFlowable
that emits the results of invoking a specified selector on items emitted by aConnectableFlowable
that shares a single subscription to the underlying sequence.Flowable.publish
(@NonNull Function<? super Flowable<@NonNull T>, @NonNull ? extends org.reactivestreams.Publisher<@NonNull R>> selector) Returns aFlowable
that emits the results of invoking a specified selector on items emitted by aConnectableFlowable
that shares a single subscription to the underlying sequence.Flowable.range
(int start, int count) Returns aFlowable
that emits a sequence ofInteger
s within a specified range.Flowable.rangeLong
(long start, long count) Returns aFlowable
that emits a sequence ofLong
s within a specified range.Flowable.rebatchRequests
(int n) Requestsn
initially from the upstream and then 75% ofn
subsequently after 75% ofn
values have been emitted to the downstream.Flowable.repeat()
Returns aFlowable
that repeats the sequence of items emitted by the currentFlowable
indefinitely.Flowable.repeat
(long times) Returns aFlowable
that repeats the sequence of items emitted by the currentFlowable
at mostcount
times.Maybe.repeat()
Returns aFlowable
that repeats the sequence of items emitted by the currentMaybe
indefinitely.Maybe.repeat
(long times) Returns aFlowable
that repeats the sequence of items emitted by the currentMaybe
at mostcount
times.Single.repeat()
Repeatedly re-subscribes to the currentSingle
and emits each success value as aFlowable
sequence.Single.repeat
(long times) Re-subscribes to the currentSingle
at most the given number of times and emits each success value as aFlowable
sequence.Flowable.repeatUntil
(@NonNull BooleanSupplier stop) Returns aFlowable
that repeats the sequence of items emitted by the currentFlowable
until the provided stop function returnstrue
.Maybe.repeatUntil
(@NonNull BooleanSupplier stop) Returns aFlowable
that repeats the sequence of items emitted by the currentMaybe
until the provided stop function returnstrue
.Single.repeatUntil
(@NonNull BooleanSupplier stop) Re-subscribes to the currentSingle
until the givenBooleanSupplier
returnstrue
and emits the success items as aFlowable
sequence.Flowable.repeatWhen
(@NonNull Function<? super Flowable<Object>, @NonNull ? extends org.reactivestreams.Publisher<@NonNull ?>> handler) Returns aFlowable
that emits the same values as the currentFlowable
with the exception of anonComplete
.Maybe.repeatWhen
(@NonNull Function<? super Flowable<Object>, @NonNull ? extends org.reactivestreams.Publisher<@NonNull ?>> handler) Returns aFlowable
that emits the same values as the currentMaybe
with the exception of anonComplete
.Single.repeatWhen
(@NonNull Function<? super Flowable<Object>, @NonNull ? extends org.reactivestreams.Publisher<@NonNull ?>> handler) Re-subscribes to the currentSingle
if thePublisher
returned by the handler function signals a value in response to a value signaled through theFlowable
the handler receives.Flowable.replay
(@NonNull Function<? super Flowable<@NonNull T>, @NonNull ? extends org.reactivestreams.Publisher<@NonNull R>> selector) Returns aFlowable
that emits items that are the results of invoking a specified selector on the items emitted by aConnectableFlowable
that shares a single subscription to the currentFlowable
.Flowable.replay
(@NonNull Function<? super Flowable<@NonNull T>, @NonNull ? extends org.reactivestreams.Publisher<@NonNull R>> selector, int bufferSize) Returns aFlowable
that emits items that are the results of invoking a specified selector on items emitted by aConnectableFlowable
that shares a single subscription to the currentFlowable
, replayingbufferSize
notifications.Flowable.replay
(@NonNull Function<? super Flowable<@NonNull T>, @NonNull ? extends org.reactivestreams.Publisher<@NonNull R>> selector, int bufferSize, boolean eagerTruncate) Returns aFlowable
that emits items that are the results of invoking a specified selector on items emitted by aConnectableFlowable
that shares a single subscription to the currentFlowable
, replayingbufferSize
notifications.Flowable.replay
(@NonNull Function<? super Flowable<@NonNull T>, @NonNull ? extends org.reactivestreams.Publisher<@NonNull R>> selector, int bufferSize, long time, @NonNull TimeUnit unit) Returns aFlowable
that emits items that are the results of invoking a specified selector on items emitted by aConnectableFlowable
that shares a single subscription to the currentFlowable
, replaying no more thanbufferSize
items that were emitted within a specified time window.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 aFlowable
that emits items that are the results of invoking a specified selector on items emitted by aConnectableFlowable
that shares a single subscription to the currentFlowable
, replaying no more thanbufferSize
items that were emitted within a specified time window.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 aFlowable
that emits items that are the results of invoking a specified selector on items emitted by aConnectableFlowable
that shares a single subscription to the currentFlowable
, replaying no more thanbufferSize
items that were emitted within a specified time window.Flowable.replay
(@NonNull Function<? super Flowable<@NonNull T>, @NonNull ? extends org.reactivestreams.Publisher<@NonNull R>> selector, long time, @NonNull TimeUnit unit) Returns aFlowable
that emits items that are the results of invoking a specified selector on items emitted by aConnectableFlowable
that shares a single subscription to the currentFlowable
, replaying all items that were emitted within a specified time window.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 aFlowable
that emits items that are the results of invoking a specified selector on items emitted by aConnectableFlowable
that shares a single subscription to the currentFlowable
, replaying all items that were emitted within a specified time window.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 aFlowable
that emits items that are the results of invoking a specified selector on items emitted by aConnectableFlowable
that shares a single subscription to the currentFlowable
, replaying all items that were emitted within a specified time window.Flowable.retry()
Returns aFlowable
that mirrors the currentFlowable
, resubscribing to it if it callsonError
(infinite retry count).Flowable.retry
(long times) Returns aFlowable
that mirrors the currentFlowable
, resubscribing to it if it callsonError
up to a specified number of retries.Retries at most times or until the predicate returnsfalse
, whichever happens first.Returns aFlowable
that mirrors the currentFlowable
, resubscribing to it if it callsonError
and the predicate returnstrue
for that specific exception and retry count.Retries the currentFlowable
if the predicate returnstrue
.Flowable.retryUntil
(@NonNull BooleanSupplier stop) Retries until the given stop function returnstrue
.Flowable.retryWhen
(@NonNull Function<? super Flowable<Throwable>, @NonNull ? extends org.reactivestreams.Publisher<@NonNull ?>> handler) Returns aFlowable
that emits the same values as the currentFlowable
with the exception of anonError
.Returns aFlowable
that emits the most recently emitted item (if any) emitted by the currentFlowable
within periodic time intervals.Returns aFlowable
that emits the most recently emitted item (if any) emitted by the currentFlowable
within periodic time intervals and optionally emit the very last upstream item when the upstream completes.Returns aFlowable
that emits the most recently emitted item (if any) emitted by the currentFlowable
within periodic time intervals, where the intervals are defined on a particularScheduler
.Flowable.sample
(long period, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean emitLast) Returns aFlowable
that emits the most recently emitted item (if any) emitted by the currentFlowable
within periodic time intervals, where the intervals are defined on a particularScheduler
and optionally emit the very last upstream item when the upstream completes.Flowable.sample
(long period, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean emitLast, @NonNull Consumer<? super @NonNull T> onDropped) Returns aFlowable
that emits the most recently emitted item (if any) emitted by the currentFlowable
within periodic time intervals, where the intervals are defined on a particularScheduler
and optionally emit the very last upstream item when the upstream completes.Returns aFlowable
that, when the specifiedsampler
Publisher
emits an item or completes, emits the most recently emitted item (if any) emitted by the currentFlowable
since the previous emission from thesampler
Publisher
.Returns aFlowable
that, when the specifiedsampler
Publisher
emits an item or completes, emits the most recently emitted item (if any) emitted by the currentFlowable
since the previous emission from thesampler
Publisher
and optionally emit the very last upstream item when the upstream or otherPublisher
complete.Returns aFlowable
that emits the first value emitted by the currentFlowable
, then emits one value for each subsequent value emitted by the currentFlowable
.Flowable.scan
(@NonNull R initialValue, @NonNull BiFunction<@NonNull R, ? super @NonNull T, @NonNull R> accumulator) Returns aFlowable
that emits the provided initial (seed) value, then emits one value for each value emitted by the currentFlowable
.Flowable.scanWith
(@NonNull Supplier<@NonNull R> seedSupplier, @NonNull BiFunction<@NonNull R, ? super @NonNull T, @NonNull R> accumulator) Returns aFlowable
that emits the provided initial (seed) value, then emits one value for each value emitted by the currentFlowable
.Flowable.serialize()
Forces the currentFlowable
's emissions and notifications to be serialized and for it to obey thePublisher
contract in other ways.Flowable.share()
Returns a newFlowable
that multicasts (and shares a single subscription to) the currentFlowable
.Flowable.skip
(long count) Returns aFlowable
that skips the firstcount
items emitted by the currentFlowable
and emits the remainder.Returns aFlowable
that skips values emitted by the currentFlowable
before a specified time window elapses.Returns aFlowable
that skips values emitted by the currentFlowable
before a specified time window on a specifiedScheduler
elapses.Flowable.skipLast
(int count) Returns aFlowable
that drops a specified number of items from the end of the sequence emitted by the currentFlowable
.Returns aFlowable
that drops items emitted by the currentFlowable
during a specified time window before the source completes.Returns aFlowable
that drops items emitted by the currentFlowable
during a specified time window before the source completes.Returns aFlowable
that drops items emitted by the currentFlowable
during a specified time window (defined on a specified scheduler) before the source completes.Flowable.skipLast
(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean delayError) Returns aFlowable
that drops items emitted by the currentFlowable
during a specified time window (defined on a specified scheduler) before the source completes.Flowable.skipLast
(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean delayError, int bufferSize) Returns aFlowable
that drops items emitted by the currentFlowable
during a specified time window (defined on a specified scheduler) before the source completes.Returns aFlowable
that skips items emitted by the currentFlowable
until a secondPublisher
emits an item.Returns aFlowable
that skips all items emitted by the currentFlowable
as long as a specified condition holdstrue
, but emits all further source items as soon as the condition becomesfalse
.Flowable.sorted()
Returns aFlowable
that emits the events emitted by sourcePublisher
, in a sorted order.Returns aFlowable
that emits the events emitted by sourcePublisher
, in a sorted order based on a specified comparison function.Completable.startWith
(@NonNull MaybeSource<@NonNull T> other) Returns aFlowable
which first runs the otherMaybeSource
then the currentCompletable
if the other succeeded or completed normally.Completable.startWith
(@NonNull SingleSource<@NonNull T> other) Returns aFlowable
which first runs the otherSingleSource
then the currentCompletable
if the other succeeded normally.Returns aFlowable
which first delivers the events of the otherPublisher
then runs the currentCompletable
.Flowable.startWith
(@NonNull CompletableSource other) Returns aFlowable
which first runs the otherCompletableSource
then the currentFlowable
if the other completed normally.Flowable.startWith
(@NonNull MaybeSource<@NonNull T> other) Returns aFlowable
which first runs the otherMaybeSource
then the currentFlowable
if the other succeeded or completed normally.Flowable.startWith
(@NonNull SingleSource<@NonNull T> other) Returns aFlowable
which first runs the otherSingleSource
then the currentFlowable
if the other succeeded normally.Returns aFlowable
that emits the items in a specifiedPublisher
before it begins to emit items emitted by the currentFlowable
.Maybe.startWith
(@NonNull CompletableSource other) Returns aFlowable
which first runs the otherCompletableSource
then the currentMaybe
if the other completed normally.Maybe.startWith
(@NonNull MaybeSource<@NonNull T> other) Returns aFlowable
which first runs the otherMaybeSource
then the currentMaybe
if the other succeeded or completed normally.Maybe.startWith
(@NonNull SingleSource<@NonNull T> other) Returns aFlowable
which first runs the otherSingleSource
then the currentMaybe
if the other succeeded normally.Returns aFlowable
which first delivers the events of the otherPublisher
then runs the currentMaybe
.Single.startWith
(@NonNull CompletableSource other) Returns aFlowable
which first runs the otherCompletableSource
then the currentSingle
if the other completed normally.Single.startWith
(@NonNull MaybeSource<@NonNull T> other) Returns aFlowable
which first runs the otherMaybeSource
then the currentSingle
if the other succeeded or completed normally.Single.startWith
(@NonNull SingleSource<@NonNull T> other) Returns aFlowable
which first runs the otherSingleSource
then the currentSingle
if the other succeeded normally.Returns aFlowable
which first delivers the events of the otherPublisher
then runs the currentSingle
.Flowable.startWithArray
(@NonNull T... items) Returns aFlowable
that emits the specified items before it begins to emit items emitted by the currentFlowable
.Flowable.startWithItem
(@NonNull T item) Returns aFlowable
that emits a specified item before it begins to emit items emitted by the currentFlowable
.Flowable.startWithIterable
(@NonNull Iterable<? extends @NonNull T> items) Returns aFlowable
that emits the items in a specifiedIterable
before it begins to emit items emitted by the currentFlowable
.Flowable.subscribeOn
(@NonNull Scheduler scheduler) Flowable.subscribeOn
(@NonNull Scheduler scheduler, boolean requestOn) Asynchronously subscribesSubscriber
s to the currentFlowable
on the specifiedScheduler
optionally reroutes requests from other threads to the sameScheduler
thread.Flowable.switchIfEmpty
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T> other) Returns aFlowable
that emits the items emitted by the currentFlowable
or the items of an alternatePublisher
if the currentFlowable
is empty.Flowable.switchMap
(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> mapper) Returns a newFlowable
by applying a function that you supply to each item emitted by the currentFlowable
that returns aPublisher
, and then emitting the items emitted by the most recently emitted of thesePublisher
s.Flowable.switchMap
(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> mapper, int bufferSize) Returns a newFlowable
by applying a function that you supply to each item emitted by the currentFlowable
that returns aPublisher
, and then emitting the items emitted by the most recently emitted of thesePublisher
s.(package private) <R> Flowable
<R> Flowable.switchMap0
(Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends R>> mapper, int bufferSize, boolean delayError) Flowable.switchMapDelayError
(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> mapper) Returns a newFlowable
by applying a function that you supply to each item emitted by the currentFlowable
that returns aPublisher
, and then emitting the items emitted by the most recently emitted of thesePublisher
s and delays any error until allPublisher
s terminate.Flowable.switchMapDelayError
(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> mapper, int bufferSize) Returns a newFlowable
by applying a function that you supply to each item emitted by the currentFlowable
that returns aPublisher
, and then emitting the items emitted by the most recently emitted of thesePublisher
s and delays any error until allPublisher
s terminate.Flowable.switchMapMaybe
(@NonNull Function<? super @NonNull T, ? extends MaybeSource<? extends @NonNull R>> mapper) Maps the upstream items intoMaybeSource
s 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 thisFlowable
or any of the active innerMaybeSource
s fail.Flowable.switchMapMaybeDelayError
(@NonNull Function<? super @NonNull T, ? extends MaybeSource<? extends @NonNull R>> mapper) Maps the upstream items intoMaybeSource
s 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 thisFlowable
or the innerMaybeSource
s until all terminate.Flowable.switchMapSingle
(@NonNull Function<? super @NonNull T, ? extends SingleSource<? extends @NonNull R>> mapper) Maps the upstream items intoSingleSource
s 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 thisFlowable
or any of the active innerSingleSource
s fail.Flowable.switchMapSingleDelayError
(@NonNull Function<? super @NonNull T, ? extends SingleSource<? extends @NonNull R>> mapper) Maps the upstream items intoSingleSource
s 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 thisFlowable
or the innerSingleSource
s until all terminate.Flowable.switchOnNext
(@NonNull org.reactivestreams.Publisher<? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources, int bufferSize) Converts aPublisher
that emitsPublisher
s into aPublisher
that emits the items emitted by the most recently emitted of thosePublisher
s.Flowable.switchOnNext
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources) Converts aPublisher
that emitsPublisher
s into aPublisher
that emits the items emitted by the most recently emitted of thosePublisher
s.Maybe.switchOnNext
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends MaybeSource<? extends @NonNull T>> sources) Switches betweenMaybeSource
s emitted by the sourcePublisher
whenever a newMaybeSource
is emitted, disposing the previously runningMaybeSource
, exposing the success items as aFlowable
sequence.Single.switchOnNext
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends SingleSource<? extends @NonNull T>> sources) Switches betweenSingleSource
s emitted by the sourcePublisher
whenever a newSingleSource
is emitted, disposing the previously runningSingleSource
, exposing the success items as aFlowable
sequence.Flowable.switchOnNextDelayError
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources) Converts aPublisher
that emitsPublisher
s into aPublisher
that emits the items emitted by the most recently emitted of thosePublisher
s and delays any exception until allPublisher
s terminate.Flowable.switchOnNextDelayError
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources, int prefetch) Converts aPublisher
that emitsPublisher
s into aPublisher
that emits the items emitted by the most recently emitted of thosePublisher
s and delays any exception until allPublisher
s terminate.Maybe.switchOnNextDelayError
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends MaybeSource<? extends @NonNull T>> sources) Switches betweenMaybeSource
s emitted by the sourcePublisher
whenever a newMaybeSource
is emitted, disposing the previously runningMaybeSource
, exposing the success items as aFlowable
sequence and delaying all errors from all of them until all terminate.Single.switchOnNextDelayError
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends SingleSource<? extends @NonNull T>> sources) Switches betweenSingleSource
s emitted by the sourcePublisher
whenever a newSingleSource
is emitted, disposing the previously runningSingleSource
, exposing the success items as aFlowable
sequence and delaying all errors from all of them until all terminate.Flowable.take
(long count) Returns aFlowable
that emits only the firstcount
items emitted by the currentFlowable
.Returns aFlowable
that emits those items emitted by sourcePublisher
before a specified time runs out.Returns aFlowable
that emits those items emitted by sourcePublisher
before a specified time (on a specifiedScheduler
) runs out.Flowable.takeLast
(int count) Returns aFlowable
that emits at most the lastcount
items emitted by the currentFlowable
.Returns aFlowable
that emits at most a specified number of items from the currentFlowable
that were emitted in a specified window of time before the currentFlowable
completed.Returns aFlowable
that emits at most a specified number of items from the currentFlowable
that were emitted in a specified window of time before the currentFlowable
completed, where the timing information is provided by a givenScheduler
.Flowable.takeLast
(long count, long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean delayError, int bufferSize) Returns aFlowable
that emits at most a specified number of items from the currentFlowable
that were emitted in a specified window of time before the currentFlowable
completed, where the timing information is provided by a givenScheduler
.Returns aFlowable
that emits the items from the currentFlowable
that were emitted in a specified window of time before the currentFlowable
completed.Returns aFlowable
that emits the items from the currentFlowable
that were emitted in a specified window of time before the currentFlowable
completed.Returns aFlowable
that emits the items from the currentFlowable
that were emitted in a specified window of time before the currentFlowable
completed, where the timing information is provided by a specifiedScheduler
.Flowable.takeLast
(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean delayError) Returns aFlowable
that emits the items from the currentFlowable
that were emitted in a specified window of time before the currentFlowable
completed, where the timing information is provided by a specifiedScheduler
.Flowable.takeLast
(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean delayError, int bufferSize) Returns aFlowable
that emits the items from the currentFlowable
that were emitted in a specified window of time before the currentFlowable
completed, where the timing information is provided by a specifiedScheduler
.Returns aFlowable
that emits items emitted by the currentFlowable
, checks the specified predicate for each item, and then completes when the condition is satisfied.Returns aFlowable
that emits the items emitted by the currentFlowable
until a secondPublisher
emits an item or completes.Returns aFlowable
that emits items emitted by the currentFlowable
so long as each item satisfied a specified condition, and then completes as soon as this condition is not satisfied.Flowable.throttleFirst
(long windowDuration, @NonNull TimeUnit unit) Returns aFlowable
that emits only the first item emitted by the currentFlowable
during sequential time windows of a specified duration.Flowable.throttleFirst
(long skipDuration, @NonNull TimeUnit unit, @NonNull Scheduler scheduler) Returns aFlowable
that emits only the first item emitted by the currentFlowable
during sequential time windows of a specified duration, where the windows are managed by a specifiedScheduler
.Flowable.throttleFirst
(long skipDuration, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, @NonNull Consumer<? super @NonNull T> onDropped) Returns aFlowable
that emits only the first item emitted by the currentFlowable
during sequential time windows of a specified duration, where the windows are managed by a specifiedScheduler
.Flowable.throttleLast
(long intervalDuration, @NonNull TimeUnit unit) Returns aFlowable
that emits only the last item emitted by the currentFlowable
during sequential time windows of a specified duration.Flowable.throttleLast
(long intervalDuration, @NonNull TimeUnit unit, @NonNull Scheduler scheduler) Returns aFlowable
that emits only the last item emitted by the currentFlowable
during sequential time windows of a specified duration, where the duration is governed by a specifiedScheduler
.Flowable.throttleLast
(long intervalDuration, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, @NonNull Consumer<? super @NonNull T> onDropped) Returns aFlowable
that emits only the last item emitted by the currentFlowable
during sequential time windows of a specified duration, where the duration is governed by a specifiedScheduler
.Flowable.throttleLatest
(long timeout, @NonNull TimeUnit unit) Throttles items from the upstreamFlowable
by first emitting the next item from upstream, then periodically emitting the latest item (if any) when the specified timeout elapses between them.Flowable.throttleLatest
(long timeout, @NonNull TimeUnit unit, boolean emitLast) Throttles items from the upstreamFlowable
by first emitting the next item from upstream, then periodically emitting the latest item (if any) when the specified timeout elapses between them.Flowable.throttleLatest
(long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler) Throttles items from the upstreamFlowable
by first emitting the next item from upstream, then periodically emitting the latest item (if any) when the specified timeout elapses between them.Flowable.throttleLatest
(long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean emitLast) Throttles items from the upstreamFlowable
by first emitting the next item from upstream, then periodically emitting the latest item (if any) when the specified timeout elapses between them.Flowable.throttleLatest
(long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean emitLast, @NonNull Consumer<? super @NonNull T> onDropped) Throttles items from the upstreamFlowable
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.Flowable.throttleWithTimeout
(long timeout, @NonNull TimeUnit unit) Returns aFlowable
that mirrors the currentFlowable
, except that it drops items emitted by the currentFlowable
that are followed by newer items before a timeout value expires.Flowable.throttleWithTimeout
(long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler) Returns aFlowable
that mirrors the currentFlowable
, except that it drops items emitted by the currentFlowable
that are followed by newer items before a timeout value expires on a specifiedScheduler
.Flowable.throttleWithTimeout
(long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, @NonNull Consumer<? super @NonNull T> onDropped) Returns aFlowable
that mirrors the currentFlowable
, except that it drops items emitted by the currentFlowable
that are followed by newer items before a timeout value expires on a specifiedScheduler
.Flowable.timeInterval()
Returns aFlowable
that emits records of the time interval between consecutive items emitted by the currentFlowable
.Flowable.timeInterval
(@NonNull Scheduler scheduler) Returns aFlowable
that emits records of the time interval between consecutive items emitted by the currentFlowable
, where this interval is computed on a specifiedScheduler
.Flowable.timeInterval
(@NonNull TimeUnit unit) Returns aFlowable
that emits records of the time interval between consecutive items emitted by the currentFlowable
.Flowable.timeInterval
(@NonNull TimeUnit unit, @NonNull Scheduler scheduler) Returns aFlowable
that emits records of the time interval between consecutive items emitted by the currentFlowable
, where this interval is computed on a specifiedScheduler
.Returns aFlowable
that mirrors the currentFlowable
but applies a timeout policy for each emitted item.Returns aFlowable
that mirrors the currentFlowable
but applies a timeout policy for each emitted item, where this policy is governed by a specifiedScheduler
.Flowable.timeout
(long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, @NonNull org.reactivestreams.Publisher<? extends @NonNull T> fallback) Returns aFlowable
that mirrors the currentFlowable
but applies a timeout policy for each emitted item using a specifiedScheduler
.Flowable.timeout
(long timeout, @NonNull TimeUnit unit, @NonNull org.reactivestreams.Publisher<? extends @NonNull T> fallback) Returns aFlowable
that mirrors the currentFlowable
but applies a timeout policy for each emitted item.Flowable.timeout
(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<@NonNull V>> itemTimeoutIndicator) Returns aFlowable
that mirrors the currentFlowable
, but notifiesSubscriber
s of aTimeoutException
if an item emitted by the currentFlowable
doesn't arrive within a window of time after the emission of the previous item, where that period of time is measured by aPublisher
that is a function of the previous item.Flowable.timeout
(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<@NonNull V>> itemTimeoutIndicator, @NonNull org.reactivestreams.Publisher<? extends @NonNull T> fallback) Returns aFlowable
that mirrors the currentFlowable
, but that switches to a fallbackPublisher
if an item emitted by the currentFlowable
doesn't arrive within a window of time after the emission of the previous item, where that period of time is measured by aPublisher
that is a function of the previous item.Flowable.timeout
(@NonNull org.reactivestreams.Publisher<@NonNull U> firstTimeoutIndicator, @NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<@NonNull V>> itemTimeoutIndicator) Returns aFlowable
that mirrors the currentFlowable
, but notifiesSubscriber
s of aTimeoutException
if either the first item emitted by the currentFlowable
or any subsequent item doesn't arrive within time windows defined by otherPublisher
s.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 aFlowable
that mirrors the currentFlowable
, but switches to a fallbackPublisher
if either the first item emitted by the currentFlowable
or any subsequent item doesn't arrive within time windows defined by otherPublisher
s.Flowable.timeout0
(long timeout, TimeUnit unit, org.reactivestreams.Publisher<? extends @NonNull T> fallback, Scheduler scheduler) 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) Returns aFlowable
that emits0L
after a specified delay, and then completes.Returns aFlowable
that emits0L
after a specified delay, on a specifiedScheduler
, and then completes.Flowable.timestamp()
Completable.toFlowable()
Returns aFlowable
which when subscribed to subscribes to thisCompletable
and relays the terminal events to the downstreamSubscriber
.Maybe.toFlowable()
Converts thisMaybe
into a backpressure-awareFlowable
instance composing cancellation through.Observable.toFlowable
(@NonNull BackpressureStrategy strategy) Converts the currentObservable
into aFlowable
by applying the specified backpressure strategy.Single.toFlowable()
Converts thisSingle
into aFlowable
.Flowable.unsafeCreate
(@NonNull org.reactivestreams.Publisher<@NonNull T> onSubscribe) Create aFlowable
by wrapping aPublisher
which has to be implemented according to the Reactive Streams specification by handling backpressure and cancellation correctly; no safeguards are provided by theFlowable
itself.Flowable.unsubscribeOn
(@NonNull Scheduler scheduler) Cancels the currentFlowable
asynchronously by invokingSubscription.cancel()
on the specifiedScheduler
.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 aFlowable
that creates a dependent resource object, aPublisher
with that resource and calls the providedresourceDisposer
function if this inner source terminates or the downstream cancels the flow.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 aFlowable
that creates a dependent resource object, aPublisher
with that resource and calls the providedresourceDisposer
function if this inner source terminates or the downstream disposes the flow; doing it before these end-states have been reached ifeager == true
, after otherwise.Flowable.window
(long count) Returns aFlowable
that emits windows of items it collects from the currentFlowable
.Flowable.window
(long count, long skip) Returns aFlowable
that emits windows of items it collects from the currentFlowable
.Flowable.window
(long count, long skip, int bufferSize) Returns aFlowable
that emits windows of items it collects from the currentFlowable
.Returns aFlowable
that emits windows of items it collects from the currentFlowable
.Returns aFlowable
that emits windows of items it collects from the currentFlowable
.Flowable.window
(long timespan, long timeskip, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, int bufferSize) Returns aFlowable
that emits windows of items it collects from the currentFlowable
.Returns aFlowable
that emits windows of items it collects from the currentFlowable
.Returns aFlowable
that emits windows of items it collects from the currentFlowable
.Returns aFlowable
that emits windows of items it collects from the currentFlowable
.Returns aFlowable
that emits windows of items it collects from the currentFlowable
.Returns aFlowable
that emits windows of items it collects from the currentFlowable
.Flowable.window
(long timespan, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, long count, boolean restart) Returns aFlowable
that emits windows of items it collects from the currentFlowable
.Flowable.window
(long timespan, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, long count, boolean restart, int bufferSize) Returns aFlowable
that emits windows of items it collects from the currentFlowable
.Returns aFlowable
that emits non-overlapping windows of items it collects from the currentFlowable
where the boundary of each window is determined by the items emitted from a specified boundary-governingPublisher
.Flowable.window
(@NonNull org.reactivestreams.Publisher<@NonNull B> boundaryIndicator, int bufferSize) Returns aFlowable
that emits non-overlapping windows of items it collects from the currentFlowable
where the boundary of each window is determined by the items emitted from a specified boundary-governingPublisher
.Flowable.window
(@NonNull org.reactivestreams.Publisher<@NonNull U> openingIndicator, @NonNull Function<? super @NonNull U, @NonNull ? extends org.reactivestreams.Publisher<@NonNull V>> closingIndicator) Returns aFlowable
that emits windows of items it collects from the currentFlowable
.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 aFlowable
that emits windows of items it collects from the currentFlowable
.Flowable.withLatestFrom
(@NonNull Iterable<@NonNull ? extends org.reactivestreams.Publisher<@NonNull ?>> others, @NonNull Function<? super Object[], @NonNull R> combiner) Combines the value emission from the currentFlowable
with the latest emissions from the otherPublisher
s via a function to produce the output item.Flowable.withLatestFrom
(@NonNull org.reactivestreams.Publisher<? extends @NonNull U> other, @NonNull BiFunction<? super @NonNull T, ? super @NonNull U, ? extends @NonNull R> combiner) Merges the specifiedPublisher
into the currentFlowable
sequence by using theresultSelector
function only when the currentFlowable
(this instance) emits an item.Flowable.withLatestFrom
(@NonNull org.reactivestreams.Publisher<@NonNull ?>[] others, @NonNull Function<? super Object[], @NonNull R> combiner) Combines the value emission from the currentFlowable
with the latest emissions from the otherPublisher
s via a function to produce the output item.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 currentFlowable
with the latest emissions from the otherPublisher
s via a function to produce the output item.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 currentFlowable
with the latest emissions from the otherPublisher
s via a function to produce the output item.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 currentFlowable
with the latest emissions from the otherPublisher
s via a function to produce the output item.Flowable.zip
(@NonNull Iterable<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources, @NonNull Function<? super Object[], ? extends @NonNull R> zipper) Returns aFlowable
that emits the results of a specified combiner function applied to combinations of items emitted, in sequence, by anIterable
of otherPublisher
s.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 aFlowable
that emits the results of a specified combiner function applied to combinations of items emitted, in sequence, by anIterable
of otherPublisher
s.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 aFlowable
that emits the results of a specified combiner function applied to combinations of two items emitted, in sequence, by two otherPublisher
s.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 aFlowable
that emits the results of a specified combiner function applied to combinations of two items emitted, in sequence, by two otherPublisher
s.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 aFlowable
that emits the results of a specified combiner function applied to combinations of two items emitted, in sequence, by two otherPublisher
s.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 aFlowable
that emits the results of a specified combiner function applied to combinations of three items emitted, in sequence, by three otherPublisher
s.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 aFlowable
that emits the results of a specified combiner function applied to combinations of four items emitted, in sequence, by four otherPublisher
s.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 aFlowable
that emits the results of a specified combiner function applied to combinations of five items emitted, in sequence, by five otherPublisher
s.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 aFlowable
that emits the results of a specified combiner function applied to combinations of six items emitted, in sequence, by six otherPublisher
s.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 aFlowable
that emits the results of a specified combiner function applied to combinations of seven items emitted, in sequence, by seven otherPublisher
s.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 aFlowable
that emits the results of a specified combiner function applied to combinations of eight items emitted, in sequence, by eight otherPublisher
s.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 aFlowable
that emits the results of a specified combiner function applied to combinations of nine items emitted, in sequence, by nine otherPublisher
s.Flowable.zipArray
(@NonNull Function<? super Object[], ? extends @NonNull R> zipper, boolean delayError, int bufferSize, @NonNull org.reactivestreams.Publisher<? extends @NonNull T>... sources) Returns aFlowable
that emits the results of a specified combiner function applied to combinations of items emitted, in sequence, by an array of otherPublisher
s.Flowable.zipWith
(@NonNull Iterable<@NonNull U> other, @NonNull BiFunction<? super @NonNull T, ? super @NonNull U, ? extends @NonNull R> zipper) Returns aFlowable
that emits items that are the result of applying a specified function to pairs of values, one each from the currentFlowable
and a specifiedIterable
sequence.Flowable.zipWith
(@NonNull org.reactivestreams.Publisher<? extends @NonNull U> other, @NonNull BiFunction<? super @NonNull T, ? super @NonNull U, ? extends @NonNull R> zipper) Returns aFlowable
that emits items that are the result of applying a specified function to pairs of values, one each from the currentFlowable
and another specifiedPublisher
.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 aFlowable
that emits items that are the result of applying a specified function to pairs of values, one each from the currentFlowable
and another specifiedPublisher
.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 aFlowable
that emits items that are the result of applying a specified function to pairs of values, one each from the currentFlowable
and another specifiedPublisher
.Methods in io.reactivex.rxjava3.core that return types with arguments of type FlowableModifier and TypeMethodDescriptionFlowable.window
(long count) Returns aFlowable
that emits windows of items it collects from the currentFlowable
.Flowable.window
(long count, long skip) Returns aFlowable
that emits windows of items it collects from the currentFlowable
.Flowable.window
(long count, long skip, int bufferSize) Returns aFlowable
that emits windows of items it collects from the currentFlowable
.Returns aFlowable
that emits windows of items it collects from the currentFlowable
.Returns aFlowable
that emits windows of items it collects from the currentFlowable
.Flowable.window
(long timespan, long timeskip, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, int bufferSize) Returns aFlowable
that emits windows of items it collects from the currentFlowable
.Returns aFlowable
that emits windows of items it collects from the currentFlowable
.Returns aFlowable
that emits windows of items it collects from the currentFlowable
.Returns aFlowable
that emits windows of items it collects from the currentFlowable
.Returns aFlowable
that emits windows of items it collects from the currentFlowable
.Returns aFlowable
that emits windows of items it collects from the currentFlowable
.Flowable.window
(long timespan, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, long count, boolean restart) Returns aFlowable
that emits windows of items it collects from the currentFlowable
.Flowable.window
(long timespan, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, long count, boolean restart, int bufferSize) Returns aFlowable
that emits windows of items it collects from the currentFlowable
.Returns aFlowable
that emits non-overlapping windows of items it collects from the currentFlowable
where the boundary of each window is determined by the items emitted from a specified boundary-governingPublisher
.Flowable.window
(@NonNull org.reactivestreams.Publisher<@NonNull B> boundaryIndicator, int bufferSize) Returns aFlowable
that emits non-overlapping windows of items it collects from the currentFlowable
where the boundary of each window is determined by the items emitted from a specified boundary-governingPublisher
.Flowable.window
(@NonNull org.reactivestreams.Publisher<@NonNull U> openingIndicator, @NonNull Function<? super @NonNull U, @NonNull ? extends org.reactivestreams.Publisher<@NonNull V>> closingIndicator) Returns aFlowable
that emits windows of items it collects from the currentFlowable
.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 aFlowable
that emits windows of items it collects from the currentFlowable
.Methods in io.reactivex.rxjava3.core with parameters of type FlowableModifier and TypeMethodDescriptionApplies a function to the upstreamFlowable
and returns a converted value of typeR
.@NonNull org.reactivestreams.Publisher
<Downstream> Applies a function to the upstreamFlowable
and returns aPublisher
with optionally different element type.Method parameters in io.reactivex.rxjava3.core with type arguments of type FlowableModifier and TypeMethodDescriptionFlowable.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 aFlowable
that correlates twoPublisher
s when they overlap in time and groups the results.Flowable.publish
(@NonNull Function<? super Flowable<@NonNull T>, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> selector, int prefetch) Returns aFlowable
that emits the results of invoking a specified selector on items emitted by aConnectableFlowable
that shares a single subscription to the underlying sequence.Flowable.publish
(@NonNull Function<? super Flowable<@NonNull T>, @NonNull ? extends org.reactivestreams.Publisher<@NonNull R>> selector) Returns aFlowable
that emits the results of invoking a specified selector on items emitted by aConnectableFlowable
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 aCompletable
instance that repeats when thePublisher
returned by the handlerFunction
emits an item or completes when thisPublisher
emits anonComplete
event.Flowable.repeatWhen
(@NonNull Function<? super Flowable<Object>, @NonNull ? extends org.reactivestreams.Publisher<@NonNull ?>> handler) Returns aFlowable
that emits the same values as the currentFlowable
with the exception of anonComplete
.Maybe.repeatWhen
(@NonNull Function<? super Flowable<Object>, @NonNull ? extends org.reactivestreams.Publisher<@NonNull ?>> handler) Returns aFlowable
that emits the same values as the currentMaybe
with the exception of anonComplete
.Single.repeatWhen
(@NonNull Function<? super Flowable<Object>, @NonNull ? extends org.reactivestreams.Publisher<@NonNull ?>> handler) Re-subscribes to the currentSingle
if thePublisher
returned by the handler function signals a value in response to a value signaled through theFlowable
the handler receives.Flowable.replay
(@NonNull Function<? super Flowable<@NonNull T>, @NonNull ? extends org.reactivestreams.Publisher<@NonNull R>> selector) Returns aFlowable
that emits items that are the results of invoking a specified selector on the items emitted by aConnectableFlowable
that shares a single subscription to the currentFlowable
.Flowable.replay
(@NonNull Function<? super Flowable<@NonNull T>, @NonNull ? extends org.reactivestreams.Publisher<@NonNull R>> selector, int bufferSize) Returns aFlowable
that emits items that are the results of invoking a specified selector on items emitted by aConnectableFlowable
that shares a single subscription to the currentFlowable
, replayingbufferSize
notifications.Flowable.replay
(@NonNull Function<? super Flowable<@NonNull T>, @NonNull ? extends org.reactivestreams.Publisher<@NonNull R>> selector, int bufferSize, boolean eagerTruncate) Returns aFlowable
that emits items that are the results of invoking a specified selector on items emitted by aConnectableFlowable
that shares a single subscription to the currentFlowable
, replayingbufferSize
notifications.Flowable.replay
(@NonNull Function<? super Flowable<@NonNull T>, @NonNull ? extends org.reactivestreams.Publisher<@NonNull R>> selector, int bufferSize, long time, @NonNull TimeUnit unit) Returns aFlowable
that emits items that are the results of invoking a specified selector on items emitted by aConnectableFlowable
that shares a single subscription to the currentFlowable
, replaying no more thanbufferSize
items that were emitted within a specified time window.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 aFlowable
that emits items that are the results of invoking a specified selector on items emitted by aConnectableFlowable
that shares a single subscription to the currentFlowable
, replaying no more thanbufferSize
items that were emitted within a specified time window.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 aFlowable
that emits items that are the results of invoking a specified selector on items emitted by aConnectableFlowable
that shares a single subscription to the currentFlowable
, replaying no more thanbufferSize
items that were emitted within a specified time window.Flowable.replay
(@NonNull Function<? super Flowable<@NonNull T>, @NonNull ? extends org.reactivestreams.Publisher<@NonNull R>> selector, long time, @NonNull TimeUnit unit) Returns aFlowable
that emits items that are the results of invoking a specified selector on items emitted by aConnectableFlowable
that shares a single subscription to the currentFlowable
, replaying all items that were emitted within a specified time window.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 aFlowable
that emits items that are the results of invoking a specified selector on items emitted by aConnectableFlowable
that shares a single subscription to the currentFlowable
, replaying all items that were emitted within a specified time window.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 aFlowable
that emits items that are the results of invoking a specified selector on items emitted by aConnectableFlowable
that shares a single subscription to the currentFlowable
, 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 aCompletable
which given aPublisher
and when thisCompletable
emits an error, delivers that error through aFlowable
and thePublisher
should signal a value indicating a retry in response or a terminal event indicating a termination.Flowable.retryWhen
(@NonNull Function<? super Flowable<Throwable>, @NonNull ? extends org.reactivestreams.Publisher<@NonNull ?>> handler) Returns aFlowable
that emits the same values as the currentFlowable
with the exception of anonError
.Maybe.retryWhen
(@NonNull Function<? super Flowable<Throwable>, @NonNull ? extends org.reactivestreams.Publisher<@NonNull ?>> handler) Returns aMaybe
that emits the same values as the currentMaybe
with the exception of anonError
.Single.retryWhen
(@NonNull Function<? super Flowable<Throwable>, @NonNull ? extends org.reactivestreams.Publisher<@NonNull ?>> handler) Re-subscribes to the currentSingle
if and when thePublisher
returned by the handler function signals a value.<S extends Scheduler & Disposable>
SScheduler.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>
SScheduler.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.flowablesModifier and TypeClassDescriptionclass
AConnectableFlowable
resembles an ordinaryFlowable
, except that it does not begin emitting items when it is subscribed to, but only when itsConnectableFlowable.connect(io.reactivex.rxjava3.functions.Consumer<? super io.reactivex.rxjava3.disposables.Disposable>)
method is called.class
GroupedFlowable<K,
T> AFlowable
that has been grouped by key, the value of which can be obtained withGroupedFlowable.getKey()
.Methods in io.reactivex.rxjava3.flowables that return FlowableModifier and TypeMethodDescriptionConnectableFlowable.autoConnect()
Returns aFlowable
that automatically connects (at most once) to thisConnectableFlowable
when the firstSubscriber
subscribes.ConnectableFlowable.autoConnect
(int numberOfSubscribers) Returns aFlowable
that automatically connects (at most once) to thisConnectableFlowable
when the specified number ofSubscriber
s subscribe to it.ConnectableFlowable.autoConnect
(int numberOfSubscribers, @NonNull Consumer<? super Disposable> connection) Returns aFlowable
that automatically connects (at most once) to thisConnectableFlowable
when the specified number ofSubscriber
s subscribe to it and calls the specified callback with theDisposable
associated with the established connection.ConnectableFlowable.refCount()
Returns aFlowable
that stays connected to thisConnectableFlowable
as long as there is at least one subscription to thisConnectableFlowable
.ConnectableFlowable.refCount
(int subscriberCount) Connects to the upstreamConnectableFlowable
if the number of subscribed subscriber reaches the specified count and disconnect if all subscribers have unsubscribed.Connects to the upstreamConnectableFlowable
if the number of subscribed subscriber reaches the specified count and disconnect after the specified timeout if all subscribers have unsubscribed.ConnectableFlowable.refCount
(int subscriberCount, long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler) Connects to the upstreamConnectableFlowable
if the number of subscribed subscriber reaches the specified count and disconnect after the specified timeout if all subscribers have unsubscribed.Connects to the upstreamConnectableFlowable
if the number of subscribed subscriber reaches 1 and disconnect after the specified timeout if all subscribers have unsubscribed.Connects to the upstreamConnectableFlowable
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 FlowableModifier and TypeMethodDescriptionFuseToFlowable.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.jdk8Modifier and TypeClassDescriptionfinal class
FlowableCollectWithCollector<T,
A, R> Collect items into a container defined by a StreamCollector
callback set.final class
Maps the upstream values ontoStream
s and emits their items in order to the downstream.final class
Wrap a CompletionStage and signal its outcome.final class
Wraps aStream
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
Map the success value into a JavaStream
and emits its values.final class
ParallelCollector<T,
A, R> Reduces all 'rails' into a single via a Java 8Collector
callback set.final class
Map the success value into a JavaStream
and emits its values.Fields in io.reactivex.rxjava3.internal.jdk8 declared as FlowableModifier and TypeFieldDescriptionFlowableCollectWithCollector.source
FlowableCollectWithCollectorSingle.source
FlowableFlatMapStream.source
FlowableMapOptional.source
Methods in io.reactivex.rxjava3.internal.jdk8 that return FlowableConstructors in io.reactivex.rxjava3.internal.jdk8 with parameters of type Flowable -
Uses of Flowable in io.reactivex.rxjava3.internal.operators.completable
Subclasses of Flowable in io.reactivex.rxjava3.internal.operators.completable -
Uses of Flowable in io.reactivex.rxjava3.internal.operators.flowable
Subclasses of Flowable in io.reactivex.rxjava3.internal.operators.flowableModifier and TypeClassDescription(package private) class
Abstract base class for operators that take an upstream sourcePublisher
.final class
FlowableAll<T>
final class
FlowableAmb<T>
final class
FlowableAny<T>
final class
Wraps aConnectableFlowable
and calls itsconnect()
method once the specified number ofSubscriber
s 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
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
Combines the latest values from multiple sources through a function.final class
final class
FlowableConcatMap<T,
R> final class
final class
ConcatMapEager which works with an arbitrary Publisher source.final class
final class
Subscribe to a main Flowable first, then when it completes normally, subscribe to a Completable and terminate when it terminates.final class
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
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
final class
final class
FlowableDebounce<T,
U> final class
final class
final class
final class
Delays the subscription to the main source until the other observable fires an event or completes.final class
final class
final class
FlowableDistinct<T,
K> final class
final class
Calls a consumer after pushing the current item to the downstream.final class
Execute an action after an onError, onComplete or a cancel event.final class
final class
final class
final class
A source Flowable that signals an onSubscribe() + onComplete() only.final class
final class
final class
FlowableFlatMap<T,
U> final class
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
Maps upstream values into MaybeSources and merges their signals into one sequence.final class
Maps upstream values into SingleSources and merges their signals into one sequence.final class
Maps upstream values into SingleSources and merges their signals into one sequence.final class
final class
Executes anAction
and signals its exception or completes normally.final class
final class
final class
Wrap a Completable into a Flowable.final class
final class
final class
final class
final class
Executes anRunnable
and signals its exception or completes normally.final class
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
final class
FlowableGroupJoin<TLeft,
TRight, TLeftEnd, TRightEnd, R> final class
FlowableHide<T>
Hides the identity of the wrapped Flowable and its Subscription.final class
final class
final class
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
final class
FlowableMapPublisher<T,
U> Map working with an arbitrary Publisher source.final class
final class
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
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
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
final class
final class
final class
Handle backpressure with a bounded buffer and custom strategy.final class
final class
final class
final class
final class
final class
Emits an onComplete if the source emits an onError and the predicate returns true for that Throwable.final class
final class
final class
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
Multicasts a Flowable over a selector function.(package private) static final class
final class
Emits a range of integer values.final class
Emits a range of long values.final class
Reduces a sequence via a function into a single value or signals NoSuchElementException for an empty source.final class
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
final class
final class
final class
(package private) static final class
final class
final class
final class
final class
final class
(package private) static final class
Maps a scalar value to a Publisher and subscribes to it.final class
FlowableScan<T>
final class
FlowableScanSeed<T,
R> final class
final class
final class
final class
FlowableSkip<T>
final class
final class
final class
FlowableSkipUntil<T,
U> final class
final class
Subscribes to the source Flowable on the specified Scheduler and makes sure downstream requests are scheduled there as well.final class
final class
FlowableSwitchMap<T,
R> final class
FlowableTake<T>
final class
final class
final class
final class
Take with a generic Publisher source.final class
FlowableTakeUntil<T,
U> final class
final class
final class
final class
Emits the next or latest item when the given time elapses.final class
final class
FlowableTimeout<T,
U, V> final class
final class
final class
FlowableToList<T,
U extends Collection<? super T>> final class
final class
FlowableUsing<T,
D> final class
final class
final class
(package private) static final class
(package private) final class
Wrapper for a FlowableProcessor that detects an incoming subscriber.final class
final class
FlowableWithLatestFrom<T,
U, R> final class
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 FlowableModifier and TypeFieldDescriptionFlowableEmpty.INSTANCE
FlowableNever.INSTANCE
FlowableInternalHelper.BufferedReplaySupplier.parent
FlowableInternalHelper.BufferedTimedReplay.parent
FlowableInternalHelper.ReplaySupplier.parent
FlowableInternalHelper.TimedReplay.parent
AbstractFlowableWithUpstream.source
The upstream source Publisher.BlockingFlowableIterable.source
BlockingFlowableMostRecent.source
FlowableAllSingle.source
FlowableAnySingle.source
FlowableCollectSingle.source
FlowableCountSingle.source
FlowableElementAtMaybe.source
FlowableElementAtSingle.source
FlowableFlatMapCompletableCompletable.source
FlowableIgnoreElementsCompletable.source
FlowableReduceMaybe.source
FlowableReplay.source
The source observable.FlowableSingleMaybe.source
FlowableSingleSingle.source
FlowableToListSingle.source
Fields in io.reactivex.rxjava3.internal.operators.flowable with type parameters of type FlowableModifier and TypeFieldDescriptionFlowableWindow.WindowExactSubscriber.downstream
FlowableWindow.WindowOverlapSubscriber.downstream
FlowableWindow.WindowSkipSubscriber.downstream
FlowableWindowBoundary.WindowBoundaryMainSubscriber.downstream
FlowableWindowBoundarySelector.WindowBoundaryMainSubscriber.downstream
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
FlowableReplay.MulticastFlowable.selector
Methods in io.reactivex.rxjava3.internal.operators.flowable that return FlowableModifier and TypeMethodDescriptionFlowableAllSingle.fuseToFlowable()
FlowableAnySingle.fuseToFlowable()
FlowableCollectSingle.fuseToFlowable()
FlowableCountSingle.fuseToFlowable()
FlowableElementAtMaybe.fuseToFlowable()
FlowableElementAtSingle.fuseToFlowable()
FlowableFlatMapCompletableCompletable.fuseToFlowable()
FlowableIgnoreElementsCompletable.fuseToFlowable()
FlowableReduceMaybe.fuseToFlowable()
FlowableSequenceEqualSingle.fuseToFlowable()
FlowableSingleMaybe.fuseToFlowable()
FlowableSingleSingle.fuseToFlowable()
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 FlowableModifier and TypeMethodDescriptionstatic <T> ConnectableFlowable
<T> 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 sourceFlowable
.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 FlowableModifier and TypeMethodDescriptionstatic <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 FlowableModifierConstructorDescription(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) 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) 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 FlowableModifierConstructorDescription(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.maybeModifier and TypeClassDescriptionfinal class
Concatenate values of each MaybeSource provided in an array.final class
Concatenate values of each MaybeSource provided in an array and delays any errors till the very end.final class
Concatenate values of each MaybeSource provided by an Iterable.final class
Maps a success value into an Iterable and streams it back as a Flowable.final class
Run all MaybeSources of an array at once and signal their values as they become available.final class
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.mixedModifier and TypeClassDescriptionfinal class
After Completable completes, it relays the signals of the Publisher to the downstream subscriber.final class
Maps each upstream item into aMaybeSource
, 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
Maps each upstream item into aMaybeSource
, 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
Maps each upstream item into aSingleSource
, 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
Maps each upstream item into aSingleSource
, 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
Maps the upstream items intoMaybeSource
s 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
Switch between subsequentMaybeSource
s emitted by aPublisher
.final class
Maps the upstream items intoSingleSource
s 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
Switch between subsequentSingleSource
s emitted by aPublisher
.final class
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 FlowableModifier and TypeFieldDescriptionFlowableConcatMapCompletable.source
FlowableConcatMapMaybe.source
FlowableConcatMapSingle.source
FlowableSwitchMapCompletable.source
FlowableSwitchMapMaybe.source
FlowableSwitchMapSingle.source
Constructors in io.reactivex.rxjava3.internal.operators.mixed with parameters of type FlowableModifierConstructorDescriptionFlowableConcatMapCompletable
(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.parallelModifier and TypeClassDescriptionfinal class
ParallelJoin<T>
Merges the individual 'rails' of the source ParallelFlowable, unordered, into a single regular Publisher sequence (exposed as Flowable).final class
Reduces all 'rails' into a single value which then gets reduced into a single Publisher sequence.final class
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.singleModifier and TypeClassDescriptionfinal class
Maps a success value into an Iterable and streams it back as a Flowable.final class
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
Wraps a Single and exposes it as a Flowable.Methods in io.reactivex.rxjava3.internal.operators.single that return FlowableMethods in io.reactivex.rxjava3.internal.operators.single that return types with arguments of type FlowableModifier and TypeMethodDescriptionSingleInternalHelper.iterableToFlowable
(Iterable<? extends SingleSource<? extends T>> sources) SingleInternalHelper.ToFlowableIterable.iterator()
-
Uses of Flowable in io.reactivex.rxjava3.internal.schedulers
Fields in io.reactivex.rxjava3.internal.schedulers with type parameters of type FlowableModifier and TypeFieldDescriptionprivate final FlowableProcessor
<Flowable<Completable>> SchedulerWhen.workerProcessor
Constructor parameters in io.reactivex.rxjava3.internal.schedulers with type arguments of type FlowableModifierConstructorDescriptionSchedulerWhen
(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 FlowableModifier and TypeMethodDescriptionReduces all values within a 'rail' and across 'rails' with a reducer function into oneFlowable
sequence.ParallelFlowable.sequential()
Merges the values from each 'rail' in a round-robin or same-order fashion and exposes it as a regularFlowable
sequence, running with a default prefetch value for the rails.ParallelFlowable.sequential
(int prefetch) Merges the values from each 'rail' in a round-robin or same-order fashion and exposes it as a regularFlowable
sequence, running with a give prefetch value for the rails.ParallelFlowable.sequentialDelayError()
Merges the values from each 'rail' in a round-robin or same-order fashion and exposes it as a regularFlowable
sequence, running with a default prefetch value for the rails and delaying errors from all rails till all terminate.ParallelFlowable.sequentialDelayError
(int prefetch) Merges the values from each 'rail' in a round-robin or same-order fashion and exposes it as a regularFlowable
sequence, running with a give prefetch value for the rails and delaying errors from all rails till all terminate.ParallelFlowable.sorted
(@NonNull Comparator<? super @NonNull T> comparator) Sorts the 'rails' of thisParallelFlowable
and returns aFlowable
that sequentially picks the smallest next value from the rails.ParallelFlowable.sorted
(@NonNull Comparator<? super @NonNull T> comparator, int capacityHint) Sorts the 'rails' of thisParallelFlowable
and returns aFlowable
that sequentially picks the smallest next value from the rails.ParallelFlowable.toSortedList
(@NonNull Comparator<? super @NonNull T> comparator) ParallelFlowable.toSortedList
(@NonNull Comparator<? super @NonNull T> comparator, int capacityHint) -
Uses of Flowable in io.reactivex.rxjava3.plugins
Fields in io.reactivex.rxjava3.plugins with type parameters of type FlowableModifier and TypeFieldDescriptionRxJavaPlugins.onFlowableAssembly
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 FlowableModifier and TypeMethodDescriptionRxJavaPlugins.onAssembly
(@NonNull Flowable<@NonNull T> source) Calls the associated hook function.Methods in io.reactivex.rxjava3.plugins that return types with arguments of type FlowableModifier and TypeMethodDescriptionRxJavaPlugins.getOnFlowableAssembly()
Returns the current hook function.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 FlowableModifier and TypeMethodDescriptionRxJavaPlugins.onAssembly
(@NonNull Flowable<@NonNull T> source) Calls the associated hook function.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 FlowableModifier and TypeMethodDescriptionstatic 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.processorsModifier and TypeClassDescriptionfinal class
Processor that emits the very last value followed by a completion event or the received error toSubscriber
s.final class
Processor that emits the most recent item it has observed and all subsequent observed items to each subscribedSubscriber
.class
Represents a Subscriber and a Flowable (Publisher) at the same time, allowing multicasting events from a single source to multiple child Subscribers.final class
AFlowableProcessor
implementation that coordinates downstream requests through a front-buffer and stable-prefetching, optionally canceling the upstream if all subscribers have cancelled.final class
Processor that multicasts all subsequently observed items to its currentSubscriber
s.final class
Replays events to Subscribers.(package private) final class
Serializes calls to the Subscriber methods.final class
AFlowableProcessor
variant that queues up events until a singleSubscriber
subscribes to it, replays those events to it until theSubscriber
catches up and then switches to relaying events live to this singleSubscriber
until thisUnicastProcessor
terminates or theSubscriber
cancels its subscription.