RetroSearch Browse

that indicates whether all of the items emitted by the current

Flowable

satisfy a condition.

static <T> @NonNull Flowable<T> amb(@NonNull Iterable<? extends Publisher<? extends T>> sources)

Mirrors the one

in an

of several

Publisher

s that first either emits an item or sends a termination notification.

static <T> @NonNull Flowable<T> ambArray(Publisher<? extends T>... sources)

Mirrors the one

in an array of several

Publisher

s that first either emits an item or sends a termination notification.

@NonNull Flowable<T> ambWith(@NonNull Publisher<? extends T> other)

Mirrors the

(current or provided) that first either emits an item or sends a termination notification.

@NonNull Single<Boolean> any(@NonNull Predicate<? super T> predicate)

Returns a

Single

that emits

true

if any item emitted by the current

Flowable

satisfies a specified condition, otherwise

false

T blockingFirst() T blockingFirst(T defaultItem)

Returns the first item emitted by this Flowable, or a default value if it emits no items.

void blockingForEach(@NonNull Consumer<? super T> onNext)

Consumes the current

Flowable

in a blocking fashion and invokes the given

with each upstream item on the

current thread

until the upstream terminates.

void blockingForEach(@NonNull Consumer<? super T> onNext, int bufferSize)

Consumes the current

Flowable

in a blocking fashion and invokes the given

with each upstream item on the

current thread

until the upstream terminates.

@NonNull Iterable<T> blockingIterable()

Converts this

Flowable

into an

@NonNull Iterable<T> blockingIterable(int bufferSize)

Converts this

Flowable

into an

T blockingLast()

Returns the last item emitted by this

Flowable

, or throws

if this

Flowable

emits no items.

T blockingLast(T defaultItem)

Returns the last item emitted by this Flowable, or a default value if it emits no items.

@NonNull Iterable<T> blockingLatest()

Returns an

that returns the latest item emitted by this

Flowable

, waiting if necessary for one to become available.

@NonNull Iterable<T> blockingMostRecent(T initialItem)

Returns an

that always returns the item most recently emitted by this

Flowable

@NonNull Iterable<T> blockingNext()

Returns an

that blocks until this

Flowable

emits another item, then returns that item.

T blockingSingle()

If this

Flowable

completes after emitting a single item, return that item, otherwise throw a

T blockingSingle(T defaultItem)

If this

Flowable

completes after emitting a single item, return that item; if it emits more than one item, throw an

IllegalArgumentException

; if it emits no items, return a default value.

@NonNull Stream<T> blockingStream()

Creates a sequential

Stream

to consume or process this

Flowable

in a blocking manner via the Java

Stream

API.

@NonNull Stream<T> blockingStream(int prefetch)

Creates a sequential

Stream

to consume or process this

Flowable

in a blocking manner via the Java

Stream

API.

void blockingSubscribe()

Runs the current Flowable to a terminal event, ignoring any values and rethrowing any exception.

void blockingSubscribe(@NonNull Consumer<? super T> onNext)

Subscribes to the source and calls the given callbacks on the current thread.

void blockingSubscribe(@NonNull Consumer<? super T> onNext, @NonNull Consumer<? super Throwable> onError)

Subscribes to the source and calls the given callbacks on the current thread.

void

blockingSubscribe(@NonNull Consumer<? super T> onNext, @NonNull Consumer<? super Throwable> onError, @NonNull Action onComplete)

Subscribes to the source and calls the given callbacks on the current thread.

void

blockingSubscribe(@NonNull Consumer<? super 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.

void blockingSubscribe(@NonNull Consumer<? super T> onNext, @NonNull Consumer<? super Throwable> onError, int bufferSize)

Subscribes to the source and calls the given callbacks on the current thread.

void blockingSubscribe(@NonNull Consumer<? super T> onNext, int bufferSize)

Subscribes to the source and calls the given callbacks on the current thread.

void blockingSubscribe(@NonNull Subscriber<? super T> subscriber)

Subscribes to the source and calls the

methods

on the current thread

@NonNull Flowable<List<T>> buffer(int count)

Returns a Flowable that emits buffers of items it collects from the current Flowable.

@NonNull Flowable<List<T>> buffer(int count, int skip)

Returns a Flowable that emits buffers of items it collects from the current Flowable.

<U extends Collection<? super T>>
@NonNull Flowable<U>

buffer(int count, int skip, @NonNull Supplier bufferSupplier)

Returns a Flowable that emits buffers of items it collects from the current Flowable.

<U extends Collection<? super T>>
@NonNull Flowable<U>

buffer(int count, @NonNull Supplier bufferSupplier)

Returns a Flowable that emits buffers of items it collects from the current Flowable.

@NonNull Flowable<List<T>> buffer(long timespan, long timeskip, @NonNull TimeUnit unit)

Returns a Flowable that emits buffers of items it collects from the current Flowable.

@NonNull Flowable<List<T>> buffer(long timespan, long timeskip, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)

Returns a Flowable that emits buffers of items it collects from the current Flowable.

<U extends Collection<? super T>>
@NonNull Flowable<U>

buffer(long timespan, long timeskip, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, @NonNull Supplier<U> bufferSupplier)

Returns a Flowable that emits buffers of items it collects from the current Flowable.

@NonNull Flowable<List<T>> buffer(long timespan, @NonNull TimeUnit unit)

Returns a Flowable that emits buffers of items it collects from the current Flowable.

@NonNull Flowable<List<T>> buffer(long timespan, @NonNull TimeUnit unit, int count)

Returns a Flowable that emits buffers of items it collects from the current Flowable.

@NonNull Flowable<List<T>> buffer(long timespan, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)

Returns a Flowable that emits buffers of items it collects from the current Flowable.

@NonNull Flowable<List<T>> buffer(long timespan, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, int count)

Returns a Flowable that emits buffers of items it collects from the current Flowable.

<U extends Collection<? super T>>
@NonNull Flowable<U>

buffer(long timespan, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, int count, @NonNull Supplier<U> bufferSupplier, boolean restartTimerOnMaxSize)

Returns a Flowable that emits buffers of items it collects from the current Flowable.

<TOpening,TClosing>
@NonNull Flowable<List<T>>

buffer(@NonNull Publisher<? extends TOpening> openingIndicator, @NonNull Function<? super TOpening,? extends Publisher<? extends TClosing>> closingIndicator)

Returns a Flowable that emits buffers of items it collects from the current Flowable.

<TOpening,TClosing,U extends Collection<? super T>>
@NonNull Flowable<U>

buffer(@NonNull Publisher<? extends TOpening> openingIndicator, @NonNull Function<? super TOpening,? extends Publisher<? extends TClosing>> closingIndicator, @NonNull Supplier<U> bufferSupplier)

Returns a Flowable that emits buffers of items it collects from the current Flowable.

 @NonNull Flowable<List<T>> buffer(@NonNull Publisher boundaryIndicator)

Returns a

Flowable

that emits non-overlapping buffered items from the current

Flowable

each time the specified boundary

emits an item.

 @NonNull Flowable<List<T>> buffer(@NonNull Publisher boundaryIndicator, int initialCapacity)

Returns a

Flowable

that emits non-overlapping buffered items from the current

Flowable

each time the specified boundary

emits an item.

<B,U extends Collection<? super T>>
@NonNull Flowable<U>

buffer(@NonNull Publisher boundaryIndicator, @NonNull Supplier bufferSupplier)

Returns a

Flowable

that emits non-overlapping buffered items from the current

Flowable

each time the specified boundary

emits an item.

static int bufferSize()

Returns the default internal buffer size used by most async operators.

@NonNull Flowable<T> cache()

Returns a

Flowable

that subscribes to this

lazily, caches all of its events and replays them, in the same order as received, to all the downstream subscribers.

@NonNull Flowable<T> cacheWithInitialCapacity(int initialCapacity)

Returns a

Flowable

that subscribes to this

lazily, caches all of its events and replays them, in the same order as received, to all the downstream subscribers.

 @NonNull Flowable cast(@NonNull Class clazz)

Returns a

Flowable

that emits the upstream items while they can be cast via

Class.cast(Object)

until the upstream terminates, or until the upstream signals an item which can't be cast, resulting in a

ClassCastException

to be signaled to the downstream.

<R,A> @NonNull Single<R> collect(@NonNull Collector<? super T,A,R> collector)

Collects the finite upstream's values into a container via a

Stream Collector

callback set and emits it as the success result.

 @NonNull Single collect(@NonNull Supplier<? extends U> initialItemSupplier, @NonNull BiConsumer<? super U,? super T> collector)

Collects items emitted by the finite source

into a single mutable data structure and returns a

Single

that emits this structure.

 @NonNull Single collectInto(U initialItem, @NonNull BiConsumer<? super U,? super T> collector)

Collects items emitted by the finite source

into a single mutable data structure and returns a

Single

that emits this structure.

static <T,R> @NonNull Flowable<R>

combineLatest(@NonNull Iterable<? extends Publisher<? extends T>> sources, @NonNull Function<? super Object[],? extends R> combiner)

Combines a collection of source

s by emitting an item that aggregates the latest values of each of the source

Publisher

s each time an item is received from any of the source

Publisher

s, where this aggregation is defined by a specified function.

static <T,R> @NonNull Flowable<R>

combineLatest(@NonNull Iterable<? extends Publisher<? extends T>> sources, @NonNull Function<? super Object[],? extends R> combiner, int bufferSize)

Combines a collection of source

s by emitting an item that aggregates the latest values of each of the source

Publisher

s each time an item is received from any of the source

Publisher

s, where this aggregation is defined by a specified function.

static <T1,T2,R> @NonNull Flowable<R>

combineLatest(@NonNull Publisher<? extends T1> source1, @NonNull Publisher<? extends T2> source2, @NonNull BiFunction<? super T1,? super T2,? extends R> combiner)

Combines two source

s by emitting an item that aggregates the latest values of each of the source

Publisher

s each time an item is received from either of the source

Publisher

s, where this aggregation is defined by a specified function.

static <T1,T2,T3,R>
@NonNull Flowable<R>

combineLatest(@NonNull Publisher<? extends T1> source1, @NonNull Publisher<? extends T2> source2, @NonNull Publisher<? extends T3> source3, @NonNull Function3<? super T1,? super T2,? super T3,? extends R> combiner)

Combines three source

s by emitting an item that aggregates the latest values of each of the source

Publisher

s each time an item is received from any of the source

Publisher

s, where this aggregation is defined by a specified function.

static <T1,T2,T3,T4,R>
@NonNull Flowable<R>

combineLatest(@NonNull Publisher<? extends T1> source1, @NonNull Publisher<? extends T2> source2, @NonNull Publisher<? extends T3> source3, @NonNull Publisher<? extends T4> source4, @NonNull Function4<? super T1,? super T2,? super T3,? super T4,? extends R> combiner)

Combines four source

s by emitting an item that aggregates the latest values of each of the source

Publisher

s each time an item is received from any of the source

Publisher

s, where this aggregation is defined by a specified function.

static <T1,T2,T3,T4,T5,R>
@NonNull Flowable<R>

combineLatest(@NonNull Publisher<? extends T1> source1, @NonNull Publisher<? extends T2> source2, @NonNull Publisher<? extends T3> source3, @NonNull Publisher<? extends T4> source4, @NonNull Publisher<? extends T5> source5, @NonNull Function5<? super T1,? super T2,? super T3,? super T4,? super T5,? extends R> combiner)

Combines five source

s by emitting an item that aggregates the latest values of each of the source

Publisher

s each time an item is received from any of the source

Publisher

s, where this aggregation is defined by a specified function.

static <T1,T2,T3,T4,T5,T6,R>
@NonNull Flowable<R>

combineLatest(@NonNull Publisher<? extends T1> source1, @NonNull Publisher<? extends T2> source2, @NonNull Publisher<? extends T3> source3, @NonNull Publisher<? extends T4> source4, @NonNull Publisher<? extends T5> source5, @NonNull Publisher<? extends T6> source6, @NonNull Function6<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? extends R> combiner)

Combines six source

s by emitting an item that aggregates the latest values of each of the source

Publisher

s each time an item is received from any of the source

Publisher

s, where this aggregation is defined by a specified function.

static <T1,T2,T3,T4,T5,T6,T7,R>
@NonNull Flowable<R>

combineLatest(@NonNull Publisher<? extends T1> source1, @NonNull Publisher<? extends T2> source2, @NonNull Publisher<? extends T3> source3, @NonNull Publisher<? extends T4> source4, @NonNull Publisher<? extends T5> source5, @NonNull Publisher<? extends T6> source6, @NonNull Publisher<? extends T7> source7, @NonNull Function7<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? extends R> combiner)

Combines seven source

s by emitting an item that aggregates the latest values of each of the source

Publisher

s each time an item is received from any of the source

Publisher

s, where this aggregation is defined by a specified function.

static <T1,T2,T3,T4,T5,T6,T7,T8,R>
@NonNull Flowable<R>

combineLatest(@NonNull Publisher<? extends T1> source1, @NonNull Publisher<? extends T2> source2, @NonNull Publisher<? extends T3> source3, @NonNull Publisher<? extends T4> source4, @NonNull Publisher<? extends T5> source5, @NonNull Publisher<? extends T6> source6, @NonNull Publisher<? extends T7> source7, @NonNull Publisher<? extends T8> source8, @NonNull Function8<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? extends R> combiner)

Combines eight source

s by emitting an item that aggregates the latest values of each of the source

Publisher

s each time an item is received from any of the source

Publisher

s, where this aggregation is defined by a specified function.

static <T1,T2,T3,T4,T5,T6,T7,T8,T9,R>
@NonNull Flowable<R>

combineLatest(@NonNull Publisher<? extends T1> source1, @NonNull Publisher<? extends T2> source2, @NonNull Publisher<? extends T3> source3, @NonNull Publisher<? extends T4> source4, @NonNull Publisher<? extends T5> source5, @NonNull Publisher<? extends T6> source6, @NonNull Publisher<? extends T7> source7, @NonNull Publisher<? extends T8> source8, @NonNull Publisher<? extends T9> source9, @NonNull Function9<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? super T9,? extends R> combiner)

Combines nine source

s by emitting an item that aggregates the latest values of each of the source

Publisher

s each time an item is received from any of the source

Publisher

s, where this aggregation is defined by a specified function.

static <T,R> @NonNull Flowable<R>

combineLatestArray(@NonNull Publisher<? extends T>[] sources, @NonNull Function<? super Object[],? extends R> combiner)

Combines a collection of source

s by emitting an item that aggregates the latest values of each of the source

Publisher

s each time an item is received from any of the source

Publisher

s, where this aggregation is defined by a specified function.

static <T,R> @NonNull Flowable<R>

combineLatestArray(@NonNull Publisher<? extends T>[] sources, @NonNull Function<? super Object[],? extends R> combiner, int bufferSize)

Combines a collection of source

s by emitting an item that aggregates the latest values of each of the source

Publisher

s each time an item is received from any of the source

Publisher

s, where this aggregation is defined by a specified function.

static <T,R> @NonNull Flowable<R>

combineLatestArrayDelayError(@NonNull Publisher<? extends T>[] sources, @NonNull Function<? super Object[],? extends R> combiner)

Combines a collection of source

s by emitting an item that aggregates the latest values of each of the source

Publisher

s each time an item is received from any of the source

Publisher

s, where this aggregation is defined by a specified function.

static <T,R> @NonNull Flowable<R>

combineLatestArrayDelayError(@NonNull Publisher<? extends T>[] sources, @NonNull Function<? super Object[],? extends R> combiner, int bufferSize)

Combines a collection of source

s by emitting an item that aggregates the latest values of each of the source

Publisher

s each time an item is received from any of the source

Publisher

s, where this aggregation is defined by a specified function and delays any error from the sources until all source

Publisher

s terminate.

static <T,R> @NonNull Flowable<R>

combineLatestDelayError(@NonNull Iterable<? extends Publisher<? extends T>> sources, @NonNull Function<? super Object[],? extends R> combiner)

Combines a collection of source

s by emitting an item that aggregates the latest values of each of the source

Publisher

s each time an item is received from any of the source

Publisher

s, where this aggregation is defined by a specified function and delays any error from the sources until all source

Publisher

s terminate.

static <T,R> @NonNull Flowable<R>

combineLatestDelayError(@NonNull Iterable<? extends Publisher<? extends T>> sources, @NonNull Function<? super Object[],? extends R> combiner, int bufferSize)

Combines a collection of source

s by emitting an item that aggregates the latest values of each of the source

Publisher

s each time an item is received from any of the source

Publisher

s, where this aggregation is defined by a specified function and delays any error from the sources until all source

Publisher

s terminate.

<R> @NonNull Flowable<R> compose(@NonNull FlowableTransformer<? super T,? extends R> composer) static <T> @NonNull Flowable<T> concat(@NonNull Iterable<? extends Publisher<? extends T>> sources)

Concatenates elements of each

provided via an

sequence into a single sequence of elements without interleaving them.

static <T> @NonNull Flowable<T> concat(@NonNull Publisher<? extends Publisher<? extends T>> sources)

Returns a

Flowable

that emits the items emitted by each of the

s emitted by the source

Publisher

, one after the other, without interleaving them.

static <T> @NonNull Flowable<T> concat(@NonNull Publisher<? extends Publisher<? extends T>> sources, int prefetch)

Returns a

Flowable

that emits the items emitted by each of the

s emitted by the source

Publisher

, one after the other, without interleaving them.

static <T> @NonNull Flowable<T> concat(@NonNull Publisher<? extends T> source1, @NonNull Publisher<? extends T> source2)

Returns a

Flowable

that emits the items emitted by two

s, one after the other, without interleaving them.

static <T> @NonNull Flowable<T>

concat(@NonNull Publisher<? extends T> source1, @NonNull Publisher<? extends T> source2, @NonNull Publisher<? extends T> source3)

Returns a

Flowable

that emits the items emitted by three

s, one after the other, without interleaving them.

static <T> @NonNull Flowable<T>

concat(@NonNull Publisher<? extends T> source1, @NonNull Publisher<? extends T> source2, @NonNull Publisher<? extends T> source3, @NonNull Publisher<? extends T> source4)

Returns a

Flowable

that emits the items emitted by four

s, one after the other, without interleaving them.

static <T> @NonNull Flowable<T> concatArray(Publisher<? extends T>... sources)

Concatenates a variable number of

sources.

static <T> @NonNull Flowable<T> concatArrayDelayError(Publisher<? extends T>... sources)

Concatenates a variable number of

sources and delays errors from any of them till all terminate.

static <T> @NonNull Flowable<T> concatArrayEager(int maxConcurrency, int prefetch, Publisher<? extends T>... sources)

Concatenates an array of

s eagerly into a single stream of values.

static <T> @NonNull Flowable<T> concatArrayEager(Publisher<? extends T>... sources)

Concatenates an array of

s eagerly into a single stream of values.

static <T> @NonNull Flowable<T> concatArrayEagerDelayError(int maxConcurrency, int prefetch, Publisher<? extends T>... sources)

Concatenates an array of

s eagerly into a single stream of values and delaying any errors until all sources terminate.

static <T> @NonNull Flowable<T> concatArrayEagerDelayError(Publisher<? extends T>... sources)

Concatenates an array of

s eagerly into a single stream of values and delaying any errors until all sources terminate.

static <T> @NonNull Flowable<T> concatDelayError(@NonNull Iterable<? extends Publisher<? extends T>> sources)

Concatenates the

sequence of

s into a single sequence by subscribing to each

Publisher

, one after the other, one at a time and delays any errors till the all inner

Publisher

s terminate.

static <T> @NonNull Flowable<T> concatDelayError(@NonNull Publisher<? extends Publisher<? extends T>> sources)

Concatenates the

sequence of

Publisher

s into a single sequence by subscribing to each inner

Publisher

, one after the other, one at a time and delays any errors till the all inner and the outer

Publisher

s terminate.

static <T> @NonNull Flowable<T> concatDelayError(@NonNull Publisher<? extends Publisher<? extends T>> sources, int prefetch, boolean tillTheEnd)

Concatenates the

sequence of

Publisher

s into a single sequence by subscribing to each inner

Publisher

, one after the other, one at a time and delays any errors till the all inner and the outer

Publisher

s terminate.

static <T> @NonNull Flowable<T> concatEager(@NonNull Iterable<? extends Publisher<? extends T>> sources)

Concatenates a sequence of

s eagerly into a single stream of values.

static <T> @NonNull Flowable<T> concatEager(@NonNull Iterable<? extends Publisher<? extends T>> sources, int maxConcurrency, int prefetch)

Concatenates a sequence of

s eagerly into a single stream of values and runs a limited number of inner sequences at once.

static <T> @NonNull Flowable<T> concatEager(@NonNull Publisher<? extends Publisher<? extends T>> sources)

Concatenates a

sequence of

Publisher

s eagerly into a single stream of values.

static <T> @NonNull Flowable<T> concatEager(@NonNull Publisher<? extends Publisher<? extends T>> sources, int maxConcurrency, int prefetch)

Concatenates a

sequence of

Publisher

s eagerly into a single stream of values and runs a limited number of inner sequences at once.

static <T> @NonNull Flowable<T> concatEagerDelayError(@NonNull Iterable<? extends Publisher<? extends T>> sources)

Concatenates a sequence of

s eagerly into a single stream of values, delaying errors until all the inner sequences terminate.

static <T> @NonNull Flowable<T> concatEagerDelayError(@NonNull Iterable<? extends Publisher<? extends T>> sources, int maxConcurrency, int prefetch)

Concatenates a sequence of

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.

static <T> @NonNull Flowable<T> concatEagerDelayError(@NonNull Publisher<? extends Publisher<? extends T>> sources)

Concatenates a

sequence of

Publisher

s eagerly into a single stream of values, delaying errors until all the inner and the outer sequences terminate.

static <T> @NonNull Flowable<T> concatEagerDelayError(@NonNull Publisher<? extends Publisher<? extends T>> sources, int maxConcurrency, int prefetch)

Concatenates a

sequence of

Publisher

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.

<R> @NonNull Flowable<R> concatMap(@NonNull Function<? super T,? extends Publisher<? extends R>> mapper)

Returns a new

Flowable

that emits items resulting from applying a function that you supply to each item emitted by the current

Flowable

, where that function returns a

, and then emitting the items that result from concatenating those returned

Publisher

<R> @NonNull Flowable<R> concatMap(@NonNull Function<? super T,? extends Publisher<? extends R>> mapper, int prefetch)

Returns a new

Flowable

that emits items resulting from applying a function that you supply to each item emitted by the current

Flowable

, where that function returns a

, and then emitting the items that result from concatenating those returned

Publisher

<R> @NonNull Flowable<R>

concatMap(@NonNull Function<? super T,? extends Publisher<? extends R>> mapper, int prefetch, @NonNull Scheduler scheduler)

Returns a new

Flowable

that emits items resulting from applying a function (on a designated scheduler) that you supply to each item emitted by the current

Flowable

, where that function returns a

, and then emitting the items that result from concatenating those returned

Publisher

@NonNull Completable concatMapCompletable(@NonNull Function<? super T,? extends CompletableSource> mapper)

Maps the upstream items into

s and subscribes to them one after the other completes.

@NonNull Completable concatMapCompletable(@NonNull Function<? super T,? extends CompletableSource> mapper, int prefetch)

Maps the upstream items into

s and subscribes to them one after the other completes.

@NonNull Completable concatMapCompletableDelayError(@NonNull Function<? super T,? extends CompletableSource> mapper)

Maps the upstream items into

s and subscribes to them one after the other terminates, delaying all errors till both this

Flowable

and all inner

CompletableSource

s terminate.

@NonNull Completable concatMapCompletableDelayError(@NonNull Function<? super T,? extends CompletableSource> mapper, boolean tillTheEnd)

Maps the upstream items into

s and subscribes to them one after the other terminates, optionally delaying all errors till both this

Flowable

and all inner

CompletableSource

s terminate.

@NonNull Completable

concatMapCompletableDelayError(@NonNull Function<? super T,? extends CompletableSource> mapper, boolean tillTheEnd, int prefetch)

Maps the upstream items into

s and subscribes to them one after the other terminates, optionally delaying all errors till both this

Flowable

and all inner

CompletableSource

s terminate.

<R> @NonNull Flowable<R> concatMapDelayError(@NonNull Function<? super T,? extends Publisher<? extends R>> mapper)

Maps each of the items into a

, subscribes to them one after the other, one at a time and emits their values in order while delaying any error from either this or any of the inner

Publisher

s till all of them terminate.

<R> @NonNull Flowable<R>

concatMapDelayError(@NonNull Function<? super T,? extends Publisher<? extends R>> mapper, boolean tillTheEnd, int prefetch)

Maps each of the items into a

, subscribes to them one after the other, one at a time and emits their values in order while delaying any error from either this or any of the inner

Publisher

s till all of them terminate.

<R> @NonNull Flowable<R>

concatMapDelayError(@NonNull Function<? super T,? extends Publisher<? extends R>> mapper, boolean tillTheEnd, int prefetch, @NonNull Scheduler scheduler)

Maps each of the upstream items into a

, subscribes to them one after the other, one at a time and emits their values in order while executing the mapper function on the designated scheduler, delaying any error from either this or any of the inner

Publisher

s till all of them terminate.

<R> @NonNull Flowable<R> concatMapEager(@NonNull Function<? super T,? extends Publisher<? extends R>> mapper)

Maps a sequence of values into

s and concatenates these

Publisher

s eagerly into a single

Publisher

<R> @NonNull Flowable<R>

concatMapEager(@NonNull Function<? super T,? extends Publisher<? extends R>> mapper, int maxConcurrency, int prefetch)

Maps a sequence of values into

s and concatenates these

Publisher

s eagerly into a single

Publisher

<R> @NonNull Flowable<R> concatMapEagerDelayError(@NonNull Function<? super T,? extends Publisher<? extends R>> mapper, boolean tillTheEnd)

Maps a sequence of values into

s and concatenates these

Publisher

s eagerly into a single

Publisher

<R> @NonNull Flowable<R>

concatMapEagerDelayError(@NonNull Function<? super T,? extends Publisher<? extends R>> mapper, boolean tillTheEnd, int maxConcurrency, int prefetch)

Maps a sequence of values into

s and concatenates these

Publisher

s eagerly into a single

Flowable

sequence.

 @NonNull Flowable concatMapIterable(@NonNull Function<? super T,? extends Iterable<? extends U>> mapper)

Returns a

Flowable

that concatenate each item emitted by the current

Flowable

with the values in an

corresponding to that item that is generated by a selector.

 @NonNull Flowable concatMapIterable(@NonNull Function<? super T,? extends Iterable<? extends U>> mapper, int prefetch)

Returns a

Flowable

that concatenate each item emitted by the current

Flowable

with the values in an

corresponding to that item that is generated by a selector.

<R> @NonNull Flowable<R> concatMapMaybe(@NonNull Function<? super T,? extends MaybeSource<? extends R>> mapper)

Maps the upstream items into

s and subscribes to them one after the other succeeds or completes, emits their success value if available or terminates immediately if either this

Flowable

or the current inner

MaybeSource

fail.

<R> @NonNull Flowable<R> concatMapMaybe(@NonNull Function<? super T,? extends MaybeSource<? extends R>> mapper, int prefetch)

Maps the upstream items into

s and subscribes to them one after the other succeeds or completes, emits their success value if available or terminates immediately if either this

Flowable

or the current inner

MaybeSource

fail.

<R> @NonNull Flowable<R> concatMapMaybeDelayError(@NonNull Function<? super T,? extends MaybeSource<? extends R>> mapper)

Maps the upstream items into

s and subscribes to them one after the other terminates, emits their success value if available and delaying all errors till both this

Flowable

and all inner

MaybeSource

s terminate.

<R> @NonNull Flowable<R> concatMapMaybeDelayError(@NonNull Function<? super T,? extends MaybeSource<? extends R>> mapper, boolean tillTheEnd)

Maps the upstream items into

s and subscribes to them one after the other terminates, emits their success value if available and optionally delaying all errors till both this

Flowable

and all inner

MaybeSource

s terminate.

<R> @NonNull Flowable<R>

concatMapMaybeDelayError(@NonNull Function<? super T,? extends MaybeSource<? extends R>> mapper, boolean tillTheEnd, int prefetch)

Maps the upstream items into

s and subscribes to them one after the other terminates, emits their success value if available and optionally delaying all errors till both this

Flowable

and all inner

MaybeSource

s terminate.

<R> @NonNull Flowable<R> concatMapSingle(@NonNull Function<? super T,? extends SingleSource<? extends R>> mapper)

Maps the upstream items into

s and subscribes to them one after the other succeeds, emits their success values or terminates immediately if either this

Flowable

or the current inner

SingleSource

fail.

<R> @NonNull Flowable<R> concatMapSingle(@NonNull Function<? super T,? extends SingleSource<? extends R>> mapper, int prefetch)

Maps the upstream items into

s and subscribes to them one after the other succeeds, emits their success values or terminates immediately if either this

Flowable

or the current inner

SingleSource

fail.

<R> @NonNull Flowable<R> concatMapSingleDelayError(@NonNull Function<? super T,? extends SingleSource<? extends R>> mapper)

Maps the upstream items into

s and subscribes to them one after the other succeeds or fails, emits their success values and delays all errors till both this

Flowable

and all inner

SingleSource

s terminate.

<R> @NonNull Flowable<R> concatMapSingleDelayError(@NonNull Function<? super T,? extends SingleSource<? extends R>> mapper, boolean tillTheEnd)

Maps the upstream items into

s and subscribes to them one after the other succeeds or fails, emits their success values and optionally delays all errors till both this

Flowable

and all inner

SingleSource

s terminate.

<R> @NonNull Flowable<R>

concatMapSingleDelayError(@NonNull Function<? super T,? extends SingleSource<? extends R>> mapper, boolean tillTheEnd, int prefetch)

Maps the upstream items into

s and subscribes to them one after the other succeeds or fails, emits their success values and optionally delays errors till both this

Flowable

and all inner

SingleSource

s terminate.

<R> @NonNull Flowable<R> concatMapStream(@NonNull Function<? super T,? extends Stream<? extends R>> mapper)

Maps each upstream item into a

Stream

and emits the

Stream

's items to the downstream in a sequential fashion.

<R> @NonNull Flowable<R> concatMapStream(@NonNull Function<? super T,? extends Stream<? extends R>> mapper, int prefetch)

Maps each upstream item into a

Stream

and emits the

Stream

's items to the downstream in a sequential fashion.

@NonNull Flowable<T> concatWith(@NonNull CompletableSource other)

Returns a

Flowable

that emits items from this

Flowable

and when it completes normally, the other

is subscribed to and the returned

Flowable

emits its terminal events.

@NonNull Flowable<T> concatWith(@NonNull MaybeSource<? extends T> other)

Returns a

Flowable

that emits the items from this

Flowable

followed by the success item or terminal events of the other

@NonNull Flowable<T> concatWith(@NonNull Publisher<? extends T> other)

Returns a Flowable that emits the items emitted from the current Flowable, then the next, one after the other, without interleaving them.

@NonNull Flowable<T> concatWith(@NonNull SingleSource<? extends T> other)

Returns a

Flowable

that emits the items from this

Flowable

followed by the success item or error event of the other

@NonNull Single<Boolean> contains(@NonNull Object item)

Returns a

Single

that emits a

that indicates whether the current

Flowable

emitted a specified item.

@NonNull Single<Long> count()

Returns a

Single

that counts the total number of items emitted by the current

Flowable

and emits this count as a 64-bit

Long

static <T> @NonNull Flowable<T> create(@NonNull FlowableOnSubscribe<T> source, @NonNull BackpressureStrategy mode)

Provides an API (via a cold Flowable) that bridges the reactive world with the callback-style, generally non-backpressured world.

 @NonNull Flowable<T> debounce(@NonNull Function<? super T,? extends Publisher> debounceIndicator)

Returns a Flowable that mirrors the current Flowable, except that it drops items emitted by the current Flowable that are followed by another item within a computed debounce duration.

@NonNull Flowable<T> debounce(long timeout, @NonNull TimeUnit unit)

Returns a Flowable that mirrors the current Flowable, except that it drops items emitted by the current Flowable that are followed by newer items before a timeout value expires.

@NonNull Flowable<T> debounce(long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)

Returns a

Flowable

that mirrors the current

Flowable

, except that it drops items emitted by the current

Flowable

that are followed by newer items before a timeout value expires on a specified

@NonNull Flowable<T> debounce(long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, @NonNull Consumer<? super T> onDropped)

Returns a

Flowable

that mirrors the current

Flowable

, except that it drops items emitted by the current

Flowable

that are followed by newer items before a timeout value expires on a specified

@NonNull Flowable<T> defaultIfEmpty(T defaultItem)

Returns a Flowable that emits the items emitted by the current Flowable or a specified default item if the current Flowable is empty.

static <T> @NonNull Flowable<T> defer(@NonNull Supplier<? extends Publisher<? extends T>> supplier)

Returns a

Flowable

that calls a

factory to create a

Publisher

for each new

that subscribes.

 @NonNull Flowable<T> delay(@NonNull Function<? super T,? extends Publisher> itemDelayIndicator)

Returns a

Flowable

that delays the emissions of the current

Flowable

via another

on a per-item basis.

@NonNull Flowable<T> delay(long time, @NonNull TimeUnit unit)

Returns a Flowable that emits the items emitted by the current Flowable shifted forward in time by a specified delay.

@NonNull Flowable<T> delay(long time, @NonNull TimeUnit unit, boolean delayError)

Returns a Flowable that emits the items emitted by the current Flowable shifted forward in time by a specified delay.

@NonNull Flowable<T> delay(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)

Returns a Flowable that emits the items emitted by the current Flowable shifted forward in time by a specified delay.

@NonNull Flowable<T> delay(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean delayError)

Returns a Flowable that emits the items emitted by the current Flowable shifted forward in time by a specified delay.

<U,V> @NonNull Flowable<T>

delay(@NonNull Publisher<U> subscriptionIndicator, @NonNull Function<? super T,? extends Publisher<V>> itemDelayIndicator)

Returns a

Flowable

that delays the subscription to and emissions from the current

Flowable

via another

on a per-item basis.

@NonNull Flowable<T> delaySubscription(long time, @NonNull TimeUnit unit)

Returns a Flowable that delays the subscription to the current Flowable by a given amount of time.

@NonNull Flowable<T> delaySubscription(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)

Returns a

Flowable

that delays the subscription to the current

Flowable

by a given amount of time, both waiting and subscribing on a given

 @NonNull Flowable<T> delaySubscription(@NonNull Publisher subscriptionIndicator)

Returns a

Flowable

that delays the subscription to this

until the other

Publisher

emits an element or completes normally.

<R> @NonNull Flowable<R> dematerialize(@NonNull Function<? super T,Notification<R>> selector)

Returns a

Flowable

that reverses the effect of

materialize

by transforming the

Notification

objects extracted from the source items via a selector function into their respective

signal types.

@NonNull Flowable<T> distinct()

Returns a

Flowable

that emits all items emitted by the current

Flowable

that are distinct based on

comparison.

<K> @NonNull Flowable<T> distinct(@NonNull Function<? super T,K> keySelector)

Returns a

Flowable

that emits all items emitted by the current

Flowable

that are distinct according to a key selector function and based on

comparison of the objects returned by the key selector function.

<K> @NonNull Flowable<T>

distinct(@NonNull Function<? super T,K> keySelector, @NonNull Supplier<? extends Collection<? super K>> collectionSupplier)

Returns a

Flowable

that emits all items emitted by the current

Flowable

that are distinct according to a key selector function and based on

comparison of the objects returned by the key selector function.

@NonNull Flowable<T> distinctUntilChanged()

Returns a

Flowable

that emits all items emitted by the current

Flowable

that are distinct from their immediate predecessors based on

comparison.

@NonNull Flowable<T> distinctUntilChanged(@NonNull BiPredicate<? super T,? super T> comparer)

Returns a Flowable that emits all items emitted by the current Flowable that are distinct from their immediate predecessors when compared with each other via the provided comparator function.

<K> @NonNull Flowable<T> distinctUntilChanged(@NonNull Function<? super T,K> keySelector)

Returns a

Flowable

that emits all items emitted by the current

Flowable

that are distinct from their immediate predecessors, according to a key selector function and based on

comparison of those objects returned by the key selector function.

@NonNull Flowable<T> doAfterNext(@NonNull Consumer<? super T> onAfterNext)

Calls the specified consumer with the current item after this item has been emitted to the downstream.

@NonNull Flowable<T> doAfterTerminate(@NonNull Action onAfterTerminate) @NonNull Flowable<T> doFinally(@NonNull Action onFinally)

Calls the specified action after this Flowable signals onError or onComplete or gets canceled by the downstream.

@NonNull Flowable<T> doOnCancel(@NonNull Action onCancel)

Calls the cancel

Action

if the downstream cancels the sequence.

@NonNull Flowable<T> doOnComplete(@NonNull Action onComplete)

Invokes an

Action

just before the current

Flowable

calls

onComplete

@NonNull Flowable<T> doOnEach(@NonNull Consumer<? super Notification<T>> onNotification)

Invokes a

with a

Notification

instances matching the signals emitted by the current

Flowable

before they are forwarded to the downstream.

@NonNull Flowable<T> doOnEach(@NonNull Subscriber<? super T> subscriber)

Calls the appropriate methods of the given

when the current

Flowable

signals events before forwarding it to the downstream.

@NonNull Flowable<T> doOnError(@NonNull Consumer<? super Throwable> onError)

Calls the given

with the error

Throwable

if the current

Flowable

failed before forwarding it to the downstream.

@NonNull Flowable<T>

doOnLifecycle(@NonNull Consumer<? super Subscription> onSubscribe, @NonNull LongConsumer onRequest, @NonNull Action onCancel)

Calls the appropriate

onXXX

method (shared between all

s) for the lifecycle events of the sequence (subscription, cancellation, requesting).

@NonNull Flowable<T> doOnNext(@NonNull Consumer<? super T> onNext)

Calls the given

with the value emitted by the current

Flowable

before forwarding it to the downstream.

@NonNull Flowable<T> doOnRequest(@NonNull LongConsumer onRequest)

Calls the given

LongConsumer

with the request amount from the downstream before forwarding it to the current

Flowable

@NonNull Flowable<T> doOnSubscribe(@NonNull Consumer<? super Subscription> onSubscribe)

Calls the given

with the

Subscription

provided by the current

Flowable

upon subscription from the downstream before forwarding it to the subscriber's

onSubscribe

method.

@NonNull Flowable<T> doOnTerminate(@NonNull Action onTerminate)

Calls the given

Action

when the current

Flowable

completes normally or with an error before those signals are forwarded to the downstream.

@NonNull Maybe<T> elementAt(long index)

Returns a

Maybe

that emits the single item at a specified index in a sequence of emissions from this

Flowable

or completes if this

Flowable

sequence has fewer elements than index.

@NonNull Single<T> elementAt(long index, T defaultItem)

Returns a

Single

that emits the item found at a specified index in a sequence of emissions from this

Flowable

, or a default item if that index is out of range.

@NonNull Single<T> elementAtOrError(long index)

Returns a

Single

that emits the item found at a specified index in a sequence of emissions from this

Flowable

or signals a

if this

Flowable

has fewer elements than index.

static <T> @NonNull Flowable<T> empty()

Returns a

Flowable

that emits no items to the

and immediately invokes its

onComplete

method.

static <T> @NonNull Flowable<T> error(@NonNull Supplier<? extends Throwable> supplier)

Returns a

Flowable

that invokes a

onError

method when the

Subscriber

subscribes to it.

static <T> @NonNull Flowable<T> error(@NonNull Throwable throwable)

Returns a

Flowable

that invokes a

onError

method when the

Subscriber

subscribes to it.

@NonNull Flowable<T> filter(@NonNull Predicate<? super T> predicate)

Filters items emitted by the current Flowable by only emitting those that satisfy a specified predicate.

@NonNull Single<T> first(T defaultItem)

Returns a

Single

that emits only the very first item emitted by this

Flowable

, or a default item if this

Flowable

completes without emitting anything.

@NonNull Maybe<T> firstElement()

Returns a

Maybe

that emits only the very first item emitted by this

Flowable

or completes if this

Flowable

is empty.

@NonNull Single<T> firstOrError()

Returns a

Single

that emits only the very first item emitted by this

Flowable

or signals a

if this

Flowable

is empty.

@NonNull CompletionStage<T> firstOrErrorStage() @NonNull CompletionStage<T> firstStage(T defaultItem)

Signals the first upstream item (or the default item if the upstream is empty) via a

CompletionStage

<R> @NonNull Flowable<R> flatMap(@NonNull Function<? super T,? extends Publisher<? extends R>> mapper)

Returns a

Flowable

that emits items based on applying a function that you supply to each item emitted by the current

Flowable

, where that function returns a

, and then merging those resulting

Publisher

s and emitting the results of this merger.

<R> @NonNull Flowable<R> flatMap(@NonNull Function<? super T,? extends Publisher<? extends R>> mapper, boolean delayErrors)

Returns a

Flowable

that emits items based on applying a function that you supply to each item emitted by the current

Flowable

, where that function returns a

, and then merging those resulting

Publisher

s and emitting the results of this merger.

<R> @NonNull Flowable<R>

flatMap(@NonNull Function<? super T,? extends Publisher<? extends R>> mapper, boolean delayErrors, int maxConcurrency)

Returns a

Flowable

that emits items based on applying a function that you supply to each item emitted by the current

Flowable

, where that function returns a

, and then merging those resulting

Publisher

s and emitting the results of this merger, while limiting the maximum number of concurrent subscriptions to these

Publisher

<R> @NonNull Flowable<R>

flatMap(@NonNull Function<? super T,? extends Publisher<? extends R>> mapper, boolean delayErrors, int maxConcurrency, int bufferSize)

Returns a

Flowable

that emits items based on applying a function that you supply to each item emitted by the current

Flowable

, where that function returns a

, and then merging those resulting

Publisher

s and emitting the results of this merger, while limiting the maximum number of concurrent subscriptions to these

Publisher

<R> @NonNull Flowable<R>

flatMap(@NonNull Function<? super T,? extends Publisher<? extends R>> onNextMapper, @NonNull Function<? super Throwable,? extends Publisher<? extends R>> onErrorMapper, @NonNull Supplier<? extends Publisher<? extends R>> onCompleteSupplier)

Returns a

Flowable

that applies a function to each item emitted or notification raised by the current

Flowable

and then flattens the

s returned from these functions and emits the resulting items.

<R> @NonNull Flowable<R>

flatMap(@NonNull Function<? super T,? extends Publisher<? extends R>> onNextMapper, @NonNull Function<Throwable,? extends Publisher<? extends R>> onErrorMapper, @NonNull Supplier<? extends Publisher<? extends R>> onCompleteSupplier, int maxConcurrency)

Returns a

Flowable

that applies a function to each item emitted or notification raised by the current

Flowable

and then flattens the

s returned from these functions and emits the resulting items, while limiting the maximum number of concurrent subscriptions to these

Publisher

<R> @NonNull Flowable<R> flatMap(@NonNull Function<? super T,? extends Publisher<? extends R>> mapper, int maxConcurrency)

Returns a

Flowable

that emits items based on applying a function that you supply to each item emitted by the current

Flowable

, where that function returns a

, and then merging those resulting

Publisher

s and emitting the results of this merger, while limiting the maximum number of concurrent subscriptions to these

Publisher

<U,R> @NonNull Flowable<R>

flatMap(@NonNull Function<? super T,? extends Publisher<? extends U>> mapper, @NonNull BiFunction<? super T,? super U,? extends R> combiner)

Returns a

Flowable

that emits the results of a specified function to the pair of values emitted by the current

Flowable

and a specified collection

<U,R> @NonNull Flowable<R>

flatMap(@NonNull Function<? super T,? extends Publisher<? extends U>> mapper, @NonNull BiFunction<? super T,? super U,? extends R> combiner, boolean delayErrors)

Returns a

Flowable

that emits the results of a specified function to the pair of values emitted by the current

Flowable

and a specified inner

<U,R> @NonNull Flowable<R>

flatMap(@NonNull Function<? super T,? extends Publisher<? extends U>> mapper, @NonNull BiFunction<? super T,? super U,? extends R> combiner, boolean delayErrors, int maxConcurrency)

Returns a

Flowable

that emits the results of a specified function to the pair of values emitted by the current

Flowable

and a specified collection

, while limiting the maximum number of concurrent subscriptions to these

Publisher

<U,R> @NonNull Flowable<R>

flatMap(@NonNull Function<? super T,? extends Publisher<? extends U>> mapper, @NonNull BiFunction<? super T,? super U,? extends R> combiner, boolean delayErrors, int maxConcurrency, int bufferSize)

Returns a

Flowable

that emits the results of a specified function to the pair of values emitted by the current

Flowable

and a specified collection

, while limiting the maximum number of concurrent subscriptions to these

Publisher

<U,R> @NonNull Flowable<R>

flatMap(@NonNull Function<? super T,? extends Publisher<? extends U>> mapper, @NonNull BiFunction<? super T,? super U,? extends R> combiner, int maxConcurrency)

Returns a

Flowable

that emits the results of a specified function to the pair of values emitted by the current

Flowable

and a specified collection

, while limiting the maximum number of concurrent subscriptions to these

Publisher

@NonNull Completable flatMapCompletable(@NonNull Function<? super T,? extends CompletableSource> mapper)

Maps each element of the upstream

Flowable

into

s, subscribes to them and waits until the upstream and all

CompletableSource

s complete.

@NonNull Completable

flatMapCompletable(@NonNull Function<? super T,? extends CompletableSource> mapper, boolean delayErrors, int maxConcurrency)

Maps each element of the upstream

Flowable

into

s, subscribes to them and waits until the upstream and all

CompletableSource

s complete, optionally delaying all errors.

 @NonNull Flowable flatMapIterable(@NonNull Function<? super T,? extends Iterable<? extends U>> mapper)

Merges

s generated by a mapper

for each individual item emitted by the current

Flowable

into a single

Flowable

sequence.

<U,V> @NonNull Flowable<V>

flatMapIterable(@NonNull Function<? super T,? extends Iterable<? extends U>> mapper, @NonNull BiFunction<? super T,? super U,? extends V> combiner)

Merges

s generated by a mapper

for each individual item emitted by the current

Flowable

into a single

Flowable

sequence where the resulting items will be the combination of the original item and each inner item of the respective

Iterable

as returned by the

resultSelector BiFunction

<U,V> @NonNull Flowable<V>

flatMapIterable(@NonNull Function<? super T,? extends Iterable<? extends U>> mapper, @NonNull BiFunction<? super T,? super U,? extends V> combiner, int prefetch)

Merges

s generated by a mapper

for each individual item emitted by the current

Flowable

into a single

Flowable

sequence where the resulting items will be the combination of the original item and each inner item of the respective

Iterable

as returned by the

resultSelector BiFunction

 @NonNull Flowable flatMapIterable(@NonNull Function<? super T,? extends Iterable<? extends U>> mapper, int bufferSize)

Merges

s generated by a mapper

for each individual item emitted by the current

Flowable

into a single

Flowable

sequence.

<R> @NonNull Flowable<R> flatMapMaybe(@NonNull Function<? super T,? extends MaybeSource<? extends R>> mapper)

Maps each element of the upstream

Flowable

into

s, subscribes to all of them and merges their

onSuccess

values, in no particular order, into a single

Flowable

sequence.

<R> @NonNull Flowable<R>

flatMapMaybe(@NonNull Function<? super T,? extends MaybeSource<? extends R>> mapper, boolean delayErrors, int maxConcurrency)

Maps each element of the upstream

Flowable

into

s, subscribes to at most

maxConcurrency MaybeSource

s at a time and merges their

onSuccess

values, in no particular order, into a single

Flowable

sequence, optionally delaying all errors.

<R> @NonNull Flowable<R> flatMapSingle(@NonNull Function<? super T,? extends SingleSource<? extends R>> mapper)

Maps each element of the upstream

Flowable

into

s, subscribes to all of them and merges their

onSuccess

values, in no particular order, into a single

Flowable

sequence.

<R> @NonNull Flowable<R>

flatMapSingle(@NonNull Function<? super T,? extends SingleSource<? extends R>> mapper, boolean delayErrors, int maxConcurrency)

Maps each element of the upstream

Flowable

into

s, subscribes to at most

maxConcurrency SingleSource

s at a time and merges their

onSuccess

values, in no particular order, into a single

Flowable

sequence, optionally delaying all errors.

<R> @NonNull Flowable<R> flatMapStream(@NonNull Function<? super T,? extends Stream<? extends R>> mapper)

Maps each upstream item into a

Stream

and emits the

Stream

's items to the downstream in a sequential fashion.

<R> @NonNull Flowable<R> flatMapStream(@NonNull Function<? super T,? extends Stream<? extends R>> mapper, int prefetch)

Maps each upstream item into a

Stream

and emits the

Stream

's items to the downstream in a sequential fashion.

@NonNull Disposable forEach(@NonNull Consumer<? super T> onNext)

Subscribes to the current Flowable and receives notifications for each element.

@NonNull Disposable forEachWhile(@NonNull Predicate<? super T> onNext)

Subscribes to the current Flowable and receives notifications for each element until the onNext Predicate returns false.

@NonNull Disposable forEachWhile(@NonNull Predicate<? super T> onNext, @NonNull Consumer<? super Throwable> onError)

Subscribes to the current Flowable and receives notifications for each element and error events until the onNext Predicate returns false.

@NonNull Disposable

forEachWhile(@NonNull Predicate<? super T> onNext, @NonNull Consumer<? super Throwable> onError, @NonNull Action onComplete)

Subscribes to the current Flowable and receives notifications for each element and the terminal events until the onNext Predicate returns false.

static <T> @NonNull Flowable<T> fromAction(@NonNull Action action)

Returns a

Flowable

instance that runs the given

Action

for each

and emits either its exception or simply completes.

static <T> @NonNull Flowable<T> fromArray(T... items)

Converts an array into a

that emits the items in the array.

static <T> @NonNull Flowable<T> fromCallable(@NonNull Callable<? extends T> callable)

Returns a

Flowable

that, when a

subscribes to it, invokes a function you specify and then emits the value returned from that function.

static <T> @NonNull Flowable<T> fromCompletable(@NonNull CompletableSource completableSource) static <T> @NonNull Flowable<T> fromCompletionStage(@NonNull CompletionStage<T> stage)

Signals the completion value or error of the given (hot)

CompletionStage

-based asynchronous calculation.

static <T> @NonNull Flowable<T> fromFuture(@NonNull Future<? extends T> future) static <T> @NonNull Flowable<T> fromFuture(@NonNull Future<? extends T> future, long timeout, @NonNull TimeUnit unit) static <T> @NonNull Flowable<T> fromIterable(@NonNull Iterable<? extends T> source) static <T> @NonNull Flowable<T> fromMaybe(@NonNull MaybeSource<T> maybe)

Returns a

Flowable

instance that when subscribed to, subscribes to the

instance and emits

onSuccess

as a single item or forwards any

onComplete

onError

signal.

static <T> @NonNull Flowable<T> fromObservable(@NonNull ObservableSource<T> source, @NonNull BackpressureStrategy strategy)

Converts the given

ObservableSource

into a

Flowable

by applying the specified backpressure strategy.

static <T> @NonNull Flowable<T> fromOptional(@NonNull Optional<T> optional)

Converts the existing value of the provided optional into a

just(Object)

or an empty optional into an

empty() Flowable

instance.

static <T> @NonNull Flowable<T> fromPublisher(@NonNull Publisher<? extends T> publisher)

Converts an arbitrary

Reactive Streams Publisher

into a

Flowable

if not already a

Flowable

static <T> @NonNull Flowable<T> fromRunnable(@NonNull Runnable run)

Returns a

Flowable

instance that runs the given

Runnable

for each

and emits either its unchecked exception or simply completes.

static <T> @NonNull Flowable<T> fromSingle(@NonNull SingleSource<T> source)

Returns a

Flowable

instance that when subscribed to, subscribes to the

instance and emits

onSuccess

as a single item or forwards the

onError

signal.

static <T> @NonNull Flowable<T> fromStream(@NonNull Stream<T> stream)

Converts a

Stream

into a finite

Flowable

and emits its items in the sequence.

static <T> @NonNull Flowable<T> fromSupplier(@NonNull Supplier<? extends T> supplier)

Returns a

Flowable

that, when a

subscribes to it, invokes a supplier function you specify and then emits the value returned from that function.

static <T> @NonNull Flowable<T> generate(@NonNull Consumer<Emitter<T>> generator)

Returns a cold, synchronous, stateless and backpressure-aware generator of values.

static <T,S> @NonNull Flowable<T> generate(@NonNull Supplier<S> initialState, @NonNull BiConsumer<S,Emitter<T>> generator)

Returns a cold, synchronous, stateful and backpressure-aware generator of values.

static <T,S> @NonNull Flowable<T>

generate(@NonNull Supplier<S> initialState, @NonNull BiConsumer<S,Emitter<T>> generator, @NonNull Consumer<? super S> disposeState)

Returns a cold, synchronous, stateful and backpressure-aware generator of values.

static <T,S> @NonNull Flowable<T> generate(@NonNull Supplier<S> initialState, @NonNull BiFunction<S,Emitter<T>,S> generator)

Returns a cold, synchronous, stateful and backpressure-aware generator of values.

static <T,S> @NonNull Flowable<T>

generate(@NonNull Supplier<S> initialState, @NonNull BiFunction<S,Emitter<T>,S> generator, @NonNull Consumer<? super S> disposeState)

Returns a cold, synchronous, stateful and backpressure-aware generator of values.

<K> @NonNull Flowable<GroupedFlowable<K,T>> groupBy(@NonNull Function<? super T,? extends K> keySelector)

Groups the items emitted by the current

Flowable

according to a specified criterion, and emits these grouped items as

<K> @NonNull Flowable<GroupedFlowable<K,T>> groupBy(@NonNull Function<? super T,? extends K> keySelector, boolean delayError)

Groups the items emitted by the current

Flowable

according to a specified criterion, and emits these grouped items as

<K,V> @NonNull Flowable<GroupedFlowable<K,V>> groupBy(@NonNull Function<? super T,? extends K> keySelector, @NonNull Function<? super T,? extends V> valueSelector)

Groups the items emitted by the current

Flowable

according to a specified criterion, and emits these grouped items as

<K,V> @NonNull Flowable<GroupedFlowable<K,V>>

groupBy(@NonNull Function<? super T,? extends K> keySelector, @NonNull Function<? super T,? extends V> valueSelector, boolean delayError)

Groups the items emitted by the current

Flowable

according to a specified criterion, and emits these grouped items as

<K,V> @NonNull Flowable<GroupedFlowable<K,V>>

groupBy(@NonNull Function<? super T,? extends K> keySelector, @NonNull Function<? super T,? extends V> valueSelector, boolean delayError, int bufferSize)

Groups the items emitted by the current

Flowable

according to a specified criterion, and emits these grouped items as

<K,V> @NonNull Flowable<GroupedFlowable<K,V>>

groupBy(@NonNull Function<? super T,? extends K> keySelector, @NonNull Function<? super T,? extends V> valueSelector, boolean delayError, int bufferSize, @NonNull Function<? super Consumer<Object>,? extends Map<K,Object>> evictingMapFactory)

Groups the items emitted by the current

Flowable

according to a specified criterion, and emits these grouped items as

<TRight,TLeftEnd,TRightEnd,R>
@NonNull Flowable<R>

groupJoin(@NonNull Publisher<? extends TRight> other, @NonNull Function<? super T,? extends Publisher<TLeftEnd>> leftEnd, @NonNull Function<? super TRight,? extends Publisher<TRightEnd>> rightEnd, @NonNull BiFunction<? super T,? super Flowable<TRight>,? extends R> resultSelector)

Returns a

Flowable

that correlates two

s when they overlap in time and groups the results.

@NonNull Flowable<T> hide() @NonNull Completable ignoreElements()

Ignores all items emitted by the current Flowable and only calls onComplete or onError.

static @NonNull Flowable<Long> interval(long initialDelay, long period, @NonNull TimeUnit unit)

Returns a Flowable that emits a 0L after the initialDelay and ever-increasing numbers after each period of time thereafter.

static @NonNull Flowable<Long> interval(long initialDelay, long period, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)

Returns a

Flowable

that emits a

0L

after the

initialDelay

and ever-increasing numbers after each

period

of time thereafter, on a specified

static @NonNull Flowable<Long> interval(long period, @NonNull TimeUnit unit)

Returns a Flowable that emits a sequential number every specified interval of time.

static @NonNull Flowable<Long> interval(long period, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)

Returns a

Flowable

that emits a sequential number every specified interval of time, on a specified

static @NonNull Flowable<Long> intervalRange(long start, long count, long initialDelay, long period, @NonNull TimeUnit unit)

Signals a range of long values, the first after some initial delay and the rest periodically after.

static @NonNull Flowable<Long>

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.

@NonNull Single<Boolean> isEmpty()

Returns a

Single

that emits

true

if the current

Flowable

is empty, otherwise

false

<TRight,TLeftEnd,TRightEnd,R>
@NonNull Flowable<R>

join(@NonNull Publisher<? extends TRight> other, @NonNull Function<? super T,? extends Publisher<TLeftEnd>> leftEnd, @NonNull Function<? super TRight,? extends Publisher<TRightEnd>> rightEnd, @NonNull BiFunction<? super T,? super TRight,? extends R> resultSelector)

Correlates the items emitted by two

s based on overlapping durations.

static <T> @NonNull Flowable<T> just(T item)

Returns a Flowable that signals the given (constant reference) item and then completes.

static <T> @NonNull Flowable<T> just(T item1, T item2)

Converts two items into a

that emits those items.

static <T> @NonNull Flowable<T> just(T item1, T item2, T item3)

Converts three items into a

that emits those items.

static <T> @NonNull Flowable<T> just(T item1, T item2, T item3, T item4)

Converts four items into a

that emits those items.

static <T> @NonNull Flowable<T> just(T item1, T item2, T item3, T item4, T item5)

Converts five items into a

that emits those items.

static <T> @NonNull Flowable<T> just(T item1, T item2, T item3, T item4, T item5, T item6)

Converts six items into a

that emits those items.

static <T> @NonNull Flowable<T> just(T item1, T item2, T item3, T item4, T item5, T item6, T item7)

Converts seven items into a

that emits those items.

static <T> @NonNull Flowable<T> just(T item1, T item2, T item3, T item4, T item5, T item6, T item7, T item8)

Converts eight items into a

that emits those items.

static <T> @NonNull Flowable<T> just(T item1, T item2, T item3, T item4, T item5, T item6, T item7, T item8, T item9)

Converts nine items into a

that emits those items.

static <T> @NonNull Flowable<T> just(T item1, T item2, T item3, T item4, T item5, T item6, T item7, T item8, T item9, T item10)

Converts ten items into a

that emits those items.

@NonNull Single<T> last(T defaultItem)

Returns a

Single

that emits only the last item emitted by this

Flowable

, or a default item if this

Flowable

completes without emitting any items.

@NonNull Maybe<T> lastElement()

Returns a

Maybe

that emits the last item emitted by this

Flowable

or completes if this

Flowable

is empty.

@NonNull Single<T> lastOrError() @NonNull CompletionStage<T> lastOrErrorStage() @NonNull CompletionStage<T> lastStage(T defaultItem)

Signals the last upstream item (or the default item if the upstream is empty) via a

CompletionStage

<R> @NonNull Flowable<R> lift(@NonNull FlowableOperator<? extends R,? super T> lifter) This method requires advanced knowledge about building operators, please consider other standard composition methods first;

Returns a

Flowable

which, when subscribed to, invokes the

apply(Subscriber)

method of the provided

FlowableOperator

for each individual downstream

and allows the insertion of a custom operator by accessing the downstream's

Subscriber

during this subscription phase and providing a new

Subscriber

, containing the custom operator's intended business logic, that will be used in the subscription process going further upstream.

<R> @NonNull Flowable<R> map(@NonNull Function<? super T,? extends R> mapper)

Returns a Flowable that applies a specified function to each item emitted by the current Flowable and emits the results of these function applications.

<R> @NonNull Flowable<R> mapOptional(@NonNull Function<? super T,Optional<? extends R>> mapper)

Maps each upstream value into an

Optional

and emits the contained item if not empty.

@NonNull Flowable<Notification<T>> materialize()

Returns a

Flowable

that represents all of the emissions

and

notifications from the current

Flowable

into emissions marked with their original types within

Notification

objects.

static <T> @NonNull Flowable<T> merge(@NonNull Iterable<? extends Publisher<? extends T>> sources) static <T> @NonNull Flowable<T> merge(@NonNull Iterable<? extends Publisher<? extends T>> sources, int maxConcurrency)

Flattens an

s into one

Publisher

, without any transformation, while limiting the number of concurrent subscriptions to these

Publisher

static <T> @NonNull Flowable<T> merge(@NonNull Iterable<? extends Publisher<? extends T>> sources, int maxConcurrency, int bufferSize)

Flattens an

s into one

Publisher

, without any transformation, while limiting the number of concurrent subscriptions to these

Publisher

static <T> @NonNull Flowable<T> merge(@NonNull Publisher<? extends Publisher<? extends T>> sources)

Flattens a

that emits

Publisher

s into a single

Publisher

that emits the items emitted by thos

Publisher

s , without any transformation.

static <T> @NonNull Flowable<T> merge(@NonNull Publisher<? extends Publisher<? extends T>> sources, int maxConcurrency)

Flattens a

that emits

Publisher

s into a single

Publisher

that emits the items emitted by those

Publisher

s, without any transformation, while limiting the maximum number of concurrent subscriptions to these

Publisher

static <T> @NonNull Flowable<T> merge(@NonNull Publisher<? extends T> source1, @NonNull Publisher<? extends T> source2)

Flattens two

s into a single

Publisher

, without any transformation.

static <T> @NonNull Flowable<T>

merge(@NonNull Publisher<? extends T> source1, @NonNull Publisher<? extends T> source2, @NonNull Publisher<? extends T> source3)

Flattens three

s into a single

Publisher

, without any transformation.

static <T> @NonNull Flowable<T>

merge(@NonNull Publisher<? extends T> source1, @NonNull Publisher<? extends T> source2, @NonNull Publisher<? extends T> source3, @NonNull Publisher<? extends T> source4)

Flattens four

s into a single

Publisher

, without any transformation.

static <T> @NonNull Flowable<T> mergeArray(int maxConcurrency, int bufferSize, Publisher<? extends T>... sources)

Flattens an array of

s into one

Publisher

, without any transformation, while limiting the number of concurrent subscriptions to these

Publisher

static <T> @NonNull Flowable<T> mergeArray(Publisher<? extends T>... sources)

Flattens an array of

s into one

Publisher

, without any transformation.

static <T> @NonNull Flowable<T> mergeArrayDelayError(int maxConcurrency, int bufferSize, Publisher<? extends T>... sources)

Flattens an array of

s into one

Publisher

, in a way that allows a

to receive all successfully emitted items from each of the source

Publisher

s without being interrupted by an error notification from one of them, while limiting the number of concurrent subscriptions to these

Publisher

static <T> @NonNull Flowable<T> mergeArrayDelayError(Publisher<? extends T>... sources)

Flattens an array of

s into one

Flowable

, in a way that allows a

to receive all successfully emitted items from each of the source

Publisher

s without being interrupted by an error notification from one of them.

static <T> @NonNull Flowable<T> mergeDelayError(@NonNull Iterable<? extends Publisher<? extends T>> sources)

Flattens an

s into one

Publisher

, in a way that allows a

to receive all successfully emitted items from each of the source

Publisher

s without being interrupted by an error notification from one of them.

static <T> @NonNull Flowable<T> mergeDelayError(@NonNull Iterable<? extends Publisher<? extends T>> sources, int maxConcurrency)

Flattens an

s into one

Publisher

, in a way that allows a

to receive all successfully emitted items from each of the source

Publisher

s without being interrupted by an error notification from one of them, while limiting the number of concurrent subscriptions to these

Publisher

static <T> @NonNull Flowable<T> mergeDelayError(@NonNull Iterable<? extends Publisher<? extends T>> sources, int maxConcurrency, int bufferSize)

Flattens an

s into one

Publisher

, in a way that allows a

to receive all successfully emitted items from each of the source

Publisher

s without being interrupted by an error notification from one of them, while limiting the number of concurrent subscriptions to these

Publisher

static <T> @NonNull Flowable<T> mergeDelayError(@NonNull Publisher<? extends Publisher<? extends T>> sources)

Flattens a

that emits

Publisher

s into one

Publisher

, in a way that allows a

to receive all successfully emitted items from all of the source

Publisher

s without being interrupted by an error notification from one of them.

static <T> @NonNull Flowable<T> mergeDelayError(@NonNull Publisher<? extends Publisher<? extends T>> sources, int maxConcurrency)

Flattens a

that emits

Publisher

s into one

Publisher

, in a way that allows a

to receive all successfully emitted items from all of the source

Publisher

s without being interrupted by an error notification from one of them, while limiting the number of concurrent subscriptions to these

Publisher

static <T> @NonNull Flowable<T> mergeDelayError(@NonNull Publisher<? extends T> source1, @NonNull Publisher<? extends T> source2)

Flattens two

s into one

Publisher

, in a way that allows a

to receive all successfully emitted items from each of the source

Publisher

s without being interrupted by an error notification from one of them.

static <T> @NonNull Flowable<T>

mergeDelayError(@NonNull Publisher<? extends T> source1, @NonNull Publisher<? extends T> source2, @NonNull Publisher<? extends T> source3)

Flattens three

s into one

Publisher

, in a way that allows a

to receive all successfully emitted items from all of the source

Publisher

s without being interrupted by an error notification from one of them.

static <T> @NonNull Flowable<T>

mergeDelayError(@NonNull Publisher<? extends T> source1, @NonNull Publisher<? extends T> source2, @NonNull Publisher<? extends T> source3, @NonNull Publisher<? extends T> source4)

Flattens four

s into one

Publisher

, in a way that allows a

to receive all successfully emitted items from all of the source

Publisher

s without being interrupted by an error notification from one of them.

@NonNull Flowable<T> mergeWith(@NonNull CompletableSource other)

Relays the items of this

Flowable

and completes only when the other

completes as well.

@NonNull Flowable<T> mergeWith(@NonNull MaybeSource<? extends T> other)

Merges the sequence of items of this

Flowable

with the success value of the other

or waits for both to complete normally if the

MaybeSource

is empty.

@NonNull Flowable<T> mergeWith(@NonNull Publisher<? extends T> other)

Flattens this and another

into a single

Publisher

, without any transformation.

@NonNull Flowable<T> mergeWith(@NonNull SingleSource<? extends T> other)

Merges the sequence of items of this

Flowable

with the success value of the other

static <T> @NonNull Flowable<T> never()

Returns a

Flowable

that never sends any items or notifications to a

@NonNull Flowable<T> observeOn(@NonNull Scheduler scheduler)

Signals the items and terminal signals of the current

Flowable

on the specified

, asynchronously with a bounded buffer of

bufferSize()

slots.

@NonNull Flowable<T> observeOn(@NonNull Scheduler scheduler, boolean delayError)

Signals the items and terminal signals of the current

Flowable

on the specified

, asynchronously with a bounded buffer and optionally delays

onError

notifications.

@NonNull Flowable<T> observeOn(@NonNull Scheduler scheduler, boolean delayError, int bufferSize)

Signals the items and terminal signals of the current

Flowable

on the specified

MissingBackpressureException

, asynchronously with a bounded buffer of configurable size and optionally delays

onError

notifications.

 @NonNull Flowable ofType(@NonNull Class clazz)

Filters the items emitted by the current Flowable, only emitting those of the specified type.

@NonNull Flowable<T> onBackpressureBuffer()

Buffers an unlimited number of items from the current Flowable and allows it to emit as fast it can while allowing the downstream to consume the items at its own place.

@NonNull Flowable<T> onBackpressureBuffer(boolean delayError)

Buffers an unlimited number of items from the current Flowable and allows it to emit as fast it can while allowing the downstream to consume the items at its own place, optionally delaying an error until all buffered items have been consumed.

@NonNull Flowable<T> onBackpressureBuffer(int capacity)

Buffers an limited number of items from the current

Flowable

and allows it to emit as fast it can while allowing the downstream to consume the items at its own place, however, the resulting

Flowable

will signal a

via

onError

as soon as the buffer's capacity is exceeded, dropping all undelivered items, and canceling the flow.

@NonNull Flowable<T> onBackpressureBuffer(int capacity, @NonNull Action onOverflow)

Buffers an limited number of items from the current

Flowable

and allows it to emit as fast it can while allowing the downstream to consume the items at its own place, however, the resulting

Flowable

will signal a

MissingBackpressureException

via

onError

as soon as the buffer's capacity is exceeded, dropping all undelivered items, canceling the flow and calling the

onOverflow

action.

@NonNull Flowable<T> onBackpressureBuffer(int capacity, boolean delayError)

Buffers an limited number of items from the current

Flowable

and allows it to emit as fast it can while allowing the downstream to consume the items at its own place, however, the resulting

Flowable

will signal a

MissingBackpressureException

via

onError

as soon as the buffer's capacity is exceeded, dropping all undelivered items, and canceling the flow.

@NonNull Flowable<T> onBackpressureBuffer(int capacity, boolean delayError, boolean unbounded)

Buffers an optionally unlimited number of items from the current Flowable and allows it to emit as fast it can while allowing the downstream to consume the items at its own place.

@NonNull Flowable<T> onBackpressureBuffer(int capacity, boolean delayError, boolean unbounded, @NonNull Action onOverflow)

Buffers an optionally unlimited number of items from the current Flowable and allows it to emit as fast it can while allowing the downstream to consume the items at its own place.

@NonNull Flowable<T>

onBackpressureBuffer(int capacity, boolean delayError, boolean unbounded, @NonNull Action onOverflow, @NonNull Consumer<? super T> onDropped)

Buffers an optionally unlimited number of items from the current Flowable and allows it to emit as fast it can while allowing the downstream to consume the items at its own place.

@NonNull Flowable<T>

onBackpressureBuffer(long capacity, @Nullable Action onOverflow, @NonNull BackpressureOverflowStrategy overflowStrategy)

Buffers an optionally unlimited number of items from the current Flowable and allows it to emit as fast it can while allowing the downstream to consume the items at its own place.

@NonNull Flowable<T>

onBackpressureBuffer(long capacity, @Nullable Action onOverflow, @NonNull BackpressureOverflowStrategy overflowStrategy, @NonNull Consumer<? super T> onDropped)

Buffers an optionally unlimited number of items from the current Flowable and allows it to emit as fast it can while allowing the downstream to consume the items at its own place.

@NonNull Flowable<T> onBackpressureDrop()

Drops items from the current

Flowable

if the downstream is not ready to receive new items (indicated by a lack of

calls from it).

@NonNull Flowable<T> onBackpressureDrop(@NonNull Consumer<? super T> onDrop)

Drops items from the current

Flowable

if the downstream is not ready to receive new items (indicated by a lack of

calls from it) and calls the given

with such dropped items.

@NonNull Flowable<T> onBackpressureLatest()

Drops all but the latest item emitted by the current

Flowable

if the downstream is not ready to receive new items (indicated by a lack of

calls from it) and emits this latest item when the downstream becomes ready.

@NonNull Flowable<T> onBackpressureLatest(@NonNull Consumer<? super T> onDropped)

Drops all but the latest item emitted by the current

Flowable

if the downstream is not ready to receive new items (indicated by a lack of

calls from it) and emits this latest item when the downstream becomes ready.

@NonNull Flowable<T> onBackpressureReduce(@NonNull BiFunction<T,T,T> reducer)

Reduces a sequence of two not emitted values via a function into a single value if the downstream is not ready to receive new items (indicated by a lack of

calls from it) and emits this latest item when the downstream becomes ready.

<R> @NonNull Flowable<R> onBackpressureReduce(@NonNull Supplier<R> supplier, @NonNull BiFunction<R,? super T,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.

@NonNull Flowable<T> onErrorComplete()

Returns a Flowable instance that if the current Flowable emits an error, it will emit an onComplete and swallow the throwable.

@NonNull Flowable<T> onErrorComplete(@NonNull Predicate<? super Throwable> predicate)

Returns a Flowable instance that if the current Flowable emits an error and the predicate returns true, it will emit an onComplete and swallow the throwable.

@NonNull Flowable<T> onErrorResumeNext(@NonNull Function<? super Throwable,? extends Publisher<? extends T>> fallbackSupplier)

Resumes the flow with a

returned for the failure

Throwable

of the current

Flowable

by a function instead of signaling the error via

onError

@NonNull Flowable<T> onErrorResumeWith(@NonNull Publisher<? extends T> fallback)

Resumes the flow with the given

when the current

Flowable

fails instead of signaling the error via

onError

@NonNull Flowable<T> onErrorReturn(@NonNull Function<? super Throwable,? extends T> itemSupplier)

Ends the flow with a last item returned by a function for the

Throwable

error signaled by the current

Flowable

instead of signaling the error via

onError

@NonNull Flowable<T> onErrorReturnItem(T item)

Ends the flow with the given last item when the current Flowable fails instead of signaling the error via onError.

@NonNull Flowable<T> onTerminateDetach()

Nulls out references to the upstream producer and downstream

if the sequence is terminated or downstream cancels.

@NonNull ParallelFlowable<T> 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.

@NonNull ParallelFlowable<T> 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.

@NonNull ParallelFlowable<T> 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.

@NonNull ConnectableFlowable<T> publish() <R> @NonNull Flowable<R> publish(@NonNull Function<? super Flowable<T>,? extends Publisher<? extends R>> selector, int prefetch)

Returns a

Flowable

that emits the results of invoking a specified selector on items emitted by a

that shares a single subscription to the underlying sequence.

<R> @NonNull Flowable<R> publish(@NonNull Function<? super Flowable<T>,? extends Publisher<R>> selector)

Returns a

Flowable

that emits the results of invoking a specified selector on items emitted by a

that shares a single subscription to the underlying sequence.

@NonNull ConnectableFlowable<T> publish(int bufferSize) static @NonNull Flowable<Integer> range(int start, int count)

Returns a

Flowable

that emits a sequence of

Integer

s within a specified range.

static @NonNull Flowable<Long> rangeLong(long start, long count)

Returns a

Flowable

that emits a sequence of

Long

s within a specified range.

@NonNull Flowable<T> rebatchRequests(int n)

Requests n initially from the upstream and then 75% of n subsequently after 75% of n values have been emitted to the downstream.

@NonNull Maybe<T> reduce(@NonNull BiFunction<T,T,T> reducer)

Returns a

Maybe

that applies a specified accumulator function to the first item emitted by the current

Flowable

, then feeds the result of that function along with the second item emitted by the current

Flowable

into the same function, and so on until all items have been emitted by the current and finite

Flowable

, and emits the final result from the final call to your function as its sole item.

<R> @NonNull Single<R> reduce(R seed, @NonNull BiFunction<R,? super T,R> reducer)

Returns a

Single

that applies a specified accumulator function to the first item emitted by the current

Flowable

and a specified seed value, then feeds the result of that function along with the second item emitted by the current

Flowable

into the same function, and so on until all items have been emitted by the current and finite

Flowable

, emitting the final result from the final call to your function as its sole item.

<R> @NonNull Single<R> reduceWith(@NonNull Supplier<R> seedSupplier, @NonNull BiFunction<R,? super T,R> reducer)

Returns a

Single

that applies a specified accumulator function to the first item emitted by the current

Flowable

and a seed value derived from calling a specified

seedSupplier

, then feeds the result of that function along with the second item emitted by the current

Flowable

into the same function, and so on until all items have been emitted by the current and finite

Flowable

, emitting the final result from the final call to your function as its sole item.

@NonNull Flowable<T> repeat()

Returns a Flowable that repeats the sequence of items emitted by the current Flowable indefinitely.

@NonNull Flowable<T> repeat(long times)

Returns a Flowable that repeats the sequence of items emitted by the current Flowable at most count times.

@NonNull Flowable<T> repeatUntil(@NonNull BooleanSupplier stop)

Returns a Flowable that repeats the sequence of items emitted by the current Flowable until the provided stop function returns true.

@NonNull Flowable<T> repeatWhen(@NonNull Function<? super Flowable<Object>,? extends Publisher<?>> handler)

Returns a Flowable that emits the same values as the current Flowable with the exception of an onComplete.

@NonNull ConnectableFlowable<T> replay() <R> @NonNull Flowable<R> replay(@NonNull Function<? super Flowable<T>,? extends Publisher<R>> selector)

Returns a

Flowable

that emits items that are the results of invoking a specified selector on the items emitted by a

that shares a single subscription to the current

Flowable

<R> @NonNull Flowable<R> replay(@NonNull Function<? super Flowable<T>,? extends Publisher<R>> selector, int bufferSize)

Returns a

Flowable

that emits items that are the results of invoking a specified selector on items emitted by a

that shares a single subscription to the current

Flowable

, replaying

bufferSize

notifications.

<R> @NonNull Flowable<R> replay(@NonNull Function<? super Flowable<T>,? extends Publisher<R>> selector, int bufferSize, boolean eagerTruncate)

Returns a

Flowable

that emits items that are the results of invoking a specified selector on items emitted by a

that shares a single subscription to the current

Flowable

, replaying

bufferSize

notifications.

<R> @NonNull Flowable<R>

replay(@NonNull Function<? super Flowable<T>,? extends Publisher<R>> selector, int bufferSize, long time, @NonNull TimeUnit unit)

Returns a

Flowable

that emits items that are the results of invoking a specified selector on items emitted by a

that shares a single subscription to the current

Flowable

, replaying no more than

bufferSize

items that were emitted within a specified time window.

<R> @NonNull Flowable<R>

replay(@NonNull Function<? super Flowable<T>,? extends Publisher<R>> selector, int bufferSize, long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)

Returns a

Flowable

that emits items that are the results of invoking a specified selector on items emitted by a

that shares a single subscription to the current

Flowable

, replaying no more than

bufferSize

items that were emitted within a specified time window.

<R> @NonNull Flowable<R>

replay(@NonNull Function<? super Flowable<T>,? extends Publisher<R>> selector, int bufferSize, long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean eagerTruncate)

Returns a

Flowable

that emits items that are the results of invoking a specified selector on items emitted by a

that shares a single subscription to the current

Flowable

, replaying no more than

bufferSize

items that were emitted within a specified time window.

<R> @NonNull Flowable<R> replay(@NonNull Function<? super Flowable<T>,? extends Publisher<R>> selector, long time, @NonNull TimeUnit unit)

Returns a

Flowable

that emits items that are the results of invoking a specified selector on items emitted by a

that shares a single subscription to the current

Flowable

, replaying all items that were emitted within a specified time window.

<R> @NonNull Flowable<R>

replay(@NonNull Function<? super Flowable<T>,? extends Publisher<R>> selector, long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)

Returns a

Flowable

that emits items that are the results of invoking a specified selector on items emitted by a

that shares a single subscription to the current

Flowable

, replaying all items that were emitted within a specified time window.

<R> @NonNull Flowable<R>

replay(@NonNull Function<? super Flowable<T>,? extends Publisher<R>> selector, long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean eagerTruncate)

Returns a

Flowable

that emits items that are the results of invoking a specified selector on items emitted by a

that shares a single subscription to the current

Flowable

, replaying all items that were emitted within a specified time window.

@NonNull ConnectableFlowable<T> replay(int bufferSize)

Returns a

that shares a single subscription to the current

Flowable

and replays at most

bufferSize

items to late

@NonNull ConnectableFlowable<T> replay(int bufferSize, boolean eagerTruncate)

Returns a

that shares a single subscription to the current

Flowable

and replays at most

bufferSize

items to late

@NonNull ConnectableFlowable<T> replay(int bufferSize, long time, @NonNull TimeUnit unit)

Returns a

that shares a single subscription to the current

Flowable

and replays at most

bufferSize

items that were emitted during a specified time window.

@NonNull ConnectableFlowable<T> replay(int bufferSize, long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)

Returns a

that shares a single subscription to the current

Flowable

and replays a maximum of

bufferSize

items that are emitted within a specified time window to late

@NonNull ConnectableFlowable<T> replay(int bufferSize, long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean eagerTruncate)

Returns a

that shares a single subscription to the current

Flowable

and replays a maximum of

bufferSize

items that are emitted within a specified time window to late

@NonNull ConnectableFlowable<T> replay(long time, @NonNull TimeUnit unit)

Returns a

that shares a single subscription to the current

Flowable

and replays all items emitted by it within a specified time window to late

@NonNull ConnectableFlowable<T> replay(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)

Returns a

that shares a single subscription to the current

Flowable

and replays all items emitted by it within a specified time window to late

@NonNull ConnectableFlowable<T> replay(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean eagerTruncate)

Returns a

that shares a single subscription to the current

Flowable

and replays all items emitted by it within a specified time window to late

@NonNull Flowable<T> retry()

Returns a Flowable that mirrors the current Flowable, resubscribing to it if it calls onError (infinite retry count).

@NonNull Flowable<T> retry(@NonNull BiPredicate<? super Integer,? super Throwable> predicate)

Returns a Flowable that mirrors the current Flowable, resubscribing to it if it calls onError and the predicate returns true for that specific exception and retry count.

@NonNull Flowable<T> retry(long times)

Returns a Flowable that mirrors the current Flowable, resubscribing to it if it calls onError up to a specified number of retries.

@NonNull Flowable<T> retry(long times, @NonNull Predicate<? super Throwable> predicate)

Retries at most times or until the predicate returns false, whichever happens first.

@NonNull Flowable<T> retry(@NonNull Predicate<? super Throwable> predicate)

Retries the current Flowable if the predicate returns true.

@NonNull Flowable<T> retryUntil(@NonNull BooleanSupplier stop)

Retries until the given stop function returns true.

@NonNull Flowable<T> retryWhen(@NonNull Function<? super Flowable<Throwable>,? extends Publisher<?>> handler)

Returns a Flowable that emits the same values as the current Flowable with the exception of an onError.

void safeSubscribe(@NonNull Subscriber<? super T> subscriber)

Subscribes to the current

Flowable

and wraps the given

into a

SafeSubscriber

(if not already a

SafeSubscriber

) that deals with exceptions thrown by a misbehaving

Subscriber

(that doesn't follow the

Reactive Streams

specification).

@NonNull Flowable<T> sample(long period, @NonNull TimeUnit unit)

Returns a Flowable that emits the most recently emitted item (if any) emitted by the current Flowable within periodic time intervals.

@NonNull Flowable<T> sample(long period, @NonNull TimeUnit unit, boolean emitLast)

Returns a Flowable that emits the most recently emitted item (if any) emitted by the current Flowable within periodic time intervals and optionally emit the very last upstream item when the upstream completes.

@NonNull Flowable<T> sample(long period, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)

Returns a

Flowable

that emits the most recently emitted item (if any) emitted by the current

Flowable

within periodic time intervals, where the intervals are defined on a particular

@NonNull Flowable<T> sample(long period, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean emitLast)

Returns a

Flowable

that emits the most recently emitted item (if any) emitted by the current

Flowable

within periodic time intervals, where the intervals are defined on a particular

and optionally emit the very last upstream item when the upstream completes.

@NonNull Flowable<T>

sample(long period, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean emitLast, @NonNull Consumer<? super T> onDropped)

Returns a

Flowable

that emits the most recently emitted item (if any) emitted by the current

Flowable

within periodic time intervals, where the intervals are defined on a particular

and optionally emit the very last upstream item when the upstream completes.

 @NonNull Flowable<T> sample(@NonNull Publisher sampler)

Returns a

Flowable

that, when the specified

sampler Publisher

emits an item or completes, emits the most recently emitted item (if any) emitted by the current

Flowable

since the previous emission from the

sampler Publisher

 @NonNull Flowable<T> sample(@NonNull Publisher sampler, boolean emitLast)

Returns a

Flowable

that, when the specified

sampler Publisher

emits an item or completes, emits the most recently emitted item (if any) emitted by the current

Flowable

since the previous emission from the

sampler Publisher

and optionally emit the very last upstream item when the upstream or other

Publisher

complete.

@NonNull Flowable<T> scan(@NonNull BiFunction<T,T,T> accumulator)

Returns a Flowable that emits the first value emitted by the current Flowable, then emits one value for each subsequent value emitted by the current Flowable.

<R> @NonNull Flowable<R> scan(R initialValue, @NonNull BiFunction<R,? super T,R> accumulator)

Returns a Flowable that emits the provided initial (seed) value, then emits one value for each value emitted by the current Flowable.

<R> @NonNull Flowable<R> scanWith(@NonNull Supplier<R> seedSupplier, @NonNull BiFunction<R,? super T,R> accumulator)

Returns a Flowable that emits the provided initial (seed) value, then emits one value for each value emitted by the current Flowable.

static <T> @NonNull Single<Boolean> sequenceEqual(@NonNull Publisher<? extends T> source1, @NonNull Publisher<? extends T> source2)

Returns a

Single

that emits a

value that indicates whether two

sequences are the same by comparing the items emitted by each

Publisher

pairwise.

static <T> @NonNull Single<Boolean>

sequenceEqual(@NonNull Publisher<? extends T> source1, @NonNull Publisher<? extends T> source2, @NonNull BiPredicate<? super T,? super T> isEqual)

Returns a

Single

that emits a

value that indicates whether two

sequences are the same by comparing the items emitted by each

Publisher

pairwise based on the results of a specified equality function.

static <T> @NonNull Single<Boolean>

sequenceEqual(@NonNull Publisher<? extends T> source1, @NonNull Publisher<? extends T> source2, @NonNull BiPredicate<? super T,? super T> isEqual, int bufferSize)

Returns a

Single

that emits a

value that indicates whether two

sequences are the same by comparing the items emitted by each

Publisher

pairwise based on the results of a specified equality function.

static <T> @NonNull Single<Boolean> sequenceEqual(@NonNull Publisher<? extends T> source1, @NonNull Publisher<? extends T> source2, int bufferSize)

Returns a

Single

that emits a

value that indicates whether two

sequences are the same by comparing the items emitted by each

Publisher

pairwise.

@NonNull Flowable<T> serialize()

Forces the current

Flowable

's emissions and notifications to be serialized and for it to obey

the Publisher contract

in other ways.

@NonNull Flowable<T> share()

Returns a new Flowable that multicasts (and shares a single subscription to) the current Flowable.

@NonNull Single<T> single(T defaultItem)

Returns a

Single

that emits the single item emitted by the current

Flowable

if it emits only a single item, or a default item if the current

Flowable

emits no items.

@NonNull Maybe<T> singleElement()

Returns a

Maybe

that completes if this

Flowable

is empty, signals one item if this

Flowable

signals exactly one item or signals an

IllegalArgumentException

if this

Flowable

signals more than one item.

@NonNull Single<T> singleOrError()

Returns a

Single

that emits the single item emitted by this

Flowable

, if this

Flowable

emits only a single item, otherwise if this

Flowable

completes without emitting any items a

will be signaled and if this

Flowable

emits more than one item, an

IllegalArgumentException

will be signaled.

@NonNull CompletionStage<T> singleOrErrorStage() @NonNull CompletionStage<T> singleStage(T defaultItem) @NonNull Flowable<T> skip(long count)

Returns a Flowable that skips the first count items emitted by the current Flowable and emits the remainder.

@NonNull Flowable<T> skip(long time, @NonNull TimeUnit unit)

Returns a Flowable that skips values emitted by the current Flowable before a specified time window elapses.

@NonNull Flowable<T> skip(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)

Returns a

Flowable

that skips values emitted by the current

Flowable

before a specified time window on a specified

elapses.

@NonNull Flowable<T> skipLast(int count)

Returns a Flowable that drops a specified number of items from the end of the sequence emitted by the current Flowable.

@NonNull Flowable<T> skipLast(long time, @NonNull TimeUnit unit)

Returns a Flowable that drops items emitted by the current Flowable during a specified time window before the source completes.

@NonNull Flowable<T> skipLast(long time, @NonNull TimeUnit unit, boolean delayError)

Returns a Flowable that drops items emitted by the current Flowable during a specified time window before the source completes.

@NonNull Flowable<T> skipLast(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)

Returns a Flowable that drops items emitted by the current Flowable during a specified time window (defined on a specified scheduler) before the source completes.

@NonNull Flowable<T> skipLast(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean delayError)

Returns a Flowable that drops items emitted by the current Flowable during a specified time window (defined on a specified scheduler) before the source completes.

@NonNull Flowable<T> skipLast(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean delayError, int bufferSize)

Returns a Flowable that drops items emitted by the current Flowable during a specified time window (defined on a specified scheduler) before the source completes.

 @NonNull Flowable<T> skipUntil(@NonNull Publisher other)

Returns a

Flowable

that skips items emitted by the current

Flowable

until a second

emits an item.

@NonNull Flowable<T> skipWhile(@NonNull Predicate<? super T> predicate)

Returns a Flowable that skips all items emitted by the current Flowable as long as a specified condition holds true, but emits all further source items as soon as the condition becomes false.

@NonNull Flowable<T> sorted()

Returns a

Flowable

that emits the events emitted by source

, in a sorted order.

@NonNull Flowable<T> sorted(@NonNull Comparator<? super T> comparator)

Returns a

Flowable

that emits the events emitted by source

, in a sorted order based on a specified comparison function.

@NonNull Flowable<T> startWith(@NonNull CompletableSource other)

Returns a

Flowable

which first runs the other

then the current

Flowable

if the other completed normally.

@NonNull Flowable<T> startWith(@NonNull MaybeSource<T> other)

Returns a

Flowable

which first runs the other

then the current

Flowable

if the other succeeded or completed normally.

@NonNull Flowable<T> startWith(@NonNull Publisher<? extends T> other)

Returns a

Flowable

that emits the items in a specified

before it begins to emit items emitted by the current

Flowable

@NonNull Flowable<T> startWith(@NonNull SingleSource<T> other)

Returns a

Flowable

which first runs the other

then the current

Flowable

if the other succeeded normally.

@NonNull Flowable<T> startWithArray(T... items)

Returns a Flowable that emits the specified items before it begins to emit items emitted by the current Flowable.

@NonNull Flowable<T> startWithItem(T item)

Returns a Flowable that emits a specified item before it begins to emit items emitted by the current Flowable.

@NonNull Flowable<T> startWithIterable(@NonNull Iterable<? extends T> items)

Returns a

Flowable

that emits the items in a specified

before it begins to emit items emitted by the current

Flowable

@NonNull Disposable subscribe()

Subscribes to the current Flowable and ignores onNext and onComplete emissions.

@NonNull Disposable subscribe(@NonNull Consumer<? super T> onNext)

Subscribes to the current Flowable and provides a callback to handle the items it emits.

@NonNull Disposable subscribe(@NonNull Consumer<? super T> onNext, @NonNull Consumer<? super Throwable> onError)

Subscribes to the current Flowable and provides callbacks to handle the items it emits and any error notification it issues.

@NonNull Disposable

subscribe(@NonNull Consumer<? super T> onNext, @NonNull Consumer<? super Throwable> onError, @NonNull Action onComplete)

Subscribes to the current Flowable and provides callbacks to handle the items it emits and any error or completion notification it issues.

@NonNull Disposable

subscribe(@NonNull Consumer<? super T> onNext, @NonNull Consumer<? super Throwable> onError, @NonNull Action onComplete, @NonNull DisposableContainer container)

Wraps the given onXXX callbacks into a

Disposable Subscriber

, adds it to the given

DisposableContainer

and ensures, that if the upstream terminates or this particular

Disposable

is disposed, the

Subscriber

is removed from the given container.

void subscribe(@NonNull FlowableSubscriber<? super T> subscriber)

Establish a connection between this

Flowable

and the given

FlowableSubscriber

and start streaming events based on the demand of the

FlowableSubscriber

void subscribe(@NonNull Subscriber<? super T> subscriber) protected abstract void subscribeActual(@NonNull Subscriber<? super T> subscriber)

Operator implementations (both source and intermediate) should implement this method that performs the necessary business logic and handles the incoming

@NonNull Flowable<T> subscribeOn(@NonNull Scheduler scheduler) @NonNull Flowable<T> subscribeOn(@NonNull Scheduler scheduler, boolean requestOn)

Asynchronously subscribes

s to the current

Flowable

on the specified

optionally reroutes requests from other threads to the same

Scheduler

thread.

<E extends Subscriber<? super T>>

  E

subscribeWith(E subscriber)

Subscribes a given

(subclass) to this

Flowable

and returns the given

Subscriber

as is.

@NonNull Flowable<T> switchIfEmpty(@NonNull Publisher<? extends T> other)

Returns a

Flowable

that emits the items emitted by the current

Flowable

or the items of an alternate

if the current

Flowable

is empty.

<R> @NonNull Flowable<R> switchMap(@NonNull Function<? super T,? extends Publisher<? extends R>> mapper)

Returns a new

Flowable

by applying a function that you supply to each item emitted by the current

Flowable

that returns a

, and then emitting the items emitted by the most recently emitted of these

Publisher

<R> @NonNull Flowable<R> switchMap(@NonNull Function<? super T,? extends Publisher<? extends R>> mapper, int bufferSize)

Returns a new

Flowable

by applying a function that you supply to each item emitted by the current

Flowable

that returns a

, and then emitting the items emitted by the most recently emitted of these

Publisher

@NonNull Completable switchMapCompletable(@NonNull Function<? super T,? extends CompletableSource> mapper)

Maps the upstream values into

s, subscribes to the newer one while disposing the subscription to the previous

CompletableSource

, thus keeping at most one active

CompletableSource

running.

@NonNull Completable switchMapCompletableDelayError(@NonNull Function<? super T,? extends CompletableSource> mapper)

Maps the upstream values into

s, subscribes to the newer one while disposing the subscription to the previous

CompletableSource

, thus keeping at most one active

CompletableSource

running and delaying any main or inner errors until all of them terminate.

<R> @NonNull Flowable<R> switchMapDelayError(@NonNull Function<? super T,? extends Publisher<? extends R>> mapper)

Returns a new

Flowable

by applying a function that you supply to each item emitted by the current

Flowable

that returns a

, and then emitting the items emitted by the most recently emitted of these

Publisher

s and delays any error until all

Publisher

s terminate.

<R> @NonNull Flowable<R> switchMapDelayError(@NonNull Function<? super T,? extends Publisher<? extends R>> mapper, int bufferSize)

Returns a new

Flowable

by applying a function that you supply to each item emitted by the current

Flowable

that returns a

, and then emitting the items emitted by the most recently emitted of these

Publisher

s and delays any error until all

Publisher

s terminate.

<R> @NonNull Flowable<R> switchMapMaybe(@NonNull Function<? super T,? extends MaybeSource<? extends R>> mapper)

Maps the upstream items into

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 this

Flowable

or any of the active inner

MaybeSource

s fail.

<R> @NonNull Flowable<R> switchMapMaybeDelayError(@NonNull Function<? super T,? extends MaybeSource<? extends R>> mapper)

Maps the upstream items into

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 this

Flowable

or the inner

MaybeSource

s until all terminate.

<R> @NonNull Flowable<R> switchMapSingle(@NonNull Function<? super T,? extends SingleSource<? extends R>> mapper)

Maps the upstream items into

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 this

Flowable

or any of the active inner

SingleSource

s fail.

<R> @NonNull Flowable<R> switchMapSingleDelayError(@NonNull Function<? super T,? extends SingleSource<? extends R>> mapper)

Maps the upstream items into

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 this

Flowable

or the inner

SingleSource

s until all terminate.

static <T> @NonNull Flowable<T> switchOnNext(@NonNull Publisher<? extends Publisher<? extends T>> sources)

Converts a

that emits

Publisher

s into a

Publisher

that emits the items emitted by the most recently emitted of those

Publisher

static <T> @NonNull Flowable<T> switchOnNext(@NonNull Publisher<? extends Publisher<? extends T>> sources, int bufferSize)

Converts a

that emits

Publisher

s into a

Publisher

that emits the items emitted by the most recently emitted of those

Publisher

static <T> @NonNull Flowable<T> switchOnNextDelayError(@NonNull Publisher<? extends Publisher<? extends T>> sources)

Converts a

that emits

Publisher

s into a

Publisher

that emits the items emitted by the most recently emitted of those

Publisher

s and delays any exception until all

Publisher

s terminate.

static <T> @NonNull Flowable<T> switchOnNextDelayError(@NonNull Publisher<? extends Publisher<? extends T>> sources, int prefetch)

Converts a

that emits

Publisher

s into a

Publisher

that emits the items emitted by the most recently emitted of those

Publisher

s and delays any exception until all

Publisher

s terminate.

@NonNull Flowable<T> take(long count)

Returns a Flowable that emits only the first count items emitted by the current Flowable.

@NonNull Flowable<T> take(long time, @NonNull TimeUnit unit)

Returns a

Flowable

that emits those items emitted by source

before a specified time runs out.

@NonNull Flowable<T> take(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)

Returns a

Flowable

that emits those items emitted by source

before a specified time (on a specified

) runs out.

@NonNull Flowable<T> takeLast(int count)

Returns a Flowable that emits at most the last count items emitted by the current Flowable.

@NonNull Flowable<T> takeLast(long count, long time, @NonNull TimeUnit unit)

Returns a Flowable that emits at most a specified number of items from the current Flowable that were emitted in a specified window of time before the current Flowable completed.

@NonNull Flowable<T> takeLast(long count, long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)

Returns a

Flowable

that emits at most a specified number of items from the current

Flowable

that were emitted in a specified window of time before the current

Flowable

completed, where the timing information is provided by a given

@NonNull Flowable<T>

takeLast(long count, long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean delayError, int bufferSize)

Returns a

Flowable

that emits at most a specified number of items from the current

Flowable

that were emitted in a specified window of time before the current

Flowable

completed, where the timing information is provided by a given

@NonNull Flowable<T> takeLast(long time, @NonNull TimeUnit unit)

Returns a Flowable that emits the items from the current Flowable that were emitted in a specified window of time before the current Flowable completed.

@NonNull Flowable<T> takeLast(long time, @NonNull TimeUnit unit, boolean delayError)

Returns a Flowable that emits the items from the current Flowable that were emitted in a specified window of time before the current Flowable completed.

@NonNull Flowable<T> takeLast(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)

Returns a

Flowable

that emits the items from the current

Flowable

that were emitted in a specified window of time before the current

Flowable

completed, where the timing information is provided by a specified

@NonNull Flowable<T> takeLast(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean delayError)

Returns a

Flowable

that emits the items from the current

Flowable

that were emitted in a specified window of time before the current

Flowable

completed, where the timing information is provided by a specified

@NonNull Flowable<T> takeLast(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean delayError, int bufferSize)

Returns a

Flowable

that emits the items from the current

Flowable

that were emitted in a specified window of time before the current

Flowable

completed, where the timing information is provided by a specified

@NonNull Flowable<T> takeUntil(@NonNull Predicate<? super T> stopPredicate)

Returns a Flowable that emits items emitted by the current Flowable, checks the specified predicate for each item, and then completes when the condition is satisfied.

 @NonNull Flowable<T> takeUntil(@NonNull Publisher other)

Returns a

Flowable

that emits the items emitted by the current

Flowable

until a second

emits an item or completes.

@NonNull Flowable<T> takeWhile(@NonNull Predicate<? super T> predicate)

Returns a Flowable that emits items emitted by the current Flowable so long as each item satisfied a specified condition, and then completes as soon as this condition is not satisfied.

@NonNull TestSubscriber<T> test() @NonNull TestSubscriber<T> test(long initialRequest)

Creates a

TestSubscriber

with the given initial request amount and subscribes it to this

Flowable

@NonNull TestSubscriber<T> test(long initialRequest, boolean cancel)

Creates a

TestSubscriber

with the given initial request amount, optionally cancels it before the subscription and subscribes it to this

Flowable

@NonNull Flowable<T> throttleFirst(long windowDuration, @NonNull TimeUnit unit)

Returns a Flowable that emits only the first item emitted by the current Flowable during sequential time windows of a specified duration.

@NonNull Flowable<T> throttleFirst(long skipDuration, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)

Returns a

Flowable

that emits only the first item emitted by the current

Flowable

during sequential time windows of a specified duration, where the windows are managed by a specified

@NonNull Flowable<T>

throttleFirst(long skipDuration, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, @NonNull Consumer<? super T> onDropped)

Returns a

Flowable

that emits only the first item emitted by the current

Flowable

during sequential time windows of a specified duration, where the windows are managed by a specified

@NonNull Flowable<T> throttleLast(long intervalDuration, @NonNull TimeUnit unit)

Returns a Flowable that emits only the last item emitted by the current Flowable during sequential time windows of a specified duration.

@NonNull Flowable<T> throttleLast(long intervalDuration, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)

Returns a

Flowable

that emits only the last item emitted by the current

Flowable

during sequential time windows of a specified duration, where the duration is governed by a specified

@NonNull Flowable<T>

throttleLast(long intervalDuration, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, @NonNull Consumer<? super T> onDropped)

Returns a

Flowable

that emits only the last item emitted by the current

Flowable

during sequential time windows of a specified duration, where the duration is governed by a specified

@NonNull Flowable<T> throttleLatest(long timeout, @NonNull TimeUnit unit)

Throttles items from the upstream Flowable by first emitting the next item from upstream, then periodically emitting the latest item (if any) when the specified timeout elapses between them.

@NonNull Flowable<T> throttleLatest(long timeout, @NonNull TimeUnit unit, boolean emitLast)

Throttles items from the upstream Flowable by first emitting the next item from upstream, then periodically emitting the latest item (if any) when the specified timeout elapses between them.

@NonNull Flowable<T> throttleLatest(long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)

Throttles items from the upstream Flowable by first emitting the next item from upstream, then periodically emitting the latest item (if any) when the specified timeout elapses between them.

@NonNull Flowable<T> throttleLatest(long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean emitLast)

Throttles items from the upstream Flowable by first emitting the next item from upstream, then periodically emitting the latest item (if any) when the specified timeout elapses between them.

@NonNull Flowable<T>

throttleLatest(long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean emitLast, @NonNull Consumer<? super T> onDropped)

Throttles items from the upstream Flowable by first emitting the next item from upstream, then periodically emitting the latest item (if any) when the specified timeout elapses between them, invoking the consumer for any dropped item.

@NonNull Flowable<T> throttleWithTimeout(long timeout, @NonNull TimeUnit unit)

Returns a Flowable that mirrors the current Flowable, except that it drops items emitted by the current Flowable that are followed by newer items before a timeout value expires.

@NonNull Flowable<T> throttleWithTimeout(long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)

Returns a

Flowable

that mirrors the current

Flowable

, except that it drops items emitted by the current

Flowable

that are followed by newer items before a timeout value expires on a specified

@NonNull Flowable<T>

throttleWithTimeout(long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, @NonNull Consumer<? super T> onDropped)

Returns a

Flowable

that mirrors the current

Flowable

, except that it drops items emitted by the current

Flowable

that are followed by newer items before a timeout value expires on a specified

@NonNull Flowable<Timed<T>> timeInterval()

Returns a Flowable that emits records of the time interval between consecutive items emitted by the current Flowable.

@NonNull Flowable<Timed<T>> timeInterval(@NonNull Scheduler scheduler)

Returns a

Flowable

that emits records of the time interval between consecutive items emitted by the current

Flowable

, where this interval is computed on a specified

@NonNull Flowable<Timed<T>> timeInterval(@NonNull TimeUnit unit)

Returns a Flowable that emits records of the time interval between consecutive items emitted by the current Flowable.

@NonNull Flowable<Timed<T>> timeInterval(@NonNull TimeUnit unit, @NonNull Scheduler scheduler)

Returns a

Flowable

that emits records of the time interval between consecutive items emitted by the current

Flowable

, where this interval is computed on a specified

<V> @NonNull Flowable<T> timeout(@NonNull Function<? super T,? extends Publisher<V>> itemTimeoutIndicator)

Returns a

Flowable

that mirrors the current

Flowable

, but notifies

s of a

TimeoutException

if an item emitted by the current

Flowable

doesn't arrive within a window of time after the emission of the previous item, where that period of time is measured by a

that is a function of the previous item.

<V> @NonNull Flowable<T>

timeout(@NonNull Function<? super T,? extends Publisher<V>> itemTimeoutIndicator, @NonNull Publisher<? extends T> fallback)

Returns a

Flowable

that mirrors the current

Flowable

, but that switches to a fallback

if an item emitted by the current

Flowable

doesn't arrive within a window of time after the emission of the previous item, where that period of time is measured by a

Publisher

that is a function of the previous item.

@NonNull Flowable<T> timeout(long timeout, @NonNull TimeUnit unit)

Returns a Flowable that mirrors the current Flowable but applies a timeout policy for each emitted item.

@NonNull Flowable<T> timeout(long timeout, @NonNull TimeUnit unit, @NonNull Publisher<? extends T> fallback)

Returns a Flowable that mirrors the current Flowable but applies a timeout policy for each emitted item.

@NonNull Flowable<T> timeout(long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)

Returns a

Flowable

that mirrors the current

Flowable

but applies a timeout policy for each emitted item, where this policy is governed by a specified

@NonNull Flowable<T>

timeout(long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, @NonNull Publisher<? extends T> fallback)

Returns a

Flowable

that mirrors the current

Flowable

but applies a timeout policy for each emitted item using a specified

<U,V> @NonNull Flowable<T>

timeout(@NonNull Publisher<U> firstTimeoutIndicator, @NonNull Function<? super T,? extends Publisher<V>> itemTimeoutIndicator)

Returns a

Flowable

that mirrors the current

Flowable

, but notifies

s of a

TimeoutException

if either the first item emitted by the current

Flowable

or any subsequent item doesn't arrive within time windows defined by other

<U,V> @NonNull Flowable<T>

timeout(@NonNull Publisher<U> firstTimeoutIndicator, @NonNull Function<? super T,? extends Publisher<V>> itemTimeoutIndicator, @NonNull Publisher<? extends T> fallback)

Returns a

Flowable

that mirrors the current

Flowable

, but switches to a fallback

if either the first item emitted by the current

Flowable

or any subsequent item doesn't arrive within time windows defined by other

Publisher

static @NonNull Flowable<Long> timer(long delay, @NonNull TimeUnit unit)

Returns a Flowable that emits 0L after a specified delay, and then completes.

static @NonNull Flowable<Long> timer(long delay, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)

Returns a

Flowable

that emits

0L

after a specified delay, on a specified

, and then completes.

@NonNull Flowable<Timed<T>> timestamp()

Returns a

Flowable

that emits each item emitted by the current

Flowable

, wrapped in a

Timed

object.

@NonNull Flowable<Timed<T>> timestamp(@NonNull Scheduler scheduler)

Returns a

Flowable

that emits each item emitted by the current

Flowable

, wrapped in a

Timed

object whose timestamps are provided by a specified

@NonNull Flowable<Timed<T>> timestamp(@NonNull TimeUnit unit)

Returns a

Flowable

that emits each item emitted by the current

Flowable

, wrapped in a

Timed

object.

@NonNull Flowable<Timed<T>> timestamp(@NonNull TimeUnit unit, @NonNull Scheduler scheduler)

Returns a

Flowable

that emits each item emitted by the current

Flowable

, wrapped in a

Timed

object whose timestamps are provided by a specified

<R> R to(@NonNull FlowableConverter<T,? extends R> converter)

Calls the specified converter function during assembly time and returns its resulting value.

@NonNull Future<T> toFuture()

Returns a

Future

representing the only value emitted by this

Flowable

@NonNull Single<List<T>> toList()

Returns a

Single

that emits a single item, a list composed of all the items emitted by the finite upstream source

@NonNull Single<List<T>> toList(int capacityHint)

Returns a

Single

that emits a single item, a list composed of all the items emitted by the finite source

<U extends Collection<? super T>>
@NonNull Single<U>

toList(@NonNull Supplier collectionSupplier)

Returns a

Single

that emits a single item, a list composed of all the items emitted by the finite source

<K> @NonNull Single<Map<K,T>> toMap(@NonNull Function<? super T,? extends K> keySelector)

Returns a

Single

that emits a single

containing all items emitted by the finite source

, mapped by the keys returned by a specified

keySelector

function.

<K,V> @NonNull Single<Map<K,V>> toMap(@NonNull Function<? super T,? extends K> keySelector, @NonNull Function<? super T,? extends V> valueSelector)

Returns a

Single

that emits a single

containing values corresponding to items emitted by the finite source

, mapped by the keys returned by a specified

keySelector

function.

<K,V> @NonNull Single<Map<K,V>>

toMap(@NonNull Function<? super T,? extends K> keySelector, @NonNull Function<? super T,? extends V> valueSelector, @NonNull Supplier<? extends Map<K,V>> mapSupplier)

Returns a

Single

that emits a single

Map

, returned by a specified

mapFactory

function, that contains keys and values extracted from the items emitted by the finite source

<K> @NonNull Single<Map<K,Collection<T>>> toMultimap(@NonNull Function<? super T,? extends K> keySelector)

Returns a

Single

that emits a single

that contains an

ArrayList

of items emitted by the finite source

keyed by a specified

keySelector

function.

<K,V> @NonNull Single<Map<K,Collection<V>>>

toMultimap(@NonNull Function<? super T,? extends K> keySelector, @NonNull Function<? super T,? extends V> valueSelector)

Returns a

Single

that emits a single

that contains an

ArrayList

of values extracted by a specified

valueSelector

function from items emitted by the finite source

, keyed by a specified

keySelector

function.

<K,V> @NonNull Single<Map<K,Collection<V>>>

toMultimap(@NonNull Function<? super T,? extends K> keySelector, @NonNull Function<? super T,? extends V> valueSelector, @NonNull Supplier<? extends Map<K,Collection<V>>> mapSupplier, @NonNull Function<? super K,? extends Collection<? super V>> collectionFactory)

Returns a

Single

that emits a single

Map

, returned by a specified

mapFactory

function, that contains a custom collection of values, extracted by a specified

valueSelector

function from items emitted by the finite source

, and keyed by the

keySelector

function.

<K,V> @NonNull Single<Map<K,Collection<V>>>

toMultimap(@NonNull Function<? super T,? extends K> keySelector, @NonNull Function<? super T,? extends V> valueSelector, @NonNull Supplier<Map<K,Collection<V>>> mapSupplier)

Returns a

Single

that emits a single

Map

, returned by a specified

mapFactory

function, that contains an

ArrayList

of values, extracted by a specified

valueSelector

function from items emitted by the finite source

and keyed by the

keySelector

function.

@NonNull Observable<T> toObservable()

Converts the current

Flowable

into a non-backpressured

Observable

@NonNull Single<List<T>> toSortedList()

Returns a

Single

that emits a

List

that contains the items emitted by the finite source

, in a sorted order.

@NonNull Single<List<T>> toSortedList(@NonNull Comparator<? super T> comparator)

Returns a

Single

that emits a

List

that contains the items emitted by the finite source

, in a sorted order based on a specified comparison function.

@NonNull Single<List<T>> toSortedList(@NonNull Comparator<? super T> comparator, int capacityHint)

Returns a

Single

that emits a

List

that contains the items emitted by the finite source

, in a sorted order based on a specified comparison function.

@NonNull Single<List<T>> toSortedList(int capacityHint)

Returns a

Single

that emits a

List

that contains the items emitted by the finite source

, in a sorted order.

static <T> @NonNull Flowable<T> unsafeCreate(@NonNull Publisher<T> onSubscribe)

Create a

Flowable

by wrapping a

Publisher which has to be implemented according to the Reactive Streams specification by handling backpressure and cancellation correctly; no safeguards are provided by the Flowable itself

@NonNull Flowable<T> unsubscribeOn(@NonNull Scheduler scheduler) static <T,D> @NonNull Flowable<T>

using(@NonNull Supplier<? extends D> resourceSupplier, @NonNull Function<? super D,? extends Publisher<? extends T>> sourceSupplier, @NonNull Consumer<? super D> resourceCleanup)

Constructs a

Flowable

that creates a dependent resource object, a

with that resource and calls the provided

resourceDisposer

function if this inner source terminates or the downstream cancels the flow.

static <T,D> @NonNull Flowable<T>

using(@NonNull Supplier<? extends D> resourceSupplier, @NonNull Function<? super D,? extends Publisher<? extends T>> sourceSupplier, @NonNull Consumer<? super D> resourceCleanup, boolean eager)

Constructs a

Flowable

that creates a dependent resource object, a

with that resource and calls the provided

resourceDisposer

function if this inner source terminates or the downstream disposes the flow; doing it before these end-states have been reached if

eager == true

, after otherwise.

@NonNull Flowable<Flowable<T>> window(long count)

Returns a Flowable that emits windows of items it collects from the current Flowable.

@NonNull Flowable<Flowable<T>> window(long count, long skip)

Returns a Flowable that emits windows of items it collects from the current Flowable.

@NonNull Flowable<Flowable<T>> window(long count, long skip, int bufferSize)

Returns a Flowable that emits windows of items it collects from the current Flowable.

@NonNull Flowable<Flowable<T>> window(long timespan, long timeskip, @NonNull TimeUnit unit)

Returns a Flowable that emits windows of items it collects from the current Flowable.

@NonNull Flowable<Flowable<T>> window(long timespan, long timeskip, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)

Returns a Flowable that emits windows of items it collects from the current Flowable.

@NonNull Flowable<Flowable<T>> window(long timespan, long timeskip, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, int bufferSize)

Returns a Flowable that emits windows of items it collects from the current Flowable.

@NonNull Flowable<Flowable<T>> window(long timespan, @NonNull TimeUnit unit)

Returns a Flowable that emits windows of items it collects from the current Flowable.

@NonNull Flowable<Flowable<T>> window(long timespan, @NonNull TimeUnit unit, long count)

Returns a Flowable that emits windows of items it collects from the current Flowable.

@NonNull Flowable<Flowable<T>> window(long timespan, @NonNull TimeUnit unit, long count, boolean restart)

Returns a Flowable that emits windows of items it collects from the current Flowable.

@NonNull Flowable<Flowable<T>> window(long timespan, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)

Returns a Flowable that emits windows of items it collects from the current Flowable.

@NonNull Flowable<Flowable<T>> window(long timespan, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, long count)

Returns a Flowable that emits windows of items it collects from the current Flowable.

@NonNull Flowable<Flowable<T>> window(long timespan, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, long count, boolean restart)

Returns a Flowable that emits windows of items it collects from the current Flowable.

@NonNull Flowable<Flowable<T>>

window(long timespan, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, long count, boolean restart, int bufferSize)

Returns a Flowable that emits windows of items it collects from the current Flowable.

 @NonNull Flowable<Flowable<T>> window(@NonNull Publisher boundaryIndicator)

Returns a

Flowable

that emits non-overlapping windows of items it collects from the current

Flowable

where the boundary of each window is determined by the items emitted from a specified boundary-governing

 @NonNull Flowable<Flowable<T>> window(@NonNull Publisher boundaryIndicator, int bufferSize)

Returns a

Flowable

that emits non-overlapping windows of items it collects from the current

Flowable

where the boundary of each window is determined by the items emitted from a specified boundary-governing

<U,V> @NonNull Flowable<Flowable<T>> window(@NonNull Publisher openingIndicator, @NonNull Function<? super U,? extends Publisher<V>> closingIndicator)

Returns a Flowable that emits windows of items it collects from the current Flowable.

<U,V> @NonNull Flowable<Flowable<T>>

window(@NonNull Publisher<U> openingIndicator, @NonNull Function<? super U,? extends Publisher<V>> closingIndicator, int bufferSize)

Returns a Flowable that emits windows of items it collects from the current Flowable.

<R> @NonNull Flowable<R> withLatestFrom(@NonNull Iterable<? extends Publisher<?>> others, @NonNull Function<? super Object[],R> combiner)

Combines the value emission from the current

Flowable

with the latest emissions from the other

s via a function to produce the output item.

<R> @NonNull Flowable<R> withLatestFrom(@NonNull Publisher<?>[] others, @NonNull Function<? super Object[],R> combiner)

Combines the value emission from the current

Flowable

with the latest emissions from the other

s via a function to produce the output item.

<U,R> @NonNull Flowable<R> withLatestFrom(@NonNull Publisher<? extends U> other, @NonNull BiFunction<? super T,? super U,? extends R> combiner)

Merges the specified

into the current

Flowable

sequence by using the

resultSelector

function only when the current

Flowable

(this instance) emits an item.

<T1,T2,R> @NonNull Flowable<R>

withLatestFrom(@NonNull Publisher<T1> source1, @NonNull Publisher<T2> source2, @NonNull Function3<? super T,? super T1,? super T2,R> combiner)

Combines the value emission from the current

Flowable

with the latest emissions from the other

s via a function to produce the output item.

<T1,T2,T3,R>
@NonNull Flowable<R>

withLatestFrom(@NonNull Publisher<T1> source1, @NonNull Publisher<T2> source2, @NonNull Publisher<T3> source3, @NonNull Function4<? super T,? super T1,? super T2,? super T3,R> combiner)

Combines the value emission from the current

Flowable

with the latest emissions from the other

s via a function to produce the output item.

<T1,T2,T3,T4,R>
@NonNull Flowable<R>

withLatestFrom(@NonNull Publisher<T1> source1, @NonNull Publisher<T2> source2, @NonNull Publisher<T3> source3, @NonNull Publisher<T4> source4, @NonNull Function5<? super T,? super T1,? super T2,? super T3,? super T4,R> combiner)

Combines the value emission from the current

Flowable

with the latest emissions from the other

s via a function to produce the output item.

static <T,R> @NonNull Flowable<R>

zip(@NonNull Iterable<? extends Publisher<? extends T>> sources, @NonNull Function<? super Object[],? extends R> zipper)

Returns a

Flowable

that emits the results of a specified combiner function applied to combinations of items emitted, in sequence, by an

of other

static <T,R> @NonNull Flowable<R>

zip(@NonNull Iterable<? extends Publisher<? extends T>> sources, @NonNull Function<? super Object[],? extends R> zipper, boolean delayError, int bufferSize)

Returns a

Flowable

that emits the results of a specified combiner function applied to combinations of items emitted, in sequence, by an

of other

static <T1,T2,R> @NonNull Flowable<R>

zip(@NonNull Publisher<? extends T1> source1, @NonNull Publisher<? extends T2> source2, @NonNull BiFunction<? super T1,? super T2,? extends R> zipper)

Returns a

Flowable

that emits the results of a specified combiner function applied to combinations of two items emitted, in sequence, by two other

static <T1,T2,R> @NonNull Flowable<R>

zip(@NonNull Publisher<? extends T1> source1, @NonNull Publisher<? extends T2> source2, @NonNull BiFunction<? super T1,? super T2,? extends R> zipper, boolean delayError)

Returns a

Flowable

that emits the results of a specified combiner function applied to combinations of two items emitted, in sequence, by two other

static <T1,T2,R> @NonNull Flowable<R>

zip(@NonNull Publisher<? extends T1> source1, @NonNull Publisher<? extends T2> source2, @NonNull BiFunction<? super T1,? super T2,? extends R> zipper, boolean delayError, int bufferSize)

Returns a

Flowable

that emits the results of a specified combiner function applied to combinations of two items emitted, in sequence, by two other

static <T1,T2,T3,R>
@NonNull Flowable<R>

zip(@NonNull Publisher<? extends T1> source1, @NonNull Publisher<? extends T2> source2, @NonNull Publisher<? extends T3> source3, @NonNull Function3<? super T1,? super T2,? super T3,? extends R> zipper)

Returns a

Flowable

that emits the results of a specified combiner function applied to combinations of three items emitted, in sequence, by three other

static <T1,T2,T3,T4,R>
@NonNull Flowable<R>

zip(@NonNull Publisher<? extends T1> source1, @NonNull Publisher<? extends T2> source2, @NonNull Publisher<? extends T3> source3, @NonNull Publisher<? extends T4> source4, @NonNull Function4<? super T1,? super T2,? super T3,? super T4,? extends R> zipper)

Returns a

Flowable

that emits the results of a specified combiner function applied to combinations of four items emitted, in sequence, by four other

static <T1,T2,T3,T4,T5,R>
@NonNull Flowable<R>

zip(@NonNull Publisher<? extends T1> source1, @NonNull Publisher<? extends T2> source2, @NonNull Publisher<? extends T3> source3, @NonNull Publisher<? extends T4> source4, @NonNull Publisher<? extends T5> source5, @NonNull Function5<? super T1,? super T2,? super T3,? super T4,? super T5,? extends R> zipper)

Returns a

Flowable

that emits the results of a specified combiner function applied to combinations of five items emitted, in sequence, by five other

static <T1,T2,T3,T4,T5,T6,R>
@NonNull Flowable<R>

zip(@NonNull Publisher<? extends T1> source1, @NonNull Publisher<? extends T2> source2, @NonNull Publisher<? extends T3> source3, @NonNull Publisher<? extends T4> source4, @NonNull Publisher<? extends T5> source5, @NonNull Publisher<? extends T6> source6, @NonNull Function6<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? extends R> zipper)

Returns a

Flowable

that emits the results of a specified combiner function applied to combinations of six items emitted, in sequence, by six other

static <T1,T2,T3,T4,T5,T6,T7,R>
@NonNull Flowable<R>

zip(@NonNull Publisher<? extends T1> source1, @NonNull Publisher<? extends T2> source2, @NonNull Publisher<? extends T3> source3, @NonNull Publisher<? extends T4> source4, @NonNull Publisher<? extends T5> source5, @NonNull Publisher<? extends T6> source6, @NonNull Publisher<? extends T7> source7, @NonNull Function7<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? extends R> zipper)

Returns a

Flowable

that emits the results of a specified combiner function applied to combinations of seven items emitted, in sequence, by seven other

static <T1,T2,T3,T4,T5,T6,T7,T8,R>
@NonNull Flowable<R>

zip(@NonNull Publisher<? extends T1> source1, @NonNull Publisher<? extends T2> source2, @NonNull Publisher<? extends T3> source3, @NonNull Publisher<? extends T4> source4, @NonNull Publisher<? extends T5> source5, @NonNull Publisher<? extends T6> source6, @NonNull Publisher<? extends T7> source7, @NonNull Publisher<? extends T8> source8, @NonNull Function8<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? extends R> zipper)

Returns a

Flowable

that emits the results of a specified combiner function applied to combinations of eight items emitted, in sequence, by eight other

static <T1,T2,T3,T4,T5,T6,T7,T8,T9,R>
@NonNull Flowable<R>

zip(@NonNull Publisher<? extends T1> source1, @NonNull Publisher<? extends T2> source2, @NonNull Publisher<? extends T3> source3, @NonNull Publisher<? extends T4> source4, @NonNull Publisher<? extends T5> source5, @NonNull Publisher<? extends T6> source6, @NonNull Publisher<? extends T7> source7, @NonNull Publisher<? extends T8> source8, @NonNull Publisher<? extends T9> source9, @NonNull Function9<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? super T9,? extends R> zipper)

Returns a

Flowable

that emits the results of a specified combiner function applied to combinations of nine items emitted, in sequence, by nine other

static <T,R> @NonNull Flowable<R>

zipArray(@NonNull Function<? super Object[],? extends R> zipper, boolean delayError, int bufferSize, Publisher<? extends T>... sources)

Returns a

Flowable

that emits the results of a specified combiner function applied to combinations of items emitted, in sequence, by an array of other

<U,R> @NonNull Flowable<R> zipWith(@NonNull Iterable other, @NonNull BiFunction<? super T,? super U,? extends R> zipper)

Returns a

Flowable

that emits items that are the result of applying a specified function to pairs of values, one each from the current

Flowable

and a specified

sequence.

<U,R> @NonNull Flowable<R> zipWith(@NonNull Publisher<? extends U> other, @NonNull BiFunction<? super T,? super U,? extends R> zipper)

Returns a

Flowable

that emits items that are the result of applying a specified function to pairs of values, one each from the current

Flowable

and another specified

<U,R> @NonNull Flowable<R>

zipWith(@NonNull Publisher<? extends U> other, @NonNull BiFunction<? super T,? super U,? extends R> zipper, boolean delayError)

Returns a

Flowable

that emits items that are the result of applying a specified function to pairs of values, one each from the current

Flowable

and another specified

<U,R> @NonNull Flowable<R>

zipWith(@NonNull Publisher<? extends U> other, @NonNull BiFunction<? super T,? super U,? extends R> zipper, boolean delayError, int bufferSize)

Returns a

Flowable

that emits items that are the result of applying a specified function to pairs of values, one each from the current

Flowable

and another specified