io.reactivex.rxjava3.core

Class Observable<T>

java.lang.Object

io.reactivex.rxjava3.core.Observable<T>

Type Parameters:

T - the type of the items emitted by the Observable

All Implemented Interfaces:

ObservableSource<T>

Direct Known Subclasses:

ConnectableObservable, GroupedObservable, Subject

public abstract class Observable<T>
extends Object
implements ObservableSource<T>

The Observable class is the non-backpressured, optionally multi-valued base reactive class that offers factory methods, intermediate operators and the ability to consume synchronous and/or asynchronous reactive dataflows.

Many operators in the class accept ObservableSource(s), the base reactive interface for such non-backpressured flows, which Observable itself implements as well.

The Observable's operators, by default, run with a buffer size of 128 elements (see Flowable.bufferSize()), that can be overridden globally via the system parameter rx3.buffer-size. Most operators, however, have overloads that allow setting their internal buffer size explicitly.

The documentation for this class makes use of marble diagrams. The following legend explains these diagrams:

The design of this class was derived from the Reactive-Streams design and specification by removing any backpressure-related infrastructure and implementation detail, replacing the org.reactivestreams.Subscription with Disposable as the primary means to dispose of a flow.

The Observable follows the protocol

      onSubscribe onNext* (onError | onComplete)?
 

where the stream can be disposed through the Disposable instance provided to consumers through Observer.onSubscribe.

Unlike the Observable of version 1.x, subscribe(Observer) does not allow external disposal of a subscription and the Observer instance is expected to expose such capability.

Example:

 Disposable d = Observable.just("Hello world!")
     .delay(1, TimeUnit.SECONDS)
     .subscribeWith(new DisposableObserver<String>() {
         @Override public void onStart() {
             System.out.println("Start!");
         }
         @Override public void onNext(String t) {
             System.out.println(t);
         }
         @Override public void onError(Throwable t) {
             t.printStackTrace();
         }
         @Override public void onComplete() {
             System.out.println("Done!");
         }
     });

 Thread.sleep(500);
 // the sequence can now be disposed via dispose()
 d.dispose();
 

See Also:

Flowable, DisposableObserver

Constructor Summary

Constructors

Constructor and Description
Observable()

Method Summary

Modifier and Type	Method and Description
@NonNull Single<Boolean>	all(@NonNull Predicate<? super T> predicate) Returns a Single that emits a Boolean that indicates whether all of the items emitted by the current Observable satisfy a condition.
static <T> @NonNull Observable<T>	amb(@NonNull Iterable<? extends ObservableSource<? extends T>> sources) Mirrors the one ObservableSource in an Iterable of several ObservableSources that first either emits an item or sends a termination notification.
static <T> @NonNull Observable<T>	ambArray(ObservableSource<? extends T>... sources) Mirrors the one ObservableSource in an array of several ObservableSources that first either emits an item or sends a termination notification.
@NonNull Observable<T>	ambWith(@NonNull ObservableSource<? extends T> other) Mirrors the current Observable or the other ObservableSource provided of which the 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 Observable satisfies a specified condition, otherwise false.
T	blockingFirst() Returns the first item emitted by the current Observable, or throws NoSuchElementException if it emits no items.
T	blockingFirst(T defaultItem) Returns the first item emitted by the current Observable, or a default value if it emits no items.
void	blockingForEach(@NonNull Consumer<? super T> onNext) Consumes the current Observable in a blocking fashion and invokes the given Consumer with each upstream item on the current thread until the upstream terminates.
void	blockingForEach(@NonNull Consumer<? super T> onNext, int capacityHint) Consumes the current Observable in a blocking fashion and invokes the given Consumer with each upstream item on the current thread until the upstream terminates.
@NonNull Iterable<T>	blockingIterable() Exposes the current Observable as an Iterable which, when iterated, subscribes to the current Observable and blocks until the current Observable emits items or terminates.
@NonNull Iterable<T>	blockingIterable(int capacityHint) Exposes the current Observable as an Iterable which, when iterated, subscribes to the current Observable and blocks until the current Observable emits items or terminates.
T	blockingLast() Returns the last item emitted by the current Observable, or throws NoSuchElementException if the current Observable emits no items.
T	blockingLast(T defaultItem) Returns the last item emitted by the current Observable, or a default value if it emits no items.
@NonNull Iterable<T>	blockingLatest() Returns an Iterable that returns the latest item emitted by the current Observable, waiting if necessary for one to become available.
@NonNull Iterable<T>	blockingMostRecent(T initialItem) Returns an Iterable that always returns the item most recently emitted by the current Observable.
@NonNull Iterable<T>	blockingNext() Returns an Iterable that blocks until the current Observable emits another item, then returns that item.
T	blockingSingle() If the current Observable completes after emitting a single item, return that item, otherwise throw a NoSuchElementException.
T	blockingSingle(T defaultItem) If the current Observable 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 the current Observable in a blocking manner via the Java Stream API.
@NonNull Stream<T>	blockingStream(int capacityHint) Creates a sequential Stream to consume or process the current Observable in a blocking manner via the Java Stream API.
void	blockingSubscribe() Runs the current Observable 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 Observer<? super T> observer) Subscribes to the source and calls the Observer methods on the current thread.
@NonNull Observable<List<T>>	buffer(int count) Returns an Observable that emits buffers of items it collects from the current Observable.
@NonNull Observable<List<T>>	buffer(int count, int skip) Returns an Observable that emits buffers of items it collects from the current Observable.
<U extends Collection<? super T>> @NonNull Observable<U>	buffer(int count, int skip, @NonNull Supplier<U> bufferSupplier) Returns an Observable that emits buffers of items it collects from the current Observable.
<U extends Collection<? super T>> @NonNull Observable<U>	buffer(int count, @NonNull Supplier<U> bufferSupplier) Returns an Observable that emits buffers of items it collects from the current Observable.
@NonNull Observable<List<T>>	buffer(long timespan, long timeskip, @NonNull TimeUnit unit) Returns an Observable that emits buffers of items it collects from the current Observable.
@NonNull Observable<List<T>>	buffer(long timespan, long timeskip, @NonNull TimeUnit unit, @NonNull Scheduler scheduler) Returns an Observable that emits buffers of items it collects from the current Observable.
<U extends Collection<? super T>> @NonNull Observable<U>	buffer(long timespan, long timeskip, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, @NonNull Supplier<U> bufferSupplier) Returns an Observable that emits buffers of items it collects from the current Observable.
@NonNull Observable<List<T>>	buffer(long timespan, @NonNull TimeUnit unit) Returns an Observable that emits buffers of items it collects from the current Observable.
@NonNull Observable<List<T>>	buffer(long timespan, @NonNull TimeUnit unit, int count) Returns an Observable that emits buffers of items it collects from the current Observable.
@NonNull Observable<List<T>>	buffer(long timespan, @NonNull TimeUnit unit, @NonNull Scheduler scheduler) Returns an Observable that emits buffers of items it collects from the current Observable.
@NonNull Observable<List<T>>	buffer(long timespan, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, int count) Returns an Observable that emits buffers of items it collects from the current Observable.
<U extends Collection<? super T>> @NonNull Observable<U>	buffer(long timespan, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, int count, @NonNull Supplier<U> bufferSupplier, boolean restartTimerOnMaxSize) Returns an Observable that emits buffers of items it collects from the current Observable.
<TOpening,TClosing> @NonNull Observable<List<T>>	buffer(@NonNull ObservableSource<? extends TOpening> openingIndicator, @NonNull Function<? super TOpening,? extends ObservableSource<? extends TClosing>> closingIndicator) Returns an Observable that emits buffers of items it collects from the current Observable.
<TOpening,TClosing,U extends Collection<? super T>> @NonNull Observable<U>	buffer(@NonNull ObservableSource<? extends TOpening> openingIndicator, @NonNull Function<? super TOpening,? extends ObservableSource<? extends TClosing>> closingIndicator, @NonNull Supplier<U> bufferSupplier) Returns an Observable that emits buffers of items it collects from the current Observable.
<B> @NonNull Observable<List<T>>	buffer(@NonNull ObservableSource<B> boundaryIndicator) Returns an Observable that emits non-overlapping buffered items from the current Observable each time the specified boundary ObservableSource emits an item.
<B> @NonNull Observable<List<T>>	buffer(@NonNull ObservableSource<B> boundaryIndicator, int initialCapacity) Returns an Observable that emits non-overlapping buffered items from the current Observable each time the specified boundary ObservableSource emits an item.
<B,U extends Collection<? super T>> @NonNull Observable<U>	buffer(@NonNull ObservableSource<B> boundaryIndicator, @NonNull Supplier<U> bufferSupplier) Returns an Observable that emits non-overlapping buffered items from the current Observable each time the specified boundary ObservableSource emits an item.
static int	bufferSize() Returns the default 'island' size or capacity-increment hint for unbounded buffers.
@NonNull Observable<T>	cache() Returns an Observable that subscribes to the current Observable lazily, caches all of its events and replays them, in the same order as received, to all the downstream observers.
@NonNull Observable<T>	cacheWithInitialCapacity(int initialCapacity) Returns an Observable that subscribes to the current Observable lazily, caches all of its events and replays them, in the same order as received, to all the downstream observers.
<U> @NonNull Observable<U>	cast(@NonNull Class<U> clazz) Returns an Observable 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 as a Single.
<U> @NonNull Single<U>	collect(@NonNull Supplier<? extends U> initialItemSupplier, @NonNull BiConsumer<? super U,? super T> collector) Collects items emitted by the finite source Observable into a single mutable data structure and returns a Single that emits this structure.
<U> @NonNull Single<U>	collectInto(U initialItem, @NonNull BiConsumer<? super U,? super T> collector) Collects items emitted by the finite source Observable into a single mutable data structure and returns a Single that emits this structure.
static <T,R> @NonNull Observable<R>	combineLatest(@NonNull Iterable<? extends ObservableSource<? extends T>> sources, @NonNull Function<? super Object[],? extends R> combiner) Combines a collection of source ObservableSources by emitting an item that aggregates the latest values of each of the returned ObservableSources each time an item is received from any of the returned ObservableSources, where this aggregation is defined by a specified function.
static <T,R> @NonNull Observable<R>	combineLatest(@NonNull Iterable<? extends ObservableSource<? extends T>> sources, @NonNull Function<? super Object[],? extends R> combiner, int bufferSize) Combines an Iterable of source ObservableSources by emitting an item that aggregates the latest values of each of the returned ObservableSources each time an item is received from any of the returned ObservableSources, where this aggregation is defined by a specified function.
static <T1,T2,R> @NonNull Observable<R>	combineLatest(@NonNull ObservableSource<? extends T1> source1, @NonNull ObservableSource<? extends T2> source2, @NonNull BiFunction<? super T1,? super T2,? extends R> combiner) Combines two source ObservableSources by emitting an item that aggregates the latest values of each of the ObservableSources each time an item is received from either of the ObservableSources, where this aggregation is defined by a specified function.
static <T1,T2,T3,R> @NonNull Observable<R>	combineLatest(@NonNull ObservableSource<? extends T1> source1, @NonNull ObservableSource<? extends T2> source2, @NonNull ObservableSource<? extends T3> source3, @NonNull Function3<? super T1,? super T2,? super T3,? extends R> combiner) Combines three source ObservableSources by emitting an item that aggregates the latest values of each of the ObservableSources each time an item is received from any of the ObservableSources, where this aggregation is defined by a specified function.
static <T1,T2,T3,T4,R> @NonNull Observable<R>	combineLatest(@NonNull ObservableSource<? extends T1> source1, @NonNull ObservableSource<? extends T2> source2, @NonNull ObservableSource<? extends T3> source3, @NonNull ObservableSource<? extends T4> source4, @NonNull Function4<? super T1,? super T2,? super T3,? super T4,? extends R> combiner) Combines four source ObservableSources by emitting an item that aggregates the latest values of each of the ObservableSources each time an item is received from any of the ObservableSources, where this aggregation is defined by a specified function.
static <T1,T2,T3,T4,T5,R> @NonNull Observable<R>	combineLatest(@NonNull ObservableSource<? extends T1> source1, @NonNull ObservableSource<? extends T2> source2, @NonNull ObservableSource<? extends T3> source3, @NonNull ObservableSource<? extends T4> source4, @NonNull ObservableSource<? extends T5> source5, @NonNull Function5<? super T1,? super T2,? super T3,? super T4,? super T5,? extends R> combiner) Combines five source ObservableSources by emitting an item that aggregates the latest values of each of the ObservableSources each time an item is received from any of the ObservableSources, where this aggregation is defined by a specified function.
static <T1,T2,T3,T4,T5,T6,R> @NonNull Observable<R>	combineLatest(@NonNull ObservableSource<? extends T1> source1, @NonNull ObservableSource<? extends T2> source2, @NonNull ObservableSource<? extends T3> source3, @NonNull ObservableSource<? extends T4> source4, @NonNull ObservableSource<? extends T5> source5, @NonNull ObservableSource<? extends T6> source6, @NonNull Function6<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? extends R> combiner) Combines six source ObservableSources by emitting an item that aggregates the latest values of each of the ObservableSources each time an item is received from any of the ObservableSources, where this aggregation is defined by a specified function.
static <T1,T2,T3,T4,T5,T6,T7,R> @NonNull Observable<R>	combineLatest(@NonNull ObservableSource<? extends T1> source1, @NonNull ObservableSource<? extends T2> source2, @NonNull ObservableSource<? extends T3> source3, @NonNull ObservableSource<? extends T4> source4, @NonNull ObservableSource<? extends T5> source5, @NonNull ObservableSource<? extends T6> source6, @NonNull ObservableSource<? 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 ObservableSources by emitting an item that aggregates the latest values of each of the ObservableSources each time an item is received from any of the ObservableSources, where this aggregation is defined by a specified function.
static <T1,T2,T3,T4,T5,T6,T7,T8,R> @NonNull Observable<R>	combineLatest(@NonNull ObservableSource<? extends T1> source1, @NonNull ObservableSource<? extends T2> source2, @NonNull ObservableSource<? extends T3> source3, @NonNull ObservableSource<? extends T4> source4, @NonNull ObservableSource<? extends T5> source5, @NonNull ObservableSource<? extends T6> source6, @NonNull ObservableSource<? extends T7> source7, @NonNull ObservableSource<? 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 ObservableSources by emitting an item that aggregates the latest values of each of the ObservableSources each time an item is received from any of the ObservableSources, where this aggregation is defined by a specified function.
static <T1,T2,T3,T4,T5,T6,T7,T8,T9,R> @NonNull Observable<R>	combineLatest(@NonNull ObservableSource<? extends T1> source1, @NonNull ObservableSource<? extends T2> source2, @NonNull ObservableSource<? extends T3> source3, @NonNull ObservableSource<? extends T4> source4, @NonNull ObservableSource<? extends T5> source5, @NonNull ObservableSource<? extends T6> source6, @NonNull ObservableSource<? extends T7> source7, @NonNull ObservableSource<? extends T8> source8, @NonNull ObservableSource<? 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 ObservableSources by emitting an item that aggregates the latest values of each of the ObservableSources each time an item is received from any of the ObservableSources, where this aggregation is defined by a specified function.
static <T,R> @NonNull Observable<R>	combineLatestArray(@NonNull ObservableSource<? extends T>[] sources, @NonNull Function<? super Object[],? extends R> combiner) Combines an array of source ObservableSources by emitting an item that aggregates the latest values of each of the ObservableSources each time an item is received from any of the returned ObservableSources, where this aggregation is defined by a specified function.
static <T,R> @NonNull Observable<R>	combineLatestArray(@NonNull ObservableSource<? extends T>[] sources, @NonNull Function<? super Object[],? extends R> combiner, int bufferSize) Combines an array of source ObservableSources by emitting an item that aggregates the latest values of each of the ObservableSources each time an item is received from any of the ObservableSources, where this aggregation is defined by a specified function.
static <T,R> @NonNull Observable<R>	combineLatestArrayDelayError(@NonNull ObservableSource<? extends T>[] sources, @NonNull Function<? super Object[],? extends R> combiner) Combines an array of ObservableSources by emitting an item that aggregates the latest values of each of the ObservableSources each time an item is received from any of the ObservableSources, where this aggregation is defined by a specified function.
static <T,R> @NonNull Observable<R>	combineLatestArrayDelayError(@NonNull ObservableSource<? extends T>[] sources, @NonNull Function<? super Object[],? extends R> combiner, int bufferSize) Combines an array of ObservableSources by emitting an item that aggregates the latest values of each of the ObservableSources each time an item is received from any of the ObservableSources, where this aggregation is defined by a specified function and delays any error from the sources until all source ObservableSources terminate.
static <T,R> @NonNull Observable<R>	combineLatestDelayError(@NonNull Iterable<? extends ObservableSource<? extends T>> sources, @NonNull Function<? super Object[],? extends R> combiner) Combines an Iterable of ObservableSources by emitting an item that aggregates the latest values of each of the ObservableSources each time an item is received from any of the ObservableSources, where this aggregation is defined by a specified function and delays any error from the sources until all source ObservableSources terminate.
static <T,R> @NonNull Observable<R>	combineLatestDelayError(@NonNull Iterable<? extends ObservableSource<? extends T>> sources, @NonNull Function<? super Object[],? extends R> combiner, int bufferSize) Combines an Iterable of ObservableSources by emitting an item that aggregates the latest values of each of the ObservableSources each time an item is received from any of the ObservableSources, where this aggregation is defined by a specified function and delays any error from the sources until all source ObservableSources terminate.
<R> @NonNull Observable<R>	compose(@NonNull ObservableTransformer<? super T,? extends R> composer) Transform the current Observable by applying a particular ObservableTransformer function to it.
static <T> @NonNull Observable<T>	concat(@NonNull Iterable<? extends ObservableSource<? extends T>> sources) Concatenates elements of each ObservableSource provided via an Iterable sequence into a single sequence of elements without interleaving them.
static <T> @NonNull Observable<T>	concat(@NonNull ObservableSource<? extends ObservableSource<? extends T>> sources) Returns an Observable that emits the items emitted by each of the ObservableSources emitted by the ObservableSource, one after the other, without interleaving them.
static <T> @NonNull Observable<T>	concat(@NonNull ObservableSource<? extends ObservableSource<? extends T>> sources, int bufferSize) Returns an Observable that emits the items emitted by each of the ObservableSources emitted by the outer ObservableSource, one after the other, without interleaving them.
static <T> @NonNull Observable<T>	concat(@NonNull ObservableSource<? extends T> source1, ObservableSource<? extends T> source2) Returns an Observable that emits the items emitted by two ObservableSources, one after the other, without interleaving them.
static <T> @NonNull Observable<T>	concat(@NonNull ObservableSource<? extends T> source1, @NonNull ObservableSource<? extends T> source2, @NonNull ObservableSource<? extends T> source3) Returns an Observable that emits the items emitted by three ObservableSources, one after the other, without interleaving them.
static <T> @NonNull Observable<T>	concat(@NonNull ObservableSource<? extends T> source1, @NonNull ObservableSource<? extends T> source2, @NonNull ObservableSource<? extends T> source3, @NonNull ObservableSource<? extends T> source4) Returns an Observable that emits the items emitted by four ObservableSources, one after the other, without interleaving them.
static <T> @NonNull Observable<T>	concatArray(ObservableSource<? extends T>... sources) Concatenates a variable number of ObservableSource sources.
static <T> @NonNull Observable<T>	concatArrayDelayError(ObservableSource<? extends T>... sources) Concatenates a variable number of ObservableSource sources and delays errors from any of them till all terminate.
static <T> @NonNull Observable<T>	concatArrayEager(int maxConcurrency, int bufferSize, ObservableSource<? extends T>... sources) Concatenates an array of ObservableSources eagerly into a single stream of values.
static <T> @NonNull Observable<T>	concatArrayEager(ObservableSource<? extends T>... sources) Concatenates an array of ObservableSources eagerly into a single stream of values.
static <T> @NonNull Observable<T>	concatArrayEagerDelayError(int maxConcurrency, int bufferSize, ObservableSource<? extends T>... sources) Concatenates an array of ObservableSources eagerly into a single stream of values and delaying any errors until all sources terminate.
static <T> @NonNull Observable<T>	concatArrayEagerDelayError(ObservableSource<? extends T>... sources) Concatenates an array of ObservableSources eagerly into a single stream of values and delaying any errors until all sources terminate.
static <T> @NonNull Observable<T>	concatDelayError(@NonNull Iterable<? extends ObservableSource<? extends T>> sources) Concatenates the Iterable sequence of ObservableSources into a single Observable sequence by subscribing to each ObservableSource, one after the other, one at a time and delays any errors till the all inner ObservableSources terminate.
static <T> @NonNull Observable<T>	concatDelayError(@NonNull ObservableSource<? extends ObservableSource<? extends T>> sources) Concatenates the ObservableSource sequence of ObservableSources into a single Observable sequence by subscribing to each inner ObservableSource, one after the other, one at a time and delays any errors till the all inner and the outer ObservableSources terminate.
static <T> @NonNull Observable<T>	concatDelayError(@NonNull ObservableSource<? extends ObservableSource<? extends T>> sources, int bufferSize, boolean tillTheEnd) Concatenates the ObservableSource sequence of ObservableSources into a single sequence by subscribing to each inner ObservableSource, one after the other, one at a time and delays any errors till the all inner and the outer ObservableSources terminate.
static <T> @NonNull Observable<T>	concatEager(@NonNull Iterable<? extends ObservableSource<? extends T>> sources) Concatenates a sequence of ObservableSources eagerly into a single stream of values.
static <T> @NonNull Observable<T>	concatEager(@NonNull Iterable<? extends ObservableSource<? extends T>> sources, int maxConcurrency, int bufferSize) Concatenates a sequence of ObservableSources eagerly into a single stream of values and runs a limited number of inner sequences at once.
static <T> @NonNull Observable<T>	concatEager(@NonNull ObservableSource<? extends ObservableSource<? extends T>> sources) Concatenates an ObservableSource sequence of ObservableSources eagerly into a single stream of values.
static <T> @NonNull Observable<T>	concatEager(@NonNull ObservableSource<? extends ObservableSource<? extends T>> sources, int maxConcurrency, int bufferSize) Concatenates an ObservableSource sequence of ObservableSources eagerly into a single stream of values and runs a limited number of inner sequences at once.
static <T> @NonNull Observable<T>	concatEagerDelayError(@NonNull Iterable<? extends ObservableSource<? extends T>> sources) Concatenates a sequence of ObservableSources eagerly into a single stream of values, delaying errors until all the inner sequences terminate.
static <T> @NonNull Observable<T>	concatEagerDelayError(@NonNull Iterable<? extends ObservableSource<? extends T>> sources, int maxConcurrency, int bufferSize) Concatenates a sequence of ObservableSources 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 Observable<T>	concatEagerDelayError(@NonNull ObservableSource<? extends ObservableSource<? extends T>> sources) Concatenates an ObservableSource sequence of ObservableSources eagerly into a single stream of values, delaying errors until all the inner and the outer sequence terminate.
static <T> @NonNull Observable<T>	concatEagerDelayError(@NonNull ObservableSource<? extends ObservableSource<? extends T>> sources, int maxConcurrency, int bufferSize) Concatenates an ObservableSource sequence of ObservableSources eagerly into a single stream of values, delaying errors until all the inner and the outer sequence terminate and runs a limited number of inner sequences at once.
<R> @NonNull Observable<R>	concatMap(@NonNull Function<? super T,? extends ObservableSource<? extends R>> mapper) Returns a new Observable that emits items resulting from applying a function that you supply to each item emitted by the current Observable, where that function returns an ObservableSource, and then emitting the items that result from concatenating those returned ObservableSources.
<R> @NonNull Observable<R>	concatMap(@NonNull Function<? super T,? extends ObservableSource<? extends R>> mapper, int bufferSize) Returns a new Observable that emits items resulting from applying a function that you supply to each item emitted by the current Observable, where that function returns an ObservableSource, and then emitting the items that result from concatenating those returned ObservableSources.
<R> @NonNull Observable<R>	concatMap(@NonNull Function<? super T,? extends ObservableSource<? extends R>> mapper, int bufferSize, @NonNull Scheduler scheduler) Returns a new Observable that emits items resulting from applying a function that you supply to each item emitted by the current Observable, where that function returns an ObservableSource, and then emitting the items that result from concatenating those returned ObservableSources.
@NonNull Completable	concatMapCompletable(@NonNull Function<? super T,? extends CompletableSource> mapper) Maps each element of the current Observable into CompletableSources, subscribes to them one at a time in order and waits until the upstream and all CompletableSources complete.
@NonNull Completable	concatMapCompletable(@NonNull Function<? super T,? extends CompletableSource> mapper, int capacityHint) Maps each element of the current Observable into CompletableSources, subscribes to them one at a time in order and waits until the upstream and all CompletableSources complete.
@NonNull Completable	concatMapCompletableDelayError(@NonNull Function<? super T,? extends CompletableSource> mapper) Maps the upstream items into CompletableSources and subscribes to them one after the other terminates, delaying all errors till both the current Observable and all inner CompletableSources terminate.
@NonNull Completable	concatMapCompletableDelayError(@NonNull Function<? super T,? extends CompletableSource> mapper, boolean tillTheEnd) Maps the upstream items into CompletableSources and subscribes to them one after the other terminates, optionally delaying all errors till both the current Observable and all inner CompletableSources terminate.
@NonNull Completable	concatMapCompletableDelayError(@NonNull Function<? super T,? extends CompletableSource> mapper, boolean tillTheEnd, int bufferSize) Maps the upstream items into CompletableSources and subscribes to them one after the other terminates, optionally delaying all errors till both the current Observable and all inner CompletableSources terminate.
<R> @NonNull Observable<R>	concatMapDelayError(@NonNull Function<? super T,? extends ObservableSource<? extends R>> mapper) Maps each of the items into an ObservableSource, 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 ObservableSources till all of them terminate.
<R> @NonNull Observable<R>	concatMapDelayError(@NonNull Function<? super T,? extends ObservableSource<? extends R>> mapper, boolean tillTheEnd, int bufferSize) Maps each of the items into an ObservableSource, 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 ObservableSources till all of them terminate.
<R> @NonNull Observable<R>	concatMapDelayError(@NonNull Function<? super T,? extends ObservableSource<? extends R>> mapper, boolean tillTheEnd, int bufferSize, @NonNull Scheduler scheduler) Maps each of the items into an ObservableSource, 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 ObservableSources till all of them terminate.
<R> @NonNull Observable<R>	concatMapEager(@NonNull Function<? super T,? extends ObservableSource<? extends R>> mapper) Maps a sequence of values into ObservableSources and concatenates these ObservableSources eagerly into a single Observable sequence.
<R> @NonNull Observable<R>	concatMapEager(@NonNull Function<? super T,? extends ObservableSource<? extends R>> mapper, int maxConcurrency, int bufferSize) Maps a sequence of values into ObservableSources and concatenates these ObservableSources eagerly into a single Observable sequence.
<R> @NonNull Observable<R>	concatMapEagerDelayError(@NonNull Function<? super T,? extends ObservableSource<? extends R>> mapper, boolean tillTheEnd) Maps a sequence of values into ObservableSources and concatenates these ObservableSources eagerly into a single Observable sequence.
<R> @NonNull Observable<R>	concatMapEagerDelayError(@NonNull Function<? super T,? extends ObservableSource<? extends R>> mapper, boolean tillTheEnd, int maxConcurrency, int bufferSize) Maps a sequence of values into ObservableSources and concatenates these ObservableSources eagerly into a single Observable sequence.
<U> @NonNull Observable<U>	concatMapIterable(@NonNull Function<? super T,? extends Iterable<? extends U>> mapper) Returns an Observable that concatenate each item emitted by the current Observable with the values in an Iterable corresponding to that item that is generated by a selector.
<R> @NonNull Observable<R>	concatMapMaybe(@NonNull Function<? super T,? extends MaybeSource<? extends R>> mapper) Maps the upstream items into MaybeSources and subscribes to them one after the other succeeds or completes, emits their success value if available or terminates immediately if either the current Observable or the current inner MaybeSource fail.
<R> @NonNull Observable<R>	concatMapMaybe(@NonNull Function<? super T,? extends MaybeSource<? extends R>> mapper, int bufferSize) Maps the upstream items into MaybeSources and subscribes to them one after the other succeeds or completes, emits their success value if available or terminates immediately if either the current Observable or the current inner MaybeSource fail.
<R> @NonNull Observable<R>	concatMapMaybeDelayError(@NonNull Function<? super T,? extends MaybeSource<? extends R>> mapper) Maps the upstream items into MaybeSources and subscribes to them one after the other terminates, emits their success value if available and delaying all errors till both the current Observable and all inner MaybeSources terminate.
<R> @NonNull Observable<R>	concatMapMaybeDelayError(@NonNull Function<? super T,? extends MaybeSource<? extends R>> mapper, boolean tillTheEnd) Maps the upstream items into MaybeSources and subscribes to them one after the other terminates, emits their success value if available and optionally delaying all errors till both the current Observable and all inner MaybeSources terminate.
<R> @NonNull Observable<R>	concatMapMaybeDelayError(@NonNull Function<? super T,? extends MaybeSource<? extends R>> mapper, boolean tillTheEnd, int bufferSize) Maps the upstream items into MaybeSources and subscribes to them one after the other terminates, emits their success value if available and optionally delaying all errors till both the current Observable and all inner MaybeSources terminate.
<R> @NonNull Observable<R>	concatMapSingle(@NonNull Function<? super T,? extends SingleSource<? extends R>> mapper) Maps the upstream items into SingleSources and subscribes to them one after the other succeeds, emits their success values or terminates immediately if either the current Observable or the current inner SingleSource fail.
<R> @NonNull Observable<R>	concatMapSingle(@NonNull Function<? super T,? extends SingleSource<? extends R>> mapper, int bufferSize) Maps the upstream items into SingleSources and subscribes to them one after the other succeeds, emits their success values or terminates immediately if either the current Observable or the current inner SingleSource fail.
<R> @NonNull Observable<R>	concatMapSingleDelayError(@NonNull Function<? super T,? extends SingleSource<? extends R>> mapper) Maps the upstream items into SingleSources and subscribes to them one after the other succeeds or fails, emits their success values and delays all errors till both the current Observable and all inner SingleSources terminate.
<R> @NonNull Observable<R>	concatMapSingleDelayError(@NonNull Function<? super T,? extends SingleSource<? extends R>> mapper, boolean tillTheEnd) Maps the upstream items into SingleSources and subscribes to them one after the other succeeds or fails, emits their success values and optionally delays all errors till both the current Observable and all inner SingleSources terminate.
<R> @NonNull Observable<R>	concatMapSingleDelayError(@NonNull Function<? super T,? extends SingleSource<? extends R>> mapper, boolean tillTheEnd, int bufferSize) Maps the upstream items into SingleSources and subscribes to them one after the other succeeds or fails, emits their success values and optionally delays errors till both the current Observable and all inner SingleSources terminate.
<R> @NonNull Observable<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.
@NonNull Observable<T>	concatWith(@NonNull CompletableSource other) Returns an Observable that emits items from the current Observable and when it completes normally, the other CompletableSource is subscribed to and the returned Observable emits its terminal events.
@NonNull Observable<T>	concatWith(@NonNull MaybeSource<? extends T> other) Returns an Observable that emits the items from the current Observable followed by the success item or terminal events of the other MaybeSource.
@NonNull Observable<T>	concatWith(@NonNull ObservableSource<? extends T> other) Returns an Observable that first emits the items emitted from the current Observable, then items from the other ObservableSource without interleaving them.
@NonNull Observable<T>	concatWith(@NonNull SingleSource<? extends T> other) Returns an Observable that emits the items from the current Observable followed by the success item or error event of the other SingleSource.
@NonNull Single<Boolean>	contains(@NonNull Object item) Returns a Single that emits a Boolean that indicates whether the current Observable emitted a specified item.
@NonNull Single<Long>	count() Returns a Single that counts the total number of items emitted by the current Observable and emits this count as a 64-bit Long.
static <T> @NonNull Observable<T>	create(@NonNull ObservableOnSubscribe<T> source) Provides an API (via a cold Observable) that bridges the reactive world with the callback-style world.
<U> @NonNull Observable<T>	debounce(@NonNull Function<? super T,? extends ObservableSource<U>> debounceIndicator) Returns an Observable that mirrors the current Observable, except that it drops items emitted by the current Observable that are followed by another item within a computed debounce duration denoted by an item emission or completion from a generated inner ObservableSource for that original item.
@NonNull Observable<T>	debounce(long timeout, @NonNull TimeUnit unit) Returns an Observable that mirrors the current Observable, except that it drops items emitted by the current Observable that are followed by newer items before a timeout value expires.
@NonNull Observable<T>	debounce(long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler) Returns an Observable that mirrors the current Observable, except that it drops items emitted by the current Observable that are followed by newer items before a timeout value expires on a specified Scheduler.
@NonNull Observable<T>	debounce(long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, @NonNull Consumer<? super T> onDropped) Returns an Observable that mirrors the current Observable, except that it drops items emitted by the current Observable that are followed by newer items before a timeout value expires on a specified Scheduler.
@NonNull Observable<T>	defaultIfEmpty(T defaultItem) Returns an Observable that emits the items emitted by the current Observable or a specified default item if the current Observable is empty.
static <T> @NonNull Observable<T>	defer(@NonNull Supplier<? extends ObservableSource<? extends T>> supplier) Returns an Observable that calls an ObservableSource factory to create an ObservableSource for each new Observer that subscribes.
<U> @NonNull Observable<T>	delay(@NonNull Function<? super T,? extends ObservableSource<U>> itemDelayIndicator) Returns an Observable that delays the emissions of the current Observable via a per-item derived ObservableSource's item emission or termination, on a per source item basis.
@NonNull Observable<T>	delay(long time, @NonNull TimeUnit unit) Returns an Observable that emits the items emitted by the current Observable shifted forward in time by a specified delay.
@NonNull Observable<T>	delay(long time, @NonNull TimeUnit unit, boolean delayError) Returns an Observable that emits the items emitted by the current Observable shifted forward in time by a specified delay.
@NonNull Observable<T>	delay(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler) Returns an Observable that emits the items emitted by the current Observable shifted forward in time by a specified delay.
@NonNull Observable<T>	delay(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean delayError) Returns an Observable that emits the items emitted by the current Observable shifted forward in time by a specified delay.
<U,V> @NonNull Observable<T>	delay(@NonNull ObservableSource<U> subscriptionIndicator, @NonNull Function<? super T,? extends ObservableSource<V>> itemDelayIndicator) Returns an Observable that delays the subscription to and emissions from the current Observable via ObservableSources for the subscription itself and on a per-item basis.
@NonNull Observable<T>	delaySubscription(long time, @NonNull TimeUnit unit) Returns an Observable that delays the subscription to the current Observable by a given amount of time.
@NonNull Observable<T>	delaySubscription(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler) Returns an Observable that delays the subscription to the current Observable by a given amount of time, both waiting and subscribing on a given Scheduler.
<U> @NonNull Observable<T>	delaySubscription(@NonNull ObservableSource<U> subscriptionIndicator) Returns an Observable that delays the subscription to the current Observable until the other ObservableSource emits an element or completes normally.
<R> @NonNull Observable<R>	dematerialize(@NonNull Function<? super T,Notification<R>> selector) Returns an Observable that reverses the effect of materialize by transforming the Notification objects extracted from the source items via a selector function into their respective Observer signal types.
@NonNull Observable<T>	distinct() Returns an Observable that emits all items emitted by the current Observable that are distinct based on Object.equals(Object) comparison.
<K> @NonNull Observable<T>	distinct(@NonNull Function<? super T,K> keySelector) Returns an Observable that emits all items emitted by the current Observable that are distinct according to a key selector function and based on Object.equals(Object) comparison of the objects returned by the key selector function.
<K> @NonNull Observable<T>	distinct(@NonNull Function<? super T,K> keySelector, @NonNull Supplier<? extends Collection<? super K>> collectionSupplier) Returns an Observable that emits all items emitted by the current Observable that are distinct according to a key selector function and based on Object.equals(Object) comparison of the objects returned by the key selector function.
@NonNull Observable<T>	distinctUntilChanged() Returns an Observable that emits all items emitted by the current Observable that are distinct from their immediate predecessors based on Object.equals(Object) comparison.
@NonNull Observable<T>	distinctUntilChanged(@NonNull BiPredicate<? super T,? super T> comparer) Returns an Observable that emits all items emitted by the current Observable that are distinct from their immediate predecessors when compared with each other via the provided comparator function.
<K> @NonNull Observable<T>	distinctUntilChanged(@NonNull Function<? super T,K> keySelector) Returns an Observable that emits all items emitted by the current Observable that are distinct from their immediate predecessors, according to a key selector function and based on Object.equals(Object) comparison of those objects returned by the key selector function.
@NonNull Observable<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 Observable<T>	doAfterTerminate(@NonNull Action onAfterTerminate) Registers an Action to be called when the current Observable invokes either onComplete or onError.
@NonNull Observable<T>	doFinally(@NonNull Action onFinally) Calls the specified action after the current Observable signals onError or onCompleted or gets disposed by the downstream.
@NonNull Observable<T>	doOnComplete(@NonNull Action onComplete) Returns an Observable that invokes an Action when the current Observable calls onComplete.
@NonNull Observable<T>	doOnDispose(@NonNull Action onDispose) Calls the given shared Action if the downstream disposes the sequence.
@NonNull Observable<T>	doOnEach(@NonNull Consumer<? super Notification<T>> onNotification) Returns an Observable that invokes a Consumer with the appropriate Notification object when the current Observable signals an item or terminates.
@NonNull Observable<T>	doOnEach(@NonNull Observer<? super T> observer) Returns an Observable that forwards the items and terminal events of the current Observable to its Observers and to the given shared Observer instance.
@NonNull Observable<T>	doOnError(@NonNull Consumer<? super Throwable> onError) Calls the given Consumer with the error Throwable if the current Observable failed before forwarding it to the downstream.
@NonNull Observable<T>	doOnLifecycle(@NonNull Consumer<? super Disposable> onSubscribe, @NonNull Action onDispose) Calls the appropriate onXXX method (shared between all Observers) for the lifecycle events of the sequence (subscription, disposal).
@NonNull Observable<T>	doOnNext(@NonNull Consumer<? super T> onNext) Calls the given Consumer with the value emitted by the current Observable before forwarding it to the downstream.
@NonNull Observable<T>	doOnSubscribe(@NonNull Consumer<? super Disposable> onSubscribe) Returns an Observable so that it invokes the given Consumer when the current Observable is subscribed from its Observers.
@NonNull Observable<T>	doOnTerminate(@NonNull Action onTerminate) Returns an Observable so that it invokes an action when the current Observable calls onComplete or onError.
@NonNull Maybe<T>	elementAt(long index) Returns a Maybe that emits the single item at a specified index in a sequence of emissions from the current Observable or completes if the current Observable signals 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 the current Observable, 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 the current Observable or signals a NoSuchElementException if the current Observable signals fewer elements than index.
static <T> @NonNull Observable<T>	empty() Returns an Observable that emits no items to the Observer and immediately invokes its onComplete method.
static <T> @NonNull Observable<T>	error(@NonNull Supplier<? extends Throwable> supplier) Returns an Observable that invokes an Observer's onError method when the Observer subscribes to it.
static <T> @NonNull Observable<T>	error(@NonNull Throwable throwable) Returns an Observable that invokes an Observer's onError method when the Observer subscribes to it.
@NonNull Observable<T>	filter(@NonNull Predicate<? super T> predicate) Filters items emitted by the current Observable 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 the current Observable, or a default item if the current Observable completes without emitting any items.
@NonNull Maybe<T>	firstElement() Returns a Maybe that emits only the very first item emitted by the current Observable, or completes if the current Observable is empty.
@NonNull Single<T>	firstOrError() Returns a Single that emits only the very first item emitted by the current Observable or signals a NoSuchElementException if the current Observable is empty.
@NonNull CompletionStage<T>	firstOrErrorStage() Signals the first upstream item or a NoSuchElementException if the upstream is empty via a CompletionStage.
@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 Observable<R>	flatMap(@NonNull Function<? super T,? extends ObservableSource<? extends R>> mapper) Returns an Observable that emits items based on applying a function that you supply to each item emitted by the current Observable, where that function returns an ObservableSource, and then merging those returned ObservableSources and emitting the results of this merger.
<R> @NonNull Observable<R>	flatMap(@NonNull Function<? super T,? extends ObservableSource<? extends R>> mapper, boolean delayErrors) Returns an Observable that emits items based on applying a function that you supply to each item emitted by the current Observable, where that function returns an ObservableSource, and then merging those returned ObservableSources and emitting the results of this merger.
<R> @NonNull Observable<R>	flatMap(@NonNull Function<? super T,? extends ObservableSource<? extends R>> mapper, boolean delayErrors, int maxConcurrency) Returns an Observable that emits items based on applying a function that you supply to each item emitted by the current Observable, where that function returns an ObservableSource, and then merging those returned ObservableSources and emitting the results of this merger, while limiting the maximum number of concurrent subscriptions to these ObservableSources.
<R> @NonNull Observable<R>	flatMap(@NonNull Function<? super T,? extends ObservableSource<? extends R>> mapper, boolean delayErrors, int maxConcurrency, int bufferSize) Returns an Observable that emits items based on applying a function that you supply to each item emitted by the current Observable, where that function returns an ObservableSource, and then merging those returned ObservableSources and emitting the results of this merger, while limiting the maximum number of concurrent subscriptions to these ObservableSources.
<R> @NonNull Observable<R>	flatMap(@NonNull Function<? super T,? extends ObservableSource<? extends R>> onNextMapper, @NonNull Function<? super Throwable,? extends ObservableSource<? extends R>> onErrorMapper, @NonNull Supplier<? extends ObservableSource<? extends R>> onCompleteSupplier) Returns an Observable that applies a function to each item emitted or notification raised by the current Observable and then flattens the ObservableSources returned from these functions and emits the resulting items.
<R> @NonNull Observable<R>	flatMap(@NonNull Function<? super T,? extends ObservableSource<? extends R>> onNextMapper, @NonNull Function<Throwable,? extends ObservableSource<? extends R>> onErrorMapper, @NonNull Supplier<? extends ObservableSource<? extends R>> onCompleteSupplier, int maxConcurrency) Returns an Observable that applies a function to each item emitted or notification raised by the current Observable and then flattens the ObservableSources returned from these functions and emits the resulting items, while limiting the maximum number of concurrent subscriptions to these ObservableSources.
<R> @NonNull Observable<R>	flatMap(@NonNull Function<? super T,? extends ObservableSource<? extends R>> mapper, int maxConcurrency) Returns an Observable that emits items based on applying a function that you supply to each item emitted by the current Observable, where that function returns an ObservableSource, and then merging those returned ObservableSources and emitting the results of this merger, while limiting the maximum number of concurrent subscriptions to these ObservableSources.
<U,R> @NonNull Observable<R>	flatMap(@NonNull Function<? super T,? extends ObservableSource<? extends U>> mapper, @NonNull BiFunction<? super T,? super U,? extends R> combiner) Returns an Observable that emits the results of a specified function to the pair of values emitted by the current Observable and the mapped inner ObservableSource.
<U,R> @NonNull Observable<R>	flatMap(@NonNull Function<? super T,? extends ObservableSource<? extends U>> mapper, @NonNull BiFunction<? super T,? super U,? extends R> combiner, boolean delayErrors) Returns an Observable that emits the results of a specified function to the pair of values emitted by the current Observable and the mapped inner ObservableSource.
<U,R> @NonNull Observable<R>	flatMap(@NonNull Function<? super T,? extends ObservableSource<? extends U>> mapper, @NonNull BiFunction<? super T,? super U,? extends R> combiner, boolean delayErrors, int maxConcurrency) Returns an Observable that emits the results of a specified function to the pair of values emitted by the current Observable and the mapped inner ObservableSource, while limiting the maximum number of concurrent subscriptions to these ObservableSources.
<U,R> @NonNull Observable<R>	flatMap(@NonNull Function<? super T,? extends ObservableSource<? extends U>> mapper, @NonNull BiFunction<? super T,? super U,? extends R> combiner, boolean delayErrors, int maxConcurrency, int bufferSize) Returns an Observable that emits the results of a specified function to the pair of values emitted by the current Observable and the mapped inner ObservableSource, while limiting the maximum number of concurrent subscriptions to these ObservableSources.
<U,R> @NonNull Observable<R>	flatMap(@NonNull Function<? super T,? extends ObservableSource<? extends U>> mapper, @NonNull BiFunction<? super T,? super U,? extends R> combiner, int maxConcurrency) Returns an Observable that emits the results of a specified function to the pair of values emitted by the current Observable and the mapped inner ObservableSource, while limiting the maximum number of concurrent subscriptions to these ObservableSources.
@NonNull Completable	flatMapCompletable(@NonNull Function<? super T,? extends CompletableSource> mapper) Maps each element of the current Observable into CompletableSources, subscribes to them and waits until the upstream and all CompletableSources complete.
@NonNull Completable	flatMapCompletable(@NonNull Function<? super T,? extends CompletableSource> mapper, boolean delayErrors) Maps each element of the current Observable into CompletableSources, subscribes to them and waits until the upstream and all CompletableSources complete, optionally delaying all errors.
<U> @NonNull Observable<U>	flatMapIterable(@NonNull Function<? super T,? extends Iterable<? extends U>> mapper) Merges Iterables generated by a mapper Function for each individual item emitted by the current Observable into a single Observable sequence.
<U,V> @NonNull Observable<V>	flatMapIterable(@NonNull Function<? super T,? extends Iterable<? extends U>> mapper, @NonNull BiFunction<? super T,? super U,? extends V> combiner) Merges Iterables generated by a mapper Function for each individual item emitted by the current Observable into a single Observable 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.
<R> @NonNull Observable<R>	flatMapMaybe(@NonNull Function<? super T,? extends MaybeSource<? extends R>> mapper) Maps each element of the current Observable into MaybeSources, subscribes to all of them and merges their onSuccess values, in no particular order, into a single Observable sequence.
<R> @NonNull Observable<R>	flatMapMaybe(@NonNull Function<? super T,? extends MaybeSource<? extends R>> mapper, boolean delayErrors) Maps each element of the current Observable into MaybeSources, subscribes to them and merges their onSuccess values, in no particular order, into a single Observable sequence, optionally delaying all errors.
<R> @NonNull Observable<R>	flatMapSingle(@NonNull Function<? super T,? extends SingleSource<? extends R>> mapper) Maps each element of the current Observable into SingleSources, subscribes to all of them and merges their onSuccess values, in no particular order, into a single Observable sequence.
<R> @NonNull Observable<R>	flatMapSingle(@NonNull Function<? super T,? extends SingleSource<? extends R>> mapper, boolean delayErrors) Maps each element of the current Observable into SingleSources, subscribes to them and merges their onSuccess values, in no particular order, into a single Observable sequence, optionally delaying all errors.
<R> @NonNull Observable<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.
@NonNull Disposable	forEach(@NonNull Consumer<? super T> onNext) Subscribes to the ObservableSource and calls a Consumer for each item of the current Observable on its emission thread.
@NonNull Disposable	forEachWhile(@NonNull Predicate<? super T> onNext) Subscribes to the ObservableSource and calls a Predicate for each item of the current Observable, on its emission thread, until the predicate returns false.
@NonNull Disposable	forEachWhile(@NonNull Predicate<? super T> onNext, @NonNull Consumer<? super Throwable> onError) Subscribes to the ObservableSource and calls a Predicate for each item or a Consumer with the error of the current Observable, on their original emission threads, until the predicate returns false.
@NonNull Disposable	forEachWhile(@NonNull Predicate<? super T> onNext, @NonNull Consumer<? super Throwable> onError, @NonNull Action onComplete) Subscribes to the ObservableSource and calls a Predicate for each item, a Consumer with the error or an Action upon completion of the current Observable, on their original emission threads, until the predicate returns false.
static <T> @NonNull Observable<T>	fromAction(@NonNull Action action) Returns an Observable instance that runs the given Action for each Observer and emits either its exception or simply completes.
static <T> @NonNull Observable<T>	fromArray(T... items) Converts an array into an ObservableSource that emits the items in the array.
static <T> @NonNull Observable<T>	fromCallable(@NonNull Callable<? extends T> callable) Returns an Observable that, when an observer subscribes to it, invokes a function you specify and then emits the value returned from that function.
static <T> @NonNull Observable<T>	fromCompletable(@NonNull CompletableSource completableSource) Wraps a CompletableSource into an Observable.
static <T> @NonNull Observable<T>	fromCompletionStage(@NonNull CompletionStage<T> stage) Signals the completion value or error of the given (hot) CompletionStage-based asynchronous calculation.
static <T> @NonNull Observable<T>	fromFuture(@NonNull Future<? extends T> future) Converts a Future into an Observable.
static <T> @NonNull Observable<T>	fromFuture(@NonNull Future<? extends T> future, long timeout, @NonNull TimeUnit unit) Converts a Future into an Observable, with a timeout on the Future.
static <T> @NonNull Observable<T>	fromIterable(@NonNull Iterable<? extends T> source) Converts an Iterable sequence into an Observable that emits the items in the sequence.
static <T> @NonNull Observable<T>	fromMaybe(@NonNull MaybeSource<T> maybe) Returns an Observable instance that when subscribed to, subscribes to the MaybeSource instance and emits onSuccess as a single item or forwards any onComplete or onError signal.
static <T> @NonNull Observable<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() Observable instance.
static <T> @NonNull Observable<T>	fromPublisher(@NonNull Publisher<? extends T> publisher) Converts an arbitrary Reactive Streams Publisher into an Observable.
static <T> @NonNull Observable<T>	fromRunnable(@NonNull Runnable run) Returns an Observable instance that runs the given Runnable for each Observer and emits either its unchecked exception or simply completes.
static <T> @NonNull Observable<T>	fromSingle(@NonNull SingleSource<T> source) Returns an Observable instance that when subscribed to, subscribes to the SingleSource instance and emits onSuccess as a single item or forwards the onError signal.
static <T> @NonNull Observable<T>	fromStream(@NonNull Stream<T> stream) Converts a Stream into a finite Observable and emits its items in the sequence.
static <T> @NonNull Observable<T>	fromSupplier(@NonNull Supplier<? extends T> supplier) Returns an Observable that, when an observer subscribes to it, invokes a supplier function you specify and then emits the value returned from that function.
static <T> @NonNull Observable<T>	generate(@NonNull Consumer<Emitter<T>> generator) Returns a cold, synchronous and stateless generator of values.
static <T,S> @NonNull Observable<T>	generate(@NonNull Supplier<S> initialState, @NonNull BiConsumer<S,Emitter<T>> generator) Returns a cold, synchronous and stateful generator of values.
static <T,S> @NonNull Observable<T>	generate(@NonNull Supplier<S> initialState, @NonNull BiConsumer<S,Emitter<T>> generator, @NonNull Consumer<? super S> disposeState) Returns a cold, synchronous and stateful generator of values.
static <T,S> @NonNull Observable<T>	generate(@NonNull Supplier<S> initialState, @NonNull BiFunction<S,Emitter<T>,S> generator) Returns a cold, synchronous and stateful generator of values.
static <T,S> @NonNull Observable<T>	generate(@NonNull Supplier<S> initialState, @NonNull BiFunction<S,Emitter<T>,S> generator, @NonNull Consumer<? super S> disposeState) Returns a cold, synchronous and stateful generator of values.
<K> @NonNull Observable<GroupedObservable<K,T>>	groupBy(@NonNull Function<? super T,? extends K> keySelector) Groups the items emitted by the current Observable according to a specified criterion, and emits these grouped items as GroupedObservables.
<K> @NonNull Observable<GroupedObservable<K,T>>	groupBy(@NonNull Function<? super T,? extends K> keySelector, boolean delayError) Groups the items emitted by the current Observable according to a specified criterion, and emits these grouped items as GroupedObservables.
<K,V> @NonNull Observable<GroupedObservable<K,V>>	groupBy(@NonNull Function<? super T,? extends K> keySelector, Function<? super T,? extends V> valueSelector) Groups the items emitted by the current Observable according to a specified criterion, and emits these grouped items as GroupedObservables.
<K,V> @NonNull Observable<GroupedObservable<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 Observable according to a specified criterion, and emits these grouped items as GroupedObservables.
<K,V> @NonNull Observable<GroupedObservable<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 Observable according to a specified criterion, and emits these grouped items as GroupedObservables.
<TRight,TLeftEnd,TRightEnd,R> @NonNull Observable<R>	groupJoin(@NonNull ObservableSource<? extends TRight> other, @NonNull Function<? super T,? extends ObservableSource<TLeftEnd>> leftEnd, @NonNull Function<? super TRight,? extends ObservableSource<TRightEnd>> rightEnd, @NonNull BiFunction<? super T,? super Observable<TRight>,? extends R> resultSelector) Returns an Observable that correlates two ObservableSources when they overlap in time and groups the results.
@NonNull Observable<T>	hide() Hides the identity of the current Observable and its Disposable.
@NonNull Completable	ignoreElements() Ignores all items emitted by the current Observable and only calls onComplete or onError.
static @NonNull Observable<Long>	interval(long initialDelay, long period, @NonNull TimeUnit unit) Returns an Observable that emits a 0L after the initialDelay and ever increasing numbers after each period of time thereafter.
static @NonNull Observable<Long>	interval(long initialDelay, long period, @NonNull TimeUnit unit, @NonNull Scheduler scheduler) Returns an Observable that emits a 0L after the initialDelay and ever increasing numbers after each period of time thereafter, on a specified Scheduler.
static @NonNull Observable<Long>	interval(long period, @NonNull TimeUnit unit) Returns an Observable that emits a sequential number every specified interval of time.
static @NonNull Observable<Long>	interval(long period, @NonNull TimeUnit unit, @NonNull Scheduler scheduler) Returns an Observable that emits a sequential number every specified interval of time, on a specified Scheduler.
static @NonNull Observable<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 Observable<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 Observable is empty, otherwise false.
<TRight,TLeftEnd,TRightEnd,R> @NonNull Observable<R>	join(@NonNull ObservableSource<? extends TRight> other, @NonNull Function<? super T,? extends ObservableSource<TLeftEnd>> leftEnd, @NonNull Function<? super TRight,? extends ObservableSource<TRightEnd>> rightEnd, @NonNull BiFunction<? super T,? super TRight,? extends R> resultSelector) Correlates the items emitted by two ObservableSources based on overlapping durations.
static <T> @NonNull Observable<T>	just(T item) Returns an Observable that signals the given (constant reference) item and then completes.
static <T> @NonNull Observable<T>	just(T item1, T item2) Converts two items into an Observable that emits those items.
static <T> @NonNull Observable<T>	just(T item1, T item2, T item3) Converts three items into an Observable that emits those items.
static <T> @NonNull Observable<T>	just(T item1, T item2, T item3, T item4) Converts four items into an Observable that emits those items.
static <T> @NonNull Observable<T>	just(T item1, T item2, T item3, T item4, T item5) Converts five items into an Observable that emits those items.
static <T> @NonNull Observable<T>	just(T item1, T item2, T item3, T item4, T item5, T item6) Converts six items into an Observable that emits those items.
static <T> @NonNull Observable<T>	just(T item1, T item2, T item3, T item4, T item5, T item6, T item7) Converts seven items into an Observable that emits those items.
static <T> @NonNull Observable<T>	just(T item1, T item2, T item3, T item4, T item5, T item6, T item7, T item8) Converts eight items into an Observable that emits those items.
static <T> @NonNull Observable<T>	just(T item1, T item2, T item3, T item4, T item5, T item6, T item7, T item8, T item9) Converts nine items into an Observable that emits those items.
static <T> @NonNull Observable<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 an Observable that emits those items.
@NonNull Single<T>	last(T defaultItem) Returns a Single that emits only the last item emitted by the current Observable, or a default item if the current Observable completes without emitting any items.
@NonNull Maybe<T>	lastElement() Returns a Maybe that emits the last item emitted by the current Observable or completes if the current Observable is empty.
@NonNull Single<T>	lastOrError() Returns a Single that emits only the last item emitted by the current Observable or signals a NoSuchElementException if the current Observable is empty.
@NonNull CompletionStage<T>	lastOrErrorStage() Signals the last upstream item or a NoSuchElementException if the upstream is empty via a CompletionStage.
@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 Observable<R>	lift(@NonNull ObservableOperator<? extends R,? super T> lifter) This method requires advanced knowledge about building operators, please consider other standard composition methods first; Returns an Observable which, when subscribed to, invokes the apply(Observer) method of the provided ObservableOperator for each individual downstream Observer and allows the insertion of a custom operator by accessing the downstream's Observer during this subscription phase and providing a new Observer, containing the custom operator's intended business logic, that will be used in the subscription process going further upstream.
<R> @NonNull Observable<R>	map(@NonNull Function<? super T,? extends R> mapper) Returns an Observable that applies a specified function to each item emitted by the current Observable and emits the results of these function applications.
<R> @NonNull Observable<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 Observable<Notification<T>>	materialize() Returns an Observable that represents all of the emissions and notifications from the current Observable into emissions marked with their original types within Notification objects.
static <T> @NonNull Observable<T>	merge(@NonNull Iterable<? extends ObservableSource<? extends T>> sources) Flattens an Iterable of ObservableSources into one Observable, without any transformation.
static <T> @NonNull Observable<T>	merge(@NonNull Iterable<? extends ObservableSource<? extends T>> sources, int maxConcurrency) Flattens an Iterable of ObservableSources into one Observable, without any transformation, while limiting the number of concurrent subscriptions to these ObservableSources.
static <T> @NonNull Observable<T>	merge(@NonNull Iterable<? extends ObservableSource<? extends T>> sources, int maxConcurrency, int bufferSize) Flattens an Iterable of ObservableSources into one Observable, without any transformation, while limiting the number of concurrent subscriptions to these ObservableSources.
static <T> @NonNull Observable<T>	merge(@NonNull ObservableSource<? extends ObservableSource<? extends T>> sources) Flattens an ObservableSource that emits ObservableSources into a single Observable that emits the items emitted by those ObservableSources, without any transformation.
static <T> @NonNull Observable<T>	merge(@NonNull ObservableSource<? extends ObservableSource<? extends T>> sources, int maxConcurrency) Flattens an ObservableSource that emits ObservableSources into a single Observable that emits the items emitted by those ObservableSources, without any transformation, while limiting the maximum number of concurrent subscriptions to these ObservableSources.
static <T> @NonNull Observable<T>	merge(@NonNull ObservableSource<? extends T> source1, @NonNull ObservableSource<? extends T> source2) Flattens two ObservableSources into a single Observable, without any transformation.
static <T> @NonNull Observable<T>	merge(@NonNull ObservableSource<? extends T> source1, @NonNull ObservableSource<? extends T> source2, @NonNull ObservableSource<? extends T> source3) Flattens three ObservableSources into a single Observable, without any transformation.
static <T> @NonNull Observable<T>	merge(@NonNull ObservableSource<? extends T> source1, @NonNull ObservableSource<? extends T> source2, @NonNull ObservableSource<? extends T> source3, @NonNull ObservableSource<? extends T> source4) Flattens four ObservableSources into a single Observable, without any transformation.
static <T> @NonNull Observable<T>	mergeArray(int maxConcurrency, int bufferSize, ObservableSource<? extends T>... sources) Flattens an array of ObservableSources into one Observable, without any transformation, while limiting the number of concurrent subscriptions to these ObservableSources.
static <T> @NonNull Observable<T>	mergeArray(ObservableSource<? extends T>... sources) Flattens an array of ObservableSources into one Observable, without any transformation.
static <T> @NonNull Observable<T>	mergeArrayDelayError(int maxConcurrency, int bufferSize, ObservableSource<? extends T>... sources) Flattens an array of ObservableSources into one Observable, in a way that allows an Observer to receive all successfully emitted items from each of the ObservableSources without being interrupted by an error notification from one of them, while limiting the number of concurrent subscriptions to these ObservableSources.
static <T> @NonNull Observable<T>	mergeArrayDelayError(ObservableSource<? extends T>... sources) Flattens an array of ObservableSources into one Observable, in a way that allows an Observer to receive all successfully emitted items from each of the ObservableSources without being interrupted by an error notification from one of them.
static <T> @NonNull Observable<T>	mergeDelayError(@NonNull Iterable<? extends ObservableSource<? extends T>> sources) Flattens an Iterable of ObservableSources into one Observable, in a way that allows an Observer to receive all successfully emitted items from each of the returned ObservableSources without being interrupted by an error notification from one of them.
static <T> @NonNull Observable<T>	mergeDelayError(@NonNull Iterable<? extends ObservableSource<? extends T>> sources, int maxConcurrency) Flattens an Iterable of ObservableSources into one Observable, in a way that allows an Observer to receive all successfully emitted items from each of the returned ObservableSources without being interrupted by an error notification from one of them, while limiting the number of concurrent subscriptions to these ObservableSources.
static <T> @NonNull Observable<T>	mergeDelayError(@NonNull Iterable<? extends ObservableSource<? extends T>> sources, int maxConcurrency, int bufferSize) Flattens an Iterable of ObservableSources into one Observable, in a way that allows an Observer to receive all successfully emitted items from each of the returned ObservableSources without being interrupted by an error notification from one of them, while limiting the number of concurrent subscriptions to these ObservableSources.
static <T> @NonNull Observable<T>	mergeDelayError(@NonNull ObservableSource<? extends ObservableSource<? extends T>> sources) Flattens an ObservableSource that emits ObservableSources into one Observable, in a way that allows an Observer to receive all successfully emitted items from all of the emitted ObservableSources without being interrupted by an error notification from one of them.
static <T> @NonNull Observable<T>	mergeDelayError(@NonNull ObservableSource<? extends ObservableSource<? extends T>> sources, int maxConcurrency) Flattens an ObservableSource that emits ObservableSources into one Observable, in a way that allows an Observer to receive all successfully emitted items from all of the emitted ObservableSources without being interrupted by an error notification from one of them, while limiting the number of concurrent subscriptions to these ObservableSources.
static <T> @NonNull Observable<T>	mergeDelayError(@NonNull ObservableSource<? extends T> source1, @NonNull ObservableSource<? extends T> source2) Flattens two ObservableSources into one Observable, in a way that allows an Observer to receive all successfully emitted items from each of the ObservableSources without being interrupted by an error notification from one of them.
static <T> @NonNull Observable<T>	mergeDelayError(@NonNull ObservableSource<? extends T> source1, @NonNull ObservableSource<? extends T> source2, @NonNull ObservableSource<? extends T> source3) Flattens three ObservableSources into one Observable, in a way that allows an Observer to receive all successfully emitted items from all of the ObservableSources without being interrupted by an error notification from one of them.
static <T> @NonNull Observable<T>	mergeDelayError(@NonNull ObservableSource<? extends T> source1, @NonNull ObservableSource<? extends T> source2, @NonNull ObservableSource<? extends T> source3, @NonNull ObservableSource<? extends T> source4) Flattens four ObservableSources into one Observable, in a way that allows an Observer to receive all successfully emitted items from all of the ObservableSources without being interrupted by an error notification from one of them.
@NonNull Observable<T>	mergeWith(@NonNull CompletableSource other) Relays the items of the current Observable and completes only when the other CompletableSource completes as well.
@NonNull Observable<T>	mergeWith(@NonNull MaybeSource<? extends T> other) Merges the sequence of items of the current Observable with the success value of the other MaybeSource or waits both to complete normally if the MaybeSource is empty.
@NonNull Observable<T>	mergeWith(@NonNull ObservableSource<? extends T> other) Flattens the current Observable and another ObservableSource into a single Observable sequence, without any transformation.
@NonNull Observable<T>	mergeWith(@NonNull SingleSource<? extends T> other) Merges the sequence of items of the current Observable with the success value of the other SingleSource.
static <T> @NonNull Observable<T>	never() Returns an Observable that never sends any items or notifications to an Observer.
@NonNull Observable<T>	observeOn(@NonNull Scheduler scheduler) Returns an Observable to perform the current Observable's emissions and notifications on a specified Scheduler, asynchronously with an unbounded buffer with Flowable.bufferSize() "island size".
@NonNull Observable<T>	observeOn(@NonNull Scheduler scheduler, boolean delayError) Returns an Observable to perform the current Observable's emissions and notifications on a specified Scheduler, asynchronously with an unbounded buffer with Flowable.bufferSize() "island size" and optionally delays onError notifications.
@NonNull Observable<T>	observeOn(@NonNull Scheduler scheduler, boolean delayError, int bufferSize) Returns an Observable to perform the current Observable's emissions and notifications on a specified Scheduler, asynchronously with an unbounded buffer of configurable "island size" and optionally delays onError notifications.
<U> @NonNull Observable<U>	ofType(@NonNull Class<U> clazz) Filters the items emitted by the current Observable, only emitting those of the specified type.
@NonNull Observable<T>	onErrorComplete() Returns an Observable instance that if the current Observable emits an error, it will emit an onComplete and swallow the throwable.
@NonNull Observable<T>	onErrorComplete(@NonNull Predicate<? super Throwable> predicate) Returns an Observable instance that if the current Observable emits an error and the predicate returns true, it will emit an onComplete and swallow the throwable.
@NonNull Observable<T>	onErrorResumeNext(@NonNull Function<? super Throwable,? extends ObservableSource<? extends T>> fallbackSupplier) Resumes the flow with an ObservableSource returned for the failure Throwable of the current Observable by a function instead of signaling the error via onError.
@NonNull Observable<T>	onErrorResumeWith(@NonNull ObservableSource<? extends T> fallback) Resumes the flow with the given ObservableSource when the current Observable fails instead of signaling the error via onError.
@NonNull Observable<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 Observable instead of signaling the error via onError.
@NonNull Observable<T>	onErrorReturnItem(T item) Ends the flow with the given last item when the current Observable fails instead of signaling the error via onError.
@NonNull Observable<T>	onTerminateDetach() Nulls out references to the upstream producer and downstream Observer if the sequence is terminated or downstream calls dispose().
@NonNull ConnectableObservable<T>	publish() Returns a ConnectableObservable, which is a variety of ObservableSource that waits until its connect method is called before it begins emitting items to those Observers that have subscribed to it.
<R> @NonNull Observable<R>	publish(@NonNull Function<? super Observable<T>,? extends ObservableSource<R>> selector) Returns an Observable that emits the results of invoking a specified selector on items emitted by a ConnectableObservable that shares a single subscription to the current Observable sequence.
static @NonNull Observable<Integer>	range(int start, int count) Returns an Observable that emits a sequence of Integers within a specified range.
static @NonNull Observable<Long>	rangeLong(long start, long count) Returns an Observable that emits a sequence of Longs within a specified range.
@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 Observable, then feeds the result of that function along with the second item emitted by the current Observable into the same function, and so on until all items have been emitted by the current and finite Observable, 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 Observable and a specified seed value, then feeds the result of that function along with the second item emitted by the current Observable into the same function, and so on until all items have been emitted by the current and finite Observable, 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 Observable 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 Observable into the same function, and so on until all items have been emitted by the current and finite Observable, emitting the final result from the final call to your function as its sole item.
@NonNull Observable<T>	repeat() Returns an Observable that repeats the sequence of items emitted by the current Observable indefinitely.
@NonNull Observable<T>	repeat(long times) Returns an Observable that repeats the sequence of items emitted by the current Observable at most count times.
@NonNull Observable<T>	repeatUntil(@NonNull BooleanSupplier stop) Returns an Observable that repeats the sequence of items emitted by the current Observable until the provided stop function returns true.
@NonNull Observable<T>	repeatWhen(@NonNull Function<? super Observable<Object>,? extends ObservableSource<?>> handler) Returns an Observable that emits the same values as the current Observable with the exception of an onComplete.
@NonNull ConnectableObservable<T>	replay() Returns a ConnectableObservable that shares a single subscription to the current Observable that will replay all of its items and notifications to any future Observer.
<R> @NonNull Observable<R>	replay(@NonNull Function<? super Observable<T>,? extends ObservableSource<R>> selector) Returns an Observable that emits items that are the results of invoking a specified selector on the items emitted by a ConnectableObservable that shares a single subscription to the current Observable.
<R> @NonNull Observable<R>	replay(@NonNull Function<? super Observable<T>,? extends ObservableSource<R>> selector, int bufferSize) Returns an Observable that emits items that are the results of invoking a specified selector on items emitted by a ConnectableObservable that shares a single subscription to the current Observable, replaying bufferSize notifications.
<R> @NonNull Observable<R>	replay(@NonNull Function<? super Observable<T>,? extends ObservableSource<R>> selector, int bufferSize, boolean eagerTruncate) Returns an Observable that emits items that are the results of invoking a specified selector on items emitted by a ConnectableObservable that shares a single subscription to the current Observable, replaying bufferSize notifications.
<R> @NonNull Observable<R>	replay(@NonNull Function<? super Observable<T>,? extends ObservableSource<R>> selector, int bufferSize, long time, @NonNull TimeUnit unit) Returns an Observable that emits items that are the results of invoking a specified selector on items emitted by a ConnectableObservable that shares a single subscription to the current Observable, replaying no more than bufferSize items that were emitted within a specified time window.
<R> @NonNull Observable<R>	replay(@NonNull Function<? super Observable<T>,? extends ObservableSource<R>> selector, int bufferSize, long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler) Returns an Observable that emits items that are the results of invoking a specified selector on items emitted by a ConnectableObservable that shares a single subscription to the current Observable, replaying no more than bufferSize items that were emitted within a specified time window.
<R> @NonNull Observable<R>	replay(@NonNull Function<? super Observable<T>,? extends ObservableSource<R>> selector, int bufferSize, long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean eagerTruncate) Returns an Observable that emits items that are the results of invoking a specified selector on items emitted by a ConnectableObservable that shares a single subscription to the current Observable, replaying no more than bufferSize items that were emitted within a specified time window.
<R> @NonNull Observable<R>	replay(@NonNull Function<? super Observable<T>,? extends ObservableSource<R>> selector, long time, @NonNull TimeUnit unit) Returns an Observable that emits items that are the results of invoking a specified selector on items emitted by a ConnectableObservable that shares a single subscription to the current Observable, replaying all items that were emitted within a specified time window.
<R> @NonNull Observable<R>	replay(@NonNull Function<? super Observable<T>,? extends ObservableSource<R>> selector, long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler) Returns an Observable that emits items that are the results of invoking a specified selector on items emitted by a ConnectableObservable that shares a single subscription to the current Observable, replaying all items that were emitted within a specified time window.
<R> @NonNull Observable<R>	replay(@NonNull Function<? super Observable<T>,? extends ObservableSource<R>> selector, long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean eagerTruncate) Returns an Observable that emits items that are the results of invoking a specified selector on items emitted by a ConnectableObservable that shares a single subscription to the current Observable, replaying all items that were emitted within a specified time window.
@NonNull ConnectableObservable<T>	replay(int bufferSize) Returns a ConnectableObservable that shares a single subscription to the current Observable that replays at most bufferSize items emitted by the current Observable.
@NonNull ConnectableObservable<T>	replay(int bufferSize, boolean eagerTruncate) Returns a ConnectableObservable that shares a single subscription to the current Observable that replays at most bufferSize items emitted by the current Observable.
@NonNull ConnectableObservable<T>	replay(int bufferSize, long time, @NonNull TimeUnit unit) Returns a ConnectableObservable that shares a single subscription to the current Observable and replays at most bufferSize items that were emitted during a specified time window.
@NonNull ConnectableObservable<T>	replay(int bufferSize, long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler) Returns a ConnectableObservable that shares a single subscription to the current Observable and that replays a maximum of bufferSize items that are emitted within a specified time window.
@NonNull ConnectableObservable<T>	replay(int bufferSize, long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean eagerTruncate) Returns a ConnectableObservable that shares a single subscription to the current Observable and that replays a maximum of bufferSize items that are emitted within a specified time window.
@NonNull ConnectableObservable<T>	replay(long time, @NonNull TimeUnit unit) Returns a ConnectableObservable that shares a single subscription to the current Observable and replays all items emitted by the current Observable within a specified time window.
@NonNull ConnectableObservable<T>	replay(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler) Returns a ConnectableObservable that shares a single subscription to the current Observable and replays all items emitted by the current Observable within a specified time window.
@NonNull ConnectableObservable<T>	replay(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean eagerTruncate) Returns a ConnectableObservable that shares a single subscription to the current Observable and replays all items emitted by the current Observable within a specified time window.
@NonNull Observable<T>	retry() Returns an Observable that mirrors the current Observable, resubscribing to it if it calls onError (infinite retry count).
@NonNull Observable<T>	retry(@NonNull BiPredicate<? super Integer,? super Throwable> predicate) Returns an Observable that mirrors the current Observable, resubscribing to it if it calls onError and the predicate returns true for that specific exception and retry count.
@NonNull Observable<T>	retry(long times) Returns an Observable that mirrors the current Observable, resubscribing to it if it calls onError up to a specified number of retries.
@NonNull Observable<T>	retry(long times, @NonNull Predicate<? super Throwable> predicate) Retries at most times or until the predicate returns false, whichever happens first.
@NonNull Observable<T>	retry(@NonNull Predicate<? super Throwable> predicate) Retries the current Observable if the predicate returns true.
@NonNull Observable<T>	retryUntil(@NonNull BooleanSupplier stop) Retries until the given stop function returns true.
@NonNull Observable<T>	retryWhen(@NonNull Function<? super Observable<Throwable>,? extends ObservableSource<?>> handler) Returns an Observable that emits the same values as the current Observable with the exception of an onError.
void	safeSubscribe(@NonNull Observer<? super T> observer) Subscribes to the current Observable and wraps the given Observer into a SafeObserver (if not already a SafeObserver) that deals with exceptions thrown by a misbehaving Observer (that doesn't follow the Reactive Streams specification).
@NonNull Observable<T>	sample(long period, @NonNull TimeUnit unit) Returns an Observable that emits the most recently emitted item (if any) emitted by the current Observable within periodic time intervals.
@NonNull Observable<T>	sample(long period, @NonNull TimeUnit unit, boolean emitLast) Returns an Observable that emits the most recently emitted item (if any) emitted by the current Observable within periodic time intervals and optionally emit the very last upstream item when the upstream completes.
@NonNull Observable<T>	sample(long period, @NonNull TimeUnit unit, @NonNull Scheduler scheduler) Returns an Observable that emits the most recently emitted item (if any) emitted by the current Observable within periodic time intervals, where the intervals are defined on a particular Scheduler.
@NonNull Observable<T>	sample(long period, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean emitLast) Returns an Observable that emits the most recently emitted item (if any) emitted by the current Observable within periodic time intervals, where the intervals are defined on a particular Scheduler and optionally emit the very last upstream item when the upstream completes.
@NonNull Observable<T>	sample(long period, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean emitLast, @NonNull Consumer<? super T> onDropped) Returns an Observable that emits the most recently emitted item (if any) emitted by the current Observable within periodic time intervals, where the intervals are defined on a particular Scheduler.
<U> @NonNull Observable<T>	sample(@NonNull ObservableSource<U> sampler) Returns an Observable that, when the specified sampler ObservableSource emits an item or completes, emits the most recently emitted item (if any) emitted by the current Observable since the previous emission from the sampler ObservableSource.
<U> @NonNull Observable<T>	sample(@NonNull ObservableSource<U> sampler, boolean emitLast) Returns an Observable that, when the specified sampler ObservableSource emits an item or completes, emits the most recently emitted item (if any) emitted by the current Observable since the previous emission from the sampler ObservableSource and optionally emit the very last upstream item when the upstream or other ObservableSource complete.
@NonNull Observable<T>	scan(@NonNull BiFunction<T,T,T> accumulator) Returns an Observable that emits the first value emitted by the current Observable, then emits one value for each subsequent value emitted by the current Observable.
<R> @NonNull Observable<R>	scan(R initialValue, @NonNull BiFunction<R,? super T,R> accumulator) Returns an Observable that emits the provided initial (seed) value, then emits one value for each value emitted by the current Observable.
<R> @NonNull Observable<R>	scanWith(@NonNull Supplier<R> seedSupplier, @NonNull BiFunction<R,? super T,R> accumulator) Returns an Observable that emits the provided initial (seed) value, then emits one value for each value emitted by the current Observable.
static <T> @NonNull Single<Boolean>	sequenceEqual(@NonNull ObservableSource<? extends T> source1, @NonNull ObservableSource<? extends T> source2) Returns a Single that emits a Boolean value that indicates whether two ObservableSource sequences are the same by comparing the items emitted by each ObservableSource pairwise.
static <T> @NonNull Single<Boolean>	sequenceEqual(@NonNull ObservableSource<? extends T> source1, @NonNull ObservableSource<? extends T> source2, @NonNull BiPredicate<? super T,? super T> isEqual) Returns a Single that emits a Boolean value that indicates whether two ObservableSource sequences are the same by comparing the items emitted by each ObservableSource pairwise based on the results of a specified equality function.
static <T> @NonNull Single<Boolean>	sequenceEqual(@NonNull ObservableSource<? extends T> source1, @NonNull ObservableSource<? extends T> source2, @NonNull BiPredicate<? super T,? super T> isEqual, int bufferSize) Returns a Single that emits a Boolean value that indicates whether two ObservableSource sequences are the same by comparing the items emitted by each ObservableSource pairwise based on the results of a specified equality function.
static <T> @NonNull Single<Boolean>	sequenceEqual(@NonNull ObservableSource<? extends T> source1, @NonNull ObservableSource<? extends T> source2, int bufferSize) Returns a Single that emits a Boolean value that indicates whether two ObservableSource sequences are the same by comparing the items emitted by each ObservableSource pairwise.
@NonNull Observable<T>	serialize() Forces the current Observable's emissions and notifications to be serialized and for it to obey the ObservableSource contract in other ways.
@NonNull Observable<T>	share() Returns a new Observable that multicasts (and shares a single subscription to) the current Observable.
@NonNull Single<T>	single(T defaultItem) Returns a Single that emits the single item emitted by the current Observable, if the current Observable emits only a single item, or a default item if the current Observable emits no items.
@NonNull Maybe<T>	singleElement() Returns a Maybe that completes if the current Observable is empty or emits the single item emitted by the current Observable, or signals an IllegalArgumentException if the current Observable emits more than one item.
@NonNull Single<T>	singleOrError() Returns a Single that emits the single item emitted by the current Observable if it emits only a single item, otherwise if the current Observable completes without emitting any items or emits more than one item a NoSuchElementException or IllegalArgumentException will be signaled respectively.
@NonNull CompletionStage<T>	singleOrErrorStage() Signals the only expected upstream item, a NoSuchElementException if the upstream is empty or signals IllegalArgumentException if the upstream has more than one item via a CompletionStage.
@NonNull CompletionStage<T>	singleStage(T defaultItem) Signals the only expected upstream item (or the default item if the upstream is empty) or signals IllegalArgumentException if the upstream has more than one item via a CompletionStage.
@NonNull Observable<T>	skip(long count) Returns an Observable that skips the first count items emitted by the current Observable and emits the remainder.
@NonNull Observable<T>	skip(long time, @NonNull TimeUnit unit) Returns an Observable that skips values emitted by the current Observable before a specified time window elapses.
@NonNull Observable<T>	skip(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler) Returns an Observable that skips values emitted by the current Observable before a specified time window on a specified Scheduler elapses.
@NonNull Observable<T>	skipLast(int count) Returns an Observable that drops a specified number of items from the end of the sequence emitted by the current Observable.
@NonNull Observable<T>	skipLast(long time, @NonNull TimeUnit unit) Returns an Observable that drops items emitted by the current Observable during a specified time window before the source completes.
@NonNull Observable<T>	skipLast(long time, @NonNull TimeUnit unit, boolean delayError) Returns an Observable that drops items emitted by the current Observable during a specified time window before the source completes.
@NonNull Observable<T>	skipLast(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler) Returns an Observable that drops items emitted by the current Observable during a specified time window (defined on a specified scheduler) before the source completes.
@NonNull Observable<T>	skipLast(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean delayError) Returns an Observable that drops items emitted by the current Observable during a specified time window (defined on a specified scheduler) before the source completes.
@NonNull Observable<T>	skipLast(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean delayError, int bufferSize) Returns an Observable that drops items emitted by the current Observable during a specified time window (defined on a specified scheduler) before the source completes.
<U> @NonNull Observable<T>	skipUntil(@NonNull ObservableSource<U> other) Returns an Observable that skips items emitted by the current Observable until a second ObservableSource emits an item.
@NonNull Observable<T>	skipWhile(@NonNull Predicate<? super T> predicate) Returns an Observable that skips all items emitted by the current Observable as long as a specified condition holds true, but emits all further source items as soon as the condition becomes false.
@NonNull Observable<T>	sorted() Returns an Observable that emits the events emitted by the current Observable, in a sorted order.
@NonNull Observable<T>	sorted(@NonNull Comparator<? super T> comparator) Returns an Observable that emits the events emitted by the current Observable, in a sorted order based on a specified comparison function.
@NonNull Observable<T>	startWith(@NonNull CompletableSource other) Returns an Observable which first runs the other CompletableSource then the current Observable if the other completed normally.
@NonNull Observable<T>	startWith(@NonNull MaybeSource<T> other) Returns an Observable which first runs the other MaybeSource then the current Observable if the other succeeded or completed normally.
@NonNull Observable<T>	startWith(@NonNull ObservableSource<? extends T> other) Returns an Observable that emits the items in a specified ObservableSource before it begins to emit items emitted by the current Observable.
@NonNull Observable<T>	startWith(@NonNull SingleSource<T> other) Returns an Observable which first runs the other SingleSource then the current Observable if the other succeeded normally.
@NonNull Observable<T>	startWithArray(T... items) Returns an Observable that emits the specified items before it begins to emit items emitted by the current Observable.
@NonNull Observable<T>	startWithItem(T item) Returns an Observable that emits a specified item before it begins to emit items emitted by the current Observable.
@NonNull Observable<T>	startWithIterable(@NonNull Iterable<? extends T> items) Returns an Observable that emits the items in a specified Iterable before it begins to emit items emitted by the current Observable.
@NonNull Disposable	subscribe() Subscribes to the current Observable and ignores onNext and onComplete emissions.
@NonNull Disposable	subscribe(@NonNull Consumer<? super T> onNext) Subscribes to the current Observable 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 Observable and provides callbacks to handle the items it emits and any error notification it signals.
@NonNull Disposable	subscribe(@NonNull Consumer<? super T> onNext, @NonNull Consumer<? super Throwable> onError, @NonNull Action onComplete) Subscribes to the current Observable and provides callbacks to handle the items it emits and any error or completion notification it signals.
@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 Observer, adds it to the given DisposableContainer and ensures, that if the upstream terminates or this particular Disposable is disposed, the Observer is removed from the given container.
void	subscribe(@NonNull Observer<? super T> observer) Subscribes the given Observer to this ObservableSource instance.
protected abstract void	subscribeActual(@NonNull Observer<? super T> observer) Operator implementations (both source and intermediate) should implement this method that performs the necessary business logic and handles the incoming Observers.
@NonNull Observable<T>	subscribeOn(@NonNull Scheduler scheduler) Asynchronously subscribes Observers to the current Observable on the specified Scheduler.
<E extends Observer<? super T>> E	subscribeWith(E observer) Subscribes a given Observer (subclass) to the current Observable and returns the given Observer instance as is.
@NonNull Observable<T>	switchIfEmpty(@NonNull ObservableSource<? extends T> other) Returns an Observable that emits the items emitted by the current Observable or the items of an alternate ObservableSource if the current Observable is empty.
<R> @NonNull Observable<R>	switchMap(@NonNull Function<? super T,? extends ObservableSource<? extends R>> mapper) Returns a new Observable by applying a function that you supply to each item emitted by the current Observable that returns an ObservableSource, and then emitting the items emitted by the most recently emitted of these ObservableSources.
<R> @NonNull Observable<R>	switchMap(@NonNull Function<? super T,? extends ObservableSource<? extends R>> mapper, int bufferSize) Returns a new Observable by applying a function that you supply to each item emitted by the current Observable that returns an ObservableSource, and then emitting the items emitted by the most recently emitted of these ObservableSources.
@NonNull Completable	switchMapCompletable(@NonNull Function<? super T,? extends CompletableSource> mapper) Maps the items of the current Observable into CompletableSources, 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 CompletableSources, 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 Observable<R>	switchMapDelayError(@NonNull Function<? super T,? extends ObservableSource<? extends R>> mapper) Returns a new Observable by applying a function that you supply to each item emitted by the current Observable that returns an ObservableSource, and then emitting the items emitted by the most recently emitted of these ObservableSources and delays any error until all ObservableSources terminate.
<R> @NonNull Observable<R>	switchMapDelayError(@NonNull Function<? super T,? extends ObservableSource<? extends R>> mapper, int bufferSize) Returns a new Observable by applying a function that you supply to each item emitted by the current Observable that returns an ObservableSource, and then emitting the items emitted by the most recently emitted of these ObservableSources and delays any error until all ObservableSources terminate.
<R> @NonNull Observable<R>	switchMapMaybe(@NonNull Function<? super T,? extends MaybeSource<? extends R>> mapper) Maps the items of the current Observable into MaybeSources and switches (subscribes) to the newer ones while disposing the older ones (and ignoring their signals) and emits the latest success value of the current one if available while failing immediately if the current Observable or any of the active inner MaybeSources fail.
<R> @NonNull Observable<R>	switchMapMaybeDelayError(@NonNull Function<? super T,? extends MaybeSource<? extends R>> mapper) Maps the upstream items into MaybeSources and switches (subscribes) to the newer ones while disposing the older ones (and ignoring their signals) and emits the latest success value of the current one if available, delaying errors from the current Observable or the inner MaybeSources until all terminate.
<R> @NonNull Observable<R>	switchMapSingle(@NonNull Function<? super T,? extends SingleSource<? extends R>> mapper) Returns a new Observable by applying a function that you supply to each item emitted by the current Observable that returns a SingleSource, and then emitting the item emitted by the most recently emitted of these SingleSources.
<R> @NonNull Observable<R>	switchMapSingleDelayError(@NonNull Function<? super T,? extends SingleSource<? extends R>> mapper) Returns a new Observable by applying a function that you supply to each item emitted by the current Observable that returns a SingleSource, and then emitting the item emitted by the most recently emitted of these SingleSources and delays any error until all SingleSources terminate.
static <T> @NonNull Observable<T>	switchOnNext(@NonNull ObservableSource<? extends ObservableSource<? extends T>> sources) Converts an ObservableSource that emits ObservableSources into an Observable that emits the items emitted by the most recently emitted of those ObservableSources.
static <T> @NonNull Observable<T>	switchOnNext(@NonNull ObservableSource<? extends ObservableSource<? extends T>> sources, int bufferSize) Converts an ObservableSource that emits ObservableSources into an Observable that emits the items emitted by the most recently emitted of those ObservableSources.
static <T> @NonNull Observable<T>	switchOnNextDelayError(@NonNull ObservableSource<? extends ObservableSource<? extends T>> sources) Converts an ObservableSource that emits ObservableSources into an Observable that emits the items emitted by the most recently emitted of those ObservableSources and delays any exception until all ObservableSources terminate.
static <T> @NonNull Observable<T>	switchOnNextDelayError(@NonNull ObservableSource<? extends ObservableSource<? extends T>> sources, int bufferSize) Converts an ObservableSource that emits ObservableSources into an Observable that emits the items emitted by the most recently emitted of those ObservableSources and delays any exception until all ObservableSources terminate.
@NonNull Observable<T>	take(long count) Returns an Observable that emits only the first count items emitted by the current Observable.
@NonNull Observable<T>	take(long time, @NonNull TimeUnit unit) Returns an Observable that emits those items emitted by the current Observable before a specified time runs out.
@NonNull Observable<T>	take(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler) Returns an Observable that emits those items emitted by the current Observable before a specified time (on a specified Scheduler) runs out.
@NonNull Observable<T>	takeLast(int count) Returns an Observable that emits at most the last count items emitted by the current Observable.
@NonNull Observable<T>	takeLast(long count, long time, @NonNull TimeUnit unit) Returns an Observable that emits at most a specified number of items from the current Observable that were emitted in a specified window of time before the current Observable completed.
@NonNull Observable<T>	takeLast(long count, long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler) Returns an Observable that emits at most a specified number of items from the current Observable that were emitted in a specified window of time before the current Observable completed, where the timing information is provided by a given Scheduler.
@NonNull Observable<T>	takeLast(long count, long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean delayError, int bufferSize) Returns an Observable that emits at most a specified number of items from the current Observable that were emitted in a specified window of time before the current Observable completed, where the timing information is provided by a given Scheduler.
@NonNull Observable<T>	takeLast(long time, @NonNull TimeUnit unit) Returns an Observable that emits the items from the current Observable that were emitted in a specified window of time before the current Observable completed.
@NonNull Observable<T>	takeLast(long time, @NonNull TimeUnit unit, boolean delayError) Returns an Observable that emits the items from the current Observable that were emitted in a specified window of time before the current Observable completed.
@NonNull Observable<T>	takeLast(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler) Returns an Observable that emits the items from the current Observable that were emitted in a specified window of time before the current Observable completed, where the timing information is provided by a specified Scheduler.
@NonNull Observable<T>	takeLast(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean delayError) Returns an Observable that emits the items from the current Observable that were emitted in a specified window of time before the current Observable completed, where the timing information is provided by a specified Scheduler.
@NonNull Observable<T>	takeLast(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean delayError, int bufferSize) Returns an Observable that emits the items from the current Observable that were emitted in a specified window of time before the current Observable completed, where the timing information is provided by a specified Scheduler.
<U> @NonNull Observable<T>	takeUntil(@NonNull ObservableSource<U> other) Returns an Observable that emits the items emitted by the current Observable until a second ObservableSource emits an item or completes.
@NonNull Observable<T>	takeUntil(@NonNull Predicate<? super T> stopPredicate) Returns an Observable that emits items emitted by the current Observable, checks the specified predicate for each item, and then completes when the condition is satisfied.
@NonNull Observable<T>	takeWhile(@NonNull Predicate<? super T> predicate) Returns an Observable that emits items emitted by the current Observable so long as each item satisfied a specified condition, and then completes as soon as this condition is not satisfied.
@NonNull TestObserver<T>	test() Creates a TestObserver and subscribes it to the current Observable.
@NonNull TestObserver<T>	test(boolean dispose) Creates a TestObserver, optionally disposes it and then subscribes it to the current Observable.
@NonNull Observable<T>	throttleFirst(long windowDuration, @NonNull TimeUnit unit) Returns an Observable that emits only the first item emitted by the current Observable during sequential time windows of a specified duration.
@NonNull Observable<T>	throttleFirst(long skipDuration, @NonNull TimeUnit unit, @NonNull Scheduler scheduler) Returns an Observable that emits only the first item emitted by the current Observable during sequential time windows of a specified duration, where the windows are managed by a specified Scheduler.
@NonNull Observable<T>	throttleFirst(long skipDuration, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, @NonNull Consumer<? super T> onDropped) Returns an Observable that emits only the first item emitted by the current Observable during sequential time windows of a specified duration, where the windows are managed by a specified Scheduler.
@NonNull Observable<T>	throttleLast(long intervalDuration, @NonNull TimeUnit unit) Returns an Observable that emits only the last item emitted by the current Observable during sequential time windows of a specified duration.
@NonNull Observable<T>	throttleLast(long intervalDuration, @NonNull TimeUnit unit, @NonNull Scheduler scheduler) Returns an Observable that emits only the last item emitted by the current Observable during sequential time windows of a specified duration, where the duration is governed by a specified Scheduler.
@NonNull Observable<T>	throttleLast(long intervalDuration, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, @NonNull Consumer<? super T> onDropped) Returns an Observable that emits only the last item emitted by the current Observable during sequential time windows of a specified duration, where the duration is governed by a specified Scheduler.
@NonNull Observable<T>	throttleLatest(long timeout, @NonNull TimeUnit unit) Throttles items from the current Observable by first emitting the next item from upstream, then periodically emitting the latest item (if any) when the specified timeout elapses between them.
@NonNull Observable<T>	throttleLatest(long timeout, @NonNull TimeUnit unit, boolean emitLast) Throttles items from the current Observable by first emitting the next item from upstream, then periodically emitting the latest item (if any) when the specified timeout elapses between them.
@NonNull Observable<T>	throttleLatest(long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler) Throttles items from the current Observable by first emitting the next item from upstream, then periodically emitting the latest item (if any) when the specified timeout elapses between them.
@NonNull Observable<T>	throttleLatest(long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean emitLast) Throttles items from the current Observable by first emitting the next item from upstream, then periodically emitting the latest item (if any) when the specified timeout elapses between them.
@NonNull Observable<T>	throttleLatest(long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean emitLast, @NonNull Consumer<? super T> onDropped) Throttles items from the current Observable 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 Observable<T>	throttleWithTimeout(long timeout, @NonNull TimeUnit unit) Returns an Observable that mirrors the current Observable, except that it drops items emitted by the current Observable that are followed by newer items before a timeout value expires.
@NonNull Observable<T>	throttleWithTimeout(long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler) Returns an Observable that mirrors the current Observable, except that it drops items emitted by the current Observable that are followed by newer items before a timeout value expires on a specified Scheduler.
@NonNull Observable<T>	throttleWithTimeout(long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, @NonNull Consumer<? super T> onDropped) Returns an Observable that mirrors the current Observable, except that it drops items emitted by the current Observable that are followed by newer items before a timeout value expires on a specified Scheduler.
@NonNull Observable<Timed<T>>	timeInterval() Returns an Observable that emits records of the time interval between consecutive items emitted by the current Observable.
@NonNull Observable<Timed<T>>	timeInterval(@NonNull Scheduler scheduler) Returns an Observable that emits records of the time interval between consecutive items emitted by the current Observable, where this interval is computed on a specified Scheduler.
@NonNull Observable<Timed<T>>	timeInterval(@NonNull TimeUnit unit) Returns an Observable that emits records of the time interval between consecutive items emitted by the current Observable.
@NonNull Observable<Timed<T>>	timeInterval(@NonNull TimeUnit unit, @NonNull Scheduler scheduler) Returns an Observable that emits records of the time interval between consecutive items emitted by the current Observable, where this interval is computed on a specified Scheduler.
<V> @NonNull Observable<T>	timeout(@NonNull Function<? super T,? extends ObservableSource<V>> itemTimeoutIndicator) Returns an Observable that mirrors the current Observable, but notifies observers of a TimeoutException if an item emitted by the current Observable doesn't arrive within a window of time after the emission of the previous item, where that period of time is measured by an ObservableSource that is a function of the previous item.
<V> @NonNull Observable<T>	timeout(@NonNull Function<? super T,? extends ObservableSource<V>> itemTimeoutIndicator, @NonNull ObservableSource<? extends T> fallback) Returns an Observable that mirrors the current Observable, but that switches to a fallback ObservableSource if an item emitted by the current Observable doesn't arrive within a window of time after the emission of the previous item, where that period of time is measured by an ObservableSource that is a function of the previous item.
@NonNull Observable<T>	timeout(long timeout, @NonNull TimeUnit unit) Returns an Observable that mirrors the current Observable but applies a timeout policy for each emitted item.
@NonNull Observable<T>	timeout(long timeout, @NonNull TimeUnit unit, @NonNull ObservableSource<? extends T> fallback) Returns an Observable that mirrors the current Observable but applies a timeout policy for each emitted item.
@NonNull Observable<T>	timeout(long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler) Returns an Observable that mirrors the current Observable but applies a timeout policy for each emitted item, where this policy is governed on a specified Scheduler.
@NonNull Observable<T>	timeout(long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, @NonNull ObservableSource<? extends T> fallback) Returns an Observable that mirrors the current Observable but applies a timeout policy for each emitted item using a specified Scheduler.
<U,V> @NonNull Observable<T>	timeout(@NonNull ObservableSource<U> firstTimeoutIndicator, @NonNull Function<? super T,? extends ObservableSource<V>> itemTimeoutIndicator) Returns an Observable that mirrors the current Observable, but notifies observers of a TimeoutException if either the first item emitted by the current Observable or any subsequent item doesn't arrive within time windows defined by indicator ObservableSources.
<U,V> @NonNull Observable<T>	timeout(@NonNull ObservableSource<U> firstTimeoutIndicator, @NonNull Function<? super T,? extends ObservableSource<V>> itemTimeoutIndicator, @NonNull ObservableSource<? extends T> fallback) Returns an Observable that mirrors the current Observable, but switches to a fallback ObservableSource if either the first item emitted by the current Observable or any subsequent item doesn't arrive within time windows defined by indicator ObservableSources.
static @NonNull Observable<Long>	timer(long delay, @NonNull TimeUnit unit) Returns an Observable that emits 0L after a specified delay, and then completes.
static @NonNull Observable<Long>	timer(long delay, @NonNull TimeUnit unit, @NonNull Scheduler scheduler) Returns an Observable that emits 0L after a specified delay, on a specified Scheduler, and then completes.
@NonNull Observable<Timed<T>>	timestamp() Returns an Observable that emits each item emitted by the current Observable, wrapped in a Timed object.
@NonNull Observable<Timed<T>>	timestamp(@NonNull Scheduler scheduler) Returns an Observable that emits each item emitted by the current Observable, wrapped in a Timed object whose timestamps are provided by a specified Scheduler.
@NonNull Observable<Timed<T>>	timestamp(@NonNull TimeUnit unit) Returns an Observable that emits each item emitted by the current Observable, wrapped in a Timed object.
@NonNull Observable<Timed<T>>	timestamp(@NonNull TimeUnit unit, @NonNull Scheduler scheduler) Returns an Observable that emits each item emitted by the current Observable, wrapped in a Timed object whose timestamps are provided by a specified Scheduler.
<R> R	to(@NonNull ObservableConverter<T,? extends R> converter) Calls the specified converter function during assembly time and returns its resulting value.
@NonNull Flowable<T>	toFlowable(@NonNull BackpressureStrategy strategy) Converts the current Observable into a Flowable by applying the specified backpressure strategy.
@NonNull Future<T>	toFuture() Returns a Future representing the only value emitted by the current Observable.
@NonNull Single<List<T>>	toList() Returns a Single that emits a single item, a List composed of all the items emitted by the current and finite Observable.
@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 current and finite Observable.
<U extends Collection<? super T>> @NonNull Single<U>	toList(@NonNull Supplier<U> collectionSupplier) Returns a Single that emits a single item, a Collection (subclass) composed of all the items emitted by the finite upstream Observable.
<K> @NonNull Single<Map<K,T>>	toMap(@NonNull Function<? super T,? extends K> keySelector) Returns a Single that emits a single HashMap containing all items emitted by the current and finite Observable, 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 HashMap containing values corresponding to items emitted by the current and finite Observable, mapped by the keys and values returned by the given selector functions.
<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 (subclass), returned by a specified mapFactory function, that contains keys and values extracted from the items, via selector functions, emitted by the current and finite Observable.
<K> @NonNull Single<Map<K,Collection<T>>>	toMultimap(@NonNull Function<? super T,? extends K> keySelector) Returns a Single that emits a single HashMap that contains an ArrayList of items emitted by the current and finite Observable keyed by a specified keySelector function.
<K,V> @NonNull Single<Map<K,Collection<V>>>	toMultimap(@NonNull Function<? super T,? extends K> keySelector, Function<? super T,? extends V> valueSelector) Returns a Single that emits a single HashMap that contains an ArrayList of values extracted by a specified valueSelector function from items emitted by the current and finite Observable, 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 (subclass), returned by a specified mapFactory function, that contains a custom Collection of values, extracted by a specified valueSelector function from items emitted by the current and finite Observable, 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 (subclass), returned by a specified mapFactory function, that contains an ArrayList of values, extracted by a specified valueSelector function from items emitted by the current and finite Observable and keyed by the keySelector function.
@NonNull Single<List<T>>	toSortedList() Returns a Single that emits a List that contains the items emitted by the current and finite Observable, 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 current and finite Observable, 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 current and finite Observable, 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 current and finite Observable, in a sorted order.
static <T> @NonNull Observable<T>	unsafeCreate(@NonNull ObservableSource<T> onSubscribe) Create an Observable by wrapping an ObservableSource which has to be implemented according to the Observable specification derived from the Reactive Streams specification by handling disposal correctly; no safeguards are provided by the Observable itself.
@NonNull Observable<T>	unsubscribeOn(@NonNull Scheduler scheduler) Return an Observable that schedules the downstream Observers' dispose calls aimed at the current Observable on the given Scheduler.
static <T,D> @NonNull Observable<T>	using(@NonNull Supplier<? extends D> resourceSupplier, @NonNull Function<? super D,? extends ObservableSource<? extends T>> sourceSupplier, @NonNull Consumer<? super D> resourceCleanup) Constructs an Observable that creates a dependent resource object, an ObservableSource with that resource and calls the provided resourceDisposer function if this inner source terminates or the downstream disposes the flow.
static <T,D> @NonNull Observable<T>	using(@NonNull Supplier<? extends D> resourceSupplier, @NonNull Function<? super D,? extends ObservableSource<? extends T>> sourceSupplier, @NonNull Consumer<? super D> resourceCleanup, boolean eager) Constructs an Observable that creates a dependent resource object, an ObservableSource with that resource and calls the provided disposer 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 Observable<Observable<T>>	window(long count) Returns an Observable that emits windows of items it collects from the current Observable.
@NonNull Observable<Observable<T>>	window(long count, long skip) Returns an Observable that emits windows of items it collects from the current Observable.
@NonNull Observable<Observable<T>>	window(long count, long skip, int bufferSize) Returns an Observable that emits windows of items it collects from the current Observable.
@NonNull Observable<Observable<T>>	window(long timespan, long timeskip, @NonNull TimeUnit unit) Returns an Observable that emits windows of items it collects from the current Observable.
@NonNull Observable<Observable<T>>	window(long timespan, long timeskip, @NonNull TimeUnit unit, @NonNull Scheduler scheduler) Returns an Observable that emits windows of items it collects from the current Observable.
@NonNull Observable<Observable<T>>	window(long timespan, long timeskip, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, int bufferSize) Returns an Observable that emits windows of items it collects from the current Observable.
@NonNull Observable<Observable<T>>	window(long timespan, @NonNull TimeUnit unit) Returns an Observable that emits windows of items it collects from the current Observable.
@NonNull Observable<Observable<T>>	window(long timespan, @NonNull TimeUnit unit, long count) Returns an Observable that emits windows of items it collects from the current Observable.
@NonNull Observable<Observable<T>>	window(long timespan, @NonNull TimeUnit unit, long count, boolean restart) Returns an Observable that emits windows of items it collects from the current Observable.
@NonNull Observable<Observable<T>>	window(long timespan, @NonNull TimeUnit unit, @NonNull Scheduler scheduler) Returns an Observable that emits windows of items it collects from the current Observable.
@NonNull Observable<Observable<T>>	window(long timespan, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, long count) Returns an Observable that emits windows of items it collects from the current Observable.
@NonNull Observable<Observable<T>>	window(long timespan, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, long count, boolean restart) Returns an Observable that emits windows of items it collects from the current Observable.
@NonNull Observable<Observable<T>>	window(long timespan, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, long count, boolean restart, int bufferSize) Returns an Observable that emits windows of items it collects from the current Observable.
<B> @NonNull Observable<Observable<T>>	window(@NonNull ObservableSource<B> boundaryIndicator) Returns an Observable that emits non-overlapping windows of items it collects from the current Observable where the boundary of each window is determined by the items emitted from a specified boundary-governing ObservableSource.
<B> @NonNull Observable<Observable<T>>	window(@NonNull ObservableSource<B> boundaryIndicator, int bufferSize) Returns an Observable that emits non-overlapping windows of items it collects from the current Observable where the boundary of each window is determined by the items emitted from a specified boundary-governing ObservableSource.
<U,V> @NonNull Observable<Observable<T>>	window(@NonNull ObservableSource<U> openingIndicator, @NonNull Function<? super U,? extends ObservableSource<V>> closingIndicator) Returns an Observable that emits windows of items it collects from the current Observable.
<U,V> @NonNull Observable<Observable<T>>	window(@NonNull ObservableSource<U> openingIndicator, @NonNull Function<? super U,? extends ObservableSource<V>> closingIndicator, int bufferSize) Returns an Observable that emits windows of items it collects from the current Observable.
<R> @NonNull Observable<R>	withLatestFrom(@NonNull Iterable<? extends ObservableSource<?>> others, @NonNull Function<? super Object[],R> combiner) Combines the value emission from the current Observable with the latest emissions from the other ObservableSources via a function to produce the output item.
<R> @NonNull Observable<R>	withLatestFrom(@NonNull ObservableSource<?>[] others, @NonNull Function<? super Object[],R> combiner) Combines the value emission from the current Observable with the latest emissions from the other ObservableSources via a function to produce the output item.
<U,R> @NonNull Observable<R>	withLatestFrom(@NonNull ObservableSource<? extends U> other, @NonNull BiFunction<? super T,? super U,? extends R> combiner) Merges the specified ObservableSource into the current Observable sequence by using the resultSelector function only when the current Observable emits an item.
<T1,T2,R> @NonNull Observable<R>	withLatestFrom(@NonNull ObservableSource<T1> source1, @NonNull ObservableSource<T2> source2, @NonNull Function3<? super T,? super T1,? super T2,R> combiner) Combines the value emission from the current Observable with the latest emissions from the other ObservableSources via a function to produce the output item.
<T1,T2,T3,R> @NonNull Observable<R>	withLatestFrom(@NonNull ObservableSource<T1> source1, @NonNull ObservableSource<T2> source2, @NonNull ObservableSource<T3> source3, @NonNull Function4<? super T,? super T1,? super T2,? super T3,R> combiner) Combines the value emission from the current Observable with the latest emissions from the other ObservableSources via a function to produce the output item.
<T1,T2,T3,T4,R> @NonNull Observable<R>	withLatestFrom(@NonNull ObservableSource<T1> source1, @NonNull ObservableSource<T2> source2, @NonNull ObservableSource<T3> source3, @NonNull ObservableSource<T4> source4, @NonNull Function5<? super T,? super T1,? super T2,? super T3,? super T4,R> combiner) Combines the value emission from the current Observable with the latest emissions from the other ObservableSources via a function to produce the output item.
static <T> @NonNull Observable<T>	wrap(@NonNull ObservableSource<T> source) Wraps an ObservableSource into an Observable if not already an Observable.
static <T,R> @NonNull Observable<R>	zip(@NonNull Iterable<? extends ObservableSource<? extends T>> sources, @NonNull Function<? super Object[],? extends R> zipper) Returns an Observable that emits the results of a specified combiner function applied to combinations of items emitted, in sequence, by an Iterable of other ObservableSources.
static <T,R> @NonNull Observable<R>	zip(@NonNull Iterable<? extends ObservableSource<? extends T>> sources, @NonNull Function<? super Object[],? extends R> zipper, boolean delayError, int bufferSize) Returns an Observable that emits the results of a specified combiner function applied to combinations of items emitted, in sequence, by an Iterable of other ObservableSources.
static <T1,T2,R> @NonNull Observable<R>	zip(@NonNull ObservableSource<? extends T1> source1, @NonNull ObservableSource<? extends T2> source2, @NonNull BiFunction<? super T1,? super T2,? extends R> zipper) Returns an Observable that emits the results of a specified combiner function applied to combinations of two items emitted, in sequence, by two other ObservableSources.
static <T1,T2,R> @NonNull Observable<R>	zip(@NonNull ObservableSource<? extends T1> source1, @NonNull ObservableSource<? extends T2> source2, @NonNull BiFunction<? super T1,? super T2,? extends R> zipper, boolean delayError) Returns an Observable that emits the results of a specified combiner function applied to combinations of two items emitted, in sequence, by two other ObservableSources.
static <T1,T2,R> @NonNull Observable<R>	zip(@NonNull ObservableSource<? extends T1> source1, @NonNull ObservableSource<? extends T2> source2, @NonNull BiFunction<? super T1,? super T2,? extends R> zipper, boolean delayError, int bufferSize) Returns an Observable that emits the results of a specified combiner function applied to combinations of two items emitted, in sequence, by two other ObservableSources.
static <T1,T2,T3,R> @NonNull Observable<R>	zip(@NonNull ObservableSource<? extends T1> source1, @NonNull ObservableSource<? extends T2> source2, @NonNull ObservableSource<? extends T3> source3, @NonNull Function3<? super T1,? super T2,? super T3,? extends R> zipper) Returns an Observable that emits the results of a specified combiner function applied to combinations of three items emitted, in sequence, by three other ObservableSources.
static <T1,T2,T3,T4,R> @NonNull Observable<R>	zip(@NonNull ObservableSource<? extends T1> source1, @NonNull ObservableSource<? extends T2> source2, @NonNull ObservableSource<? extends T3> source3, @NonNull ObservableSource<? extends T4> source4, @NonNull Function4<? super T1,? super T2,? super T3,? super T4,? extends R> zipper) Returns an Observable that emits the results of a specified combiner function applied to combinations of four items emitted, in sequence, by four other ObservableSources.
static <T1,T2,T3,T4,T5,R> @NonNull Observable<R>	zip(@NonNull ObservableSource<? extends T1> source1, @NonNull ObservableSource<? extends T2> source2, @NonNull ObservableSource<? extends T3> source3, @NonNull ObservableSource<? extends T4> source4, @NonNull ObservableSource<? extends T5> source5, @NonNull Function5<? super T1,? super T2,? super T3,? super T4,? super T5,? extends R> zipper) Returns an Observable that emits the results of a specified combiner function applied to combinations of five items emitted, in sequence, by five other ObservableSources.
static <T1,T2,T3,T4,T5,T6,R> @NonNull Observable<R>	zip(@NonNull ObservableSource<? extends T1> source1, @NonNull ObservableSource<? extends T2> source2, @NonNull ObservableSource<? extends T3> source3, @NonNull ObservableSource<? extends T4> source4, @NonNull ObservableSource<? extends T5> source5, @NonNull ObservableSource<? extends T6> source6, @NonNull Function6<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? extends R> zipper) Returns an Observable that emits the results of a specified combiner function applied to combinations of six items emitted, in sequence, by six other ObservableSources.
static <T1,T2,T3,T4,T5,T6,T7,R> @NonNull Observable<R>	zip(@NonNull ObservableSource<? extends T1> source1, @NonNull ObservableSource<? extends T2> source2, @NonNull ObservableSource<? extends T3> source3, @NonNull ObservableSource<? extends T4> source4, @NonNull ObservableSource<? extends T5> source5, @NonNull ObservableSource<? extends T6> source6, @NonNull ObservableSource<? extends T7> source7, @NonNull Function7<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? extends R> zipper) Returns an Observable that emits the results of a specified combiner function applied to combinations of seven items emitted, in sequence, by seven other ObservableSources.
static <T1,T2,T3,T4,T5,T6,T7,T8,R> @NonNull Observable<R>	zip(@NonNull ObservableSource<? extends T1> source1, @NonNull ObservableSource<? extends T2> source2, @NonNull ObservableSource<? extends T3> source3, @NonNull ObservableSource<? extends T4> source4, @NonNull ObservableSource<? extends T5> source5, @NonNull ObservableSource<? extends T6> source6, @NonNull ObservableSource<? extends T7> source7, @NonNull ObservableSource<? 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 an Observable that emits the results of a specified combiner function applied to combinations of eight items emitted, in sequence, by eight other ObservableSources.
static <T1,T2,T3,T4,T5,T6,T7,T8,T9,R> @NonNull Observable<R>	zip(@NonNull ObservableSource<? extends T1> source1, @NonNull ObservableSource<? extends T2> source2, @NonNull ObservableSource<? extends T3> source3, @NonNull ObservableSource<? extends T4> source4, @NonNull ObservableSource<? extends T5> source5, @NonNull ObservableSource<? extends T6> source6, @NonNull ObservableSource<? extends T7> source7, @NonNull ObservableSource<? extends T8> source8, @NonNull ObservableSource<? 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 an Observable that emits the results of a specified combiner function applied to combinations of nine items emitted, in sequence, by nine other ObservableSources.
static <T,R> @NonNull Observable<R>	zipArray(@NonNull Function<? super Object[],? extends R> zipper, boolean delayError, int bufferSize, ObservableSource<? extends T>... sources) Returns an Observable that emits the results of a specified combiner function applied to combinations of items emitted, in sequence, by an array of other ObservableSources.
<U,R> @NonNull Observable<R>	zipWith(@NonNull Iterable<U> other, @NonNull BiFunction<? super T,? super U,? extends R> zipper) Returns an Observable that emits items that are the result of applying a specified function to pairs of values, one each from the current Observable and a specified Iterable sequence.
<U,R> @NonNull Observable<R>	zipWith(@NonNull ObservableSource<? extends U> other, @NonNull BiFunction<? super T,? super U,? extends R> zipper) Returns an Observable that emits items that are the result of applying a specified function to pairs of values, one each from the current Observable and another specified ObservableSource.
<U,R> @NonNull Observable<R>	zipWith(@NonNull ObservableSource<? extends U> other, @NonNull BiFunction<? super T,? super U,? extends R> zipper, boolean delayError) Returns an Observable that emits items that are the result of applying a specified function to pairs of values, one each from the current Observable and another specified ObservableSource.
<U,R> @NonNull Observable<R>	zipWith(@NonNull ObservableSource<? extends U> other, @NonNull BiFunction<? super T,? super U,? extends R> zipper, boolean delayError, int bufferSize) Returns an Observable that emits items that are the result of applying a specified function to pairs of values, one each from the current Observable and another specified ObservableSource.

Methods inherited from class java.lang.Object

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

Constructor Detail

Observable

public Observable()

Method Detail

amb

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public static <T> @NonNull Observable<T> amb(@NonNull Iterable<? extends ObservableSource<? extends T>> sources)

Mirrors the one ObservableSource in an Iterable of several ObservableSources that first either emits an item or sends a termination notification.

When one of the ObservableSources signal an item or terminates first, all subscriptions to the other ObservableSources are disposed.

Scheduler:

amb does not operate by default on a particular Scheduler.

Error handling:

If any of the losing ObservableSources signals an error, the error is routed to the global error handler via RxJavaPlugins.onError(Throwable).

Type Parameters:

T - the common element type

Parameters:

sources - an Iterable of ObservableSource sources competing to react first. A subscription to each source will occur in the same order as in the Iterable.

Returns:

the new Observable instance

Throws:

NullPointerException - if sources is null

See Also:

ReactiveX operators documentation: Amb

ambArray

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
 @SafeVarargs
public static <T> @NonNull Observable<T> ambArray(@NonNull ObservableSource<? extends T>... sources)

Mirrors the one ObservableSource in an array of several ObservableSources that first either emits an item or sends a termination notification.

When one of the ObservableSources signal an item or terminates first, all subscriptions to the other ObservableSources are disposed.

Scheduler:

ambArray does not operate by default on a particular Scheduler.

Error handling:

If any of the losing ObservableSources signals an error, the error is routed to the global error handler via RxJavaPlugins.onError(Throwable).

Type Parameters:

T - the common element type

Parameters:

sources - an array of ObservableSource sources competing to react first. A subscription to each source will occur in the same order as in the array.

Returns:

the new Observable instance

Throws:

NullPointerException - if sources is null

See Also:

ReactiveX operators documentation: Amb

bufferSize

@CheckReturnValue
public static int bufferSize()

Returns the default 'island' size or capacity-increment hint for unbounded buffers.

Delegates to Flowable.bufferSize() but is public for convenience.

The value can be overridden via system parameter rx3.buffer-size before the Flowable class is loaded.

Returns:

the default 'island' size or capacity-increment hint

combineLatest

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public static <T,R> @NonNull Observable<R> combineLatest(@NonNull Iterable<? extends ObservableSource<? extends T>> sources,
        @NonNull Function<? super Object[],? extends R> combiner)

Combines a collection of source ObservableSources by emitting an item that aggregates the latest values of each of the returned ObservableSources each time an item is received from any of the returned ObservableSources, where this aggregation is defined by a specified function.

Note on method signature: since Java doesn't allow creating a generic array with new T[], the implementation of this operator has to create an Object[] instead. Unfortunately, a Function<Integer[], R> passed to the method would trigger a ClassCastException.

If any of the sources never produces an item but only terminates (normally or with an error), the resulting sequence terminates immediately (normally or with all the errors accumulated till that point). If that input source is also synchronous, other sources after it will not be subscribed to.

If the provided iterable of ObservableSources is empty, the resulting sequence completes immediately without emitting any items and without any calls to the combiner function.

Scheduler:

combineLatest does not operate by default on a particular Scheduler.

Type Parameters:

T - the common base type of source values

R - the result type

Parameters:

sources - the collection of source ObservableSources

combiner - the aggregation function used to combine the items emitted by the returned ObservableSources

Returns:

the new Observable instance

Throws:

NullPointerException - if sources or combiner is null

See Also:

ReactiveX operators documentation: CombineLatest

combineLatest

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public static <T,R> @NonNull Observable<R> combineLatest(@NonNull Iterable<? extends ObservableSource<? extends T>> sources,
        @NonNull Function<? super Object[],? extends R> combiner,
        int bufferSize)

Combines an Iterable of source ObservableSources by emitting an item that aggregates the latest values of each of the returned ObservableSources each time an item is received from any of the returned ObservableSources, where this aggregation is defined by a specified function.

Note on method signature: since Java doesn't allow creating a generic array with new T[], the implementation of this operator has to create an Object[] instead. Unfortunately, a Function<Integer[], R> passed to the method would trigger a ClassCastException.

If any of the sources never produces an item but only terminates (normally or with an error), the resulting sequence terminates immediately (normally or with all the errors accumulated till that point). If that input source is also synchronous, other sources after it will not be subscribed to.

If the provided Iterable of ObservableSources is empty, the resulting sequence completes immediately without emitting any items and without any calls to the combiner function.

Scheduler:

combineLatest does not operate by default on a particular Scheduler.

Type Parameters:

T - the common base type of source values

R - the result type

Parameters:

sources - the collection of source ObservableSources

combiner - the aggregation function used to combine the items emitted by the returned ObservableSources

bufferSize - the expected number of row combination items to be buffered internally

Returns:

the new Observable instance

Throws:

NullPointerException - if sources or combiner is null

IllegalArgumentException - if bufferSize is non-positive

See Also:

ReactiveX operators documentation: CombineLatest

combineLatestArray

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public static <T,R> @NonNull Observable<R> combineLatestArray(@NonNull ObservableSource<? extends T>[] sources,
        @NonNull Function<? super Object[],? extends R> combiner)

Combines an array of source ObservableSources by emitting an item that aggregates the latest values of each of the ObservableSources each time an item is received from any of the returned ObservableSources, where this aggregation is defined by a specified function.

Note on method signature: since Java doesn't allow creating a generic array with new T[], the implementation of this operator has to create an Object[] instead. Unfortunately, a Function<Integer[], R> passed to the method would trigger a ClassCastException.

If any of the sources never produces an item but only terminates (normally or with an error), the resulting sequence terminates immediately (normally or with all the errors accumulated till that point). If that input source is also synchronous, other sources after it will not be subscribed to.

If the provided array of ObservableSources is empty, the resulting sequence completes immediately without emitting any items and without any calls to the combiner function.

Scheduler:

combineLatestArray does not operate by default on a particular Scheduler.

Type Parameters:

T - the common base type of source values

R - the result type

Parameters:

sources - the collection of source ObservableSources

combiner - the aggregation function used to combine the items emitted by the ObservableSources

Returns:

the new Observable instance

Throws:

NullPointerException - if sources or combiner is null

See Also:

ReactiveX operators documentation: CombineLatest

combineLatestArray

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public static <T,R> @NonNull Observable<R> combineLatestArray(@NonNull ObservableSource<? extends T>[] sources,
        @NonNull Function<? super Object[],? extends R> combiner,
        int bufferSize)

Combines an array of source ObservableSources by emitting an item that aggregates the latest values of each of the ObservableSources each time an item is received from any of the ObservableSources, where this aggregation is defined by a specified function.

Note on method signature: since Java doesn't allow creating a generic array with new T[], the implementation of this operator has to create an Object[] instead. Unfortunately, a Function<Integer[], R> passed to the method would trigger a ClassCastException.

If any of the sources never produces an item but only terminates (normally or with an error), the resulting sequence terminates immediately (normally or with all the errors accumulated till that point). If that input source is also synchronous, other sources after it will not be subscribed to.

If the provided array of ObservableSources is empty, the resulting sequence completes immediately without emitting any items and without any calls to the combiner function.

Scheduler:

combineLatestArray does not operate by default on a particular Scheduler.

Type Parameters:

T - the common base type of source values

R - the result type

Parameters:

sources - the collection of source ObservableSources

combiner - the aggregation function used to combine the items emitted by the ObservableSources

bufferSize - the expected number of row combination items to be buffered internally

Returns:

the new Observable instance

Throws:

NullPointerException - if sources or combiner is null

IllegalArgumentException - if bufferSize is non-positive

See Also:

ReactiveX operators documentation: CombineLatest

combineLatest

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public static <T1,T2,R> @NonNull Observable<R> combineLatest(@NonNull ObservableSource<? extends T1> source1,
        @NonNull ObservableSource<? extends T2> source2,
        @NonNull BiFunction<? super T1,? super T2,? extends R> combiner)

Combines two source ObservableSources by emitting an item that aggregates the latest values of each of the ObservableSources each time an item is received from either of the ObservableSources, where this aggregation is defined by a specified function.

If any of the sources never produces an item but only terminates (normally or with an error), the resulting sequence terminates immediately (normally or with all the errors accumulated till that point). If that input source is also synchronous, other sources after it will not be subscribed to.

Scheduler:

combineLatest does not operate by default on a particular Scheduler.

Type Parameters:

T1 - the element type of the first source

T2 - the element type of the second source

R - the combined output type

Parameters:

source1 - the first source ObservableSource

source2 - the second source ObservableSource

combiner - the aggregation function used to combine the items emitted by the ObservableSources

Returns:

the new Observable instance

Throws:

NullPointerException - if source1, source2 or combiner is null

See Also:

ReactiveX operators documentation: CombineLatest

combineLatest

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public static <T1,T2,T3,R> @NonNull Observable<R> combineLatest(@NonNull ObservableSource<? extends T1> source1,
        @NonNull ObservableSource<? extends T2> source2,
        @NonNull ObservableSource<? extends T3> source3,
        @NonNull Function3<? super T1,? super T2,? super T3,? extends R> combiner)

Combines three source ObservableSources by emitting an item that aggregates the latest values of each of the ObservableSources each time an item is received from any of the ObservableSources, where this aggregation is defined by a specified function.

If any of the sources never produces an item but only terminates (normally or with an error), the resulting sequence terminates immediately (normally or with all the errors accumulated till that point). If that input source is also synchronous, other sources after it will not be subscribed to.

Scheduler:

combineLatest does not operate by default on a particular Scheduler.

Type Parameters:

T1 - the element type of the first source

T2 - the element type of the second source

T3 - the element type of the third source

R - the combined output type

Parameters:

source1 - the first source ObservableSource

source2 - the second source ObservableSource

source3 - the third source ObservableSource

combiner - the aggregation function used to combine the items emitted by the ObservableSources

Returns:

the new Observable instance

Throws:

NullPointerException - if source1, source2, source3 or combiner is null

See Also:

ReactiveX operators documentation: CombineLatest

combineLatest

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public static <T1,T2,T3,T4,R> @NonNull Observable<R> combineLatest(@NonNull ObservableSource<? extends T1> source1,
        @NonNull ObservableSource<? extends T2> source2,
        @NonNull ObservableSource<? extends T3> source3,
        @NonNull ObservableSource<? extends T4> source4,
        @NonNull Function4<? super T1,? super T2,? super T3,? super T4,? extends R> combiner)

Combines four source ObservableSources by emitting an item that aggregates the latest values of each of the ObservableSources each time an item is received from any of the ObservableSources, where this aggregation is defined by a specified function.

If any of the sources never produces an item but only terminates (normally or with an error), the resulting sequence terminates immediately (normally or with all the errors accumulated till that point). If that input source is also synchronous, other sources after it will not be subscribed to.

Scheduler:

combineLatest does not operate by default on a particular Scheduler.

Type Parameters:

T1 - the element type of the first source

T2 - the element type of the second source

T3 - the element type of the third source

T4 - the element type of the fourth source

R - the combined output type

Parameters:

source1 - the first source ObservableSource

source2 - the second source ObservableSource

source3 - the third source ObservableSource

source4 - the fourth source ObservableSource

combiner - the aggregation function used to combine the items emitted by the ObservableSources

Returns:

the new Observable instance

Throws:

NullPointerException - if source1, source2, source3, source4 or combiner is null

See Also:

ReactiveX operators documentation: CombineLatest

combineLatest

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public static <T1,T2,T3,T4,T5,R> @NonNull Observable<R> combineLatest(@NonNull ObservableSource<? extends T1> source1,
        @NonNull ObservableSource<? extends T2> source2,
        @NonNull ObservableSource<? extends T3> source3,
        @NonNull ObservableSource<? extends T4> source4,
        @NonNull ObservableSource<? extends T5> source5,
        @NonNull Function5<? super T1,? super T2,? super T3,? super T4,? super T5,? extends R> combiner)

Combines five source ObservableSources by emitting an item that aggregates the latest values of each of the ObservableSources each time an item is received from any of the ObservableSources, where this aggregation is defined by a specified function.

If any of the sources never produces an item but only terminates (normally or with an error), the resulting sequence terminates immediately (normally or with all the errors accumulated till that point). If that input source is also synchronous, other sources after it will not be subscribed to.

Scheduler:

combineLatest does not operate by default on a particular Scheduler.

Type Parameters:

T1 - the element type of the first source

T2 - the element type of the second source

T3 - the element type of the third source

T4 - the element type of the fourth source

T5 - the element type of the fifth source

R - the combined output type

Parameters:

source1 - the first source ObservableSource

source2 - the second source ObservableSource

source3 - the third source ObservableSource

source4 - the fourth source ObservableSource

source5 - the fifth source ObservableSource

combiner - the aggregation function used to combine the items emitted by the ObservableSources

Returns:

the new Observable instance

Throws:

NullPointerException - if source1, source2, source3, source4, source5 or combiner is null

See Also:

ReactiveX operators documentation: CombineLatest

combineLatest

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public static <T1,T2,T3,T4,T5,T6,R> @NonNull Observable<R> combineLatest(@NonNull ObservableSource<? extends T1> source1,
        @NonNull ObservableSource<? extends T2> source2,
        @NonNull ObservableSource<? extends T3> source3,
        @NonNull ObservableSource<? extends T4> source4,
        @NonNull ObservableSource<? extends T5> source5,
        @NonNull ObservableSource<? extends T6> source6,
        @NonNull Function6<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? extends R> combiner)

Combines six source ObservableSources by emitting an item that aggregates the latest values of each of the ObservableSources each time an item is received from any of the ObservableSources, where this aggregation is defined by a specified function.

If any of the sources never produces an item but only terminates (normally or with an error), the resulting sequence terminates immediately (normally or with all the errors accumulated till that point). If that input source is also synchronous, other sources after it will not be subscribed to.

Scheduler:

combineLatest does not operate by default on a particular Scheduler.

Type Parameters:

T1 - the element type of the first source

T2 - the element type of the second source

T3 - the element type of the third source

T4 - the element type of the fourth source

T5 - the element type of the fifth source

T6 - the element type of the sixth source

R - the combined output type

Parameters:

source1 - the first source ObservableSource

source2 - the second source ObservableSource

source3 - the third source ObservableSource

source4 - the fourth source ObservableSource

source5 - the fifth source ObservableSource

source6 - the sixth source ObservableSource

combiner - the aggregation function used to combine the items emitted by the ObservableSources

Returns:

the new Observable instance

Throws:

NullPointerException - if source1, source2, source3, source4, source5, source6 or combiner is null

See Also:

ReactiveX operators documentation: CombineLatest

combineLatest

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public static <T1,T2,T3,T4,T5,T6,T7,R> @NonNull Observable<R> combineLatest(@NonNull ObservableSource<? extends T1> source1,
        @NonNull ObservableSource<? extends T2> source2,
        @NonNull ObservableSource<? extends T3> source3,
        @NonNull ObservableSource<? extends T4> source4,
        @NonNull ObservableSource<? extends T5> source5,
        @NonNull ObservableSource<? extends T6> source6,
        @NonNull ObservableSource<? 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 ObservableSources by emitting an item that aggregates the latest values of each of the ObservableSources each time an item is received from any of the ObservableSources, where this aggregation is defined by a specified function.

If any of the sources never produces an item but only terminates (normally or with an error), the resulting sequence terminates immediately (normally or with all the errors accumulated till that point). If that input source is also synchronous, other sources after it will not be subscribed to.

Scheduler:

combineLatest does not operate by default on a particular Scheduler.

Type Parameters:

T1 - the element type of the first source

T2 - the element type of the second source

T3 - the element type of the third source

T4 - the element type of the fourth source

T5 - the element type of the fifth source

T6 - the element type of the sixth source

T7 - the element type of the seventh source

R - the combined output type

Parameters:

source1 - the first source ObservableSource

source2 - the second source ObservableSource

source3 - the third source ObservableSource

source4 - the fourth source ObservableSource

source5 - the fifth source ObservableSource

source6 - the sixth source ObservableSource

source7 - the seventh source ObservableSource

combiner - the aggregation function used to combine the items emitted by the ObservableSources

Returns:

the new Observable instance

Throws:

NullPointerException - if source1, source2, source3, source4, source5, source6, source7 or combiner is null

See Also:

ReactiveX operators documentation: CombineLatest

combineLatest

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public static <T1,T2,T3,T4,T5,T6,T7,T8,R> @NonNull Observable<R> combineLatest(@NonNull ObservableSource<? extends T1> source1,
        @NonNull ObservableSource<? extends T2> source2,
        @NonNull ObservableSource<? extends T3> source3,
        @NonNull ObservableSource<? extends T4> source4,
        @NonNull ObservableSource<? extends T5> source5,
        @NonNull ObservableSource<? extends T6> source6,
        @NonNull ObservableSource<? extends T7> source7,
        @NonNull ObservableSource<? 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 ObservableSources by emitting an item that aggregates the latest values of each of the ObservableSources each time an item is received from any of the ObservableSources, where this aggregation is defined by a specified function.

If any of the sources never produces an item but only terminates (normally or with an error), the resulting sequence terminates immediately (normally or with all the errors accumulated till that point). If that input source is also synchronous, other sources after it will not be subscribed to.

Scheduler:

combineLatest does not operate by default on a particular Scheduler.

Type Parameters:

T1 - the element type of the first source

T2 - the element type of the second source

T3 - the element type of the third source

T4 - the element type of the fourth source

T5 - the element type of the fifth source

T6 - the element type of the sixth source

T7 - the element type of the seventh source

T8 - the element type of the eighth source

R - the combined output type

Parameters:

source1 - the first source ObservableSource

source2 - the second source ObservableSource

source3 - the third source ObservableSource

source4 - the fourth source ObservableSource

source5 - the fifth source ObservableSource

source6 - the sixth source ObservableSource

source7 - the seventh source ObservableSource

source8 - the eighth source ObservableSource

combiner - the aggregation function used to combine the items emitted by the ObservableSources

Returns:

the new Observable instance

Throws:

NullPointerException - if source1, source2, source3, source4, source5, source6, source7, source8 or combiner is null

See Also:

ReactiveX operators documentation: CombineLatest

combineLatest

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public static <T1,T2,T3,T4,T5,T6,T7,T8,T9,R> @NonNull Observable<R> combineLatest(@NonNull ObservableSource<? extends T1> source1,
        @NonNull ObservableSource<? extends T2> source2,
        @NonNull ObservableSource<? extends T3> source3,
        @NonNull ObservableSource<? extends T4> source4,
        @NonNull ObservableSource<? extends T5> source5,
        @NonNull ObservableSource<? extends T6> source6,
        @NonNull ObservableSource<? extends T7> source7,
        @NonNull ObservableSource<? extends T8> source8,
        @NonNull ObservableSource<? 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 ObservableSources by emitting an item that aggregates the latest values of each of the ObservableSources each time an item is received from any of the ObservableSources, where this aggregation is defined by a specified function.

If any of the sources never produces an item but only terminates (normally or with an error), the resulting sequence terminates immediately (normally or with all the errors accumulated till that point). If that input source is also synchronous, other sources after it will not be subscribed to.

Scheduler:

combineLatest does not operate by default on a particular Scheduler.

Type Parameters:

T1 - the element type of the first source

T2 - the element type of the second source

T3 - the element type of the third source

T4 - the element type of the fourth source

T5 - the element type of the fifth source

T6 - the element type of the sixth source

T7 - the element type of the seventh source

T8 - the element type of the eighth source

T9 - the element type of the ninth source

R - the combined output type

Parameters:

source1 - the first source ObservableSource

source2 - the second source ObservableSource

source3 - the third source ObservableSource

source4 - the fourth source ObservableSource

source5 - the fifth source ObservableSource

source6 - the sixth source ObservableSource

source7 - the seventh source ObservableSource

source8 - the eighth source ObservableSource

source9 - the ninth source ObservableSource

combiner - the aggregation function used to combine the items emitted by the ObservableSources

Returns:

the new Observable instance

Throws:

NullPointerException - if source1, source2, source3, source4, source5, source6, source7, source8, source9 or combiner is null

See Also:

ReactiveX operators documentation: CombineLatest

combineLatestArrayDelayError

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public static <T,R> @NonNull Observable<R> combineLatestArrayDelayError(@NonNull ObservableSource<? extends T>[] sources,
        @NonNull Function<? super Object[],? extends R> combiner)

Combines an array of ObservableSources by emitting an item that aggregates the latest values of each of the ObservableSources each time an item is received from any of the ObservableSources, where this aggregation is defined by a specified function.

Note on method signature: since Java doesn't allow creating a generic array with new T[], the implementation of this operator has to create an Object[] instead. Unfortunately, a Function<Integer[], R> passed to the method would trigger a ClassCastException.

If any of the sources never produces an item but only terminates (normally or with an error), the resulting sequence terminates immediately (normally or with all the errors accumulated till that point). If that input source is also synchronous, other sources after it will not be subscribed to.

If the provided array of ObservableSources is empty, the resulting sequence completes immediately without emitting any items and without any calls to the combiner function.

Scheduler:

combineLatestArrayDelayError does not operate by default on a particular Scheduler.

Type Parameters:

T - the common base type of source values

R - the result type

Parameters:

sources - the collection of source ObservableSources

combiner - the aggregation function used to combine the items emitted by the ObservableSources

Returns:

the new Observable instance

Throws:

NullPointerException - if sources or combiner is null

See Also:

ReactiveX operators documentation: CombineLatest

combineLatestArrayDelayError

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public static <T,R> @NonNull Observable<R> combineLatestArrayDelayError(@NonNull ObservableSource<? extends T>[] sources,
        @NonNull Function<? super Object[],? extends R> combiner,
        int bufferSize)

Combines an array of ObservableSources by emitting an item that aggregates the latest values of each of the ObservableSources each time an item is received from any of the ObservableSources, where this aggregation is defined by a specified function and delays any error from the sources until all source ObservableSources terminate.

Note on method signature: since Java doesn't allow creating a generic array with new T[], the implementation of this operator has to create an Object[] instead. Unfortunately, a Function<Integer[], R> passed to the method would trigger a ClassCastException.

If any of the sources never produces an item but only terminates (normally or with an error), the resulting sequence terminates immediately (normally or with all the errors accumulated till that point). If that input source is also synchronous, other sources after it will not be subscribed to.

If the provided array of ObservableSources is empty, the resulting sequence completes immediately without emitting any items and without any calls to the combiner function.

Scheduler:

combineLatestArrayDelayError does not operate by default on a particular Scheduler.

Type Parameters:

T - the common base type of source values

R - the result type

Parameters:

sources - the collection of source ObservableSources

combiner - the aggregation function used to combine the items emitted by the ObservableSources

bufferSize - the expected number of row combination items to be buffered internally

Returns:

the new Observable instance

Throws:

NullPointerException - if sources or combiner is null

IllegalArgumentException - if bufferSize is non-positive

See Also:

ReactiveX operators documentation: CombineLatest

combineLatestDelayError

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public static <T,R> @NonNull Observable<R> combineLatestDelayError(@NonNull Iterable<? extends ObservableSource<? extends T>> sources,
        @NonNull Function<? super Object[],? extends R> combiner)

Combines an Iterable of ObservableSources by emitting an item that aggregates the latest values of each of the ObservableSources each time an item is received from any of the ObservableSources, where this aggregation is defined by a specified function and delays any error from the sources until all source ObservableSources terminate.

Note on method signature: since Java doesn't allow creating a generic array with new T[], the implementation of this operator has to create an Object[] instead. Unfortunately, a Function<Integer[], R> passed to the method would trigger a ClassCastException.

If any of the sources never produces an item but only terminates (normally or with an error), the resulting sequence terminates immediately (normally or with all the errors accumulated till that point). If that input source is also synchronous, other sources after it will not be subscribed to.

If the provided iterable of ObservableSources is empty, the resulting sequence completes immediately without emitting any items and without any calls to the combiner function.

Scheduler:

combineLatestDelayError does not operate by default on a particular Scheduler.

Type Parameters:

T - the common base type of source values

R - the result type

Parameters:

sources - the Iterable of source ObservableSources

combiner - the aggregation function used to combine the items emitted by the ObservableSources

Returns:

the new Observable instance

Throws:

NullPointerException - if sources or combiner is null

See Also:

ReactiveX operators documentation: CombineLatest

combineLatestDelayError

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public static <T,R> @NonNull Observable<R> combineLatestDelayError(@NonNull Iterable<? extends ObservableSource<? extends T>> sources,
        @NonNull Function<? super Object[],? extends R> combiner,
        int bufferSize)

Combines an Iterable of ObservableSources by emitting an item that aggregates the latest values of each of the ObservableSources each time an item is received from any of the ObservableSources, where this aggregation is defined by a specified function and delays any error from the sources until all source ObservableSources terminate.

Note on method signature: since Java doesn't allow creating a generic array with new T[], the implementation of this operator has to create an Object[] instead. Unfortunately, a Function<Integer[], R> passed to the method would trigger a ClassCastException.

If any of the sources never produces an item but only terminates (normally or with an error), the resulting sequence terminates immediately (normally or with all the errors accumulated till that point). If that input source is also synchronous, other sources after it will not be subscribed to.

If the provided iterable of ObservableSources is empty, the resulting sequence completes immediately without emitting any items and without any calls to the combiner function.

Scheduler:

combineLatestDelayError does not operate by default on a particular Scheduler.

Type Parameters:

T - the common base type of source values

R - the result type

Parameters:

sources - the collection of source ObservableSources

combiner - the aggregation function used to combine the items emitted by the ObservableSources

bufferSize - the expected number of row combination items to be buffered internally

Returns:

the new Observable instance

Throws:

NullPointerException - if sources or combiner is null

IllegalArgumentException - if bufferSize is non-positive

See Also:

ReactiveX operators documentation: CombineLatest

concat

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public static <T> @NonNull Observable<T> concat(@NonNull Iterable<? extends ObservableSource<? extends T>> sources)

Concatenates elements of each ObservableSource provided via an Iterable sequence into a single sequence of elements without interleaving them.

Scheduler:

concat does not operate by default on a particular Scheduler.

Type Parameters:

T - the common value type of the sources

Parameters:

sources - the Iterable sequence of ObservableSources

Returns:

the new Observable instance

Throws:

NullPointerException - if sources is null

concat

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public static <T> @NonNull Observable<T> concat(@NonNull ObservableSource<? extends ObservableSource<? extends T>> sources)

Returns an Observable that emits the items emitted by each of the ObservableSources emitted by the ObservableSource, one after the other, without interleaving them.

Scheduler:

concat does not operate by default on a particular Scheduler.

Type Parameters:

T - the common element base type

Parameters:

sources - an ObservableSource that emits ObservableSources

Returns:

the new Observable instance

Throws:

NullPointerException - if sources is null

See Also:

ReactiveX operators documentation: Concat

concat

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public static <T> @NonNull Observable<T> concat(@NonNull ObservableSource<? extends ObservableSource<? extends T>> sources,
        int bufferSize)

Returns an Observable that emits the items emitted by each of the ObservableSources emitted by the outer ObservableSource, one after the other, without interleaving them.

Scheduler:

concat does not operate by default on a particular Scheduler.

Type Parameters:

T - the common element base type

Parameters:

sources - an ObservableSource that emits ObservableSources

bufferSize - the number of inner ObservableSources expected to be buffered.

Returns:

the new Observable instance

Throws:

NullPointerException - if sources is null

IllegalArgumentException - if bufferSize is non-positive

See Also:

ReactiveX operators documentation: Concat

concat

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public static <T> @NonNull Observable<T> concat(@NonNull ObservableSource<? extends T> source1,
        ObservableSource<? extends T> source2)

Returns an Observable that emits the items emitted by two ObservableSources, one after the other, without interleaving them.

Scheduler:

concat does not operate by default on a particular Scheduler.

Type Parameters:

T - the common element base type

Parameters:

source1 - an ObservableSource to be concatenated

source2 - an ObservableSource to be concatenated

Returns:

the new Observable instance

Throws:

NullPointerException - if source1 or source2 is null

See Also:

ReactiveX operators documentation: Concat

concat

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public static <T> @NonNull Observable<T> concat(@NonNull ObservableSource<? extends T> source1,
        @NonNull ObservableSource<? extends T> source2,
        @NonNull ObservableSource<? extends T> source3)

Returns an Observable that emits the items emitted by three ObservableSources, one after the other, without interleaving them.

Scheduler:

concat does not operate by default on a particular Scheduler.

Type Parameters:

T - the common element base type

Parameters:

source1 - an ObservableSource to be concatenated

source2 - an ObservableSource to be concatenated

source3 - an ObservableSource to be concatenated

Returns:

the new Observable instance

Throws:

NullPointerException - if source1, source2 or source3 is null

See Also:

ReactiveX operators documentation: Concat

concat

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public static <T> @NonNull Observable<T> concat(@NonNull ObservableSource<? extends T> source1,
        @NonNull ObservableSource<? extends T> source2,
        @NonNull ObservableSource<? extends T> source3,
        @NonNull ObservableSource<? extends T> source4)

Returns an Observable that emits the items emitted by four ObservableSources, one after the other, without interleaving them.

Scheduler:

concat does not operate by default on a particular Scheduler.

Type Parameters:

T - the common element base type

Parameters:

source1 - an ObservableSource to be concatenated

source2 - an ObservableSource to be concatenated

source3 - an ObservableSource to be concatenated

source4 - an ObservableSource to be concatenated

Returns:

the new Observable instance

Throws:

NullPointerException - if source1, source2, source3 or source4 is null

See Also:

ReactiveX operators documentation: Concat

concatArray

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
 @SafeVarargs
public static <T> @NonNull Observable<T> concatArray(@NonNull ObservableSource<? extends T>... sources)

Concatenates a variable number of ObservableSource sources.

Note: named this way because of overload conflict with concat(ObservableSource<ObservableSource>)

Scheduler:

concatArray does not operate by default on a particular Scheduler.

Type Parameters:

T - the common base value type

Parameters:

sources - the array of sources

Returns:

the new Observable instance

Throws:

NullPointerException - if sources is null

concatArrayDelayError

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
 @SafeVarargs
public static <T> @NonNull Observable<T> concatArrayDelayError(@NonNull ObservableSource<? extends T>... sources)

Concatenates a variable number of ObservableSource sources and delays errors from any of them till all terminate.

Scheduler:

concatArrayDelayError does not operate by default on a particular Scheduler.

Type Parameters:

T - the common base value type

Parameters:

sources - the array of sources

Returns:

the new Observable instance

Throws:

NullPointerException - if sources is null

concatArrayEager

@CheckReturnValue
 @SchedulerSupport(value="none")
 @SafeVarargs
 @NonNull
public static <T> @NonNull Observable<T> concatArrayEager(@NonNull ObservableSource<? extends T>... sources)

Concatenates an array of ObservableSources eagerly into a single stream of values.

Eager concatenation means that once a subscriber subscribes, this operator subscribes to all of the ObservableSources. The operator buffers the values emitted by these ObservableSources and then drains them in order, each one after the previous one completes.

Scheduler:

This method does not operate by default on a particular Scheduler.

Type Parameters:

T - the value type

Parameters:

sources - an array of ObservableSources that need to be eagerly concatenated

Returns:

the new Observable instance with the specified concatenation behavior

Throws:

NullPointerException - if sources is null

Since:

2.0

concatArrayEager

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
 @SafeVarargs
public static <T> @NonNull Observable<T> concatArrayEager(int maxConcurrency,
        int bufferSize,
        @NonNull ObservableSource<? extends T>... sources)

Concatenates an array of ObservableSources eagerly into a single stream of values.

Eager concatenation means that once a subscriber subscribes, this operator subscribes to all of the ObservableSources. The operator buffers the values emitted by these ObservableSources and then drains them in order, each one after the previous one completes.

Scheduler:

This method does not operate by default on a particular Scheduler.

Type Parameters:

T - the value type

Parameters:

sources - an array of ObservableSources that need to be eagerly concatenated

maxConcurrency - the maximum number of concurrent subscriptions at a time, Integer.MAX_VALUE is interpreted as indication to subscribe to all sources at once

bufferSize - the number of elements expected from each ObservableSource to be buffered

Returns:

the new Observable instance with the specified concatenation behavior

Throws:

NullPointerException - if sources is null

IllegalArgumentException - if maxConcurrency or bufferSize is non-positive

Since:

2.0

concatArrayEagerDelayError

@CheckReturnValue
 @SchedulerSupport(value="none")
 @SafeVarargs
 @NonNull
public static <T> @NonNull Observable<T> concatArrayEagerDelayError(@NonNull ObservableSource<? extends T>... sources)

Concatenates an array of ObservableSources eagerly into a single stream of values and delaying any errors until all sources terminate.

Eager concatenation means that once a subscriber subscribes, this operator subscribes to all of the ObservableSources. The operator buffers the values emitted by these ObservableSources and then drains them in order, each one after the previous one completes.

Scheduler:

This method does not operate by default on a particular Scheduler.

Type Parameters:

T - the value type

Parameters:

sources - an array of ObservableSources that need to be eagerly concatenated

Returns:

the new Observable instance with the specified concatenation behavior

Throws:

NullPointerException - if sources is null

Since:

2.2.1 - experimental

concatArrayEagerDelayError

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
 @SafeVarargs
public static <T> @NonNull Observable<T> concatArrayEagerDelayError(int maxConcurrency,
        int bufferSize,
        @NonNull ObservableSource<? extends T>... sources)

Concatenates an array of ObservableSources eagerly into a single stream of values and delaying any errors until all sources terminate.

Eager concatenation means that once a subscriber subscribes, this operator subscribes to all of the ObservableSources. The operator buffers the values emitted by these ObservableSources and then drains them in order, each one after the previous one completes.

Scheduler:

This method does not operate by default on a particular Scheduler.

Type Parameters:

T - the value type

Parameters:

sources - an array of ObservableSources that need to be eagerly concatenated

maxConcurrency - the maximum number of concurrent subscriptions at a time, Integer.MAX_VALUE is interpreted as indication to subscribe to all sources at once

bufferSize - the number of elements expected from each ObservableSource to be buffered

Returns:

the new Observable instance with the specified concatenation behavior

Throws:

NullPointerException - if sources is null

IllegalArgumentException - if maxConcurrency or bufferSize is non-positive

Since:

2.2.1 - experimental

concatDelayError

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public static <T> @NonNull Observable<T> concatDelayError(@NonNull Iterable<? extends ObservableSource<? extends T>> sources)

Concatenates the Iterable sequence of ObservableSources into a single Observable sequence by subscribing to each ObservableSource, one after the other, one at a time and delays any errors till the all inner ObservableSources terminate.

Scheduler:

concatDelayError does not operate by default on a particular Scheduler.

Type Parameters:

T - the common element base type

Parameters:

sources - the Iterable sequence of ObservableSources

Returns:

the new Observable with the concatenating behavior

Throws:

NullPointerException - if sources is null

concatDelayError

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public static <T> @NonNull Observable<T> concatDelayError(@NonNull ObservableSource<? extends ObservableSource<? extends T>> sources)

Concatenates the ObservableSource sequence of ObservableSources into a single Observable sequence by subscribing to each inner ObservableSource, one after the other, one at a time and delays any errors till the all inner and the outer ObservableSources terminate.

Scheduler:

concatDelayError does not operate by default on a particular Scheduler.

Type Parameters:

T - the common element base type

Parameters:

sources - the ObservableSource sequence of ObservableSources

Returns:

the new Observable with the concatenating behavior

Throws:

NullPointerException - if sources is null

concatDelayError

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public static <T> @NonNull Observable<T> concatDelayError(@NonNull ObservableSource<? extends ObservableSource<? extends T>> sources,
        int bufferSize,
        boolean tillTheEnd)

Concatenates the ObservableSource sequence of ObservableSources into a single sequence by subscribing to each inner ObservableSource, one after the other, one at a time and delays any errors till the all inner and the outer ObservableSources terminate.

Scheduler:

concatDelayError does not operate by default on a particular Scheduler.

Type Parameters:

T - the common element base type

Parameters:

sources - the ObservableSource sequence of ObservableSources

bufferSize - the number of inner ObservableSources expected to be buffered

tillTheEnd - if true, exceptions from the outer and all inner ObservableSources are delayed to the end if false, exception from the outer ObservableSource is delayed till the active ObservableSource terminates

Returns:

the new Observable with the concatenating behavior

Throws:

NullPointerException - if sources is null

IllegalArgumentException - if bufferSize is non-positive

concatEager

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public static <T> @NonNull Observable<T> concatEager(@NonNull Iterable<? extends ObservableSource<? extends T>> sources)

Concatenates a sequence of ObservableSources eagerly into a single stream of values.

Eager concatenation means that once a subscriber subscribes, this operator subscribes to all of the ObservableSources. The operator buffers the values emitted by these ObservableSources and then drains them in order, each one after the previous one completes.

Scheduler:

This method does not operate by default on a particular Scheduler.

Type Parameters:

T - the value type

Parameters:

sources - a sequence of ObservableSources that need to be eagerly concatenated

Returns:

the new Observable instance with the specified concatenation behavior

Throws:

NullPointerException - if sources is null

Since:

2.0

concatEager

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public static <T> @NonNull Observable<T> concatEager(@NonNull Iterable<? extends ObservableSource<? extends T>> sources,
        int maxConcurrency,
        int bufferSize)

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

Eager concatenation means that once a subscriber subscribes, this operator subscribes to all of the ObservableSources. The operator buffers the values emitted by these ObservableSources and then drains them in order, each one after the previous one completes.

Scheduler:

This method does not operate by default on a particular Scheduler.

Type Parameters:

T - the value type

Parameters:

sources - a sequence of ObservableSources that need to be eagerly concatenated

maxConcurrency - the maximum number of concurrently running inner ObservableSources; Integer.MAX_VALUE is interpreted as all inner ObservableSources can be active at the same time

bufferSize - the number of elements expected from each inner ObservableSource to be buffered

Returns:

the new Observable instance with the specified concatenation behavior

Throws:

NullPointerException - if sources is null

IllegalArgumentException - if maxConcurrency or bufferSize is non-positive

Since:

2.0

concatEager

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public static <T> @NonNull Observable<T> concatEager(@NonNull ObservableSource<? extends ObservableSource<? extends T>> sources)

Concatenates an ObservableSource sequence of ObservableSources eagerly into a single stream of values.

Eager concatenation means that once a subscriber subscribes, this operator subscribes to all of the emitted source ObservableSources as they are observed. The operator buffers the values emitted by these ObservableSources and then drains them in order, each one after the previous one completes.

Scheduler:

This method does not operate by default on a particular Scheduler.

Type Parameters:

T - the value type

Parameters:

sources - a sequence of ObservableSources that need to be eagerly concatenated

Returns:

the new Observable instance with the specified concatenation behavior

Throws:

NullPointerException - if sources is null

Since:

2.0

concatEager

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public static <T> @NonNull Observable<T> concatEager(@NonNull ObservableSource<? extends ObservableSource<? extends T>> sources,
        int maxConcurrency,
        int bufferSize)

Concatenates an ObservableSource sequence of ObservableSources eagerly into a single stream of values and runs a limited number of inner sequences at once.

Eager concatenation means that once a subscriber subscribes, this operator subscribes to all of the emitted source ObservableSources as they are observed. The operator buffers the values emitted by these ObservableSources and then drains them in order, each one after the previous one completes.

Scheduler:

This method does not operate by default on a particular Scheduler.

Type Parameters:

T - the value type

Parameters:

sources - a sequence of ObservableSources that need to be eagerly concatenated

maxConcurrency - the maximum number of concurrently running inner ObservableSources; Integer.MAX_VALUE is interpreted as all inner ObservableSources can be active at the same time

bufferSize - the number of inner ObservableSource expected to be buffered

Returns:

the new Observable instance with the specified concatenation behavior

Throws:

NullPointerException - if sources is null

IllegalArgumentException - if maxConcurrency or bufferSize is non-positive

Since:

2.0

concatEagerDelayError

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public static <T> @NonNull Observable<T> concatEagerDelayError(@NonNull Iterable<? extends ObservableSource<? extends T>> sources)

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

Eager concatenation means that once a subscriber subscribes, this operator subscribes to all of the ObservableSources. The operator buffers the values emitted by these ObservableSources and then drains them in order, each one after the previous one completes.

Scheduler:

This method does not operate by default on a particular Scheduler.

Type Parameters:

T - the value type

Parameters:

sources - a sequence of ObservableSources that need to be eagerly concatenated

Returns:

the new Observable instance with the specified concatenation behavior

Throws:

NullPointerException - if sources is null

Since:

3.0.0

concatEagerDelayError

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public static <T> @NonNull Observable<T> concatEagerDelayError(@NonNull Iterable<? extends ObservableSource<? extends T>> sources,
        int maxConcurrency,
        int bufferSize)

Concatenates a sequence of ObservableSources 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.

Eager concatenation means that once a subscriber subscribes, this operator subscribes to all of the ObservableSources. The operator buffers the values emitted by these ObservableSources and then drains them in order, each one after the previous one completes.

Scheduler:

This method does not operate by default on a particular Scheduler.

Type Parameters:

T - the value type

Parameters:

sources - a sequence of ObservableSources that need to be eagerly concatenated

maxConcurrency - the maximum number of concurrently running inner ObservableSources; Integer.MAX_VALUE is interpreted as all inner ObservableSources can be active at the same time

bufferSize - the number of elements expected from each inner ObservableSource to be buffered

Returns:

the new Observable instance with the specified concatenation behavior

Throws:

NullPointerException - if sources is null

IllegalArgumentException - if maxConcurrency or bufferSize is non-positive

Since:

3.0.0

concatEagerDelayError

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public static <T> @NonNull Observable<T> concatEagerDelayError(@NonNull ObservableSource<? extends ObservableSource<? extends T>> sources)

Concatenates an ObservableSource sequence of ObservableSources eagerly into a single stream of values, delaying errors until all the inner and the outer sequence terminate.

Eager concatenation means that once a subscriber subscribes, this operator subscribes to all of the emitted source ObservableSources as they are observed. The operator buffers the values emitted by these ObservableSources and then drains them in order, each one after the previous one completes.

Scheduler:

This method does not operate by default on a particular Scheduler.

Type Parameters:

T - the value type

Parameters:

sources - a sequence of ObservableSources that need to be eagerly concatenated

Returns:

the new Observable instance with the specified concatenation behavior

Throws:

NullPointerException - if sources is null

Since:

3.0.0

concatEagerDelayError

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public static <T> @NonNull Observable<T> concatEagerDelayError(@NonNull ObservableSource<? extends ObservableSource<? extends T>> sources,
        int maxConcurrency,
        int bufferSize)

Concatenates an ObservableSource sequence of ObservableSources eagerly into a single stream of values, delaying errors until all the inner and the outer sequence terminate and runs a limited number of inner sequences at once.

Eager concatenation means that once a subscriber subscribes, this operator subscribes to all of the emitted source ObservableSources as they are observed. The operator buffers the values emitted by these ObservableSources and then drains them in order, each one after the previous one completes.

Scheduler:

This method does not operate by default on a particular Scheduler.

Type Parameters:

T - the value type

Parameters:

sources - a sequence of ObservableSources that need to be eagerly concatenated

maxConcurrency - the maximum number of concurrently running inner ObservableSources; Integer.MAX_VALUE is interpreted as all inner ObservableSources can be active at the same time

bufferSize - the number of inner ObservableSource expected to be buffered

Returns:

the new Observable instance with the specified concatenation behavior

Throws:

NullPointerException - if sources is null

IllegalArgumentException - if maxConcurrency or bufferSize is non-positive

Since:

3.0.0

create

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public static <T> @NonNull Observable<T> create(@NonNull ObservableOnSubscribe<T> source)

Provides an API (via a cold Observable) that bridges the reactive world with the callback-style world.

Example:

 Observable.<Event>create(emitter -> {
     Callback listener = new Callback() {
         @Override
         public void onEvent(Event e) {
             emitter.onNext(e);
             if (e.isLast()) {
                 emitter.onComplete();
             }
         }

         @Override
         public void onFailure(Exception e) {
             emitter.onError(e);
         }
     };

     AutoCloseable c = api.someMethod(listener);

     emitter.setCancellable(c::close);

 });
 

Whenever an Observer subscribes to the returned Observable, the provided ObservableOnSubscribe callback is invoked with a fresh instance of an ObservableEmitter that will interact only with that specific Observer. If this Observer disposes the flow (making ObservableEmitter.isDisposed() return true), other observers subscribed to the same returned Observable are not affected.

You should call the ObservableEmitter's onNext, onError and onComplete methods in a serialized fashion. The rest of its methods are thread-safe.

Scheduler:

create does not operate by default on a particular Scheduler.

Type Parameters:

T - the element type

Parameters:

source - the emitter that is called when an Observer subscribes to the returned Observable

Returns:

the new Observable instance

Throws:

NullPointerException - if source is null

See Also:

ObservableOnSubscribe, ObservableEmitter, Cancellable

defer

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public static <T> @NonNull Observable<T> defer(@NonNull Supplier<? extends ObservableSource<? extends T>> supplier)

Returns an Observable that calls an ObservableSource factory to create an ObservableSource for each new Observer that subscribes. That is, for each subscriber, the actual ObservableSource that subscriber observes is determined by the factory function.

The defer operator allows you to defer or delay emitting items from an ObservableSource until such time as an Observer subscribes to the ObservableSource. This allows an Observer to easily obtain updates or a refreshed version of the sequence.

Scheduler:

defer does not operate by default on a particular Scheduler.

Type Parameters:

T - the type of the items emitted by the ObservableSource

Parameters:

supplier - the ObservableSource factory function to invoke for each Observer that subscribes to the resulting Observable

Returns:

the new Observable instance

Throws:

NullPointerException - if supplier is null

See Also:

ReactiveX operators documentation: Defer

empty

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public static <T> @NonNull Observable<T> empty()

Returns an Observable that emits no items to the Observer and immediately invokes its onComplete method.

Scheduler:

empty does not operate by default on a particular Scheduler.

Type Parameters:

T - the type of the items (ostensibly) emitted by the Observable

Returns:

the shared Observable instance

See Also:

ReactiveX operators documentation: Empty

error

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public static <T> @NonNull Observable<T> error(@NonNull Supplier<? extends Throwable> supplier)

Returns an Observable that invokes an Observer's onError method when the Observer subscribes to it.

Scheduler:

error does not operate by default on a particular Scheduler.

Type Parameters:

T - the type of the items (ostensibly) emitted by the Observable

Parameters:

supplier - a Supplier factory to return a Throwable for each individual Observer

Returns:

the new Observable instance

Throws:

NullPointerException - if supplier is null

See Also:

ReactiveX operators documentation: Throw

error

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public static <T> @NonNull Observable<T> error(@NonNull Throwable throwable)

Returns an Observable that invokes an Observer's onError method when the Observer subscribes to it.

Scheduler:

error does not operate by default on a particular Scheduler.

Type Parameters:

T - the type of the items (ostensibly) emitted by the Observable

Parameters:

throwable - the particular Throwable to pass to onError

Returns:

the new Observable instance

Throws:

NullPointerException - if throwable is null

See Also:

ReactiveX operators documentation: Throw

fromAction

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public static <T> @NonNull Observable<T> fromAction(@NonNull Action action)

Returns an Observable instance that runs the given Action for each Observer and emits either its exception or simply completes.

Scheduler:

fromAction does not operate by default on a particular Scheduler.

Error handling:

If the Action throws an exception, the respective Throwable is delivered to the downstream via Observer.onError(Throwable), except when the downstream has canceled the resulting Observable source. In this latter case, the Throwable is delivered to the global error handler via RxJavaPlugins.onError(Throwable) as an UndeliverableException.

Type Parameters:

T - the target type

Parameters:

action - the Action to run for each Observer

Returns:

the new Observable instance

Throws:

NullPointerException - if action is null

Since:

3.0.0

fromArray

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
 @SafeVarargs
public static <T> @NonNull Observable<T> fromArray(@NonNull T... items)

Converts an array into an ObservableSource that emits the items in the array.

Scheduler:

fromArray does not operate by default on a particular Scheduler.

Type Parameters:

T - the type of items in the array and the type of items to be emitted by the resulting Observable

Parameters:

items - the array of elements

Returns:

the new Observable instance

Throws:

NullPointerException - if items is null

See Also:

ReactiveX operators documentation: From

fromCallable

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public static <T> @NonNull Observable<T> fromCallable(@NonNull Callable<? extends T> callable)

Returns an Observable that, when an observer subscribes to it, invokes a function you specify and then emits the value returned from that function.

This allows you to defer the execution of the function you specify until an observer subscribes to the Observable. That is to say, it makes the function "lazy."

Scheduler:

fromCallable does not operate by default on a particular Scheduler.

Error handling:

If the Callable throws an exception, the respective Throwable is delivered to the downstream via Observer.onError(Throwable), except when the downstream has disposed the current Observable source. In this latter case, the Throwable is delivered to the global error handler via RxJavaPlugins.onError(Throwable) as an UndeliverableException.

Type Parameters:

T - the type of the item returned by the Callable and emitted by the Observable

Parameters:

callable - a function, the execution of which should be deferred; fromCallable will invoke this function only when an observer subscribes to the Observable that fromCallable returns

Returns:

the new Observable instance

Throws:

NullPointerException - if callable is null

Since:

2.0

See Also:

defer(Supplier), fromSupplier(Supplier)

fromCompletable

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public static <T> @NonNull Observable<T> fromCompletable(@NonNull CompletableSource completableSource)

Wraps a CompletableSource into an Observable.

Scheduler:

fromCompletable does not operate by default on a particular Scheduler.

Type Parameters:

T - the target type

Parameters:

completableSource - the CompletableSource to convert from

Returns:

the new Observable instance

Throws:

NullPointerException - if completableSource is null

fromFuture

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public static <T> @NonNull Observable<T> fromFuture(@NonNull Future<? extends T> future)

Converts a Future into an Observable.

The operator calls Future.get(), which is a blocking method, on the subscription thread. It is recommended applying subscribeOn(Scheduler) to move this blocking wait to a background thread, and if the Scheduler supports it, interrupt the wait when the flow is disposed.

Unlike 1.x, disposing the Observable won't cancel the future. If necessary, one can use composition to achieve the cancellation effect: futureObservableSource.doOnDispose(() -> future.cancel(true));.

Also note that this operator will consume a CompletionStage-based Future subclass (such as CompletableFuture) in a blocking manner as well. Use the fromCompletionStage(CompletionStage) operator to convert and consume such sources in a non-blocking fashion instead.

Scheduler:

fromFuture does not operate by default on a particular Scheduler.

Type Parameters:

T - the type of object that the Future returns, and also the type of item to be emitted by the resulting Observable

Parameters:

future - the source Future

Returns:

the new Observable instance

Throws:

NullPointerException - if future is null

See Also:

ReactiveX operators documentation: From, fromCompletionStage(CompletionStage)

fromFuture

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public static <T> @NonNull Observable<T> fromFuture(@NonNull Future<? extends T> future,
        long timeout,
        @NonNull TimeUnit unit)

Converts a Future into an Observable, with a timeout on the Future.

The operator calls Future.get(long, TimeUnit), which is a blocking method, on the subscription thread. It is recommended applying subscribeOn(Scheduler) to move this blocking wait to a background thread, and if the Scheduler supports it, interrupt the wait when the flow is disposed.

Unlike 1.x, disposing the Observable won't cancel the future. If necessary, one can use composition to achieve the cancellation effect: futureObservableSource.doOnDispose(() -> future.cancel(true));.

Also note that this operator will consume a CompletionStage-based Future subclass (such as CompletableFuture) in a blocking manner as well. Use the fromCompletionStage(CompletionStage) operator to convert and consume such sources in a non-blocking fashion instead.

Scheduler:

fromFuture does not operate by default on a particular Scheduler.

Type Parameters:

T - the type of object that the Future returns, and also the type of item to be emitted by the resulting Observable

Parameters:

future - the source Future

timeout - the maximum time to wait before calling get

unit - the TimeUnit of the timeout argument

Returns:

the new Observable instance

Throws:

NullPointerException - if future or unit is null

See Also:

ReactiveX operators documentation: From, fromCompletionStage(CompletionStage)

fromIterable

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public static <T> @NonNull Observable<T> fromIterable(@NonNull Iterable<? extends T> source)

Converts an Iterable sequence into an Observable that emits the items in the sequence.

Scheduler:

fromIterable does not operate by default on a particular Scheduler.

Type Parameters:

T - the type of items in the Iterable sequence and the type of items to be emitted by the resulting Observable

Parameters:

source - the source Iterable sequence

Returns:

the new Observable instance

Throws:

NullPointerException - if source is null

See Also:

ReactiveX operators documentation: From, fromStream(Stream)

fromMaybe

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public static <T> @NonNull Observable<T> fromMaybe(@NonNull MaybeSource<T> maybe)

Returns an Observable instance that when subscribed to, subscribes to the MaybeSource instance and emits onSuccess as a single item or forwards any onComplete or onError signal.

Scheduler:

fromMaybe does not operate by default on a particular Scheduler.

Type Parameters:

T - the value type of the MaybeSource element

Parameters:

maybe - the MaybeSource instance to subscribe to, not null

Returns:

the new Observable instance

Throws:

NullPointerException - if maybe is null

Since:

3.0.0

fromPublisher

@BackpressureSupport(value=UNBOUNDED_IN)
 @CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public static <T> @NonNull Observable<T> fromPublisher(@NonNull Publisher<? extends T> publisher)

Converts an arbitrary Reactive Streams Publisher into an Observable.

The Publisher must follow the Reactive-Streams specification. Violating the specification may result in undefined behavior.

If possible, use create(ObservableOnSubscribe) to create a source-like Observable instead.

Note that even though Publisher appears to be a functional interface, it is not recommended to implement it through a lambda as the specification requires state management that is not achievable with a stateless lambda.

Backpressure:

The source publisher is consumed in an unbounded fashion without applying any backpressure to it.

Scheduler:

fromPublisher does not operate by default on a particular Scheduler.

Type Parameters:

T - the value type of the flow

Parameters:

publisher - the Publisher to convert

Returns:

the new Observable instance

Throws:

NullPointerException - if publisher is null

See Also:

create(ObservableOnSubscribe)

fromRunnable

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public static <T> @NonNull Observable<T> fromRunnable(@NonNull Runnable run)

Returns an Observable instance that runs the given Runnable for each Observer and emits either its unchecked exception or simply completes.

If the code to be wrapped needs to throw a checked or more broader Throwable exception, that exception has to be converted to an unchecked exception by the wrapped code itself. Alternatively, use the fromAction(Action) method which allows the wrapped code to throw any Throwable exception and will signal it to observers as-is.

Scheduler:

fromRunnable does not operate by default on a particular Scheduler.

Error handling:

If the Runnable throws an exception, the respective Throwable is delivered to the downstream via Observer.onError(Throwable), except when the downstream has canceled the resulting Observable source. In this latter case, the Throwable is delivered to the global error handler via RxJavaPlugins.onError(Throwable) as an UndeliverableException.

Type Parameters:

T - the target type

Parameters:

run - the Runnable to run for each Observer

Returns:

the new Observable instance

Throws:

NullPointerException - if run is null

Since:

3.0.0

See Also:

fromAction(Action)

fromSingle

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public static <T> @NonNull Observable<T> fromSingle(@NonNull SingleSource<T> source)

Returns an Observable instance that when subscribed to, subscribes to the SingleSource instance and emits onSuccess as a single item or forwards the onError signal.

Scheduler:

fromSingle does not operate by default on a particular Scheduler.

Type Parameters:

T - the value type of the SingleSource element

Parameters:

source - the SingleSource instance to subscribe to, not null

Returns:

the new Observable instance

Throws:

NullPointerException - if source is null

Since:

3.0.0

fromSupplier

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public static <T> @NonNull Observable<T> fromSupplier(@NonNull Supplier<? extends T> supplier)

Returns an Observable that, when an observer subscribes to it, invokes a supplier function you specify and then emits the value returned from that function.

This allows you to defer the execution of the function you specify until an observer subscribes to the Observable. That is to say, it makes the function "lazy."

Scheduler:

fromSupplier does not operate by default on a particular Scheduler.

Error handling:

If the Supplier throws an exception, the respective Throwable is delivered to the downstream via Observer.onError(Throwable), except when the downstream has disposed the current Observable source. In this latter case, the Throwable is delivered to the global error handler via RxJavaPlugins.onError(Throwable) as an UndeliverableException.

Type Parameters:

T - the type of the item emitted by the Observable

Parameters:

supplier - a function, the execution of which should be deferred; fromSupplier will invoke this function only when an observer subscribes to the Observable that fromSupplier returns

Returns:

the new Observable instance

Throws:

NullPointerException - if supplier is null

Since:

3.0.0

See Also:

defer(Supplier), fromCallable(Callable)

generate

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public static <T> @NonNull Observable<T> generate(@NonNull Consumer<Emitter<T>> generator)

Returns a cold, synchronous and stateless generator of values.

Note that the Emitter.onNext(T), Emitter.onError(java.lang.Throwable) and Emitter.onComplete() methods provided to the function via the Emitter instance should be called synchronously, never concurrently and only while the function body is executing. Calling them from multiple threads or outside the function call is not supported and leads to an undefined behavior.

Scheduler:

generate does not operate by default on a particular Scheduler.

Type Parameters:

T - the generated value type

Parameters:

generator - the Consumer called in a loop after a downstream Observer has subscribed. The callback then should call onNext, onError or onComplete to signal a value or a terminal event. Signaling multiple onNext in a call will make the operator signal IllegalStateException.

Returns:

the new Observable instance

Throws:

NullPointerException - if generator is null

generate

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public static <T,S> @NonNull Observable<T> generate(@NonNull Supplier<S> initialState,
        @NonNull BiConsumer<S,Emitter<T>> generator)

Returns a cold, synchronous and stateful generator of values.

Note that the Emitter.onNext(T), Emitter.onError(java.lang.Throwable) and Emitter.onComplete() methods provided to the function via the Emitter instance should be called synchronously, never concurrently and only while the function body is executing. Calling them from multiple threads or outside the function call is not supported and leads to an undefined behavior.

Scheduler:

generate does not operate by default on a particular Scheduler.

Type Parameters:

S - the type of the per-Observer state

T - the generated value type

Parameters:

initialState - the Supplier to generate the initial state for each Observer

generator - the BiConsumer called in a loop after a downstream Observer has subscribed. The callback then should call onNext, onError or onComplete to signal a value or a terminal event. Signaling multiple onNext in a call will make the operator signal IllegalStateException.

Returns:

the new Observable instance

Throws:

NullPointerException - if initialState or generator is null

generate

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public static <T,S> @NonNull Observable<T> generate(@NonNull Supplier<S> initialState,
        @NonNull BiConsumer<S,Emitter<T>> generator,
        @NonNull Consumer<? super S> disposeState)

Returns a cold, synchronous and stateful generator of values.

Note that the Emitter.onNext(T), Emitter.onError(java.lang.Throwable) and Emitter.onComplete() methods provided to the function via the Emitter instance should be called synchronously, never concurrently and only while the function body is executing. Calling them from multiple threads or outside the function call is not supported and leads to an undefined behavior.

Scheduler:

generate does not operate by default on a particular Scheduler.

Type Parameters:

S - the type of the per-Observer state

T - the generated value type

Parameters:

initialState - the Supplier to generate the initial state for each Observer

generator - the BiConsumer called in a loop after a downstream Observer has subscribed. The callback then should call onNext, onError or onComplete to signal a value or a terminal event. Signaling multiple onNext in a call will make the operator signal IllegalStateException.

disposeState - the Consumer that is called with the current state when the generator terminates the sequence or it gets disposed

Returns:

the new Observable instance

Throws:

NullPointerException - if initialState, generator or disposeState is null

generate

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public static <T,S> @NonNull Observable<T> generate(@NonNull Supplier<S> initialState,
        @NonNull BiFunction<S,Emitter<T>,S> generator)

Returns a cold, synchronous and stateful generator of values.

Note that the Emitter.onNext(T), Emitter.onError(java.lang.Throwable) and Emitter.onComplete() methods provided to the function via the Emitter instance should be called synchronously, never concurrently and only while the function body is executing. Calling them from multiple threads or outside the function call is not supported and leads to an undefined behavior.

Scheduler:

generate does not operate by default on a particular Scheduler.

Type Parameters:

S - the type of the per-Observer state

T - the generated value type

Parameters:

initialState - the Supplier to generate the initial state for each Observer

generator - the BiConsumer called in a loop after a downstream Observer has subscribed. The callback then should call onNext, onError or onComplete to signal a value or a terminal event and should return a (new) state for the next invocation. Signaling multiple onNext in a call will make the operator signal IllegalStateException.

Returns:

the new Observable instance

Throws:

NullPointerException - if initialState or generator is null

generate

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public static <T,S> @NonNull Observable<T> generate(@NonNull Supplier<S> initialState,
        @NonNull BiFunction<S,Emitter<T>,S> generator,
        @NonNull Consumer<? super S> disposeState)

Returns a cold, synchronous and stateful generator of values.

Note that the Emitter.onNext(T), Emitter.onError(java.lang.Throwable) and Emitter.onComplete() methods provided to the function via the Emitter instance should be called synchronously, never concurrently and only while the function body is executing. Calling them from multiple threads or outside the function call is not supported and leads to an undefined behavior.

Scheduler:

generate does not operate by default on a particular Scheduler.

Type Parameters:

S - the type of the per-Observer state

T - the generated value type

Parameters:

initialState - the Supplier to generate the initial state for each Observer

generator - the BiConsumer called in a loop after a downstream Observer has subscribed. The callback then should call onNext, onError or onComplete to signal a value or a terminal event and should return a (new) state for the next invocation. Signaling multiple onNext in a call will make the operator signal IllegalStateException.

disposeState - the Consumer that is called with the current state when the generator terminates the sequence or it gets disposed

Returns:

the new Observable instance

Throws:

NullPointerException - if initialState, generator or disposeState is null

interval

@CheckReturnValue
 @SchedulerSupport(value="io.reactivex:computation")
 @NonNull
public static @NonNull Observable<Long> interval(long initialDelay,
        long period,
        @NonNull TimeUnit unit)

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

Scheduler:

interval operates by default on the computation Scheduler.

Parameters:

initialDelay - the initial delay time to wait before emitting the first value of 0L

period - the period of time between emissions of the subsequent numbers

unit - the time unit for both initialDelay and period

Returns:

the new Observable instance

Throws:

NullPointerException - if unit is null

Since:

1.0.12

See Also:

ReactiveX operators documentation: Interval

interval

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="custom")
public static @NonNull Observable<Long> interval(long initialDelay,
        long period,
        @NonNull TimeUnit unit,
        @NonNull Scheduler scheduler)

Returns an Observable that emits a 0L after the initialDelay and ever increasing numbers after each period of time thereafter, on a specified Scheduler.

Scheduler:

You specify which Scheduler this operator will use.

Parameters:

initialDelay - the initial delay time to wait before emitting the first value of 0L

period - the period of time between emissions of the subsequent numbers

unit - the time unit for both initialDelay and period

scheduler - the Scheduler on which the waiting happens and items are emitted

Returns:

the new Observable instance

Throws:

NullPointerException - if unit or scheduler is null

Since:

1.0.12

See Also:

ReactiveX operators documentation: Interval

interval

@CheckReturnValue
 @SchedulerSupport(value="io.reactivex:computation")
 @NonNull
public static @NonNull Observable<Long> interval(long period,
        @NonNull TimeUnit unit)

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

Scheduler:

interval operates by default on the computation Scheduler.

Parameters:

period - the period size in time units (see below)

unit - time units to use for the interval size

Returns:

the new Observable instance

Throws:

NullPointerException - if unit is null

See Also:

ReactiveX operators documentation: Interval

interval

@CheckReturnValue
 @SchedulerSupport(value="custom")
 @NonNull
public static @NonNull Observable<Long> interval(long period,
        @NonNull TimeUnit unit,
        @NonNull Scheduler scheduler)

Returns an Observable that emits a sequential number every specified interval of time, on a specified Scheduler.

Scheduler:

You specify which Scheduler this operator will use.

Parameters:

period - the period size in time units (see below)

unit - time units to use for the interval size

scheduler - the Scheduler to use for scheduling the items

Returns:

the new Observable instance

Throws:

NullPointerException - if unit or scheduler is null

See Also:

ReactiveX operators documentation: Interval

intervalRange

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="io.reactivex:computation")
public static @NonNull Observable<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.

The sequence completes immediately after the last value (start + count - 1) has been reached.

Scheduler:

intervalRange by default operates on the computation Scheduler.

Parameters:

start - that start value of the range

count - the number of values to emit in total, if zero, the operator emits an onComplete after the initial delay.

initialDelay - the initial delay before signaling the first value (the start)

period - the period between subsequent values

unit - the unit of measure of the initialDelay and period amounts

Returns:

the new Observable instance

Throws:

NullPointerException - if unit is null

IllegalArgumentException - if count is negative, or if start + count − 1 exceeds Long.MAX_VALUE

See Also:

range(int, int)

intervalRange

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="custom")
public static @NonNull Observable<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.

The sequence completes immediately after the last value (start + count - 1) has been reached.

*

Scheduler:

you provide the Scheduler.

Parameters:

start - that start value of the range

count - the number of values to emit in total, if zero, the operator emits an onComplete after the initial delay.

initialDelay - the initial delay before signaling the first value (the start)

period - the period between subsequent values

unit - the unit of measure of the initialDelay and period amounts

scheduler - the target scheduler where the values and terminal signals will be emitted

Returns:

the new Observable instance

Throws:

NullPointerException - if unit or scheduler is null

IllegalArgumentException - if count is negative, or if start + count − 1 exceeds Long.MAX_VALUE

just

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public static <T> @NonNull Observable<T> just(@NonNull T item)

Returns an Observable that signals the given (constant reference) item and then completes.

Note that the item is taken and re-emitted as is and not computed by any means by just. Use fromCallable(Callable) to generate a single item on demand (when Observers subscribe to it).

See the multi-parameter overloads of just to emit more than one (constant reference) items one after the other. Use fromArray(Object...) to emit an arbitrary number of items that are known upfront.

To emit the items of an Iterable sequence (such as a List), use fromIterable(Iterable).

Scheduler:

just does not operate by default on a particular Scheduler.

Type Parameters:

T - the type of that item

Parameters:

item - the item to emit

Returns:

the new Observable instance

Throws:

NullPointerException - if item is null

See Also:

ReactiveX operators documentation: Just, just(Object, Object), fromCallable(Callable), fromArray(Object...), fromIterable(Iterable)

just

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public static <T> @NonNull Observable<T> just(@NonNull T item1,
        @NonNull T item2)

Converts two items into an Observable that emits those items.

Scheduler:

just does not operate by default on a particular Scheduler.

Type Parameters:

T - the type of these items

Parameters:

item1 - first item

item2 - second item

Returns:

the new Observable instance

Throws:

NullPointerException - if item1 or item2 is null

See Also:

ReactiveX operators documentation: Just

just

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public static <T> @NonNull Observable<T> just(@NonNull T item1,
        @NonNull T item2,
        @NonNull T item3)

Converts three items into an Observable that emits those items.

Scheduler:

just does not operate by default on a particular Scheduler.

Type Parameters:

T - the type of these items

Parameters:

item1 - first item

item2 - second item

item3 - third item

Returns:

the new Observable instance

Throws:

NullPointerException - if item1, item2 or item3 is null

See Also:

ReactiveX operators documentation: Just

just

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public static <T> @NonNull Observable<T> just(@NonNull T item1,
        @NonNull T item2,
        @NonNull T item3,
        @NonNull T item4)

Converts four items into an Observable that emits those items.

Scheduler:

just does not operate by default on a particular Scheduler.

Type Parameters:

T - the type of these items

Parameters:

item1 - first item

item2 - second item

item3 - third item

item4 - fourth item

Returns:

the new Observable instance

Throws:

NullPointerException - if item1, item2, item3 or item4 is null

See Also:

ReactiveX operators documentation: Just

just

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public static <T> @NonNull Observable<T> just(@NonNull T item1,
        @NonNull T item2,
        @NonNull T item3,
        @NonNull T item4,
        @NonNull T item5)

Converts five items into an Observable that emits those items.

Scheduler:

just does not operate by default on a particular Scheduler.

Type Parameters:

T - the type of these items

Parameters:

item1 - first item

item2 - second item

item3 - third item

item4 - fourth item

item5 - fifth item

Returns:

the new Observable instance

Throws:

NullPointerException - if item1, item2, item3, item4 or item5 is null

See Also:

ReactiveX operators documentation: Just

just

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public static <T> @NonNull Observable<T> just(@NonNull T item1,
        @NonNull T item2,
        @NonNull T item3,
        @NonNull T item4,
        @NonNull T item5,
        @NonNull T item6)

Converts six items into an Observable that emits those items.

Scheduler:

just does not operate by default on a particular Scheduler.

Type Parameters:

T - the type of these items

Parameters:

item1 - first item

item2 - second item

item3 - third item

item4 - fourth item

item5 - fifth item

item6 - sixth item

Returns:

the new Observable instance

Throws:

NullPointerException - if item1, item2, item3, item4, item5 or item6 is null

See Also:

ReactiveX operators documentation: Just

just

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public static <T> @NonNull Observable<T> just(@NonNull T item1,
        @NonNull T item2,
        @NonNull T item3,
        @NonNull T item4,
        @NonNull T item5,
        @NonNull T item6,
        @NonNull T item7)

Converts seven items into an Observable that emits those items.

Scheduler:

just does not operate by default on a particular Scheduler.

Type Parameters:

T - the type of these items

Parameters:

item1 - first item

item2 - second item

item3 - third item

item4 - fourth item

item5 - fifth item

item6 - sixth item

item7 - seventh item

Returns:

the new Observable instance

Throws:

NullPointerException - if item1, item2, item3, item4, item5, item6 or item7 is null

See Also:

ReactiveX operators documentation: Just

just

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public static <T> @NonNull Observable<T> just(@NonNull T item1,
        @NonNull T item2,
        @NonNull T item3,
        @NonNull T item4,
        @NonNull T item5,
        @NonNull T item6,
        @NonNull T item7,
        @NonNull T item8)

Converts eight items into an Observable that emits those items.

Scheduler:

just does not operate by default on a particular Scheduler.

Type Parameters:

T - the type of these items

Parameters:

item1 - first item

item2 - second item

item3 - third item

item4 - fourth item

item5 - fifth item

item6 - sixth item

item7 - seventh item

item8 - eighth item

Returns:

the new Observable instance

Throws:

NullPointerException - if item1, item2, item3, item4, item5, item6 item7 or item8 is null

See Also:

ReactiveX operators documentation: Just

just

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public static <T> @NonNull Observable<T> just(@NonNull T item1,
        @NonNull T item2,
        @NonNull T item3,
        @NonNull T item4,
        @NonNull T item5,
        @NonNull T item6,
        @NonNull T item7,
        @NonNull T item8,
        @NonNull T item9)

Converts nine items into an Observable that emits those items.

Scheduler:

just does not operate by default on a particular Scheduler.

Type Parameters:

T - the type of these items

Parameters:

item1 - first item

item2 - second item

item3 - third item

item4 - fourth item

item5 - fifth item

item6 - sixth item

item7 - seventh item

item8 - eighth item

item9 - ninth item

Returns:

the new Observable instance

Throws:

NullPointerException - if item1, item2, item3, item4, item5, item6 item7, item8 or item9 is null

See Also:

ReactiveX operators documentation: Just

just

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public static <T> @NonNull Observable<T> just(@NonNull T item1,
        @NonNull T item2,
        @NonNull T item3,
        @NonNull T item4,
        @NonNull T item5,
        @NonNull T item6,
        @NonNull T item7,
        @NonNull T item8,
        @NonNull T item9,
        @NonNull T item10)

Converts ten items into an Observable that emits those items.

Scheduler:

just does not operate by default on a particular Scheduler.

Type Parameters:

T - the type of these items

Parameters:

item1 - first item

item2 - second item

item3 - third item

item4 - fourth item

item5 - fifth item

item6 - sixth item

item7 - seventh item

item8 - eighth item

item9 - ninth item

item10 - tenth item

Returns:

the new Observable instance

Throws:

NullPointerException - if item1, item2, item3, item4, item5, item6 item7, item8, item9 or item10 is null

See Also:

ReactiveX operators documentation: Just

merge

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public static <T> @NonNull Observable<T> merge(@NonNull Iterable<? extends ObservableSource<? extends T>> sources,
        int maxConcurrency,
        int bufferSize)

Flattens an Iterable of ObservableSources into one Observable, without any transformation, while limiting the number of concurrent subscriptions to these ObservableSources.

You can combine the items emitted by multiple ObservableSources so that they appear as a single ObservableSource, by using the merge method.

Scheduler:

merge does not operate by default on a particular Scheduler.

Error handling:

If any of the returned ObservableSources signal a Throwable via onError, the resulting Observable terminates with that Throwable and all other source ObservableSources are disposed. If more than one ObservableSource signals an error, the resulting Observable may terminate with the first one's error or, depending on the concurrency of the sources, may terminate with a CompositeException containing two or more of the various error signals. Throwables that didn't make into the composite will be sent (individually) to the global error handler via RxJavaPlugins.onError(Throwable) method as UndeliverableException errors. Similarly, Throwables signaled by source(s) after the returned Observable has been disposed or terminated with a (composite) error will be sent to the same global error handler. Use mergeDelayError(Iterable, int, int) to merge sources and terminate only when all source ObservableSources have completed or failed with an error.

Type Parameters:

T - the common element base type

Parameters:

sources - the Iterable of ObservableSources

maxConcurrency - the maximum number of ObservableSources that may be subscribed to concurrently

bufferSize - the number of items expected from each inner ObservableSource to be buffered

Returns:

the new Observable instance

Throws:

NullPointerException - if sources is null

IllegalArgumentException - if maxConcurrency or bufferSize is non-positive

See Also:

ReactiveX operators documentation: Merge, mergeDelayError(Iterable, int, int)

mergeArray

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
 @SafeVarargs
public static <T> @NonNull Observable<T> mergeArray(int maxConcurrency,
        int bufferSize,
        @NonNull ObservableSource<? extends T>... sources)

Flattens an array of ObservableSources into one Observable, without any transformation, while limiting the number of concurrent subscriptions to these ObservableSources.

You can combine the items emitted by multiple ObservableSources so that they appear as a single ObservableSource, by using the merge method.

Scheduler:

mergeArray does not operate by default on a particular Scheduler.

Error handling:

If any of the ObservableSources signal a Throwable via onError, the resulting Observable terminates with that Throwable and all other source ObservableSources are disposed. If more than one ObservableSource signals an error, the resulting Observable may terminate with the first one's error or, depending on the concurrency of the sources, may terminate with a CompositeException containing two or more of the various error signals. Throwables that didn't make into the composite will be sent (individually) to the global error handler via RxJavaPlugins.onError(Throwable) method as UndeliverableException errors. Similarly, Throwables signaled by source(s) after the returned Observable has been disposed or terminated with a (composite) error will be sent to the same global error handler. Use mergeArrayDelayError(int, int, ObservableSource...) to merge sources and terminate only when all source ObservableSources have completed or failed with an error.

Type Parameters:

T - the common element base type

Parameters:

sources - the array of ObservableSources

maxConcurrency - the maximum number of ObservableSources that may be subscribed to concurrently

bufferSize - the number of items expected from each inner ObservableSource to be buffered

Returns:

the new Observable instance

Throws:

NullPointerException - if sources is null

IllegalArgumentException - if maxConcurrency or bufferSize is non-positive

See Also:

ReactiveX operators documentation: Merge, mergeArrayDelayError(int, int, ObservableSource...)

merge

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public static <T> @NonNull Observable<T> merge(@NonNull Iterable<? extends ObservableSource<? extends T>> sources)

Flattens an Iterable of ObservableSources into one Observable, without any transformation.

You can combine the items emitted by multiple ObservableSources so that they appear as a single ObservableSource, by using the merge method.

Scheduler:

merge does not operate by default on a particular Scheduler.

Error handling:

If any of the returned ObservableSources signal a Throwable via onError, the resulting Observable terminates with that Throwable and all other source ObservableSources are disposed. If more than one ObservableSource signals an error, the resulting Observable may terminate with the first one's error or, depending on the concurrency of the sources, may terminate with a CompositeException containing two or more of the various error signals. Throwables that didn't make into the composite will be sent (individually) to the global error handler via RxJavaPlugins.onError(Throwable) method as UndeliverableException errors. Similarly, Throwables signaled by source(s) after the returned Observable has been disposed or terminated with a (composite) error will be sent to the same global error handler. Use mergeDelayError(Iterable) to merge sources and terminate only when all source ObservableSources have completed or failed with an error.

Type Parameters:

T - the common element base type

Parameters:

sources - the Iterable of ObservableSources

Returns:

the new Observable instance

Throws:

NullPointerException - if sources is null

See Also:

ReactiveX operators documentation: Merge, mergeDelayError(Iterable)

merge

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public static <T> @NonNull Observable<T> merge(@NonNull Iterable<? extends ObservableSource<? extends T>> sources,
        int maxConcurrency)

Flattens an Iterable of ObservableSources into one Observable, without any transformation, while limiting the number of concurrent subscriptions to these ObservableSources.

You can combine the items emitted by multiple ObservableSources so that they appear as a single ObservableSource, by using the merge method.

Scheduler:

merge does not operate by default on a particular Scheduler.

Error handling:

If any of the returned ObservableSources signal a Throwable via onError, the resulting Observable terminates with that Throwable and all other source ObservableSources are disposed. If more than one ObservableSource signals an error, the resulting Observable may terminate with the first one's error or, depending on the concurrency of the sources, may terminate with a CompositeException containing two or more of the various error signals. Throwables that didn't make into the composite will be sent (individually) to the global error handler via RxJavaPlugins.onError(Throwable) method as UndeliverableException errors. Similarly, Throwables signaled by source(s) after the returned Observable has been disposed or terminated with a (composite) error will be sent to the same global error handler. Use mergeDelayError(Iterable, int) to merge sources and terminate only when all source ObservableSources have completed or failed with an error.

Type Parameters:

T - the common element base type

Parameters:

sources - the Iterable of ObservableSources

maxConcurrency - the maximum number of ObservableSources that may be subscribed to concurrently

Returns:

the new Observable instance

Throws:

NullPointerException - if sources is null

IllegalArgumentException - if maxConcurrency is less than or equal to 0

See Also:

ReactiveX operators documentation: Merge, mergeDelayError(Iterable, int)

merge

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public static <T> @NonNull Observable<T> merge(@NonNull ObservableSource<? extends ObservableSource<? extends T>> sources)

Flattens an ObservableSource that emits ObservableSources into a single Observable that emits the items emitted by those ObservableSources, without any transformation.

You can combine the items emitted by multiple ObservableSources so that they appear as a single ObservableSource, by using the merge method.

Scheduler:

merge does not operate by default on a particular Scheduler.

Error handling:

If any of the returned ObservableSources signal a Throwable via onError, the resulting Observable terminates with that Throwable and all other source ObservableSources are disposed. If more than one ObservableSource signals an error, the resulting Observable may terminate with the first one's error or, depending on the concurrency of the sources, may terminate with a CompositeException containing two or more of the various error signals. Throwables that didn't make into the composite will be sent (individually) to the global error handler via RxJavaPlugins.onError(Throwable) method as UndeliverableException errors. Similarly, Throwables signaled by source(s) after the returned Observable has been disposed or terminated with a (composite) error will be sent to the same global error handler. Use mergeDelayError(ObservableSource) to merge sources and terminate only when all source ObservableSources have completed or failed with an error.

Type Parameters:

T - the common element base type

Parameters:

sources - an ObservableSource that emits ObservableSources

Returns:

the new Observable instance

Throws:

NullPointerException - if sources is null

See Also:

ReactiveX operators documentation: Merge, mergeDelayError(ObservableSource)

merge

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public static <T> @NonNull Observable<T> merge(@NonNull ObservableSource<? extends ObservableSource<? extends T>> sources,
        int maxConcurrency)

Flattens an ObservableSource that emits ObservableSources into a single Observable that emits the items emitted by those ObservableSources, without any transformation, while limiting the maximum number of concurrent subscriptions to these ObservableSources.

You can combine the items emitted by multiple ObservableSources so that they appear as a single ObservableSource, by using the merge method.

Scheduler:

merge does not operate by default on a particular Scheduler.

Error handling:

If any of the returned ObservableSources signal a Throwable via onError, the resulting Observable terminates with that Throwable and all other source ObservableSources are disposed. If more than one ObservableSource signals an error, the resulting Observable may terminate with the first one's error or, depending on the concurrency of the sources, may terminate with a CompositeException containing two or more of the various error signals. Throwables that didn't make into the composite will be sent (individually) to the global error handler via RxJavaPlugins.onError(Throwable) method as UndeliverableException errors. Similarly, Throwables signaled by source(s) after the returned Observable has been disposed or terminated with a (composite) error will be sent to the same global error handler. Use mergeDelayError(ObservableSource, int) to merge sources and terminate only when all source ObservableSources have completed or failed with an error.

Type Parameters:

T - the common element base type

Parameters:

sources - an ObservableSource that emits ObservableSources

maxConcurrency - the maximum number of ObservableSources that may be subscribed to concurrently

Returns:

the new Observable instance

Throws:

NullPointerException - if sources is null

IllegalArgumentException - if maxConcurrency is non-positive

Since:

1.1.0

See Also:

ReactiveX operators documentation: Merge, mergeDelayError(ObservableSource, int)

merge

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public static <T> @NonNull Observable<T> merge(@NonNull ObservableSource<? extends T> source1,
        @NonNull ObservableSource<? extends T> source2)

Flattens two ObservableSources into a single Observable, without any transformation.

You can combine items emitted by multiple ObservableSources so that they appear as a single ObservableSource, by using the merge method.

Scheduler:

merge does not operate by default on a particular Scheduler.

Error handling:

If any of the ObservableSources signal a Throwable via onError, the resulting Observable terminates with that Throwable and all other source ObservableSources are disposed. If more than one ObservableSource signals an error, the resulting Observable may terminate with the first one's error or, depending on the concurrency of the sources, may terminate with a CompositeException containing two or more of the various error signals. Throwables that didn't make into the composite will be sent (individually) to the global error handler via RxJavaPlugins.onError(Throwable) method as UndeliverableException errors. Similarly, Throwables signaled by source(s) after the returned Observable has been disposed or terminated with a (composite) error will be sent to the same global error handler. Use mergeDelayError(ObservableSource, ObservableSource) to merge sources and terminate only when all source ObservableSources have completed or failed with an error.

Type Parameters:

T - the common element base type

Parameters:

source1 - an ObservableSource to be merged

source2 - an ObservableSource to be merged

Returns:

the new Observable instance

Throws:

NullPointerException - if source1 or source2 is null

See Also:

ReactiveX operators documentation: Merge, mergeDelayError(ObservableSource, ObservableSource)

merge

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public static <T> @NonNull Observable<T> merge(@NonNull ObservableSource<? extends T> source1,
        @NonNull ObservableSource<? extends T> source2,
        @NonNull ObservableSource<? extends T> source3)

Flattens three ObservableSources into a single Observable, without any transformation.

You can combine items emitted by multiple ObservableSources so that they appear as a single ObservableSource, by using the merge method.

Scheduler:

merge does not operate by default on a particular Scheduler.

Error handling:

If any of the ObservableSources signal a Throwable via onError, the resulting Observable terminates with that Throwable and all other source ObservableSources are disposed. If more than one ObservableSource signals an error, the resulting Observable may terminate with the first one's error or, depending on the concurrency of the sources, may terminate with a CompositeException containing two or more of the various error signals. Throwables that didn't make into the composite will be sent (individually) to the global error handler via RxJavaPlugins.onError(Throwable) method as UndeliverableException errors. Similarly, Throwables signaled by source(s) after the returned Observable has been disposed or terminated with a (composite) error will be sent to the same global error handler. Use mergeDelayError(ObservableSource, ObservableSource, ObservableSource) to merge sources and terminate only when all source ObservableSources have completed or failed with an error.

Type Parameters:

T - the common element base type

Parameters:

source1 - an ObservableSource to be merged

source2 - an ObservableSource to be merged

source3 - an ObservableSource to be merged

Returns:

the new Observable instance

Throws:

NullPointerException - if source1, source2 or source3 is null

See Also:

ReactiveX operators documentation: Merge, mergeDelayError(ObservableSource, ObservableSource, ObservableSource)

merge

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public static <T> @NonNull Observable<T> merge(@NonNull ObservableSource<? extends T> source1,
        @NonNull ObservableSource<? extends T> source2,
        @NonNull ObservableSource<? extends T> source3,
        @NonNull ObservableSource<? extends T> source4)

Flattens four ObservableSources into a single Observable, without any transformation.

You can combine items emitted by multiple ObservableSources so that they appear as a single ObservableSource, by using the merge method.

Scheduler:

merge does not operate by default on a particular Scheduler.

Error handling:

If any of the ObservableSources signal a Throwable via onError, the resulting Observable terminates with that Throwable and all other source ObservableSources are disposed. If more than one ObservableSource signals an error, the resulting Observable may terminate with the first one's error or, depending on the concurrency of the sources, may terminate with a CompositeException containing two or more of the various error signals. Throwables that didn't make into the composite will be sent (individually) to the global error handler via RxJavaPlugins.onError(Throwable) method as UndeliverableException errors. Similarly, Throwables signaled by source(s) after the returned Observable has been disposed or terminated with a (composite) error will be sent to the same global error handler. Use mergeDelayError(ObservableSource, ObservableSource, ObservableSource, ObservableSource) to merge sources and terminate only when all source ObservableSources have completed or failed with an error.

Type Parameters:

T - the common element base type

Parameters:

source1 - an ObservableSource to be merged

source2 - an ObservableSource to be merged

source3 - an ObservableSource to be merged

source4 - an ObservableSource to be merged

Returns:

the new Observable instance

Throws:

NullPointerException - if source1, source2, source3 or source4 is null

See Also:

ReactiveX operators documentation: Merge, mergeDelayError(ObservableSource, ObservableSource, ObservableSource, ObservableSource)

mergeArray

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
 @SafeVarargs
public static <T> @NonNull Observable<T> mergeArray(@NonNull ObservableSource<? extends T>... sources)

Flattens an array of ObservableSources into one Observable, without any transformation.

You can combine items emitted by multiple ObservableSources so that they appear as a single ObservableSource, by using the merge method.

Scheduler:

mergeArray does not operate by default on a particular Scheduler.

Error handling:

If any of the ObservableSources signal a Throwable via onError, the resulting Observable terminates with that Throwable and all other source ObservableSources are disposed. If more than one ObservableSource signals an error, the resulting Observable may terminate with the first one's error or, depending on the concurrency of the sources, may terminate with a CompositeException containing two or more of the various error signals. Throwables that didn't make into the composite will be sent (individually) to the global error handler via RxJavaPlugins.onError(Throwable) method as UndeliverableException errors. Similarly, Throwables signaled by source(s) after the returned Observable has been disposed or terminated with a (composite) error will be sent to the same global error handler. Use mergeArrayDelayError(ObservableSource...) to merge sources and terminate only when all source ObservableSources have completed or failed with an error.

Type Parameters:

T - the common element base type

Parameters:

sources - the array of ObservableSources

Returns:

the new Observable instance

Throws:

NullPointerException - if sources is null

See Also:

ReactiveX operators documentation: Merge, mergeArrayDelayError(ObservableSource...)

mergeDelayError

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public static <T> @NonNull Observable<T> mergeDelayError(@NonNull Iterable<? extends ObservableSource<? extends T>> sources)

Flattens an Iterable of ObservableSources into one Observable, in a way that allows an Observer to receive all successfully emitted items from each of the returned ObservableSources without being interrupted by an error notification from one of them.

This behaves like merge(ObservableSource) except that if any of the merged ObservableSources notify of an error via onError, mergeDelayError will refrain from propagating that error notification until all of the merged ObservableSources have finished emitting items.

Even if multiple merged ObservableSources send onError notifications, mergeDelayError will only invoke the onError method of its Observers once.

Scheduler:

mergeDelayError does not operate by default on a particular Scheduler.

Type Parameters:

T - the common element base type

Parameters:

sources - the Iterable of ObservableSources

Returns:

the new Observable instance

Throws:

NullPointerException - if sources is null

See Also:

ReactiveX operators documentation: Merge

mergeDelayError

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public static <T> @NonNull Observable<T> mergeDelayError(@NonNull Iterable<? extends ObservableSource<? extends T>> sources,
        int maxConcurrency,
        int bufferSize)

Flattens an Iterable of ObservableSources into one Observable, in a way that allows an Observer to receive all successfully emitted items from each of the returned ObservableSources without being interrupted by an error notification from one of them, while limiting the number of concurrent subscriptions to these ObservableSources.

This behaves like merge(ObservableSource) except that if any of the merged ObservableSources notify of an error via onError, mergeDelayError will refrain from propagating that error notification until all of the merged ObservableSources have finished emitting items.

Even if multiple merged ObservableSources send onError notifications, mergeDelayError will only invoke the onError method of its Observers once.

Scheduler:

mergeDelayError does not operate by default on a particular Scheduler.

Type Parameters:

T - the common element base type

Parameters:

sources - the Iterable of ObservableSources

maxConcurrency - the maximum number of ObservableSources that may be subscribed to concurrently

bufferSize - the number of items expected from each inner ObservableSource to be buffered

Returns:

the new Observable instance

Throws:

NullPointerException - if sources is null

IllegalArgumentException - if maxConcurrency or bufferSize is non-positive

See Also:

ReactiveX operators documentation: Merge

mergeArrayDelayError

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
 @SafeVarargs
public static <T> @NonNull Observable<T> mergeArrayDelayError(int maxConcurrency,
        int bufferSize,
        @NonNull ObservableSource<? extends T>... sources)

Flattens an array of ObservableSources into one Observable, in a way that allows an Observer to receive all successfully emitted items from each of the ObservableSources without being interrupted by an error notification from one of them, while limiting the number of concurrent subscriptions to these ObservableSources.

This behaves like merge(ObservableSource) except that if any of the merged ObservableSources notify of an error via onError, mergeDelayError will refrain from propagating that error notification until all of the merged ObservableSources have finished emitting items.

Even if multiple merged ObservableSources send onError notifications, mergeDelayError will only invoke the onError method of its Observers once.

Scheduler:

mergeArrayDelayError does not operate by default on a particular Scheduler.

Type Parameters:

T - the common element base type

Parameters:

sources - the array of ObservableSources

maxConcurrency - the maximum number of ObservableSources that may be subscribed to concurrently

bufferSize - the number of items expected from each inner ObservableSource to be buffered

Returns:

the new Observable instance

Throws:

NullPointerException - if sources is null

IllegalArgumentException - if maxConcurrency or bufferSize is non-positive

See Also:

ReactiveX operators documentation: Merge

mergeDelayError

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public static <T> @NonNull Observable<T> mergeDelayError(@NonNull Iterable<? extends ObservableSource<? extends T>> sources,
        int maxConcurrency)

Flattens an Iterable of ObservableSources into one Observable, in a way that allows an Observer to receive all successfully emitted items from each of the returned ObservableSources without being interrupted by an error notification from one of them, while limiting the number of concurrent subscriptions to these ObservableSources.

This behaves like merge(ObservableSource) except that if any of the merged ObservableSources notify of an error via onError, mergeDelayError will refrain from propagating that error notification until all of the merged ObservableSources have finished emitting items.

Even if multiple merged ObservableSources send onError notifications, mergeDelayError will only invoke the onError method of its Observers once.

Scheduler:

mergeDelayError does not operate by default on a particular Scheduler.

Type Parameters:

T - the common element base type

Parameters:

sources - the Iterable of ObservableSources

maxConcurrency - the maximum number of ObservableSources that may be subscribed to concurrently

Returns:

the new Observable instance

Throws:

NullPointerException - if sources is null

IllegalArgumentException - if maxConcurrency is non-positive

See Also:

ReactiveX operators documentation: Merge

mergeDelayError

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public static <T> @NonNull Observable<T> mergeDelayError(@NonNull ObservableSource<? extends ObservableSource<? extends T>> sources)

Flattens an ObservableSource that emits ObservableSources into one Observable, in a way that allows an Observer to receive all successfully emitted items from all of the emitted ObservableSources without being interrupted by an error notification from one of them.

This behaves like merge(ObservableSource) except that if any of the merged ObservableSources notify of an error via onError, mergeDelayError will refrain from propagating that error notification until all of the merged ObservableSources have finished emitting items.

Even if multiple merged ObservableSources send onError notifications, mergeDelayError will only invoke the onError method of its Observers once.

Scheduler:

mergeDelayError does not operate by default on a particular Scheduler.

Type Parameters:

T - the common element base type

Parameters:

sources - an ObservableSource that emits ObservableSources

Returns:

the new Observable instance

Throws:

NullPointerException - if sources is null

See Also:

ReactiveX operators documentation: Merge

mergeDelayError

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public static <T> @NonNull Observable<T> mergeDelayError(@NonNull ObservableSource<? extends ObservableSource<? extends T>> sources,
        int maxConcurrency)

Flattens an ObservableSource that emits ObservableSources into one Observable, in a way that allows an Observer to receive all successfully emitted items from all of the emitted ObservableSources without being interrupted by an error notification from one of them, while limiting the number of concurrent subscriptions to these ObservableSources.

This behaves like merge(ObservableSource) except that if any of the merged ObservableSources notify of an error via onError, mergeDelayError will refrain from propagating that error notification until all of the merged ObservableSources have finished emitting items.

Even if multiple merged ObservableSources send onError notifications, mergeDelayError will only invoke the onError method of its Observers once.

Scheduler:

mergeDelayError does not operate by default on a particular Scheduler.

Type Parameters:

T - the common element base type

Parameters:

sources - an ObservableSource that emits ObservableSources

maxConcurrency - the maximum number of ObservableSources that may be subscribed to concurrently

Returns:

the new Observable instance

Throws:

NullPointerException - if sources is null

IllegalArgumentException - if maxConcurrency is non-positive

Since:

2.0

See Also:

ReactiveX operators documentation: Merge

mergeDelayError

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public static <T> @NonNull Observable<T> mergeDelayError(@NonNull ObservableSource<? extends T> source1,
        @NonNull ObservableSource<? extends T> source2)

Flattens two ObservableSources into one Observable, in a way that allows an Observer to receive all successfully emitted items from each of the ObservableSources without being interrupted by an error notification from one of them.

This behaves like merge(ObservableSource, ObservableSource) except that if any of the merged ObservableSources notify of an error via onError, mergeDelayError will refrain from propagating that error notification until all of the merged ObservableSources have finished emitting items.

Even if both merged ObservableSources send onError notifications, mergeDelayError will only invoke the onError method of its Observers once.

Scheduler:

mergeDelayError does not operate by default on a particular Scheduler.

Type Parameters:

T - the common element base type

Parameters:

source1 - an ObservableSource to be merged

source2 - an ObservableSource to be merged

Returns:

the new Observable instance

Throws:

NullPointerException - if source1 or source2 is null

See Also:

ReactiveX operators documentation: Merge

mergeDelayError

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public static <T> @NonNull Observable<T> mergeDelayError(@NonNull ObservableSource<? extends T> source1,
        @NonNull ObservableSource<? extends T> source2,
        @NonNull ObservableSource<? extends T> source3)

Flattens three ObservableSources into one Observable, in a way that allows an Observer to receive all successfully emitted items from all of the ObservableSources without being interrupted by an error notification from one of them.

This behaves like merge(ObservableSource, ObservableSource, ObservableSource) except that if any of the merged ObservableSources notify of an error via onError, mergeDelayError will refrain from propagating that error notification until all of the merged ObservableSources have finished emitting items.

Even if multiple merged ObservableSources send onError notifications, mergeDelayError will only invoke the onError method of its Observers once.

Scheduler:

mergeDelayError does not operate by default on a particular Scheduler.

Type Parameters:

T - the common element base type

Parameters:

source1 - an ObservableSource to be merged

source2 - an ObservableSource to be merged

source3 - an ObservableSource to be merged

Returns:

the new Observable instance

Throws:

NullPointerException - if source1, source2 or source3 is null

See Also:

ReactiveX operators documentation: Merge

mergeDelayError

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public static <T> @NonNull Observable<T> mergeDelayError(@NonNull ObservableSource<? extends T> source1,
        @NonNull ObservableSource<? extends T> source2,
        @NonNull ObservableSource<? extends T> source3,
        @NonNull ObservableSource<? extends T> source4)

Flattens four ObservableSources into one Observable, in a way that allows an Observer to receive all successfully emitted items from all of the ObservableSources without being interrupted by an error notification from one of them.

This behaves like merge(ObservableSource, ObservableSource, ObservableSource, ObservableSource) except that if any of the merged ObservableSources notify of an error via onError, mergeDelayError will refrain from propagating that error notification until all of the merged ObservableSources have finished emitting items.

Even if multiple merged ObservableSources send onError notifications, mergeDelayError will only invoke the onError method of its Observers once.

Scheduler:

mergeDelayError does not operate by default on a particular Scheduler.

Type Parameters:

T - the common element base type

Parameters:

source1 - an ObservableSource to be merged

source2 - an ObservableSource to be merged

source3 - an ObservableSource to be merged

source4 - an ObservableSource to be merged

Returns:

the new Observable instance

Throws:

NullPointerException - if source1, source2, source3 or source4 is null

See Also:

ReactiveX operators documentation: Merge

mergeArrayDelayError

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
 @SafeVarargs
public static <T> @NonNull Observable<T> mergeArrayDelayError(@NonNull ObservableSource<? extends T>... sources)

Flattens an array of ObservableSources into one Observable, in a way that allows an Observer to receive all successfully emitted items from each of the ObservableSources without being interrupted by an error notification from one of them.

This behaves like merge(ObservableSource) except that if any of the merged ObservableSources notify of an error via onError, mergeDelayError will refrain from propagating that error notification until all of the merged ObservableSources have finished emitting items.

Even if multiple merged ObservableSources send onError notifications, mergeDelayError will only invoke the onError method of its Observers once.

Scheduler:

mergeArrayDelayError does not operate by default on a particular Scheduler.

Type Parameters:

T - the common element base type

Parameters:

sources - the array of ObservableSources

Returns:

the new Observable instance

Throws:

NullPointerException - if sources is null

See Also:

ReactiveX operators documentation: Merge

never

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public static <T> @NonNull Observable<T> never()

Returns an Observable that never sends any items or notifications to an Observer.

The returned Observable is useful primarily for testing purposes.

Scheduler:

never does not operate by default on a particular Scheduler.

Type Parameters:

T - the type of items (not) emitted by the Observable

Returns:

the shared Observable instance

See Also:

ReactiveX operators documentation: Never

range

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public static @NonNull Observable<Integer> range(int start,
        int count)

Returns an Observable that emits a sequence of Integers within a specified range.

Scheduler:

range does not operate by default on a particular Scheduler.

Parameters:

start - the value of the first Integer in the sequence

count - the number of sequential Integers to generate

Returns:

the new Observable instance

Throws:

IllegalArgumentException - if count is negative, or if start + count − 1 exceeds Integer.MAX_VALUE

See Also:

ReactiveX operators documentation: Range, rangeLong(long, long), intervalRange(long, long, long, long, TimeUnit)

rangeLong

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public static @NonNull Observable<Long> rangeLong(long start,
        long count)

Returns an Observable that emits a sequence of Longs within a specified range.

Scheduler:

rangeLong does not operate by default on a particular Scheduler.

Parameters:

start - the value of the first Long in the sequence

count - the number of sequential Longs to generate

Returns:

the new Observable instance

Throws:

IllegalArgumentException - if count is negative, or if start + count − 1 exceeds Long.MAX_VALUE

See Also:

ReactiveX operators documentation: Range, intervalRange(long, long, long, long, TimeUnit)

sequenceEqual

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public static <T> @NonNull Single<Boolean> sequenceEqual(@NonNull ObservableSource<? extends T> source1,
        @NonNull ObservableSource<? extends T> source2)

Returns a Single that emits a Boolean value that indicates whether two ObservableSource sequences are the same by comparing the items emitted by each ObservableSource pairwise.

Scheduler:

sequenceEqual does not operate by default on a particular Scheduler.

Type Parameters:

T - the type of items emitted by each ObservableSource

Parameters:

source1 - the first ObservableSource to compare

source2 - the second ObservableSource to compare

Returns:

the new Single instance

Throws:

NullPointerException - if source1 or source2 is null

See Also:

ReactiveX operators documentation: SequenceEqual

sequenceEqual

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public static <T> @NonNull Single<Boolean> sequenceEqual(@NonNull ObservableSource<? extends T> source1,
        @NonNull ObservableSource<? extends T> source2,
        @NonNull BiPredicate<? super T,? super T> isEqual)

Returns a Single that emits a Boolean value that indicates whether two ObservableSource sequences are the same by comparing the items emitted by each ObservableSource pairwise based on the results of a specified equality function.

Scheduler:

sequenceEqual does not operate by default on a particular Scheduler.

Type Parameters:

T - the type of items emitted by each ObservableSource

Parameters:

source1 - the first ObservableSource to compare

source2 - the second ObservableSource to compare

isEqual - a function used to compare items emitted by each ObservableSource

Returns:

the new Single instance

Throws:

NullPointerException - if source1, source2 or isEqual is null

See Also:

ReactiveX operators documentation: SequenceEqual

sequenceEqual

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public static <T> @NonNull Single<Boolean> sequenceEqual(@NonNull ObservableSource<? extends T> source1,
        @NonNull ObservableSource<? extends T> source2,
        @NonNull BiPredicate<? super T,? super T> isEqual,
        int bufferSize)

Returns a Single that emits a Boolean value that indicates whether two ObservableSource sequences are the same by comparing the items emitted by each ObservableSource pairwise based on the results of a specified equality function.

Scheduler:

sequenceEqual does not operate by default on a particular Scheduler.

Type Parameters:

T - the type of items emitted by each ObservableSource

Parameters:

source1 - the first ObservableSource to compare

source2 - the second ObservableSource to compare

isEqual - a function used to compare items emitted by each ObservableSource

bufferSize - the number of items expected from the first and second source ObservableSource to be buffered

Returns:

the new Single instance

Throws:

NullPointerException - if source1, source2 or isEqual is null

IllegalArgumentException - if bufferSize is non-positive

See Also:

ReactiveX operators documentation: SequenceEqual

sequenceEqual

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public static <T> @NonNull Single<Boolean> sequenceEqual(@NonNull ObservableSource<? extends T> source1,
        @NonNull ObservableSource<? extends T> source2,
        int bufferSize)

Returns a Single that emits a Boolean value that indicates whether two ObservableSource sequences are the same by comparing the items emitted by each ObservableSource pairwise.

Scheduler:

sequenceEqual does not operate by default on a particular Scheduler.

Type Parameters:

T - the type of items emitted by each ObservableSource

Parameters:

source1 - the first ObservableSource to compare

source2 - the second ObservableSource to compare

bufferSize - the number of items expected from the first and second source ObservableSource to be buffered

Returns:

the new Single instance

Throws:

NullPointerException - if source1 or source2 is null

IllegalArgumentException - if bufferSize is non-positive

See Also:

ReactiveX operators documentation: SequenceEqual

switchOnNext

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public static <T> @NonNull Observable<T> switchOnNext(@NonNull ObservableSource<? extends ObservableSource<? extends T>> sources,
        int bufferSize)

Converts an ObservableSource that emits ObservableSources into an Observable that emits the items emitted by the most recently emitted of those ObservableSources.

switchOnNext subscribes to an ObservableSource that emits ObservableSources. Each time it observes one of these emitted ObservableSources, the ObservableSource returned by switchOnNext begins emitting the items emitted by that ObservableSource. When a new inner ObservableSource is emitted, switchOnNext stops emitting items from the earlier-emitted ObservableSource and begins emitting items from the new one.

The resulting Observable completes if both the outer ObservableSource and the last inner ObservableSource, if any, complete. If the outer ObservableSource signals an onError, the inner ObservableSource is disposed and the error delivered in-sequence.

Scheduler:

switchOnNext does not operate by default on a particular Scheduler.

Type Parameters:

T - the item type

Parameters:

sources - the ObservableSource that emits ObservableSources

bufferSize - the expected number of items to cache from the inner ObservableSources

Returns:

the new Observable instance

Throws:

NullPointerException - if sources is null

IllegalArgumentException - if bufferSize is non-positive

See Also:

ReactiveX operators documentation: Switch

switchOnNext

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public static <T> @NonNull Observable<T> switchOnNext(@NonNull ObservableSource<? extends ObservableSource<? extends T>> sources)

Converts an ObservableSource that emits ObservableSources into an Observable that emits the items emitted by the most recently emitted of those ObservableSources.

switchOnNext subscribes to an ObservableSource that emits ObservableSources. Each time it observes one of these emitted ObservableSources, the ObservableSource returned by switchOnNext begins emitting the items emitted by that ObservableSource. When a new inner ObservableSource is emitted, switchOnNext stops emitting items from the earlier-emitted ObservableSource and begins emitting items from the new one.

The resulting Observable completes if both the outer ObservableSource and the last inner ObservableSource, if any, complete. If the outer ObservableSource signals an onError, the inner ObservableSource is disposed and the error delivered in-sequence.

Scheduler:

switchOnNext does not operate by default on a particular Scheduler.

Type Parameters:

T - the item type

Parameters:

sources - the ObservableSource that emits ObservableSources

Returns:

the new Observable instance

Throws:

NullPointerException - if sources is null

See Also:

ReactiveX operators documentation: Switch

switchOnNextDelayError

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public static <T> @NonNull Observable<T> switchOnNextDelayError(@NonNull ObservableSource<? extends ObservableSource<? extends T>> sources)

Converts an ObservableSource that emits ObservableSources into an Observable that emits the items emitted by the most recently emitted of those ObservableSources and delays any exception until all ObservableSources terminate.

switchOnNext subscribes to an ObservableSource that emits ObservableSources. Each time it observes one of these emitted ObservableSources, the ObservableSource returned by switchOnNext begins emitting the items emitted by that ObservableSource. When a new inner ObservableSource is emitted, switchOnNext stops emitting items from the earlier-emitted ObservableSource and begins emitting items from the new one.

The resulting Observable completes if both the main ObservableSource and the last inner ObservableSource, if any, complete. If the main ObservableSource signals an onError, the termination of the last inner ObservableSource will emit that error as is or wrapped into a CompositeException along with the other possible errors the former inner ObservableSources signaled.

Scheduler:

switchOnNextDelayError does not operate by default on a particular Scheduler.

Type Parameters:

T - the item type

Parameters:

sources - the ObservableSource that emits ObservableSources

Returns:

the new Observable instance

Throws:

NullPointerException - if sources is null

Since:

2.0

See Also:

ReactiveX operators documentation: Switch

switchOnNextDelayError

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public static <T> @NonNull Observable<T> switchOnNextDelayError(@NonNull ObservableSource<? extends ObservableSource<? extends T>> sources,
        int bufferSize)

Converts an ObservableSource that emits ObservableSources into an Observable that emits the items emitted by the most recently emitted of those ObservableSources and delays any exception until all ObservableSources terminate.

switchOnNext subscribes to an ObservableSource that emits ObservableSources. Each time it observes one of these emitted ObservableSources, the ObservableSource returned by switchOnNext begins emitting the items emitted by that ObservableSource. When a new inner ObservableSource is emitted, switchOnNext stops emitting items from the earlier-emitted ObservableSource and begins emitting items from the new one.

The resulting Observable completes if both the main ObservableSource and the last inner ObservableSource, if any, complete. If the main ObservableSource signals an onError, the termination of the last inner ObservableSource will emit that error as is or wrapped into a CompositeException along with the other possible errors the former inner ObservableSources signaled.

Scheduler:

switchOnNextDelayError does not operate by default on a particular Scheduler.

Type Parameters:

T - the item type

Parameters:

sources - the ObservableSource that emits ObservableSources

bufferSize - the expected number of items to cache from the inner ObservableSources

Returns:

the new Observable instance

Throws:

NullPointerException - if sources is null

IllegalArgumentException - if bufferSize is non-positive

Since:

2.0

See Also:

ReactiveX operators documentation: Switch

timer

@CheckReturnValue
 @SchedulerSupport(value="io.reactivex:computation")
 @NonNull
public static @NonNull Observable<Long> timer(long delay,
        @NonNull TimeUnit unit)

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

Scheduler:

timer operates by default on the computation Scheduler.

Parameters:

delay - the initial delay before emitting a single 0L

unit - time units to use for delay

Returns:

the new Observable instance

Throws:

NullPointerException - if unit is null

See Also:

ReactiveX operators documentation: Timer

timer

@CheckReturnValue
 @SchedulerSupport(value="custom")
 @NonNull
public static @NonNull Observable<Long> timer(long delay,
        @NonNull TimeUnit unit,
        @NonNull Scheduler scheduler)

Returns an Observable that emits 0L after a specified delay, on a specified Scheduler, and then completes.

Scheduler:

You specify which Scheduler this operator will use.

Parameters:

delay - the initial delay before emitting a single 0L

unit - time units to use for delay

scheduler - the Scheduler to use for scheduling the item

Returns:

the new Observable instance

Throws:

NullPointerException - if unit or scheduler is null

See Also:

ReactiveX operators documentation: Timer

unsafeCreate

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public static <T> @NonNull Observable<T> unsafeCreate(@NonNull ObservableSource<T> onSubscribe)

Create an Observable by wrapping an ObservableSource which has to be implemented according to the Observable specification derived from the Reactive Streams specification by handling disposal correctly; no safeguards are provided by the Observable itself.

Scheduler:

unsafeCreate by default doesn't operate on any particular Scheduler.

Type Parameters:

T - the value type emitted

Parameters:

onSubscribe - the ObservableSource instance to wrap

Returns:

the new Observable instance

Throws:

NullPointerException - if onSubscribe is null

IllegalArgumentException - if the onSubscribe is already an Observable, use wrap(ObservableSource) in this case

See Also:

wrap(ObservableSource)

using

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public static <T,D> @NonNull Observable<T> using(@NonNull Supplier<? extends D> resourceSupplier,
        @NonNull Function<? super D,? extends ObservableSource<? extends T>> sourceSupplier,
        @NonNull Consumer<? super D> resourceCleanup)

Constructs an Observable that creates a dependent resource object, an ObservableSource with that resource and calls the provided resourceDisposer function if this inner source terminates or the downstream disposes the flow.

Scheduler:

using does not operate by default on a particular Scheduler.

Type Parameters:

T - the element type of the generated Observable

D - the type of the resource associated with the output sequence

Parameters:

resourceSupplier - the factory function to create a resource object that depends on the ObservableSource

sourceSupplier - the factory function to create an ObservableSource

resourceCleanup - the function that will dispose of the resource

Returns:

the new Observable instance

Throws:

NullPointerException - if resourceSupplier, sourceSupplier or resourceCleanup is null

See Also:

ReactiveX operators documentation: Using

using

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public static <T,D> @NonNull Observable<T> using(@NonNull Supplier<? extends D> resourceSupplier,
        @NonNull Function<? super D,? extends ObservableSource<? extends T>> sourceSupplier,
        @NonNull Consumer<? super D> resourceCleanup,
        boolean eager)

Constructs an Observable that creates a dependent resource object, an ObservableSource with that resource and calls the provided disposer 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.

Scheduler:

using does not operate by default on a particular Scheduler.

Type Parameters:

T - the element type of the generated ObservableSource

D - the type of the resource associated with the output sequence

Parameters:

resourceSupplier - the factory function to create a resource object that depends on the ObservableSource

sourceSupplier - the factory function to create an ObservableSource

resourceCleanup - the function that will dispose of the resource

eager - If true, the resource disposal will happen either on a dispose() call before the upstream is disposed or just before the emission of a terminal event (onComplete or onError). If false, the resource disposal will happen either on a dispose() call after the upstream is disposed or just after the emission of a terminal event (onComplete or onError).

Returns:

the new Observable instance

Throws:

NullPointerException - if resourceSupplier, sourceSupplier and resourceCleanup is null

Since:

2.0

See Also:

ReactiveX operators documentation: Using

wrap

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public static <T> @NonNull Observable<T> wrap(@NonNull ObservableSource<T> source)

Wraps an ObservableSource into an Observable if not already an Observable.

Scheduler:

wrap does not operate by default on a particular Scheduler.

Type Parameters:

T - the value type

Parameters:

source - the ObservableSource instance to wrap or cast to Observable

Returns:

the new Observable instance or the same as the source

Throws:

NullPointerException - if source is null

zip

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public static <T,R> @NonNull Observable<R> zip(@NonNull Iterable<? extends ObservableSource<? extends T>> sources,
        @NonNull Function<? super Object[],? extends R> zipper)

Returns an Observable that emits the results of a specified combiner function applied to combinations of items emitted, in sequence, by an Iterable of other ObservableSources.

zip applies this function in strict sequence, so the first item emitted by the resulting Observable will be the result of the function applied to the first item emitted by each of the ObservableSources; the second item emitted by the resulting Observable will be the result of the function applied to the second item emitted by each of those ObservableSources; and so forth.

The resulting Observable<R> returned from zip will invoke onNext as many times as the number of onNext invocations of the ObservableSource that emits the fewest items.

The operator subscribes to its sources in order they are specified and completes eagerly if one of the sources is shorter than the rest while disposing the other sources. Therefore, it is possible those other sources will never be able to run to completion (and thus not calling doOnComplete()). This can also happen if the sources are exactly the same length; if source A completes and B has been consumed and is about to complete, the operator detects A won't be sending further values and it will dispose B immediately. For example:

zip(Arrays.asList(range(1, 5).doOnComplete(action1), range(6, 5).doOnComplete(action2)), (a) -> a)

action1 will be called but action2 won't.
To work around this termination property, use doOnDispose(Action) as well or use using() to do cleanup in case of completion or a dispose() call.

Note on method signature: since Java doesn't allow creating a generic array with new T[], the implementation of this operator has to create an Object[] instead. Unfortunately, a Function<Integer[], R> passed to the method would trigger a ClassCastException.

Scheduler:

zip does not operate by default on a particular Scheduler.

Type Parameters:

T - the common value type

R - the zipped result type

Parameters:

sources - an Iterable of source ObservableSources

zipper - a function that, when applied to an item emitted by each of the ObservableSources, results in an item that will be emitted by the resulting Observable

Returns:

the new Observable instance

Throws:

NullPointerException - if sources or zipper is null

See Also:

ReactiveX operators documentation: Zip

zip

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public static <T,R> @NonNull Observable<R> zip(@NonNull Iterable<? extends ObservableSource<? extends T>> sources,
        @NonNull Function<? super Object[],? extends R> zipper,
        boolean delayError,
        int bufferSize)

Returns an Observable that emits the results of a specified combiner function applied to combinations of items emitted, in sequence, by an Iterable of other ObservableSources.

zip applies this function in strict sequence, so the first item emitted by the resulting Observable will be the result of the function applied to the first item emitted by each of the ObservableSources; the second item emitted by the resulting Observable will be the result of the function applied to the second item emitted by each of those ObservableSources; and so forth.

The resulting Observable<R> returned from zip will invoke onNext as many times as the number of onNext invocations of the ObservableSource that emits the fewest items.

The operator subscribes to its sources in order they are specified and completes eagerly if one of the sources is shorter than the rest while disposing the other sources. Therefore, it is possible those other sources will never be able to run to completion (and thus not calling doOnComplete()). This can also happen if the sources are exactly the same length; if source A completes and B has been consumed and is about to complete, the operator detects A won't be sending further values and it will dispose B immediately. For example:

zip(Arrays.asList(range(1, 5).doOnComplete(action1), range(6, 5).doOnComplete(action2)), (a) -> a)

action1 will be called but action2 won't.
To work around this termination property, use doOnDispose(Action) as well or use using() to do cleanup in case of completion or a dispose() call.

Note on method signature: since Java doesn't allow creating a generic array with new T[], the implementation of this operator has to create an Object[] instead. Unfortunately, a Function<Integer[], R> passed to the method would trigger a ClassCastException.

Scheduler:

zip does not operate by default on a particular Scheduler.

Type Parameters:

T - the common source value type

R - the zipped result type

Parameters:

sources - an Iterable of source ObservableSources

zipper - a function that, when applied to an item emitted by each of the ObservableSources, results in an item that will be emitted by the resulting Observable

delayError - delay errors signaled by any of the ObservableSource until all ObservableSources terminate

bufferSize - the number of elements expected from each source ObservableSource to be buffered

Returns:

the new Observable instance

Throws:

NullPointerException - if sources or zipper is null

IllegalArgumentException - if bufferSize is non-positive

See Also:

ReactiveX operators documentation: Zip

zip

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public static <T1,T2,R> @NonNull Observable<R> zip(@NonNull ObservableSource<? extends T1> source1,
        @NonNull ObservableSource<? extends T2> source2,
        @NonNull BiFunction<? super T1,? super T2,? extends R> zipper)

Returns an Observable that emits the results of a specified combiner function applied to combinations of two items emitted, in sequence, by two other ObservableSources.

zip applies this function in strict sequence, so the first item emitted by the resulting Observable will be the result of the function applied to the first item emitted by o1 and the first item emitted by o2; the second item emitted by the resulting Observable will be the result of the function applied to the second item emitted by o1 and the second item emitted by o2; and so forth.

The resulting Observable<R> returned from zip will invoke onNext as many times as the number of onNext invocations of the ObservableSource that emits the fewest items.

The operator subscribes to its sources in order they are specified and completes eagerly if one of the sources is shorter than the rest while disposing the other sources. Therefore, it is possible those other sources will never be able to run to completion (and thus not calling doOnComplete()). This can also happen if the sources are exactly the same length; if source A completes and B has been consumed and is about to complete, the operator detects A won't be sending further values and it will dispose B immediately. For example:

zip(range(1, 5).doOnComplete(action1), range(6, 5).doOnComplete(action2), (a, b) -> a + b)

action1 will be called but action2 won't.
To work around this termination property, use doOnDispose(Action) as well or use using() to do cleanup in case of completion or a dispose() call.

Scheduler:

zip does not operate by default on a particular Scheduler.

Type Parameters:

T1 - the value type of the first source

T2 - the value type of the second source

R - the zipped result type

Parameters:

source1 - the first source ObservableSource

source2 - a second source ObservableSource

zipper - a function that, when applied to an item emitted by each of the ObservableSources, results in an item that will be emitted by the resulting Observable

Returns:

the new Observable instance

Throws:

NullPointerException - if source1, source2 or zipper is null

See Also:

ReactiveX operators documentation: Zip

zip

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public static <T1,T2,R> @NonNull Observable<R> zip(@NonNull ObservableSource<? extends T1> source1,
        @NonNull ObservableSource<? extends T2> source2,
        @NonNull BiFunction<? super T1,? super T2,? extends R> zipper,
        boolean delayError)

Returns an Observable that emits the results of a specified combiner function applied to combinations of two items emitted, in sequence, by two other ObservableSources.

zip applies this function in strict sequence, so the first item emitted by the resulting Observable will be the result of the function applied to the first item emitted by o1 and the first item emitted by o2; the second item emitted by the resulting Observable will be the result of the function applied to the second item emitted by o1 and the second item emitted by o2; and so forth.

The resulting Observable<R> returned from zip will invoke onNext as many times as the number of onNext invocations of the ObservableSource that emits the fewest items.

The operator subscribes to its sources in order they are specified and completes eagerly if one of the sources is shorter than the rest while disposing the other sources. Therefore, it is possible those other sources will never be able to run to completion (and thus not calling doOnComplete()). This can also happen if the sources are exactly the same length; if source A completes and B has been consumed and is about to complete, the operator detects A won't be sending further values and it will dispose B immediately. For example:

zip(range(1, 5).doOnComplete(action1), range(6, 5).doOnComplete(action2), (a, b) -> a + b)

action1 will be called but action2 won't.
To work around this termination property, use doOnDispose(Action) as well or use using() to do cleanup in case of completion or a dispose() call.

Scheduler:

zip does not operate by default on a particular Scheduler.

Type Parameters:

T1 - the value type of the first source

T2 - the value type of the second source

R - the zipped result type

Parameters:

source1 - the first source ObservableSource

source2 - a second source ObservableSource

zipper - a function that, when applied to an item emitted by each of the ObservableSources, results in an item that will be emitted by the resulting Observable

delayError - delay errors from any of the ObservableSources till the other terminates

Returns:

the new Observable instance

Throws:

NullPointerException - if source1, source2 or zipper is null

See Also:

ReactiveX operators documentation: Zip

zip

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public static <T1,T2,R> @NonNull Observable<R> zip(@NonNull ObservableSource<? extends T1> source1,
        @NonNull ObservableSource<? extends T2> source2,
        @NonNull BiFunction<? super T1,? super T2,? extends R> zipper,
        boolean delayError,
        int bufferSize)

Returns an Observable that emits the results of a specified combiner function applied to combinations of two items emitted, in sequence, by two other ObservableSources.

zip applies this function in strict sequence, so the first item emitted by the resulting Observable will be the result of the function applied to the first item emitted by o1 and the first item emitted by o2; the second item emitted by the resulting Observable will be the result of the function applied to the second item emitted by o1 and the second item emitted by o2; and so forth.

The resulting Observable<R> returned from zip will invoke onNext as many times as the number of onNext invocations of the ObservableSource that emits the fewest items.

The operator subscribes to its sources in order they are specified and completes eagerly if one of the sources is shorter than the rest while disposing the other sources. Therefore, it is possible those other sources will never be able to run to completion (and thus not calling doOnComplete()). This can also happen if the sources are exactly the same length; if source A completes and B has been consumed and is about to complete, the operator detects A won't be sending further values and it will dispose B immediately. For example:

zip(range(1, 5).doOnComplete(action1), range(6, 5).doOnComplete(action2), (a, b) -> a + b)

action1 will be called but action2 won't.
To work around this termination property, use doOnDispose(Action) as well or use using() to do cleanup in case of completion or a dispose() call.

Scheduler:

zip does not operate by default on a particular Scheduler.

Type Parameters:

T1 - the value type of the first source

T2 - the value type of the second source

R - the zipped result type

Parameters:

source1 - the first source ObservableSource

source2 - a second source ObservableSource

zipper - a function that, when applied to an item emitted by each of the ObservableSources, results in an item that will be emitted by the resulting Observable

delayError - delay errors from any of the ObservableSources till the other terminates

bufferSize - the number of elements expected from each source ObservableSource to be buffered

Returns:

the new Observable instance

Throws:

NullPointerException - if source1, source2 or zipper is null

IllegalArgumentException - if bufferSize is non-positive

See Also:

ReactiveX operators documentation: Zip

zip

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public static <T1,T2,T3,R> @NonNull Observable<R> zip(@NonNull ObservableSource<? extends T1> source1,
        @NonNull ObservableSource<? extends T2> source2,
        @NonNull ObservableSource<? extends T3> source3,
        @NonNull Function3<? super T1,? super T2,? super T3,? extends R> zipper)

Returns an Observable that emits the results of a specified combiner function applied to combinations of three items emitted, in sequence, by three other ObservableSources.

zip applies this function in strict sequence, so the first item emitted by the resulting Observable will be the result of the function applied to the first item emitted by o1, the first item emitted by o2, and the first item emitted by o3; the second item emitted by the resulting Observable will be the result of the function applied to the second item emitted by o1, the second item emitted by o2, and the second item emitted by o3; and so forth.

The resulting Observable<R> returned from zip will invoke onNext as many times as the number of onNext invocations of the ObservableSource that emits the fewest items.

The operator subscribes to its sources in order they are specified and completes eagerly if one of the sources is shorter than the rest while disposing the other sources. Therefore, it is possible those other sources will never be able to run to completion (and thus not calling doOnComplete()). This can also happen if the sources are exactly the same length; if source A completes and B has been consumed and is about to complete, the operator detects A won't be sending further values and it will dispose B immediately. For example:

zip(range(1, 5).doOnComplete(action1), range(6, 5).doOnComplete(action2), ..., (a, b, c) -> a + b)

action1 will be called but action2 won't.
To work around this termination property, use doOnDispose(Action) as well or use using() to do cleanup in case of completion or a dispose() call.

Scheduler:

zip does not operate by default on a particular Scheduler.

Type Parameters:

T1 - the value type of the first source

T2 - the value type of the second source

T3 - the value type of the third source

R - the zipped result type

Parameters:

source1 - the first source ObservableSource

source2 - a second source ObservableSource

source3 - a third source ObservableSource

zipper - a function that, when applied to an item emitted by each of the ObservableSources, results in an item that will be emitted by the resulting Observable

Returns:

the new Observable instance

Throws:

NullPointerException - if source1, source2, source3 or zipper is null

See Also:

ReactiveX operators documentation: Zip

zip

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public static <T1,T2,T3,T4,R> @NonNull Observable<R> zip(@NonNull ObservableSource<? extends T1> source1,
        @NonNull ObservableSource<? extends T2> source2,
        @NonNull ObservableSource<? extends T3> source3,
        @NonNull ObservableSource<? extends T4> source4,
        @NonNull Function4<? super T1,? super T2,? super T3,? super T4,? extends R> zipper)

Returns an Observable that emits the results of a specified combiner function applied to combinations of four items emitted, in sequence, by four other ObservableSources.

zip applies this function in strict sequence, so the first item emitted by the resulting Observable will be the result of the function applied to the first item emitted by o1, the first item emitted by o2, the first item emitted by o3, and the first item emitted by 04; the second item emitted by the resulting Observable will be the result of the function applied to the second item emitted by each of those ObservableSources; and so forth.

The resulting Observable<R> returned from zip will invoke onNext as many times as the number of onNext invocations of the ObservableSource that emits the fewest items.

The operator subscribes to its sources in order they are specified and completes eagerly if one of the sources is shorter than the rest while disposing the other sources. Therefore, it is possible those other sources will never be able to run to completion (and thus not calling doOnComplete()). This can also happen if the sources are exactly the same length; if source A completes and B has been consumed and is about to complete, the operator detects A won't be sending further values and it will dispose B immediately. For example:

zip(range(1, 5).doOnComplete(action1), range(6, 5).doOnComplete(action2), ..., (a, b, c, d) -> a + b)

action1 will be called but action2 won't.
To work around this termination property, use doOnDispose(Action) as well or use using() to do cleanup in case of completion or a dispose() call.

Scheduler:

zip does not operate by default on a particular Scheduler.

Type Parameters:

T1 - the value type of the first source

T2 - the value type of the second source

T3 - the value type of the third source

T4 - the value type of the fourth source

R - the zipped result type

Parameters:

source1 - the first source ObservableSource

source2 - a second source ObservableSource

source3 - a third source ObservableSource

source4 - a fourth source ObservableSource

zipper - a function that, when applied to an item emitted by each of the ObservableSources, results in an item that will be emitted by the resulting Observable

Returns:

the new Observable instance

Throws:

NullPointerException - if source1, source2, source3, source4 or zipper is null

See Also:

ReactiveX operators documentation: Zip

zip

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public static <T1,T2,T3,T4,T5,R> @NonNull Observable<R> zip(@NonNull ObservableSource<? extends T1> source1,
        @NonNull ObservableSource<? extends T2> source2,
        @NonNull ObservableSource<? extends T3> source3,
        @NonNull ObservableSource<? extends T4> source4,
        @NonNull ObservableSource<? extends T5> source5,
        @NonNull Function5<? super T1,? super T2,? super T3,? super T4,? super T5,? extends R> zipper)

Returns an Observable that emits the results of a specified combiner function applied to combinations of five items emitted, in sequence, by five other ObservableSources.

zip applies this function in strict sequence, so the first item emitted by the resulting Observable will be the result of the function applied to the first item emitted by o1, the first item emitted by o2, the first item emitted by o3, the first item emitted by o4, and the first item emitted by o5; the second item emitted by the resulting Observable will be the result of the function applied to the second item emitted by each of those ObservableSources; and so forth.

The resulting Observable<R> returned from zip will invoke onNext as many times as the number of onNext invocations of the ObservableSource that emits the fewest items.

The operator subscribes to its sources in order they are specified and completes eagerly if one of the sources is shorter than the rest while disposing the other sources. Therefore, it is possible those other sources will never be able to run to completion (and thus not calling doOnComplete()). This can also happen if the sources are exactly the same length; if source A completes and B has been consumed and is about to complete, the operator detects A won't be sending further values and it will dispose B immediately. For example:

zip(range(1, 5).doOnComplete(action1), range(6, 5).doOnComplete(action2), ..., (a, b, c, d, e) -> a + b)

action1 will be called but action2 won't.
To work around this termination property, use doOnDispose(Action) as well or use using() to do cleanup in case of completion or a dispose() call.

Scheduler:

zip does not operate by default on a particular Scheduler.

Type Parameters:

T1 - the value type of the first source

T2 - the value type of the second source

T3 - the value type of the third source

T4 - the value type of the fourth source

T5 - the value type of the fifth source

R - the zipped result type

Parameters:

source1 - the first source ObservableSource

source2 - a second source ObservableSource

source3 - a third source ObservableSource

source4 - a fourth source ObservableSource

source5 - a fifth source ObservableSource

zipper - a function that, when applied to an item emitted by each of the ObservableSources, results in an item that will be emitted by the resulting Observable

Returns:

the new Observable instance

Throws:

NullPointerException - if source1, source2, source3, source4, source5 or zipper is null

See Also:

ReactiveX operators documentation: Zip

zip

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public static <T1,T2,T3,T4,T5,T6,R> @NonNull Observable<R> zip(@NonNull ObservableSource<? extends T1> source1,
        @NonNull ObservableSource<? extends T2> source2,
        @NonNull ObservableSource<? extends T3> source3,
        @NonNull ObservableSource<? extends T4> source4,
        @NonNull ObservableSource<? extends T5> source5,
        @NonNull ObservableSource<? extends T6> source6,
        @NonNull Function6<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? extends R> zipper)

Returns an Observable that emits the results of a specified combiner function applied to combinations of six items emitted, in sequence, by six other ObservableSources.

zip applies this function in strict sequence, so the first item emitted by the resulting Observable will be the result of the function applied to the first item emitted by each source ObservableSource, the second item emitted by the resulting Observable will be the result of the function applied to the second item emitted by each of those ObservableSources, and so forth.

The resulting Observable<R> returned from zip will invoke onNext as many times as the number of onNext invocations of the ObservableSource that emits the fewest items.

The operator subscribes to its sources in order they are specified and completes eagerly if one of the sources is shorter than the rest while disposing the other sources. Therefore, it is possible those other sources will never be able to run to completion (and thus not calling doOnComplete()). This can also happen if the sources are exactly the same length; if source A completes and B has been consumed and is about to complete, the operator detects A won't be sending further values and it will dispose B immediately. For example:

zip(range(1, 5).doOnComplete(action1), range(6, 5).doOnComplete(action2), ..., (a, b, c, d, e, f) -> a + b)

action1 will be called but action2 won't.
To work around this termination property, use doOnDispose(Action) as well or use using() to do cleanup in case of completion or a dispose() call.

Scheduler:

zip does not operate by default on a particular Scheduler.

Type Parameters:

T1 - the value type of the first source

T2 - the value type of the second source

T3 - the value type of the third source

T4 - the value type of the fourth source

T5 - the value type of the fifth source

T6 - the value type of the sixth source

R - the zipped result type

Parameters:

source1 - the first source ObservableSource

source2 - a second source ObservableSource

source3 - a third source ObservableSource

source4 - a fourth source ObservableSource

source5 - a fifth source ObservableSource

source6 - a sixth source ObservableSource

zipper - a function that, when applied to an item emitted by each of the ObservableSources, results in an item that will be emitted by the resulting Observable

Returns:

the new Observable instance

Throws:

NullPointerException - if source1, source2, source3, source4, source5, source6 or zipper is null

See Also:

ReactiveX operators documentation: Zip

zip

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public static <T1,T2,T3,T4,T5,T6,T7,R> @NonNull Observable<R> zip(@NonNull ObservableSource<? extends T1> source1,
        @NonNull ObservableSource<? extends T2> source2,
        @NonNull ObservableSource<? extends T3> source3,
        @NonNull ObservableSource<? extends T4> source4,
        @NonNull ObservableSource<? extends T5> source5,
        @NonNull ObservableSource<? extends T6> source6,
        @NonNull ObservableSource<? extends T7> source7,
        @NonNull Function7<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? extends R> zipper)

Returns an Observable that emits the results of a specified combiner function applied to combinations of seven items emitted, in sequence, by seven other ObservableSources.

zip applies this function in strict sequence, so the first item emitted by the resulting Observable will be the result of the function applied to the first item emitted by each source ObservableSource, the second item emitted by the resulting Observable will be the result of the function applied to the second item emitted by each of those ObservableSources, and so forth.

The resulting Observable<R> returned from zip will invoke onNext as many times as the number of onNext invocations of the ObservableSource that emits the fewest items.

The operator subscribes to its sources in order they are specified and completes eagerly if one of the sources is shorter than the rest while disposing the other sources. Therefore, it is possible those other sources will never be able to run to completion (and thus not calling doOnComplete()). This can also happen if the sources are exactly the same length; if source A completes and B has been consumed and is about to complete, the operator detects A won't be sending further values and it will dispose B immediately. For example:

zip(range(1, 5).doOnComplete(action1), range(6, 5).doOnComplete(action2), ..., (a, b, c, d, e, f, g) -> a + b)

action1 will be called but action2 won't.
To work around this termination property, use doOnDispose(Action) as well or use using() to do cleanup in case of completion or a dispose() call.

Scheduler:

zip does not operate by default on a particular Scheduler.

Type Parameters:

T1 - the value type of the first source

T2 - the value type of the second source

T3 - the value type of the third source

T4 - the value type of the fourth source

T5 - the value type of the fifth source

T6 - the value type of the sixth source

T7 - the value type of the seventh source

R - the zipped result type

Parameters:

source1 - the first source ObservableSource

source2 - a second source ObservableSource

source3 - a third source ObservableSource

source4 - a fourth source ObservableSource

source5 - a fifth source ObservableSource

source6 - a sixth source ObservableSource

source7 - a seventh source ObservableSource

zipper - a function that, when applied to an item emitted by each of the ObservableSources, results in an item that will be emitted by the resulting Observable

Returns:

the new Observable instance

Throws:

NullPointerException - if source1, source2, source3, source4, source5, source6, source7 or zipper is null

See Also:

ReactiveX operators documentation: Zip

zip

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public static <T1,T2,T3,T4,T5,T6,T7,T8,R> @NonNull Observable<R> zip(@NonNull ObservableSource<? extends T1> source1,
        @NonNull ObservableSource<? extends T2> source2,
        @NonNull ObservableSource<? extends T3> source3,
        @NonNull ObservableSource<? extends T4> source4,
        @NonNull ObservableSource<? extends T5> source5,
        @NonNull ObservableSource<? extends T6> source6,
        @NonNull ObservableSource<? extends T7> source7,
        @NonNull ObservableSource<? 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 an Observable that emits the results of a specified combiner function applied to combinations of eight items emitted, in sequence, by eight other ObservableSources.

zip applies this function in strict sequence, so the first item emitted by the resulting Observable will be the result of the function applied to the first item emitted by each source ObservableSource, the second item emitted by the resulting Observable will be the result of the function applied to the second item emitted by each of those ObservableSources, and so forth.

The resulting Observable<R> returned from zip will invoke onNext as many times as the number of onNext invocations of the ObservableSource that emits the fewest items.

The operator subscribes to its sources in order they are specified and completes eagerly if one of the sources is shorter than the rest while disposing the other sources. Therefore, it is possible those other sources will never be able to run to completion (and thus not calling doOnComplete()). This can also happen if the sources are exactly the same length; if source A completes and B has been consumed and is about to complete, the operator detects A won't be sending further values and it will dispose B immediately. For example:

zip(range(1, 5).doOnComplete(action1), range(6, 5).doOnComplete(action2), ..., (a, b, c, d, e, f, g, h) -> a + b)

action1 will be called but action2 won't.
To work around this termination property, use doOnDispose(Action) as well or use using() to do cleanup in case of completion or a dispose() call.

Scheduler:

zip does not operate by default on a particular Scheduler.

Type Parameters:

T1 - the value type of the first source

T2 - the value type of the second source

T3 - the value type of the third source

T4 - the value type of the fourth source

T5 - the value type of the fifth source

T6 - the value type of the sixth source

T7 - the value type of the seventh source

T8 - the value type of the eighth source

R - the zipped result type

Parameters:

source1 - the first source ObservableSource

source2 - a second source ObservableSource

source3 - a third source ObservableSource

source4 - a fourth source ObservableSource

source5 - a fifth source ObservableSource

source6 - a sixth source ObservableSource

source7 - a seventh source ObservableSource

source8 - an eighth source ObservableSource

zipper - a function that, when applied to an item emitted by each of the ObservableSources, results in an item that will be emitted by the resulting Observable

Returns:

the new Observable instance

Throws:

NullPointerException - if source1, source2, source3, source4, source5, source6, source7, source8 or zipper is null

See Also:

ReactiveX operators documentation: Zip

zip

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public static <T1,T2,T3,T4,T5,T6,T7,T8,T9,R> @NonNull Observable<R> zip(@NonNull ObservableSource<? extends T1> source1,
        @NonNull ObservableSource<? extends T2> source2,
        @NonNull ObservableSource<? extends T3> source3,
        @NonNull ObservableSource<? extends T4> source4,
        @NonNull ObservableSource<? extends T5> source5,
        @NonNull ObservableSource<? extends T6> source6,
        @NonNull ObservableSource<? extends T7> source7,
        @NonNull ObservableSource<? extends T8> source8,
        @NonNull ObservableSource<? 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 an Observable that emits the results of a specified combiner function applied to combinations of nine items emitted, in sequence, by nine other ObservableSources.

zip applies this function in strict sequence, so the first item emitted by the resulting Observable will be the result of the function applied to the first item emitted by each source ObservableSource, the second item emitted by the resulting Observable will be the result of the function applied to the second item emitted by each of those ObservableSources, and so forth.

The resulting Observable<R> returned from zip will invoke onNext as many times as the number of onNext invocations of the ObservableSource that emits the fewest items.

The operator subscribes to its sources in order they are specified and completes eagerly if one of the sources is shorter than the rest while disposing the other sources. Therefore, it is possible those other sources will never be able to run to completion (and thus not calling doOnComplete()). This can also happen if the sources are exactly the same length; if source A completes and B has been consumed and is about to complete, the operator detects A won't be sending further values and it will dispose B immediately. For example:

zip(range(1, 5).doOnComplete(action1), range(6, 5).doOnComplete(action2), ..., (a, b, c, d, e, f, g, h, i) -> a + b)

action1 will be called but action2 won't.
To work around this termination property, use doOnDispose(Action) as well or use using() to do cleanup in case of completion or a dispose() call.

Scheduler:

zip does not operate by default on a particular Scheduler.

Type Parameters:

T1 - the value type of the first source

T2 - the value type of the second source

T3 - the value type of the third source

T4 - the value type of the fourth source

T5 - the value type of the fifth source

T6 - the value type of the sixth source

T7 - the value type of the seventh source

T8 - the value type of the eighth source

T9 - the value type of the ninth source

R - the zipped result type

Parameters:

source1 - the first source ObservableSource

source2 - a second source ObservableSource

source3 - a third source ObservableSource

source4 - a fourth source ObservableSource

source5 - a fifth source ObservableSource

source6 - a sixth source ObservableSource

source7 - a seventh source ObservableSource

source8 - an eighth source ObservableSource

source9 - a ninth source ObservableSource

zipper - a function that, when applied to an item emitted by each of the ObservableSources, results in an item that will be emitted by the resulting Observable

Returns:

the new Observable instance

Throws:

NullPointerException - if source1, source2, source3, source4, source5, source6, source7, source8, source9 or zipper is null

See Also:

ReactiveX operators documentation: Zip

zipArray

@CheckReturnValue
 @SchedulerSupport(value="none")
 @SafeVarargs
 @NonNull
public static <T,R> @NonNull Observable<R> zipArray(@NonNull Function<? super Object[],? extends R> zipper,
        boolean delayError,
        int bufferSize,
        @NonNull ObservableSource<? extends T>... sources)

Returns an Observable that emits the results of a specified combiner function applied to combinations of items emitted, in sequence, by an array of other ObservableSources.

zip applies this function in strict sequence, so the first item emitted by the resulting Observable will be the result of the function applied to the first item emitted by each of the ObservableSources; the second item emitted by the resulting Observable will be the result of the function applied to the second item emitted by each of those ObservableSources; and so forth.

The resulting Observable<R> returned from zip will invoke onNext as many times as the number of onNext invocations of the ObservableSource that emits the fewest items.

The operator subscribes to its sources in order they are specified and completes eagerly if one of the sources is shorter than the rest while disposing the other sources. Therefore, it is possible those other sources will never be able to run to completion (and thus not calling doOnComplete()). This can also happen if the sources are exactly the same length; if source A completes and B has been consumed and is about to complete, the operator detects A won't be sending further values and it will dispose B immediately. For example:

zip(new ObservableSource[]{range(1, 5).doOnComplete(action1), range(6, 5).doOnComplete(action2)}, (a) ->
 a)

action1 will be called but action2 won't.
To work around this termination property, use doOnDispose(Action) as well or use using() to do cleanup in case of completion or a dispose() call.

Note on method signature: since Java doesn't allow creating a generic array with new T[], the implementation of this operator has to create an Object[] instead. Unfortunately, a Function<Integer[], R> passed to the method would trigger a ClassCastException.

Scheduler:

zipArray does not operate by default on a particular Scheduler.

Type Parameters:

T - the common element type

R - the result type

Parameters:

sources - an array of source ObservableSources

zipper - a function that, when applied to an item emitted by each of the ObservableSources, results in an item that will be emitted by the resulting Observable

delayError - delay errors signaled by any of the ObservableSource until all ObservableSources terminate

bufferSize - the number of elements expected from each source ObservableSource to be buffered

Returns:

the new Observable instance

Throws:

NullPointerException - if sources or zipper is null

IllegalArgumentException - if bufferSize is non-positive

See Also:

ReactiveX operators documentation: Zip

all

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Single<Boolean> all(@NonNull Predicate<? super T> predicate)

Returns a Single that emits a Boolean that indicates whether all of the items emitted by the current Observable satisfy a condition.

Scheduler:

all does not operate by default on a particular Scheduler.

Parameters:

predicate - a function that evaluates an item and returns a Boolean

Returns:

the new Single instance

Throws:

NullPointerException - if predicate is null

See Also:

ReactiveX operators documentation: All

ambWith

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Observable<T> ambWith(@NonNull ObservableSource<? extends T> other)

Mirrors the current Observable or the other ObservableSource provided of which the first either emits an item or sends a termination notification.

When the current Observable signals an item or terminates first, the subscription to the other ObservableSource is disposed. If the other ObservableSource signals an item or terminates first, the subscription to the current Observable is disposed.

Scheduler:

ambWith does not operate by default on a particular Scheduler.

Error handling:

If the losing ObservableSource signals an error, the error is routed to the global error handler via RxJavaPlugins.onError(Throwable).

Parameters:

other - an ObservableSource competing to react first. A subscription to this provided source will occur after subscribing to the current source.

Returns:

the new Observable instance

Throws:

NullPointerException - if other is null

See Also:

ReactiveX operators documentation: Amb

any

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Single<Boolean> any(@NonNull Predicate<? super T> predicate)

Returns a Single that emits true if any item emitted by the current Observable satisfies a specified condition, otherwise false. Note: this always emits false if the current Observable is empty.

In Rx.Net this is the any Observer but we renamed it in RxJava to better match Java naming idioms.

Scheduler:

any does not operate by default on a particular Scheduler.

Parameters:

predicate - the condition to test items emitted by the current Observable

Returns:

the new Single instance

Throws:

NullPointerException - if predicate is null

See Also:

ReactiveX operators documentation: Contains

blockingFirst

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final T blockingFirst()

Returns the first item emitted by the current Observable, or throws NoSuchElementException if it emits no items.

Scheduler:

blockingFirst does not operate by default on a particular Scheduler.

Error handling:

If the source signals an error, the operator wraps a checked Exception into RuntimeException and throws that. Otherwise, RuntimeExceptions and Errors are rethrown as they are.

Returns:

the first item emitted by the current Observable

Throws:

NoSuchElementException - if the current Observable emits no items

See Also:

ReactiveX documentation: First

blockingFirst

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final T blockingFirst(@NonNull T defaultItem)

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

Scheduler:

blockingFirst does not operate by default on a particular Scheduler.

Error handling:

If the source signals an error, the operator wraps a checked Exception into RuntimeException and throws that. Otherwise, RuntimeExceptions and Errors are rethrown as they are.

Parameters:

defaultItem - a default value to return if the current Observable emits no items

Returns:

the first item emitted by the current Observable, or the default value if it emits no items

Throws:

NullPointerException - if defaultItem is null

See Also:

ReactiveX documentation: First

blockingForEach

@SchedulerSupport(value="none")
public final void blockingForEach(@NonNull Consumer<? super T> onNext)

Consumes the current Observable in a blocking fashion and invokes the given Consumer with each upstream item on the current thread until the upstream terminates.

Note: the method will only return if the upstream terminates or the current thread is interrupted.

This method executes the Consumer on the current thread while subscribe(Consumer) executes the consumer on the original caller thread of the sequence.

Scheduler:

blockingForEach does not operate by default on a particular Scheduler.

Error handling:

If the source signals an error, the operator wraps a checked Exception into RuntimeException and throws that. Otherwise, RuntimeExceptions and Errors are rethrown as they are.

Parameters:

onNext - the Consumer to invoke for each item emitted by the Observable

Throws:

NullPointerException - if onNext is null

RuntimeException - if an error occurs

See Also:

ReactiveX documentation: Subscribe, subscribe(Consumer), blockingForEach(Consumer, int)

blockingForEach

@SchedulerSupport(value="none")
public final void blockingForEach(@NonNull Consumer<? super T> onNext,
        int capacityHint)

Consumes the current Observable in a blocking fashion and invokes the given Consumer with each upstream item on the current thread until the upstream terminates.

Note: the method will only return if the upstream terminates or the current thread is interrupted.

This method executes the Consumer on the current thread while subscribe(Consumer) executes the consumer on the original caller thread of the sequence.

Scheduler:

blockingForEach does not operate by default on a particular Scheduler.

Error handling:

If the source signals an error, the operator wraps a checked Exception into RuntimeException and throws that. Otherwise, RuntimeExceptions and Errors are rethrown as they are.

Parameters:

onNext - the Consumer to invoke for each item emitted by the Observable

capacityHint - the number of items expected to be buffered (allows reducing buffer reallocations)

Throws:

NullPointerException - if onNext is null

IllegalArgumentException - if capacityHint is non-positive

RuntimeException - if an error occurs; Errors and RuntimeExceptions are rethrown as they are, checked Exceptions are wrapped into RuntimeExceptions

See Also:

ReactiveX documentation: Subscribe, subscribe(Consumer)

blockingIterable

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Iterable<T> blockingIterable()

Exposes the current Observable as an Iterable which, when iterated, subscribes to the current Observable and blocks until the current Observable emits items or terminates.

Scheduler:

blockingIterable does not operate by default on a particular Scheduler.

Returns:

the new Iterable instance

See Also:

ReactiveX documentation: To

blockingIterable

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Iterable<T> blockingIterable(int capacityHint)

Exposes the current Observable as an Iterable which, when iterated, subscribes to the current Observable and blocks until the current Observable emits items or terminates.

Scheduler:

blockingIterable does not operate by default on a particular Scheduler.

Parameters:

capacityHint - the expected number of items to be buffered

Returns:

the new Iterable instance

Throws:

IllegalArgumentException - if capacityHint is non-positive

See Also:

ReactiveX documentation: To

blockingLast

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final T blockingLast()

Returns the last item emitted by the current Observable, or throws NoSuchElementException if the current Observable emits no items.

Scheduler:

blockingLast does not operate by default on a particular Scheduler.

Error handling:

If the source signals an error, the operator wraps a checked Exception into RuntimeException and throws that. Otherwise, RuntimeExceptions and Errors are rethrown as they are.

Returns:

the last item emitted by the current Observable

Throws:

NoSuchElementException - if the current Observable emits no items

See Also:

ReactiveX documentation: Last

blockingLast

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final T blockingLast(@NonNull T defaultItem)

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

Scheduler:

blockingLast does not operate by default on a particular Scheduler.

Error handling:

If the source signals an error, the operator wraps a checked Exception into RuntimeException and throws that. Otherwise, RuntimeExceptions and Errors are rethrown as they are.

Parameters:

defaultItem - a default value to return if the current Observable emits no items

Returns:

the last item emitted by the Observable, or the default value if it emits no items

Throws:

NullPointerException - if defaultItem is null

See Also:

ReactiveX documentation: Last

blockingLatest

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Iterable<T> blockingLatest()

Returns an Iterable that returns the latest item emitted by the current Observable, waiting if necessary for one to become available.

If the current Observable produces items faster than Iterator.next takes them, onNext events might be skipped, but onError or onComplete events are not.

Note also that an onNext directly followed by onComplete might hide the onNext event.

Scheduler:

blockingLatest does not operate by default on a particular Scheduler.

Returns:

the new Iterable instance

See Also:

ReactiveX documentation: First

blockingMostRecent

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Iterable<T> blockingMostRecent(@NonNull T initialItem)

Returns an Iterable that always returns the item most recently emitted by the current Observable.

Scheduler:

blockingMostRecent does not operate by default on a particular Scheduler.

Parameters:

initialItem - the initial value that the Iterable sequence will yield if the current Observable has not yet emitted an item

Returns:

the new Iterable instance

Throws:

NullPointerException - if initialItem is null

See Also:

ReactiveX documentation: First

blockingNext

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Iterable<T> blockingNext()

Returns an Iterable that blocks until the current Observable emits another item, then returns that item.

Scheduler:

blockingNext does not operate by default on a particular Scheduler.

Returns:

the new Iterable instance

See Also:

ReactiveX documentation: TakeLast

blockingSingle

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final T blockingSingle()

If the current Observable completes after emitting a single item, return that item, otherwise throw a NoSuchElementException.

Scheduler:

blockingSingle does not operate by default on a particular Scheduler.

Error handling:

If the source signals an error, the operator wraps a checked Exception into RuntimeException and throws that. Otherwise, RuntimeExceptions and Errors are rethrown as they are.

Returns:

the single item emitted by the current Observable

See Also:

ReactiveX documentation: First

blockingSingle

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final T blockingSingle(@NonNull T defaultItem)

If the current Observable 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.

Scheduler:

blockingSingle does not operate by default on a particular Scheduler.

Error handling:

If the source signals an error, the operator wraps a checked Exception into RuntimeException and throws that. Otherwise, RuntimeExceptions and Errors are rethrown as they are.

Parameters:

defaultItem - a default value to return if the current Observable emits no items

Returns:

the single item emitted by the current Observable, or the default value if it emits no items

Throws:

NullPointerException - if defaultItem is null

See Also:

ReactiveX documentation: First

toFuture

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Future<T> toFuture()

Returns a Future representing the only value emitted by the current Observable.

If the Observable emits more than one item, Future will receive an IndexOutOfBoundsException. If the Observable is empty, Future will receive an NoSuchElementException. The Observable source has to terminate in order for the returned Future to terminate as well.

If the Observable may emit more than one item, use Observable.toList().toFuture().

Scheduler:

toFuture does not operate by default on a particular Scheduler.

Returns:

the new Future instance

See Also:

ReactiveX documentation: To, singleOrErrorStage()

blockingSubscribe

@SchedulerSupport(value="none")
public final void blockingSubscribe()

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

Note that calling this method will block the caller thread until the upstream terminates normally or with an error. Therefore, calling this method from special threads such as the Android Main Thread or the Swing Event Dispatch Thread is not recommended.

Scheduler:

blockingSubscribe does not operate by default on a particular Scheduler.

Since:

2.0

See Also:

blockingSubscribe(Consumer), blockingSubscribe(Consumer, Consumer), blockingSubscribe(Consumer, Consumer, Action)

blockingSubscribe

@SchedulerSupport(value="none")
public final void blockingSubscribe(@NonNull Consumer<? super T> onNext)

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

If the Observable emits an error, it is wrapped into an OnErrorNotImplementedException and routed to the RxJavaPlugins.onError(Throwable) handler. Using the overloads blockingSubscribe(Consumer, Consumer) or blockingSubscribe(Consumer, Consumer, Action) instead is recommended.

Note that calling this method will block the caller thread until the upstream terminates normally or with an error. Therefore, calling this method from special threads such as the Android Main Thread or the Swing Event Dispatch Thread is not recommended.

Scheduler:

blockingSubscribe does not operate by default on a particular Scheduler.

Parameters:

onNext - the callback action for each source value

Throws:

NullPointerException - if onNext is null

Since:

2.0

See Also:

blockingSubscribe(Consumer, Consumer), blockingSubscribe(Consumer, Consumer, Action)

blockingSubscribe

@SchedulerSupport(value="none")
public final 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.

Note that calling this method will block the caller thread until the upstream terminates normally or with an error. Therefore, calling this method from special threads such as the Android Main Thread or the Swing Event Dispatch Thread is not recommended.

Scheduler:

blockingSubscribe does not operate by default on a particular Scheduler.

Parameters:

onNext - the callback action for each source value

onError - the callback action for an error event

Throws:

NullPointerException - if onNext or onError is null

Since:

2.0

See Also:

blockingSubscribe(Consumer, Consumer, Action)

blockingSubscribe

@SchedulerSupport(value="none")
public final 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.

Note that calling this method will block the caller thread until the upstream terminates normally or with an error. Therefore, calling this method from special threads such as the Android Main Thread or the Swing Event Dispatch Thread is not recommended.

Scheduler:

blockingSubscribe does not operate by default on a particular Scheduler.

Parameters:

onNext - the callback action for each source value

onError - the callback action for an error event

onComplete - the callback action for the completion event.

Throws:

NullPointerException - if onNext, onError or onComplete is null

Since:

2.0

blockingSubscribe

@SchedulerSupport(value="none")
public final void blockingSubscribe(@NonNull Observer<? super T> observer)

Subscribes to the source and calls the Observer methods on the current thread.

Note that calling this method will block the caller thread until the upstream terminates normally, with an error or the Observer disposes the Disposable it receives via Observer.onSubscribe(Disposable). Therefore, calling this method from special threads such as the Android Main Thread or the Swing Event Dispatch Thread is not recommended.

Scheduler:

blockingSubscribe does not operate by default on a particular Scheduler.

The a dispose() call is composed through.

Parameters:

observer - the Observer instance to forward events and calls to in the current thread

Throws:

NullPointerException - if observer is null

Since:

2.0

buffer

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Observable<List<T>> buffer(int count)

Returns an Observable that emits buffers of items it collects from the current Observable. The resulting Observable emits connected, non-overlapping buffers, each containing count items. When the current Observable completes, the resulting Observable emits the current buffer and propagates the notification from the current Observable. Note that if the current Observable issues an onError notification the event is passed on immediately without first emitting the buffer it is in the process of assembling.

Scheduler:

This version of buffer does not operate by default on a particular Scheduler.

Parameters:

count - the maximum number of items in each buffer before it should be emitted

Returns:

the new Observable instance

Throws:

IllegalArgumentException - if count is non-positive

See Also:

ReactiveX operators documentation: Buffer

buffer

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Observable<List<T>> buffer(int count,
        int skip)

Returns an Observable that emits buffers of items it collects from the current Observable. The resulting Observable emits buffers every skip items, each containing count items. When the current Observable completes, the resulting Observable emits the current buffer and propagates the notification from the current Observable. Note that if the current Observable issues an onError notification the event is passed on immediately without first emitting the buffer it is in the process of assembling.

Scheduler:

This version of buffer does not operate by default on a particular Scheduler.

Parameters:

count - the maximum size of each buffer before it should be emitted

skip - how many items emitted by the current Observable should be skipped before starting a new buffer. Note that when skip and count are equal, this is the same operation as buffer(int).

Returns:

the new Observable instance

Throws:

IllegalArgumentException - if count or skip is non-positive

See Also:

ReactiveX operators documentation: Buffer

buffer

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final <U extends Collection<? super T>> @NonNull Observable<U> buffer(int count,
        int skip,
        @NonNull Supplier<U> bufferSupplier)

Returns an Observable that emits buffers of items it collects from the current Observable. The resulting Observable emits buffers every skip items, each containing count items. When the current Observable completes, the resulting Observable emits the current buffer and propagates the notification from the current Observable. Note that if the current Observable issues an onError notification the event is passed on immediately without first emitting the buffer it is in the process of assembling.

Scheduler:

This version of buffer does not operate by default on a particular Scheduler.

Type Parameters:

U - the collection subclass type to buffer into

Parameters:

count - the maximum size of each buffer before it should be emitted

skip - how many items emitted by the current Observable should be skipped before starting a new buffer. Note that when skip and count are equal, this is the same operation as buffer(int).

bufferSupplier - a factory function that returns an instance of the collection subclass to be used and returned as the buffer

Returns:

the new Observable instance

Throws:

NullPointerException - if bufferSupplier is null

IllegalArgumentException - if count or skip is non-positive

See Also:

ReactiveX operators documentation: Buffer

buffer

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final <U extends Collection<? super T>> @NonNull Observable<U> buffer(int count,
        @NonNull Supplier<U> bufferSupplier)

Returns an Observable that emits buffers of items it collects from the current Observable. The resulting Observable emits connected, non-overlapping buffers, each containing count items. When the current Observable completes, the resulting Observable emits the current buffer and propagates the notification from the current Observable. Note that if the current Observable issues an onError notification the event is passed on immediately without first emitting the buffer it is in the process of assembling.

Scheduler:

This version of buffer does not operate by default on a particular Scheduler.

Type Parameters:

U - the collection subclass type to buffer into

Parameters:

count - the maximum number of items in each buffer before it should be emitted

bufferSupplier - a factory function that returns an instance of the collection subclass to be used and returned as the buffer

Returns:

the new Observable instance

Throws:

NullPointerException - if bufferSupplier is null

IllegalArgumentException - if count is non-positive

See Also:

ReactiveX operators documentation: Buffer

buffer

@CheckReturnValue
 @SchedulerSupport(value="io.reactivex:computation")
 @NonNull
public final @NonNull Observable<List<T>> buffer(long timespan,
        long timeskip,
        @NonNull TimeUnit unit)

Returns an Observable that emits buffers of items it collects from the current Observable. The resulting Observable starts a new buffer periodically, as determined by the timeskip argument. It emits each buffer after a fixed timespan, specified by the timespan argument. When the current Observable completes, the resulting Observable emits the current buffer and propagates the notification from the current Observable. Note that if the current Observable issues an onError notification the event is passed on immediately without first emitting the buffer it is in the process of assembling.

Scheduler:

This version of buffer operates by default on the computation Scheduler.

Parameters:

timespan - the period of time each buffer collects items before it is emitted

timeskip - the period of time after which a new buffer will be created

unit - the unit of time that applies to the timespan and timeskip arguments

Returns:

the new Observable instance

Throws:

NullPointerException - if unit is null

See Also:

ReactiveX operators documentation: Buffer

buffer

@CheckReturnValue
 @SchedulerSupport(value="custom")
 @NonNull
public final @NonNull Observable<List<T>> buffer(long timespan,
        long timeskip,
        @NonNull TimeUnit unit,
        @NonNull Scheduler scheduler)

Returns an Observable that emits buffers of items it collects from the current Observable. The resulting Observable starts a new buffer periodically, as determined by the timeskip argument, and on the specified scheduler. It emits each buffer after a fixed timespan, specified by the timespan argument. When the current Observable completes, the resulting Observable emits the current buffer and propagates the notification from the current Observable. Note that if the current Observable issues an onError notification the event is passed on immediately without first emitting the buffer it is in the process of assembling.

Scheduler:

You specify which Scheduler this operator will use.

Parameters:

timespan - the period of time each buffer collects items before it is emitted

timeskip - the period of time after which a new buffer will be created

unit - the unit of time that applies to the timespan and timeskip arguments

scheduler - the Scheduler to use when determining the end and start of a buffer

Returns:

the new Observable instance

Throws:

NullPointerException - if unit or scheduler is null

See Also:

ReactiveX operators documentation: Buffer

buffer

@CheckReturnValue
 @SchedulerSupport(value="custom")
 @NonNull
public final <U extends Collection<? super T>> @NonNull Observable<U> buffer(long timespan,
        long timeskip,
        @NonNull TimeUnit unit,
        @NonNull Scheduler scheduler,
        @NonNull Supplier<U> bufferSupplier)

Returns an Observable that emits buffers of items it collects from the current Observable. The resulting Observable starts a new buffer periodically, as determined by the timeskip argument, and on the specified scheduler. It emits each buffer after a fixed timespan, specified by the timespan argument. When the current Observable completes, the resulting Observable emits the current buffer and propagates the notification from the current Observable. Note that if the current Observable issues an onError notification the event is passed on immediately without first emitting the buffer it is in the process of assembling.

Scheduler:

You specify which Scheduler this operator will use.

Type Parameters:

U - the collection subclass type to buffer into

Parameters:

timespan - the period of time each buffer collects items before it is emitted

timeskip - the period of time after which a new buffer will be created

unit - the unit of time that applies to the timespan and timeskip arguments

scheduler - the Scheduler to use when determining the end and start of a buffer

bufferSupplier - a factory function that returns an instance of the collection subclass to be used and returned as the buffer

Returns:

the new Observable instance

Throws:

NullPointerException - if unit, scheduler or bufferSupplier is null

See Also:

ReactiveX operators documentation: Buffer

buffer

@CheckReturnValue
 @SchedulerSupport(value="io.reactivex:computation")
 @NonNull
public final @NonNull Observable<List<T>> buffer(long timespan,
        @NonNull TimeUnit unit)

Returns an Observable that emits buffers of items it collects from the current Observable. The resulting Observable emits connected, non-overlapping buffers, each of a fixed duration specified by the timespan argument. When the current Observable completes, the resulting Observable emits the current buffer and propagates the notification from the current Observable. Note that if the current Observable issues an onError notification the event is passed on immediately without first emitting the buffer it is in the process of assembling.

Scheduler:

This version of buffer operates by default on the computation Scheduler.

Parameters:

timespan - the period of time each buffer collects items before it is emitted and replaced with a new buffer

unit - the unit of time that applies to the timespan argument

Returns:

the new Observable instance

Throws:

NullPointerException - if unit is null

See Also:

ReactiveX operators documentation: Buffer

buffer

@CheckReturnValue
 @SchedulerSupport(value="io.reactivex:computation")
 @NonNull
public final @NonNull Observable<List<T>> buffer(long timespan,
        @NonNull TimeUnit unit,
        int count)

Returns an Observable that emits buffers of items it collects from the current Observable. The resulting Observable emits connected, non-overlapping buffers, each of a fixed duration specified by the timespan argument or a maximum size specified by the count argument (whichever is reached first). When the current Observable completes, the resulting Observable emits the current buffer and propagates the notification from the current Observable. Note that if the current Observable issues an onError notification the event is passed on immediately without first emitting the buffer it is in the process of assembling.

Scheduler:

This version of buffer operates by default on the computation Scheduler.

Parameters:

timespan - the period of time each buffer collects items before it is emitted and replaced with a new buffer

unit - the unit of time which applies to the timespan argument

count - the maximum size of each buffer before it is emitted

Returns:

the new Observable instance

Throws:

NullPointerException - if unit is null

IllegalArgumentException - if count is non-positive

See Also:

ReactiveX operators documentation: Buffer

buffer

@CheckReturnValue
 @SchedulerSupport(value="custom")
 @NonNull
public final @NonNull Observable<List<T>> buffer(long timespan,
        @NonNull TimeUnit unit,
        @NonNull Scheduler scheduler,
        int count)

Returns an Observable that emits buffers of items it collects from the current Observable. The resulting Observable emits connected, non-overlapping buffers, each of a fixed duration specified by the timespan argument as measured on the specified scheduler, or a maximum size specified by the count argument (whichever is reached first). When the current Observable completes, the resulting Observable emits the current buffer and propagates the notification from the current Observable. Note that if the current Observable issues an onError notification the event is passed on immediately without first emitting the buffer it is in the process of assembling.

Scheduler:

You specify which Scheduler this operator will use.

Parameters:

timespan - the period of time each buffer collects items before it is emitted and replaced with a new buffer

unit - the unit of time which applies to the timespan argument

scheduler - the Scheduler to use when determining the end and start of a buffer

count - the maximum size of each buffer before it is emitted

Returns:

the new Observable instance

Throws:

NullPointerException - if unit or scheduler is null

IllegalArgumentException - if count is non-positive

See Also:

ReactiveX operators documentation: Buffer

buffer

@CheckReturnValue
 @SchedulerSupport(value="custom")
 @NonNull
public final <U extends Collection<? super T>> @NonNull Observable<U> buffer(long timespan,
        @NonNull TimeUnit unit,
        @NonNull Scheduler scheduler,
        int count,
        @NonNull Supplier<U> bufferSupplier,
        boolean restartTimerOnMaxSize)

Returns an Observable that emits buffers of items it collects from the current Observable. The resulting Observable emits connected, non-overlapping buffers, each of a fixed duration specified by the timespan argument as measured on the specified scheduler, or a maximum size specified by the count argument (whichever is reached first). When the current Observable completes, the resulting Observable emits the current buffer and propagates the notification from the current Observable. Note that if the current Observable issues an onError notification the event is passed on immediately without first emitting the buffer it is in the process of assembling.

Scheduler:

You specify which Scheduler this operator will use.

Type Parameters:

U - the collection subclass type to buffer into

Parameters:

timespan - the period of time each buffer collects items before it is emitted and replaced with a new buffer

unit - the unit of time which applies to the timespan argument

scheduler - the Scheduler to use when determining the end and start of a buffer

count - the maximum size of each buffer before it is emitted

bufferSupplier - a factory function that returns an instance of the collection subclass to be used and returned as the buffer

restartTimerOnMaxSize - if true, the time window is restarted when the max capacity of the current buffer is reached

Returns:

the new Observable instance

Throws:

NullPointerException - if unit, scheduler or bufferSupplier is null

IllegalArgumentException - if count is non-positive

See Also:

ReactiveX operators documentation: Buffer

buffer

@CheckReturnValue
 @SchedulerSupport(value="custom")
 @NonNull
public final @NonNull Observable<List<T>> buffer(long timespan,
        @NonNull TimeUnit unit,
        @NonNull Scheduler scheduler)

Returns an Observable that emits buffers of items it collects from the current Observable. The resulting Observable emits connected, non-overlapping buffers, each of a fixed duration specified by the timespan argument and on the specified scheduler. When the current Observable completes, the resulting Observable emits the current buffer and propagates the notification from the current Observable. Note that if the current Observable issues an onError notification the event is passed on immediately without first emitting the buffer it is in the process of assembling.

Scheduler:

You specify which Scheduler this operator will use.

Parameters:

timespan - the period of time each buffer collects items before it is emitted and replaced with a new buffer

unit - the unit of time which applies to the timespan argument

scheduler - the Scheduler to use when determining the end and start of a buffer

Returns:

the new Observable instance

Throws:

NullPointerException - if unit or scheduler is null

See Also:

ReactiveX operators documentation: Buffer

buffer

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final <TOpening,TClosing> @NonNull Observable<List<T>> buffer(@NonNull ObservableSource<? extends TOpening> openingIndicator,
        @NonNull Function<? super TOpening,? extends ObservableSource<? extends TClosing>> closingIndicator)

Returns an Observable that emits buffers of items it collects from the current Observable. The resulting Observable emits buffers that it creates when the specified openingIndicator ObservableSource emits an item, and closes when the ObservableSource returned from closingIndicator emits an item. If any of the current Observable, openingIndicator or closingIndicator issues an onError notification the event is passed on immediately without first emitting the buffer it is in the process of assembling.

Scheduler:

This version of buffer does not operate by default on a particular Scheduler.

Type Parameters:

TOpening - the element type of the buffer-opening ObservableSource

TClosing - the element type of the individual buffer-closing ObservableSources

Parameters:

openingIndicator - the ObservableSource that, when it emits an item, causes a new buffer to be created

closingIndicator - the Function that is used to produce an ObservableSource for every buffer created. When this indicator ObservableSource emits an item, the associated buffer is emitted.

Returns:

the new Observable instance

Throws:

NullPointerException - if openingIndicator or closingIndicator is null

See Also:

ReactiveX operators documentation: Buffer

buffer

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final <TOpening,TClosing,U extends Collection<? super T>> @NonNull Observable<U> buffer(@NonNull ObservableSource<? extends TOpening> openingIndicator,
        @NonNull Function<? super TOpening,? extends ObservableSource<? extends TClosing>> closingIndicator,
        @NonNull Supplier<U> bufferSupplier)

Returns an Observable that emits buffers of items it collects from the current Observable. The resulting Observable emits buffers that it creates when the specified openingIndicator ObservableSource emits an item, and closes when the ObservableSource returned from closingIndicator emits an item. If any of the current Observable, openingIndicator or closingIndicator issues an onError notification the event is passed on immediately without first emitting the buffer it is in the process of assembling.

Scheduler:

This version of buffer does not operate by default on a particular Scheduler.

Type Parameters:

U - the collection subclass type to buffer into

TOpening - the element type of the buffer-opening ObservableSource

TClosing - the element type of the individual buffer-closing ObservableSources

Parameters:

openingIndicator - the ObservableSource that, when it emits an item, causes a new buffer to be created

closingIndicator - the Function that is used to produce an ObservableSource for every buffer created. When this indicator ObservableSource emits an item, the associated buffer is emitted.

bufferSupplier - a factory function that returns an instance of the collection subclass to be used and returned as the buffer

Returns:

the new Observable instance

Throws:

NullPointerException - if openingIndicator, closingIndicator or bufferSupplier is null

See Also:

ReactiveX operators documentation: Buffer

buffer

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final <B> @NonNull Observable<List<T>> buffer(@NonNull ObservableSource<B> boundaryIndicator)

Returns an Observable that emits non-overlapping buffered items from the current Observable each time the specified boundary ObservableSource emits an item.

Completion of either the source or the boundary ObservableSource causes the returned ObservableSource to emit the latest buffer and complete. If either the current Observable or the boundary ObservableSource issues an onError notification the event is passed on immediately without first emitting the buffer it is in the process of assembling.

Scheduler:

This version of buffer does not operate by default on a particular Scheduler.

Type Parameters:

B - the boundary value type (ignored)

Parameters:

boundaryIndicator - the boundary ObservableSource

Returns:

the new Observable instance

Throws:

NullPointerException - if boundaryIndicator is null

See Also:

buffer(ObservableSource, int), ReactiveX operators documentation: Buffer

buffer

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final <B> @NonNull Observable<List<T>> buffer(@NonNull ObservableSource<B> boundaryIndicator,
        int initialCapacity)

Returns an Observable that emits non-overlapping buffered items from the current Observable each time the specified boundary ObservableSource emits an item.

Completion of either the source or the boundary ObservableSource causes the returned ObservableSource to emit the latest buffer and complete. If either the current Observable or the boundary ObservableSource issues an onError notification the event is passed on immediately without first emitting the buffer it is in the process of assembling.

Scheduler:

This version of buffer does not operate by default on a particular Scheduler.

Type Parameters:

B - the boundary value type (ignored)

Parameters:

boundaryIndicator - the boundary ObservableSource

initialCapacity - the initial capacity of each buffer chunk

Returns:

the new Observable instance

Throws:

NullPointerException - if boundaryIndicator is null

IllegalArgumentException - if initialCapacity is non-positive

See Also:

ReactiveX operators documentation: Buffer, buffer(ObservableSource)

buffer

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final <B,U extends Collection<? super T>> @NonNull Observable<U> buffer(@NonNull ObservableSource<B> boundaryIndicator,
        @NonNull Supplier<U> bufferSupplier)

Returns an Observable that emits non-overlapping buffered items from the current Observable each time the specified boundary ObservableSource emits an item.

Completion of either the source or the boundary ObservableSource causes the returned ObservableSource to emit the latest buffer and complete. If either the current Observable or the boundary ObservableSource issues an onError notification the event is passed on immediately without first emitting the buffer it is in the process of assembling.

Scheduler:

This version of buffer does not operate by default on a particular Scheduler.

Type Parameters:

U - the collection subclass type to buffer into

B - the boundary value type (ignored)

Parameters:

boundaryIndicator - the boundary ObservableSource

bufferSupplier - a factory function that returns an instance of the collection subclass to be used and returned as the buffer

Returns:

the new Observable instance

Throws:

NullPointerException - if boundaryIndicator or bufferSupplier is null

See Also:

buffer(ObservableSource, int), ReactiveX operators documentation: Buffer

cache

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Observable<T> cache()

Returns an Observable that subscribes to the current Observable lazily, caches all of its events and replays them, in the same order as received, to all the downstream observers.

This is useful when you want an Observable to cache responses and you can't control the subscribe/dispose behavior of all the Observers.

The operator subscribes only when the first downstream observer subscribes and maintains a single subscription towards the current Observable. In contrast, the operator family of replay() that return a ConnectableObservable require an explicit call to ConnectableObservable.connect().

Note: You sacrifice the ability to dispose the origin when you use the cache operator so be careful not to use this operator on Observables that emit an infinite or very large number of items that will use up memory. A possible workaround is to apply takeUntil with a predicate or another source before (and perhaps after) the application of cache().

 AtomicBoolean shouldStop = new AtomicBoolean();

 source.takeUntil(v -> shouldStop.get())
       .cache()
       .takeUntil(v -> shouldStop.get())
       .subscribe(...);
 

Since the operator doesn't allow clearing the cached values either, the possible workaround is to forget all references to it via onTerminateDetach() applied along with the previous workaround:

 AtomicBoolean shouldStop = new AtomicBoolean();

 source.takeUntil(v -> shouldStop.get())
       .onTerminateDetach()
       .cache()
       .takeUntil(v -> shouldStop.get())
       .onTerminateDetach()
       .subscribe(...);
 

Scheduler:

cache does not operate by default on a particular Scheduler.

Returns:

the new Observable instance

See Also:

ReactiveX operators documentation: Replay, takeUntil(Predicate), takeUntil(ObservableSource)

cacheWithInitialCapacity

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Observable<T> cacheWithInitialCapacity(int initialCapacity)

Returns an Observable that subscribes to the current Observable lazily, caches all of its events and replays them, in the same order as received, to all the downstream observers.

This is useful when you want an Observable to cache responses and you can't control the subscribe/dispose behavior of all the Observers.

The operator subscribes only when the first downstream observer subscribes and maintains a single subscription towards the current Observable. In contrast, the operator family of replay() that return a ConnectableObservable require an explicit call to ConnectableObservable.connect().

Note: You sacrifice the ability to dispose the origin when you use the cache operator so be careful not to use this operator on Observables that emit an infinite or very large number of items that will use up memory. A possible workaround is to apply `takeUntil` with a predicate or another source before (and perhaps after) the application of cache().

 AtomicBoolean shouldStop = new AtomicBoolean();

 source.takeUntil(v -> shouldStop.get())
       .cache()
       .takeUntil(v -> shouldStop.get())
       .subscribe(...);
 

Since the operator doesn't allow clearing the cached values either, the possible workaround is to forget all references to it via onTerminateDetach() applied along with the previous workaround:

 AtomicBoolean shouldStop = new AtomicBoolean();

 source.takeUntil(v -> shouldStop.get())
       .onTerminateDetach()
       .cache()
       .takeUntil(v -> shouldStop.get())
       .onTerminateDetach()
       .subscribe(...);
 

Scheduler:

cacheWithInitialCapacity does not operate by default on a particular Scheduler.

Note: The capacity hint is not an upper bound on cache size. For that, consider replay(int) in combination with ConnectableObservable.autoConnect() or similar.

Parameters:

initialCapacity - hint for number of items to cache (for optimizing underlying data structure)

Returns:

the new Observable instance

Throws:

IllegalArgumentException - if initialCapacity is non-positive

See Also:

ReactiveX operators documentation: Replay, takeUntil(Predicate), takeUntil(ObservableSource)

cast

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final <U> @NonNull Observable<U> cast(@NonNull Class<U> clazz)

Returns an Observable 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.

Scheduler:

cast does not operate by default on a particular Scheduler.

Type Parameters:

U - the output value type cast to

Parameters:

clazz - the target class to use to try and cast the upstream items into

Returns:

the new Observable instance

Throws:

NullPointerException - if clazz is null

See Also:

ReactiveX operators documentation: Map

collect

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final <U> @NonNull Single<U> collect(@NonNull Supplier<? extends U> initialItemSupplier,
        @NonNull BiConsumer<? super U,? super T> collector)

Collects items emitted by the finite source Observable into a single mutable data structure and returns a Single that emits this structure.

This is a simplified version of reduce that does not need to return the state on each pass.

Note that this operator requires the upstream to signal onComplete for the accumulator object to be emitted. Sources that are infinite and never complete will never emit anything through this operator and an infinite source may lead to a fatal OutOfMemoryError.

Scheduler:

collect does not operate by default on a particular Scheduler.

Type Parameters:

U - the accumulator and output type

Parameters:

initialItemSupplier - the mutable data structure that will collect the items

collector - a function that accepts the state and an emitted item, and modifies the accumulator accordingly accordingly

Returns:

the new Single instance

Throws:

NullPointerException - if initialItemSupplier or collector is null

See Also:

ReactiveX operators documentation: Reduce

collectInto

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final <U> @NonNull Single<U> collectInto(@NonNull U initialItem,
        @NonNull BiConsumer<? super U,? super T> collector)

Collects items emitted by the finite source Observable into a single mutable data structure and returns a Single that emits this structure.

This is a simplified version of reduce that does not need to return the state on each pass.

Note that this operator requires the upstream to signal onComplete for the accumulator object to be emitted. Sources that are infinite and never complete will never emit anything through this operator and an infinite source may lead to a fatal OutOfMemoryError.

Scheduler:

collectInto does not operate by default on a particular Scheduler.

Type Parameters:

U - the accumulator and output type

Parameters:

initialItem - the mutable data structure that will collect the items

collector - a function that accepts the state and an emitted item, and modifies the accumulator accordingly accordingly

Returns:

the new Single instance

Throws:

NullPointerException - if initialItem or collector is null

See Also:

ReactiveX operators documentation: Reduce

compose

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final <R> @NonNull Observable<R> compose(@NonNull ObservableTransformer<? super T,? extends R> composer)

Transform the current Observable by applying a particular ObservableTransformer function to it.

This method operates on the Observable itself whereas lift(io.reactivex.rxjava3.core.ObservableOperator<? extends R, ? super T>) operates on the ObservableSource's Observers.

If the operator you are creating is designed to act on the individual items emitted by the current Observable, use lift(io.reactivex.rxjava3.core.ObservableOperator<? extends R, ? super T>). If your operator is designed to transform the current Observable as a whole (for instance, by applying a particular set of existing RxJava operators to it) use compose.

Scheduler:

compose does not operate by default on a particular Scheduler.

Type Parameters:

R - the value type of the output ObservableSource

Parameters:

composer - implements the function that transforms the current Observable

Returns:

the new Observable instance

Throws:

NullPointerException - if composer is null

See Also:

RxJava wiki: Implementing Your Own Operators

concatMap

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final <R> @NonNull Observable<R> concatMap(@NonNull Function<? super T,? extends ObservableSource<? extends R>> mapper)

Returns a new Observable that emits items resulting from applying a function that you supply to each item emitted by the current Observable, where that function returns an ObservableSource, and then emitting the items that result from concatenating those returned ObservableSources.

Note that there is no guarantee where the given mapper function will be executed; it could be on the subscribing thread, on the upstream thread signaling the new item to be mapped or on the thread where the inner source terminates. To ensure the mapper function is confined to a known thread, use the concatMap(Function, int, Scheduler) overload.

Scheduler:

concatMap does not operate by default on a particular Scheduler.

Type Parameters:

R - the type of the inner ObservableSource sources and thus the output type

Parameters:

mapper - a function that, when applied to an item emitted by the current Observable, returns an ObservableSource

Returns:

the new Observable instance

Throws:

NullPointerException - if mapper is null

See Also:

ReactiveX operators documentation: FlatMap, concatMap(Function, int, Scheduler)

concatMap

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final <R> @NonNull Observable<R> concatMap(@NonNull Function<? super T,? extends ObservableSource<? extends R>> mapper,
        int bufferSize)

Returns a new Observable that emits items resulting from applying a function that you supply to each item emitted by the current Observable, where that function returns an ObservableSource, and then emitting the items that result from concatenating those returned ObservableSources.

Note that there is no guarantee where the given mapper function will be executed; it could be on the subscribing thread, on the upstream thread signaling the new item to be mapped or on the thread where the inner source terminates. To ensure the mapper function is confined to a known thread, use the concatMap(Function, int, Scheduler) overload.

Scheduler:

concatMap does not operate by default on a particular Scheduler.

Type Parameters:

R - the type of the inner ObservableSource sources and thus the output type

Parameters:

mapper - a function that, when applied to an item emitted by the current Observable, returns an ObservableSource

bufferSize - the number of elements expected from the current Observable to be buffered

Returns:

the new Observable instance

Throws:

NullPointerException - if mapper is null

IllegalArgumentException - if bufferSize is non-positive

See Also:

ReactiveX operators documentation: FlatMap, concatMap(Function, int, Scheduler)

concatMap

@CheckReturnValue
 @SchedulerSupport(value="custom")
 @NonNull
public final <R> @NonNull Observable<R> concatMap(@NonNull Function<? super T,? extends ObservableSource<? extends R>> mapper,
        int bufferSize,
        @NonNull Scheduler scheduler)

Returns a new Observable that emits items resulting from applying a function that you supply to each item emitted by the current Observable, where that function returns an ObservableSource, and then emitting the items that result from concatenating those returned ObservableSources.

The difference between concatMap(Function, int) and this operator is that this operator guarantees the mapper function is executed on the specified scheduler.

Scheduler:

concatMap executes the given mapper function on the provided Scheduler.

Type Parameters:

R - the type of the inner ObservableSource sources and thus the output type

Parameters:

mapper - a function that, when applied to an item emitted by the current Observable, returns an ObservableSource

bufferSize - the number of elements expected from the current Observable to be buffered

scheduler - the scheduler where the mapper function will be executed

Returns:

the new Observable instance

Throws:

NullPointerException - if mapper or scheduler is null

IllegalArgumentException - if bufferSize is non-positive

Since:

3.0.0

See Also:

ReactiveX operators documentation: FlatMap

concatMapDelayError

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final <R> @NonNull Observable<R> concatMapDelayError(@NonNull Function<? super T,? extends ObservableSource<? extends R>> mapper)

Maps each of the items into an ObservableSource, 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 ObservableSources till all of them terminate.

Note that there is no guarantee where the given mapper function will be executed; it could be on the subscribing thread, on the upstream thread signaling the new item to be mapped or on the thread where the inner source terminates. To ensure the mapper function is confined to a known thread, use the concatMapDelayError(Function, boolean, int, Scheduler) overload.

Scheduler:

concatMapDelayError does not operate by default on a particular Scheduler.

Type Parameters:

R - the result value type

Parameters:

mapper - the function that maps the items of the current Observable into the inner ObservableSources.

Returns:

the new Observable instance with the concatenation behavior

Throws:

NullPointerException - if mapper is null

See Also:

concatMapDelayError(Function, boolean, int, Scheduler)

concatMapDelayError

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final <R> @NonNull Observable<R> concatMapDelayError(@NonNull Function<? super T,? extends ObservableSource<? extends R>> mapper,
        boolean tillTheEnd,
        int bufferSize)

Maps each of the items into an ObservableSource, 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 ObservableSources till all of them terminate.

Note that there is no guarantee where the given mapper function will be executed; it could be on the subscribing thread, on the upstream thread signaling the new item to be mapped or on the thread where the inner source terminates. To ensure the mapper function is confined to a known thread, use the concatMapDelayError(Function, boolean, int, Scheduler) overload.

Scheduler:

concatMapDelayError does not operate by default on a particular Scheduler.

Type Parameters:

R - the result value type

Parameters:

mapper - the function that maps the items of the current Observable into the inner ObservableSources.

tillTheEnd - if true, all errors from the outer and inner ObservableSource sources are delayed until the end, if false, an error from the main source is signaled when the current Observable source terminates

bufferSize - the number of elements expected from the current Observable to be buffered

Returns:

the new Observable instance with the concatenation behavior

Throws:

NullPointerException - if mapper is null

IllegalArgumentException - if bufferSize is non-positive

See Also:

concatMapDelayError(Function, boolean, int, Scheduler)

concatMapDelayError

@CheckReturnValue
 @SchedulerSupport(value="custom")
 @NonNull
public final <R> @NonNull Observable<R> concatMapDelayError(@NonNull Function<? super T,? extends ObservableSource<? extends R>> mapper,
        boolean tillTheEnd,
        int bufferSize,
        @NonNull Scheduler scheduler)

Maps each of the items into an ObservableSource, 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 ObservableSources till all of them terminate.

Scheduler:

concatMapDelayError does not operate by default on a particular Scheduler.

Type Parameters:

R - the result value type

Parameters:

mapper - the function that maps the items of the current Observable into the inner ObservableSources.

tillTheEnd - if true, all errors from the outer and inner ObservableSource sources are delayed until the end, if false, an error from the main source is signaled when the current Observable source terminates

bufferSize - the number of elements expected from the current Observable to be buffered

scheduler - the scheduler where the mapper function will be executed

Returns:

the new Observable instance with the concatenation behavior

Throws:

NullPointerException - if mapper or scheduler is null

IllegalArgumentException - if bufferSize is non-positive

Since:

3.0.0

See Also:

concatMapDelayError(Function, boolean, int)

concatMapEager

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final <R> @NonNull Observable<R> concatMapEager(@NonNull Function<? super T,? extends ObservableSource<? extends R>> mapper)

Maps a sequence of values into ObservableSources and concatenates these ObservableSources eagerly into a single Observable sequence.

Eager concatenation means that once a subscriber subscribes, this operator subscribes to all of the current Observables. The operator buffers the values emitted by these ObservableSources and then drains them in order, each one after the previous one completes.

Scheduler:

This method does not operate by default on a particular Scheduler.

Type Parameters:

R - the value type

Parameters:

mapper - the function that maps a sequence of values into a sequence of ObservableSources that will be eagerly concatenated

Returns:

the new Observable instance with the specified concatenation behavior

Throws:

NullPointerException - if mapper is null

Since:

2.0

concatMapEager

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final <R> @NonNull Observable<R> concatMapEager(@NonNull Function<? super T,? extends ObservableSource<? extends R>> mapper,
        int maxConcurrency,
        int bufferSize)

Maps a sequence of values into ObservableSources and concatenates these ObservableSources eagerly into a single Observable sequence.

Eager concatenation means that once a subscriber subscribes, this operator subscribes to all of the current Observables. The operator buffers the values emitted by these ObservableSources and then drains them in order, each one after the previous one completes.

Scheduler:

This method does not operate by default on a particular Scheduler.

Type Parameters:

R - the value type

Parameters:

mapper - the function that maps a sequence of values into a sequence of ObservableSources that will be eagerly concatenated

maxConcurrency - the maximum number of concurrent subscribed ObservableSources

bufferSize - hints about the number of expected items from each inner ObservableSource, must be positive

Returns:

the new Observable instance with the specified concatenation behavior

Throws:

NullPointerException - if mapper is null

IllegalArgumentException - if maxConcurrency or bufferSize is non-positive

Since:

2.0

concatMapEagerDelayError

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final <R> @NonNull Observable<R> concatMapEagerDelayError(@NonNull Function<? super T,? extends ObservableSource<? extends R>> mapper,
        boolean tillTheEnd)

Maps a sequence of values into ObservableSources and concatenates these ObservableSources eagerly into a single Observable sequence.

Eager concatenation means that once a subscriber subscribes, this operator subscribes to all of the current Observables. The operator buffers the values emitted by these ObservableSources and then drains them in order, each one after the previous one completes.

Scheduler:

This method does not operate by default on a particular Scheduler.

Type Parameters:

R - the value type

Parameters:

mapper - the function that maps a sequence of values into a sequence of ObservableSources that will be eagerly concatenated

tillTheEnd - if true, all errors from the outer and inner ObservableSource sources are delayed until the end, if false, an error from the main source is signaled when the current Observable source terminates

Returns:

the new Observable instance with the specified concatenation behavior

Throws:

NullPointerException - if mapper is null

Since:

2.0

concatMapEagerDelayError

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final <R> @NonNull Observable<R> concatMapEagerDelayError(@NonNull Function<? super T,? extends ObservableSource<? extends R>> mapper,
        boolean tillTheEnd,
        int maxConcurrency,
        int bufferSize)

Maps a sequence of values into ObservableSources and concatenates these ObservableSources eagerly into a single Observable sequence.

Eager concatenation means that once a subscriber subscribes, this operator subscribes to all of the current Observables. The operator buffers the values emitted by these ObservableSources and then drains them in order, each one after the previous one completes.

Scheduler:

This method does not operate by default on a particular Scheduler.

Type Parameters:

R - the value type

Parameters:

mapper - the function that maps a sequence of values into a sequence of ObservableSources that will be eagerly concatenated

tillTheEnd - if true, exceptions from the current Observable and all the inner ObservableSources are delayed until all of them terminate, if false, exception from the current Observable is delayed until the currently running ObservableSource terminates

maxConcurrency - the maximum number of concurrent subscribed ObservableSources

bufferSize - the number of elements expected from the current Observable and each inner ObservableSource to be buffered

Returns:

the new Observable instance with the specified concatenation behavior

Throws:

NullPointerException - if mapper is null

IllegalArgumentException - if maxConcurrency or bufferSize is non-positive

Since:

2.0

concatMapCompletable

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Completable concatMapCompletable(@NonNull Function<? super T,? extends CompletableSource> mapper)

Maps each element of the current Observable into CompletableSources, subscribes to them one at a time in order and waits until the upstream and all CompletableSources complete.

Scheduler:

concatMapCompletable does not operate by default on a particular Scheduler.

History: 2.1.6 - experimental

Parameters:

mapper - a function that, when applied to an item emitted by the current Observable, returns a CompletableSource

Returns:

the new Completable instance

Throws:

NullPointerException - if mapper is null

Since:

2.2

concatMapCompletable

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Completable concatMapCompletable(@NonNull Function<? super T,? extends CompletableSource> mapper,
        int capacityHint)

Maps each element of the current Observable into CompletableSources, subscribes to them one at a time in order and waits until the upstream and all CompletableSources complete.

Scheduler:

concatMapCompletable does not operate by default on a particular Scheduler.

History: 2.1.6 - experimental

Parameters:

mapper - a function that, when applied to an item emitted by the current Observable, returns a CompletableSource

capacityHint - the number of upstream items expected to be buffered until the current CompletableSource, mapped from the current item, completes.

Returns:

the new Completable instance

Throws:

NullPointerException - if mapper is null

IllegalArgumentException - if capacityHint is non-positive

Since:

2.2

concatMapCompletableDelayError

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Completable concatMapCompletableDelayError(@NonNull Function<? super T,? extends CompletableSource> mapper)

Maps the upstream items into CompletableSources and subscribes to them one after the other terminates, delaying all errors till both the current Observable and all inner CompletableSources terminate.

Scheduler:

concatMapCompletableDelayError does not operate by default on a particular Scheduler.

History: 2.1.11 - experimental

Parameters:

mapper - the function called with the upstream item and should return a CompletableSource to become the next source to be subscribed to

Returns:

the new Completable instance

Throws:

NullPointerException - if mapper is null

Since:

2.2

See Also:

concatMapCompletable(Function, int)

concatMapCompletableDelayError

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Completable concatMapCompletableDelayError(@NonNull Function<? super T,? extends CompletableSource> mapper,
        boolean tillTheEnd)

Maps the upstream items into CompletableSources and subscribes to them one after the other terminates, optionally delaying all errors till both the current Observable and all inner CompletableSources terminate.

Scheduler:

concatMapCompletableDelayError does not operate by default on a particular Scheduler.

History: 2.1.11 - experimental

Parameters:

mapper - the function called with the upstream item and should return a CompletableSource to become the next source to be subscribed to

tillTheEnd - If true, errors from the current Observable or any of the inner CompletableSources are delayed until all of them terminate. If false, an error from the current Observable is delayed until the current inner CompletableSource terminates and only then is it emitted to the downstream.

Returns:

the new Completable instance

Throws:

NullPointerException - if mapper is null

Since:

2.2

See Also:

concatMapCompletable(Function)

concatMapCompletableDelayError

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Completable concatMapCompletableDelayError(@NonNull Function<? super T,? extends CompletableSource> mapper,
        boolean tillTheEnd,
        int bufferSize)

Maps the upstream items into CompletableSources and subscribes to them one after the other terminates, optionally delaying all errors till both the current Observable and all inner CompletableSources terminate.

Scheduler:

concatMapCompletableDelayError does not operate by default on a particular Scheduler.

History: 2.1.11 - experimental

Parameters:

mapper - the function called with the upstream item and should return a CompletableSource to become the next source to be subscribed to

tillTheEnd - If true, errors from the current Observable or any of the inner CompletableSources are delayed until all of them terminate. If false, an error from the current Observable is delayed until the current inner CompletableSource terminates and only then is it emitted to the downstream.

bufferSize - The number of upstream items expected to be buffered so that fresh items are ready to be mapped when a previous CompletableSource terminates.

Returns:

the new Completable instance

Throws:

NullPointerException - if mapper is null

IllegalArgumentException - if bufferSize is non-positive

Since:

2.2

See Also:

concatMapCompletable(Function, int)

concatMapIterable

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final <U> @NonNull Observable<U> concatMapIterable(@NonNull Function<? super T,? extends Iterable<? extends U>> mapper)

Returns an Observable that concatenate each item emitted by the current Observable with the values in an Iterable corresponding to that item that is generated by a selector.

Scheduler:

concatMapIterable does not operate by default on a particular Scheduler.

Type Parameters:

U - the type of item emitted by the resulting Observable

Parameters:

mapper - a function that returns an Iterable sequence of values for when given an item emitted by the current Observable

Returns:

the new Observable instance

Throws:

NullPointerException - if mapper is null

See Also:

ReactiveX operators documentation: FlatMap

concatMapMaybe

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final <R> @NonNull Observable<R> concatMapMaybe(@NonNull Function<? super T,? extends MaybeSource<? extends R>> mapper)

Maps the upstream items into MaybeSources and subscribes to them one after the other succeeds or completes, emits their success value if available or terminates immediately if either the current Observable or the current inner MaybeSource fail.

Scheduler:

concatMapMaybe does not operate by default on a particular Scheduler.

History: 2.1.11 - experimental

Type Parameters:

R - the result type of the inner MaybeSources

Parameters:

mapper - the function called with the upstream item and should return a MaybeSource to become the next source to be subscribed to

Returns:

the new Observable instance

Throws:

NullPointerException - if mapper is null

Since:

2.2

See Also:

concatMapMaybeDelayError(Function), concatMapMaybe(Function, int)

concatMapMaybe

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final <R> @NonNull Observable<R> concatMapMaybe(@NonNull Function<? super T,? extends MaybeSource<? extends R>> mapper,
        int bufferSize)

Maps the upstream items into MaybeSources and subscribes to them one after the other succeeds or completes, emits their success value if available or terminates immediately if either the current Observable or the current inner MaybeSource fail.

Scheduler:

concatMapMaybe does not operate by default on a particular Scheduler.

History: 2.1.11 - experimental

Type Parameters:

R - the result type of the inner MaybeSources

Parameters:

mapper - the function called with the upstream item and should return a MaybeSource to become the next source to be subscribed to

bufferSize - The number of upstream items expected to be buffered so that fresh items are ready to be mapped when a previous MaybeSource terminates.

Returns:

the new Observable instance

Throws:

NullPointerException - if mapper is null

IllegalArgumentException - if bufferSize is non-positive

Since:

2.2

See Also:

concatMapMaybe(Function), concatMapMaybeDelayError(Function, boolean, int)

concatMapMaybeDelayError

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final <R> @NonNull Observable<R> concatMapMaybeDelayError(@NonNull Function<? super T,? extends MaybeSource<? extends R>> mapper)

Maps the upstream items into MaybeSources and subscribes to them one after the other terminates, emits their success value if available and delaying all errors till both the current Observable and all inner MaybeSources terminate.

Scheduler:

concatMapMaybeDelayError does not operate by default on a particular Scheduler.

History: 2.1.11 - experimental

Type Parameters:

R - the result type of the inner MaybeSources

Parameters:

mapper - the function called with the upstream item and should return a MaybeSource to become the next source to be subscribed to

Returns:

the new Observable instance

Throws:

NullPointerException - if mapper is null

Since:

2.2

See Also:

concatMapMaybe(Function), concatMapMaybeDelayError(Function, boolean)

concatMapMaybeDelayError

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final <R> @NonNull Observable<R> concatMapMaybeDelayError(@NonNull Function<? super T,? extends MaybeSource<? extends R>> mapper,
        boolean tillTheEnd)

Maps the upstream items into MaybeSources and subscribes to them one after the other terminates, emits their success value if available and optionally delaying all errors till both the current Observable and all inner MaybeSources terminate.

Scheduler:

concatMapMaybeDelayError does not operate by default on a particular Scheduler.

History: 2.1.11 - experimental

Type Parameters:

R - the result type of the inner MaybeSources

Parameters:

mapper - the function called with the upstream item and should return a MaybeSource to become the next source to be subscribed to

tillTheEnd - If true, errors from the current Observable or any of the inner MaybeSources are delayed until all of them terminate. If false, an error from the current Observable is delayed until the current inner MaybeSource terminates and only then is it emitted to the downstream.

Returns:

the new Observable instance

Throws:

NullPointerException - if mapper is null

Since:

2.2

See Also:

concatMapMaybe(Function, int), concatMapMaybeDelayError(Function, boolean, int)

concatMapMaybeDelayError

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final <R> @NonNull Observable<R> concatMapMaybeDelayError(@NonNull Function<? super T,? extends MaybeSource<? extends R>> mapper,
        boolean tillTheEnd,
        int bufferSize)

Maps the upstream items into MaybeSources and subscribes to them one after the other terminates, emits their success value if available and optionally delaying all errors till both the current Observable and all inner MaybeSources terminate.

Scheduler:

concatMapMaybeDelayError does not operate by default on a particular Scheduler.

History: 2.1.11 - experimental

Type Parameters:

R - the result type of the inner MaybeSources

Parameters:

mapper - the function called with the upstream item and should return a MaybeSource to become the next source to be subscribed to

tillTheEnd - If true, errors from the current Observable or any of the inner MaybeSources are delayed until all of them terminate. If false, an error from the current Observable is delayed until the current inner MaybeSource terminates and only then is it emitted to the downstream.

bufferSize - The number of upstream items expected to be buffered so that fresh items are ready to be mapped when a previous MaybeSource terminates.

Returns:

the new Observable instance

Throws:

NullPointerException - if mapper is null

IllegalArgumentException - if bufferSize is non-positive

Since:

2.2

See Also:

concatMapMaybe(Function, int)

concatMapSingle

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final <R> @NonNull Observable<R> concatMapSingle(@NonNull Function<? super T,? extends SingleSource<? extends R>> mapper)

Maps the upstream items into SingleSources and subscribes to them one after the other succeeds, emits their success values or terminates immediately if either the current Observable or the current inner SingleSource fail.

Scheduler:

concatMapSingle does not operate by default on a particular Scheduler.

History: 2.1.11 - experimental

Type Parameters:

R - the result type of the inner SingleSources

Parameters:

mapper - the function called with the upstream item and should return a SingleSource to become the next source to be subscribed to

Returns:

the new Observable instance

Throws:

NullPointerException - if mapper is null

Since:

2.2

See Also:

concatMapSingleDelayError(Function), concatMapSingle(Function, int)

concatMapSingle

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final <R> @NonNull Observable<R> concatMapSingle(@NonNull Function<? super T,? extends SingleSource<? extends R>> mapper,
        int bufferSize)

Maps the upstream items into SingleSources and subscribes to them one after the other succeeds, emits their success values or terminates immediately if either the current Observable or the current inner SingleSource fail.

Scheduler:

concatMapSingle does not operate by default on a particular Scheduler.

History: 2.1.11 - experimental

Type Parameters:

R - the result type of the inner SingleSources

Parameters:

mapper - the function called with the upstream item and should return a SingleSource to become the next source to be subscribed to

bufferSize - The number of upstream items expected to be buffered so that fresh items are ready to be mapped when a previous SingleSource terminates.

Returns:

the new Observable instance

Throws:

NullPointerException - if mapper is null

IllegalArgumentException - if bufferSize is non-positive

Since:

2.2

See Also:

concatMapSingle(Function), concatMapSingleDelayError(Function, boolean, int)

concatMapSingleDelayError

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final <R> @NonNull Observable<R> concatMapSingleDelayError(@NonNull Function<? super T,? extends SingleSource<? extends R>> mapper)

Maps the upstream items into SingleSources and subscribes to them one after the other succeeds or fails, emits their success values and delays all errors till both the current Observable and all inner SingleSources terminate.

Scheduler:

concatMapSingleDelayError does not operate by default on a particular Scheduler.

History: 2.1.11 - experimental

Type Parameters:

R - the result type of the inner SingleSources

Parameters:

mapper - the function called with the upstream item and should return a SingleSource to become the next source to be subscribed to

Returns:

the new Observable instance

Throws:

NullPointerException - if mapper is null

Since:

2.2

See Also:

concatMapSingle(Function), concatMapSingleDelayError(Function, boolean)

concatMapSingleDelayError

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final <R> @NonNull Observable<R> concatMapSingleDelayError(@NonNull Function<? super T,? extends SingleSource<? extends R>> mapper,
        boolean tillTheEnd)

Maps the upstream items into SingleSources and subscribes to them one after the other succeeds or fails, emits their success values and optionally delays all errors till both the current Observable and all inner SingleSources terminate.

Scheduler:

concatMapSingleDelayError does not operate by default on a particular Scheduler.

History: 2.1.11 - experimental

Type Parameters:

R - the result type of the inner SingleSources

Parameters:

mapper - the function called with the upstream item and should return a SingleSource to become the next source to be subscribed to

tillTheEnd - If true, errors from the current Observable or any of the inner SingleSources are delayed until all of them terminate. If false, an error from the current Observable is delayed until the current inner SingleSource terminates and only then is it emitted to the downstream.

Returns:

the new Observable instance

Throws:

NullPointerException - if mapper is null

Since:

2.2

See Also:

concatMapSingle(Function, int), concatMapSingleDelayError(Function, boolean, int)

concatMapSingleDelayError

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final <R> @NonNull Observable<R> concatMapSingleDelayError(@NonNull Function<? super T,? extends SingleSource<? extends R>> mapper,
        boolean tillTheEnd,
        int bufferSize)

Maps the upstream items into SingleSources and subscribes to them one after the other succeeds or fails, emits their success values and optionally delays errors till both the current Observable and all inner SingleSources terminate.

Scheduler:

concatMapSingleDelayError does not operate by default on a particular Scheduler.

History: 2.1.11 - experimental

Type Parameters:

R - the result type of the inner SingleSources

Parameters:

mapper - the function called with the upstream item and should return a SingleSource to become the next source to be subscribed to

tillTheEnd - If true, errors from the current Observable or any of the inner SingleSources are delayed until all of them terminate. If false, an error from the current Observable is delayed until the current inner SingleSource terminates and only then is it emitted to the downstream.

bufferSize - The number of upstream items expected to be buffered so that fresh items are ready to be mapped when a previous SingleSource terminates.

Returns:

the new Observable instance

Throws:

NullPointerException - if mapper is null

IllegalArgumentException - if bufferSize is non-positive

Since:

2.2

See Also:

concatMapSingle(Function, int)

concatWith

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Observable<T> concatWith(@NonNull ObservableSource<? extends T> other)

Returns an Observable that first emits the items emitted from the current Observable, then items from the other ObservableSource without interleaving them.

Scheduler:

concatWith does not operate by default on a particular Scheduler.

Parameters:

other - an ObservableSource to be concatenated after the current

Returns:

the new Observable instance

Throws:

NullPointerException - if other is null

See Also:

ReactiveX operators documentation: Concat

concatWith

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Observable<T> concatWith(@NonNull SingleSource<? extends T> other)

Returns an Observable that emits the items from the current Observable followed by the success item or error event of the other SingleSource.

Scheduler:

concatWith does not operate by default on a particular Scheduler.

History: 2.1.10 - experimental

Parameters:

other - the SingleSource whose signal should be emitted after the current Observable completes normally.

Returns:

the new Observable instance

Throws:

NullPointerException - if other is null

Since:

2.2

concatWith

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Observable<T> concatWith(@NonNull MaybeSource<? extends T> other)

Returns an Observable that emits the items from the current Observable followed by the success item or terminal events of the other MaybeSource.

Scheduler:

concatWith does not operate by default on a particular Scheduler.

History: 2.1.10 - experimental

Parameters:

other - the MaybeSource whose signal should be emitted after the current Observable completes normally.

Returns:

the new Observable instance

Throws:

NullPointerException - if other is null

Since:

2.2

concatWith

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Observable<T> concatWith(@NonNull CompletableSource other)

Returns an Observable that emits items from the current Observable and when it completes normally, the other CompletableSource is subscribed to and the returned Observable emits its terminal events.

Scheduler:

concatWith does not operate by default on a particular Scheduler.

History: 2.1.10 - experimental

Parameters:

other - the CompletableSource to subscribe to once the current Observable completes normally

Returns:

the new Observable instance

Throws:

NullPointerException - if other is null

Since:

2.2

contains

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Single<Boolean> contains(@NonNull Object item)

Returns a Single that emits a Boolean that indicates whether the current Observable emitted a specified item.

Scheduler:

contains does not operate by default on a particular Scheduler.

Parameters:

item - the item to search for in the emissions from the current Observable

Returns:

the new Single instance

Throws:

NullPointerException - if item is null

See Also:

ReactiveX operators documentation: Contains

count

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Single<Long> count()

Returns a Single that counts the total number of items emitted by the current Observable and emits this count as a 64-bit Long.

Scheduler:

count does not operate by default on a particular Scheduler.

Returns:

the new Single instance

See Also:

ReactiveX operators documentation: Count

debounce

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final <U> @NonNull Observable<T> debounce(@NonNull Function<? super T,? extends ObservableSource<U>> debounceIndicator)

Returns an Observable that mirrors the current Observable, except that it drops items emitted by the current Observable that are followed by another item within a computed debounce duration denoted by an item emission or completion from a generated inner ObservableSource for that original item.

The delivery of the item happens on the thread of the first onNext or onComplete signal of the generated ObservableSource sequence, which if takes too long, a newer item may arrive from the upstream, causing the generated sequence to get disposed, which may also interrupt any downstream blocking operation (yielding an InterruptedException). It is recommended processing items that may take long time to be moved to another thread via observeOn(io.reactivex.rxjava3.core.Scheduler) applied after debounce itself.

Scheduler:

This version of debounce does not operate by default on a particular Scheduler.

Type Parameters:

U - the debounce value type (ignored)

Parameters:

debounceIndicator - function to return a sequence that indicates the throttle duration for each item via its own emission or completion

Returns:

the new Observable instance

Throws:

NullPointerException - if debounceIndicator is null

See Also:

ReactiveX operators documentation: Debounce

debounce

@CheckReturnValue
 @SchedulerSupport(value="io.reactivex:computation")
 @NonNull
public final @NonNull Observable<T> debounce(long timeout,
        @NonNull TimeUnit unit)

Returns an Observable that mirrors the current Observable, except that it drops items emitted by the current Observable that are followed by newer items before a timeout value expires. The timer resets on each emission.

Note: If items keep being emitted by the current Observable faster than the timeout then no items will be emitted by the resulting Observable.

Delivery of the item after the grace period happens on the computation Scheduler's Worker which if takes too long, a newer item may arrive from the upstream, causing the Worker's task to get disposed, which may also interrupt any downstream blocking operation (yielding an InterruptedException). It is recommended processing items that may take long time to be moved to another thread via observeOn(io.reactivex.rxjava3.core.Scheduler) applied after debounce itself.

Scheduler:

debounce operates by default on the computation Scheduler.

Parameters:

timeout - the length of the window of time that must pass after the emission of an item from the current Observable in which the Observable emits no items in order for the item to be emitted by the resulting Observable

unit - the unit of time for the specified timeout

Returns:

the new Observable instance

Throws:

NullPointerException - if unit is null

See Also:

ReactiveX operators documentation: Debounce, throttleWithTimeout(long, TimeUnit)

debounce

@CheckReturnValue
 @SchedulerSupport(value="custom")
 @NonNull
public final @NonNull Observable<T> debounce(long timeout,
        @NonNull TimeUnit unit,
        @NonNull Scheduler scheduler)

Returns an Observable that mirrors the current Observable, except that it drops items emitted by the current Observable that are followed by newer items before a timeout value expires on a specified Scheduler. The timer resets on each emission.

Note: If items keep being emitted by the current Observable faster than the timeout then no items will be emitted by the resulting Observable.

Delivery of the item after the grace period happens on the given Scheduler's Worker which if takes too long, a newer item may arrive from the upstream, causing the Worker's task to get disposed, which may also interrupt any downstream blocking operation (yielding an InterruptedException). It is recommended processing items that may take long time to be moved to another thread via observeOn(io.reactivex.rxjava3.core.Scheduler) applied after debounce itself.

Scheduler:

You specify which Scheduler this operator will use.

Parameters:

timeout - the time each item has to be "the most recent" of those emitted by the current Observable to ensure that it's not dropped

unit - the unit of time for the specified timeout

scheduler - the Scheduler to use internally to manage the timers that handle the timeout for each item

Returns:

the new Observable instance

Throws:

NullPointerException - if unit or scheduler is null

See Also:

ReactiveX operators documentation: Debounce, throttleWithTimeout(long, TimeUnit, Scheduler)

debounce

@CheckReturnValue
 @SchedulerSupport(value="custom")
 @NonNull
public final @NonNull Observable<T> debounce(long timeout,
        @NonNull TimeUnit unit,
        @NonNull Scheduler scheduler,
        @NonNull Consumer<? super T> onDropped)

Returns an Observable that mirrors the current Observable, except that it drops items emitted by the current Observable that are followed by newer items before a timeout value expires on a specified Scheduler. The timer resets on each emission.

Note: If items keep being emitted by the current Observable faster than the timeout then no items will be emitted by the resulting Observable.

Delivery of the item after the grace period happens on the given Scheduler's Worker which if takes too long, a newer item may arrive from the upstream, causing the Worker's task to get disposed, which may also interrupt any downstream blocking operation (yielding an InterruptedException). It is recommended processing items that may take long time to be moved to another thread via observeOn(io.reactivex.rxjava3.core.Scheduler) applied after debounce itself.

Scheduler:

You specify which Scheduler this operator will use.

Parameters:

timeout - the time each item has to be "the most recent" of those emitted by the current Observable to ensure that it's not dropped

unit - the unit of time for the specified timeout

scheduler - the Scheduler to use internally to manage the timers that handle the timeout for each item

onDropped - called with the current entry when it has been replaced by a new one

Returns:

the new Observable instance

Throws:

NullPointerException - if unit or scheduler is null } or onDropped is null

Since:

3.1.6 - Experimental

See Also:

ReactiveX operators documentation: Debounce, throttleWithTimeout(long, TimeUnit, Scheduler, Consumer)

defaultIfEmpty

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Observable<T> defaultIfEmpty(@NonNull T defaultItem)

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

Scheduler:

defaultIfEmpty does not operate by default on a particular Scheduler.

Parameters:

defaultItem - the item to emit if the current Observable emits no items

Returns:

the new Observable instance

Throws:

NullPointerException - if defaultItem is null

See Also:

ReactiveX operators documentation: DefaultIfEmpty

delay

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final <U> @NonNull Observable<T> delay(@NonNull Function<? super T,? extends ObservableSource<U>> itemDelayIndicator)

Returns an Observable that delays the emissions of the current Observable via a per-item derived ObservableSource's item emission or termination, on a per source item basis.

Note: the resulting Observable will immediately propagate any onError notification from the current Observable.

Scheduler:

This version of delay does not operate by default on a particular Scheduler.

Type Parameters:

U - the item delay value type (ignored)

Parameters:

itemDelayIndicator - a function that returns an ObservableSource for each item emitted by the current Observable, which is then used to delay the emission of that item by the resulting Observable until the ObservableSource returned from itemDelay emits an item

Returns:

the new Observable instance

Throws:

NullPointerException - if itemDelayIndicator is null

See Also:

ReactiveX operators documentation: Delay

delay

@CheckReturnValue
 @SchedulerSupport(value="io.reactivex:computation")
 @NonNull
public final @NonNull Observable<T> delay(long time,
        @NonNull TimeUnit unit)

Returns an Observable that emits the items emitted by the current Observable shifted forward in time by a specified delay. An error notification from the current Observable is not delayed.

Scheduler:

This version of delay operates by default on the computation Scheduler.

Parameters:

time - the delay to shift the source by

unit - the TimeUnit in which period is defined

Returns:

the new Observable instance

Throws:

NullPointerException - if unit is null

See Also:

ReactiveX operators documentation: Delay, delay(long, TimeUnit, boolean), delay(long, TimeUnit, Scheduler)

delay

@CheckReturnValue
 @SchedulerSupport(value="io.reactivex:computation")
 @NonNull
public final @NonNull Observable<T> delay(long time,
        @NonNull TimeUnit unit,
        boolean delayError)

Returns an Observable that emits the items emitted by the current Observable shifted forward in time by a specified delay. If delayError is true, error notifications will also be delayed.

Scheduler:

This version of delay operates by default on the computation Scheduler.

Parameters:

time - the delay to shift the source by

unit - the TimeUnit in which period is defined

delayError - if true, the upstream exception is signaled with the given delay, after all preceding normal elements, if false, the upstream exception is signaled immediately

Returns:

the new Observable instance

Throws:

NullPointerException - if unit is null

See Also:

ReactiveX operators documentation: Delay, delay(long, TimeUnit, Scheduler, boolean)

delay

@CheckReturnValue
 @SchedulerSupport(value="custom")
 @NonNull
public final @NonNull Observable<T> delay(long time,
        @NonNull TimeUnit unit,
        @NonNull Scheduler scheduler)

Returns an Observable that emits the items emitted by the current Observable shifted forward in time by a specified delay. An error notification from the current Observable is not delayed.

Scheduler:

You specify which Scheduler this operator will use.

Parameters:

time - the delay to shift the source by

unit - the time unit of delay

scheduler - the Scheduler to use for delaying

Returns:

the new Observable instance

Throws:

NullPointerException - if unit or scheduler is null

See Also:

ReactiveX operators documentation: Delay

delay

@CheckReturnValue
 @SchedulerSupport(value="custom")
 @NonNull
public final @NonNull Observable<T> delay(long time,
        @NonNull TimeUnit unit,
        @NonNull Scheduler scheduler,
        boolean delayError)

Returns an Observable that emits the items emitted by the current Observable shifted forward in time by a specified delay. If delayError is true, error notifications will also be delayed.

Scheduler:

You specify which Scheduler this operator will use.

Parameters:

time - the delay to shift the source by

unit - the time unit of delay

scheduler - the Scheduler to use for delaying

delayError - if true, the upstream exception is signaled with the given delay, after all preceding normal elements, if false, the upstream exception is signaled immediately

Returns:

the new Observable instance

Throws:

NullPointerException - if unit or scheduler is null

See Also:

ReactiveX operators documentation: Delay

delay

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final <U,V> @NonNull Observable<T> delay(@NonNull ObservableSource<U> subscriptionIndicator,
        @NonNull Function<? super T,? extends ObservableSource<V>> itemDelayIndicator)

Returns an Observable that delays the subscription to and emissions from the current Observable via ObservableSources for the subscription itself and on a per-item basis.

Note: the resulting Observable will immediately propagate any onError notification from the current Observable.

Scheduler:

This version of delay does not operate by default on a particular Scheduler.

Type Parameters:

U - the subscription delay value type (ignored)

V - the item delay value type (ignored)

Parameters:

subscriptionIndicator - a function that returns an ObservableSource that triggers the subscription to the current Observable once it emits any item

itemDelayIndicator - a function that returns an ObservableSource for each item emitted by the current Observable, which is then used to delay the emission of that item by the resulting Observable until the ObservableSource returned from itemDelay emits an item

Returns:

the new Observable instance

Throws:

NullPointerException - if subscriptionIndicator or itemDelayIndicator is null

See Also:

ReactiveX operators documentation: Delay

delaySubscription

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final <U> @NonNull Observable<T> delaySubscription(@NonNull ObservableSource<U> subscriptionIndicator)

Returns an Observable that delays the subscription to the current Observable until the other ObservableSource emits an element or completes normally.

Scheduler:

This method does not operate by default on a particular Scheduler.

Type Parameters:

U - the value type of the other Observable, irrelevant

Parameters:

subscriptionIndicator - the other ObservableSource that should trigger the subscription to the current Observable.

Returns:

the new Observable instance

Throws:

NullPointerException - if subscriptionIndicator is null

Since:

2.0

delaySubscription

@CheckReturnValue
 @SchedulerSupport(value="io.reactivex:computation")
 @NonNull
public final @NonNull Observable<T> delaySubscription(long time,
        @NonNull TimeUnit unit)

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

Scheduler:

This version of delaySubscription operates by default on the computation Scheduler.

Parameters:

time - the time to delay the subscription

unit - the time unit of delay

Returns:

the new Observable instance

Throws:

NullPointerException - if unit is null

See Also:

ReactiveX operators documentation: Delay

delaySubscription

@CheckReturnValue
 @SchedulerSupport(value="custom")
 @NonNull
public final @NonNull Observable<T> delaySubscription(long time,
        @NonNull TimeUnit unit,
        @NonNull Scheduler scheduler)

Returns an Observable that delays the subscription to the current Observable by a given amount of time, both waiting and subscribing on a given Scheduler.

Scheduler:

You specify which Scheduler this operator will use.

Parameters:

time - the time to delay the subscription

unit - the time unit of delay

scheduler - the Scheduler on which the waiting and subscription will happen

Returns:

the new Observable instance

Throws:

NullPointerException - if unit or scheduler is null

See Also:

ReactiveX operators documentation: Delay

dematerialize

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final <R> @NonNull Observable<R> dematerialize(@NonNull Function<? super T,Notification<R>> selector)

Returns an Observable that reverses the effect of materialize by transforming the Notification objects extracted from the source items via a selector function into their respective Observer signal types.

The intended use of the selector function is to perform a type-safe identity mapping (see example) on a source that is already of type Notification<T>. The Java language doesn't allow limiting instance methods to a certain generic argument shape, therefore, a function is used to ensure the conversion remains type safe.

When the upstream signals an onError or onComplete item, the returned Observable disposes of the flow and terminates with that type of terminal event:

 Observable.just(createOnNext(1), createOnComplete(), createOnNext(2))
 .doOnDispose(() -> System.out.println("Disposed!"));
 .dematerialize(notification -> notification)
 .test()
 .assertResult(1);
 

If the upstream signals onError or onComplete directly, the flow is terminated with the same event.

 Observable.just(createOnNext(1), createOnNext(2))
 .dematerialize(notification -> notification)
 .test()
 .assertResult(1, 2);
 

If this behavior is not desired, the completion can be suppressed by applying concatWith(ObservableSource) with a never() source.

Scheduler:

dematerialize does not operate by default on a particular Scheduler.

History: 2.2.4 - experimental

Type Parameters:

R - the output value type

Parameters:

selector - function that returns the upstream item and should return a Notification to signal the corresponding Observer event to the downstream.

Returns:

the new Observable instance

Throws:

NullPointerException - if selector is null

Since:

3.0.0

See Also:

ReactiveX operators documentation: Dematerialize

distinct

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Observable<T> distinct()

Returns an Observable that emits all items emitted by the current Observable that are distinct based on Object.equals(Object) comparison.

It is recommended the elements' class T in the flow overrides the default Object.equals() and Object.hashCode() to provide meaningful comparison between items as the default Java implementation only considers reference equivalence.

By default, distinct() uses an internal HashSet per Observer to remember previously seen items and uses Set.add(Object) returning false as the indicator for duplicates.

Note that this internal HashSet may grow unbounded as items won't be removed from it by the operator. Therefore, using very long or infinite upstream (with very distinct elements) may lead to OutOfMemoryError.

Customizing the retention policy can happen only by providing a custom Collection implementation to the distinct(Function, Supplier) overload.

Scheduler:

distinct does not operate by default on a particular Scheduler.

Returns:

the new Observable instance

See Also:

ReactiveX operators documentation: Distinct, distinct(Function), distinct(Function, Supplier)

distinct

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final <K> @NonNull Observable<T> distinct(@NonNull Function<? super T,K> keySelector)

Returns an Observable that emits all items emitted by the current Observable that are distinct according to a key selector function and based on Object.equals(Object) comparison of the objects returned by the key selector function.

It is recommended the keys' class K overrides the default Object.equals() and Object.hashCode() to provide meaningful comparison between the key objects as the default Java implementation only considers reference equivalence.

By default, distinct() uses an internal HashSet per Observer to remember previously seen keys and uses Set.add(Object) returning false as the indicator for duplicates.

Note that this internal HashSet may grow unbounded as keys won't be removed from it by the operator. Therefore, using very long or infinite upstream (with very distinct keys) may lead to OutOfMemoryError.

Customizing the retention policy can happen only by providing a custom Collection implementation to the distinct(Function, Supplier) overload.

Scheduler:

distinct does not operate by default on a particular Scheduler.

Type Parameters:

K - the key type

Parameters:

keySelector - a function that projects an emitted item to a key value that is used to decide whether an item is distinct from another one or not

Returns:

the new Observable instance

Throws:

NullPointerException - if keySelector is null

See Also:

ReactiveX operators documentation: Distinct, distinct(Function, Supplier)

distinct

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final <K> @NonNull Observable<T> distinct(@NonNull Function<? super T,K> keySelector,
        @NonNull Supplier<? extends Collection<? super K>> collectionSupplier)

Returns an Observable that emits all items emitted by the current Observable that are distinct according to a key selector function and based on Object.equals(Object) comparison of the objects returned by the key selector function.

It is recommended the keys' class K overrides the default Object.equals() and Object.hashCode() to provide meaningful comparison between the key objects as the default Java implementation only considers reference equivalence.

Scheduler:

distinct does not operate by default on a particular Scheduler.

Type Parameters:

K - the key type

Parameters:

keySelector - a function that projects an emitted item to a key value that is used to decide whether an item is distinct from another one or not

collectionSupplier - function called for each individual Observer to return a Collection subtype for holding the extracted keys and whose add() method's return indicates uniqueness.

Returns:

the new Observable instance

Throws:

NullPointerException - if keySelector or collectionSupplier is null

See Also:

ReactiveX operators documentation: Distinct

distinctUntilChanged

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Observable<T> distinctUntilChanged()

Returns an Observable that emits all items emitted by the current Observable that are distinct from their immediate predecessors based on Object.equals(Object) comparison.

It is recommended the elements' class T in the flow overrides the default Object.equals() to provide meaningful comparison between items as the default Java implementation only considers reference equivalence. Alternatively, use the distinctUntilChanged(BiPredicate) overload and provide a comparison function in case the class T can't be overridden with custom equals() or the comparison itself should happen on different terms or properties of the class T.

Note that the operator always retains the latest item from upstream regardless of the comparison result and uses it in the next comparison with the next upstream item.

Note that if element type T in the flow is mutable, the comparison of the previous and current item may yield unexpected results if the items are mutated externally. Common cases are mutable CharSequences or Lists where the objects will actually have the same references when they are modified and distinctUntilChanged will evaluate subsequent items as same. To avoid such situation, it is recommended that mutable data is converted to an immutable one, for example using map(CharSequence::toString) or map(list -> Collections.unmodifiableList(new ArrayList<>(list))).

Scheduler:

distinctUntilChanged does not operate by default on a particular Scheduler.

Returns:

the new Observable instance

See Also:

ReactiveX operators documentation: Distinct, distinctUntilChanged(BiPredicate)

distinctUntilChanged

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final <K> @NonNull Observable<T> distinctUntilChanged(@NonNull Function<? super T,K> keySelector)

Returns an Observable that emits all items emitted by the current Observable that are distinct from their immediate predecessors, according to a key selector function and based on Object.equals(Object) comparison of those objects returned by the key selector function.

It is recommended the keys' class K overrides the default Object.equals() to provide meaningful comparison between the key objects as the default Java implementation only considers reference equivalence. Alternatively, use the distinctUntilChanged(BiPredicate) overload and provide a comparison function in case the class K can't be overridden with custom equals() or the comparison itself should happen on different terms or properties of the item class T (for which the keys can be derived via a similar selector).

Note that the operator always retains the latest key from upstream regardless of the comparison result and uses it in the next comparison with the next key derived from the next upstream item.

Note that if element type T in the flow is mutable, the comparison of the previous and current item may yield unexpected results if the items are mutated externally. Common cases are mutable CharSequences or Lists where the objects will actually have the same references when they are modified and distinctUntilChanged will evaluate subsequent items as same. To avoid such situation, it is recommended that mutable data is converted to an immutable one, for example using map(CharSequence::toString) or map(list -> Collections.unmodifiableList(new ArrayList<>(list))).

Scheduler:

distinctUntilChanged does not operate by default on a particular Scheduler.

Type Parameters:

K - the key type

Parameters:

keySelector - a function that projects an emitted item to a key value that is used to decide whether an item is distinct from another one or not

Returns:

the new Observable instance

Throws:

NullPointerException - if keySelector is null

See Also:

ReactiveX operators documentation: Distinct

distinctUntilChanged

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Observable<T> distinctUntilChanged(@NonNull BiPredicate<? super T,? super T> comparer)

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

Note that the operator always retains the latest item from upstream regardless of the comparison result and uses it in the next comparison with the next upstream item.

Note that if element type T in the flow is mutable, the comparison of the previous and current item may yield unexpected results if the items are mutated externally. Common cases are mutable CharSequences or Lists where the objects will actually have the same references when they are modified and distinctUntilChanged will evaluate subsequent items as same. To avoid such situation, it is recommended that mutable data is converted to an immutable one, for example using map(CharSequence::toString) or map(list -> Collections.unmodifiableList(new ArrayList<>(list))).

Scheduler:

distinctUntilChanged does not operate by default on a particular Scheduler.

Parameters:

comparer - the function that receives the previous item and the current item and is expected to return true if the two are equal, thus skipping the current value.

Returns:

the new Observable instance

Throws:

NullPointerException - if comparer is null

Since:

2.0

See Also:

ReactiveX operators documentation: Distinct

doAfterNext

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Observable<T> doAfterNext(@NonNull Consumer<? super T> onAfterNext)

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

Note that the onAfterNext action is shared between subscriptions and as such should be thread-safe.

Scheduler:

doAfterNext does not operate by default on a particular Scheduler.

Operator-fusion:

This operator supports boundary-limited synchronous or asynchronous queue-fusion.

History: 2.0.1 - experimental

Parameters:

onAfterNext - the Consumer that will be called after emitting an item from upstream to the downstream

Returns:

the new Observable instance

Throws:

NullPointerException - if onAfterNext is null

Since:

2.1

doAfterTerminate

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Observable<T> doAfterTerminate(@NonNull Action onAfterTerminate)

Registers an Action to be called when the current Observable invokes either onComplete or onError.

Scheduler:

doAfterTerminate does not operate by default on a particular Scheduler.

Parameters:

onAfterTerminate - an Action to be invoked after the current Observable finishes

Returns:

the new Observable instance

Throws:

NullPointerException - if onAfterTerminate is null

See Also:

ReactiveX operators documentation: Do, doOnTerminate(Action)

doFinally

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Observable<T> doFinally(@NonNull Action onFinally)

Calls the specified action after the current Observable signals onError or onCompleted or gets disposed by the downstream.

In case of a race between a terminal event and a dispose call, the provided onFinally action is executed once per subscription.

Note that the onFinally action is shared between subscriptions and as such should be thread-safe.

Scheduler:

doFinally does not operate by default on a particular Scheduler.

Operator-fusion:

This operator supports boundary-limited synchronous or asynchronous queue-fusion.

History: 2.0.1 - experimental

Parameters:

onFinally - the action called when the current Observable terminates or gets disposed

Returns:

the new Observable instance

Throws:

NullPointerException - if onFinally is null

Since:

2.1

doOnDispose

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Observable<T> doOnDispose(@NonNull Action onDispose)

Calls the given shared Action if the downstream disposes the sequence.

The action is shared between subscriptions and thus may be called concurrently from multiple threads; the action must be thread safe.

If the action throws a runtime exception, that exception is rethrown by the dispose() call, sometimes as a CompositeException if there were multiple exceptions along the way.

Scheduler:

doOnDispose does not operate by default on a particular Scheduler.

Parameters:

onDispose - the action that gets called when the current Observable's Disposable is disposed

Returns:

the new Observable instance

Throws:

NullPointerException - if onDispose is null

See Also:

ReactiveX operators documentation: Do

doOnComplete

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Observable<T> doOnComplete(@NonNull Action onComplete)

Returns an Observable that invokes an Action when the current Observable calls onComplete.

Scheduler:

doOnComplete does not operate by default on a particular Scheduler.

Parameters:

onComplete - the action to invoke when the current Observable calls onComplete

Returns:

the new Observable instance

Throws:

NullPointerException - if onComplete is null

See Also:

ReactiveX operators documentation: Do

doOnEach

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Observable<T> doOnEach(@NonNull Consumer<? super Notification<T>> onNotification)

Returns an Observable that invokes a Consumer with the appropriate Notification object when the current Observable signals an item or terminates.

Scheduler:

doOnEach does not operate by default on a particular Scheduler.

Parameters:

onNotification - the action to invoke for each item emitted by the current Observable

Returns:

the new Observable instance

Throws:

NullPointerException - if onNotification is null

See Also:

ReactiveX operators documentation: Do

doOnEach

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Observable<T> doOnEach(@NonNull Observer<? super T> observer)

Returns an Observable that forwards the items and terminal events of the current Observable to its Observers and to the given shared Observer instance.

In case the onError of the supplied observer throws, the downstream will receive a composite exception containing the original exception and the exception thrown by onError. If either the onNext or the onComplete method of the supplied observer throws, the downstream will be terminated and will receive this thrown exception.

Scheduler:

doOnEach does not operate by default on a particular Scheduler.

Parameters:

observer - the observer to be notified about onNext, onError and onComplete events on its respective methods before the actual downstream Observer gets notified.

Returns:

the new Observable instance

Throws:

NullPointerException - if observer is null

See Also:

ReactiveX operators documentation: Do

doOnError

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Observable<T> doOnError(@NonNull Consumer<? super Throwable> onError)

Calls the given Consumer with the error Throwable if the current Observable failed before forwarding it to the downstream.

In case the onError action throws, the downstream will receive a composite exception containing the original exception and the exception thrown by onError.

Scheduler:

doOnError does not operate by default on a particular Scheduler.

Parameters:

onError - the action to invoke if the current Observable calls onError

Returns:

the new Observable instance

Throws:

NullPointerException - if onError is null

See Also:

ReactiveX operators documentation: Do

doOnLifecycle

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Observable<T> doOnLifecycle(@NonNull Consumer<? super Disposable> onSubscribe,
        @NonNull Action onDispose)

Calls the appropriate onXXX method (shared between all Observers) for the lifecycle events of the sequence (subscription, disposal).

Scheduler:

doOnLifecycle does not operate by default on a particular Scheduler.

Parameters:

onSubscribe - a Consumer called with the Disposable sent via Observer.onSubscribe(Disposable)

onDispose - called when the downstream disposes the Disposable via dispose()

Returns:

the new Observable instance

Throws:

NullPointerException - if onSubscribe or onDispose is null

See Also:

ReactiveX operators documentation: Do

doOnNext

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Observable<T> doOnNext(@NonNull Consumer<? super T> onNext)

Calls the given Consumer with the value emitted by the current Observable before forwarding it to the downstream.

Scheduler:

doOnNext does not operate by default on a particular Scheduler.

Parameters:

onNext - the action to invoke when the current Observable calls onNext

Returns:

the new Observable instance

Throws:

NullPointerException - if onNext is null

See Also:

ReactiveX operators documentation: Do

doOnSubscribe

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Observable<T> doOnSubscribe(@NonNull Consumer<? super Disposable> onSubscribe)

Returns an Observable so that it invokes the given Consumer when the current Observable is subscribed from its Observers. Each subscription will result in an invocation of the given action except when the current Observable is reference counted, in which case the current Observable will invoke the given action for the first subscription.

Scheduler:

doOnSubscribe does not operate by default on a particular Scheduler.

Parameters:

onSubscribe - the Consumer that gets called when an Observer subscribes to the current Observable

Returns:

the new Observable instance

Throws:

NullPointerException - if onSubscribe is null

See Also:

ReactiveX operators documentation: Do

doOnTerminate

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Observable<T> doOnTerminate(@NonNull Action onTerminate)

Returns an Observable so that it invokes an action when the current Observable calls onComplete or onError.

This differs from doAfterTerminate in that this happens before the onComplete or onError notification.

Scheduler:

doOnTerminate does not operate by default on a particular Scheduler.

Parameters:

onTerminate - the action to invoke when the current Observable calls onComplete or onError

Returns:

the new Observable instance

Throws:

NullPointerException - if onTerminate is null

See Also:

ReactiveX operators documentation: Do, doAfterTerminate(Action)

elementAt

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Maybe<T> elementAt(long index)

Returns a Maybe that emits the single item at a specified index in a sequence of emissions from the current Observable or completes if the current Observable signals fewer elements than index.

Scheduler:

elementAt does not operate by default on a particular Scheduler.

Parameters:

index - the zero-based index of the item to retrieve

Returns:

the new Maybe instance

Throws:

IndexOutOfBoundsException - if index is negative

See Also:

ReactiveX operators documentation: ElementAt

elementAt

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Single<T> elementAt(long index,
        @NonNull T defaultItem)

Returns a Single that emits the item found at a specified index in a sequence of emissions from the current Observable, or a default item if that index is out of range.

Scheduler:

elementAt does not operate by default on a particular Scheduler.

Parameters:

index - the zero-based index of the item to retrieve

defaultItem - the default item

Returns:

the new Single instance

Throws:

NullPointerException - if defaultItem is null

IndexOutOfBoundsException - if index is negative

See Also:

ReactiveX operators documentation: ElementAt

elementAtOrError

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Single<T> elementAtOrError(long index)

Returns a Single that emits the item found at a specified index in a sequence of emissions from the current Observable or signals a NoSuchElementException if the current Observable signals fewer elements than index.

Scheduler:

elementAtOrError does not operate by default on a particular Scheduler.

Parameters:

index - the zero-based index of the item to retrieve

Returns:

the new Single instance

Throws:

IndexOutOfBoundsException - if index is negative

See Also:

ReactiveX operators documentation: ElementAt

filter

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Observable<T> filter(@NonNull Predicate<? super T> predicate)

Filters items emitted by the current Observable by only emitting those that satisfy a specified Predicate.

Scheduler:

filter does not operate by default on a particular Scheduler.

Parameters:

predicate - a function that evaluates each item emitted by the current Observable, returning true if it passes the filter

Returns:

the new Observable instance

Throws:

NullPointerException - if predicate is null

See Also:

ReactiveX operators documentation: Filter

firstElement

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Maybe<T> firstElement()

Returns a Maybe that emits only the very first item emitted by the current Observable, or completes if the current Observable is empty.

Scheduler:

firstElement does not operate by default on a particular Scheduler.

Returns:

the new Maybe instance

See Also:

ReactiveX operators documentation: First

first

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Single<T> first(@NonNull T defaultItem)

Returns a Single that emits only the very first item emitted by the current Observable, or a default item if the current Observable completes without emitting any items.

Scheduler:

first does not operate by default on a particular Scheduler.

Parameters:

defaultItem - the default item to emit if the current Observable doesn't emit anything

Returns:

the new Single instance

Throws:

NullPointerException - if defaultItem is null

See Also:

ReactiveX operators documentation: First

firstOrError

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Single<T> firstOrError()

Returns a Single that emits only the very first item emitted by the current Observable or signals a NoSuchElementException if the current Observable is empty.

Scheduler:

firstOrError does not operate by default on a particular Scheduler.

Returns:

the new Single instance

See Also:

ReactiveX operators documentation: First

flatMap

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final <R> @NonNull Observable<R> flatMap(@NonNull Function<? super T,? extends ObservableSource<? extends R>> mapper)

Returns an Observable that emits items based on applying a function that you supply to each item emitted by the current Observable, where that function returns an ObservableSource, and then merging those returned ObservableSources and emitting the results of this merger.

Scheduler:

flatMap does not operate by default on a particular Scheduler.

Type Parameters:

R - the value type of the inner ObservableSources and the output type

Parameters:

mapper - a function that, when applied to an item emitted by the current Observable, returns an ObservableSource

Returns:

the new Observable instance

Throws:

NullPointerException - if mapper is null

See Also:

ReactiveX operators documentation: FlatMap

flatMap

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final <R> @NonNull Observable<R> flatMap(@NonNull Function<? super T,? extends ObservableSource<? extends R>> mapper,
        boolean delayErrors)

Returns an Observable that emits items based on applying a function that you supply to each item emitted by the current Observable, where that function returns an ObservableSource, and then merging those returned ObservableSources and emitting the results of this merger.

Scheduler:

flatMap does not operate by default on a particular Scheduler.

Type Parameters:

R - the value type of the inner ObservableSources and the output type

Parameters:

mapper - a function that, when applied to an item emitted by the current Observable, returns an ObservableSource

delayErrors - if true, exceptions from the current Observable and all inner ObservableSources are delayed until all of them terminate if false, the first one signaling an exception will terminate the whole sequence immediately

Returns:

the new Observable instance

Throws:

NullPointerException - if mapper is null

See Also:

ReactiveX operators documentation: FlatMap

flatMap

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final <R> @NonNull Observable<R> flatMap(@NonNull Function<? super T,? extends ObservableSource<? extends R>> mapper,
        boolean delayErrors,
        int maxConcurrency)

Returns an Observable that emits items based on applying a function that you supply to each item emitted by the current Observable, where that function returns an ObservableSource, and then merging those returned ObservableSources and emitting the results of this merger, while limiting the maximum number of concurrent subscriptions to these ObservableSources.

Scheduler:

flatMap does not operate by default on a particular Scheduler.

Type Parameters:

R - the value type of the inner ObservableSources and the output type

Parameters:

mapper - a function that, when applied to an item emitted by the current Observable, returns an ObservableSource

maxConcurrency - the maximum number of ObservableSources that may be subscribed to concurrently

delayErrors - if true, exceptions from the current Observable and all inner ObservableSources are delayed until all of them terminate if false, the first one signaling an exception will terminate the whole sequence immediately

Returns:

the new Observable instance

Throws:

NullPointerException - if mapper is null

IllegalArgumentException - if maxConcurrency is non-positive

Since:

2.0

See Also:

ReactiveX operators documentation: FlatMap

flatMap

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final <R> @NonNull Observable<R> flatMap(@NonNull Function<? super T,? extends ObservableSource<? extends R>> mapper,
        boolean delayErrors,
        int maxConcurrency,
        int bufferSize)

Returns an Observable that emits items based on applying a function that you supply to each item emitted by the current Observable, where that function returns an ObservableSource, and then merging those returned ObservableSources and emitting the results of this merger, while limiting the maximum number of concurrent subscriptions to these ObservableSources.

Scheduler:

flatMap does not operate by default on a particular Scheduler.

Type Parameters:

R - the value type of the inner ObservableSources and the output type

Parameters:

mapper - a function that, when applied to an item emitted by the current Observable, returns an ObservableSource

maxConcurrency - the maximum number of ObservableSources that may be subscribed to concurrently

delayErrors - if true, exceptions from the current Observable and all inner ObservableSources are delayed until all of them terminate if false, the first one signaling an exception will terminate the whole sequence immediately

bufferSize - the number of elements expected from each inner ObservableSource to be buffered

Returns:

the new Observable instance

Throws:

NullPointerException - if mapper is null

IllegalArgumentException - if maxConcurrency or bufferSize is non-positive

Since:

2.0

See Also:

ReactiveX operators documentation: FlatMap

flatMap

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final <R> @NonNull Observable<R> flatMap(@NonNull Function<? super T,? extends ObservableSource<? extends R>> onNextMapper,
        @NonNull Function<? super Throwable,? extends ObservableSource<? extends R>> onErrorMapper,
        @NonNull Supplier<? extends ObservableSource<? extends R>> onCompleteSupplier)

Returns an Observable that applies a function to each item emitted or notification raised by the current Observable and then flattens the ObservableSources returned from these functions and emits the resulting items.

Scheduler:

flatMap does not operate by default on a particular Scheduler.

Type Parameters:

R - the result type

Parameters:

onNextMapper - a function that returns an ObservableSource to merge for each item emitted by the current Observable

onErrorMapper - a function that returns an ObservableSource to merge for an onError notification from the current Observable

onCompleteSupplier - a function that returns an ObservableSource to merge for an onComplete notification from the current Observable

Returns:

the new Observable instance

Throws:

NullPointerException - if onNextMapper or onErrorMapper or onCompleteSupplier is null

See Also:

ReactiveX operators documentation: FlatMap

flatMap

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final <R> @NonNull Observable<R> flatMap(@NonNull Function<? super T,? extends ObservableSource<? extends R>> onNextMapper,
        @NonNull Function<Throwable,? extends ObservableSource<? extends R>> onErrorMapper,
        @NonNull Supplier<? extends ObservableSource<? extends R>> onCompleteSupplier,
        int maxConcurrency)

Returns an Observable that applies a function to each item emitted or notification raised by the current Observable and then flattens the ObservableSources returned from these functions and emits the resulting items, while limiting the maximum number of concurrent subscriptions to these ObservableSources.

Scheduler:

flatMap does not operate by default on a particular Scheduler.

Type Parameters:

R - the result type

Parameters:

onNextMapper - a function that returns an ObservableSource to merge for each item emitted by the current Observable

onErrorMapper - a function that returns an ObservableSource to merge for an onError notification from the current Observable

onCompleteSupplier - a function that returns an ObservableSource to merge for an onComplete notification from the current Observable

maxConcurrency - the maximum number of ObservableSources that may be subscribed to concurrently

Returns:

the new Observable instance

Throws:

NullPointerException - if onNextMapper or onErrorMapper or onCompleteSupplier is null

IllegalArgumentException - if maxConcurrency is non-positive

Since:

2.0

See Also:

ReactiveX operators documentation: FlatMap

flatMap

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final <R> @NonNull Observable<R> flatMap(@NonNull Function<? super T,? extends ObservableSource<? extends R>> mapper,
        int maxConcurrency)

Returns an Observable that emits items based on applying a function that you supply to each item emitted by the current Observable, where that function returns an ObservableSource, and then merging those returned ObservableSources and emitting the results of this merger, while limiting the maximum number of concurrent subscriptions to these ObservableSources.

Scheduler:

flatMap does not operate by default on a particular Scheduler.

Type Parameters:

R - the value type of the inner ObservableSources and the output type

Parameters:

mapper - a function that, when applied to an item emitted by the current Observable, returns an ObservableSource

maxConcurrency - the maximum number of ObservableSources that may be subscribed to concurrently

Returns:

the new Observable instance

Throws:

NullPointerException - if mapper is null

IllegalArgumentException - if maxConcurrency is non-positive

Since:

2.0

See Also:

ReactiveX operators documentation: FlatMap

flatMap

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final <U,R> @NonNull Observable<R> flatMap(@NonNull Function<? super T,? extends ObservableSource<? extends U>> mapper,
        @NonNull BiFunction<? super T,? super U,? extends R> combiner)

Returns an Observable that emits the results of a specified function to the pair of values emitted by the current Observable and the mapped inner ObservableSource.

Scheduler:

flatMap does not operate by default on a particular Scheduler.

Type Parameters:

U - the type of items emitted by the collection ObservableSource

R - the type of items emitted by the resulting Observable

Parameters:

mapper - a function that returns an ObservableSource for each item emitted by the current Observable

combiner - a function that combines one item emitted by each of the source and collection ObservableSources and returns an item to be emitted by the resulting Observable

Returns:

the new Observable instance

Throws:

NullPointerException - if mapper or combiner is null

See Also:

ReactiveX operators documentation: FlatMap

flatMap

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final <U,R> @NonNull Observable<R> flatMap(@NonNull Function<? super T,? extends ObservableSource<? extends U>> mapper,
        @NonNull BiFunction<? super T,? super U,? extends R> combiner,
        boolean delayErrors)

Returns an Observable that emits the results of a specified function to the pair of values emitted by the current Observable and the mapped inner ObservableSource.

Scheduler:

flatMap does not operate by default on a particular Scheduler.

Type Parameters:

U - the type of items emitted by the collection ObservableSource

R - the type of items emitted by the resulting Observable

Parameters:

mapper - a function that returns an ObservableSource for each item emitted by the current Observable

combiner - a function that combines one item emitted by each of the source and collection ObservableSources and returns an item to be emitted by the resulting Observable

delayErrors - if true, exceptions from the current Observable and all inner ObservableSources are delayed until all of them terminate if false, the first one signaling an exception will terminate the whole sequence immediately

Returns:

the new Observable instance

Throws:

NullPointerException - if mapper or combiner is null

See Also:

ReactiveX operators documentation: FlatMap

flatMap

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final <U,R> @NonNull Observable<R> flatMap(@NonNull Function<? super T,? extends ObservableSource<? extends U>> mapper,
        @NonNull BiFunction<? super T,? super U,? extends R> combiner,
        boolean delayErrors,
        int maxConcurrency)

Returns an Observable that emits the results of a specified function to the pair of values emitted by the current Observable and the mapped inner ObservableSource, while limiting the maximum number of concurrent subscriptions to these ObservableSources.

Scheduler:

flatMap does not operate by default on a particular Scheduler.

Type Parameters:

U - the type of items emitted by the collection ObservableSource

R - the type of items emitted by the resulting Observable

Parameters:

mapper - a function that returns an ObservableSource for each item emitted by the current Observable

combiner - a function that combines one item emitted by each of the source and collection ObservableSources and returns an item to be emitted by the resulting Observable

maxConcurrency - the maximum number of ObservableSources that may be subscribed to concurrently

delayErrors - if true, exceptions from the current Observable and all inner ObservableSources are delayed until all of them terminate if false, the first one signaling an exception will terminate the whole sequence immediately

Returns:

the new Observable instance

Throws:

NullPointerException - if mapper or combiner is null

IllegalArgumentException - if maxConcurrency is non-positive

Since:

2.0

See Also:

ReactiveX operators documentation: FlatMap

flatMap

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final <U,R> @NonNull Observable<R> flatMap(@NonNull Function<? super T,? extends ObservableSource<? extends U>> mapper,
        @NonNull BiFunction<? super T,? super U,? extends R> combiner,
        boolean delayErrors,
        int maxConcurrency,
        int bufferSize)

Returns an Observable that emits the results of a specified function to the pair of values emitted by the current Observable and the mapped inner ObservableSource, while limiting the maximum number of concurrent subscriptions to these ObservableSources.

Scheduler:

flatMap does not operate by default on a particular Scheduler.

Type Parameters:

U - the type of items emitted by the collection ObservableSource

R - the type of items emitted by the resulting Observable

Parameters:

mapper - a function that returns an ObservableSource for each item emitted by the current Observable

combiner - a function that combines one item emitted by each of the source and collection ObservableSources and returns an item to be emitted by the resulting Observable

maxConcurrency - the maximum number of ObservableSources that may be subscribed to concurrently

delayErrors - if true, exceptions from the current Observable and all inner ObservableSources are delayed until all of them terminate if false, the first one signaling an exception will terminate the whole sequence immediately

bufferSize - the number of elements expected from the inner ObservableSource to be buffered

Returns:

the new Observable instance

Throws:

NullPointerException - if mapper or combiner is null

IllegalArgumentException - if maxConcurrency or bufferSize is non-positive

Since:

2.0

See Also:

ReactiveX operators documentation: FlatMap

flatMap

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final <U,R> @NonNull Observable<R> flatMap(@NonNull Function<? super T,? extends ObservableSource<? extends U>> mapper,
        @NonNull BiFunction<? super T,? super U,? extends R> combiner,
        int maxConcurrency)

Returns an Observable that emits the results of a specified function to the pair of values emitted by the current Observable and the mapped inner ObservableSource, while limiting the maximum number of concurrent subscriptions to these ObservableSources.

Scheduler:

flatMap does not operate by default on a particular Scheduler.

Type Parameters:

U - the type of items emitted by the collection ObservableSource

R - the type of items emitted by the resulting Observable

Parameters:

mapper - a function that returns an ObservableSource for each item emitted by the current Observable

combiner - a function that combines one item emitted by each of the source and collection ObservableSources and returns an item to be emitted by the resulting Observable

maxConcurrency - the maximum number of ObservableSources that may be subscribed to concurrently

Returns:

the new Observable instance

Throws:

NullPointerException - if mapper or combiner is null

IllegalArgumentException - if maxConcurrency is non-positive

Since:

2.0

See Also:

ReactiveX operators documentation: FlatMap

flatMapCompletable

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Completable flatMapCompletable(@NonNull Function<? super T,? extends CompletableSource> mapper)

Maps each element of the current Observable into CompletableSources, subscribes to them and waits until the upstream and all CompletableSources complete.

Scheduler:

flatMapCompletable does not operate by default on a particular Scheduler.

Parameters:

mapper - the function that received each source value and transforms them into CompletableSources.

Returns:

the new Completable instance

Throws:

NullPointerException - if mapper is null

flatMapCompletable

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Completable flatMapCompletable(@NonNull Function<? super T,? extends CompletableSource> mapper,
        boolean delayErrors)

Maps each element of the current Observable into CompletableSources, subscribes to them and waits until the upstream and all CompletableSources complete, optionally delaying all errors.

Scheduler:

flatMapCompletable does not operate by default on a particular Scheduler.

Parameters:

mapper - the function that received each source value and transforms them into CompletableSources.

delayErrors - if true, errors from the upstream and inner CompletableSources are delayed until all of them terminate.

Returns:

the new Completable instance

Throws:

NullPointerException - if mapper is null

flatMapIterable

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final <U> @NonNull Observable<U> flatMapIterable(@NonNull Function<? super T,? extends Iterable<? extends U>> mapper)

Merges Iterables generated by a mapper Function for each individual item emitted by the current Observable into a single Observable sequence.

Scheduler:

flatMapIterable does not operate by default on a particular Scheduler.

Type Parameters:

U - the output type and the element type of the Iterables

Parameters:

mapper - a function that returns an Iterable sequence of values for when given an item emitted by the current Observable

Returns:

the new Observable instance

Throws:

NullPointerException - if mapper is null

See Also:

ReactiveX operators documentation: FlatMap

flatMapIterable

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final <U,V> @NonNull Observable<V> flatMapIterable(@NonNull Function<? super T,? extends Iterable<? extends U>> mapper,
        @NonNull BiFunction<? super T,? super U,? extends V> combiner)

Merges Iterables generated by a mapper Function for each individual item emitted by the current Observable into a single Observable 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.

Scheduler:

flatMapIterable does not operate by default on a particular Scheduler.

Type Parameters:

U - the element type of the Iterables

V - the output type as determined by the resultSelector function

Parameters:

mapper - a function that returns an Iterable sequence of values for each item emitted by the current Observable

combiner - a function that returns an item based on the item emitted by the current Observable and the next item of the Iterable returned for that original item by the mapper

Returns:

the new Observable instance

Throws:

NullPointerException - if mapper or combiner is null

See Also:

ReactiveX operators documentation: FlatMap

flatMapMaybe

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final <R> @NonNull Observable<R> flatMapMaybe(@NonNull Function<? super T,? extends MaybeSource<? extends R>> mapper)

Maps each element of the current Observable into MaybeSources, subscribes to all of them and merges their onSuccess values, in no particular order, into a single Observable sequence.

Scheduler:

flatMapMaybe does not operate by default on a particular Scheduler.

Type Parameters:

R - the result value type

Parameters:

mapper - the function that received each source value and transforms them into MaybeSources.

Returns:

the new Observable instance

Throws:

NullPointerException - if mapper is null

flatMapMaybe

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final <R> @NonNull Observable<R> flatMapMaybe(@NonNull Function<? super T,? extends MaybeSource<? extends R>> mapper,
        boolean delayErrors)

Maps each element of the current Observable into MaybeSources, subscribes to them and merges their onSuccess values, in no particular order, into a single Observable sequence, optionally delaying all errors.

Scheduler:

flatMapMaybe does not operate by default on a particular Scheduler.

Type Parameters:

R - the result value type

Parameters:

mapper - the function that received each source value and transforms them into MaybeSources.

delayErrors - if true, errors from the upstream and inner MaybeSources are delayed until all of them terminate.

Returns:

the new Observable instance

Throws:

NullPointerException - if mapper is null

flatMapSingle

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final <R> @NonNull Observable<R> flatMapSingle(@NonNull Function<? super T,? extends SingleSource<? extends R>> mapper)

Maps each element of the current Observable into SingleSources, subscribes to all of them and merges their onSuccess values, in no particular order, into a single Observable sequence.

Scheduler:

flatMapSingle does not operate by default on a particular Scheduler.

Type Parameters:

R - the result value type

Parameters:

mapper - the function that received each source value and transforms them into SingleSources.

Returns:

the new Observable instance

Throws:

NullPointerException - if mapper is null

flatMapSingle

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final <R> @NonNull Observable<R> flatMapSingle(@NonNull Function<? super T,? extends SingleSource<? extends R>> mapper,
        boolean delayErrors)

Maps each element of the current Observable into SingleSources, subscribes to them and merges their onSuccess values, in no particular order, into a single Observable sequence, optionally delaying all errors.

Scheduler:

flatMapSingle does not operate by default on a particular Scheduler.

Type Parameters:

R - the result value type

Parameters:

mapper - the function that received each source value and transforms them into SingleSources.

delayErrors - if true, errors from the upstream and inner SingleSources are delayed until each of them terminates.

Returns:

the new Observable instance

Throws:

NullPointerException - if mapper is null

forEach

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Disposable forEach(@NonNull Consumer<? super T> onNext)

Subscribes to the ObservableSource and calls a Consumer for each item of the current Observable on its emission thread.

Alias to subscribe(Consumer)

Scheduler:

forEach does not operate by default on a particular Scheduler.

Parameters:

onNext - the Consumer to execute for each item.

Returns:

a Disposable that allows disposing the sequence if the current Observable runs asynchronously

Throws:

NullPointerException - if onNext is null

See Also:

ReactiveX operators documentation: Subscribe

forEachWhile

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Disposable forEachWhile(@NonNull Predicate<? super T> onNext)

Subscribes to the ObservableSource and calls a Predicate for each item of the current Observable, on its emission thread, until the predicate returns false.

If the Observable emits an error, it is wrapped into an OnErrorNotImplementedException and routed to the RxJavaPlugins.onError(Throwable) handler.

Scheduler:

forEachWhile does not operate by default on a particular Scheduler.

Parameters:

onNext - the Predicate to execute for each item.

Returns:

a Disposable that allows disposing the sequence if the current Observable runs asynchronously

Throws:

NullPointerException - if onNext is null

See Also:

ReactiveX operators documentation: Subscribe

forEachWhile

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Disposable forEachWhile(@NonNull Predicate<? super T> onNext,
        @NonNull Consumer<? super Throwable> onError)

Subscribes to the ObservableSource and calls a Predicate for each item or a Consumer with the error of the current Observable, on their original emission threads, until the predicate returns false.

Scheduler:

forEachWhile does not operate by default on a particular Scheduler.

Parameters:

onNext - the Predicate to execute for each item.

onError - the Consumer to execute when an error is emitted.

Returns:

a Disposable that allows disposing the sequence if the current Observable runs asynchronously

Throws:

NullPointerException - if onNext or onError is null

See Also:

ReactiveX operators documentation: Subscribe

forEachWhile

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Disposable forEachWhile(@NonNull Predicate<? super T> onNext,
        @NonNull Consumer<? super Throwable> onError,
        @NonNull Action onComplete)

Subscribes to the ObservableSource and calls a Predicate for each item, a Consumer with the error or an Action upon completion of the current Observable, on their original emission threads, until the predicate returns false.

Scheduler:

forEachWhile does not operate by default on a particular Scheduler.

Parameters:

onNext - the Predicate to execute for each item.

onError - the Consumer to execute when an error is emitted.

onComplete - the Action to execute when completion is signaled.

Returns:

a Disposable that allows disposing the sequence if the current Observable runs asynchronously

Throws:

NullPointerException - if onNext or onError or onComplete is null

See Also:

ReactiveX operators documentation: Subscribe

groupBy

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final <K> @NonNull Observable<GroupedObservable<K,T>> groupBy(@NonNull Function<? super T,? extends K> keySelector)

Groups the items emitted by the current Observable according to a specified criterion, and emits these grouped items as GroupedObservables.

Each emitted GroupedObservable allows only a single Observer to subscribe to it during its lifetime and if this Observer calls dispose() before the source terminates, the next emission by the source having the same key will trigger a new GroupedObservable emission.

Note: A GroupedObservable will cache the items it is to emit until such time as it is subscribed to. For this reason, in order to avoid memory leaks, you should not simply ignore those GroupedObservables that do not concern you. Instead, you can signal to them that they may discard their buffers by applying an operator like ignoreElements() to them.

Note also that ignoring groups or subscribing later (i.e., on another thread) will result in so-called group abandonment where a group will only contain one element and the group will be re-created over and over as new upstream items trigger a new group. The behavior is a trade-off between no-dataloss, upstream cancellation and excessive group creation.

Scheduler:

groupBy does not operate by default on a particular Scheduler.

Type Parameters:

K - the key type

Parameters:

keySelector - a function that extracts the key for each item

Returns:

the new Observable instance

Throws:

NullPointerException - if keySelector is null

See Also:

ReactiveX operators documentation: GroupBy

groupBy

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final <K> @NonNull Observable<GroupedObservable<K,T>> groupBy(@NonNull Function<? super T,? extends K> keySelector,
        boolean delayError)

Groups the items emitted by the current Observable according to a specified criterion, and emits these grouped items as GroupedObservables.

Each emitted GroupedObservable allows only a single Observer to subscribe to it during its lifetime and if this Observer calls dispose() before the source terminates, the next emission by the source having the same key will trigger a new GroupedObservable emission.

Note: A GroupedObservable will cache the items it is to emit until such time as it is subscribed to. For this reason, in order to avoid memory leaks, you should not simply ignore those GroupedObservables that do not concern you. Instead, you can signal to them that they may discard their buffers by applying an operator like ignoreElements() to them.

Note also that ignoring groups or subscribing later (i.e., on another thread) will result in so-called group abandonment where a group will only contain one element and the group will be re-created over and over as new upstream items trigger a new group. The behavior is a trade-off between no-dataloss, upstream cancellation and excessive group creation.

Scheduler:

groupBy does not operate by default on a particular Scheduler.

Type Parameters:

K - the key type

Parameters:

keySelector - a function that extracts the key for each item

delayError - if true, the exception from the current Observable is delayed in each group until that specific group emitted the normal values; if false, the exception bypasses values in the groups and is reported immediately.

Returns:

the new Observable instance

Throws:

NullPointerException - if keySelector is null

See Also:

ReactiveX operators documentation: GroupBy

groupBy

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final <K,V> @NonNull Observable<GroupedObservable<K,V>> groupBy(@NonNull Function<? super T,? extends K> keySelector,
        Function<? super T,? extends V> valueSelector)

Groups the items emitted by the current Observable according to a specified criterion, and emits these grouped items as GroupedObservables.

Each emitted GroupedObservable allows only a single Observer to subscribe to it during its lifetime and if this Observer calls dispose() before the source terminates, the next emission by the source having the same key will trigger a new GroupedObservable emission.

Note: A GroupedObservable will cache the items it is to emit until such time as it is subscribed to. For this reason, in order to avoid memory leaks, you should not simply ignore those GroupedObservables that do not concern you. Instead, you can signal to them that they may discard their buffers by applying an operator like ignoreElements() to them.

Note also that ignoring groups or subscribing later (i.e., on another thread) will result in so-called group abandonment where a group will only contain one element and the group will be re-created over and over as new upstream items trigger a new group. The behavior is a trade-off between no-dataloss, upstream cancellation and excessive group creation.

Scheduler:

groupBy does not operate by default on a particular Scheduler.

Type Parameters:

K - the key type

V - the element type

Parameters:

keySelector - a function that extracts the key for each item

valueSelector - a function that extracts the return element for each item

Returns:

the new Observable instance

Throws:

NullPointerException - if keySelector or valueSelector is null

See Also:

ReactiveX operators documentation: GroupBy

groupBy

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final <K,V> @NonNull Observable<GroupedObservable<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 Observable according to a specified criterion, and emits these grouped items as GroupedObservables.

Each emitted GroupedObservable allows only a single Observer to subscribe to it during its lifetime and if this Observer calls dispose() before the source terminates, the next emission by the source having the same key will trigger a new GroupedObservable emission.

Note: A GroupedObservable will cache the items it is to emit until such time as it is subscribed to. For this reason, in order to avoid memory leaks, you should not simply ignore those GroupedObservables that do not concern you. Instead, you can signal to them that they may discard their buffers by applying an operator like ignoreElements() to them.

Note also that ignoring groups or subscribing later (i.e., on another thread) will result in so-called group abandonment where a group will only contain one element and the group will be re-created over and over as new upstream items trigger a new group. The behavior is a trade-off between no-dataloss, upstream cancellation and excessive group creation.

Scheduler:

groupBy does not operate by default on a particular Scheduler.

Type Parameters:

K - the key type

V - the element type

Parameters:

keySelector - a function that extracts the key for each item

valueSelector - a function that extracts the return element for each item

delayError - if true, the exception from the current Observable is delayed in each group until that specific group emitted the normal values; if false, the exception bypasses values in the groups and is reported immediately.

Returns:

the new Observable instance

Throws:

NullPointerException - if keySelector or valueSelector is null

See Also:

ReactiveX operators documentation: GroupBy

groupBy

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final <K,V> @NonNull Observable<GroupedObservable<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 Observable according to a specified criterion, and emits these grouped items as GroupedObservables.

Each emitted GroupedObservable allows only a single Observer to subscribe to it during its lifetime and if this Observer calls dispose() before the source terminates, the next emission by the source having the same key will trigger a new GroupedObservable emission.

Note: A GroupedObservable will cache the items it is to emit until such time as it is subscribed to. For this reason, in order to avoid memory leaks, you should not simply ignore those GroupedObservables that do not concern you. Instead, you can signal to them that they may discard their buffers by applying an operator like ignoreElements() to them.

Note also that ignoring groups or subscribing later (i.e., on another thread) will result in so-called group abandonment where a group will only contain one element and the group will be re-created over and over as new upstream items trigger a new group. The behavior is a trade-off between no-dataloss, upstream cancellation and excessive group creation.

Scheduler:

groupBy does not operate by default on a particular Scheduler.

Type Parameters:

K - the key type

V - the element type

Parameters:

keySelector - a function that extracts the key for each item

valueSelector - a function that extracts the return element for each item

delayError - if true, the exception from the current Observable is delayed in each group until that specific group emitted the normal values; if false, the exception bypasses values in the groups and is reported immediately.

bufferSize - the hint for how many GroupedObservables and element in each GroupedObservable should be buffered

Returns:

the new Observable instance

Throws:

NullPointerException - if keySelector or valueSelector is null

IllegalArgumentException - if bufferSize is non-positive

See Also:

ReactiveX operators documentation: GroupBy

groupJoin

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final <TRight,TLeftEnd,TRightEnd,R> @NonNull Observable<R> groupJoin(@NonNull ObservableSource<? extends TRight> other,
        @NonNull Function<? super T,? extends ObservableSource<TLeftEnd>> leftEnd,
        @NonNull Function<? super TRight,? extends ObservableSource<TRightEnd>> rightEnd,
        @NonNull BiFunction<? super T,? super Observable<TRight>,? extends R> resultSelector)

Returns an Observable that correlates two ObservableSources when they overlap in time and groups the results.

There are no guarantees in what order the items get combined when multiple items from one or both source ObservableSources overlap.

Scheduler:

groupJoin does not operate by default on a particular Scheduler.

Type Parameters:

TRight - the value type of the right ObservableSource source

TLeftEnd - the element type of the left duration ObservableSources

TRightEnd - the element type of the right duration ObservableSources

R - the result type

Parameters:

other - the other ObservableSource to correlate items from the current Observable with

leftEnd - a function that returns an ObservableSource whose emissions indicate the duration of the values of the current Observable

rightEnd - a function that returns an ObservableSource whose emissions indicate the duration of the values of the right ObservableSource

resultSelector - a function that takes an item emitted by each ObservableSource and returns the value to be emitted by the resulting Observable

Returns:

the new Observable instance

Throws:

NullPointerException - if other, leftEnd, rightEnd or resultSelector is null

See Also:

ReactiveX operators documentation: Join

hide

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Observable<T> hide()

Hides the identity of the current Observable and its Disposable.

Allows hiding extra features such as Subject's Observer methods or preventing certain identity-based optimizations (fusion).

Scheduler:

hide does not operate by default on a particular Scheduler.

Returns:

the new Observable instance

Since:

2.0

ignoreElements

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Completable ignoreElements()

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

Scheduler:

ignoreElements does not operate by default on a particular Scheduler.

Returns:

the new Completable instance

See Also:

ReactiveX operators documentation: IgnoreElements

isEmpty

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Single<Boolean> isEmpty()

Returns a Single that emits true if the current Observable is empty, otherwise false.

In Rx.Net this is negated as the any Observer but we renamed this in RxJava to better match Java naming idioms.

Scheduler:

isEmpty does not operate by default on a particular Scheduler.

Returns:

the new Single instance

See Also:

ReactiveX operators documentation: Contains

join

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final <TRight,TLeftEnd,TRightEnd,R> @NonNull Observable<R> join(@NonNull ObservableSource<? extends TRight> other,
        @NonNull Function<? super T,? extends ObservableSource<TLeftEnd>> leftEnd,
        @NonNull Function<? super TRight,? extends ObservableSource<TRightEnd>> rightEnd,
        @NonNull BiFunction<? super T,? super TRight,? extends R> resultSelector)

Correlates the items emitted by two ObservableSources based on overlapping durations.

There are no guarantees in what order the items get combined when multiple items from one or both source ObservableSources overlap.

Scheduler:

join does not operate by default on a particular Scheduler.

Type Parameters:

TRight - the value type of the right ObservableSource source

TLeftEnd - the element type of the left duration ObservableSources

TRightEnd - the element type of the right duration ObservableSources

R - the result type

Parameters:

other - the second ObservableSource to join items from

leftEnd - a function to select a duration for each item emitted by the current Observable, used to determine overlap

rightEnd - a function to select a duration for each item emitted by the right ObservableSource, used to determine overlap

resultSelector - a function that computes an item to be emitted by the resulting Observable for any two overlapping items emitted by the two ObservableSources

Returns:

the new Observable instance

Throws:

NullPointerException - if other, leftEnd, rightEnd or resultSelector is null

See Also:

ReactiveX operators documentation: Join

lastElement

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Maybe<T> lastElement()

Returns a Maybe that emits the last item emitted by the current Observable or completes if the current Observable is empty.

Scheduler:

lastElement does not operate by default on a particular Scheduler.

Returns:

the new Maybe instance

See Also:

ReactiveX operators documentation: Last

last

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Single<T> last(@NonNull T defaultItem)

Returns a Single that emits only the last item emitted by the current Observable, or a default item if the current Observable completes without emitting any items.

Scheduler:

last does not operate by default on a particular Scheduler.

Parameters:

defaultItem - the default item to emit if the current Observable is empty

Returns:

the new Single instance

Throws:

NullPointerException - if defaultItem is null

See Also:

ReactiveX operators documentation: Last

lastOrError

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Single<T> lastOrError()

Returns a Single that emits only the last item emitted by the current Observable or signals a NoSuchElementException if the current Observable is empty.

Scheduler:

lastOrError does not operate by default on a particular Scheduler.

Returns:

the new Single instance

See Also:

ReactiveX operators documentation: Last

lift

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final <R> @NonNull Observable<R> lift(@NonNull ObservableOperator<? extends R,? super T> lifter)

This method requires advanced knowledge about building operators, please consider other standard composition methods first; Returns an Observable which, when subscribed to, invokes the apply(Observer) method of the provided ObservableOperator for each individual downstream Observer and allows the insertion of a custom operator by accessing the downstream's Observer during this subscription phase and providing a new Observer, containing the custom operator's intended business logic, that will be used in the subscription process going further upstream.

Generally, such a new Observer will wrap the downstream's Observer and forwards the onNext, onError and onComplete events from the upstream directly or according to the emission pattern the custom operator's business logic requires. In addition, such operator can intercept the flow control calls of dispose and isDisposed that would have traveled upstream and perform additional actions depending on the same business logic requirements.

Example:

 // Step 1: Create the consumer type that will be returned by the ObservableOperator.apply():

 public final class CustomObserver<T> implements Observer<T>, Disposable {

     // The downstream's Observer that will receive the onXXX events
     final Observer<? super String> downstream;

     // The connection to the upstream source that will call this class' onXXX methods
     Disposable upstream;

     // The constructor takes the downstream subscriber and usually any other parameters
     public CustomObserver(Observer<? super String> downstream) {
         this.downstream = downstream;
     }

     // In the subscription phase, the upstream sends a Disposable to this class
     // and subsequently this class has to send a Disposable to the downstream.
     // Note that relaying the upstream's Disposable directly is not allowed in RxJava
     @Override
     public void onSubscribe(Disposable d) {
         if (upstream != null) {
             d.dispose();
         } else {
             upstream = d;
             downstream.onSubscribe(this);
         }
     }

     // The upstream calls this with the next item and the implementation's
     // responsibility is to emit an item to the downstream based on the intended
     // business logic, or if it can't do so for the particular item,
        // request more from the upstream
     @Override
     public void onNext(T item) {
         String str = item.toString();
         if (str.length() < 2) {
             downstream.onNext(str);
         }
         // Observable doesn't support backpressure, therefore, there is no
         // need or opportunity to call upstream.request(1) if an item
         // is not produced to the downstream
     }

     // Some operators may handle the upstream's error while others
     // could just forward it to the downstream.
     @Override
     public void onError(Throwable throwable) {
         downstream.onError(throwable);
     }

     // When the upstream completes, usually the downstream should complete as well.
     @Override
     public void onComplete() {
         downstream.onComplete();
     }

     // Some operators may use their own resources which should be cleaned up if
     // the downstream disposes the flow before it completed. Operators without
     // resources can simply forward the dispose to the upstream.
     // In some cases, a disposed flag may be set by this method so that other parts
     // of this class may detect the dispose and stop sending events
     // to the downstream.
     @Override
     public void dispose() {
         upstream.dispose();
     }

     // Some operators may simply forward the call to the upstream while others
     // can return the disposed flag set in dispose().
     @Override
     public boolean isDisposed() {
         return upstream.isDisposed();
     }
 }

 // Step 2: Create a class that implements the ObservableOperator interface and
 //         returns the custom consumer type from above in its apply() method.
 //         Such class may define additional parameters to be submitted to
 //         the custom consumer type.

 final class CustomOperator<T> implements ObservableOperator<String, T> {
     @Override
     public Observer<T> apply(Observer<? super String> downstream) {
         return new CustomObserver<T>(downstream);
     }
 }

 // Step 3: Apply the custom operator via lift() in a flow by creating an instance of it
 //         or reusing an existing one.

 Observable.range(5, 10)
 .lift(new CustomOperator<Integer>())
 .test()
 .assertResult("5", "6", "7", "8", "9");
 

Creating custom operators can be complicated and it is recommended one consults the RxJava wiki: Writing operators page about the tools, requirements, rules, considerations and pitfalls of implementing them.

Note that implementing custom operators via this lift() method adds slightly more overhead by requiring an additional allocation and indirection per assembled flows. Instead, extending the abstract Observable class and creating an ObservableTransformer with it is recommended.

Note also that it is not possible to stop the subscription phase in lift() as the apply() method requires a non-null Observer instance to be returned, which is then unconditionally subscribed to the current Observable. For example, if the operator decided there is no reason to subscribe to the upstream source because of some optimization possibility or a failure to prepare the operator, it still has to return an Observer that should immediately dispose the upstream's Disposable in its onSubscribe method. Again, using an ObservableTransformer and extending the Observable is a better option as subscribeActual(io.reactivex.rxjava3.core.Observer<? super T>) can decide to not subscribe to its upstream after all.

Scheduler:

lift does not operate by default on a particular Scheduler, however, the ObservableOperator may use a Scheduler to support its own asynchronous behavior.

Type Parameters:

R - the output value type

Parameters:

lifter - the ObservableOperator that receives the downstream's Observer and should return an Observer with custom behavior to be used as the consumer for the current Observable.

Returns:

the new Observable instance

Throws:

NullPointerException - if lifter is null

See Also:

RxJava wiki: Writing operators, compose(ObservableTransformer)

map

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final <R> @NonNull Observable<R> map(@NonNull Function<? super T,? extends R> mapper)

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

Scheduler:

map does not operate by default on a particular Scheduler.

Type Parameters:

R - the output type

Parameters:

mapper - a function to apply to each item emitted by the current Observable

Returns:

the new Observable instance

Throws:

NullPointerException - if mapper is null

See Also:

ReactiveX operators documentation: Map

materialize

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Observable<Notification<T>> materialize()

Returns an Observable that represents all of the emissions and notifications from the current Observable into emissions marked with their original types within Notification objects.

Scheduler:

materialize does not operate by default on a particular Scheduler.

Returns:

the new Observable instance

See Also:

ReactiveX operators documentation: Materialize, dematerialize(Function)

mergeWith

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Observable<T> mergeWith(@NonNull ObservableSource<? extends T> other)

Flattens the current Observable and another ObservableSource into a single Observable sequence, without any transformation.

You can combine items emitted by multiple ObservableSources so that they appear as a single ObservableSource, by using the mergeWith method.

Scheduler:

mergeWith does not operate by default on a particular Scheduler.

Parameters:

other - an ObservableSource to be merged

Returns:

the new Observable instance

Throws:

NullPointerException - if other is null

See Also:

ReactiveX operators documentation: Merge

mergeWith

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Observable<T> mergeWith(@NonNull SingleSource<? extends T> other)

Merges the sequence of items of the current Observable with the success value of the other SingleSource.

The success value of the other SingleSource can get interleaved at any point of the current Observable sequence.

Scheduler:

mergeWith does not operate by default on a particular Scheduler.

History: 2.1.10 - experimental

Parameters:

other - the SingleSource whose success value to merge with

Returns:

the new Observable instance

Throws:

NullPointerException - if other is null

Since:

2.2

mergeWith

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Observable<T> mergeWith(@NonNull MaybeSource<? extends T> other)

Merges the sequence of items of the current Observable with the success value of the other MaybeSource or waits both to complete normally if the MaybeSource is empty.

The success value of the other MaybeSource can get interleaved at any point of the current Observable sequence.

Scheduler:

mergeWith does not operate by default on a particular Scheduler.

History: 2.1.10 - experimental

Parameters:

other - the MaybeSource which provides a success value to merge with or completes

Returns:

the new Observable instance

Throws:

NullPointerException - if other is null

Since:

2.2

mergeWith

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Observable<T> mergeWith(@NonNull CompletableSource other)

Relays the items of the current Observable and completes only when the other CompletableSource completes as well.

Scheduler:

mergeWith does not operate by default on a particular Scheduler.

History: 2.1.10 - experimental

Parameters:

other - the CompletableSource to await for completion

Returns:

the new Observable instance

Throws:

NullPointerException - if other is null

Since:

2.2

observeOn

@CheckReturnValue
 @SchedulerSupport(value="custom")
 @NonNull
public final @NonNull Observable<T> observeOn(@NonNull Scheduler scheduler)

Returns an Observable to perform the current Observable's emissions and notifications on a specified Scheduler, asynchronously with an unbounded buffer with Flowable.bufferSize() "island size".

Note that onError notifications will cut ahead of onNext notifications on the emission thread if Scheduler is truly asynchronous. If strict event ordering is required, consider using the observeOn(Scheduler, boolean) overload.

This operator keeps emitting as many signals as it can on the given Scheduler's worker thread, which may result in a longer than expected occupation of this thread. In other terms, it does not allow per-signal fairness in case the worker runs on a shared underlying thread. If such fairness and signal/work interleaving is preferred, use the delay operator with zero time instead.

Scheduler:

You specify which Scheduler this operator will use.

"Island size" indicates how large chunks the unbounded buffer allocates to store the excess elements waiting to be consumed on the other side of the asynchronous boundary.

Parameters:

scheduler - the Scheduler to notify Observers on

Returns:

the new Observable instance

Throws:

NullPointerException - if scheduler is null

See Also:

ReactiveX operators documentation: ObserveOn, RxJava Threading Examples, subscribeOn(io.reactivex.rxjava3.core.Scheduler), observeOn(Scheduler, boolean), observeOn(Scheduler, boolean, int), delay(long, TimeUnit, Scheduler)

observeOn

@CheckReturnValue
 @SchedulerSupport(value="custom")
 @NonNull
public final @NonNull Observable<T> observeOn(@NonNull Scheduler scheduler,
        boolean delayError)

Returns an Observable to perform the current Observable's emissions and notifications on a specified Scheduler, asynchronously with an unbounded buffer with Flowable.bufferSize() "island size" and optionally delays onError notifications.

This operator keeps emitting as many signals as it can on the given Scheduler's worker thread, which may result in a longer than expected occupation of this thread. In other terms, it does not allow per-signal fairness in case the worker runs on a shared underlying thread. If such fairness and signal/work interleaving is preferred, use the delay operator with zero time instead.

Scheduler:

You specify which Scheduler this operator will use.

"Island size" indicates how large chunks the unbounded buffer allocates to store the excess elements waiting to be consumed on the other side of the asynchronous boundary.

Parameters:

scheduler - the Scheduler to notify Observers on

delayError - indicates if the onError notification may not cut ahead of onNext notification on the other side of the scheduling boundary. If true, a sequence ending in onError will be replayed in the same order as was received from the current Observable

Returns:

the new Observable instance

Throws:

NullPointerException - if scheduler is null

See Also:

ReactiveX operators documentation: ObserveOn, RxJava Threading Examples, subscribeOn(io.reactivex.rxjava3.core.Scheduler), observeOn(Scheduler), observeOn(Scheduler, boolean, int), delay(long, TimeUnit, Scheduler, boolean)

observeOn

@CheckReturnValue
 @SchedulerSupport(value="custom")
 @NonNull
public final @NonNull Observable<T> observeOn(@NonNull Scheduler scheduler,
        boolean delayError,
        int bufferSize)

Returns an Observable to perform the current Observable's emissions and notifications on a specified Scheduler, asynchronously with an unbounded buffer of configurable "island size" and optionally delays onError notifications.

This operator keeps emitting as many signals as it can on the given Scheduler's worker thread, which may result in a longer than expected occupation of this thread. In other terms, it does not allow per-signal fairness in case the worker runs on a shared underlying thread. If such fairness and signal/work interleaving is preferred, use the delay operator with zero time instead.

Scheduler:

You specify which Scheduler this operator will use.

"Island size" indicates how large chunks the unbounded buffer allocates to store the excess elements waiting to be consumed on the other side of the asynchronous boundary. Values below 16 are not recommended in performance sensitive scenarios.

Parameters:

scheduler - the Scheduler to notify Observers on

delayError - indicates if the onError notification may not cut ahead of onNext notification on the other side of the scheduling boundary. If true a sequence ending in onError will be replayed in the same order as was received from upstream

bufferSize - the size of the buffer.

Returns:

the new Observable instance

Throws:

NullPointerException - if scheduler is null

IllegalArgumentException - if bufferSize is non-positive

See Also:

ReactiveX operators documentation: ObserveOn, RxJava Threading Examples, subscribeOn(io.reactivex.rxjava3.core.Scheduler), observeOn(Scheduler), observeOn(Scheduler, boolean), delay(long, TimeUnit, Scheduler, boolean)

ofType

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final <U> @NonNull Observable<U> ofType(@NonNull Class<U> clazz)

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

Scheduler:

ofType does not operate by default on a particular Scheduler.

Type Parameters:

U - the output type

Parameters:

clazz - the class type to filter the items emitted by the current Observable

Returns:

the new Observable instance

Throws:

NullPointerException - if clazz is null

See Also:

ReactiveX operators documentation: Filter

onErrorComplete

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Observable<T> onErrorComplete()

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

Scheduler:

onErrorComplete does not operate by default on a particular Scheduler.

Returns:

the new Observable instance

Since:

3.0.0

onErrorComplete

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public final @NonNull Observable<T> onErrorComplete(@NonNull Predicate<? super Throwable> predicate)

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

Scheduler:

onErrorComplete does not operate by default on a particular Scheduler.

Parameters:

predicate - the predicate to call when an Throwable is emitted which should return true if the Throwable should be swallowed and replaced with an onComplete.

Returns:

the new Observable instance

Throws:

NullPointerException - if predicate is null

Since:

3.0.0

onErrorResumeNext

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Observable<T> onErrorResumeNext(@NonNull Function<? super Throwable,? extends ObservableSource<? extends T>> fallbackSupplier)

Resumes the flow with an ObservableSource returned for the failure Throwable of the current Observable by a function instead of signaling the error via onError.

By default, when an ObservableSource encounters an error that prevents it from emitting the expected item to its Observer, the ObservableSource invokes its Observer's onError method, and then quits without invoking any more of its Observer's methods. The onErrorResumeNext method changes this behavior. If you pass a function that returns an ObservableSource (resumeFunction) to onErrorResumeNext, if the original ObservableSource encounters an error, instead of invoking its Observer's onError method, it will instead relinquish control to the ObservableSource returned from resumeFunction, which will invoke the Observer's onNext method if it is able to do so. In such a case, because no ObservableSource necessarily invokes onError, the Observer may never know that an error happened.

You can use this to prevent errors from propagating or to supply fallback data should errors be encountered.

Scheduler:

onErrorResumeNext does not operate by default on a particular Scheduler.

Parameters:

fallbackSupplier - a function that returns an ObservableSource that will take over if the current Observable encounters an error

Returns:

the new Observable instance

Throws:

NullPointerException - if fallbackSupplier is null

See Also:

ReactiveX operators documentation: Catch

onErrorResumeWith

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Observable<T> onErrorResumeWith(@NonNull ObservableSource<? extends T> fallback)

Resumes the flow with the given ObservableSource when the current Observable fails instead of signaling the error via onError.

By default, when an ObservableSource encounters an error that prevents it from emitting the expected item to its Observer, the ObservableSource invokes its Observer's onError method, and then quits without invoking any more of its Observer's methods. The onErrorResumeWith method changes this behavior. If you pass another ObservableSource (next) to an ObservableSource's onErrorResumeWith method, if the original ObservableSource encounters an error, instead of invoking its Observer's onError method, it will instead relinquish control to next which will invoke the Observer's onNext method if it is able to do so. In such a case, because no ObservableSource necessarily invokes onError, the Observer may never know that an error happened.

You can use this to prevent errors from propagating or to supply fallback data should errors be encountered.

Scheduler:

onErrorResumeWith does not operate by default on a particular Scheduler.

Parameters:

fallback - the next ObservableSource source that will take over if the current Observable encounters an error

Returns:

the new Observable instance

Throws:

NullPointerException - if fallback is null

See Also:

ReactiveX operators documentation: Catch

onErrorReturn

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Observable<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 Observable instead of signaling the error via onError.

By default, when an ObservableSource encounters an error that prevents it from emitting the expected item to its Observer, the ObservableSource invokes its Observer's onError method, and then quits without invoking any more of its Observer's methods. The onErrorReturn method changes this behavior. If you pass a function (resumeFunction) to an ObservableSource's onErrorReturn method, if the original ObservableSource encounters an error, instead of invoking its Observer's onError method, it will instead emit the return value of resumeFunction.

You can use this to prevent errors from propagating or to supply fallback data should errors be encountered.

Scheduler:

onErrorReturn does not operate by default on a particular Scheduler.

Parameters:

itemSupplier - a function that returns a single value that will be emitted along with a regular onComplete in case the current Observable signals an onError event

Returns:

the new Observable instance

Throws:

NullPointerException - if itemSupplier is null

See Also:

ReactiveX operators documentation: Catch

onErrorReturnItem

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Observable<T> onErrorReturnItem(@NonNull T item)

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

By default, when an ObservableSource encounters an error that prevents it from emitting the expected item to its Observer, the ObservableSource invokes its Observer's onError method, and then quits without invoking any more of its Observer's methods. The onErrorReturn method changes this behavior. If you pass a function (resumeFunction) to an ObservableSource's onErrorReturn method, if the original ObservableSource encounters an error, instead of invoking its Observer's onError method, it will instead emit the return value of resumeFunction.

You can use this to prevent errors from propagating or to supply fallback data should errors be encountered.

Scheduler:

onErrorReturnItem does not operate by default on a particular Scheduler.

Parameters:

item - the value that is emitted along with a regular onComplete in case the current Observable signals an exception

Returns:

the new Observable instance

Throws:

NullPointerException - if item is null

See Also:

ReactiveX operators documentation: Catch

onTerminateDetach

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Observable<T> onTerminateDetach()

Nulls out references to the upstream producer and downstream Observer if the sequence is terminated or downstream calls dispose().

Scheduler:

onTerminateDetach does not operate by default on a particular Scheduler.

Returns:

the new Observable instance the sequence is terminated or downstream calls dispose()

Since:

2.0

publish

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull ConnectableObservable<T> publish()

Returns a ConnectableObservable, which is a variety of ObservableSource that waits until its connect method is called before it begins emitting items to those Observers that have subscribed to it.

Scheduler:

publish does not operate by default on a particular Scheduler.

Returns:

the new ConnectableObservable instance

See Also:

ReactiveX operators documentation: Publish

publish

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final <R> @NonNull Observable<R> publish(@NonNull Function<? super Observable<T>,? extends ObservableSource<R>> selector)

Returns an Observable that emits the results of invoking a specified selector on items emitted by a ConnectableObservable that shares a single subscription to the current Observable sequence.

Scheduler:

publish does not operate by default on a particular Scheduler.

Type Parameters:

R - the type of items emitted by the resulting Observable

Parameters:

selector - a function that can use the multicasted source sequence as many times as needed, without causing multiple subscriptions to the source sequence. Observers to the given source will receive all notifications of the source from the time of the subscription forward.

Returns:

the new Observable instance

Throws:

NullPointerException - if selector is null

See Also:

ReactiveX operators documentation: Publish

reduce

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @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 Observable, then feeds the result of that function along with the second item emitted by the current Observable into the same function, and so on until all items have been emitted by the current and finite Observable, and emits the final result from the final call to your function as its sole item.

This technique, which is called "reduce" here, is sometimes called "aggregate," "fold," "accumulate," "compress," or "inject" in other programming contexts. Groovy, for instance, has an inject method that does a similar operation on lists.

Note that this operator requires the upstream to signal onComplete for the accumulator object to be emitted. Sources that are infinite and never complete will never emit anything through this operator and an infinite source may lead to a fatal OutOfMemoryError.

Scheduler:

reduce does not operate by default on a particular Scheduler.

Parameters:

reducer - an accumulator function to be invoked on each item emitted by the current Observable, whose result will be used in the next accumulator call

Returns:

the new Maybe instance

Throws:

NullPointerException - if reducer is null

See Also:

ReactiveX operators documentation: Reduce, Wikipedia: Fold (higher-order function)

reduce

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final <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 Observable and a specified seed value, then feeds the result of that function along with the second item emitted by the current Observable into the same function, and so on until all items have been emitted by the current and finite Observable, emitting the final result from the final call to your function as its sole item.

This technique, which is called "reduce" here, is sometimes called "aggregate," "fold," "accumulate," "compress," or "inject" in other programming contexts. Groovy, for instance, has an inject method that does a similar operation on lists.

Note that the seed is shared among all subscribers to the resulting Observable and may cause problems if it is mutable. To make sure each subscriber gets its own value, defer the application of this operator via defer(Supplier):

 ObservableSource<T> source = ...
 Single.defer(() -> source.reduce(new ArrayList<>(), (list, item) -> list.add(item)));

 // alternatively, by using compose to stay fluent

 source.compose(o ->
     Observable.defer(() -> o.reduce(new ArrayList<>(), (list, item) -> list.add(item)).toObservable())
 ).firstOrError();

 // or, by using reduceWith instead of reduce

 source.reduceWith(() -> new ArrayList<>(), (list, item) -> list.add(item)));
 

Note that this operator requires the upstream to signal onComplete for the accumulator object to be emitted. Sources that are infinite and never complete will never emit anything through this operator and an infinite source may lead to a fatal OutOfMemoryError.

Scheduler:

reduce does not operate by default on a particular Scheduler.

Type Parameters:

R - the accumulator and output value type

Parameters:

seed - the initial (seed) accumulator value

reducer - an accumulator function to be invoked on each item emitted by the current Observable, the result of which will be used in the next accumulator call

Returns:

the new Single instance

Throws:

NullPointerException - if seed or reducer is null

See Also:

ReactiveX operators documentation: Reduce, Wikipedia: Fold (higher-order function), reduceWith(Supplier, BiFunction)

reduceWith

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final <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 Observable 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 Observable into the same function, and so on until all items have been emitted by the current and finite Observable, emitting the final result from the final call to your function as its sole item.

This technique, which is called "reduce" here, is sometimes called "aggregate," "fold," "accumulate," "compress," or "inject" in other programming contexts. Groovy, for instance, has an inject method that does a similar operation on lists.

Note that this operator requires the upstream to signal onComplete for the accumulator object to be emitted. Sources that are infinite and never complete will never emit anything through this operator and an infinite source may lead to a fatal OutOfMemoryError.

Scheduler:

reduceWith does not operate by default on a particular Scheduler.

Type Parameters:

R - the accumulator and output value type

Parameters:

seedSupplier - the Supplier that provides the initial (seed) accumulator value for each individual Observer

reducer - an accumulator function to be invoked on each item emitted by the current Observable, the result of which will be used in the next accumulator call

Returns:

the new Single instance

Throws:

NullPointerException - if seedSupplier or reducer is null

See Also:

ReactiveX operators documentation: Reduce, Wikipedia: Fold (higher-order function)

repeat

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Observable<T> repeat()

Returns an Observable that repeats the sequence of items emitted by the current Observable indefinitely.

Scheduler:

repeat does not operate by default on a particular Scheduler.

Returns:

the new Observable instance

See Also:

ReactiveX operators documentation: Repeat

repeat

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Observable<T> repeat(long times)

Returns an Observable that repeats the sequence of items emitted by the current Observable at most count times.

Scheduler:

repeat does not operate by default on a particular Scheduler.

Parameters:

times - the number of times the current Observable items are repeated, a count of 0 will yield an empty sequence

Returns:

the new Observable instance

Throws:

IllegalArgumentException - if times is negative

See Also:

ReactiveX operators documentation: Repeat

repeatUntil

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Observable<T> repeatUntil(@NonNull BooleanSupplier stop)

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

Scheduler:

repeatUntil does not operate by default on a particular Scheduler.

Parameters:

stop - a boolean supplier that is called when the current Observable completes; if it returns true, the returned Observable completes; if it returns false, the current Observable is resubscribed.

Returns:

the new Observable instance

Throws:

NullPointerException - if stop is null

See Also:

ReactiveX operators documentation: Repeat

repeatWhen

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Observable<T> repeatWhen(@NonNull Function<? super Observable<Object>,? extends ObservableSource<?>> handler)

Returns an Observable that emits the same values as the current Observable with the exception of an onComplete. An onComplete notification from the source will result in the emission of a void item to the ObservableSource provided as an argument to the notificationHandler function. If that ObservableSource calls onComplete or onError then repeatWhen will call onComplete or onError on the child subscription. Otherwise, the current Observable will be resubscribed.

Scheduler:

repeatWhen does not operate by default on a particular Scheduler.

Parameters:

handler - receives an ObservableSource of notifications with which a user can complete or error, aborting the repeat.

Returns:

the new Observable instance

Throws:

NullPointerException - if handler is null

See Also:

ReactiveX operators documentation: Repeat

replay

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull ConnectableObservable<T> replay()

Returns a ConnectableObservable that shares a single subscription to the current Observable that will replay all of its items and notifications to any future Observer. A connectable Observable resembles an ordinary Observable, except that it does not begin emitting items when it is subscribed to, but only when its connect method is called.

Scheduler:

This version of replay does not operate by default on a particular Scheduler.

Returns:

the new ConnectableObservable instance

See Also:

ReactiveX operators documentation: Replay

replay

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final <R> @NonNull Observable<R> replay(@NonNull Function<? super Observable<T>,? extends ObservableSource<R>> selector)

Returns an Observable that emits items that are the results of invoking a specified selector on the items emitted by a ConnectableObservable that shares a single subscription to the current Observable.

Scheduler:

This version of replay does not operate by default on a particular Scheduler.

Type Parameters:

R - the type of items emitted by the resulting Observable

Parameters:

selector - the selector function, which can use the multicasted sequence as many times as needed, without causing multiple subscriptions to the current Observable

Returns:

the new Observable instance

Throws:

NullPointerException - if selector is null

See Also:

ReactiveX operators documentation: Replay

replay

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final <R> @NonNull Observable<R> replay(@NonNull Function<? super Observable<T>,? extends ObservableSource<R>> selector,
        int bufferSize)

Returns an Observable that emits items that are the results of invoking a specified selector on items emitted by a ConnectableObservable that shares a single subscription to the current Observable, replaying bufferSize notifications.

Note that due to concurrency requirements, replay(bufferSize) may hold strong references to more than bufferSize source emissions.

Scheduler:

This version of replay does not operate by default on a particular Scheduler.

Type Parameters:

R - the type of items emitted by the resulting Observable

Parameters:

selector - the selector function, which can use the multicasted sequence as many times as needed, without causing multiple subscriptions to the current Observable

bufferSize - the buffer size that limits the number of items the connectable Observable can replay

Returns:

the new Observable instance

Throws:

NullPointerException - if selector is null

IllegalArgumentException - if bufferSize is non-positive

See Also:

ReactiveX operators documentation: Replay, replay(Function, int, boolean)

replay

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final <R> @NonNull Observable<R> replay(@NonNull Function<? super Observable<T>,? extends ObservableSource<R>> selector,
        int bufferSize,
        boolean eagerTruncate)

Returns an Observable that emits items that are the results of invoking a specified selector on items emitted by a ConnectableObservable that shares a single subscription to the current Observable, replaying bufferSize notifications.

Note that due to concurrency requirements, replay(bufferSize) may hold strong references to more than bufferSize source emissions.

Scheduler:

This version of replay does not operate by default on a particular Scheduler.

Type Parameters:

R - the type of items emitted by the resulting Observable

Parameters:

selector - the selector function, which can use the multicasted sequence as many times as needed, without causing multiple subscriptions to the current Observable

bufferSize - the buffer size that limits the number of items the connectable Observable can replay

eagerTruncate - if true, whenever the internal buffer is truncated to the given bufferSize, the oldest item will be guaranteed dereferenced, thus avoiding unexpected retention

Returns:

the new Observable instance

Throws:

NullPointerException - if selector is null

IllegalArgumentException - if bufferSize is non-positive

See Also:

ReactiveX operators documentation: Replay

replay

@CheckReturnValue
 @SchedulerSupport(value="io.reactivex:computation")
 @NonNull
public final <R> @NonNull Observable<R> replay(@NonNull Function<? super Observable<T>,? extends ObservableSource<R>> selector,
        int bufferSize,
        long time,
        @NonNull TimeUnit unit)

Returns an Observable that emits items that are the results of invoking a specified selector on items emitted by a ConnectableObservable that shares a single subscription to the current Observable, replaying no more than bufferSize items that were emitted within a specified time window.

Note that due to concurrency requirements, replay(bufferSize) may hold strong references to more than bufferSize source emissions.

Scheduler:

This version of replay operates by default on the computation Scheduler.

Type Parameters:

R - the type of items emitted by the resulting Observable

Parameters:

selector - a selector function, which can use the multicasted sequence as many times as needed, without causing multiple subscriptions to the current Observable

bufferSize - the buffer size that limits the number of items the connectable Observable can replay

time - the duration of the window in which the replayed items must have been emitted

unit - the time unit of time

Returns:

the new Observable instance

Throws:

NullPointerException - if selector or unit is null

IllegalArgumentException - if bufferSize is non-positive

See Also:

ReactiveX operators documentation: Replay

replay

@CheckReturnValue
 @SchedulerSupport(value="custom")
 @NonNull
public final <R> @NonNull Observable<R> replay(@NonNull Function<? super Observable<T>,? extends ObservableSource<R>> selector,
        int bufferSize,
        long time,
        @NonNull TimeUnit unit,
        @NonNull Scheduler scheduler)

Returns an Observable that emits items that are the results of invoking a specified selector on items emitted by a ConnectableObservable that shares a single subscription to the current Observable, replaying no more than bufferSize items that were emitted within a specified time window.

Note that due to concurrency requirements, replay(bufferSize) may hold strong references to more than bufferSize source emissions.

Scheduler:

You specify which Scheduler this operator will use.

Type Parameters:

R - the type of items emitted by the resulting Observable

Parameters:

selector - a selector function, which can use the multicasted sequence as many times as needed, without causing multiple subscriptions to the current Observable

bufferSize - the buffer size that limits the number of items the connectable Observable can replay

time - the duration of the window in which the replayed items must have been emitted

unit - the time unit of time

scheduler - the Scheduler that is the time source for the window

Returns:

the new Observable instance

Throws:

IllegalArgumentException - if bufferSize is non-positive

NullPointerException - if selector, unit or scheduler is null

IllegalArgumentException - if bufferSize is non-positive

See Also:

ReactiveX operators documentation: Replay, replay(Function, int, long, TimeUnit, Scheduler, boolean)

replay

@CheckReturnValue
 @SchedulerSupport(value="custom")
 @NonNull
public final <R> @NonNull Observable<R> replay(@NonNull Function<? super Observable<T>,? extends ObservableSource<R>> selector,
        int bufferSize,
        long time,
        @NonNull TimeUnit unit,
        @NonNull Scheduler scheduler,
        boolean eagerTruncate)

Returns an Observable that emits items that are the results of invoking a specified selector on items emitted by a ConnectableObservable that shares a single subscription to the current Observable, replaying no more than bufferSize items that were emitted within a specified time window.

Note that due to concurrency requirements, replay(bufferSize) may hold strong references to more than bufferSize source emissions.

Scheduler:

You specify which Scheduler this operator will use.

Type Parameters:

R - the type of items emitted by the resulting Observable

Parameters:

selector - a selector function, which can use the multicasted sequence as many times as needed, without causing multiple subscriptions to the current Observable

bufferSize - the buffer size that limits the number of items the connectable Observable can replay

time - the duration of the window in which the replayed items must have been emitted

unit - the time unit of time

scheduler - the Scheduler that is the time source for the window

eagerTruncate - if true, whenever the internal buffer is truncated to the given bufferSize/age, the oldest item will be guaranteed dereferenced, thus avoiding unexpected retention

Returns:

the new Observable instance

Throws:

NullPointerException - if selector, unit or scheduler is null

IllegalArgumentException - if bufferSize is non-positive

See Also:

ReactiveX operators documentation: Replay

replay

@CheckReturnValue
 @SchedulerSupport(value="io.reactivex:computation")
 @NonNull
public final <R> @NonNull Observable<R> replay(@NonNull Function<? super Observable<T>,? extends ObservableSource<R>> selector,
        long time,
        @NonNull TimeUnit unit)

Returns an Observable that emits items that are the results of invoking a specified selector on items emitted by a ConnectableObservable that shares a single subscription to the current Observable, replaying all items that were emitted within a specified time window.

Scheduler:

This version of replay operates by default on the computation Scheduler.

Type Parameters:

R - the type of items emitted by the resulting Observable

Parameters:

selector - a selector function, which can use the multicasted sequence as many times as needed, without causing multiple subscriptions to the current Observable

time - the duration of the window in which the replayed items must have been emitted

unit - the time unit of time

Returns:

the new Observable instance

Throws:

NullPointerException - if selector or unit is null

See Also:

ReactiveX operators documentation: Replay

replay

@CheckReturnValue
 @SchedulerSupport(value="custom")
 @NonNull
public final <R> @NonNull Observable<R> replay(@NonNull Function<? super Observable<T>,? extends ObservableSource<R>> selector,
        long time,
        @NonNull TimeUnit unit,
        @NonNull Scheduler scheduler)

Returns an Observable that emits items that are the results of invoking a specified selector on items emitted by a ConnectableObservable that shares a single subscription to the current Observable, replaying all items that were emitted within a specified time window.

Scheduler:

You specify which Scheduler this operator will use.

Type Parameters:

R - the type of items emitted by the resulting Observable

Parameters:

selector - a selector function, which can use the multicasted sequence as many times as needed, without causing multiple subscriptions to the current Observable

time - the duration of the window in which the replayed items must have been emitted

unit - the time unit of time

scheduler - the scheduler that is the time source for the window

Returns:

the new Observable instance

Throws:

NullPointerException - if selector, unit or scheduler is null

See Also:

ReactiveX operators documentation: Replay, replay(Function, long, TimeUnit, Scheduler, boolean)

replay

@CheckReturnValue
 @SchedulerSupport(value="custom")
 @NonNull
public final <R> @NonNull Observable<R> replay(@NonNull Function<? super Observable<T>,? extends ObservableSource<R>> selector,
        long time,
        @NonNull TimeUnit unit,
        @NonNull Scheduler scheduler,
        boolean eagerTruncate)

Returns an Observable that emits items that are the results of invoking a specified selector on items emitted by a ConnectableObservable that shares a single subscription to the current Observable, replaying all items that were emitted within a specified time window.

Scheduler:

You specify which Scheduler this operator will use.

Type Parameters:

R - the type of items emitted by the resulting Observable

Parameters:

selector - a selector function, which can use the multicasted sequence as many times as needed, without causing multiple subscriptions to the current Observable

time - the duration of the window in which the replayed items must have been emitted

unit - the time unit of time

scheduler - the scheduler that is the time source for the window

eagerTruncate - if true, whenever the internal buffer is truncated to the given age, the oldest item will be guaranteed dereferenced, thus avoiding unexpected retention

Returns:

the new Observable instance

Throws:

NullPointerException - if selector, unit or scheduler is null

See Also:

ReactiveX operators documentation: Replay

replay

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull ConnectableObservable<T> replay(int bufferSize)

Returns a ConnectableObservable that shares a single subscription to the current Observable that replays at most bufferSize items emitted by the current Observable. A connectable Observable resembles an ordinary Observable, except that it does not begin emitting items when it is subscribed to, but only when its connect method is called.

Note that due to concurrency requirements, replay(bufferSize) may hold strong references to more than bufferSize source emissions. To ensure no beyond-bufferSize items are referenced, use the replay(int, boolean) overload with eagerTruncate = true.

Scheduler:

This version of replay does not operate by default on a particular Scheduler.

Parameters:

bufferSize - the buffer size that limits the number of items that can be replayed

Returns:

the new ConnectableObservable instance

Throws:

IllegalArgumentException - if bufferSize is non-positive

See Also:

ReactiveX operators documentation: Replay, replay(int, boolean)

replay

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull ConnectableObservable<T> replay(int bufferSize,
        boolean eagerTruncate)

Returns a ConnectableObservable that shares a single subscription to the current Observable that replays at most bufferSize items emitted by the current Observable. A connectable Observable resembles an ordinary Observable, except that it does not begin emitting items when it is subscribed to, but only when its connect method is called.

Note that due to concurrency requirements, replay(bufferSize) may hold strong references to more than bufferSize source emissions. To ensure no beyond-bufferSize items are referenced, set eagerTruncate = true.

Scheduler:

This version of replay does not operate by default on a particular Scheduler.

Parameters:

bufferSize - the buffer size that limits the number of items that can be replayed

eagerTruncate - if true, whenever the internal buffer is truncated to the given bufferSize/age, the oldest item will be guaranteed dereferenced, thus avoiding unexpected retention

Returns:

the new ConnectableObservable instance

Throws:

IllegalArgumentException - if bufferSize is non-positive

See Also:

ReactiveX operators documentation: Replay

replay

@CheckReturnValue
 @SchedulerSupport(value="io.reactivex:computation")
 @NonNull
public final @NonNull ConnectableObservable<T> replay(int bufferSize,
        long time,
        @NonNull TimeUnit unit)

Returns a ConnectableObservable that shares a single subscription to the current Observable and replays at most bufferSize items that were emitted during a specified time window. A connectable Observable resembles an ordinary Observable, except that it does not begin emitting items when it is subscribed to, but only when its connect method is called.

Note that due to concurrency requirements, replay(bufferSize) may hold strong references to more than bufferSize source emissions. To ensure no out-of-date or beyond-bufferSize items are referenced, use the replay(int, long, TimeUnit, Scheduler, boolean) overload with eagerTruncate = true.

Scheduler:

This version of replay operates by default on the computation Scheduler.

Parameters:

bufferSize - the buffer size that limits the number of items that can be replayed

time - the duration of the window in which the replayed items must have been emitted

unit - the time unit of time

Returns:

the new ConnectableObservable instance

Throws:

NullPointerException - if unit is null

IllegalArgumentException - if bufferSize is non-positive

See Also:

ReactiveX operators documentation: Replay, replay(int, long, TimeUnit, Scheduler, boolean)

replay

@CheckReturnValue
 @SchedulerSupport(value="custom")
 @NonNull
public final @NonNull ConnectableObservable<T> replay(int bufferSize,
        long time,
        @NonNull TimeUnit unit,
        @NonNull Scheduler scheduler)

Returns a ConnectableObservable that shares a single subscription to the current Observable and that replays a maximum of bufferSize items that are emitted within a specified time window. A connectable Observable resembles an ordinary Observable, except that it does not begin emitting items when it is subscribed to, but only when its connect method is called.

Note that due to concurrency requirements, replay(bufferSize) may hold strong references to more than bufferSize source emissions. To ensure no out-of-date or beyond-bufferSize items are referenced, use the replay(int, long, TimeUnit, Scheduler, boolean) overload with eagerTruncate = true.

Scheduler:

You specify which Scheduler this operator will use.

Parameters:

bufferSize - the buffer size that limits the number of items that can be replayed

time - the duration of the window in which the replayed items must have been emitted

unit - the time unit of time

scheduler - the scheduler that is used as a time source for the window

Returns:

the new ConnectableObservable instance

Throws:

NullPointerException - if unit or scheduler is null

IllegalArgumentException - if bufferSize is non-positive

See Also:

ReactiveX operators documentation: Replay, replay(int, long, TimeUnit, Scheduler, boolean)

replay

@CheckReturnValue
 @SchedulerSupport(value="custom")
 @NonNull
public final @NonNull ConnectableObservable<T> replay(int bufferSize,
        long time,
        @NonNull TimeUnit unit,
        @NonNull Scheduler scheduler,
        boolean eagerTruncate)

Returns a ConnectableObservable that shares a single subscription to the current Observable and that replays a maximum of bufferSize items that are emitted within a specified time window. A connectable Observable resembles an ordinary Observable, except that it does not begin emitting items when it is subscribed to, but only when its connect method is called.

Note that due to concurrency requirements, replay(bufferSize) may hold strong references to more than bufferSize source emissions. To ensure no out-of-date or beyond-bufferSize items are referenced, set eagerTruncate = true.

Scheduler:

You specify which Scheduler this operator will use.

Parameters:

bufferSize - the buffer size that limits the number of items that can be replayed

time - the duration of the window in which the replayed items must have been emitted

unit - the time unit of time

scheduler - the scheduler that is used as a time source for the window

eagerTruncate - if true, whenever the internal buffer is truncated to the given bufferSize/age, the oldest item will be guaranteed dereferenced, thus avoiding unexpected retention

Returns:

the new ConnectableObservable instance

Throws:

NullPointerException - if unit or scheduler is null

IllegalArgumentException - if bufferSize is non-positive

See Also:

ReactiveX operators documentation: Replay

replay

@CheckReturnValue
 @SchedulerSupport(value="io.reactivex:computation")
 @NonNull
public final @NonNull ConnectableObservable<T> replay(long time,
        @NonNull TimeUnit unit)

Returns a ConnectableObservable that shares a single subscription to the current Observable and replays all items emitted by the current Observable within a specified time window. A connectable Observable resembles an ordinary Observable, except that it does not begin emitting items when it is subscribed to, but only when its connect method is called.

Scheduler:

This version of replay operates by default on the computation Scheduler.

Parameters:

time - the duration of the window in which the replayed items must have been emitted

unit - the time unit of time

Returns:

the new ConnectableObservable instance

Throws:

NullPointerException - if unit is null

See Also:

ReactiveX operators documentation: Replay

replay

@CheckReturnValue
 @SchedulerSupport(value="custom")
 @NonNull
public final @NonNull ConnectableObservable<T> replay(long time,
        @NonNull TimeUnit unit,
        @NonNull Scheduler scheduler)

Returns a ConnectableObservable that shares a single subscription to the current Observable and replays all items emitted by the current Observable within a specified time window. A connectable Observable resembles an ordinary Observable, except that it does not begin emitting items when it is subscribed to, but only when its connect method is called.

Note that the internal buffer may retain strong references to the oldest item. To ensure no out-of-date items are referenced, use the replay(long, TimeUnit, Scheduler, boolean) overload with eagerTruncate = true.

Scheduler:

You specify which Scheduler this operator will use.

Parameters:

time - the duration of the window in which the replayed items must have been emitted

unit - the time unit of time

scheduler - the Scheduler that is the time source for the window

Returns:

the new ConnectableObservable instance

Throws:

NullPointerException - if unit or scheduler is null

See Also:

ReactiveX operators documentation: Replay, replay(long, TimeUnit, Scheduler, boolean)

replay

@CheckReturnValue
 @SchedulerSupport(value="custom")
 @NonNull
public final @NonNull ConnectableObservable<T> replay(long time,
        @NonNull TimeUnit unit,
        @NonNull Scheduler scheduler,
        boolean eagerTruncate)

Returns a ConnectableObservable that shares a single subscription to the current Observable and replays all items emitted by the current Observable within a specified time window. A connectable Observable resembles an ordinary Observable, except that it does not begin emitting items when it is subscribed to, but only when its connect method is called.

Note that the internal buffer may retain strong references to the oldest item. To ensure no out-of-date items are referenced, set eagerTruncate = true.

Scheduler:

You specify which Scheduler this operator will use.

Parameters:

time - the duration of the window in which the replayed items must have been emitted

unit - the time unit of time

scheduler - the Scheduler that is the time source for the window

eagerTruncate - if true, whenever the internal buffer is truncated to the given bufferSize/age, the oldest item will be guaranteed dereferenced, thus avoiding unexpected retention

Returns:

the new ConnectableObservable instance

Throws:

NullPointerException - if unit or scheduler is null

See Also:

ReactiveX operators documentation: Replay

retry

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Observable<T> retry()

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

If the current Observable calls Observer.onError(java.lang.Throwable), this method will resubscribe to the current Observable rather than propagating the onError call.

Any and all items emitted by the current Observable will be emitted by the resulting Observable, even those emitted during failed subscriptions. For example, if the current Observable fails at first but emits [1, 2] then succeeds the second time and emits [1, 2, 3, 4, 5] then the complete sequence of emissions and notifications would be [1, 2, 1, 2, 3, 4, 5, onComplete].

Scheduler:

retry does not operate by default on a particular Scheduler.

Returns:

the new Observable instance

See Also:

ReactiveX operators documentation: Retry

retry

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Observable<T> retry(@NonNull BiPredicate<? super Integer,? super Throwable> predicate)

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

Scheduler:

retry does not operate by default on a particular Scheduler.

Parameters:

predicate - the predicate that determines if a resubscription may happen in case of a specific exception and retry count

Returns:

the new Observable instance

Throws:

NullPointerException - if predicate is null

See Also:

retry(), ReactiveX operators documentation: Retry

retry

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Observable<T> retry(long times)

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

If the current Observable calls Observer.onError(java.lang.Throwable), this method will resubscribe to the current Observable for a maximum of count resubscriptions rather than propagating the onError call.

Any and all items emitted by the current Observable will be emitted by the resulting Observable, even those emitted during failed subscriptions. For example, if the current Observable fails at first but emits [1, 2] then succeeds the second time and emits [1, 2, 3, 4, 5] then the complete sequence of emissions and notifications would be [1, 2, 1, 2, 3, 4, 5, onComplete].

Scheduler:

retry does not operate by default on a particular Scheduler.

Parameters:

times - the number of times to resubscribe if the current Observable fails

Returns:

the new Observable instance

Throws:

IllegalArgumentException - if times is negative

See Also:

ReactiveX operators documentation: Retry

retry

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Observable<T> retry(long times,
        @NonNull Predicate<? super Throwable> predicate)

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

Scheduler:

retry does not operate by default on a particular Scheduler.

Parameters:

times - the number of times to resubscribe if the current Observable fails

predicate - the predicate called with the failure Throwable and should return true to trigger a retry.

Returns:

the new Observable instance

Throws:

NullPointerException - if predicate is null

IllegalArgumentException - if times is negative

retry

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Observable<T> retry(@NonNull Predicate<? super Throwable> predicate)

Retries the current Observable if the predicate returns true.

Scheduler:

retry does not operate by default on a particular Scheduler.

Parameters:

predicate - the predicate that receives the failure Throwable and should return true to trigger a retry.

Returns:

the new Observable instance

Throws:

NullPointerException - if predicate is null

retryUntil

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Observable<T> retryUntil(@NonNull BooleanSupplier stop)

Retries until the given stop function returns true.

Scheduler:

retryUntil does not operate by default on a particular Scheduler.

Parameters:

stop - the function that should return true to stop retrying

Returns:

the new Observable instance

Throws:

NullPointerException - if stop is null

retryWhen

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Observable<T> retryWhen(@NonNull Function<? super Observable<Throwable>,? extends ObservableSource<?>> handler)

Returns an Observable that emits the same values as the current Observable with the exception of an onError. An onError notification from the source will result in the emission of a Throwable item to the Observable provided as an argument to the notificationHandler function. If that Observable calls onComplete or onError then retry will call onComplete or onError on the child subscription. Otherwise, the current Observable will be resubscribed.

Example: This retries 3 times, each time incrementing the number of seconds it waits.

  Observable.create((ObservableEmitter<? super String> s) -> {
      System.out.println("subscribing");
      s.onError(new RuntimeException("always fails"));
  }).retryWhen(attempts -> {
      return attempts.zipWith(Observable.range(1, 3), (n, i) -> i).flatMap(i -> {
          System.out.println("delay retry by " + i + " second(s)");
          return Observable.timer(i, TimeUnit.SECONDS);
      });
  }).blockingForEach(System.out::println);
 

Output is:

 
 subscribing
 delay retry by 1 second(s)
 subscribing
 delay retry by 2 second(s)
 subscribing
 delay retry by 3 second(s)
 subscribing
  

Note that the inner ObservableSource returned by the handler function should signal either onNext, onError or onComplete in response to the received Throwable to indicate the operator should retry or terminate. If the upstream to the operator is asynchronous, signaling onNext followed by onComplete immediately may result in the sequence to be completed immediately. Similarly, if this inner ObservableSource signals onError or onComplete while the upstream is active, the sequence is terminated with the same signal immediately.

The following example demonstrates how to retry an asynchronous source with a delay:

 Observable.timer(1, TimeUnit.SECONDS)
     .doOnSubscribe(s -> System.out.println("subscribing"))
     .map(v -> { throw new RuntimeException(); })
     .retryWhen(errors -> {
         AtomicInteger counter = new AtomicInteger();
         return errors
                   .takeWhile(e -> counter.getAndIncrement() != 3)
                   .flatMap(e -> {
                       System.out.println("delay retry by " + counter.get() + " second(s)");
                       return Observable.timer(counter.get(), TimeUnit.SECONDS);
                   });
     })
     .blockingSubscribe(System.out::println, System.out::println);
 

Scheduler:

retryWhen does not operate by default on a particular Scheduler.

Parameters:

handler - receives an Observable of notifications with which a user can complete or error, aborting the retry

Returns:

the new Observable instance

Throws:

NullPointerException - if handler is null

See Also:

ReactiveX operators documentation: Retry

safeSubscribe

@SchedulerSupport(value="none")
public final void safeSubscribe(@NonNull Observer<? super T> observer)

Subscribes to the current Observable and wraps the given Observer into a SafeObserver (if not already a SafeObserver) that deals with exceptions thrown by a misbehaving Observer (that doesn't follow the Reactive Streams specification).

Scheduler:

safeSubscribe does not operate by default on a particular Scheduler.

Parameters:

observer - the incoming Observer instance

Throws:

NullPointerException - if observer is null

sample

@CheckReturnValue
 @SchedulerSupport(value="io.reactivex:computation")
 @NonNull
public final @NonNull Observable<T> sample(long period,
        @NonNull TimeUnit unit)

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

Scheduler:

sample operates by default on the computation Scheduler.

Parameters:

period - the sampling rate

unit - the TimeUnit in which period is defined

Returns:

the new Observable instance

Throws:

NullPointerException - if unit is null

See Also:

ReactiveX operators documentation: Sample, throttleLast(long, TimeUnit)

sample

@CheckReturnValue
 @SchedulerSupport(value="io.reactivex:computation")
 @NonNull
public final @NonNull Observable<T> sample(long period,
        @NonNull TimeUnit unit,
        boolean emitLast)

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

Scheduler:

sample operates by default on the computation Scheduler.

History: 2.0.5 - experimental

Parameters:

period - the sampling rate

unit - the TimeUnit in which period is defined

emitLast - if true and the upstream completes while there is still an unsampled item available, that item is emitted to downstream before completion if false, an unsampled last item is ignored.

Returns:

the new Observable instance

Throws:

NullPointerException - if unit is null

Since:

2.1

See Also:

ReactiveX operators documentation: Sample, throttleLast(long, TimeUnit)

sample

@CheckReturnValue
 @SchedulerSupport(value="custom")
 @NonNull
public final @NonNull Observable<T> sample(long period,
        @NonNull TimeUnit unit,
        @NonNull Scheduler scheduler)

Returns an Observable that emits the most recently emitted item (if any) emitted by the current Observable within periodic time intervals, where the intervals are defined on a particular Scheduler.

Scheduler:

You specify which Scheduler this operator will use.

Parameters:

period - the sampling rate

unit - the TimeUnit in which period is defined

scheduler - the Scheduler to use when sampling

Returns:

the new Observable instance

Throws:

NullPointerException - if unit or scheduler is null

See Also:

ReactiveX operators documentation: Sample, throttleLast(long, TimeUnit, Scheduler)

sample

@CheckReturnValue
 @SchedulerSupport(value="custom")
 @NonNull
public final @NonNull Observable<T> sample(long period,
        @NonNull TimeUnit unit,
        @NonNull Scheduler scheduler,
        boolean emitLast)

Returns an Observable that emits the most recently emitted item (if any) emitted by the current Observable within periodic time intervals, where the intervals are defined on a particular Scheduler and optionally emit the very last upstream item when the upstream completes.

Scheduler:

You specify which Scheduler this operator will use.

History: 2.0.5 - experimental

Parameters:

period - the sampling rate

unit - the TimeUnit in which period is defined

scheduler - the Scheduler to use when sampling

emitLast - if true and the upstream completes while there is still an unsampled item available, that item is emitted to downstream before completion if false, an unsampled last item is ignored.

Returns:

the new Observable instance

Throws:

NullPointerException - if unit or scheduler is null

Since:

2.1

See Also:

ReactiveX operators documentation: Sample, throttleLast(long, TimeUnit, Scheduler)

sample

@CheckReturnValue
 @SchedulerSupport(value="custom")
 @NonNull
public final @NonNull Observable<T> sample(long period,
        @NonNull TimeUnit unit,
        @NonNull Scheduler scheduler,
        boolean emitLast,
        @NonNull Consumer<? super T> onDropped)

Returns an Observable that emits the most recently emitted item (if any) emitted by the current Observable within periodic time intervals, where the intervals are defined on a particular Scheduler.

Scheduler:

You specify which Scheduler this operator will use.

Parameters:

period - the sampling rate

unit - the TimeUnit in which period is defined

scheduler - the Scheduler to use when sampling

emitLast - if true and the upstream completes while there is still an unsampled item available, that item is emitted to downstream before completion if false, an unsampled last item is ignored.

onDropped - called with the current entry when it has been replaced by a new one

Returns:

the new Observable instance

Throws:

NullPointerException - if unit or scheduler is null or onDropped is null

Since:

3.1.6 - Experimental

See Also:

ReactiveX operators documentation: Sample, throttleLast(long, TimeUnit, Scheduler)

sample

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final <U> @NonNull Observable<T> sample(@NonNull ObservableSource<U> sampler)

Returns an Observable that, when the specified sampler ObservableSource emits an item or completes, emits the most recently emitted item (if any) emitted by the current Observable since the previous emission from the sampler ObservableSource.

Scheduler:

This version of sample does not operate by default on a particular Scheduler.

Type Parameters:

U - the element type of the sampler ObservableSource

Parameters:

sampler - the ObservableSource to use for sampling the current Observable

Returns:

the new Observable instance

Throws:

NullPointerException - if sampler is null

See Also:

ReactiveX operators documentation: Sample

sample

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final <U> @NonNull Observable<T> sample(@NonNull ObservableSource<U> sampler,
        boolean emitLast)

Returns an Observable that, when the specified sampler ObservableSource emits an item or completes, emits the most recently emitted item (if any) emitted by the current Observable since the previous emission from the sampler ObservableSource and optionally emit the very last upstream item when the upstream or other ObservableSource complete.

Scheduler:

This version of sample does not operate by default on a particular Scheduler.

History: 2.0.5 - experimental

Type Parameters:

U - the element type of the sampler ObservableSource

Parameters:

sampler - the ObservableSource to use for sampling the current Observable

emitLast - if true and the upstream completes while there is still an unsampled item available, that item is emitted to downstream before completion if false, an unsampled last item is ignored.

Returns:

the new Observable instance

Throws:

NullPointerException - if sampler is null

Since:

2.1

See Also:

ReactiveX operators documentation: Sample

scan

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Observable<T> scan(@NonNull BiFunction<T,T,T> accumulator)

Returns an Observable that emits the first value emitted by the current Observable, then emits one value for each subsequent value emitted by the current Observable. Each emission after the first is the result of applying the specified accumulator function to the previous emission and the corresponding value from the current Observable.

This sort of function is sometimes called an accumulator.

Scheduler:

scan does not operate by default on a particular Scheduler.

Parameters:

accumulator - an accumulator function to be invoked on each item emitted by the current Observable, whose result will be emitted to Observers via onNext and used in the next accumulator call

Returns:

the new Observable instance

Throws:

NullPointerException - if accumulator is null

See Also:

ReactiveX operators documentation: Scan

scan

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final <R> @NonNull Observable<R> scan(@NonNull R initialValue,
        @NonNull BiFunction<R,? super T,R> accumulator)

Returns an Observable that emits the provided initial (seed) value, then emits one value for each value emitted by the current Observable. Each emission after the first is the result of applying the specified accumulator function to the previous emission and the corresponding value from the current Observable.

This sort of function is sometimes called an accumulator.

Note that the Observable that results from this method will emit initialValue as its first emitted item.

Note that the initialValue is shared among all subscribers to the resulting Observable and may cause problems if it is mutable. To make sure each subscriber gets its own value, defer the application of this operator via defer(Supplier):

 ObservableSource<T> source = ...
 Observable.defer(() -> source.scan(new ArrayList<>(), (list, item) -> list.add(item)));

 // alternatively, by using compose to stay fluent

 source.compose(o ->
     Observable.defer(() -> o.scan(new ArrayList<>(), (list, item) -> list.add(item)))
 );
 

Scheduler:

scan does not operate by default on a particular Scheduler.

Type Parameters:

R - the initial, accumulator and result type

Parameters:

initialValue - the initial (seed) accumulator item

accumulator - an accumulator function to be invoked on each item emitted by the current Observable, whose result will be emitted to Observers via onNext and used in the next accumulator call

Returns:

the new Observable instance

Throws:

NullPointerException - if initialValue or accumulator is null

See Also:

ReactiveX operators documentation: Scan

scanWith

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final <R> @NonNull Observable<R> scanWith(@NonNull Supplier<R> seedSupplier,
        @NonNull BiFunction<R,? super T,R> accumulator)

Returns an Observable that emits the provided initial (seed) value, then emits one value for each value emitted by the current Observable. Each emission after the first is the result of applying the specified accumulator function to the previous emission and the corresponding value from the current Observable.

This sort of function is sometimes called an accumulator.

Note that the Observable that results from this method will emit the value returned by the seedSupplier as its first item.

Scheduler:

scanWith does not operate by default on a particular Scheduler.

Type Parameters:

R - the initial, accumulator and result type

Parameters:

seedSupplier - a Supplier that returns the initial (seed) accumulator item for each individual Observer

accumulator - an accumulator function to be invoked on each item emitted by the current Observable, whose result will be emitted to Observers via onNext and used in the next accumulator call

Returns:

the new Observable instance

Throws:

NullPointerException - if seedSupplier or accumulator is null

See Also:

ReactiveX operators documentation: Scan

serialize

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Observable<T> serialize()

Forces the current Observable's emissions and notifications to be serialized and for it to obey the ObservableSource contract in other ways.

It is possible for an Observable to invoke its Observers' methods asynchronously, perhaps from different threads. This could make such an Observable poorly-behaved, in that it might try to invoke onComplete or onError before one of its onNext invocations, or it might call onNext from two different threads concurrently. You can force such an Observable to be well-behaved and sequential by applying the serialize method to it.

Scheduler:

serialize does not operate by default on a particular Scheduler.

Returns:

the new Observable instance

See Also:

ReactiveX operators documentation: Serialize

share

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Observable<T> share()

Returns a new Observable that multicasts (and shares a single subscription to) the current Observable. As long as there is at least one Observer, the current Observable will stay subscribed and keep emitting signals. When all observers have disposed, the operator will dispose the subscription to the current Observable.

This is an alias for publish().refCount().

Scheduler:

share does not operate by default on a particular Scheduler.

Returns:

the new Observable instance

See Also:

ReactiveX operators documentation: RefCount

singleElement

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Maybe<T> singleElement()

Returns a Maybe that completes if the current Observable is empty or emits the single item emitted by the current Observable, or signals an IllegalArgumentException if the current Observable emits more than one item.

Scheduler:

singleElement does not operate by default on a particular Scheduler.

Returns:

the new Maybe instance

See Also:

ReactiveX operators documentation: First

single

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Single<T> single(@NonNull T defaultItem)

Returns a Single that emits the single item emitted by the current Observable, if the current Observable emits only a single item, or a default item if the current Observable emits no items. If the current Observable emits more than one item, an IllegalArgumentException is signaled instead.

Scheduler:

single does not operate by default on a particular Scheduler.

Parameters:

defaultItem - a default value to emit if the current Observable emits no item

Returns:

the new Single instance

Throws:

NullPointerException - if defaultItem is null

See Also:

ReactiveX operators documentation: First

singleOrError

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Single<T> singleOrError()

Returns a Single that emits the single item emitted by the current Observable if it emits only a single item, otherwise if the current Observable completes without emitting any items or emits more than one item a NoSuchElementException or IllegalArgumentException will be signaled respectively.

Scheduler:

singleOrError does not operate by default on a particular Scheduler.

Returns:

the new Single instance

See Also:

ReactiveX operators documentation: First

skip

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Observable<T> skip(long count)

Returns an Observable that skips the first count items emitted by the current Observable and emits the remainder.

Scheduler:

This version of skip does not operate by default on a particular Scheduler.

Parameters:

count - the number of items to skip

Returns:

the new Observable instance

Throws:

IllegalArgumentException - if count is negative

See Also:

ReactiveX operators documentation: Skip

skip

@CheckReturnValue
 @SchedulerSupport(value="io.reactivex:computation")
 @NonNull
public final @NonNull Observable<T> skip(long time,
        @NonNull TimeUnit unit)

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

Scheduler:

skip does not operate on any particular scheduler but uses the current time from the computation Scheduler.

Parameters:

time - the length of the time window to skip

unit - the time unit of time

Returns:

the new Observable instance

Throws:

NullPointerException - if unit is null

See Also:

ReactiveX operators documentation: Skip

skip

@CheckReturnValue
 @SchedulerSupport(value="custom")
 @NonNull
public final @NonNull Observable<T> skip(long time,
        @NonNull TimeUnit unit,
        @NonNull Scheduler scheduler)

Returns an Observable that skips values emitted by the current Observable before a specified time window on a specified Scheduler elapses.

Scheduler:

You specify which Scheduler this operator will use for the timed skipping

Parameters:

time - the length of the time window to skip

unit - the time unit of time

scheduler - the Scheduler on which the timed wait happens

Returns:

the new Observable instance

Throws:

NullPointerException - if unit or scheduler is null

See Also:

ReactiveX operators documentation: Skip

skipLast

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Observable<T> skipLast(int count)

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

This Observer accumulates a queue long enough to store the first count items. As more items are received, items are taken from the front of the queue and emitted by the returned Observable. This causes such items to be delayed.

Scheduler:

This version of skipLast does not operate by default on a particular Scheduler.

Parameters:

count - number of items to drop from the end of the source sequence

Returns:

the new Observable instance

Throws:

IllegalArgumentException - if count is negative

See Also:

ReactiveX operators documentation: SkipLast

skipLast

@CheckReturnValue
 @SchedulerSupport(value="io.reactivex:trampoline")
 @NonNull
public final @NonNull Observable<T> skipLast(long time,
        @NonNull TimeUnit unit)

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

Note: this action will cache the latest items arriving in the specified time window.

Scheduler:

skipLast does not operate on any particular scheduler but uses the current time from the trampoline Scheduler.

Parameters:

time - the length of the time window

unit - the time unit of time

Returns:

the new Observable instance

Throws:

NullPointerException - if unit is null

See Also:

ReactiveX operators documentation: SkipLast

skipLast

@CheckReturnValue
 @SchedulerSupport(value="io.reactivex:trampoline")
 @NonNull
public final @NonNull Observable<T> skipLast(long time,
        @NonNull TimeUnit unit,
        boolean delayError)

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

Note: this action will cache the latest items arriving in the specified time window.

Scheduler:

skipLast does not operate on any particular scheduler but uses the current time from the computation Scheduler.

Parameters:

time - the length of the time window

unit - the time unit of time

delayError - if true, an exception signaled by the current Observable is delayed until the regular elements are consumed by the downstream; if false, an exception is immediately signaled and all regular elements dropped

Returns:

the new Observable instance

Throws:

NullPointerException - if unit is null

See Also:

ReactiveX operators documentation: SkipLast

skipLast

@CheckReturnValue
 @SchedulerSupport(value="custom")
 @NonNull
public final @NonNull Observable<T> skipLast(long time,
        @NonNull TimeUnit unit,
        @NonNull Scheduler scheduler)

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

Note: this action will cache the latest items arriving in the specified time window.

Scheduler:

You specify which Scheduler this operator will use for tracking the current time

Parameters:

time - the length of the time window

unit - the time unit of time

scheduler - the scheduler used as the time source

Returns:

the new Observable instance

Throws:

NullPointerException - if unit or scheduler is null

See Also:

ReactiveX operators documentation: SkipLast

skipLast

@CheckReturnValue
 @SchedulerSupport(value="custom")
 @NonNull
public final @NonNull Observable<T> skipLast(long time,
        @NonNull TimeUnit unit,
        @NonNull Scheduler scheduler,
        boolean delayError)

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

Note: this action will cache the latest items arriving in the specified time window.

Scheduler:

You specify which Scheduler this operator will use to track the current time

Parameters:

time - the length of the time window

unit - the time unit of time

scheduler - the scheduler used as the time source

delayError - if true, an exception signaled by the current Observable is delayed until the regular elements are consumed by the downstream; if false, an exception is immediately signaled and all regular elements dropped

Returns:

the new Observable instance

Throws:

NullPointerException - if unit or scheduler is null

See Also:

ReactiveX operators documentation: SkipLast

skipLast

@CheckReturnValue
 @SchedulerSupport(value="custom")
 @NonNull
public final @NonNull Observable<T> skipLast(long time,
        @NonNull TimeUnit unit,
        @NonNull Scheduler scheduler,
        boolean delayError,
        int bufferSize)

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

Note: this action will cache the latest items arriving in the specified time window.

Scheduler:

You specify which Scheduler this operator will use.

Parameters:

time - the length of the time window

unit - the time unit of time

scheduler - the scheduler used as the time source

delayError - if true, an exception signaled by the current Observable is delayed until the regular elements are consumed by the downstream; if false, an exception is immediately signaled and all regular elements dropped

bufferSize - the hint about how many elements to expect to be skipped

Returns:

the new Observable instance

Throws:

NullPointerException - if unit or scheduler is null

IllegalArgumentException - if bufferSize is non-positive

See Also:

ReactiveX operators documentation: SkipLast

skipUntil

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final <U> @NonNull Observable<T> skipUntil(@NonNull ObservableSource<U> other)

Returns an Observable that skips items emitted by the current Observable until a second ObservableSource emits an item.

Scheduler:

skipUntil does not operate by default on a particular Scheduler.

Type Parameters:

U - the element type of the other ObservableSource

Parameters:

other - the second ObservableSource that has to emit an item before the current Observable's elements begin to be mirrored by the resulting Observable

Returns:

the new Observable instance

Throws:

NullPointerException - if other is null

See Also:

ReactiveX operators documentation: SkipUntil

skipWhile

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Observable<T> skipWhile(@NonNull Predicate<? super T> predicate)

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

Scheduler:

skipWhile does not operate by default on a particular Scheduler.

Parameters:

predicate - a function to test each item emitted from the current Observable

Returns:

the new Observable instance

Throws:

NullPointerException - if predicate is null

See Also:

ReactiveX operators documentation: SkipWhile

sorted

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Observable<T> sorted()

Returns an Observable that emits the events emitted by the current Observable, in a sorted order. Each item emitted by the current Observable must implement Comparable with respect to all other items in the sequence.

If any item emitted by the current Observable does not implement Comparable with respect to all other items emitted by the current Observable, no items will be emitted and the sequence is terminated with a ClassCastException.

Note that calling sorted with long, non-terminating or infinite sources might cause OutOfMemoryError

Scheduler:

sorted does not operate by default on a particular Scheduler.

Returns:

the new Observable instance

sorted

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Observable<T> sorted(@NonNull Comparator<? super T> comparator)

Returns an Observable that emits the events emitted by the current Observable, in a sorted order based on a specified comparison function.

Note that calling sorted with long, non-terminating or infinite sources might cause OutOfMemoryError

Scheduler:

sorted does not operate by default on a particular Scheduler.

Parameters:

comparator - a function that compares two items emitted by the current Observable and returns an int that indicates their sort order

Returns:

the new Observable instance

Throws:

NullPointerException - if comparator is null

startWithIterable

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Observable<T> startWithIterable(@NonNull Iterable<? extends T> items)

Returns an Observable that emits the items in a specified Iterable before it begins to emit items emitted by the current Observable.

Scheduler:

startWithIterable does not operate by default on a particular Scheduler.

Parameters:

items - an Iterable that contains the items you want the resulting Observable to emit first

Returns:

the new Observable instance

Throws:

NullPointerException - if items is null

Since:

3.0.0

See Also:

ReactiveX operators documentation: StartWith, startWithItem(Object), startWithArray(Object...)

startWith

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public final @NonNull Observable<T> startWith(@NonNull CompletableSource other)

Returns an Observable which first runs the other CompletableSource then the current Observable if the other completed normally.

Scheduler:

startWith does not operate by default on a particular Scheduler.

Parameters:

other - the other CompletableSource to run first

Returns:

the new Observable instance

Throws:

NullPointerException - if other is null

Since:

3.0.0

startWith

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public final @NonNull Observable<T> startWith(@NonNull SingleSource<T> other)

Returns an Observable which first runs the other SingleSource then the current Observable if the other succeeded normally.

Scheduler:

startWith does not operate by default on a particular Scheduler.

Parameters:

other - the other SingleSource to run first

Returns:

the new Observable instance

Throws:

NullPointerException - if other is null

Since:

3.0.0

startWith

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public final @NonNull Observable<T> startWith(@NonNull MaybeSource<T> other)

Returns an Observable which first runs the other MaybeSource then the current Observable if the other succeeded or completed normally.

Scheduler:

startWith does not operate by default on a particular Scheduler.

Parameters:

other - the other MaybeSource to run first

Returns:

the new Observable instance

Throws:

NullPointerException - if other is null

Since:

3.0.0

startWith

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Observable<T> startWith(@NonNull ObservableSource<? extends T> other)

Returns an Observable that emits the items in a specified ObservableSource before it begins to emit items emitted by the current Observable.

Scheduler:

startWith does not operate by default on a particular Scheduler.

Parameters:

other - an ObservableSource that contains the items you want the modified ObservableSource to emit first

Returns:

the new Observable instance

Throws:

NullPointerException - if other is null

See Also:

ReactiveX operators documentation: StartWith

startWithItem

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Observable<T> startWithItem(@NonNull T item)

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

Scheduler:

startWithItem does not operate by default on a particular Scheduler.

Parameters:

item - the item to emit first

Returns:

the new Observable instance

Throws:

NullPointerException - if item is null

Since:

3.0.0

See Also:

ReactiveX operators documentation: StartWith, startWithArray(Object...), startWithIterable(Iterable)

startWithArray

@CheckReturnValue
 @SchedulerSupport(value="none")
 @SafeVarargs
 @NonNull
public final @NonNull Observable<T> startWithArray(@NonNull T... items)

Returns an Observable that emits the specified items before it begins to emit items emitted by the current Observable.

Scheduler:

startWithArray does not operate by default on a particular Scheduler.

Parameters:

items - the array of values to emit first

Returns:

the new Observable instance

Throws:

NullPointerException - if items is null

See Also:

ReactiveX operators documentation: StartWith, startWithItem(Object), startWithIterable(Iterable)

subscribe

@SchedulerSupport(value="none")
 @NonNull
public final @NonNull Disposable subscribe()

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

If the Observable emits an error, it is wrapped into an OnErrorNotImplementedException and routed to the RxJavaPlugins.onError(Throwable) handler.

Scheduler:

subscribe does not operate by default on a particular Scheduler.

Returns:

the new Disposable instance that can be used to dispose the subscription at any time

See Also:

ReactiveX operators documentation: Subscribe, subscribe(Consumer, Consumer, Action, DisposableContainer)

subscribe

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Disposable subscribe(@NonNull Consumer<? super T> onNext)

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

If the Observable emits an error, it is wrapped into an OnErrorNotImplementedException and routed to the RxJavaPlugins.onError(Throwable) handler.

Scheduler:

subscribe does not operate by default on a particular Scheduler.

Parameters:

onNext - the Consumer<T> you have designed to accept emissions from the current Observable

Returns:

the new Disposable instance that can be used to dispose the subscription at any time

Throws:

NullPointerException - if onNext is null

See Also:

ReactiveX operators documentation: Subscribe, subscribe(Consumer, Consumer, Action, DisposableContainer)

subscribe

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Disposable subscribe(@NonNull Consumer<? super T> onNext,
        @NonNull Consumer<? super Throwable> onError)

Subscribes to the current Observable and provides callbacks to handle the items it emits and any error notification it signals.

Scheduler:

subscribe does not operate by default on a particular Scheduler.

Parameters:

onNext - the Consumer<T> you have designed to accept emissions from the current Observable

onError - the Consumer<Throwable> you have designed to accept any error notification from the current Observable

Returns:

the new Disposable instance that can be used to dispose the subscription at any time

Throws:

NullPointerException - if onNext or onError is null

See Also:

ReactiveX operators documentation: Subscribe, subscribe(Consumer, Consumer, Action, DisposableContainer)

subscribe

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Disposable subscribe(@NonNull Consumer<? super T> onNext,
        @NonNull Consumer<? super Throwable> onError,
        @NonNull Action onComplete)

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

Scheduler:

subscribe does not operate by default on a particular Scheduler.

Parameters:

onNext - the Consumer<T> you have designed to accept emissions from the current Observable

onError - the Consumer<Throwable> you have designed to accept any error notification from the current Observable

onComplete - the Action you have designed to accept a completion notification from the current Observable

Returns:

the new Disposable instance that can be used to dispose the subscription at any time

Throws:

NullPointerException - if onNext, onError or onComplete is null

See Also:

ReactiveX operators documentation: Subscribe, subscribe(Consumer, Consumer, Action, DisposableContainer)

subscribe

@SchedulerSupport(value="none")
 @NonNull
public final @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 Observer, adds it to the given DisposableContainer and ensures, that if the upstream terminates or this particular Disposable is disposed, the Observer is removed from the given container.

The Observer will be removed after the callback for the terminal event has been invoked.

Scheduler:

subscribe does not operate by default on a particular Scheduler.

Parameters:

onNext - the callback for upstream items

onError - the callback for an upstream error if any

onComplete - the callback for the upstream completion if any

container - the DisposableContainer (such as CompositeDisposable) to add and remove the created Disposable Observer

Returns:

the Disposable that allows disposing the particular subscription.

Throws:

NullPointerException - if onNext, onError, onComplete or container is null

Since:

3.1.0

subscribe

@SchedulerSupport(value="none")
public final void subscribe(@NonNull Observer<? super T> observer)

Description copied from interface: ObservableSource

Subscribes the given Observer to this ObservableSource instance.

Specified by:

subscribe in interface ObservableSource<T>

Parameters:

observer - the Observer, not null

subscribeActual

protected abstract void subscribeActual(@NonNull Observer<? super T> observer)

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

There is no need to call any of the plugin hooks on the current Observable instance or the Observer; all hooks and basic safeguards have been applied by subscribe(Observer) before this method gets called.

Parameters:

observer - the incoming Observer, never null

subscribeWith

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final <E extends Observer<? super T>> E subscribeWith(E observer)

Subscribes a given Observer (subclass) to the current Observable and returns the given Observer instance as is.

Usage example:

 Observable<Integer> source = Observable.range(1, 10);
 CompositeDisposable composite = new CompositeDisposable();

 DisposableObserver<Integer> ds = new DisposableObserver<>() {
     // ...
 };

 composite.add(source.subscribeWith(ds));
 

Scheduler:

subscribeWith does not operate by default on a particular Scheduler.

Type Parameters:

E - the type of the Observer to use and return

Parameters:

observer - the Observer (subclass) to use and return, not null

Returns:

the input observer

Throws:

NullPointerException - if observer is null

Since:

2.0

subscribeOn

@CheckReturnValue
 @SchedulerSupport(value="custom")
 @NonNull
public final @NonNull Observable<T> subscribeOn(@NonNull Scheduler scheduler)

Asynchronously subscribes Observers to the current Observable on the specified Scheduler.

Scheduler:

You specify which Scheduler this operator will use.

Parameters:

scheduler - the Scheduler to perform subscription actions on

Returns:

the new Observable instance

Throws:

NullPointerException - if scheduler is null

See Also:

ReactiveX operators documentation: SubscribeOn, RxJava Threading Examples, observeOn(io.reactivex.rxjava3.core.Scheduler)

switchIfEmpty

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Observable<T> switchIfEmpty(@NonNull ObservableSource<? extends T> other)

Returns an Observable that emits the items emitted by the current Observable or the items of an alternate ObservableSource if the current Observable is empty.

Scheduler:

switchIfEmpty does not operate by default on a particular Scheduler.

Parameters:

other - the alternate ObservableSource to subscribe to if the source does not emit any items

Returns:

the new Observable instance

Throws:

NullPointerException - if other is null

Since:

1.1.0

switchMap

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final <R> @NonNull Observable<R> switchMap(@NonNull Function<? super T,? extends ObservableSource<? extends R>> mapper)

Returns a new Observable by applying a function that you supply to each item emitted by the current Observable that returns an ObservableSource, and then emitting the items emitted by the most recently emitted of these ObservableSources.

The resulting Observable completes if both the current Observable and the last inner ObservableSource, if any, complete. If the current Observable signals an onError, the inner ObservableSource is disposed and the error delivered in-sequence.

Scheduler:

switchMap does not operate by default on a particular Scheduler.

Type Parameters:

R - the element type of the inner ObservableSources and the output

Parameters:

mapper - a function that, when applied to an item emitted by the current Observable, returns an ObservableSource

Returns:

the new Observable instance

Throws:

NullPointerException - if mapper is null

See Also:

ReactiveX operators documentation: FlatMap, switchMapDelayError(Function)

switchMap

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final <R> @NonNull Observable<R> switchMap(@NonNull Function<? super T,? extends ObservableSource<? extends R>> mapper,
        int bufferSize)

Returns a new Observable by applying a function that you supply to each item emitted by the current Observable that returns an ObservableSource, and then emitting the items emitted by the most recently emitted of these ObservableSources.

The resulting Observable completes if both the current Observable and the last inner ObservableSource, if any, complete. If the current Observable signals an onError, the inner ObservableSource is disposed and the error delivered in-sequence.

Scheduler:

switchMap does not operate by default on a particular Scheduler.

Type Parameters:

R - the element type of the inner ObservableSources and the output

Parameters:

mapper - a function that, when applied to an item emitted by the current Observable, returns an ObservableSource

bufferSize - the number of elements expected from the current active inner ObservableSource to be buffered

Returns:

the new Observable instance

Throws:

NullPointerException - if mapper is null

IllegalArgumentException - if bufferSize is non-positive

See Also:

ReactiveX operators documentation: FlatMap, switchMapDelayError(Function, int)

switchMapCompletable

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Completable switchMapCompletable(@NonNull Function<? super T,? extends CompletableSource> mapper)

Maps the items of the current Observable into CompletableSources, subscribes to the newer one while disposing the subscription to the previous CompletableSource, thus keeping at most one active CompletableSource running.

Since a CompletableSource doesn't produce any items, the resulting reactive type of this operator is a Completable that can only indicate successful completion or a failure in any of the inner CompletableSources or the failure of the current Observable.

Scheduler:

switchMapCompletable does not operate by default on a particular Scheduler.

Error handling:

If either the current Observable or the active CompletableSource signals an onError, the resulting Completable is terminated immediately with that Throwable. Use the switchMapCompletableDelayError(Function) to delay such inner failures until every inner CompletableSources and the main Observable terminates in some fashion. If they fail concurrently, the operator may combine the Throwables into a CompositeException and signal it to the downstream instead. If any inactivated (switched out) CompletableSource signals an onError late, the Throwables will be signaled to the global error handler via RxJavaPlugins.onError(Throwable) method as UndeliverableException errors.

History: 2.1.11 - experimental

Parameters:

mapper - the function called with each upstream item and should return a CompletableSource to be subscribed to and awaited for (non blockingly) for its terminal event

Returns:

the new Completable instance

Throws:

NullPointerException - if mapper is null

Since:

2.2

See Also:

switchMapCompletableDelayError(Function)

switchMapCompletableDelayError

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Completable switchMapCompletableDelayError(@NonNull Function<? super T,? extends CompletableSource> mapper)

Maps the upstream values into CompletableSources, 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.

Since a CompletableSource doesn't produce any items, the resulting reactive type of this operator is a Completable that can only indicate successful completion or a failure in any of the inner CompletableSources or the failure of the current Observable.

Scheduler:

switchMapCompletableDelayError does not operate by default on a particular Scheduler.

Error handling:

The errors of the current Observable and all the CompletableSources, who had the chance to run to their completion, are delayed until all of them terminate in some fashion. At this point, if there was only one failure, the respective Throwable is emitted to the downstream. It there were more than one failures, the operator combines all Throwables into a CompositeException and signals that to the downstream. If any inactivated (switched out) CompletableSource signals an onError late, the Throwables will be signaled to the global error handler via RxJavaPlugins.onError(Throwable) method as UndeliverableException errors.

History: 2.1.11 - experimental

Parameters:

mapper - the function called with each upstream item and should return a CompletableSource to be subscribed to and awaited for (non blockingly) for its terminal event

Returns:

the new Completable instance

Throws:

NullPointerException - if mapper is null

Since:

2.2

See Also:

switchMapCompletable(Function)

switchMapMaybe

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final <R> @NonNull Observable<R> switchMapMaybe(@NonNull Function<? super T,? extends MaybeSource<? extends R>> mapper)

Maps the items of the current Observable into MaybeSources and switches (subscribes) to the newer ones while disposing the older ones (and ignoring their signals) and emits the latest success value of the current one if available while failing immediately if the current Observable or any of the active inner MaybeSources fail.

Scheduler:

switchMapMaybe does not operate by default on a particular Scheduler.

Error handling:

This operator terminates with an onError if the current Observable or any of the inner MaybeSources fail while they are active. When this happens concurrently, their individual Throwable errors may get combined and emitted as a single CompositeException. Otherwise, a late (i.e., inactive or switched out) onError from the current Observable or from any of the inner MaybeSources will be forwarded to the global error handler via RxJavaPlugins.onError(Throwable) as UndeliverableException

History: 2.1.11 - experimental

Type Parameters:

R - the output value type

Parameters:

mapper - the function called with the current upstream event and should return a MaybeSource to replace the current active inner source and get subscribed to.

Returns:

the new Observable instance

Throws:

NullPointerException - if mapper is null

Since:

2.2

See Also:

switchMapMaybeDelayError(Function)

switchMapMaybeDelayError

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final <R> @NonNull Observable<R> switchMapMaybeDelayError(@NonNull Function<? super T,? extends MaybeSource<? extends R>> mapper)

Maps the upstream items into MaybeSources and switches (subscribes) to the newer ones while disposing the older ones (and ignoring their signals) and emits the latest success value of the current one if available, delaying errors from the current Observable or the inner MaybeSources until all terminate.

Scheduler:

switchMapMaybeDelayError does not operate by default on a particular Scheduler.

History: 2.1.11 - experimental

Type Parameters:

R - the output value type

Parameters:

mapper - the function called with the current upstream event and should return a MaybeSource to replace the current active inner source and get subscribed to.

Returns:

the new Observable instance

Throws:

NullPointerException - if mapper is null

Since:

2.2

See Also:

switchMapMaybe(Function)

switchMapSingle

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final <R> @NonNull Observable<R> switchMapSingle(@NonNull Function<? super T,? extends SingleSource<? extends R>> mapper)

Returns a new Observable by applying a function that you supply to each item emitted by the current Observable that returns a SingleSource, and then emitting the item emitted by the most recently emitted of these SingleSources.

The resulting Observable completes if both the current Observable and the last inner SingleSource, if any, complete. If the current Observable signals an onError, the inner SingleSource is disposed and the error delivered in-sequence.

Scheduler:

switchMapSingle does not operate by default on a particular Scheduler.

History: 2.0.8 - experimental

Type Parameters:

R - the element type of the inner SingleSources and the output

Parameters:

mapper - a function that, when applied to an item emitted by the current Observable, returns a SingleSource

Returns:

the new Observable instance

Throws:

NullPointerException - if mapper is null

Since:

2.2

See Also:

ReactiveX operators documentation: FlatMap, switchMapSingleDelayError(Function)

switchMapSingleDelayError

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final <R> @NonNull Observable<R> switchMapSingleDelayError(@NonNull Function<? super T,? extends SingleSource<? extends R>> mapper)

Returns a new Observable by applying a function that you supply to each item emitted by the current Observable that returns a SingleSource, and then emitting the item emitted by the most recently emitted of these SingleSources and delays any error until all SingleSources terminate.

The resulting Observable completes if both the current Observable and the last inner SingleSource, if any, complete. If the current Observable signals an onError, the termination of the last inner SingleSource will emit that error as is or wrapped into a CompositeException along with the other possible errors the former inner SingleSources signaled.

Scheduler:

switchMapSingleDelayError does not operate by default on a particular Scheduler.

History: 2.0.8 - experimental

Type Parameters:

R - the element type of the inner SingleSources and the output

Parameters:

mapper - a function that, when applied to an item emitted by the current Observable, returns a SingleSource

Returns:

the new Observable instance

Throws:

NullPointerException - if mapper is null

Since:

2.2

See Also:

ReactiveX operators documentation: FlatMap, switchMapSingle(Function)

switchMapDelayError

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final <R> @NonNull Observable<R> switchMapDelayError(@NonNull Function<? super T,? extends ObservableSource<? extends R>> mapper)

Returns a new Observable by applying a function that you supply to each item emitted by the current Observable that returns an ObservableSource, and then emitting the items emitted by the most recently emitted of these ObservableSources and delays any error until all ObservableSources terminate.

The resulting Observable completes if both the current Observable and the last inner ObservableSource, if any, complete. If the current Observable signals an onError, the termination of the last inner ObservableSource will emit that error as is or wrapped into a CompositeException along with the other possible errors the former inner ObservableSources signaled.

Scheduler:

switchMapDelayError does not operate by default on a particular Scheduler.

Type Parameters:

R - the element type of the inner ObservableSources and the output

Parameters:

mapper - a function that, when applied to an item emitted by the current Observable, returns an ObservableSource

Returns:

the new Observable instance

Throws:

NullPointerException - if mapper is null

Since:

2.0

See Also:

ReactiveX operators documentation: FlatMap, switchMap(Function)

switchMapDelayError

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final <R> @NonNull Observable<R> switchMapDelayError(@NonNull Function<? super T,? extends ObservableSource<? extends R>> mapper,
        int bufferSize)

Returns a new Observable by applying a function that you supply to each item emitted by the current Observable that returns an ObservableSource, and then emitting the items emitted by the most recently emitted of these ObservableSources and delays any error until all ObservableSources terminate.

The resulting Observable completes if both the current Observable and the last inner ObservableSource, if any, complete. If the current Observable signals an onError, the termination of the last inner ObservableSource will emit that error as is or wrapped into a CompositeException along with the other possible errors the former inner ObservableSources signaled.

Scheduler:

switchMapDelayError does not operate by default on a particular Scheduler.

Type Parameters:

R - the element type of the inner ObservableSources and the output

Parameters:

mapper - a function that, when applied to an item emitted by the current Observable, returns an ObservableSource

bufferSize - the number of elements expected from the current active inner ObservableSource to be buffered

Returns:

the new Observable instance

Throws:

NullPointerException - if mapper is null

IllegalArgumentException - if bufferSize is non-positive

Since:

2.0

See Also:

ReactiveX operators documentation: FlatMap, switchMap(Function, int)

take

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Observable<T> take(long count)

Returns an Observable that emits only the first count items emitted by the current Observable. If the source emits fewer than count items then all of its items are emitted.

This method returns an Observable that will invoke a subscribing Observer's onNext function a maximum of count times before invoking onComplete.

Taking 0 items from the current Observable will still subscribe to it, allowing the subscription-time side-effects to happen there, but will be immediately disposed and the downstream completed without any item emission.

Scheduler:

This version of take does not operate by default on a particular Scheduler.

Parameters:

count - the maximum number of items to emit

Returns:

the new Observable instance

Throws:

IllegalArgumentException - if count is negative

See Also:

ReactiveX operators documentation: Take

take

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Observable<T> take(long time,
        @NonNull TimeUnit unit)

Returns an Observable that emits those items emitted by the current Observable before a specified time runs out.

If time runs out before the Observable completes normally, the onComplete event will be signaled on the default computation Scheduler.

Scheduler:

This version of take operates by default on the computation Scheduler.

Parameters:

time - the length of the time window

unit - the time unit of time

Returns:

the new Observable instance

Throws:

NullPointerException - if unit is null

See Also:

ReactiveX operators documentation: Take

take

@CheckReturnValue
 @SchedulerSupport(value="custom")
 @NonNull
public final @NonNull Observable<T> take(long time,
        @NonNull TimeUnit unit,
        @NonNull Scheduler scheduler)

Returns an Observable that emits those items emitted by the current Observable before a specified time (on a specified Scheduler) runs out.

If time runs out before the Observable completes normally, the onComplete event will be signaled on the provided Scheduler.

Scheduler:

You specify which Scheduler this operator will use.

Parameters:

time - the length of the time window

unit - the time unit of time

scheduler - the Scheduler used for time source

Returns:

the new Observable instance

Throws:

NullPointerException - if unit or scheduler is null

See Also:

ReactiveX operators documentation: Take

takeLast

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Observable<T> takeLast(int count)

Returns an Observable that emits at most the last count items emitted by the current Observable. If the source emits fewer than count items then all of its items are emitted.

Scheduler:

This version of takeLast does not operate by default on a particular Scheduler.

Parameters:

count - the maximum number of items to emit from the end of the sequence of items emitted by the current Observable

Returns:

the new Observable instance

Throws:

IllegalArgumentException - if count is negative

See Also:

ReactiveX operators documentation: TakeLast

takeLast

@CheckReturnValue
 @SchedulerSupport(value="io.reactivex:trampoline")
 @NonNull
public final @NonNull Observable<T> takeLast(long count,
        long time,
        @NonNull TimeUnit unit)

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

Scheduler:

takeLast does not operate on any particular scheduler but uses the current time from the trampoline Scheduler.

Parameters:

count - the maximum number of items to emit

time - the length of the time window

unit - the time unit of time

Returns:

the new Observable instance

Throws:

NullPointerException - if unit is null

IllegalArgumentException - if count is negative

See Also:

ReactiveX operators documentation: TakeLast

takeLast

@CheckReturnValue
 @SchedulerSupport(value="custom")
 @NonNull
public final @NonNull Observable<T> takeLast(long count,
        long time,
        @NonNull TimeUnit unit,
        @NonNull Scheduler scheduler)

Returns an Observable that emits at most a specified number of items from the current Observable that were emitted in a specified window of time before the current Observable completed, where the timing information is provided by a given Scheduler.

Scheduler:

You specify which Scheduler this operator will use for tracking the current time

Parameters:

count - the maximum number of items to emit

time - the length of the time window

unit - the time unit of time

scheduler - the Scheduler that provides the timestamps for the observed items

Returns:

the new Observable instance

Throws:

NullPointerException - if unit or scheduler is null

IllegalArgumentException - if count is negative

See Also:

ReactiveX operators documentation: TakeLast

takeLast

@CheckReturnValue
 @SchedulerSupport(value="custom")
 @NonNull
public final @NonNull Observable<T> takeLast(long count,
        long time,
        @NonNull TimeUnit unit,
        @NonNull Scheduler scheduler,
        boolean delayError,
        int bufferSize)

Returns an Observable that emits at most a specified number of items from the current Observable that were emitted in a specified window of time before the current Observable completed, where the timing information is provided by a given Scheduler.

Scheduler:

You specify which Scheduler this operator will use for tracking the current time

Parameters:

count - the maximum number of items to emit

time - the length of the time window

unit - the time unit of time

scheduler - the Scheduler that provides the timestamps for the observed items

delayError - if true, an exception signaled by the current Observable is delayed until the regular elements are consumed by the downstream; if false, an exception is immediately signaled and all regular elements dropped

bufferSize - the hint about how many elements to expect to be last

Returns:

the new Observable instance

Throws:

NullPointerException - if unit or scheduler is null

IllegalArgumentException - if count is negative or bufferSize is non-positive

See Also:

ReactiveX operators documentation: TakeLast

takeLast

@CheckReturnValue
 @SchedulerSupport(value="io.reactivex:trampoline")
 @NonNull
public final @NonNull Observable<T> takeLast(long time,
        @NonNull TimeUnit unit)

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

Scheduler:

takeLast does not operate on any particular scheduler but uses the current time from the trampoline Scheduler.

Parameters:

time - the length of the time window

unit - the time unit of time

Returns:

the new Observable instance

Throws:

NullPointerException - if unit is null

See Also:

ReactiveX operators documentation: TakeLast

takeLast

@CheckReturnValue
 @SchedulerSupport(value="io.reactivex:trampoline")
 @NonNull
public final @NonNull Observable<T> takeLast(long time,
        @NonNull TimeUnit unit,
        boolean delayError)

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

Scheduler:

takeLast does not operate on any particular scheduler but uses the current time from the trampoline Scheduler.

Parameters:

time - the length of the time window

unit - the time unit of time

delayError - if true, an exception signaled by the current Observable is delayed until the regular elements are consumed by the downstream; if false, an exception is immediately signaled and all regular elements dropped

Returns:

the new Observable instance

Throws:

NullPointerException - if unit is null

IllegalArgumentException - if count is non-positive

See Also:

ReactiveX operators documentation: TakeLast

takeLast

@CheckReturnValue
 @SchedulerSupport(value="custom")
 @NonNull
public final @NonNull Observable<T> takeLast(long time,
        @NonNull TimeUnit unit,
        @NonNull Scheduler scheduler)

Returns an Observable that emits the items from the current Observable that were emitted in a specified window of time before the current Observable completed, where the timing information is provided by a specified Scheduler.

Scheduler:

You specify which Scheduler this operator will use.

Parameters:

time - the length of the time window

unit - the time unit of time

scheduler - the Scheduler that provides the timestamps for the observed items

Returns:

the new Observable instance

Throws:

NullPointerException - if unit or scheduler is null

See Also:

ReactiveX operators documentation: TakeLast

takeLast

@CheckReturnValue
 @SchedulerSupport(value="custom")
 @NonNull
public final @NonNull Observable<T> takeLast(long time,
        @NonNull TimeUnit unit,
        @NonNull Scheduler scheduler,
        boolean delayError)

Returns an Observable that emits the items from the current Observable that were emitted in a specified window of time before the current Observable completed, where the timing information is provided by a specified Scheduler.

Scheduler:

You specify which Scheduler this operator will use.

Parameters:

time - the length of the time window

unit - the time unit of time

scheduler - the Scheduler that provides the timestamps for the observed items

delayError - if true, an exception signaled by the current Observable is delayed until the regular elements are consumed by the downstream; if false, an exception is immediately signaled and all regular elements dropped

Returns:

the new Observable instance

Throws:

NullPointerException - if unit or scheduler is null

See Also:

ReactiveX operators documentation: TakeLast

takeLast

@CheckReturnValue
 @SchedulerSupport(value="custom")
 @NonNull
public final @NonNull Observable<T> takeLast(long time,
        @NonNull TimeUnit unit,
        @NonNull Scheduler scheduler,
        boolean delayError,
        int bufferSize)

Returns an Observable that emits the items from the current Observable that were emitted in a specified window of time before the current Observable completed, where the timing information is provided by a specified Scheduler.

Scheduler:

You specify which Scheduler this operator will use.

Parameters:

time - the length of the time window

unit - the time unit of time

scheduler - the Scheduler that provides the timestamps for the observed items

delayError - if true, an exception signaled by the current Observable is delayed until the regular elements are consumed by the downstream; if false, an exception is immediately signaled and all regular elements dropped

bufferSize - the hint about how many elements to expect to be last

Returns:

the new Observable instance

Throws:

NullPointerException - if unit or scheduler is null

IllegalArgumentException - if bufferSize is non-positive

See Also:

ReactiveX operators documentation: TakeLast

takeUntil

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final <U> @NonNull Observable<T> takeUntil(@NonNull ObservableSource<U> other)

Returns an Observable that emits the items emitted by the current Observable until a second ObservableSource emits an item or completes.

Scheduler:

takeUntil does not operate by default on a particular Scheduler.

Type Parameters:

U - the type of items emitted by other

Parameters:

other - the ObservableSource whose first emitted item or completion will cause takeUntil to stop emitting items from the current Observable

Returns:

the new Observable instance

Throws:

NullPointerException - if other is null

See Also:

ReactiveX operators documentation: TakeUntil

takeUntil

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Observable<T> takeUntil(@NonNull Predicate<? super T> stopPredicate)

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

The difference between this operator and takeWhile(Predicate) is that here, the condition is evaluated after the item is emitted.

Scheduler:

takeUntil does not operate by default on a particular Scheduler.

Parameters:

stopPredicate - a function that evaluates an item emitted by the current Observable and returns a Boolean

Returns:

the new Observable instance

Throws:

NullPointerException - if stopPredicate is null

Since:

1.1.0

See Also:

ReactiveX operators documentation: TakeUntil, takeWhile(Predicate)

takeWhile

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Observable<T> takeWhile(@NonNull Predicate<? super T> predicate)

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

Scheduler:

takeWhile does not operate by default on a particular Scheduler.

Parameters:

predicate - a function that evaluates an item emitted by the current Observable and returns a Boolean

Returns:

the new Observable instance

Throws:

NullPointerException - if predicate is null

See Also:

ReactiveX operators documentation: TakeWhile, takeUntil(Predicate)

throttleFirst

@CheckReturnValue
 @SchedulerSupport(value="io.reactivex:computation")
 @NonNull
public final @NonNull Observable<T> throttleFirst(long windowDuration,
        @NonNull TimeUnit unit)

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

This differs from throttleLast(long, java.util.concurrent.TimeUnit) in that this only tracks passage of time whereas throttleLast ticks at scheduled intervals.

Scheduler:

throttleFirst operates by default on the computation Scheduler.

Parameters:

windowDuration - time to wait before emitting another item after emitting the last item

unit - the unit of time of windowDuration

Returns:

the new Observable instance

Throws:

NullPointerException - if unit is null

See Also:

ReactiveX operators documentation: Sample

throttleFirst

@CheckReturnValue
 @SchedulerSupport(value="custom")
 @NonNull
public final @NonNull Observable<T> throttleFirst(long skipDuration,
        @NonNull TimeUnit unit,
        @NonNull Scheduler scheduler)

Returns an Observable that emits only the first item emitted by the current Observable during sequential time windows of a specified duration, where the windows are managed by a specified Scheduler.

This differs from throttleLast(long, java.util.concurrent.TimeUnit) in that this only tracks passage of time whereas throttleLast ticks at scheduled intervals.

Scheduler:

You specify which Scheduler this operator will use.

Parameters:

skipDuration - time to wait before emitting another item after emitting the last item

unit - the unit of time of skipDuration

scheduler - the Scheduler to use internally to manage the timers that handle timeout for each event

Returns:

the new Observable instance

Throws:

NullPointerException - if unit or scheduler is null

See Also:

ReactiveX operators documentation: Sample

throttleFirst

@CheckReturnValue
 @SchedulerSupport(value="custom")
 @NonNull
public final @NonNull Observable<T> throttleFirst(long skipDuration,
        @NonNull TimeUnit unit,
        @NonNull Scheduler scheduler,
        @NonNull Consumer<? super T> onDropped)

Returns an Observable that emits only the first item emitted by the current Observable during sequential time windows of a specified duration, where the windows are managed by a specified Scheduler.

This differs from throttleLast(long, java.util.concurrent.TimeUnit) in that this only tracks passage of time whereas throttleLast ticks at scheduled intervals.

Scheduler:

You specify which Scheduler this operator will use.

Parameters:

skipDuration - time to wait before emitting another item after emitting the last item

unit - the unit of time of skipDuration

scheduler - the Scheduler to use internally to manage the timers that handle timeout for each event

onDropped - called when an item doesn't get delivered to the downstream

Returns:

the new Observable instance

Throws:

NullPointerException - if unit or scheduler or onDropped is null

Since:

3.1.6 - Experimental

See Also:

ReactiveX operators documentation: Sample

throttleLast

@CheckReturnValue
 @SchedulerSupport(value="io.reactivex:computation")
 @NonNull
public final @NonNull Observable<T> throttleLast(long intervalDuration,
        @NonNull TimeUnit unit)

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

This differs from throttleFirst(long, java.util.concurrent.TimeUnit) in that this ticks along at a scheduled interval whereas throttleFirst does not tick, it just tracks passage of time.

Scheduler:

throttleLast operates by default on the computation Scheduler.

Parameters:

intervalDuration - duration of windows within which the last item emitted by the current Observable will be emitted

unit - the unit of time of intervalDuration

Returns:

the new Observable instance

Throws:

NullPointerException - if unit is null

See Also:

ReactiveX operators documentation: Sample, sample(long, TimeUnit)

throttleLast

@CheckReturnValue
 @SchedulerSupport(value="custom")
 @NonNull
public final @NonNull Observable<T> throttleLast(long intervalDuration,
        @NonNull TimeUnit unit,
        @NonNull Scheduler scheduler,
        @NonNull Consumer<? super T> onDropped)

Returns an Observable that emits only the last item emitted by the current Observable during sequential time windows of a specified duration, where the duration is governed by a specified Scheduler.

This differs from throttleFirst(long, java.util.concurrent.TimeUnit) in that this ticks along at a scheduled interval whereas throttleFirst does not tick, it just tracks passage of time.

Scheduler:

You specify which Scheduler this operator will use.

Parameters:

intervalDuration - duration of windows within which the last item emitted by the current Observable will be emitted

unit - the unit of time of intervalDuration

scheduler - the Scheduler to use internally to manage the timers that handle timeout for each event

onDropped - called with the current entry when it has been replaced by a new one

Returns:

the new Observable instance

Throws:

NullPointerException - if unit or scheduler is null or onDropped is null

Since:

3.1.6 - Experimental

See Also:

ReactiveX operators documentation: Sample, sample(long, TimeUnit, Scheduler)

throttleLast

@CheckReturnValue
 @SchedulerSupport(value="custom")
 @NonNull
public final @NonNull Observable<T> throttleLast(long intervalDuration,
        @NonNull TimeUnit unit,
        @NonNull Scheduler scheduler)

Returns an Observable that emits only the last item emitted by the current Observable during sequential time windows of a specified duration, where the duration is governed by a specified Scheduler.

This differs from throttleFirst(long, java.util.concurrent.TimeUnit) in that this ticks along at a scheduled interval whereas throttleFirst does not tick, it just tracks passage of time.

Scheduler:

You specify which Scheduler this operator will use.

Parameters:

intervalDuration - duration of windows within which the last item emitted by the current Observable will be emitted

unit - the unit of time of intervalDuration

scheduler - the Scheduler to use internally to manage the timers that handle timeout for each event

Returns:

the new Observable instance

Throws:

NullPointerException - if unit or scheduler is null

See Also:

ReactiveX operators documentation: Sample, sample(long, TimeUnit, Scheduler)

throttleLatest

@CheckReturnValue
 @SchedulerSupport(value="io.reactivex:computation")
 @NonNull
public final @NonNull Observable<T> throttleLatest(long timeout,
        @NonNull TimeUnit unit)

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

Unlike the option with throttleLatest(long, TimeUnit, boolean), the very last item being held back (if any) is not emitted when the upstream completes.

If no items were emitted from the upstream during this timeout phase, the next upstream item is emitted immediately and the timeout window starts from then.

Scheduler:

throttleLatest operates by default on the computation Scheduler.

History: 2.1.14 - experimental

Parameters:

timeout - the time to wait after an item emission towards the downstream before trying to emit the latest item from upstream again

unit - the time unit

Returns:

the new Observable instance

Throws:

NullPointerException - if unit is null

Since:

2.2

See Also:

throttleLatest(long, TimeUnit, boolean), throttleLatest(long, TimeUnit, Scheduler)

throttleLatest

@CheckReturnValue
 @SchedulerSupport(value="io.reactivex:computation")
 @NonNull
public final @NonNull Observable<T> throttleLatest(long timeout,
        @NonNull TimeUnit unit,
        boolean emitLast)

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

If no items were emitted from the upstream during this timeout phase, the next upstream item is emitted immediately and the timeout window starts from then.

Scheduler:

throttleLatest operates by default on the computation Scheduler.

History: 2.1.14 - experimental

Parameters:

timeout - the time to wait after an item emission towards the downstream before trying to emit the latest item from upstream again

unit - the time unit

emitLast - If true, the very last item from the upstream will be emitted immediately when the upstream completes, regardless if there is a timeout window active or not. If false, the very last upstream item is ignored and the flow terminates.

Returns:

the new Observable instance

Throws:

NullPointerException - if unit is null

Since:

2.2

See Also:

throttleLatest(long, TimeUnit, Scheduler, boolean)

throttleLatest

@CheckReturnValue
 @SchedulerSupport(value="custom")
 @NonNull
public final @NonNull Observable<T> throttleLatest(long timeout,
        @NonNull TimeUnit unit,
        @NonNull Scheduler scheduler)

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

Unlike the option with throttleLatest(long, TimeUnit, Scheduler, boolean), the very last item being held back (if any) is not emitted when the upstream completes.

If no items were emitted from the upstream during this timeout phase, the next upstream item is emitted immediately and the timeout window starts from then.

Scheduler:

You specify which Scheduler this operator will use.

History: 2.1.14 - experimental

Parameters:

timeout - the time to wait after an item emission towards the downstream before trying to emit the latest item from upstream again

unit - the time unit

scheduler - the Scheduler where the timed wait and latest item emission will be performed

Returns:

the new Observable instance

Throws:

NullPointerException - if unit or scheduler is null

Since:

2.2

See Also:

throttleLatest(long, TimeUnit, Scheduler, boolean)

throttleLatest

@CheckReturnValue
 @SchedulerSupport(value="custom")
 @NonNull
public final @NonNull Observable<T> throttleLatest(long timeout,
        @NonNull TimeUnit unit,
        @NonNull Scheduler scheduler,
        boolean emitLast)

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

If no items were emitted from the upstream during this timeout phase, the next upstream item is emitted immediately and the timeout window starts from then.

Scheduler:

You specify which Scheduler this operator will use.

History: 2.1.14 - experimental

Parameters:

timeout - the time to wait after an item emission towards the downstream before trying to emit the latest item from upstream again

unit - the time unit

scheduler - the Scheduler where the timed wait and latest item emission will be performed

emitLast - If true, the very last item from the upstream will be emitted immediately when the upstream completes, regardless if there is a timeout window active or not. If false, the very last upstream item is ignored and the flow terminates.

Returns:

the new Observable instance

Throws:

NullPointerException - if unit or scheduler is null

Since:

2.2

throttleLatest

@CheckReturnValue
 @SchedulerSupport(value="custom")
 @NonNull
public final @NonNull Observable<T> throttleLatest(long timeout,
        @NonNull TimeUnit unit,
        @NonNull Scheduler scheduler,
        boolean emitLast,
        @NonNull Consumer<? super T> onDropped)

Throttles items from the current Observable 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.

If no items were emitted from the upstream during this timeout phase, the next upstream item is emitted immediately and the timeout window starts from then.

Scheduler:

You specify which Scheduler this operator will use.

Error handling:

If the upstream signals an onError or onDropped callback crashes, the error is delivered immediately to the downstream. If both happen, a CompositeException is created, containing both the upstream and the callback error. If the onDropped callback crashes when the sequence gets disposed, the exception is forwarded to the global error handler via RxJavaPlugins.onError(Throwable).

Parameters:

timeout - the time to wait after an item emission towards the downstream before trying to emit the latest item from upstream again

unit - the time unit

scheduler - the Scheduler where the timed wait and latest item emission will be performed

emitLast - If true, the very last item from the upstream will be emitted immediately when the upstream completes, regardless if there is a timeout window active or not. If false, the very last upstream item is ignored and the flow terminates.

onDropped - called when an item is replaced by a newer item that doesn't get delivered to the downstream, including the very last item if emitLast is false and the current undelivered item when the sequence gets disposed.

Returns:

the new Observable instance

Throws:

NullPointerException - if unit, scheduler or onDropped is null

Since:

3.1.6 - Experimental

throttleWithTimeout

@CheckReturnValue
 @SchedulerSupport(value="io.reactivex:computation")
 @NonNull
public final @NonNull Observable<T> throttleWithTimeout(long timeout,
        @NonNull TimeUnit unit)

Returns an Observable that mirrors the current Observable, except that it drops items emitted by the current Observable that are followed by newer items before a timeout value expires. The timer resets on each emission (alias to debounce(long, TimeUnit, Scheduler)).

Note: If items keep being emitted by the current Observable faster than the timeout then no items will be emitted by the resulting Observable.

Scheduler:

throttleWithTimeout operates by default on the computation Scheduler.

Parameters:

timeout - the length of the window of time that must pass after the emission of an item from the current Observable, in which the current Observable emits no items, in order for the item to be emitted by the resulting Observable

unit - the unit of time for the specified timeout

Returns:

the new Observable instance

Throws:

NullPointerException - if unit is null

See Also:

ReactiveX operators documentation: Debounce, debounce(long, TimeUnit)

throttleWithTimeout

@CheckReturnValue
 @SchedulerSupport(value="custom")
 @NonNull
public final @NonNull Observable<T> throttleWithTimeout(long timeout,
        @NonNull TimeUnit unit,
        @NonNull Scheduler scheduler)

Returns an Observable that mirrors the current Observable, except that it drops items emitted by the current Observable that are followed by newer items before a timeout value expires on a specified Scheduler. The timer resets on each emission (Alias to debounce(long, TimeUnit, Scheduler)).

Note: If items keep being emitted by the current Observable faster than the timeout then no items will be emitted by the resulting Observable.

Scheduler:

You specify which Scheduler this operator will use.

Parameters:

timeout - the length of the window of time that must pass after the emission of an item from the current Observable, in which the current Observable emits no items, in order for the item to be emitted by the resulting Observable

unit - the unit of time for the specified timeout

scheduler - the Scheduler to use internally to manage the timers that handle the timeout for each item

Returns:

the new Observable instance

Throws:

NullPointerException - if unit or scheduler is null

See Also:

ReactiveX operators documentation: Debounce, debounce(long, TimeUnit, Scheduler)

throttleWithTimeout

@CheckReturnValue
 @SchedulerSupport(value="custom")
 @NonNull
public final @NonNull Observable<T> throttleWithTimeout(long timeout,
        @NonNull TimeUnit unit,
        @NonNull Scheduler scheduler,
        @NonNull Consumer<? super T> onDropped)

Returns an Observable that mirrors the current Observable, except that it drops items emitted by the current Observable that are followed by newer items before a timeout value expires on a specified Scheduler. The timer resets on each emission (Alias to debounce(long, TimeUnit, Scheduler)).

Note: If items keep being emitted by the current Observable faster than the timeout then no items will be emitted by the resulting Observable.

Scheduler:

You specify which Scheduler this operator will use.

Parameters:

timeout - the length of the window of time that must pass after the emission of an item from the current Observable, in which the current Observable emits no items, in order for the item to be emitted by the resulting Observable

unit - the unit of time for the specified timeout

scheduler - the Scheduler to use internally to manage the timers that handle the timeout for each item

onDropped - called with the current entry when it has been replaced by a new one

Returns:

the new Observable instance

Throws:

NullPointerException - if unit or scheduler is null or onDropped is null

Since:

3.1.6 - Experimental

See Also:

ReactiveX operators documentation: Debounce, debounce(long, TimeUnit, Scheduler, Consumer)

timeInterval

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Observable<Timed<T>> timeInterval()

Returns an Observable that emits records of the time interval between consecutive items emitted by the current Observable.

Scheduler:

timeInterval does not operate on any particular scheduler but uses the current time from the computation Scheduler.

Returns:

the new Observable instance

See Also:

ReactiveX operators documentation: TimeInterval

timeInterval

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Observable<Timed<T>> timeInterval(@NonNull Scheduler scheduler)

Returns an Observable that emits records of the time interval between consecutive items emitted by the current Observable, where this interval is computed on a specified Scheduler.

Scheduler:

The operator does not operate on any particular scheduler but uses the current time from the specified Scheduler.

Parameters:

scheduler - the Scheduler used to compute time intervals

Returns:

the new Observable instance

Throws:

NullPointerException - if scheduler is null

See Also:

ReactiveX operators documentation: TimeInterval

timeInterval

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Observable<Timed<T>> timeInterval(@NonNull TimeUnit unit)

Returns an Observable that emits records of the time interval between consecutive items emitted by the current Observable.

Scheduler:

timeInterval does not operate on any particular scheduler but uses the current time from the computation Scheduler.

Parameters:

unit - the time unit for the current time

Returns:

the new Observable instance

Throws:

NullPointerException - if unit is null

See Also:

ReactiveX operators documentation: TimeInterval

timeInterval

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Observable<Timed<T>> timeInterval(@NonNull TimeUnit unit,
        @NonNull Scheduler scheduler)

Returns an Observable that emits records of the time interval between consecutive items emitted by the current Observable, where this interval is computed on a specified Scheduler.

Scheduler:

The operator does not operate on any particular scheduler but uses the current time from the specified Scheduler.

Parameters:

unit - the time unit for the current time

scheduler - the Scheduler used to compute time intervals

Returns:

the new Observable instance

Throws:

NullPointerException - if unit or scheduler is null

See Also:

ReactiveX operators documentation: TimeInterval

timeout

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final <V> @NonNull Observable<T> timeout(@NonNull Function<? super T,? extends ObservableSource<V>> itemTimeoutIndicator)

Returns an Observable that mirrors the current Observable, but notifies observers of a TimeoutException if an item emitted by the current Observable doesn't arrive within a window of time after the emission of the previous item, where that period of time is measured by an ObservableSource that is a function of the previous item.

Note: The arrival of the first source item is never timed out.

Scheduler:

This version of timeout operates by default on the immediate Scheduler.

Type Parameters:

V - the timeout value type (ignored)

Parameters:

itemTimeoutIndicator - a function that returns an ObservableSource for each item emitted by the current Observable and that determines the timeout window for the subsequent item

Returns:

the new Observable instance

Throws:

NullPointerException - if itemTimeoutIndicator is null

See Also:

ReactiveX operators documentation: Timeout

timeout

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final <V> @NonNull Observable<T> timeout(@NonNull Function<? super T,? extends ObservableSource<V>> itemTimeoutIndicator,
        @NonNull ObservableSource<? extends T> fallback)

Returns an Observable that mirrors the current Observable, but that switches to a fallback ObservableSource if an item emitted by the current Observable doesn't arrive within a window of time after the emission of the previous item, where that period of time is measured by an ObservableSource that is a function of the previous item.

Note: The arrival of the first source item is never timed out.

Scheduler:

This version of timeout operates by default on the immediate Scheduler.

Type Parameters:

V - the timeout value type (ignored)

Parameters:

itemTimeoutIndicator - a function that returns an ObservableSource, for each item emitted by the current Observable, that determines the timeout window for the subsequent item

fallback - the fallback ObservableSource to switch to if the current Observable times out

Returns:

the new Observable instance

Throws:

NullPointerException - if itemTimeoutIndicator or fallback is null

See Also:

ReactiveX operators documentation: Timeout

timeout

@CheckReturnValue
 @SchedulerSupport(value="io.reactivex:computation")
 @NonNull
public final @NonNull Observable<T> timeout(long timeout,
        @NonNull TimeUnit unit)

Returns an Observable that mirrors the current Observable but applies a timeout policy for each emitted item. If the next item isn't emitted within the specified timeout duration starting from its predecessor, the resulting Observable terminates and notifies observers of a TimeoutException.

Scheduler:

This version of timeout operates by default on the computation Scheduler.

Parameters:

timeout - maximum duration between emitted items before a timeout occurs

unit - the unit of time that applies to the timeout argument.

Returns:

the new Observable instance

Throws:

NullPointerException - if unit is null

See Also:

ReactiveX operators documentation: Timeout

timeout

@CheckReturnValue
 @SchedulerSupport(value="io.reactivex:computation")
 @NonNull
public final @NonNull Observable<T> timeout(long timeout,
        @NonNull TimeUnit unit,
        @NonNull ObservableSource<? extends T> fallback)

Returns an Observable that mirrors the current Observable but applies a timeout policy for each emitted item. If the next item isn't emitted within the specified timeout duration starting from its predecessor, the current Observable is disposed and the resulting Observable begins instead to mirror a fallback ObservableSource.

Scheduler:

This version of timeout operates by default on the computation Scheduler.

Parameters:

timeout - maximum duration between items before a timeout occurs

unit - the unit of time that applies to the timeout argument

fallback - the fallback ObservableSource to use in case of a timeout

Returns:

the new Observable instance

Throws:

NullPointerException - if unit or fallback is null

See Also:

ReactiveX operators documentation: Timeout

timeout

@CheckReturnValue
 @SchedulerSupport(value="custom")
 @NonNull
public final @NonNull Observable<T> timeout(long timeout,
        @NonNull TimeUnit unit,
        @NonNull Scheduler scheduler,
        @NonNull ObservableSource<? extends T> fallback)

Returns an Observable that mirrors the current Observable but applies a timeout policy for each emitted item using a specified Scheduler. If the next item isn't emitted within the specified timeout duration starting from its predecessor, the current Observable is disposed and returned Observable begins instead to mirror a fallback ObservableSource.

Scheduler:

You specify which Scheduler this operator will use.

Parameters:

timeout - maximum duration between items before a timeout occurs

unit - the unit of time that applies to the timeout argument

scheduler - the Scheduler to run the timeout timers on

fallback - the ObservableSource to use as the fallback in case of a timeout

Returns:

the new Observable instance

Throws:

NullPointerException - if unit, scheduler or fallback is null

See Also:

ReactiveX operators documentation: Timeout

timeout

@CheckReturnValue
 @SchedulerSupport(value="custom")
 @NonNull
public final @NonNull Observable<T> timeout(long timeout,
        @NonNull TimeUnit unit,
        @NonNull Scheduler scheduler)

Returns an Observable that mirrors the current Observable but applies a timeout policy for each emitted item, where this policy is governed on a specified Scheduler. If the next item isn't emitted within the specified timeout duration starting from its predecessor, the resulting Observable terminates and notifies observers of a TimeoutException.

Scheduler:

You specify which Scheduler this operator will use.

Parameters:

timeout - maximum duration between items before a timeout occurs

unit - the unit of time that applies to the timeout argument

scheduler - the Scheduler to run the timeout timers on

Returns:

the new Observable instance

Throws:

NullPointerException - if unit or scheduler is null

See Also:

ReactiveX operators documentation: Timeout

timeout

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final <U,V> @NonNull Observable<T> timeout(@NonNull ObservableSource<U> firstTimeoutIndicator,
        @NonNull Function<? super T,? extends ObservableSource<V>> itemTimeoutIndicator)

Returns an Observable that mirrors the current Observable, but notifies observers of a TimeoutException if either the first item emitted by the current Observable or any subsequent item doesn't arrive within time windows defined by indicator ObservableSources.

Scheduler:

This version of timeout operates by default on the immediate Scheduler.

Type Parameters:

U - the first timeout value type (ignored)

V - the subsequent timeout value type (ignored)

Parameters:

firstTimeoutIndicator - a function that returns an ObservableSource that determines the timeout window for the first source item

itemTimeoutIndicator - a function that returns an ObservableSource for each item emitted by the current Observable and that determines the timeout window in which the subsequent source item must arrive in order to continue the sequence

Returns:

the new Observable instance

Throws:

NullPointerException - if firstTimeoutIndicator or itemTimeoutIndicator is null

See Also:

ReactiveX operators documentation: Timeout

timeout

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final <U,V> @NonNull Observable<T> timeout(@NonNull ObservableSource<U> firstTimeoutIndicator,
        @NonNull Function<? super T,? extends ObservableSource<V>> itemTimeoutIndicator,
        @NonNull ObservableSource<? extends T> fallback)

Returns an Observable that mirrors the current Observable, but switches to a fallback ObservableSource if either the first item emitted by the current Observable or any subsequent item doesn't arrive within time windows defined by indicator ObservableSources.

Scheduler:

This version of timeout operates by default on the immediate Scheduler.

Type Parameters:

U - the first timeout value type (ignored)

V - the subsequent timeout value type (ignored)

Parameters:

firstTimeoutIndicator - a function that returns an ObservableSource which determines the timeout window for the first source item

itemTimeoutIndicator - a function that returns an ObservableSource for each item emitted by the current Observable and that determines the timeout window in which the subsequent source item must arrive in order to continue the sequence

fallback - the fallback ObservableSource to switch to if the current Observable times out

Returns:

the new Observable instance

Throws:

NullPointerException - if firstTimeoutIndicator, itemTimeoutIndicator or fallback is null

See Also:

ReactiveX operators documentation: Timeout

timestamp

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Observable<Timed<T>> timestamp()

Returns an Observable that emits each item emitted by the current Observable, wrapped in a Timed object.

Scheduler:

timestamp does not operate on any particular scheduler but uses the current time from the computation Scheduler.

Returns:

the new Observable instance

See Also:

ReactiveX operators documentation: Timestamp

timestamp

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Observable<Timed<T>> timestamp(@NonNull Scheduler scheduler)

Returns an Observable that emits each item emitted by the current Observable, wrapped in a Timed object whose timestamps are provided by a specified Scheduler.

Scheduler:

This operator does not operate on any particular scheduler but uses the current time from the specified Scheduler.

Parameters:

scheduler - the Scheduler to use as a time source

Returns:

the new Observable instance

Throws:

NullPointerException - if scheduler is null

See Also:

ReactiveX operators documentation: Timestamp

timestamp

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Observable<Timed<T>> timestamp(@NonNull TimeUnit unit)

Returns an Observable that emits each item emitted by the current Observable, wrapped in a Timed object.

Scheduler:

timestamp does not operate on any particular scheduler but uses the current time from the computation Scheduler.

Parameters:

unit - the time unit for the current time

Returns:

the new Observable instance

Throws:

NullPointerException - if unit is null

See Also:

ReactiveX operators documentation: Timestamp

timestamp

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Observable<Timed<T>> timestamp(@NonNull TimeUnit unit,
        @NonNull Scheduler scheduler)

Returns an Observable that emits each item emitted by the current Observable, wrapped in a Timed object whose timestamps are provided by a specified Scheduler.

Scheduler:

This operator does not operate on any particular scheduler but uses the current time from the specified Scheduler.

Parameters:

unit - the time unit for the current time

scheduler - the Scheduler to use as a time source

Returns:

the new Observable instance

Throws:

NullPointerException - if unit or scheduler is null

See Also:

ReactiveX operators documentation: Timestamp

to

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final <R> R to(@NonNull ObservableConverter<T,? extends R> converter)

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

This allows fluent conversion to any other type.

Scheduler:

to does not operate by default on a particular Scheduler.

History: 2.1.7 - experimental

Type Parameters:

R - the resulting object type

Parameters:

converter - the function that receives the current Observable instance and returns a value

Returns:

the converted value

Throws:

NullPointerException - if converter is null

Since:

2.2

toList

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Single<List<T>> toList()

Returns a Single that emits a single item, a List composed of all the items emitted by the current and finite Observable.

Normally, an ObservableSource that returns multiple items will do so by invoking its Observer's onNext method for each such item. You can change this behavior by having the operator to compose a list of all of these items and then to invoke the SingleObserver's onSuccess method once, passing it the entire list, by calling the Observable's toList method prior to calling its subscribe() method.

Note that this operator requires the upstream to signal onComplete for the accumulated list to be emitted. Sources that are infinite and never complete will never emit anything through this operator and an infinite source may lead to a fatal OutOfMemoryError.

Scheduler:

toList does not operate by default on a particular Scheduler.

Returns:

the new Single instance

See Also:

ReactiveX operators documentation: To

toList

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @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 current and finite Observable.

Normally, an ObservableSource that returns multiple items will do so by invoking its Observer's onNext method for each such item. You can change this behavior by having the operator to compose a list of all of these items and then to invoke the SingleObserver's onSuccess method once, passing it the entire list, by calling the Observable's toList method prior to calling its subscribe() method.

Note that this operator requires the upstream to signal onComplete for the accumulated list to be emitted. Sources that are infinite and never complete will never emit anything through this operator and an infinite source may lead to a fatal OutOfMemoryError.

Scheduler:

toList does not operate by default on a particular Scheduler.

Parameters:

capacityHint - the number of elements expected from the current Observable

Returns:

the new Single instance

Throws:

IllegalArgumentException - if capacityHint is non-positive

See Also:

ReactiveX operators documentation: To

toList

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final <U extends Collection<? super T>> @NonNull Single<U> toList(@NonNull Supplier<U> collectionSupplier)

Returns a Single that emits a single item, a Collection (subclass) composed of all the items emitted by the finite upstream Observable.

Normally, an ObservableSource that returns multiple items will do so by invoking its Observer's onNext method for each such item. You can change this behavior by having the operator to compose a collection of all of these items and then to invoke the SingleObserver's onSuccess method once, passing it the entire collection, by calling the Observable's toList method prior to calling its subscribe() method.

Note that this operator requires the upstream to signal onComplete for the accumulated collection to be emitted. Sources that are infinite and never complete will never emit anything through this operator and an infinite source may lead to a fatal OutOfMemoryError.

Scheduler:

toList does not operate by default on a particular Scheduler.

Type Parameters:

U - the subclass of a collection of Ts

Parameters:

collectionSupplier - the Supplier returning the collection (for each individual Observer) to be filled in

Returns:

the new Single instance

Throws:

NullPointerException - if collectionSupplier is null

See Also:

ReactiveX operators documentation: To

toMap

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final <K> @NonNull Single<Map<K,T>> toMap(@NonNull Function<? super T,? extends K> keySelector)

Returns a Single that emits a single HashMap containing all items emitted by the current and finite Observable, mapped by the keys returned by a specified keySelector function.

If more than one source item maps to the same key, the HashMap will contain the latest of those items.

Note that this operator requires the upstream to signal onComplete for the accumulated HashMap to be emitted. Sources that are infinite and never complete will never emit anything through this operator and an infinite source may lead to a fatal OutOfMemoryError.

Scheduler:

toMap does not operate by default on a particular Scheduler.

Type Parameters:

K - the key type of the Map

Parameters:

keySelector - the function that extracts the key from a source item to be used in the HashMap

Returns:

the new Single instance

Throws:

NullPointerException - if keySelector is null

See Also:

ReactiveX operators documentation: To

toMap

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final <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 HashMap containing values corresponding to items emitted by the current and finite Observable, mapped by the keys and values returned by the given selector functions.

If more than one source item maps to the same key, the HashMap will contain a single entry that corresponds to the latest of those items.

Note that this operator requires the upstream to signal onComplete for the accumulated HashMap to be emitted. Sources that are infinite and never complete will never emit anything through this operator and an infinite source may lead to a fatal OutOfMemoryError.

Scheduler:

toMap does not operate by default on a particular Scheduler.

Type Parameters:

K - the key type of the HashMap

V - the value type of the HashMap

Parameters:

keySelector - the function that extracts the key from a source item to be used in the HashMap

valueSelector - the function that extracts the value from a source item to be used in the HashMap

Returns:

the new Single instance

Throws:

NullPointerException - if keySelector or valueSelector is null

See Also:

ReactiveX operators documentation: To

toMap

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final <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 (subclass), returned by a specified mapFactory function, that contains keys and values extracted from the items, via selector functions, emitted by the current and finite Observable.

Note that this operator requires the upstream to signal onComplete for the accumulated Map to be emitted. Sources that are infinite and never complete will never emit anything through this operator and an infinite source may lead to a fatal OutOfMemoryError.

Scheduler:

toMap does not operate by default on a particular Scheduler.

Type Parameters:

K - the key type of the Map

V - the value type of the Map

Parameters:

keySelector - the function that extracts the key from a source item to be used in the Map

valueSelector - the function that extracts the value from the source items to be used as value in the Map

mapSupplier - the function that returns a Map instance to be used

Returns:

the new Single instance

Throws:

NullPointerException - if keySelector, valueSelector or mapSupplier is null

See Also:

ReactiveX operators documentation: To

toMultimap

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final <K> @NonNull Single<Map<K,Collection<T>>> toMultimap(@NonNull Function<? super T,? extends K> keySelector)

Returns a Single that emits a single HashMap that contains an ArrayList of items emitted by the current and finite Observable keyed by a specified keySelector function.

Note that this operator requires the upstream to signal onComplete for the accumulated HashMap to be emitted. Sources that are infinite and never complete will never emit anything through this operator and an infinite source may lead to a fatal OutOfMemoryError.

Scheduler:

toMultimap does not operate by default on a particular Scheduler.

Type Parameters:

K - the key type of the HashMap

Parameters:

keySelector - the function that extracts the key from the source items to be used as key in the HashMap

Returns:

the new Single instance

Throws:

NullPointerException - if keySelector is null

See Also:

ReactiveX operators documentation: To

toMultimap

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final <K,V> @NonNull Single<Map<K,Collection<V>>> toMultimap(@NonNull Function<? super T,? extends K> keySelector,
        Function<? super T,? extends V> valueSelector)

Returns a Single that emits a single HashMap that contains an ArrayList of values extracted by a specified valueSelector function from items emitted by the current and finite Observable, keyed by a specified keySelector function.

Note that this operator requires the upstream to signal onComplete for the accumulated HashMap to be emitted. Sources that are infinite and never complete will never emit anything through this operator and an infinite source may lead to a fatal OutOfMemoryError.

Scheduler:

toMultimap does not operate by default on a particular Scheduler.

Type Parameters:

K - the key type of the HashMap

V - the value type of the HashMap

Parameters:

keySelector - the function that extracts a key from the source items to be used as key in the HashMap

valueSelector - the function that extracts a value from the source items to be used as value in the HashMap

Returns:

the new Single instance

Throws:

NullPointerException - if keySelector or valueSelector is null

See Also:

ReactiveX operators documentation: To

toMultimap

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final <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 (subclass), returned by a specified mapFactory function, that contains a custom Collection of values, extracted by a specified valueSelector function from items emitted by the current and finite Observable, and keyed by the keySelector function.

Note that this operator requires the upstream to signal onComplete for the accumulated Map to be emitted. Sources that are infinite and never complete will never emit anything through this operator and an infinite source may lead to a fatal OutOfMemoryError.

Scheduler:

toMultimap does not operate by default on a particular Scheduler.

Type Parameters:

K - the key type of the Map

V - the value type of the Map

Parameters:

keySelector - the function that extracts a key from the source items to be used as the key in the Map

valueSelector - the function that extracts a value from the source items to be used as the value in the Map

mapSupplier - the function that returns a Map instance to be used

collectionFactory - the function that returns a Collection instance for a particular key to be used in the Map

Returns:

the new Single instance

Throws:

NullPointerException - if keySelector, valueSelector, mapSupplier or collectionFactory is null

See Also:

ReactiveX operators documentation: To

toMultimap

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final <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 (subclass), returned by a specified mapFactory function, that contains an ArrayList of values, extracted by a specified valueSelector function from items emitted by the current and finite Observable and keyed by the keySelector function.

Note that this operator requires the upstream to signal onComplete for the accumulated Map to be emitted. Sources that are infinite and never complete will never emit anything through this operator and an infinite source may lead to a fatal OutOfMemoryError.

Scheduler:

toMultimap does not operate by default on a particular Scheduler.

Type Parameters:

K - the key type of the Map

V - the value type of the Map

Parameters:

keySelector - the function that extracts a key from the source items to be used as the key in the Map

valueSelector - the function that extracts a value from the source items to be used as the value in the Map

mapSupplier - the function that returns a Map instance to be used

Returns:

the new Single instance

Throws:

NullPointerException - if keySelector, valueSelector or mapSupplier is null

See Also:

ReactiveX operators documentation: To

toFlowable

@BackpressureSupport(value=SPECIAL)
 @CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Flowable<T> toFlowable(@NonNull BackpressureStrategy strategy)

Converts the current Observable into a Flowable by applying the specified backpressure strategy.

Marble diagrams for the various backpressure strategies are as follows:

• BackpressureStrategy.BUFFER

  

• BackpressureStrategy.DROP

  

• BackpressureStrategy.LATEST

  

• BackpressureStrategy.ERROR

  

• BackpressureStrategy.MISSING

  

Backpressure:

The operator applies the chosen backpressure strategy of BackpressureStrategy enum.

Scheduler:

toFlowable does not operate by default on a particular Scheduler.

Parameters:

strategy - the backpressure strategy to apply

Returns:

the new Flowable instance

Throws:

NullPointerException - if strategy is null

toSortedList

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Single<List<T>> toSortedList()

Returns a Single that emits a List that contains the items emitted by the current and finite Observable, in a sorted order. Each item emitted by the current Observable must implement Comparable with respect to all other items in the sequence.

If any item emitted by the current Observable does not implement Comparable with respect to all other items emitted by the current Observable, no items will be emitted and the sequence is terminated with a ClassCastException.

Note that this operator requires the upstream to signal onComplete for the accumulated List to be emitted. Sources that are infinite and never complete will never emit anything through this operator and an infinite source may lead to a fatal OutOfMemoryError.

Scheduler:

toSortedList does not operate by default on a particular Scheduler.

Returns:

the new Single instance

See Also:

ReactiveX operators documentation: To, toSortedList(int), toSortedList(Comparator)

toSortedList

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Single<List<T>> toSortedList(@NonNull Comparator<? super T> comparator)

Returns a Single that emits a List that contains the items emitted by the current and finite Observable, in a sorted order based on a specified comparison function.

Note that this operator requires the upstream to signal onComplete for the accumulated List to be emitted. Sources that are infinite and never complete will never emit anything through this operator and an infinite source may lead to a fatal OutOfMemoryError.

Scheduler:

toSortedList does not operate by default on a particular Scheduler.

Parameters:

comparator - a function that compares two items emitted by the current Observable and returns an int that indicates their sort order

Returns:

the new Single instance

Throws:

NullPointerException - if comparator is null

See Also:

ReactiveX operators documentation: To

toSortedList

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @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 current and finite Observable, in a sorted order based on a specified comparison function.

Note that this operator requires the upstream to signal onComplete for the accumulated List to be emitted. Sources that are infinite and never complete will never emit anything through this operator and an infinite source may lead to a fatal OutOfMemoryError.

Scheduler:

toSortedList does not operate by default on a particular Scheduler.

Parameters:

comparator - a function that compares two items emitted by the current Observable and returns an int that indicates their sort order

capacityHint - the initial capacity of the List used to accumulate items before sorting

Returns:

the new Single instance

Throws:

NullPointerException - if comparator is null

IllegalArgumentException - if capacityHint is non-positive

Since:

2.0

See Also:

ReactiveX operators documentation: To

toSortedList

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Single<List<T>> toSortedList(int capacityHint)

Returns a Single that emits a List that contains the items emitted by the current and finite Observable, in a sorted order. Each item emitted by the current Observable must implement Comparable with respect to all other items in the sequence.

If any item emitted by the current Observable does not implement Comparable with respect to all other items emitted by the current Observable, no items will be emitted and the sequence is terminated with a ClassCastException.

Note that this operator requires the upstream to signal onComplete for the accumulated List to be emitted. Sources that are infinite and never complete will never emit anything through this operator and an infinite source may lead to a fatal OutOfMemoryError.

Scheduler:

toSortedList does not operate by default on a particular Scheduler.

Parameters:

capacityHint - the initial capacity of the List used to accumulate items before sorting

Returns:

the new Single instance

Throws:

IllegalArgumentException - if capacityHint is non-positive

Since:

2.0

See Also:

ReactiveX operators documentation: To, toSortedList(Comparator, int)

unsubscribeOn

@CheckReturnValue
 @SchedulerSupport(value="custom")
 @NonNull
public final @NonNull Observable<T> unsubscribeOn(@NonNull Scheduler scheduler)

Return an Observable that schedules the downstream Observers' dispose calls aimed at the current Observable on the given Scheduler.

Scheduler:

You specify which Scheduler this operator will use.

Parameters:

scheduler - the Scheduler to perform the call to dispose() of the upstream Disposable

Returns:

the new Observable instance

Throws:

NullPointerException - if scheduler is null

See Also:

ReactiveX operators documentation: SubscribeOn

window

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Observable<Observable<T>> window(long count)

Returns an Observable that emits windows of items it collects from the current Observable. The resulting Observable emits connected, non-overlapping windows, each containing count items. When the current Observable completes or encounters an error, the resulting Observable emits the current window and propagates the notification from the current Observable.

Scheduler:

This version of window does not operate by default on a particular Scheduler.

Parameters:

count - the maximum size of each window before it should be emitted

Returns:

the new Observable instance

Throws:

IllegalArgumentException - if count is non-positive

See Also:

ReactiveX operators documentation: Window

window

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Observable<Observable<T>> window(long count,
        long skip)

Returns an Observable that emits windows of items it collects from the current Observable. The resulting Observable emits windows every skip items, each containing no more than count items. When the current Observable completes or encounters an error, the resulting Observable emits the current window and propagates the notification from the current Observable.

Scheduler:

This version of window does not operate by default on a particular Scheduler.

Parameters:

count - the maximum size of each window before it should be emitted

skip - how many items need to be skipped before starting a new window. Note that if skip and count are equal this is the same operation as window(long).

Returns:

the new Observable instance

Throws:

IllegalArgumentException - if count or skip is non-positive

See Also:

ReactiveX operators documentation: Window

window

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Observable<Observable<T>> window(long count,
        long skip,
        int bufferSize)

Returns an Observable that emits windows of items it collects from the current Observable. The resulting Observable emits windows every skip items, each containing no more than count items. When the current Observable completes or encounters an error, the resulting Observable emits the current window and propagates the notification from the current Observable.

Scheduler:

This version of window does not operate by default on a particular Scheduler.

Parameters:

count - the maximum size of each window before it should be emitted

skip - how many items need to be skipped before starting a new window. Note that if skip and count are equal this is the same operation as window(long).

bufferSize - the capacity hint for the buffer in the inner windows

Returns:

the new Observable instance

Throws:

IllegalArgumentException - if count, skip or bufferSize is non-positive

See Also:

ReactiveX operators documentation: Window

window

@CheckReturnValue
 @SchedulerSupport(value="io.reactivex:computation")
 @NonNull
public final @NonNull Observable<Observable<T>> window(long timespan,
        long timeskip,
        @NonNull TimeUnit unit)

Returns an Observable that emits windows of items it collects from the current Observable. The resulting Observable starts a new window periodically, as determined by the timeskip argument. It emits each window after a fixed timespan, specified by the timespan argument. When the current Observable completes or encounters an error, the resulting Observable emits the current window and propagates the notification from the current Observable.

Note that ignoring windows or subscribing later (i.e., on another thread) will result in so-called window abandonment where a window may not contain any elements. In this case, subsequent elements will be dropped until the condition for the next window boundary is satisfied. The behavior is a trade-off for ensuring upstream cancellation can happen under some race conditions.

Scheduler:

This version of window operates by default on the computation Scheduler.

Parameters:

timespan - the period of time each window collects items before it should be emitted

timeskip - the period of time after which a new window will be created

unit - the unit of time that applies to the timespan and timeskip arguments

Returns:

the new Observable instance

Throws:

NullPointerException - if unit is null

IllegalArgumentException - if timespan or timeskip is non-positive

See Also:

ReactiveX operators documentation: Window

window

@CheckReturnValue
 @SchedulerSupport(value="custom")
 @NonNull
public final @NonNull Observable<Observable<T>> window(long timespan,
        long timeskip,
        @NonNull TimeUnit unit,
        @NonNull Scheduler scheduler)

Returns an Observable that emits windows of items it collects from the current Observable. The resulting Observable starts a new window periodically, as determined by the timeskip argument. It emits each window after a fixed timespan, specified by the timespan argument. When the current Observable completes or encounters an error, the resulting Observable emits the current window and propagates the notification from the current Observable.

Note that ignoring windows or subscribing later (i.e., on another thread) will result in so-called window abandonment where a window may not contain any elements. In this case, subsequent elements will be dropped until the condition for the next window boundary is satisfied. The behavior is a trade-off for ensuring upstream cancellation can happen under some race conditions.

Scheduler:

You specify which Scheduler this operator will use.

Parameters:

timespan - the period of time each window collects items before it should be emitted

timeskip - the period of time after which a new window will be created

unit - the unit of time that applies to the timespan and timeskip arguments

scheduler - the Scheduler to use when determining the end and start of a window

Returns:

the new Observable instance

Throws:

NullPointerException - if unit or scheduler is null

IllegalArgumentException - if timespan or timeskip is non-positive

See Also:

ReactiveX operators documentation: Window

window

@CheckReturnValue
 @SchedulerSupport(value="custom")
 @NonNull
public final @NonNull Observable<Observable<T>> window(long timespan,
        long timeskip,
        @NonNull TimeUnit unit,
        @NonNull Scheduler scheduler,
        int bufferSize)

Returns an Observable that emits windows of items it collects from the current Observable. The resulting Observable starts a new window periodically, as determined by the timeskip argument. It emits each window after a fixed timespan, specified by the timespan argument. When the current Observable completes or encounters an error, the resulting Observable emits the current window and propagates the notification from the current Observable.

Note that ignoring windows or subscribing later (i.e., on another thread) will result in so-called window abandonment where a window may not contain any elements. In this case, subsequent elements will be dropped until the condition for the next window boundary is satisfied. The behavior is a trade-off for ensuring upstream cancellation can happen under some race conditions.

Scheduler:

You specify which Scheduler this operator will use.

Parameters:

timespan - the period of time each window collects items before it should be emitted

timeskip - the period of time after which a new window will be created

unit - the unit of time that applies to the timespan and timeskip arguments

scheduler - the Scheduler to use when determining the end and start of a window

bufferSize - the capacity hint for the buffer in the inner windows

Returns:

the new Observable instance

Throws:

NullPointerException - if unit or scheduler is null

IllegalArgumentException - if timespan, timeskip or bufferSize is non-positive

See Also:

ReactiveX operators documentation: Window

window

@CheckReturnValue
 @SchedulerSupport(value="io.reactivex:computation")
 @NonNull
public final @NonNull Observable<Observable<T>> window(long timespan,
        @NonNull TimeUnit unit)

Returns an Observable that emits windows of items it collects from the current Observable. The resulting Observable emits connected, non-overlapping windows, each of a fixed duration specified by the timespan argument. When the current Observable completes or encounters an error, the resulting Observable emits the current window and propagates the notification from the current Observable.

Note that ignoring windows or subscribing later (i.e., on another thread) will result in so-called window abandonment where a window may not contain any elements. In this case, subsequent elements will be dropped until the condition for the next window boundary is satisfied. The behavior is a trade-off for ensuring upstream cancellation can happen under some race conditions.

Scheduler:

This version of window operates by default on the computation Scheduler.

Parameters:

timespan - the period of time each window collects items before it should be emitted and replaced with a new window

unit - the unit of time that applies to the timespan argument

Returns:

the new Observable instance

Throws:

NullPointerException - if unit is null

See Also:

ReactiveX operators documentation: Window

window

@CheckReturnValue
 @SchedulerSupport(value="io.reactivex:computation")
 @NonNull
public final @NonNull Observable<Observable<T>> window(long timespan,
        @NonNull TimeUnit unit,
        long count)

Returns an Observable that emits windows of items it collects from the current Observable. The resulting Observable emits connected, non-overlapping windows, each of a fixed duration as specified by the timespan argument or a maximum size as specified by the count argument (whichever is reached first). When the current Observable completes or encounters an error, the resulting Observable emits the current window and propagates the notification from the current Observable.

Note that ignoring windows or subscribing later (i.e., on another thread) will result in so-called window abandonment where a window may not contain any elements. In this case, subsequent elements will be dropped until the condition for the next window boundary is satisfied. The behavior is a trade-off for ensuring upstream cancellation can happen under some race conditions.

Scheduler:

This version of window operates by default on the computation Scheduler.

Parameters:

timespan - the period of time each window collects items before it should be emitted and replaced with a new window

unit - the unit of time that applies to the timespan argument

count - the maximum size of each window before it should be emitted

Returns:

the new Observable instance

Throws:

NullPointerException - if unit is null

IllegalArgumentException - if count is non-positive

See Also:

ReactiveX operators documentation: Window

window

@CheckReturnValue
 @SchedulerSupport(value="io.reactivex:computation")
 @NonNull
public final @NonNull Observable<Observable<T>> window(long timespan,
        @NonNull TimeUnit unit,
        long count,
        boolean restart)

Returns an Observable that emits windows of items it collects from the current Observable. The resulting Observable emits connected, non-overlapping windows, each of a fixed duration as specified by the timespan argument or a maximum size as specified by the count argument (whichever is reached first). When the current Observable completes or encounters an error, the resulting Observable emits the current window and propagates the notification from the current Observable.

Note that ignoring windows or subscribing later (i.e., on another thread) will result in so-called window abandonment where a window may not contain any elements. In this case, subsequent elements will be dropped until the condition for the next window boundary is satisfied. The behavior is a trade-off for ensuring upstream cancellation can happen under some race conditions.

Scheduler:

This version of window operates by default on the computation Scheduler.

Parameters:

timespan - the period of time each window collects items before it should be emitted and replaced with a new window

unit - the unit of time that applies to the timespan argument

count - the maximum size of each window before it should be emitted

restart - if true, when a window reaches the capacity limit, the timer is restarted as well

Returns:

the new Observable instance

Throws:

NullPointerException - if unit is null

IllegalArgumentException - if count is non-positive

See Also:

ReactiveX operators documentation: Window

window

@CheckReturnValue
 @SchedulerSupport(value="custom")
 @NonNull
public final @NonNull Observable<Observable<T>> window(long timespan,
        @NonNull TimeUnit unit,
        @NonNull Scheduler scheduler)

Returns an Observable that emits windows of items it collects from the current Observable. The resulting Observable emits connected, non-overlapping windows, each of a fixed duration as specified by the timespan argument. When the current Observable completes or encounters an error, the resulting Observable emits the current window and propagates the notification from the current Observable.

Note that ignoring windows or subscribing later (i.e., on another thread) will result in so-called window abandonment where a window may not contain any elements. In this case, subsequent elements will be dropped until the condition for the next window boundary is satisfied. The behavior is a trade-off for ensuring upstream cancellation can happen under some race conditions.

Scheduler:

You specify which Scheduler this operator will use.

Parameters:

timespan - the period of time each window collects items before it should be emitted and replaced with a new window

unit - the unit of time which applies to the timespan argument

scheduler - the Scheduler to use when determining the end and start of a window

Returns:

the new Observable instance

Throws:

NullPointerException - if unit or scheduler is null

See Also:

ReactiveX operators documentation: Window

window

@CheckReturnValue
 @SchedulerSupport(value="custom")
 @NonNull
public final @NonNull Observable<Observable<T>> window(long timespan,
        @NonNull TimeUnit unit,
        @NonNull Scheduler scheduler,
        long count)

Returns an Observable that emits windows of items it collects from the current Observable. The resulting Observable emits connected, non-overlapping windows, each of a fixed duration specified by the timespan argument or a maximum size specified by the count argument (whichever is reached first). When the current Observable completes or encounters an error, the resulting Observable emits the current window and propagates the notification from the current Observable.

Note that ignoring windows or subscribing later (i.e., on another thread) will result in so-called window abandonment where a window may not contain any elements. In this case, subsequent elements will be dropped until the condition for the next window boundary is satisfied. The behavior is a trade-off for ensuring upstream cancellation can happen under some race conditions.

Scheduler:

You specify which Scheduler this operator will use.

Parameters:

timespan - the period of time each window collects items before it should be emitted and replaced with a new window

unit - the unit of time which applies to the timespan argument

count - the maximum size of each window before it should be emitted

scheduler - the Scheduler to use when determining the end and start of a window

Returns:

the new Observable instance

Throws:

NullPointerException - if unit or scheduler is null

IllegalArgumentException - if count is non-positive

See Also:

ReactiveX operators documentation: Window

window

@CheckReturnValue
 @SchedulerSupport(value="custom")
 @NonNull
public final @NonNull Observable<Observable<T>> window(long timespan,
        @NonNull TimeUnit unit,
        @NonNull Scheduler scheduler,
        long count,
        boolean restart)

Returns an Observable that emits windows of items it collects from the current Observable. The resulting Observable emits connected, non-overlapping windows, each of a fixed duration specified by the timespan argument or a maximum size specified by the count argument (whichever is reached first). When the current Observable completes or encounters an error, the resulting Observable emits the current window and propagates the notification from the current Observable.

Note that ignoring windows or subscribing later (i.e., on another thread) will result in so-called window abandonment where a window may not contain any elements. In this case, subsequent elements will be dropped until the condition for the next window boundary is satisfied. The behavior is a trade-off for ensuring upstream cancellation can happen under some race conditions.

Scheduler:

You specify which Scheduler this operator will use.

Parameters:

timespan - the period of time each window collects items before it should be emitted and replaced with a new window

unit - the unit of time which applies to the timespan argument

count - the maximum size of each window before it should be emitted

scheduler - the Scheduler to use when determining the end and start of a window

restart - if true, when a window reaches the capacity limit, the timer is restarted as well

Returns:

the new Observable instance

Throws:

NullPointerException - if unit or scheduler is null

IllegalArgumentException - if count is non-positive

See Also:

ReactiveX operators documentation: Window

window

@CheckReturnValue
 @SchedulerSupport(value="custom")
 @NonNull
public final @NonNull Observable<Observable<T>> window(long timespan,
        @NonNull TimeUnit unit,
        @NonNull Scheduler scheduler,
        long count,
        boolean restart,
        int bufferSize)

Returns an Observable that emits windows of items it collects from the current Observable. The resulting Observable emits connected, non-overlapping windows, each of a fixed duration specified by the timespan argument or a maximum size specified by the count argument (whichever is reached first). When the current Observable completes or encounters an error, the resulting Observable emits the current window and propagates the notification from the current Observable.

Note that ignoring windows or subscribing later (i.e., on another thread) will result in so-called window abandonment where a window may not contain any elements. In this case, subsequent elements will be dropped until the condition for the next window boundary is satisfied. The behavior is a trade-off for ensuring upstream cancellation can happen under some race conditions.

Scheduler:

You specify which Scheduler this operator will use.

Parameters:

timespan - the period of time each window collects items before it should be emitted and replaced with a new window

unit - the unit of time which applies to the timespan argument

count - the maximum size of each window before it should be emitted

scheduler - the Scheduler to use when determining the end and start of a window

restart - if true, when a window reaches the capacity limit, the timer is restarted as well

bufferSize - the capacity hint for the buffer in the inner windows

Returns:

the new Observable instance

Throws:

NullPointerException - if unit or scheduler is null

IllegalArgumentException - if count or bufferSize is non-positive

See Also:

ReactiveX operators documentation: Window

window

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final <B> @NonNull Observable<Observable<T>> window(@NonNull ObservableSource<B> boundaryIndicator)

Returns an Observable that emits non-overlapping windows of items it collects from the current Observable where the boundary of each window is determined by the items emitted from a specified boundary-governing ObservableSource.

Note that ignoring windows or subscribing later (i.e., on another thread) will result in so-called window abandonment where a window may not contain any elements. In this case, subsequent elements will be dropped until the condition for the next window boundary is satisfied. The behavior is a trade-off for ensuring upstream cancellation can happen under some race conditions.

Scheduler:

This version of window does not operate by default on a particular Scheduler.

Type Parameters:

B - the window element type (ignored)

Parameters:

boundaryIndicator - an ObservableSource whose emitted items close and open windows

Returns:

the new Observable instance

Throws:

NullPointerException - if boundaryIndicator is null

See Also:

ReactiveX operators documentation: Window

window

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final <B> @NonNull Observable<Observable<T>> window(@NonNull ObservableSource<B> boundaryIndicator,
        int bufferSize)

Returns an Observable that emits non-overlapping windows of items it collects from the current Observable where the boundary of each window is determined by the items emitted from a specified boundary-governing ObservableSource.

Note that ignoring windows or subscribing later (i.e., on another thread) will result in so-called window abandonment where a window may not contain any elements. In this case, subsequent elements will be dropped until the condition for the next window boundary is satisfied. The behavior is a trade-off for ensuring upstream cancellation can happen under some race conditions.

Scheduler:

This version of window does not operate by default on a particular Scheduler.

Type Parameters:

B - the window element type (ignored)

Parameters:

boundaryIndicator - an ObservableSource whose emitted items close and open windows

bufferSize - the capacity hint for the buffer in the inner windows

Returns:

the new Observable instance

Throws:

NullPointerException - if boundaryIndicator is null

IllegalArgumentException - if bufferSize is non-positive

See Also:

ReactiveX operators documentation: Window

window

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final <U,V> @NonNull Observable<Observable<T>> window(@NonNull ObservableSource<U> openingIndicator,
        @NonNull Function<? super U,? extends ObservableSource<V>> closingIndicator)

Returns an Observable that emits windows of items it collects from the current Observable. The resulting Observable emits windows that contain those items emitted by the current Observable between the time when the openingIndicator ObservableSource emits an item and when the ObservableSource returned by closingIndicator emits an item.

Note that ignoring windows or subscribing later (i.e., on another thread) will result in so-called window abandonment where a window may not contain any elements. In this case, subsequent elements will be dropped until the condition for the next window boundary is satisfied. The behavior is a trade-off for ensuring upstream cancellation can happen under some race conditions.

Scheduler:

This version of window does not operate by default on a particular Scheduler.

Type Parameters:

U - the element type of the window-opening ObservableSource

V - the element type of the window-closing ObservableSources

Parameters:

openingIndicator - an ObservableSource that, when it emits an item, causes another window to be created

closingIndicator - a Function that produces an ObservableSource for every window created. When this indicator ObservableSource emits an item, the associated window is completed

Returns:

the new Observable instance

Throws:

NullPointerException - if openingIndicator or closingIndicator is null

See Also:

ReactiveX operators documentation: Window

window

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final <U,V> @NonNull Observable<Observable<T>> window(@NonNull ObservableSource<U> openingIndicator,
        @NonNull Function<? super U,? extends ObservableSource<V>> closingIndicator,
        int bufferSize)

Returns an Observable that emits windows of items it collects from the current Observable. The resulting Observable emits windows that contain those items emitted by the current Observable between the time when the openingIndicator ObservableSource emits an item and when the ObservableSource returned by closingIndicator emits an item.

Note that ignoring windows or subscribing later (i.e., on another thread) will result in so-called window abandonment where a window may not contain any elements. In this case, subsequent elements will be dropped until the condition for the next window boundary is satisfied. The behavior is a trade-off for ensuring upstream cancellation can happen under some race conditions.

Scheduler:

This version of window does not operate by default on a particular Scheduler.

Type Parameters:

U - the element type of the window-opening ObservableSource

V - the element type of the window-closing ObservableSources

Parameters:

openingIndicator - an ObservableSource that, when it emits an item, causes another window to be created

closingIndicator - a Function that produces an ObservableSource for every window created. When this indicator ObservableSource emits an item, the associated window is completed

bufferSize - the capacity hint for the buffer in the inner windows

Returns:

the new Observable instance

Throws:

NullPointerException - if openingIndicator or closingIndicator is null

IllegalArgumentException - if bufferSize is non-positive

See Also:

ReactiveX operators documentation: Window

withLatestFrom

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final <U,R> @NonNull Observable<R> withLatestFrom(@NonNull ObservableSource<? extends U> other,
        @NonNull BiFunction<? super T,? super U,? extends R> combiner)

Merges the specified ObservableSource into the current Observable sequence by using the resultSelector function only when the current Observable emits an item.

Note that this operator doesn't emit anything until the other source has produced at least one value. The resulting emission only happens when the current Observable emits (and not when the other source emits, unlike combineLatest). If the other source doesn't produce any value and just completes, the sequence is completed immediately. If the upstream completes before the other source has produced at least one value, the sequence completes without emission.

Scheduler:

This operator, by default, doesn't run any particular Scheduler.

Type Parameters:

U - the element type of the other ObservableSource

R - the result type of the combination

Parameters:

other - the other ObservableSource

combiner - the function to call when the current Observable emits an item and the other ObservableSource has already emitted an item, to generate the item to be emitted by the resulting Observable

Returns:

the new Observable instance

Throws:

NullPointerException - if other or combiner is null

Since:

2.0

See Also:

ReactiveX operators documentation: CombineLatest

withLatestFrom

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final <T1,T2,R> @NonNull Observable<R> withLatestFrom(@NonNull ObservableSource<T1> source1,
        @NonNull ObservableSource<T2> source2,
        @NonNull Function3<? super T,? super T1,? super T2,R> combiner)

Combines the value emission from the current Observable with the latest emissions from the other ObservableSources via a function to produce the output item.

Note that this operator doesn't emit anything until all other sources have produced at least one value. The resulting emission only happens when the current Observable emits (and not when any of the other sources emit, unlike combineLatest). If a source doesn't produce any value and just completes, the sequence is completed immediately. If the upstream completes before all other sources have produced at least one value, the sequence completes without emission.

Scheduler:

This operator does not operate by default on a particular Scheduler.

Type Parameters:

T1 - the first other source's value type

T2 - the second other source's value type

R - the result value type

Parameters:

source1 - the first other ObservableSource

source2 - the second other ObservableSource

combiner - the function called with an array of values from each participating ObservableSource

Returns:

the new Observable instance

Throws:

NullPointerException - if source1, source2 or combiner is null

Since:

2.0

withLatestFrom

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final <T1,T2,T3,R> @NonNull Observable<R> withLatestFrom(@NonNull ObservableSource<T1> source1,
        @NonNull ObservableSource<T2> source2,
        @NonNull ObservableSource<T3> source3,
        @NonNull Function4<? super T,? super T1,? super T2,? super T3,R> combiner)

Combines the value emission from the current Observable with the latest emissions from the other ObservableSources via a function to produce the output item.

Note that this operator doesn't emit anything until all other sources have produced at least one value. The resulting emission only happens when the current Observable emits (and not when any of the other sources emit, unlike combineLatest). If a source doesn't produce any value and just completes, the sequence is completed immediately. If the upstream completes before all other sources have produced at least one value, the sequence completes without emission.

Scheduler:

This operator does not operate by default on a particular Scheduler.

Type Parameters:

T1 - the first other source's value type

T2 - the second other source's value type

T3 - the third other source's value type

R - the result value type

Parameters:

source1 - the first other ObservableSource

source2 - the second other ObservableSource

source3 - the third other ObservableSource

combiner - the function called with an array of values from each participating ObservableSource

Returns:

the new Observable instance

Throws:

NullPointerException - if source1, source2, source3 or combiner is null

Since:

2.0

withLatestFrom

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final <T1,T2,T3,T4,R> @NonNull Observable<R> withLatestFrom(@NonNull ObservableSource<T1> source1,
        @NonNull ObservableSource<T2> source2,
        @NonNull ObservableSource<T3> source3,
        @NonNull ObservableSource<T4> source4,
        @NonNull Function5<? super T,? super T1,? super T2,? super T3,? super T4,R> combiner)

Combines the value emission from the current Observable with the latest emissions from the other ObservableSources via a function to produce the output item.

Note that this operator doesn't emit anything until all other sources have produced at least one value. The resulting emission only happens when the current Observable emits (and not when any of the other sources emit, unlike combineLatest). If a source doesn't produce any value and just completes, the sequence is completed immediately. If the upstream completes before all other sources have produced at least one value, the sequence completes without emission.

Scheduler:

This operator does not operate by default on a particular Scheduler.

Type Parameters:

T1 - the first other source's value type

T2 - the second other source's value type

T3 - the third other source's value type

T4 - the fourth other source's value type

R - the result value type

Parameters:

source1 - the first other ObservableSource

source2 - the second other ObservableSource

source3 - the third other ObservableSource

source4 - the fourth other ObservableSource

combiner - the function called with an array of values from each participating ObservableSource

Returns:

the new Observable instance

Throws:

NullPointerException - if source1, source2, source3, source4 or combiner is null

Since:

2.0

withLatestFrom

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final <R> @NonNull Observable<R> withLatestFrom(@NonNull ObservableSource<?>[] others,
        @NonNull Function<? super Object[],R> combiner)

Combines the value emission from the current Observable with the latest emissions from the other ObservableSources via a function to produce the output item.

Note that this operator doesn't emit anything until all other sources have produced at least one value. The resulting emission only happens when the current Observable emits (and not when any of the other sources emit, unlike combineLatest). If a source doesn't produce any value and just completes, the sequence is completed immediately. If the upstream completes before all other sources have produced at least one value, the sequence completes without emission.

Scheduler:

This operator does not operate by default on a particular Scheduler.

Type Parameters:

R - the result value type

Parameters:

others - the array of other sources

combiner - the function called with an array of values from each participating ObservableSource

Returns:

the new Observable instance

Throws:

NullPointerException - if others or combiner is null

Since:

2.0

withLatestFrom

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final <R> @NonNull Observable<R> withLatestFrom(@NonNull Iterable<? extends ObservableSource<?>> others,
        @NonNull Function<? super Object[],R> combiner)

Combines the value emission from the current Observable with the latest emissions from the other ObservableSources via a function to produce the output item.

Note that this operator doesn't emit anything until all other sources have produced at least one value. The resulting emission only happens when the current Observable emits (and not when any of the other sources emit, unlike combineLatest). If a source doesn't produce any value and just completes, the sequence is completed immediately. If the upstream completes before all other sources have produced at least one value, the sequence completes without emission.

Scheduler:

This operator does not operate by default on a particular Scheduler.

Type Parameters:

R - the result value type

Parameters:

others - the iterable of other sources

combiner - the function called with an array of values from each participating ObservableSource

Returns:

the new Observable instance

Throws:

NullPointerException - if others or combiner is null

Since:

2.0

zipWith

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final <U,R> @NonNull Observable<R> zipWith(@NonNull Iterable<U> other,
        @NonNull BiFunction<? super T,? super U,? extends R> zipper)

Returns an Observable that emits items that are the result of applying a specified function to pairs of values, one each from the current Observable and a specified Iterable sequence.

Note that the other Iterable is evaluated as items are observed from the current Observable; it is not pre-consumed. This allows you to zip infinite streams on either side.

Scheduler:

zipWith does not operate by default on a particular Scheduler.

Type Parameters:

U - the type of items in the other Iterable

R - the type of items emitted by the resulting Observable

Parameters:

other - the Iterable sequence

zipper - a function that combines the pairs of items from the current Observable and the Iterable to generate the items to be emitted by the resulting Observable

Returns:

the new Observable instance

Throws:

NullPointerException - if other or zipper is null

See Also:

ReactiveX operators documentation: Zip

zipWith

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final <U,R> @NonNull Observable<R> zipWith(@NonNull ObservableSource<? extends U> other,
        @NonNull BiFunction<? super T,? super U,? extends R> zipper)

Returns an Observable that emits items that are the result of applying a specified function to pairs of values, one each from the current Observable and another specified ObservableSource.

The operator subscribes to its sources in order they are specified and completes eagerly if one of the sources is shorter than the rest while disposing the other sources. Therefore, it is possible those other sources will never be able to run to completion (and thus not calling doOnComplete()). This can also happen if the sources are exactly the same length; if source A completes and B has been consumed and is about to complete, the operator detects A won't be sending further values and it will dispose B immediately. For example:

range(1, 5).doOnComplete(action1).zipWith(range(6, 5).doOnComplete(action2), (a, b) -> a + b)

action1 will be called but action2 won't.
To work around this termination property, use doOnDispose(Action) as well or use using() to do cleanup in case of completion or a dispose() call.

Scheduler:

zipWith does not operate by default on a particular Scheduler.

Type Parameters:

U - the type of items emitted by the other ObservableSource

R - the type of items emitted by the resulting Observable

Parameters:

other - the other ObservableSource

zipper - a function that combines the pairs of items from the current Observable and the other ObservableSource to generate the items to be emitted by the resulting Observable

Returns:

the new Observable instance

Throws:

NullPointerException - if other or zipper is null

See Also:

ReactiveX operators documentation: Zip

zipWith

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final <U,R> @NonNull Observable<R> zipWith(@NonNull ObservableSource<? extends U> other,
        @NonNull BiFunction<? super T,? super U,? extends R> zipper,
        boolean delayError)

Returns an Observable that emits items that are the result of applying a specified function to pairs of values, one each from the current Observable and another specified ObservableSource.

The operator subscribes to its sources in order they are specified and completes eagerly if one of the sources is shorter than the rest while disposing the other sources. Therefore, it is possible those other sources will never be able to run to completion (and thus not calling doOnComplete()). This can also happen if the sources are exactly the same length; if source A completes and B has been consumed and is about to complete, the operator detects A won't be sending further values and it will dispose B immediately. For example:

range(1, 5).doOnComplete(action1).zipWith(range(6, 5).doOnComplete(action2), (a, b) -> a + b)

action1 will be called but action2 won't.
To work around this termination property, use doOnDispose(Action) as well or use using() to do cleanup in case of completion or a dispose() call.

Scheduler:

zipWith does not operate by default on a particular Scheduler.

Type Parameters:

U - the type of items emitted by the other ObservableSource

R - the type of items emitted by the resulting Observable

Parameters:

other - the other ObservableSource

zipper - a function that combines the pairs of items from the current Observable and the other ObservableSource to generate the items to be emitted by the resulting Observable

delayError - if true, errors from the current Observable or the other ObservableSource is delayed until both terminate

Returns:

the new Observable instance

Throws:

NullPointerException - if other or zipper is null

Since:

2.0

See Also:

ReactiveX operators documentation: Zip

zipWith

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final <U,R> @NonNull Observable<R> zipWith(@NonNull ObservableSource<? extends U> other,
        @NonNull BiFunction<? super T,? super U,? extends R> zipper,
        boolean delayError,
        int bufferSize)

Returns an Observable that emits items that are the result of applying a specified function to pairs of values, one each from the current Observable and another specified ObservableSource.

The operator subscribes to its sources in order they are specified and completes eagerly if one of the sources is shorter than the rest while disposing the other sources. Therefore, it is possible those other sources will never be able to run to completion (and thus not calling doOnComplete()). This can also happen if the sources are exactly the same length; if source A completes and B has been consumed and is about to complete, the operator detects A won't be sending further values and it will dispose B immediately. For example:

range(1, 5).doOnComplete(action1).zipWith(range(6, 5).doOnComplete(action2), (a, b) -> a + b)

action1 will be called but action2 won't.
To work around this termination property, use doOnDispose(Action) as well or use using() to do cleanup in case of completion or a dispose() call.

Scheduler:

zipWith does not operate by default on a particular Scheduler.

Type Parameters:

U - the type of items emitted by the other ObservableSource

R - the type of items emitted by the resulting Observable

Parameters:

other - the other ObservableSource

zipper - a function that combines the pairs of items from the current Observable and the other ObservableSource to generate the items to be emitted by the resulting Observable

bufferSize - the capacity hint for the buffer in the inner windows

delayError - if true, errors from the current Observable or the other ObservableSource is delayed until both terminate

Returns:

the new Observable instance

Throws:

NullPointerException - if other or zipper is null

IllegalArgumentException - if bufferSize is non-positive

Since:

2.0

See Also:

ReactiveX operators documentation: Zip

test

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull TestObserver<T> test()

Creates a TestObserver and subscribes it to the current Observable.

Scheduler:

test does not operate by default on a particular Scheduler.

Returns:

the new TestObserver instance

Since:

2.0

test

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull TestObserver<T> test(boolean dispose)

Creates a TestObserver, optionally disposes it and then subscribes it to the current Observable.

Scheduler:

test does not operate by default on a particular Scheduler.

Parameters:

dispose - indicates if the TestObserver should be disposed before it is subscribed to the current Observable

Returns:

the new TestObserver instance

Since:

2.0

fromOptional

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public static <T> @NonNull Observable<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() Observable instance.

Note that the operator takes an already instantiated optional reference and does not by any means create this original optional. If the optional is to be created per consumer upon subscription, use defer(Supplier) around fromOptional:

 Observable.defer(() -> Observable.fromOptional(createOptional()));
 

Scheduler:

fromOptional does not operate by default on a particular Scheduler.

Type Parameters:

T - the element type of the optional value

Parameters:

optional - the optional value to convert into an Observable

Returns:

the new Observable instance

Throws:

NullPointerException - if optional is null

Since:

3.0.0

See Also:

just(Object), empty()

fromCompletionStage

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public static <T> @NonNull Observable<T> fromCompletionStage(@NonNull CompletionStage<T> stage)

Signals the completion value or error of the given (hot) CompletionStage-based asynchronous calculation.

Note that the operator takes an already instantiated, running or terminated CompletionStage. If the CompletionStage is to be created per consumer upon subscription, use defer(Supplier) around fromCompletionStage:

 Observable.defer(() -> Observable.fromCompletionStage(createCompletionStage()));
 

If the CompletionStage completes with null, a NullPointerException is signaled.

Canceling the flow can't cancel the execution of the CompletionStage because CompletionStage itself doesn't support cancellation. Instead, the operator detaches from the CompletionStage.

Scheduler:

fromCompletionStage does not operate by default on a particular Scheduler.

Type Parameters:

T - the element type of the CompletionStage

Parameters:

stage - the CompletionStage to convert to Observable and signal its terminal value or error

Returns:

the new Observable instance

Throws:

NullPointerException - if stage is null

Since:

3.0.0

fromStream

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public static <T> @NonNull Observable<T> fromStream(@NonNull Stream<T> stream)

Converts a Stream into a finite Observable and emits its items in the sequence.

The operator closes the Stream upon cancellation and when it terminates. The exceptions raised when closing a Stream are routed to the global error handler (RxJavaPlugins.onError(Throwable). If a Stream should not be closed, turn it into an Iterable and use fromIterable(Iterable):

 Stream<T> stream = ...
 Observable.fromIterable(stream::iterator);
 

Note that Streams can be consumed only once; any subsequent attempt to consume a Stream will result in an IllegalStateException.

Primitive streams are not supported and items have to be boxed manually (e.g., via IntStream.boxed()):

 IntStream intStream = IntStream.rangeClosed(1, 10);
 Observable.fromStream(intStream.boxed());
 

Stream does not support concurrent usage so creating and/or consuming the same instance multiple times from multiple threads can lead to undefined behavior.

Scheduler:

fromStream does not operate by default on a particular Scheduler.

Type Parameters:

T - the element type of the source Stream

Parameters:

stream - the Stream of values to emit

Returns:

the new Observable instance

Throws:

NullPointerException - if stream is null

Since:

3.0.0

See Also:

fromIterable(Iterable)

mapOptional

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final <R> @NonNull Observable<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.

Scheduler:

mapOptional does not operate by default on a particular Scheduler.

Type Parameters:

R - the non-null output type

Parameters:

mapper - the function that receives the upstream item and should return a non-empty Optional to emit as the output or an empty Optional to skip to the next upstream value

Returns:

the new Observable instance

Throws:

NullPointerException - if mapper is null

Since:

3.0.0

See Also:

map(Function), filter(Predicate)

collect

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final <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 as a Single.

Scheduler:

collect does not operate by default on a particular Scheduler.

Type Parameters:

R - the non-null result type

A - the intermediate container type used for the accumulation

Parameters:

collector - the interface defining the container supplier, accumulator and finisher functions; see Collectors for some standard implementations

Returns:

the new Single instance

Throws:

NullPointerException - if collector is null

Since:

3.0.0

See Also:

Collectors, collect(Supplier, BiConsumer)

firstStage

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull CompletionStage<T> firstStage(@Nullable T defaultItem)

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

The upstream can be canceled by converting the resulting CompletionStage into CompletableFuture via CompletionStage.toCompletableFuture() and calling CompletableFuture.cancel(boolean) on it. The upstream will be also cancelled if the resulting CompletionStage is converted to and completed manually by CompletableFuture.complete(Object) or CompletableFuture.completeExceptionally(Throwable).

CompletionStages don't have a notion of emptiness and allow nulls, therefore, one can either use a defaultItem of null or turn the flow into a sequence of Optionals and default to Optional.empty():

 CompletionStage<Optional<T>> stage = source.map(Optional::of).firstStage(Optional.empty());
 

Scheduler:

firstStage does not operate by default on a particular Scheduler.

Parameters:

defaultItem - the item to signal if the upstream is empty

Returns:

the new CompletionStage instance

Throws:

NullPointerException - if defaultItem is null

Since:

3.0.0

See Also:

firstOrErrorStage()

singleStage

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull CompletionStage<T> singleStage(@Nullable T defaultItem)

Signals the only expected upstream item (or the default item if the upstream is empty) or signals IllegalArgumentException if the upstream has more than one item via a CompletionStage.

The upstream can be canceled by converting the resulting CompletionStage into CompletableFuture via CompletionStage.toCompletableFuture() and calling CompletableFuture.cancel(boolean) on it. The upstream will be also cancelled if the resulting CompletionStage is converted to and completed manually by CompletableFuture.complete(Object) or CompletableFuture.completeExceptionally(Throwable).

CompletionStages don't have a notion of emptiness and allow nulls, therefore, one can either use a defaultItem of null or turn the flow into a sequence of Optionals and default to Optional.empty():

 CompletionStage<Optional<T>> stage = source.map(Optional::of).singleStage(Optional.empty());
 

Scheduler:

singleStage does not operate by default on a particular Scheduler.

Parameters:

defaultItem - the item to signal if the upstream is empty

Returns:

the new CompletionStage instance

Throws:

NullPointerException - if defaultItem is null

Since:

3.0.0

See Also:

singleOrErrorStage()

lastStage

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull CompletionStage<T> lastStage(@Nullable T defaultItem)

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

The upstream can be canceled by converting the resulting CompletionStage into CompletableFuture via CompletionStage.toCompletableFuture() and calling CompletableFuture.cancel(boolean) on it. The upstream will be also cancelled if the resulting CompletionStage is converted to and completed manually by CompletableFuture.complete(Object) or CompletableFuture.completeExceptionally(Throwable).

CompletionStages don't have a notion of emptiness and allow nulls, therefore, one can either use a defaultItem of null or turn the flow into a sequence of Optionals and default to Optional.empty():

 CompletionStage<Optional<T>> stage = source.map(Optional::of).lastStage(Optional.empty());
 

Scheduler:

lastStage does not operate by default on a particular Scheduler.

Parameters:

defaultItem - the item to signal if the upstream is empty

Returns:

the new CompletionStage instance

Throws:

NullPointerException - if defaultItem is null

Since:

3.0.0

See Also:

lastOrErrorStage()

firstOrErrorStage

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull CompletionStage<T> firstOrErrorStage()

Signals the first upstream item or a NoSuchElementException if the upstream is empty via a CompletionStage.

The upstream can be canceled by converting the resulting CompletionStage into CompletableFuture via CompletionStage.toCompletableFuture() and calling CompletableFuture.cancel(boolean) on it. The upstream will be also cancelled if the resulting CompletionStage is converted to and completed manually by CompletableFuture.complete(Object) or CompletableFuture.completeExceptionally(Throwable).

Scheduler:

firstOrErrorStage does not operate by default on a particular Scheduler.

Returns:

the new CompletionStage instance

Since:

3.0.0

See Also:

firstStage(Object)

singleOrErrorStage

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull CompletionStage<T> singleOrErrorStage()

Signals the only expected upstream item, a NoSuchElementException if the upstream is empty or signals IllegalArgumentException if the upstream has more than one item via a CompletionStage.

The upstream can be canceled by converting the resulting CompletionStage into CompletableFuture via CompletionStage.toCompletableFuture() and calling CompletableFuture.cancel(boolean) on it. The upstream will be also cancelled if the resulting CompletionStage is converted to and completed manually by CompletableFuture.complete(Object) or CompletableFuture.completeExceptionally(Throwable).

Scheduler:

singleOrErrorStage does not operate by default on a particular Scheduler.

Returns:

the new CompletionStage instance

Since:

3.0.0

See Also:

singleStage(Object)

lastOrErrorStage

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull CompletionStage<T> lastOrErrorStage()

Signals the last upstream item or a NoSuchElementException if the upstream is empty via a CompletionStage.

The upstream can be canceled by converting the resulting CompletionStage into CompletableFuture via CompletionStage.toCompletableFuture() and calling CompletableFuture.cancel(boolean) on it. The upstream will be also cancelled if the resulting CompletionStage is converted to and completed manually by CompletableFuture.complete(Object) or CompletableFuture.completeExceptionally(Throwable).

Scheduler:

lastOrErrorStage does not operate by default on a particular Scheduler.

Returns:

the new CompletionStage instance

Since:

3.0.0

See Also:

lastStage(Object)

blockingStream

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Stream<T> blockingStream()

Creates a sequential Stream to consume or process the current Observable in a blocking manner via the Java Stream API.

Cancellation of the upstream is done via BaseStream.close(), therefore, it is strongly recommended the consumption is performed within a try-with-resources construct:

 Observable<Integer> source = Observable.range(1, 10)
        .subscribeOn(Schedulers.computation());

 try (Stream<Integer> stream = source.blockingStream()) {
     stream.limit(3).forEach(System.out::println);
 }
 

Scheduler:

blockingStream does not operate by default on a particular Scheduler.

Returns:

the new Stream instance

Since:

3.0.0

See Also:

blockingStream(int)

blockingStream

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Stream<T> blockingStream(int capacityHint)

Creates a sequential Stream to consume or process the current Observable in a blocking manner via the Java Stream API.

Cancellation of the upstream is done via BaseStream.close(), therefore, it is strongly recommended the consumption is performed within a try-with-resources construct:

 Observable<Integer> source = Observable.range(1, 10)
        .subscribeOn(Schedulers.computation());

 try (Stream<Integer> stream = source.blockingStream(4)) {
     stream.limit(3).forEach(System.out::println);
 }
 

Scheduler:

blockingStream does not operate by default on a particular Scheduler.

Parameters:

capacityHint - the expected number of items to be buffered

Returns:

the new Stream instance

Throws:

IllegalArgumentException - if capacityHint is non-positive

Since:

3.0.0

concatMapStream

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final <R> @NonNull Observable<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.

Due to the blocking and sequential nature of Java Streams, the streams are mapped and consumed in a sequential fashion without interleaving (unlike a more general flatMap(Function)). Therefore, flatMapStream and concatMapStream are identical operators and are provided as aliases.

The operator closes the Stream upon cancellation and when it terminates. The exceptions raised when closing a Stream are routed to the global error handler (RxJavaPlugins.onError(Throwable). If a Stream should not be closed, turn it into an Iterable and use concatMapIterable(Function):

 source.concatMapIterable(v -> createStream(v)::iterator);
 

Note that Streams can be consumed only once; any subsequent attempt to consume a Stream will result in an IllegalStateException.

Primitive streams are not supported and items have to be boxed manually (e.g., via IntStream.boxed()):

 source.concatMapStream(v -> IntStream.rangeClosed(v + 1, v + 10).boxed());
 

Stream does not support concurrent usage so creating and/or consuming the same instance multiple times from multiple threads can lead to undefined behavior.

Scheduler:

concatMapStream does not operate by default on a particular Scheduler.

Type Parameters:

R - the element type of the Streams and the result

Parameters:

mapper - the function that receives an upstream item and should return a Stream whose elements will be emitted to the downstream

Returns:

the new Observable instance

Throws:

NullPointerException - if mapper is null

Since:

3.0.0

See Also:

concatMap(Function), concatMapIterable(Function), flatMapStream(Function)

flatMapStream

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final <R> @NonNull Observable<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.

Due to the blocking and sequential nature of Java Streams, the streams are mapped and consumed in a sequential fashion without interleaving (unlike a more general flatMap(Function)). Therefore, flatMapStream and concatMapStream are identical operators and are provided as aliases.

The operator closes the Stream upon cancellation and when it terminates. The exceptions raised when closing a Stream are routed to the global error handler (RxJavaPlugins.onError(Throwable). If a Stream should not be closed, turn it into an Iterable and use flatMapIterable(Function):

 source.flatMapIterable(v -> createStream(v)::iterator);
 

Note that Streams can be consumed only once; any subsequent attempt to consume a Stream will result in an IllegalStateException.

Primitive streams are not supported and items have to be boxed manually (e.g., via IntStream.boxed()):

 source.flatMapStream(v -> IntStream.rangeClosed(v + 1, v + 10).boxed());
 

Stream does not support concurrent usage so creating and/or consuming the same instance multiple times from multiple threads can lead to undefined behavior.

Scheduler:

flatMapStream does not operate by default on a particular Scheduler.

Type Parameters:

R - the element type of the Streams and the result

Parameters:

mapper - the function that receives an upstream item and should return a Stream whose elements will be emitted to the downstream

Returns:

the new Observable instance

Throws:

NullPointerException - if mapper is null

Since:

3.0.0

See Also:

flatMap(Function), flatMapIterable(Function)