Uses of Annotation Interface
io.reactivex.rxjava3.annotations.BackpressureSupport
Packages that use BackpressureSupport
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
.Contains the base type
ParallelFlowable
,
a sub-DSL for working with Flowable
sequences in parallel.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 BackpressureSupport in io.reactivex.rxjava3.core
Methods in io.reactivex.rxjava3.core with annotations of type BackpressureSupportModifier 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
.Returns aSingle
that emitstrue
if any item emitted by the currentFlowable
satisfies a specified condition, otherwisefalse
.final T
Flowable.blockingFirst()
Returns the first item emitted by thisFlowable
, or throwsNoSuchElementException
if it emits no items.final T
Flowable.blockingFirst
(@NonNull T defaultItem) Returns the first item emitted by thisFlowable
, or a default value if it emits no items.final void
Flowable.blockingForEach
(@NonNull Consumer<? super @NonNull T> onNext) Consumes the currentFlowable
in a blocking fashion and invokes the givenConsumer
with each upstream item on the current thread until the upstream terminates.final void
Flowable.blockingForEach
(@NonNull Consumer<? super @NonNull T> onNext, int bufferSize) Consumes the currentFlowable
in a blocking fashion and invokes the givenConsumer
with each upstream item on the current thread until the upstream terminates.Flowable.blockingIterable()
Converts thisFlowable
into anIterable
.Flowable.blockingIterable
(int bufferSize) Converts thisFlowable
into anIterable
.final T
Flowable.blockingLast()
Returns the last item emitted by thisFlowable
, or throwsNoSuchElementException
if thisFlowable
emits no items.final T
Flowable.blockingLast
(@NonNull T defaultItem) Returns the last item emitted by thisFlowable
, or a default value if it emits no items.Flowable.blockingLatest()
Returns anIterable
that returns the latest item emitted by thisFlowable
, waiting if necessary for one to become available.Flowable.blockingMostRecent
(@NonNull T initialItem) Returns anIterable
that always returns the item most recently emitted by thisFlowable
.Flowable.blockingNext()
Returns anIterable
that blocks until thisFlowable
emits another item, then returns that item.final T
Flowable.blockingSingle()
If thisFlowable
completes after emitting a single item, return that item, otherwise throw aNoSuchElementException
.final T
Flowable.blockingSingle
(@NonNull T defaultItem) If thisFlowable
completes after emitting a single item, return that item; if it emits more than one item, throw anIllegalArgumentException
; if it emits no items, return a default value.Flowable.blockingStream()
Creates a sequentialStream
to consume or process thisFlowable
in a blocking manner via the JavaStream
API.Flowable.blockingStream
(int prefetch) Creates a sequentialStream
to consume or process thisFlowable
in a blocking manner via the JavaStream
API.final void
Flowable.blockingSubscribe()
Runs the currentFlowable
to a terminal event, ignoring any values and rethrowing any exception.final void
Flowable.blockingSubscribe
(@NonNull Consumer<? super @NonNull T> onNext) Subscribes to the source and calls the given callbacks on the current thread.final void
Flowable.blockingSubscribe
(@NonNull Consumer<? super @NonNull T> onNext, int bufferSize) Subscribes to the source and calls the given callbacks on the current thread.final void
Flowable.blockingSubscribe
(@NonNull Consumer<? super @NonNull T> onNext, @NonNull Consumer<? super Throwable> onError) Subscribes to the source and calls the given callbacks on the current thread.final void
Flowable.blockingSubscribe
(@NonNull Consumer<? super @NonNull T> onNext, @NonNull Consumer<? super Throwable> onError, int bufferSize) Subscribes to the source and calls the given callbacks on the current thread.final void
Flowable.blockingSubscribe
(@NonNull Consumer<? super @NonNull T> onNext, @NonNull Consumer<? super Throwable> onError, @NonNull Action onComplete) Subscribes to the source and calls the given callbacks on the current thread.final void
Flowable.blockingSubscribe
(@NonNull Consumer<? super @NonNull T> onNext, @NonNull Consumer<? super Throwable> onError, @NonNull Action onComplete, int bufferSize) Subscribes to the source and calls the given callbacks on the current thread.final void
Flowable.blockingSubscribe
(@NonNull org.reactivestreams.Subscriber<? super @NonNull T> subscriber) Subscribes to the source and calls theSubscriber
methods on the current thread.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.collect
(@NonNull Supplier<? extends @NonNull U> initialItemSupplier, @NonNull BiConsumer<? super @NonNull U, ? super @NonNull T> collector) Collects items emitted by the finite sourcePublisher
into a single mutable data structure and returns aSingle
that emits this structure.Flowable.collectInto
(@NonNull U initialItem, @NonNull BiConsumer<? super @NonNull U, ? super @NonNull T> collector) Collects items emitted by the finite sourcePublisher
into a single mutable data structure and returns aSingle
that emits this structure.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.static @NonNull Completable
Completable.concat
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends CompletableSource> sources) Returns aCompletable
which completes only when all sources complete, one after another.static @NonNull Completable
Completable.concat
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends CompletableSource> sources, int prefetch) Returns aCompletable
which completes only when all sources complete, one after another.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.static @NonNull Completable
Completable.concatDelayError
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends CompletableSource> sources) Returns aCompletable
which completes only when all sources complete, one after another.static @NonNull Completable
Completable.concatDelayError
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends CompletableSource> sources, int prefetch) Returns aCompletable
which completes only when all sources complete, one after another.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.final @NonNull Completable
Flowable.concatMapCompletable
(@NonNull Function<? super @NonNull T, ? extends CompletableSource> mapper) Maps the upstream items intoCompletableSource
s and subscribes to them one after the other completes.final @NonNull Completable
Flowable.concatMapCompletable
(@NonNull Function<? super @NonNull T, ? extends CompletableSource> mapper, int prefetch) Maps the upstream items intoCompletableSource
s and subscribes to them one after the other completes.final @NonNull Completable
Flowable.concatMapCompletableDelayError
(@NonNull Function<? super @NonNull T, ? extends CompletableSource> mapper) Maps the upstream items intoCompletableSource
s and subscribes to them one after the other terminates, delaying all errors till both thisFlowable
and all innerCompletableSource
s terminate.final @NonNull Completable
Flowable.concatMapCompletableDelayError
(@NonNull Function<? super @NonNull T, ? extends CompletableSource> mapper, boolean tillTheEnd) Maps the upstream items intoCompletableSource
s and subscribes to them one after the other terminates, optionally delaying all errors till both thisFlowable
and all innerCompletableSource
s terminate.final @NonNull Completable
Flowable.concatMapCompletableDelayError
(@NonNull Function<? super @NonNull T, ? extends CompletableSource> mapper, boolean tillTheEnd, int prefetch) Maps the upstream items intoCompletableSource
s and subscribes to them one after the other terminates, optionally delaying all errors till both thisFlowable
and all innerCompletableSource
s terminate.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.count()
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.Delays the emission of thisMaybe
until the givenPublisher
signals an item or completes.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.Maybe.delaySubscription
(@NonNull org.reactivestreams.Publisher<@NonNull U> subscriptionIndicator) Returns aMaybe
that delays the subscription to thisMaybe
until the otherPublisher
emits an element or completes normally.Single.delaySubscription
(@NonNull org.reactivestreams.Publisher<@NonNull U> subscriptionIndicator) Delays the actual subscription to the currentSingle
until the given otherPublisher
signals its first value or completes.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.elementAt
(long index) Returns aMaybe
that emits the single item at a specified index in a sequence of emissions from thisFlowable
or completes if thisFlowable
sequence has fewer elements than index.Returns aSingle
that emits the item found at a specified index in a sequence of emissions from thisFlowable
, or a default item if that index is out of range.Flowable.elementAtOrError
(long index) Returns aSingle
that emits the item found at a specified index in a sequence of emissions from thisFlowable
or signals aNoSuchElementException
if thisFlowable
has fewer elements than index.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.Returns aSingle
that emits only the very first item emitted by thisFlowable
, or a default item if thisFlowable
completes without emitting anything.Flowable.firstElement()
Returns aMaybe
that emits only the very first item emitted by thisFlowable
or completes if thisFlowable
is empty.Flowable.firstOrError()
Returns aSingle
that emits only the very first item emitted by thisFlowable
or signals aNoSuchElementException
if thisFlowable
is empty.final @NonNull CompletionStage
<T> Flowable.firstOrErrorStage()
Signals the first upstream item or aNoSuchElementException
if the upstream is empty via aCompletionStage
.final @NonNull CompletionStage
<T> Flowable.firstStage
(@NonNull T defaultItem) Signals the first upstream item (or the default item if the upstream is empty) via aCompletionStage
.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.final @NonNull Completable
Flowable.flatMapCompletable
(@NonNull Function<? super @NonNull T, ? extends CompletableSource> mapper) Maps each element of the upstreamFlowable
intoCompletableSource
s, subscribes to them and waits until the upstream and allCompletableSource
s complete.final @NonNull Completable
Flowable.flatMapCompletable
(@NonNull Function<? super @NonNull T, ? extends CompletableSource> mapper, boolean delayErrors, int maxConcurrency) Maps each element of the upstreamFlowable
intoCompletableSource
s, subscribes to them and waits until the upstream and allCompletableSource
s complete, optionally delaying all errors.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) final @NonNull Disposable
Subscribes to the currentFlowable
and receives notifications for each element.final @NonNull Disposable
Flowable.forEachWhile
(@NonNull Predicate<? super @NonNull T> onNext) Subscribes to the currentFlowable
and receives notifications for each element until theonNext
Predicate returnsfalse
.final @NonNull Disposable
Flowable.forEachWhile
(@NonNull Predicate<? super @NonNull T> onNext, @NonNull Consumer<? super Throwable> onError) Subscribes to the currentFlowable
and receives notifications for each element and error events until theonNext
Predicate returnsfalse
.final @NonNull Disposable
Flowable.forEachWhile
(@NonNull Predicate<? super @NonNull T> onNext, @NonNull Consumer<? super Throwable> onError, @NonNull Action onComplete) Subscribes to the currentFlowable
and receives notifications for each element and the terminal events until theonNext
Predicate returnsfalse
.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 aFlowable.just(Object)
or an empty optional into anFlowable.empty()
Flowable
instance.static <@NonNull T>
@NonNull CompletableCompletable.fromPublisher
(@NonNull org.reactivestreams.Publisher<@NonNull T> publisher) Returns aCompletable
instance that subscribes to the givenPublisher
, ignores all values and emits only the terminal event.Flowable.fromPublisher
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T> publisher) Converts an arbitrary Reactive StreamsPublisher
into aFlowable
if not already aFlowable
.Maybe.fromPublisher
(@NonNull org.reactivestreams.Publisher<@NonNull T> source) Wraps aPublisher
into aMaybe
and emits the very first item or completes if the source is empty.static <@NonNull T>
@NonNull Observable<T> Observable.fromPublisher
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T> publisher) Converts an arbitrary Reactive StreamsPublisher
into anObservable
.Single.fromPublisher
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T> publisher) Wraps a specificPublisher
into aSingle
and signals its single element or error.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
.final @NonNull Completable
Flowable.ignoreElements()
Ignores all items emitted by the currentFlowable
and only callsonComplete
oronError
.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.isEmpty()
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.Returns aSingle
that emits only the last item emitted by thisFlowable
, or a default item if thisFlowable
completes without emitting any items.Flowable.lastElement()
Returns aMaybe
that emits the last item emitted by thisFlowable
or completes if thisFlowable
is empty.Flowable.lastOrError()
Returns aSingle
that emits only the last item emitted by thisFlowable
or signals aNoSuchElementException
if thisFlowable
is empty.final @NonNull CompletionStage
<T> Flowable.lastOrErrorStage()
Signals the last upstream item or aNoSuchElementException
if the upstream is empty via aCompletionStage
.final @NonNull CompletionStage
<T> Signals the last upstream item (or the default item if the upstream is empty) via aCompletionStage
.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.static @NonNull Completable
Completable.merge
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends CompletableSource> sources) Returns aCompletable
instance that subscribes to all sources at once and completes only when all sourceCompletableSource
s complete or one of them emits an error.static @NonNull Completable
Completable.merge
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends CompletableSource> sources, int maxConcurrency) Returns aCompletable
instance that keeps subscriptions to a limited number of sources at once and completes only when all sourceCompletableSource
s complete or one of them emits an error.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.private static @NonNull Completable
Completable.merge0
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends CompletableSource> sources, int maxConcurrency, boolean delayErrors) Returns aCompletable
instance that keeps subscriptions to a limited number ofCompletableSource
s at once and completes only when all sourceCompletableSource
s terminate in one way or another, combining any exceptions signaled by either the sourcePublisher
or the innerCompletableSource
instances.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.static @NonNull Completable
Completable.mergeDelayError
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends CompletableSource> sources) Returns aCompletable
that subscribes to allCompletableSource
s in the source sequence and delays any error emitted by either the sourcesPublisher
or any of the innerCompletableSource
s until all of them terminate in a way or another.static @NonNull Completable
Completable.mergeDelayError
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends CompletableSource> sources, int maxConcurrency) Returns aCompletable
that subscribes to a limited number of innerCompletableSource
s at once in the source sequence and delays any error emitted by either the sourcesPublisher
or any of the innerCompletableSource
s until all of them terminate in a way or another.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 ofFlowable.bufferSize()
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.final @NonNull ParallelFlowable
<T> Flowable.parallel()
Parallelizes the flow by creating multiple 'rails' (equal to the number of CPUs) and dispatches the upstream items to them in a round-robin fashion.final @NonNull ParallelFlowable
<T> Flowable.parallel
(int parallelism) Parallelizes the flow by creating the specified number of 'rails' and dispatches the upstream items to them in a round-robin fashion.final @NonNull ParallelFlowable
<T> Flowable.parallel
(int parallelism, int prefetch) Parallelizes the flow by creating the specified number of 'rails' and dispatches the upstream items to them in a round-robin fashion and uses the defined per-'rail' prefetch amount.final @NonNull ConnectableFlowable
<T> Flowable.publish()
Returns aConnectableFlowable
, which is a variety ofPublisher
that waits until itsconnect
method is called before it begins emitting items to thoseSubscriber
s that have subscribed to it.final @NonNull ConnectableFlowable
<T> Flowable.publish
(int bufferSize) Returns aConnectableFlowable
, which is a variety ofPublisher
that waits until itsconnect
method is called before it begins emitting items to thoseSubscriber
s that have subscribed to it.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.Returns aMaybe
that applies a specified accumulator function to the first item emitted by the currentFlowable
, then feeds the result of that function along with the second item emitted by the currentFlowable
into the same function, and so on until all items have been emitted by the current and finiteFlowable
, and emits the final result from the final call to your function as its sole item.Flowable.reduce
(@NonNull R seed, @NonNull BiFunction<@NonNull R, ? super @NonNull T, @NonNull R> reducer) Returns aSingle
that applies a specified accumulator function to the first item emitted by the currentFlowable
and a specified seed value, then feeds the result of that function along with the second item emitted by the currentFlowable
into the same function, and so on until all items have been emitted by the current and finiteFlowable
, emitting the final result from the final call to your function as its sole item.Flowable.reduceWith
(@NonNull Supplier<@NonNull R> seedSupplier, @NonNull BiFunction<@NonNull R, ? super @NonNull T, @NonNull R> reducer) Returns aSingle
that applies a specified accumulator function to the first item emitted by the currentFlowable
and a seed value derived from calling a specifiedseedSupplier
, then feeds the result of that function along with the second item emitted by the currentFlowable
into the same function, and so on until all items have been emitted by the current and finiteFlowable
, emitting the final result from the final call to your function as its sole item.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.final @NonNull ConnectableFlowable
<T> Flowable.replay()
Returns aConnectableFlowable
that shares a single subscription to the underlyingPublisher
that will replay all of its items and notifications to any futureSubscriber
.final @NonNull ConnectableFlowable
<T> Flowable.replay
(int bufferSize) Returns aConnectableFlowable
that shares a single subscription to the currentFlowable
and replays at mostbufferSize
items to lateSubscriber
s.final @NonNull ConnectableFlowable
<T> Flowable.replay
(int bufferSize, boolean eagerTruncate) Returns aConnectableFlowable
that shares a single subscription to the currentFlowable
and replays at mostbufferSize
items to lateSubscriber
s.final @NonNull ConnectableFlowable
<T> Returns aConnectableFlowable
that shares a single subscription to the currentFlowable
and replays at mostbufferSize
items that were emitted during a specified time window.final @NonNull ConnectableFlowable
<T> Returns aConnectableFlowable
that shares a single subscription to the currentFlowable
and replays a maximum ofbufferSize
items that are emitted within a specified time window to lateSubscriber
s.final @NonNull ConnectableFlowable
<T> Flowable.replay
(int bufferSize, long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean eagerTruncate) Returns aConnectableFlowable
that shares a single subscription to the currentFlowable
and replays a maximum ofbufferSize
items that are emitted within a specified time window to lateSubscriber
s.final @NonNull ConnectableFlowable
<T> Returns aConnectableFlowable
that shares a single subscription to the currentFlowable
and replays all items emitted by it within a specified time window to lateSubscriber
s.final @NonNull ConnectableFlowable
<T> Returns aConnectableFlowable
that shares a single subscription to the currentFlowable
and replays all items emitted by it within a specified time window to lateSubscriber
s.final @NonNull ConnectableFlowable
<T> Flowable.replay
(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean eagerTruncate) Returns aConnectableFlowable
that shares a single subscription to the currentFlowable
and replays all items emitted by it within a specified time window to lateSubscriber
s.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
.final void
Flowable.safeSubscribe
(@NonNull org.reactivestreams.Subscriber<? super @NonNull T> subscriber) Subscribes to the currentFlowable
and wraps the givenSubscriber
into aSafeSubscriber
(if not already aSafeSubscriber
) that deals with exceptions thrown by a misbehavingSubscriber
(that doesn't follow the Reactive Streams specification).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.sequenceEqual
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T> source2) Flowable.sequenceEqual
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T> source2, int bufferSize) Flowable.sequenceEqual
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T> source2, @NonNull BiPredicate<? super @NonNull T, ? super @NonNull T> isEqual) Flowable.sequenceEqual
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T> source2, @NonNull BiPredicate<? super @NonNull T, ? super @NonNull T> isEqual, int bufferSize) 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
.Returns aSingle
that emits the single item emitted by the currentFlowable
if it emits only a single item, or a default item if the currentFlowable
emits no items.Flowable.singleElement()
Returns aMaybe
that completes if thisFlowable
is empty, signals one item if thisFlowable
signals exactly one item or signals anIllegalArgumentException
if thisFlowable
signals more than one item.Flowable.singleOrError()
Returns aSingle
that emits the single item emitted by thisFlowable
, if thisFlowable
emits only a single item, otherwise if thisFlowable
completes without emitting any items aNoSuchElementException
will be signaled and if thisFlowable
emits more than one item, anIllegalArgumentException
will be signaled.final @NonNull CompletionStage
<T> Flowable.singleOrErrorStage()
Signals the only expected upstream item, aNoSuchElementException
if the upstream is empty or signalsIllegalArgumentException
if the upstream has more than one item via aCompletionStage
.final @NonNull CompletionStage
<T> Flowable.singleStage
(@NonNull T defaultItem) Signals the only expected upstream item (or the default item if the upstream is empty) or signalsIllegalArgumentException
if the upstream has more than one item via aCompletionStage
.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
.final @NonNull Disposable
Flowable.subscribe()
Subscribes to the currentFlowable
and ignoresonNext
andonComplete
emissions.final void
Flowable.subscribe
(@NonNull FlowableSubscriber<? super @NonNull T> subscriber) Establish a connection between thisFlowable
and the givenFlowableSubscriber
and start streaming events based on the demand of theFlowableSubscriber
.final @NonNull Disposable
Subscribes to the currentFlowable
and provides a callback to handle the items it emits.final @NonNull Disposable
Flowable.subscribe
(@NonNull Consumer<? super @NonNull T> onNext, @NonNull Consumer<? super Throwable> onError) Subscribes to the currentFlowable
and provides callbacks to handle the items it emits and any error notification it issues.final @NonNull Disposable
Flowable.subscribe
(@NonNull Consumer<? super @NonNull T> onNext, @NonNull Consumer<? super Throwable> onError, @NonNull Action onComplete) Subscribes to the currentFlowable
and provides callbacks to handle the items it emits and any error or completion notification it issues.final @NonNull Disposable
Flowable.subscribe
(@NonNull Consumer<? super @NonNull T> onNext, @NonNull Consumer<? super Throwable> onError, @NonNull Action onComplete, @NonNull DisposableContainer container) Wraps the given onXXX callbacks into aDisposable
Subscriber
, adds it to the givenDisposableContainer
and ensures, that if the upstream terminates or this particularDisposable
is disposed, theSubscriber
is removed from the given container.final void
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.subscribeWith
(@NonNull E subscriber) Subscribes a givenSubscriber
(subclass) to thisFlowable
and returns the givenSubscriber
as is.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.final @NonNull Completable
Flowable.switchMapCompletable
(@NonNull Function<? super @NonNull T, ? extends CompletableSource> mapper) Maps the upstream values intoCompletableSource
s, subscribes to the newer one while disposing the subscription to the previousCompletableSource
, thus keeping at most one activeCompletableSource
running.final @NonNull Completable
Flowable.switchMapCompletableDelayError
(@NonNull Function<? super @NonNull T, ? extends CompletableSource> mapper) Maps the upstream values intoCompletableSource
s, subscribes to the newer one while disposing the subscription to the previousCompletableSource
, thus keeping at most one activeCompletableSource
running and delaying any main or inner errors until all of them terminate.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.static @NonNull Completable
Completable.switchOnNext
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends CompletableSource> sources) Switches betweenCompletableSource
s emitted by the sourcePublisher
whenever a newCompletableSource
is emitted, disposing the previously runningCompletableSource
, exposing the setup as aCompletable
sequence.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.static @NonNull Completable
Completable.switchOnNextDelayError
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends CompletableSource> sources) Switches betweenCompletableSource
s emitted by the sourcePublisher
whenever a newCompletableSource
is emitted, disposing the previously runningCompletableSource
, exposing the setup as aCompletable
sequence and delaying all errors from all of them until all terminate.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 aMaybe
that emits the item emitted by the currentMaybe
until a secondPublisher
emits an item.Returns aSingle
that emits the item emitted by the currentSingle
until aPublisher
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.final @NonNull TestSubscriber
<T> Flowable.test()
final @NonNull TestSubscriber
<T> Flowable.test
(long initialRequest) Creates aTestSubscriber
with the given initial request amount and subscribes it to thisFlowable
.final @NonNull TestSubscriber
<T> Flowable.test
(long initialRequest, boolean cancel) Creates aTestSubscriber
with the given initial request amount, optionally cancels it before the subscription and subscribes it to thisFlowable
.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.If the currentMaybe
source didn't signal an event before thetimeoutIndicator
Publisher
signals, aTimeoutException
is signaled instead.Maybe.timeout
(@NonNull org.reactivestreams.Publisher<@NonNull U> timeoutIndicator, @NonNull MaybeSource<? extends @NonNull T> fallback) If the currentMaybe
didn't signal an event before thetimeoutIndicator
Publisher
signals, the currentMaybe
is disposed and thefallback
MaybeSource
subscribed to as a continuation.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()
final <@NonNull R>
RCalls the specified converter function during assembly time and returns its resulting value.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.toFuture()
Returns aFuture
representing the only value emitted by thisFlowable
.Flowable.toList()
Returns aSingle
that emits a single item, a list composed of all the items emitted by the finite upstream sourcePublisher
.Flowable.toList
(int capacityHint) Returns aSingle
that emits a single item, a list composed of all the items emitted by the finite sourcePublisher
.Returns aSingle
that emits a single item, a list composed of all the items emitted by the finite sourcePublisher
.Flowable.toMap
(@NonNull Function<? super @NonNull T, ? extends @NonNull K> keySelector, @NonNull Function<? super @NonNull T, ? extends @NonNull V> valueSelector) Flowable.toMap
(@NonNull Function<? super @NonNull T, ? extends @NonNull K> keySelector, @NonNull Function<? super @NonNull T, ? extends @NonNull V> valueSelector, @NonNull Supplier<? extends Map<@NonNull K, @NonNull V>> mapSupplier) Flowable.toMultimap
(@NonNull Function<? super @NonNull T, ? extends @NonNull K> keySelector, @NonNull Function<? super @NonNull T, ? extends @NonNull V> valueSelector) Flowable.toMultimap
(@NonNull Function<? super @NonNull T, ? extends @NonNull K> keySelector, @NonNull Function<? super @NonNull T, ? extends @NonNull V> valueSelector, @NonNull Supplier<? extends Map<@NonNull K, Collection<@NonNull V>>> mapSupplier, @NonNull Function<? super @NonNull K, ? extends Collection<? super @NonNull V>> collectionFactory) Flowable.toMultimap
(@NonNull Function<? super @NonNull T, ? extends @NonNull K> keySelector, @NonNull Function<? super @NonNull T, ? extends @NonNull V> valueSelector, @NonNull Supplier<Map<@NonNull K, Collection<@NonNull V>>> mapSupplier) final @NonNull Observable
<T> Flowable.toObservable()
Converts the currentFlowable
into a non-backpressuredObservable
.Flowable.toSortedList()
Flowable.toSortedList
(int capacityHint) Flowable.toSortedList
(@NonNull Comparator<? super @NonNull T> comparator) Flowable.toSortedList
(@NonNull Comparator<? super @NonNull T> comparator, int capacityHint) 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
. -
Uses of BackpressureSupport in io.reactivex.rxjava3.flowables
Methods in io.reactivex.rxjava3.flowables with annotations of type BackpressureSupportModifier 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 BackpressureSupport in io.reactivex.rxjava3.parallel
Methods in io.reactivex.rxjava3.parallel with annotations of type BackpressureSupportModifier and TypeMethodDescriptionfinal <@NonNull C>
@NonNull ParallelFlowable<C> ParallelFlowable.collect
(@NonNull Supplier<? extends @NonNull C> collectionSupplier, @NonNull BiConsumer<? super @NonNull C, ? super @NonNull T> collector) Collect the elements in each rail into a collection supplied via acollectionSupplier
and collected into with a collector action, emitting the collection at the end.final <@NonNull U>
@NonNull ParallelFlowable<U> Allows composing operators, in assembly time, on top of thisParallelFlowable
and returns anotherParallelFlowable
with composed features.final <@NonNull R>
@NonNull ParallelFlowable<R> ParallelFlowable.concatMap
(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> mapper) Generates and concatenatesPublisher
s on each 'rail', signalling errors immediately and generating 2 publishers upfront.final <@NonNull R>
@NonNull ParallelFlowable<R> ParallelFlowable.concatMap
(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> mapper, int prefetch) Generates and concatenatesPublisher
s on each 'rail', signalling errors immediately and using the given prefetch amount for generatingPublisher
s upfront.final <@NonNull R>
@NonNull ParallelFlowable<R> ParallelFlowable.concatMapDelayError
(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> mapper, boolean tillTheEnd) Generates and concatenatesPublisher
s on each 'rail', optionally delaying errors and generating 2 publishers upfront.final <@NonNull R>
@NonNull ParallelFlowable<R> ParallelFlowable.concatMapDelayError
(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> mapper, int prefetch, boolean tillTheEnd) Generates and concatenatesPublisher
s on each 'rail', optionally delaying errors and using the given prefetch amount for generatingPublisher
s upfront.final @NonNull ParallelFlowable
<T> ParallelFlowable.doAfterNext
(@NonNull Consumer<? super @NonNull T> onAfterNext) Call the specified consumer with the current element passing through any 'rail' after it has been delivered to downstream within the rail.final @NonNull ParallelFlowable
<T> ParallelFlowable.doAfterTerminated
(@NonNull Action onAfterTerminate) Run the specifiedAction
when a 'rail' completes or signals an error.final @NonNull ParallelFlowable
<T> ParallelFlowable.doOnCancel
(@NonNull Action onCancel) Run the specifiedAction
when a 'rail' receives a cancellation.final @NonNull ParallelFlowable
<T> ParallelFlowable.doOnComplete
(@NonNull Action onComplete) Run the specifiedAction
when a 'rail' completes.final @NonNull ParallelFlowable
<T> Call the specified consumer with the exception passing through any 'rail'.final @NonNull ParallelFlowable
<T> Call the specified consumer with the current element passing through any 'rail'.final @NonNull ParallelFlowable
<T> ParallelFlowable.doOnNext
(@NonNull Consumer<? super @NonNull T> onNext, @NonNull BiFunction<? super Long, ? super Throwable, ParallelFailureHandling> errorHandler) Call the specified consumer with the current element passing through any 'rail' and handles errors based on the returned value by the handler function.final @NonNull ParallelFlowable
<T> ParallelFlowable.doOnNext
(@NonNull Consumer<? super @NonNull T> onNext, @NonNull ParallelFailureHandling errorHandler) Call the specified consumer with the current element passing through any 'rail' and handles errors based on the givenParallelFailureHandling
enumeration value.final @NonNull ParallelFlowable
<T> ParallelFlowable.doOnRequest
(@NonNull LongConsumer onRequest) Call the specified consumer with the request amount if any rail receives a request.final @NonNull ParallelFlowable
<T> ParallelFlowable.doOnSubscribe
(@NonNull Consumer<? super org.reactivestreams.Subscription> onSubscribe) Call the specified callback when a 'rail' receives aSubscription
from its upstream.final @NonNull ParallelFlowable
<T> Filters the source values on each 'rail'.final @NonNull ParallelFlowable
<T> ParallelFlowable.filter
(@NonNull Predicate<? super @NonNull T> predicate, @NonNull BiFunction<? super Long, ? super Throwable, ParallelFailureHandling> errorHandler) Filters the source values on each 'rail' and handles errors based on the returned value by the handler function.final @NonNull ParallelFlowable
<T> ParallelFlowable.filter
(@NonNull Predicate<? super @NonNull T> predicate, @NonNull ParallelFailureHandling errorHandler) Filters the source values on each 'rail' and handles errors based on the givenParallelFailureHandling
enumeration value.final <@NonNull R>
@NonNull ParallelFlowable<R> ParallelFlowable.flatMap
(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> mapper) Generates and flattensPublisher
s on each 'rail'.final <@NonNull R>
@NonNull ParallelFlowable<R> ParallelFlowable.flatMap
(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> mapper, boolean delayError) Generates and flattensPublisher
s on each 'rail', optionally delaying errors.final <@NonNull R>
@NonNull ParallelFlowable<R> ParallelFlowable.flatMap
(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> mapper, boolean delayError, int maxConcurrency) Generates and flattensPublisher
s on each 'rail', optionally delaying errors and having a total number of simultaneous subscriptions to the innerPublisher
s.final <@NonNull R>
@NonNull ParallelFlowable<R> ParallelFlowable.flatMap
(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> mapper, boolean delayError, int maxConcurrency, int prefetch) Generates and flattensPublisher
s on each 'rail', optionally delaying errors, having a total number of simultaneous subscriptions to the innerPublisher
s and using the given prefetch amount for the innerPublisher
s.final <@NonNull U>
@NonNull ParallelFlowable<U> ParallelFlowable.flatMapIterable
(@NonNull Function<? super @NonNull T, @NonNull ? extends Iterable<? extends @NonNull U>> mapper) Returns aParallelFlowable
that merges each item emitted by the source on each rail with the values in anIterable
corresponding to that item that is generated by a selector.final <@NonNull U>
@NonNull ParallelFlowable<U> ParallelFlowable.flatMapIterable
(@NonNull Function<? super @NonNull T, @NonNull ? extends Iterable<? extends @NonNull U>> mapper, int bufferSize) Returns aParallelFlowable
that merges each item emitted by the sourceParallelFlowable
with the values in anIterable
corresponding to that item that is generated by a selector.final <@NonNull R>
@NonNull ParallelFlowable<R> ParallelFlowable.flatMapStream
(@NonNull Function<? super @NonNull T, @NonNull ? extends Stream<? extends @NonNull R>> mapper) Maps each upstream item on each rail into aStream
and emits theStream
's items to the downstream in a sequential fashion.final <@NonNull R>
@NonNull ParallelFlowable<R> ParallelFlowable.flatMapStream
(@NonNull Function<? super @NonNull T, @NonNull ? extends Stream<? extends @NonNull R>> mapper, int prefetch) Maps each upstream item of each rail into aStream
and emits theStream
's items to the downstream in a sequential fashion.static <@NonNull T>
@NonNull ParallelFlowable<T> Take aPublisher
and prepare to consume it on multiple 'rails' (number of CPUs) in a round-robin fashion.static <@NonNull T>
@NonNull ParallelFlowable<T> ParallelFlowable.from
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T> source, int parallelism) Take aPublisher
and prepare to consume it on parallelism number of 'rails' in a round-robin fashion.static <@NonNull T>
@NonNull ParallelFlowable<T> ParallelFlowable.from
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T> source, int parallelism, int prefetch) Take aPublisher
and prepare to consume it on parallelism number of 'rails' , possibly ordered and round-robin fashion and use custom prefetch amount and queue for dealing with the sourcePublisher
's values.static <@NonNull T>
@NonNull ParallelFlowable<T> Wraps multiplePublisher
s into aParallelFlowable
which runs them in parallel and unordered.final <@NonNull R>
@NonNull ParallelFlowable<R> Maps the source values on each 'rail' to another value.final <@NonNull R>
@NonNull ParallelFlowable<R> ParallelFlowable.map
(@NonNull Function<? super @NonNull T, ? extends @NonNull R> mapper, @NonNull BiFunction<? super Long, ? super Throwable, ParallelFailureHandling> errorHandler) Maps the source values on each 'rail' to another value and handles errors based on the returned value by the handler function.final <@NonNull R>
@NonNull ParallelFlowable<R> ParallelFlowable.map
(@NonNull Function<? super @NonNull T, ? extends @NonNull R> mapper, @NonNull ParallelFailureHandling errorHandler) Maps the source values on each 'rail' to another value and handles errors based on the givenParallelFailureHandling
enumeration value.final <@NonNull R>
@NonNull ParallelFlowable<R> ParallelFlowable.mapOptional
(@NonNull Function<? super @NonNull T, @NonNull Optional<? extends @NonNull R>> mapper) Maps the source values on each 'rail' to an optional and emits its value if any.final <@NonNull R>
@NonNull ParallelFlowable<R> ParallelFlowable.mapOptional
(@NonNull Function<? super @NonNull T, @NonNull Optional<? extends @NonNull R>> mapper, @NonNull BiFunction<? super Long, ? super Throwable, ParallelFailureHandling> errorHandler) Maps the source values on each 'rail' to an optional and emits its value if any and handles errors based on the returned value by the handler function.final <@NonNull R>
@NonNull ParallelFlowable<R> ParallelFlowable.mapOptional
(@NonNull Function<? super @NonNull T, @NonNull Optional<? extends @NonNull R>> mapper, @NonNull ParallelFailureHandling errorHandler) Maps the source values on each 'rail' to an optional and emits its value if any and handles errors based on the givenParallelFailureHandling
enumeration value.Reduces all values within a 'rail' and across 'rails' with a reducer function into oneFlowable
sequence.final <@NonNull R>
@NonNull ParallelFlowable<R> ParallelFlowable.reduce
(@NonNull Supplier<@NonNull R> initialSupplier, @NonNull BiFunction<@NonNull R, ? super @NonNull T, @NonNull R> reducer) Reduces all values within a 'rail' to a single value (with a possibly different type) via a reducer function that is initialized on each rail from aninitialSupplier
value.final @NonNull ParallelFlowable
<T> Specifies where each 'rail' will observe its incoming values, specified via aScheduler
, with no work-stealing and default prefetch amount.final @NonNull ParallelFlowable
<T> Specifies where each 'rail' will observe its incoming values, specified via aScheduler
, with possibly work-stealing and a given prefetch amount.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.abstract void
ParallelFlowable.subscribe
(@NonNull org.reactivestreams.Subscriber<? super @NonNull T>[] subscribers) Subscribes an array ofSubscriber
s to thisParallelFlowable
and triggers the execution chain for all 'rails'.final <@NonNull R>
RCalls the specified converter function during assembly time and returns its resulting value.ParallelFlowable.toSortedList
(@NonNull Comparator<? super @NonNull T> comparator) ParallelFlowable.toSortedList
(@NonNull Comparator<? super @NonNull T> comparator, int capacityHint) -
Uses of BackpressureSupport in io.reactivex.rxjava3.processors
Classes in io.reactivex.rxjava3.processors with annotations of type BackpressureSupportModifier and TypeClassDescriptionfinal class
AFlowableProcessor
implementation that coordinates downstream requests through a front-buffer and stable-prefetching, optionally canceling the upstream if all subscribers have cancelled.