public abstract class

Observable

extends Object
implements ObservableSource<T>
java.lang.Object
   ↳ io.reactivex.Observable<T>
Known Direct Subclasses
Known Indirect Subclasses

Class Overview

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 bufferSize(), that can be overridden globally via the system parameter rx2.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 cancel 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 cancellation 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(Integer 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 now can be cancelled via dispose()
 d.dispose();

See Also

Summary

Public Constructors
Observable()
Public Methods
final Single<Boolean> all(Predicate<? super T> predicate)
Returns an Observable that emits a Boolean that indicates whether all of the items emitted by the source ObservableSource satisfy a condition.
static <T> Observable<T> amb(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> 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.
final Observable<T> ambWith(ObservableSource<? extends T> other)
Mirrors the ObservableSource (current or provided) that first either emits an item or sends a termination notification.
final Single<Boolean> any(Predicate<? super T> predicate)
Returns an Observable that emits true if any item emitted by the source ObservableSource satisfies a specified condition, otherwise false.
final T blockingFirst(T defaultItem)
Returns the first item emitted by this Observable, or a default value if it emits no items.
final T blockingFirst()
Returns the first item emitted by this Observable, or throws NoSuchElementException if it emits no items.
final void blockingForEach(Consumer<? super T> onNext)
Invokes a method on each item emitted by this Observable and blocks until the Observable completes.
final Iterable<T> blockingIterable(int bufferSize)
Converts this Observable into an Iterable.
final Iterable<T> blockingIterable()
Converts this Observable into an Iterable.
final T blockingLast()
Returns the last item emitted by this Observable, or throws NoSuchElementException if this Observable emits no items.
final T blockingLast(T defaultItem)
Returns the last item emitted by this Observable, or a default value if it emits no items.
final Iterable<T> blockingLatest()
Returns an Iterable that returns the latest item emitted by this Observable, waiting if necessary for one to become available.
final Iterable<T> blockingMostRecent(T initialValue)
Returns an Iterable that always returns the item most recently emitted by this Observable.
final Iterable<T> blockingNext()
Returns an Iterable that blocks until this Observable emits another item, then returns that item.
final T blockingSingle(T defaultItem)
If this 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.
final T blockingSingle()
If this Observable completes after emitting a single item, return that item, otherwise throw a NoSuchElementException.
final void blockingSubscribe(Consumer<? super T> onNext)
Subscribes to the source and calls the given callbacks on the current thread.
final void blockingSubscribe(Observer<? super T> subscriber)
Subscribes to the source and calls the Observer methods on the current thread.
final void blockingSubscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError)
Subscribes to the source and calls the given callbacks on the current thread.
final void blockingSubscribe()
Runs the source observable to a terminal event, ignoring any values and rethrowing any exception.
final void blockingSubscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError, Action onComplete)
Subscribes to the source and calls the given callbacks on the current thread.
final <TOpening, TClosing> Observable<List<T>> buffer(ObservableSource<? extends TOpening> openingIndicator, Function<? super TOpening, ? extends ObservableSource<? extends TClosing>> closingIndicator)
Returns an Observable that emits buffers of items it collects from the source ObservableSource.
final <TOpening, TClosing, U extends Collection<? super T>> Observable<U> buffer(ObservableSource<? extends TOpening> openingIndicator, Function<? super TOpening, ? extends ObservableSource<? extends TClosing>> closingIndicator, Callable<U> bufferSupplier)
Returns an Observable that emits buffers of items it collects from the source ObservableSource.
final <U extends Collection<? super T>> Observable<U> buffer(long timespan, long timeskip, TimeUnit unit, Scheduler scheduler, Callable<U> bufferSupplier)
Returns an Observable that emits buffers of items it collects from the source ObservableSource.
final Observable<List<T>> buffer(long timespan, long timeskip, TimeUnit unit, Scheduler scheduler)
Returns an Observable that emits buffers of items it collects from the source ObservableSource.
final <U extends Collection<? super T>> Observable<U> buffer(int count, Callable<U> bufferSupplier)
Returns an Observable that emits buffers of items it collects from the source ObservableSource.
final <B, U extends Collection<? super T>> Observable<U> buffer(Callable<? extends ObservableSource<B>> boundarySupplier, Callable<U> bufferSupplier)
Returns an Observable that emits buffers of items it collects from the source ObservableSource.
final Observable<List<T>> buffer(long timespan, TimeUnit unit, Scheduler scheduler)
Returns an Observable that emits buffers of items it collects from the source ObservableSource.
final <B> Observable<List<T>> buffer(ObservableSource<B> boundary, int initialCapacity)
Returns an Observable that emits non-overlapping buffered items from the source ObservableSource each time the specified boundary ObservableSource emits an item.
final Observable<List<T>> buffer(int count)
Returns an Observable that emits buffers of items it collects from the source ObservableSource.
final <B> Observable<List<T>> buffer(Callable<? extends ObservableSource<B>> boundarySupplier)
Returns an Observable that emits buffers of items it collects from the source ObservableSource.
final <B> Observable<List<T>> buffer(ObservableSource<B> boundary)
Returns an Observable that emits non-overlapping buffered items from the source ObservableSource each time the specified boundary ObservableSource emits an item.
final Observable<List<T>> buffer(long timespan, long timeskip, TimeUnit unit)
Returns an Observable that emits buffers of items it collects from the source ObservableSource.
final Observable<List<T>> buffer(long timespan, TimeUnit unit, Scheduler scheduler, int count)
Returns an Observable that emits buffers of items it collects from the source ObservableSource.
final Observable<List<T>> buffer(long timespan, TimeUnit unit)
Returns an Observable that emits buffers of items it collects from the source ObservableSource.
final <U extends Collection<? super T>> Observable<U> buffer(long timespan, TimeUnit unit, Scheduler scheduler, int count, Callable<U> bufferSupplier, boolean restartTimerOnMaxSize)
Returns an Observable that emits buffers of items it collects from the source ObservableSource.
final <B, U extends Collection<? super T>> Observable<U> buffer(ObservableSource<B> boundary, Callable<U> bufferSupplier)
Returns an Observable that emits non-overlapping buffered items from the source ObservableSource each time the specified boundary ObservableSource emits an item.
final Observable<List<T>> buffer(int count, int skip)
Returns an Observable that emits buffers of items it collects from the source ObservableSource.
final Observable<List<T>> buffer(long timespan, TimeUnit unit, int count)
Returns an Observable that emits buffers of items it collects from the source ObservableSource.
final <U extends Collection<? super T>> Observable<U> buffer(int count, int skip, Callable<U> bufferSupplier)
Returns an Observable that emits buffers of items it collects from the source ObservableSource.
static int bufferSize()
Returns the default 'island' size or capacity-increment hint for unbounded buffers.
final Observable<T> cache()
Returns an Observable that subscribes to this ObservableSource lazily, caches all of its events and replays them, in the same order as received, to all the downstream subscribers.
final Observable<T> cacheWithInitialCapacity(int initialCapacity)
Returns an Observable that subscribes to this ObservableSource lazily, caches all of its events and replays them, in the same order as received, to all the downstream subscribers.
final <U> Observable<U> cast(Class<U> clazz)
Returns an Observable that emits the items emitted by the source ObservableSource, converted to the specified type.
final <U> Single<U> collect(Callable<? extends U> initialValueSupplier, BiConsumer<? super U, ? super T> collector)
Collects items emitted by the source ObservableSource into a single mutable data structure and returns a Single that emits this structure.
final <U> Single<U> collectInto(U initialValue, BiConsumer<? super U, ? super T> collector)
Collects items emitted by the source ObservableSource into a single mutable data structure and returns a Single that emits this structure.
static <T1, T2, T3, R> Observable<R> combineLatest(ObservableSource<? extends T1> source1, ObservableSource<? extends T2> source2, ObservableSource<? extends T3> source3, 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 source ObservableSources each time an item is received from any of the source ObservableSources, where this aggregation is defined by a specified function.
static <T1, T2, T3, T4, T5, T6, T7, T8, R> Observable<R> combineLatest(ObservableSource<? extends T1> source1, ObservableSource<? extends T2> source2, ObservableSource<? extends T3> source3, ObservableSource<? extends T4> source4, ObservableSource<? extends T5> source5, ObservableSource<? extends T6> source6, ObservableSource<? extends T7> source7, ObservableSource<? extends T8> source8, 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 source ObservableSources each time an item is received from any of the source ObservableSources, where this aggregation is defined by a specified function.
static <T, R> Observable<R> combineLatest(Iterable<? extends ObservableSource<? extends T>> sources, Function<? super Object[], ? extends R> combiner, int bufferSize)
Combines a collection of source ObservableSources by emitting an item that aggregates the latest values of each of the source ObservableSources each time an item is received from any of the source ObservableSources, where this aggregation is defined by a specified function.
static <T, R> Observable<R> combineLatest(Iterable<? extends ObservableSource<? extends T>> sources, 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 source ObservableSources each time an item is received from any of the source ObservableSources, where this aggregation is defined by a specified function.
static <T1, T2, T3, T4, T5, R> Observable<R> combineLatest(ObservableSource<? extends T1> source1, ObservableSource<? extends T2> source2, ObservableSource<? extends T3> source3, ObservableSource<? extends T4> source4, ObservableSource<? extends T5> source5, 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 source ObservableSources each time an item is received from any of the source ObservableSources, where this aggregation is defined by a specified function.
static <T1, T2, R> Observable<R> combineLatest(ObservableSource<? extends T1> source1, ObservableSource<? extends T2> source2, 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 source ObservableSources each time an item is received from either of the source ObservableSources, where this aggregation is defined by a specified function.
static <T1, T2, T3, T4, R> Observable<R> combineLatest(ObservableSource<? extends T1> source1, ObservableSource<? extends T2> source2, ObservableSource<? extends T3> source3, ObservableSource<? extends T4> source4, 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 source ObservableSources each time an item is received from any of the source ObservableSources, where this aggregation is defined by a specified function.
static <T, R> Observable<R> combineLatest(ObservableSource[]<? extends T> sources, 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 source ObservableSources each time an item is received from any of the source ObservableSources, where this aggregation is defined by a specified function.
static <T1, T2, T3, T4, T5, T6, T7, R> Observable<R> combineLatest(ObservableSource<? extends T1> source1, ObservableSource<? extends T2> source2, ObservableSource<? extends T3> source3, ObservableSource<? extends T4> source4, ObservableSource<? extends T5> source5, ObservableSource<? extends T6> source6, ObservableSource<? extends T7> source7, 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 source ObservableSources each time an item is received from any of the source ObservableSources, where this aggregation is defined by a specified function.
static <T, R> Observable<R> combineLatest(ObservableSource[]<? extends T> sources, Function<? super Object[], ? extends R> combiner, int bufferSize)
Combines a collection of source ObservableSources by emitting an item that aggregates the latest values of each of the source ObservableSources each time an item is received from any of the source ObservableSources, where this aggregation is defined by a specified function.
static <T1, T2, T3, T4, T5, T6, R> Observable<R> combineLatest(ObservableSource<? extends T1> source1, ObservableSource<? extends T2> source2, ObservableSource<? extends T3> source3, ObservableSource<? extends T4> source4, ObservableSource<? extends T5> source5, ObservableSource<? extends T6> source6, 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 source ObservableSources each time an item is received from any of the source ObservableSources, where this aggregation is defined by a specified function.
static <T, R> Observable<R> combineLatest(Function<? super Object[], ? extends R> combiner, int bufferSize, ObservableSource...<? extends T> sources)
Combines a collection of source ObservableSources by emitting an item that aggregates the latest values of each of the source ObservableSources each time an item is received from any of the source ObservableSources, where this aggregation is defined by a specified function.
static <T1, T2, T3, T4, T5, T6, T7, T8, T9, R> Observable<R> combineLatest(ObservableSource<? extends T1> source1, ObservableSource<? extends T2> source2, ObservableSource<? extends T3> source3, ObservableSource<? extends T4> source4, ObservableSource<? extends T5> source5, ObservableSource<? extends T6> source6, ObservableSource<? extends T7> source7, ObservableSource<? extends T8> source8, ObservableSource<? extends T9> source9, 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 source ObservableSources each time an item is received from any of the source ObservableSources, where this aggregation is defined by a specified function.
static <T, R> Observable<R> combineLatestDelayError(Iterable<? extends ObservableSource<? extends T>> sources, Function<? super Object[], ? extends R> combiner, int bufferSize)
Combines a collection of source ObservableSources by emitting an item that aggregates the latest values of each of the source ObservableSources each time an item is received from any of the source 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> Observable<R> combineLatestDelayError(Function<? super Object[], ? extends R> combiner, int bufferSize, ObservableSource...<? extends T> sources)
Combines a collection of source ObservableSources by emitting an item that aggregates the latest values of each of the source ObservableSources each time an item is received from any of the source 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> Observable<R> combineLatestDelayError(Iterable<? extends ObservableSource<? extends T>> sources, 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 source ObservableSources each time an item is received from any of the source 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> Observable<R> combineLatestDelayError(ObservableSource[]<? extends T> sources, Function<? super Object[], ? extends R> combiner, int bufferSize)
Combines a collection of source ObservableSources by emitting an item that aggregates the latest values of each of the source ObservableSources each time an item is received from any of the source 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> Observable<R> combineLatestDelayError(ObservableSource[]<? extends T> sources, 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 source ObservableSources each time an item is received from any of the source ObservableSources, where this aggregation is defined by a specified function.
final <R> Observable<R> compose(ObservableTransformer<? super T, ? extends R> composer)
Transform an ObservableSource by applying a particular Transformer function to it.
static <T> Observable<T> concat(ObservableSource<? extends T> source1, ObservableSource<? extends T> source2, ObservableSource<? extends T> source3)
Returns an Observable that emits the items emitted by three ObservableSources, one after the other, without interleaving them.
static <T> Observable<T> concat(ObservableSource<? extends ObservableSource<? extends T>> sources, int prefetch)
Returns an Observable that emits the items emitted by each of the ObservableSources emitted by the source ObservableSource, one after the other, without interleaving them.
static <T> Observable<T> concat(ObservableSource<? extends ObservableSource<? extends T>> sources)
Returns an Observable that emits the items emitted by each of the ObservableSources emitted by the source ObservableSource, one after the other, without interleaving them.
static <T> Observable<T> concat(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> Observable<T> concat(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> Observable<T> concat(ObservableSource<? extends T> source1, ObservableSource<? extends T> source2, ObservableSource<? extends T> source3, ObservableSource<? extends T> source4)
Returns an Observable that emits the items emitted by four ObservableSources, one after the other, without interleaving them.
static <T> Observable<T> concatArray(ObservableSource...<? extends T> sources)
Concatenates a variable number of ObservableSource sources.
static <T> 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> Observable<T> concatArrayEager(ObservableSource...<? extends T> sources)
Concatenates a sequence of ObservableSources eagerly into a single stream of values.
static <T> Observable<T> concatArrayEager(int maxConcurrency, int prefetch, ObservableSource...<? extends T> sources)
Concatenates a sequence of ObservableSources eagerly into a single stream of values.
static <T> Observable<T> concatDelayError(Iterable<? extends ObservableSource<? extends T>> sources)
Concatenates the Iterable sequence of ObservableSources into a single 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> Observable<T> concatDelayError(ObservableSource<? extends ObservableSource<? extends T>> sources, int prefetch, 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> Observable<T> concatDelayError(ObservableSource<? extends ObservableSource<? extends T>> sources)
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> Observable<T> concatEager(ObservableSource<? extends ObservableSource<? extends T>> sources, int maxConcurrency, int prefetch)
Concatenates an ObservableSource sequence of ObservableSources eagerly into a single stream of values.
static <T> Observable<T> concatEager(Iterable<? extends ObservableSource<? extends T>> sources, int maxConcurrency, int prefetch)
Concatenates a sequence of ObservableSources eagerly into a single stream of values.
static <T> Observable<T> concatEager(Iterable<? extends ObservableSource<? extends T>> sources)
Concatenates a sequence of ObservableSources eagerly into a single stream of values.
static <T> Observable<T> concatEager(ObservableSource<? extends ObservableSource<? extends T>> sources)
Concatenates an ObservableSource sequence of ObservableSources eagerly into a single stream of values.
final <R> Observable<R> concatMap(Function<? super T, ? extends ObservableSource<? extends R>> mapper, int prefetch)
Returns a new Observable that emits items resulting from applying a function that you supply to each item emitted by the source ObservableSource, where that function returns an ObservableSource, and then emitting the items that result from concatenating those resulting ObservableSources.
final <R> Observable<R> concatMap(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 source ObservableSource, where that function returns an ObservableSource, and then emitting the items that result from concatenating those resulting ObservableSources.
final <R> Observable<R> concatMapDelayError(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.
final <R> Observable<R> concatMapDelayError(Function<? super T, ? extends ObservableSource<? extends R>> mapper, int prefetch, boolean tillTheEnd)
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.
final <R> Observable<R> concatMapEager(Function<? super T, ? extends ObservableSource<? extends R>> mapper)
Maps a sequence of values into ObservableSources and concatenates these ObservableSources eagerly into a single ObservableSource.
final <R> Observable<R> concatMapEager(Function<? super T, ? extends ObservableSource<? extends R>> mapper, int maxConcurrency, int prefetch)
Maps a sequence of values into ObservableSources and concatenates these ObservableSources eagerly into a single ObservableSource.
final <R> Observable<R> concatMapEagerDelayError(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 ObservableSource.
final <R> Observable<R> concatMapEagerDelayError(Function<? super T, ? extends ObservableSource<? extends R>> mapper, int maxConcurrency, int prefetch, boolean tillTheEnd)
Maps a sequence of values into ObservableSources and concatenates these ObservableSources eagerly into a single ObservableSource.
final <U> Observable<U> concatMapIterable(Function<? super T, ? extends Iterable<? extends U>> mapper)
Returns an Observable that concatenate each item emitted by the source ObservableSource with the values in an Iterable corresponding to that item that is generated by a selector.
final <U> Observable<U> concatMapIterable(Function<? super T, ? extends Iterable<? extends U>> mapper, int prefetch)
Returns an Observable that concatenate each item emitted by the source ObservableSource with the values in an Iterable corresponding to that item that is generated by a selector.
final Observable<T> concatWith(ObservableSource<? extends T> other)
Returns an Observable that emits the items emitted from the current ObservableSource, then the next, one after the other, without interleaving them.
final Single<Boolean> contains(Object element)
Returns an Observable that emits a Boolean that indicates whether the source ObservableSource emitted a specified item.
final Single<Long> count()
Returns a Single that counts the total number of items emitted by the source ObservableSource and emits this count as a 64-bit Long.
static <T> Observable<T> create(ObservableOnSubscribe<T> source)
Provides an API (via a cold Observable) that bridges the reactive world with the callback-style world.
final Observable<T> debounce(long timeout, TimeUnit unit)
Returns an Observable that mirrors the source ObservableSource, except that it drops items emitted by the source ObservableSource that are followed by newer items before a timeout value expires.
final Observable<T> debounce(long timeout, TimeUnit unit, Scheduler scheduler)
Returns an Observable that mirrors the source ObservableSource, except that it drops items emitted by the source ObservableSource that are followed by newer items before a timeout value expires on a specified Scheduler.
final <U> Observable<T> debounce(Function<? super T, ? extends ObservableSource<U>> debounceSelector)
Returns an Observable that mirrors the source ObservableSource, except that it drops items emitted by the source ObservableSource that are followed by another item within a computed debounce duration.
final Observable<T> defaultIfEmpty(T defaultItem)
Returns an Observable that emits the items emitted by the source ObservableSource or a specified default item if the source ObservableSource is empty.
static <T> Observable<T> defer(Callable<? extends ObservableSource<? extends T>> supplier)
Returns an Observable that calls an ObservableSource factory to create an ObservableSource for each new Observer that subscribes.
final Observable<T> delay(long delay, TimeUnit unit, boolean delayError)
Returns an Observable that emits the items emitted by the source ObservableSource shifted forward in time by a specified delay.
final Observable<T> delay(long delay, TimeUnit unit, Scheduler scheduler)
Returns an Observable that emits the items emitted by the source ObservableSource shifted forward in time by a specified delay.
final Observable<T> delay(long delay, TimeUnit unit, Scheduler scheduler, boolean delayError)
Returns an Observable that emits the items emitted by the source ObservableSource shifted forward in time by a specified delay.
final <U> Observable<T> delay(Function<? super T, ? extends ObservableSource<U>> itemDelay)
Returns an Observable that delays the emissions of the source ObservableSource via another ObservableSource on a per-item basis.
final <U, V> Observable<T> delay(ObservableSource<U> subscriptionDelay, Function<? super T, ? extends ObservableSource<V>> itemDelay)
Returns an Observable that delays the subscription to and emissions from the source ObservableSource via another ObservableSource on a per-item basis.
final Observable<T> delay(long delay, TimeUnit unit)
Returns an Observable that emits the items emitted by the source ObservableSource shifted forward in time by a specified delay.
final Observable<T> delaySubscription(long delay, TimeUnit unit, Scheduler scheduler)
Returns an Observable that delays the subscription to the source ObservableSource by a given amount of time, both waiting and subscribing on a given Scheduler.
final Observable<T> delaySubscription(long delay, TimeUnit unit)
Returns an Observable that delays the subscription to the source ObservableSource by a given amount of time.
final <U> Observable<T> delaySubscription(ObservableSource<U> other)
Returns an Observable that delays the subscription to this Observable until the other Observable emits an element or completes normally.
final <T2> Observable<T2> dematerialize()
Returns an Observable that reverses the effect of materialize by transforming the Notification objects emitted by the source ObservableSource into the items or notifications they represent.
final Observable<T> distinct()
Returns an Observable that emits all items emitted by the source ObservableSource that are distinct.
final <K> Observable<T> distinct(Function<? super T, K> keySelector)
Returns an Observable that emits all items emitted by the source ObservableSource that are distinct according to a key selector function.
final <K> Observable<T> distinct(Function<? super T, K> keySelector, Callable<? extends Collection<? super K>> collectionSupplier)
Returns an Observable that emits all items emitted by the source ObservableSource that are distinct according to a key selector function.
final Observable<T> distinctUntilChanged(BiPredicate<? super T, ? super T> comparer)
Returns an Observable that emits all items emitted by the source ObservableSource that are distinct from their immediate predecessors when compared with each other via the provided comparator function.
final <K> Observable<T> distinctUntilChanged(Function<? super T, K> keySelector)
Returns an Observable that emits all items emitted by the source ObservableSource that are distinct from their immediate predecessors, according to a key selector function.
final Observable<T> distinctUntilChanged()
Returns an Observable that emits all items emitted by the source ObservableSource that are distinct from their immediate predecessors.
final Observable<T> doAfterNext(Consumer<? super T> onAfterNext)
Calls the specified consumer with the current item after this item has been emitted to the downstream.
final Observable<T> doAfterTerminate(Action onFinally)
Registers an Action to be called when this ObservableSource invokes either onComplete or onError.
final Observable<T> doFinally(Action onFinally)
Calls the specified action after this Observable signals onError or onCompleted or gets disposed by the downstream.
final Observable<T> doOnComplete(Action onComplete)
Modifies the source ObservableSource so that it invokes an action when it calls onComplete.
final Observable<T> doOnDispose(Action onDispose)
Calls the dispose Action if the downstream disposes the sequence.
final Observable<T> doOnEach(Observer<? super T> observer)
Modifies the source ObservableSource so that it notifies an Observer for each item and terminal event it emits.
final Observable<T> doOnEach(Consumer<? super Notification<T>> onNotification)
Modifies the source ObservableSource so that it invokes an action for each item it emits.
final Observable<T> doOnError(Consumer<? super Throwable> onError)
Modifies the source ObservableSource so that it invokes an action if it calls onError.
final Observable<T> doOnLifecycle(Consumer<? super Disposable> onSubscribe, Action onDispose)
Calls the appropriate onXXX method (shared between all Observer) for the lifecycle events of the sequence (subscription, cancellation, requesting).
final Observable<T> doOnNext(Consumer<? super T> onNext)
Modifies the source ObservableSource so that it invokes an action when it calls onNext.
final Observable<T> doOnSubscribe(Consumer<? super Disposable> onSubscribe)
Modifies the source ObservableSource so that it invokes the given action when it is subscribed from its subscribers.
final Observable<T> doOnTerminate(Action onTerminate)
Modifies the source ObservableSource so that it invokes an action when it calls onComplete or onError.
final Single<T> elementAt(long index, T defaultItem)
Returns a Single that emits the item found at a specified index in a sequence of emissions from this Observable, or a default item if that index is out of range.
final Maybe<T> elementAt(long index)
Returns a Maybe that emits the single item at a specified index in a sequence of emissions from this Observable or completes if this Observable signals fewer elements than index.
final Single<T> elementAtOrError(long index)
Returns a Single that emits the item found at a specified index in a sequence of emissions from this Observable or signals a NoSuchElementException if this Observable signals fewer elements than index.
static <T> Observable<T> empty()
Returns an Observable that emits no items to the Observer and immediately invokes its onComplete method.
static <T> Observable<T> error(Callable<? extends Throwable> errorSupplier)
Returns an Observable that invokes an Observer's onError method when the Observer subscribes to it.
static <T> Observable<T> error(Throwable exception)
Returns an Observable that invokes an Observer's onError method when the Observer subscribes to it.
final Observable<T> filter(Predicate<? super T> predicate)
Filters items emitted by an ObservableSource by only emitting those that satisfy a specified predicate.
final Single<T> first(T defaultItem)
Returns a Single that emits only the very first item emitted by the source ObservableSource, or a default item if the source ObservableSource completes without emitting any items.
final Maybe<T> firstElement()
Returns a Maybe that emits only the very first item emitted by the source ObservableSource, or completes if the source ObservableSource is empty.
final Single<T> firstOrError()
Returns a Single that emits only the very first item emitted by this Observable or signals a NoSuchElementException if this Observable is empty.
final <U, R> Observable<R> flatMap(Function<? super T, ? extends ObservableSource<? extends U>> mapper, 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 source ObservableSource and a specified collection ObservableSource, while limiting the maximum number of concurrent subscriptions to these ObservableSources.
final <R> Observable<R> flatMap(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 source ObservableSource, where that function returns an ObservableSource, and then merging those resulting ObservableSources and emitting the results of this merger.
final <R> Observable<R> flatMap(Function<? super T, ? extends ObservableSource<? extends R>> onNextMapper, Function<Throwable, ? extends ObservableSource<? extends R>> onErrorMapper, Callable<? extends ObservableSource<? extends R>> onCompleteSupplier, int maxConcurrency)
Returns an Observable that applies a function to each item emitted or notification raised by the source ObservableSource 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.
final <U, R> Observable<R> flatMap(Function<? super T, ? extends ObservableSource<? extends U>> mapper, 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 source ObservableSource and a specified collection ObservableSource, while limiting the maximum number of concurrent subscriptions to these ObservableSources.
final <R> Observable<R> flatMap(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 source ObservableSource, where that function returns an ObservableSource, and then merging those resulting ObservableSources and emitting the results of this merger.
final <U, R> Observable<R> flatMap(Function<? super T, ? extends ObservableSource<? extends U>> mapper, 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 source ObservableSource and a specified collection ObservableSource.
final <R> Observable<R> flatMap(Function<? super T, ? extends ObservableSource<? extends R>> onNextMapper, Function<? super Throwable, ? extends ObservableSource<? extends R>> onErrorMapper, Callable<? extends ObservableSource<? extends R>> onCompleteSupplier)
Returns an Observable that applies a function to each item emitted or notification raised by the source ObservableSource and then flattens the ObservableSources returned from these functions and emits the resulting items.
final <U, R> Observable<R> flatMap(Function<? super T, ? extends ObservableSource<? extends U>> mapper, 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 source ObservableSource and a specified collection ObservableSource, while limiting the maximum number of concurrent subscriptions to these ObservableSources.
final <R> Observable<R> flatMap(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 source ObservableSource, where that function returns an ObservableSource, and then merging those resulting ObservableSources and emitting the results of this merger, while limiting the maximum number of concurrent subscriptions to these ObservableSources.
final <R> Observable<R> flatMap(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 source ObservableSource, where that function returns an ObservableSource, and then merging those resulting ObservableSources and emitting the results of this merger, while limiting the maximum number of concurrent subscriptions to these ObservableSources.
final <R> Observable<R> flatMap(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 source ObservableSource, where that function returns an ObservableSource, and then merging those resulting ObservableSources and emitting the results of this merger, while limiting the maximum number of concurrent subscriptions to these ObservableSources.
final <U, R> Observable<R> flatMap(Function<? super T, ? extends ObservableSource<? extends U>> mapper, BiFunction<? super T, ? super U, ? extends R> resultSelector)
Returns an Observable that emits the results of a specified function to the pair of values emitted by the source ObservableSource and a specified collection ObservableSource.
final Completable flatMapCompletable(Function<? super T, ? extends CompletableSource> mapper, boolean delayErrors)
Maps each element of the upstream Observable into CompletableSources, subscribes to them and waits until the upstream and all CompletableSources complete, optionally delaying all errors.
final Completable flatMapCompletable(Function<? super T, ? extends CompletableSource> mapper)
Maps each element of the upstream Observable into CompletableSources, subscribes to them and waits until the upstream and all CompletableSources complete.
final <U, V> Observable<V> flatMapIterable(Function<? super T, ? extends Iterable<? extends U>> mapper, BiFunction<? super T, ? super U, ? extends V> resultSelector)
Returns an Observable that emits the results of applying a function to the pair of values from the source ObservableSource and an Iterable corresponding to that item that is generated by a selector.
final <U> Observable<U> flatMapIterable(Function<? super T, ? extends Iterable<? extends U>> mapper)
Returns an Observable that merges each item emitted by the source ObservableSource with the values in an Iterable corresponding to that item that is generated by a selector.
final <R> Observable<R> flatMapMaybe(Function<? super T, ? extends MaybeSource<? extends R>> mapper, boolean delayErrors)
Maps each element of the upstream Observable into MaybeSources, subscribes to them and waits until the upstream and all MaybeSources complete, optionally delaying all errors.
final <R> Observable<R> flatMapMaybe(Function<? super T, ? extends MaybeSource<? extends R>> mapper)
Maps each element of the upstream Observable into MaybeSources, subscribes to them and waits until the upstream and all MaybeSources complete.
final <R> Observable<R> flatMapSingle(Function<? super T, ? extends SingleSource<? extends R>> mapper)
Maps each element of the upstream Observable into SingleSources, subscribes to them and waits until the upstream and all SingleSources complete.
final <R> Observable<R> flatMapSingle(Function<? super T, ? extends SingleSource<? extends R>> mapper, boolean delayErrors)
Maps each element of the upstream Observable into SingleSources, subscribes to them and waits until the upstream and all SingleSources complete, optionally delaying all errors.
final Disposable forEach(Consumer<? super T> onNext)
Subscribes to the ObservableSource and receives notifications for each element.
final Disposable forEachWhile(Predicate<? super T> onNext, Consumer<? super Throwable> onError, Action onComplete)
Subscribes to the ObservableSource and receives notifications for each element and the terminal events until the onNext Predicate returns false.
final Disposable forEachWhile(Predicate<? super T> onNext, Consumer<? super Throwable> onError)
Subscribes to the ObservableSource and receives notifications for each element and error events until the onNext Predicate returns false.
final Disposable forEachWhile(Predicate<? super T> onNext)
Subscribes to the ObservableSource and receives notifications for each element until the onNext Predicate returns false.
static <T> Observable<T> fromArray(T... items)
Converts an Array into an ObservableSource that emits the items in the Array.
static <T> Observable<T> fromCallable(Callable<? extends T> supplier)
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> Observable<T> fromFuture(Future<? extends T> future, Scheduler scheduler)
Converts a Future, operating on a specified Scheduler, into an ObservableSource.
static <T> Observable<T> fromFuture(Future<? extends T> future, long timeout, TimeUnit unit, Scheduler scheduler)
Converts a Future into an ObservableSource, with a timeout on the Future.
static <T> Observable<T> fromFuture(Future<? extends T> future, long timeout, TimeUnit unit)
Converts a Future into an ObservableSource, with a timeout on the Future.
static <T> Observable<T> fromFuture(Future<? extends T> future)
Converts a Future into an ObservableSource.
static <T> Observable<T> fromIterable(Iterable<? extends T> source)
Converts an Iterable sequence into an ObservableSource that emits the items in the sequence.
static <T> Observable<T> fromPublisher(Publisher<? extends T> publisher)
Converts an arbitrary Reactive-Streams Publisher into an Observable.
static <T, S> Observable<T> generate(Callable<S> initialState, BiFunction<S, Emitter<T>, S> generator, Consumer<? super S> disposeState)
Returns a cold, synchronous and stateful generator of values.
static <T, S> Observable<T> generate(Callable<S> initialState, BiFunction<S, Emitter<T>, S> generator)
Returns a cold, synchronous and stateful generator of values.
static <T, S> Observable<T> generate(Callable<S> initialState, BiConsumer<S, Emitter<T>> generator)
Returns a cold, synchronous and stateful generator of values.
static <T, S> Observable<T> generate(Callable<S> initialState, BiConsumer<S, Emitter<T>> generator, Consumer<? super S> disposeState)
Returns a cold, synchronous and stateful generator of values.
static <T> Observable<T> generate(Consumer<Emitter<T>> generator)
Returns a cold, synchronous and stateless generator of values.
final <K> Observable<GroupedObservable<K, T>> groupBy(Function<? super T, ? extends K> keySelector, boolean delayError)
Groups the items emitted by an ObservableSource according to a specified criterion, and emits these grouped items as GroupedObservables.
final <K> Observable<GroupedObservable<K, T>> groupBy(Function<? super T, ? extends K> keySelector)
Groups the items emitted by an ObservableSource according to a specified criterion, and emits these grouped items as GroupedObservables.
final <K, V> Observable<GroupedObservable<K, V>> groupBy(Function<? super T, ? extends K> keySelector, Function<? super T, ? extends V> valueSelector)
Groups the items emitted by an ObservableSource according to a specified criterion, and emits these grouped items as GroupedObservables.
final <K, V> Observable<GroupedObservable<K, V>> groupBy(Function<? super T, ? extends K> keySelector, Function<? super T, ? extends V> valueSelector, boolean delayError)
Groups the items emitted by an ObservableSource according to a specified criterion, and emits these grouped items as GroupedObservables.
final <K, V> Observable<GroupedObservable<K, V>> groupBy(Function<? super T, ? extends K> keySelector, Function<? super T, ? extends V> valueSelector, boolean delayError, int bufferSize)
Groups the items emitted by an ObservableSource according to a specified criterion, and emits these grouped items as GroupedObservables.
final <TRight, TLeftEnd, TRightEnd, R> Observable<R> groupJoin(ObservableSource<? extends TRight> other, Function<? super T, ? extends ObservableSource<TLeftEnd>> leftEnd, Function<? super TRight, ? extends ObservableSource<TRightEnd>> rightEnd, 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.
final Observable<T> hide()
Hides the identity of this Observable and its Disposable.
final Completable ignoreElements()
Ignores all items emitted by the source ObservableSource and only calls onComplete or onError.
static Observable<Long> interval(long period, TimeUnit unit, Scheduler scheduler)
Returns an Observable that emits a sequential number every specified interval of time, on a specified Scheduler.
static Observable<Long> interval(long period, TimeUnit unit)
Returns an Observable that emits a sequential number every specified interval of time.
static Observable<Long> interval(long initialDelay, long period, TimeUnit unit, 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 Observable<Long> interval(long initialDelay, long period, TimeUnit unit)
Returns an Observable that emits a 0L after the initialDelay and ever increasing numbers after each period of time thereafter.
static Observable<Long> intervalRange(long start, long count, long initialDelay, long period, TimeUnit unit, Scheduler scheduler)
Signals a range of long values, the first after some initial delay and the rest periodically after.
static Observable<Long> intervalRange(long start, long count, long initialDelay, long period, TimeUnit unit)
Signals a range of long values, the first after some initial delay and the rest periodically after.
final Single<Boolean> isEmpty()
Returns an Observable that emits true if the source ObservableSource is empty, otherwise false.
final <TRight, TLeftEnd, TRightEnd, R> Observable<R> join(ObservableSource<? extends TRight> other, Function<? super T, ? extends ObservableSource<TLeftEnd>> leftEnd, Function<? super TRight, ? extends ObservableSource<TRightEnd>> rightEnd, BiFunction<? super T, ? super TRight, ? extends R> resultSelector)
Correlates the items emitted by two ObservableSources based on overlapping durations.
static <T> Observable<T> just(T item1, T item2, T item3, T item4, T item5, T item6)
Converts six items into an ObservableSource that emits those items.
static <T> Observable<T> just(T item1, T item2)
Converts two items into an ObservableSource that emits those items.
static <T> Observable<T> just(T item1, T item2, T item3, T item4)
Converts four items into an ObservableSource that emits those items.
static <T> Observable<T> just(T item)
Returns an Observable that emits a single item and then completes.
static <T> Observable<T> just(T item1, T item2, T item3, T item4, T item5)
Converts five items into an ObservableSource that emits those items.
static <T> Observable<T> just(T item1, T item2, T item3, T item4, T item5, T item6, T item7)
Converts seven items into an ObservableSource that emits those items.
static <T> Observable<T> just(T item1, T item2, T item3, T item4, T item5, T item6, T item7, T item8)
Converts eight items into an ObservableSource that emits those items.
static <T> 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 ObservableSource that emits those items.
static <T> 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 ObservableSource that emits those items.
static <T> Observable<T> just(T item1, T item2, T item3)
Converts three items into an ObservableSource that emits those items.
final Single<T> last(T defaultItem)
Returns a Single that emits only the last item emitted by this Observable, or a default item if this Observable completes without emitting any items.
final Maybe<T> lastElement()
Returns a Maybe that emits the last item emitted by this Observable or completes if this Observable is empty.
final Single<T> lastOrError()
Returns a Single that emits only the last item emitted by this Observable or signals a NoSuchElementException if this Observable is empty.
final <R> Observable<R> lift(ObservableOperator<? extends R, ? super T> lifter)
This method requires advanced knowledge about building operators; please consider other standard composition methods first; Lifts a function to the current ObservableSource and returns a new ObservableSource that when subscribed to will pass the values of the current ObservableSource through the Operator function.
final <R> Observable<R> map(Function<? super T, ? extends R> mapper)
Returns an Observable that applies a specified function to each item emitted by the source ObservableSource and emits the results of these function applications.
final Observable<Notification<T>> materialize()
Returns an Observable that represents all of the emissions and notifications from the source ObservableSource into emissions marked with their original types within Notification objects.
static <T> Observable<T> merge(Iterable<? extends ObservableSource<? extends T>> sources)
Flattens an Iterable of ObservableSources into one ObservableSource, without any transformation.
static <T> Observable<T> merge(ObservableSource<? extends ObservableSource<? extends T>> sources)
Flattens an ObservableSource that emits ObservableSources into a single ObservableSource that emits the items emitted by those ObservableSources, without any transformation.
static <T> Observable<T> merge(ObservableSource<? extends T> source1, ObservableSource<? extends T> source2)
Flattens two ObservableSources into a single ObservableSource, without any transformation.
static <T> Observable<T> merge(Iterable<? extends ObservableSource<? extends T>> sources, int maxConcurrency, int bufferSize)
Flattens an Iterable of ObservableSources into one ObservableSource, without any transformation, while limiting the number of concurrent subscriptions to these ObservableSources.
static <T> Observable<T> merge(Iterable<? extends ObservableSource<? extends T>> sources, int maxConcurrency)
Flattens an Iterable of ObservableSources into one ObservableSource, without any transformation, while limiting the number of concurrent subscriptions to these ObservableSources.
static <T> Observable<T> merge(ObservableSource<? extends T> source1, ObservableSource<? extends T> source2, ObservableSource<? extends T> source3)
Flattens three ObservableSources into a single ObservableSource, without any transformation.
static <T> Observable<T> merge(ObservableSource<? extends ObservableSource<? extends T>> sources, int maxConcurrency)
Flattens an ObservableSource that emits ObservableSources into a single ObservableSource that emits the items emitted by those ObservableSources, without any transformation, while limiting the maximum number of concurrent subscriptions to these ObservableSources.
static <T> Observable<T> merge(ObservableSource<? extends T> source1, ObservableSource<? extends T> source2, ObservableSource<? extends T> source3, ObservableSource<? extends T> source4)
Flattens four ObservableSources into a single ObservableSource, without any transformation.
static <T> Observable<T> mergeArray(int maxConcurrency, int bufferSize, ObservableSource...<? extends T> sources)
Flattens an Iterable of ObservableSources into one ObservableSource, without any transformation, while limiting the number of concurrent subscriptions to these ObservableSources.
static <T> Observable<T> mergeArray(ObservableSource...<? extends T> sources)
Flattens an Array of ObservableSources into one ObservableSource, without any transformation.
static <T> Observable<T> mergeArrayDelayError(ObservableSource...<? extends T> sources)
Flattens an Iterable of ObservableSources into one ObservableSource, in a way that allows an Observer to receive all successfully emitted items from each of the source ObservableSources without being interrupted by an error notification from one of them.
static <T> Observable<T> mergeArrayDelayError(int maxConcurrency, int bufferSize, ObservableSource...<? extends T> sources)
Flattens an array of ObservableSources into one ObservableSource, in a way that allows an Observer to receive all successfully emitted items from each of the source ObservableSources without being interrupted by an error notification from one of them, while limiting the number of concurrent subscriptions to these ObservableSources.
static <T> Observable<T> mergeDelayError(ObservableSource<? extends T> source1, ObservableSource<? extends T> source2, ObservableSource<? extends T> source3, ObservableSource<? extends T> source4)
Flattens four ObservableSources into one ObservableSource, in a way that allows an Observer to receive all successfully emitted items from all of the source ObservableSources without being interrupted by an error notification from one of them.
static <T> Observable<T> mergeDelayError(Iterable<? extends ObservableSource<? extends T>> sources)
Flattens an Iterable of ObservableSources into one ObservableSource, in a way that allows an Observer to receive all successfully emitted items from each of the source ObservableSources without being interrupted by an error notification from one of them.
static <T> Observable<T> mergeDelayError(ObservableSource<? extends T> source1, ObservableSource<? extends T> source2)
Flattens two ObservableSources into one ObservableSource, in a way that allows an Observer to receive all successfully emitted items from each of the source ObservableSources without being interrupted by an error notification from one of them.
static <T> Observable<T> mergeDelayError(ObservableSource<? extends T> source1, ObservableSource<? extends T> source2, ObservableSource<? extends T> source3)
Flattens three ObservableSources into one ObservableSource, in a way that allows an Observer to receive all successfully emitted items from all of the source ObservableSources without being interrupted by an error notification from one of them.
static <T> Observable<T> mergeDelayError(ObservableSource<? extends ObservableSource<? extends T>> sources)
Flattens an ObservableSource that emits ObservableSources into one ObservableSource, in a way that allows an Observer to receive all successfully emitted items from all of the source ObservableSources without being interrupted by an error notification from one of them.
static <T> Observable<T> mergeDelayError(Iterable<? extends ObservableSource<? extends T>> sources, int maxConcurrency, int bufferSize)
Flattens an Iterable of ObservableSources into one ObservableSource, in a way that allows an Observer to receive all successfully emitted items from each of the source ObservableSources without being interrupted by an error notification from one of them, while limiting the number of concurrent subscriptions to these ObservableSources.
static <T> Observable<T> mergeDelayError(Iterable<? extends ObservableSource<? extends T>> sources, int maxConcurrency)
Flattens an Iterable of ObservableSources into one ObservableSource, in a way that allows an Observer to receive all successfully emitted items from each of the source ObservableSources without being interrupted by an error notification from one of them, while limiting the number of concurrent subscriptions to these ObservableSources.
static <T> Observable<T> mergeDelayError(ObservableSource<? extends ObservableSource<? extends T>> sources, int maxConcurrency)
Flattens an ObservableSource that emits ObservableSources into one ObservableSource, in a way that allows an Observer to receive all successfully emitted items from all of the source ObservableSources without being interrupted by an error notification from one of them, while limiting the number of concurrent subscriptions to these ObservableSources.
final Observable<T> mergeWith(ObservableSource<? extends T> other)
Flattens this and another ObservableSource into a single ObservableSource, without any transformation.
static <T> Observable<T> never()
Returns an Observable that never sends any items or notifications to an Observer.
final Observable<T> observeOn(Scheduler scheduler, boolean delayError)
Modifies an ObservableSource to perform its emissions and notifications on a specified Scheduler, asynchronously with an unbounded buffer with bufferSize() "island size" and optionally delays onError notifications.
final Observable<T> observeOn(Scheduler scheduler)
Modifies an ObservableSource to perform its emissions and notifications on a specified Scheduler, asynchronously with an unbounded buffer with bufferSize() "island size".
final Observable<T> observeOn(Scheduler scheduler, boolean delayError, int bufferSize)
Modifies an ObservableSource to perform its emissions and notifications on a specified Scheduler, asynchronously with an unbounded buffer of configurable "island size" and optionally delays onError notifications.
final <U> Observable<U> ofType(Class<U> clazz)
Filters the items emitted by an ObservableSource, only emitting those of the specified type.
final Observable<T> onErrorResumeNext(Function<? super Throwable, ? extends ObservableSource<? extends T>> resumeFunction)
Instructs an ObservableSource to pass control to another ObservableSource rather than invoking onError if it encounters an error.
final Observable<T> onErrorResumeNext(ObservableSource<? extends T> next)
Instructs an ObservableSource to pass control to another ObservableSource rather than invoking onError if it encounters an error.
final Observable<T> onErrorReturn(Function<? super Throwable, ? extends T> valueSupplier)
Instructs an ObservableSource to emit an item (returned by a specified function) rather than invoking onError if it encounters an error.
final Observable<T> onErrorReturnItem(T item)
Instructs an ObservableSource to emit an item (returned by a specified function) rather than invoking onError if it encounters an error.
final Observable<T> onExceptionResumeNext(ObservableSource<? extends T> next)
Instructs an ObservableSource to pass control to another ObservableSource rather than invoking onError if it encounters an Exception.
final Observable<T> onTerminateDetach()
Nulls out references to the upstream producer and downstream Observer if the sequence is terminated or downstream calls dispose().
final 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.
final <R> Observable<R> publish(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 underlying sequence.
static Observable<Integer> range(int start, int count)
Returns an Observable that emits a sequence of Integers within a specified range.
static Observable<Long> rangeLong(long start, long count)
Returns an Observable that emits a sequence of Longs within a specified range.
final Maybe<T> reduce(BiFunction<T, T, T> reducer)
Returns a Maybe that applies a specified accumulator function to the first item emitted by a source ObservableSource, then feeds the result of that function along with the second item emitted by the source ObservableSource into the same function, and so on until all items have been emitted by the source ObservableSource, and emits the final result from the final call to your function as its sole item.
final <R> Single<R> reduce(R seed, BiFunction<R, ? super T, R> reducer)
Returns a Single that applies a specified accumulator function to the first item emitted by a source ObservableSource and a specified seed value, then feeds the result of that function along with the second item emitted by an ObservableSource into the same function, and so on until all items have been emitted by the source ObservableSource, emitting the final result from the final call to your function as its sole item.
final <R> Single<R> reduceWith(Callable<R> seedSupplier, BiFunction<R, ? super T, R> reducer)
Returns a Single that applies a specified accumulator function to the first item emitted by a source ObservableSource and a seed value derived from calling a specified seedSupplier, then feeds the result of that function along with the second item emitted by an ObservableSource into the same function, and so on until all items have been emitted by the source ObservableSource, emitting the final result from the final call to your function as its sole item.
final Observable<T> repeat()
Returns an Observable that repeats the sequence of items emitted by the source ObservableSource indefinitely.
final Observable<T> repeat(long times)
Returns an Observable that repeats the sequence of items emitted by the source ObservableSource at most count times.
final Observable<T> repeatUntil(BooleanSupplier stop)
Returns an Observable that repeats the sequence of items emitted by the source ObservableSource until the provided stop function returns true.
final Observable<T> repeatWhen(Function<? super Observable<Object>, ? extends ObservableSource<?>> handler)
Returns an Observable that emits the same values as the source ObservableSource with the exception of an onComplete.
final <R> Observable<R> replay(Function<? super Observable<T>, ? extends ObservableSource<R>> selector, int bufferSize, 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 source ObservableSource, replaying a maximum of bufferSize items.
final <R> Observable<R> replay(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 source ObservableSource, replaying bufferSize notifications.
final <R> Observable<R> replay(Function<? super Observable<T>, ? extends ObservableSource<R>> selector, int bufferSize, long time, TimeUnit unit, 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 source ObservableSource, replaying no more than bufferSize items that were emitted within a specified time window.
final ConnectableObservable<T> replay(int bufferSize, long time, TimeUnit unit)
Returns a ConnectableObservable that shares a single subscription to the source ObservableSource and replays at most bufferSize items that were emitted during a specified time window.
final ConnectableObservable<T> replay(int bufferSize, long time, TimeUnit unit, Scheduler scheduler)
Returns a ConnectableObservable that shares a single subscription to the source ObservableSource and that replays a maximum of bufferSize items that are emitted within a specified time window.
final ConnectableObservable<T> replay(int bufferSize)
Returns a ConnectableObservable that shares a single subscription to the source ObservableSource that replays at most bufferSize items emitted by that ObservableSource.
final ConnectableObservable<T> replay()
Returns a ConnectableObservable that shares a single subscription to the underlying ObservableSource that will replay all of its items and notifications to any future Observer.
final <R> Observable<R> replay(Function<? super Observable<T>, ? extends ObservableSource<R>> selector, int bufferSize, long time, 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 source ObservableSource, replaying no more than bufferSize items that were emitted within a specified time window.
final ConnectableObservable<T> replay(long time, TimeUnit unit)
Returns a ConnectableObservable that shares a single subscription to the source ObservableSource and replays all items emitted by that ObservableSource within a specified time window.
final <R> Observable<R> replay(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 source ObservableSource.
final <R> Observable<R> replay(Function<? super Observable<T>, ? extends ObservableSource<R>> selector, 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 source ObservableSource.
final ConnectableObservable<T> replay(Scheduler scheduler)
Returns a ConnectableObservable that shares a single subscription to the source ObservableSource that will replay all of its items and notifications to any future Observer on the given Scheduler.
final ConnectableObservable<T> replay(int bufferSize, Scheduler scheduler)
Returns a ConnectableObservable that shares a single subscription to the source ObservableSource and replays at most bufferSize items emitted by that ObservableSource.
final <R> Observable<R> replay(Function<? super Observable<T>, ? extends ObservableSource<R>> selector, long time, 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 source ObservableSource, replaying all items that were emitted within a specified time window.
final <R> Observable<R> replay(Function<? super Observable<T>, ? extends ObservableSource<R>> selector, long time, TimeUnit unit, 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 source ObservableSource, replaying all items that were emitted within a specified time window.
final ConnectableObservable<T> replay(long time, TimeUnit unit, Scheduler scheduler)
Returns a ConnectableObservable that shares a single subscription to the source ObservableSource and replays all items emitted by that ObservableSource within a specified time window.
final Observable<T> retry()
Returns an Observable that mirrors the source ObservableSource, resubscribing to it if it calls onError (infinite retry count).
final Observable<T> retry(long times)
Returns an Observable that mirrors the source ObservableSource, resubscribing to it if it calls onError up to a specified number of retries.
final Observable<T> retry(long times, Predicate<? super Throwable> predicate)
Retries at most times or until the predicate returns false, whichever happens first.
final Observable<T> retry(BiPredicate<? super Integer, ? super Throwable> predicate)
Returns an Observable that mirrors the source ObservableSource, resubscribing to it if it calls onError and the predicate returns true for that specific exception and retry count.
final Observable<T> retry(Predicate<? super Throwable> predicate)
Retries the current Observable if the predicate returns true.
final Observable<T> retryUntil(BooleanSupplier stop)
Retries until the given stop function returns true.
final Observable<T> retryWhen(Function<? super Observable<Throwable>, ? extends ObservableSource<?>> handler)
Returns an Observable that emits the same values as the source ObservableSource with the exception of an onError.
final void safeSubscribe(Observer<? super T> s)
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).
final Observable<T> sample(long period, TimeUnit unit, Scheduler scheduler)
Returns an Observable that emits the most recently emitted item (if any) emitted by the source ObservableSource within periodic time intervals, where the intervals are defined on a particular Scheduler.
final Observable<T> sample(long period, TimeUnit unit)
Returns an Observable that emits the most recently emitted item (if any) emitted by the source ObservableSource within periodic time intervals.
final <U> Observable<T> sample(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 source ObservableSource since the previous emission from the sampler ObservableSource.
final Observable<T> sample(long period, TimeUnit unit, boolean emitLast)
Returns an Observable that emits the most recently emitted item (if any) emitted by the source ObservableSource within periodic time intervals and optionally emit the very last upstream item when the upstream completes.
final Observable<T> sample(long period, TimeUnit unit, Scheduler scheduler, boolean emitLast)
Returns an Observable that emits the most recently emitted item (if any) emitted by the source ObservableSource within periodic time intervals, where the intervals are defined on a particular Scheduler and optionally emit the very last upstream item when the upstream completes.
final <U> Observable<T> sample(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 source ObservableSource since the previous emission from the sampler ObservableSource and optionally emit the very last upstream item when the upstream or other ObservableSource complete.
final <R> Observable<R> scan(R initialValue, BiFunction<R, ? super T, R> accumulator)
Returns an Observable that applies a specified accumulator function to the first item emitted by a source ObservableSource and a seed value, then feeds the result of that function along with the second item emitted by the source ObservableSource into the same function, and so on until all items have been emitted by the source ObservableSource, emitting the result of each of these iterations.
final Observable<T> scan(BiFunction<T, T, T> accumulator)
Returns an Observable that applies a specified accumulator function to the first item emitted by a source ObservableSource, then feeds the result of that function along with the second item emitted by the source ObservableSource into the same function, and so on until all items have been emitted by the source ObservableSource, emitting the result of each of these iterations.
final <R> Observable<R> scanWith(Callable<R> seedSupplier, BiFunction<R, ? super T, R> accumulator)
Returns an Observable that applies a specified accumulator function to the first item emitted by a source ObservableSource and a seed value, then feeds the result of that function along with the second item emitted by the source ObservableSource into the same function, and so on until all items have been emitted by the source ObservableSource, emitting the result of each of these iterations.
static <T> Single<Boolean> sequenceEqual(ObservableSource<? extends T> source1, 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.
static <T> Single<Boolean> sequenceEqual(ObservableSource<? extends T> source1, ObservableSource<? extends T> source2, 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> Single<Boolean> sequenceEqual(ObservableSource<? extends T> source1, ObservableSource<? extends T> source2, 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> Single<Boolean> sequenceEqual(ObservableSource<? extends T> source1, 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.
final Observable<T> serialize()
Forces an ObservableSource's emissions and notifications to be serialized and for it to obey the ObservableSource contract in other ways.
final Observable<T> share()
Returns a new ObservableSource that multicasts (shares) the original ObservableSource.
final Single<T> single(T defaultItem)
Returns a Single that emits the single item emitted by this Observable, if this Observable emits only a single item, or a default item if the source ObservableSource emits no items.
final Maybe<T> singleElement()
Returns a Maybe that emits the single item emitted by this Observable if this Observable emits only a single item, otherwise if this Observable emits more than one item or no items, an IllegalArgumentException or NoSuchElementException is signalled respectively.
final Single<T> singleOrError()
Returns a Single that emits the single item emitted by this Observable if this Observable emits only a single item, otherwise if this Observable completes without emitting any items or emits more than one item a NoSuchElementException or IllegalArgumentException will be signalled respectively.
final Observable<T> skip(long count)
Returns an Observable that skips the first count items emitted by the source ObservableSource and emits the remainder.
final Observable<T> skip(long time, TimeUnit unit, Scheduler scheduler)
Returns an Observable that skips values emitted by the source ObservableSource before a specified time window on a specified Scheduler elapses.
final Observable<T> skip(long time, TimeUnit unit)
Returns an Observable that skips values emitted by the source ObservableSource before a specified time window elapses.
final Observable<T> skipLast(int count)
Returns an Observable that drops a specified number of items from the end of the sequence emitted by the source ObservableSource.
final Observable<T> skipLast(long time, TimeUnit unit)
Returns an Observable that drops items emitted by the source ObservableSource during a specified time window before the source completes.
final Observable<T> skipLast(long time, TimeUnit unit, boolean delayError)
Returns an Observable that drops items emitted by the source ObservableSource during a specified time window before the source completes.
final Observable<T> skipLast(long time, TimeUnit unit, Scheduler scheduler)
Returns an Observable that drops items emitted by the source ObservableSource during a specified time window (defined on a specified scheduler) before the source completes.
final Observable<T> skipLast(long time, TimeUnit unit, Scheduler scheduler, boolean delayError, int bufferSize)
Returns an Observable that drops items emitted by the source ObservableSource during a specified time window (defined on a specified scheduler) before the source completes.
final Observable<T> skipLast(long time, TimeUnit unit, Scheduler scheduler, boolean delayError)
Returns an Observable that drops items emitted by the source ObservableSource during a specified time window (defined on a specified scheduler) before the source completes.
final <U> Observable<T> skipUntil(ObservableSource<U> other)
Returns an Observable that skips items emitted by the source ObservableSource until a second ObservableSource emits an item.
final Observable<T> skipWhile(Predicate<? super T> predicate)
Returns an Observable that skips all items emitted by the source ObservableSource as long as a specified condition holds true, but emits all further source items as soon as the condition becomes false.
final Observable<T> sorted()
Returns an Observable that emits the events emitted by source ObservableSource, in a sorted order.
final Observable<T> sorted(Comparator<? super T> sortFunction)
Returns an Observable that emits the events emitted by source ObservableSource, in a sorted order based on a specified comparison function.
final Observable<T> startWith(ObservableSource<? extends T> other)
Returns an Observable that emits the items in a specified ObservableSource before it begins to emit items emitted by the source ObservableSource.
final Observable<T> startWith(Iterable<? extends T> items)
Returns an Observable that emits the items in a specified Iterable before it begins to emit items emitted by the source ObservableSource.
final Observable<T> startWith(T item)
Returns an Observable that emits a specified item before it begins to emit items emitted by the source ObservableSource.
final Observable<T> startWithArray(T... items)
Returns an Observable that emits the specified items before it begins to emit items emitted by the source ObservableSource.
final Disposable subscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError, Action onComplete, Consumer<? super Disposable> onSubscribe)
Subscribes to an ObservableSource and provides callbacks to handle the items it emits and any error or completion notification it issues.
final void subscribe(Observer<? super T> observer)
Subscribes the given Observer to this ObservableSource instance.
final Disposable subscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError, Action onComplete)
Subscribes to an ObservableSource and provides callbacks to handle the items it emits and any error or completion notification it issues.
final Disposable subscribe()
Subscribes to an ObservableSource and ignores onNext and onComplete emissions.
final Disposable subscribe(Consumer<? super T> onNext)
Subscribes to an ObservableSource and provides a callback to handle the items it emits.
final Disposable subscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError)
Subscribes to an ObservableSource and provides callbacks to handle the items it emits and any error notification it issues.
final Observable<T> subscribeOn(Scheduler scheduler)
Asynchronously subscribes Observers to this ObservableSource on the specified Scheduler.
final <E extends Observer<? super T>> E subscribeWith(E observer)
Subscribes a given Observer (subclass) to this Observable and returns the given Observer as is.
final Observable<T> switchIfEmpty(ObservableSource<? extends T> other)
Returns an Observable that emits the items emitted by the source ObservableSource or the items of an alternate ObservableSource if the source ObservableSource is empty.
final <R> Observable<R> switchMap(Function<? super T, ? extends ObservableSource<? extends R>> mapper)
Returns a new ObservableSource by applying a function that you supply to each item emitted by the source ObservableSource that returns an ObservableSource, and then emitting the items emitted by the most recently emitted of these ObservableSources.
final <R> Observable<R> switchMap(Function<? super T, ? extends ObservableSource<? extends R>> mapper, int bufferSize)
Returns a new ObservableSource by applying a function that you supply to each item emitted by the source ObservableSource that returns an ObservableSource, and then emitting the items emitted by the most recently emitted of these ObservableSources.
final <R> Observable<R> switchMapDelayError(Function<? super T, ? extends ObservableSource<? extends R>> mapper)
Returns a new ObservableSource by applying a function that you supply to each item emitted by the source ObservableSource 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.
final <R> Observable<R> switchMapDelayError(Function<? super T, ? extends ObservableSource<? extends R>> mapper, int bufferSize)
Returns a new ObservableSource by applying a function that you supply to each item emitted by the source ObservableSource 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.
final <R> Observable<R> switchMapSingle(Function<? super T, ? extends SingleSource<? extends R>> mapper)
Returns a new ObservableSource by applying a function that you supply to each item emitted by the source ObservableSource that returns a SingleSource, and then emitting the item emitted by the most recently emitted of these SingleSources.
final <R> Observable<R> switchMapSingleDelayError(Function<? super T, ? extends SingleSource<? extends R>> mapper)
Returns a new ObservableSource by applying a function that you supply to each item emitted by the source ObservableSource 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> Observable<T> switchOnNext(ObservableSource<? extends ObservableSource<? extends T>> sources, int bufferSize)
Converts an ObservableSource that emits ObservableSources into an ObservableSource that emits the items emitted by the most recently emitted of those ObservableSources.
static <T> Observable<T> switchOnNext(ObservableSource<? extends ObservableSource<? extends T>> sources)
Converts an ObservableSource that emits ObservableSources into an ObservableSource that emits the items emitted by the most recently emitted of those ObservableSources.
static <T> Observable<T> switchOnNextDelayError(ObservableSource<? extends ObservableSource<? extends T>> sources, int prefetch)
Converts an ObservableSource that emits ObservableSources into an ObservableSource that emits the items emitted by the most recently emitted of those ObservableSources and delays any exception until all ObservableSources terminate.
static <T> Observable<T> switchOnNextDelayError(ObservableSource<? extends ObservableSource<? extends T>> sources)
Converts an ObservableSource that emits ObservableSources into an ObservableSource that emits the items emitted by the most recently emitted of those ObservableSources and delays any exception until all ObservableSources terminate.
final Observable<T> take(long time, TimeUnit unit)
Returns an Observable that emits those items emitted by source ObservableSource before a specified time runs out.
final Observable<T> take(long time, TimeUnit unit, Scheduler scheduler)
Returns an Observable that emits those items emitted by source ObservableSource before a specified time (on a specified Scheduler) runs out.
final Observable<T> take(long count)
Returns an Observable that emits only the first count items emitted by the source ObservableSource.
final Observable<T> takeLast(long time, TimeUnit unit, boolean delayError)
Returns an Observable that emits the items from the source ObservableSource that were emitted in a specified window of time before the ObservableSource completed.
final Observable<T> takeLast(long count, long time, TimeUnit unit, Scheduler scheduler, boolean delayError, int bufferSize)
Returns an Observable that emits at most a specified number of items from the source ObservableSource that were emitted in a specified window of time before the ObservableSource completed, where the timing information is provided by a given Scheduler.
final Observable<T> takeLast(long time, TimeUnit unit, Scheduler scheduler)
Returns an Observable that emits the items from the source ObservableSource that were emitted in a specified window of time before the ObservableSource completed, where the timing information is provided by a specified Scheduler.
final Observable<T> takeLast(long time, TimeUnit unit, Scheduler scheduler, boolean delayError)
Returns an Observable that emits the items from the source ObservableSource that were emitted in a specified window of time before the ObservableSource completed, where the timing information is provided by a specified Scheduler.
final Observable<T> takeLast(int count)
Returns an Observable that emits at most the last count items emitted by the source ObservableSource.
final Observable<T> takeLast(long time, TimeUnit unit)
Returns an Observable that emits the items from the source ObservableSource that were emitted in a specified window of time before the ObservableSource completed.
final Observable<T> takeLast(long count, long time, TimeUnit unit)
Returns an Observable that emits at most a specified number of items from the source ObservableSource that were emitted in a specified window of time before the ObservableSource completed.
final Observable<T> takeLast(long count, long time, TimeUnit unit, Scheduler scheduler)
Returns an Observable that emits at most a specified number of items from the source ObservableSource that were emitted in a specified window of time before the ObservableSource completed, where the timing information is provided by a given Scheduler.
final Observable<T> takeLast(long time, TimeUnit unit, Scheduler scheduler, boolean delayError, int bufferSize)
Returns an Observable that emits the items from the source ObservableSource that were emitted in a specified window of time before the ObservableSource completed, where the timing information is provided by a specified Scheduler.
final Observable<T> takeUntil(Predicate<? super T> stopPredicate)
Returns an Observable that emits items emitted by the source Observable, checks the specified predicate for each item, and then completes when the condition is satisfied.
final <U> Observable<T> takeUntil(ObservableSource<U> other)
Returns an Observable that emits the items emitted by the source Observable until a second ObservableSource emits an item.
final Observable<T> takeWhile(Predicate<? super T> predicate)
Returns an Observable that emits items emitted by the source ObservableSource so long as each item satisfied a specified condition, and then completes as soon as this condition is not satisfied.
final TestObserver<T> test(boolean dispose)
Creates a TestObserver, optionally disposes it and then subscribes it to this Observable.
final TestObserver<T> test()
Creates a TestObserver and subscribes it to this Observable.
final Observable<T> throttleFirst(long windowDuration, TimeUnit unit)
Returns an Observable that emits only the first item emitted by the source ObservableSource during sequential time windows of a specified duration.
final Observable<T> throttleFirst(long skipDuration, TimeUnit unit, Scheduler scheduler)
Returns an Observable that emits only the first item emitted by the source ObservableSource during sequential time windows of a specified duration, where the windows are managed by a specified Scheduler.
final Observable<T> throttleLast(long intervalDuration, TimeUnit unit, Scheduler scheduler)
Returns an Observable that emits only the last item emitted by the source ObservableSource during sequential time windows of a specified duration, where the duration is governed by a specified Scheduler.
final Observable<T> throttleLast(long intervalDuration, TimeUnit unit)
Returns an Observable that emits only the last item emitted by the source ObservableSource during sequential time windows of a specified duration.
final Observable<T> throttleWithTimeout(long timeout, TimeUnit unit, Scheduler scheduler)
Returns an Observable that only emits those items emitted by the source ObservableSource that are not followed by another emitted item within a specified time window, where the time window is governed by a specified Scheduler.
final Observable<T> throttleWithTimeout(long timeout, TimeUnit unit)
Returns an Observable that only emits those items emitted by the source ObservableSource that are not followed by another emitted item within a specified time window.
final Observable<Timed<T>> timeInterval(Scheduler scheduler)
Returns an Observable that emits records of the time interval between consecutive items emitted by the source ObservableSource, where this interval is computed on a specified Scheduler.
final Observable<Timed<T>> timeInterval(TimeUnit unit, Scheduler scheduler)
Returns an Observable that emits records of the time interval between consecutive items emitted by the source ObservableSource, where this interval is computed on a specified Scheduler.
final Observable<Timed<T>> timeInterval()
Returns an Observable that emits records of the time interval between consecutive items emitted by the source ObservableSource.
final Observable<Timed<T>> timeInterval(TimeUnit unit)
Returns an Observable that emits records of the time interval between consecutive items emitted by the source ObservableSource.
final <V> Observable<T> timeout(Function<? super T, ? extends ObservableSource<V>> itemTimeoutIndicator, ObservableSource<? extends T> other)
Returns an Observable that mirrors the source ObservableSource, but that switches to a fallback ObservableSource if an item emitted by the source ObservableSource 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.
final Observable<T> timeout(long timeout, TimeUnit timeUnit, Scheduler scheduler, ObservableSource<? extends T> other)
Returns an Observable that mirrors the source ObservableSource but applies a timeout policy for each emitted item using a specified Scheduler.
final <U, V> Observable<T> timeout(ObservableSource<U> firstTimeoutIndicator, Function<? super T, ? extends ObservableSource<V>> itemTimeoutIndicator, ObservableSource<? extends T> other)
Returns an Observable that mirrors the source ObservableSource, but switches to a fallback ObservableSource if either the first item emitted by the source ObservableSource or any subsequent item doesn't arrive within time windows defined by other ObservableSources.
final Observable<T> timeout(long timeout, TimeUnit timeUnit)
Returns an Observable that mirrors the source ObservableSource but applies a timeout policy for each emitted item.
final Observable<T> timeout(long timeout, TimeUnit timeUnit, ObservableSource<? extends T> other)
Returns an Observable that mirrors the source ObservableSource but applies a timeout policy for each emitted item.
final <U, V> Observable<T> timeout(ObservableSource<U> firstTimeoutIndicator, Function<? super T, ? extends ObservableSource<V>> itemTimeoutIndicator)
Returns an Observable that mirrors the source ObservableSource, but notifies observers of a TimeoutException if either the first item emitted by the source ObservableSource or any subsequent item doesn't arrive within time windows defined by other ObservableSources.
final Observable<T> timeout(long timeout, TimeUnit timeUnit, Scheduler scheduler)
Returns an Observable that mirrors the source ObservableSource but applies a timeout policy for each emitted item, where this policy is governed on a specified Scheduler.
final <V> Observable<T> timeout(Function<? super T, ? extends ObservableSource<V>> itemTimeoutIndicator)
Returns an Observable that mirrors the source ObservableSource, but notifies observers of a TimeoutException if an item emitted by the source ObservableSource 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.
static Observable<Long> timer(long delay, TimeUnit unit)
Returns an Observable that emits 0L after a specified delay, and then completes.
static Observable<Long> timer(long delay, TimeUnit unit, Scheduler scheduler)
Returns an Observable that emits 0L after a specified delay, on a specified Scheduler, and then completes.
final Observable<Timed<T>> timestamp(TimeUnit unit, Scheduler scheduler)
Returns an Observable that emits each item emitted by the source ObservableSource, wrapped in a Timed object whose timestamps are provided by a specified Scheduler.
final Observable<Timed<T>> timestamp()
Returns an Observable that emits each item emitted by the source ObservableSource, wrapped in a Timed object.
final Observable<Timed<T>> timestamp(Scheduler scheduler)
Returns an Observable that emits each item emitted by the source ObservableSource, wrapped in a Timed object whose timestamps are provided by a specified Scheduler.
final Observable<Timed<T>> timestamp(TimeUnit unit)
Returns an Observable that emits each item emitted by the source ObservableSource, wrapped in a Timed object.
final <R> R to(Function<? super Observable<T>, R> converter)
Calls the specified converter function during assembly time and returns its resulting value.
final Flowable<T> toFlowable(BackpressureStrategy strategy)
Converts the current Observable into a Flowable by applying the specified backpressure strategy.
final Future<T> toFuture()
Returns a Future representing the single value emitted by this Observable.
final <U extends Collection<? super T>> Single<U> toList(Callable<U> collectionSupplier)
Returns a Single that emits a single item, a list composed of all the items emitted by the finite source ObservableSource.
final Single<List<T>> toList()
Returns a Single that emits a single item, a list composed of all the items emitted by the finite source ObservableSource.
final Single<List<T>> toList(int capacityHint)
Returns a Single that emits a single item, a list composed of all the items emitted by the finite source ObservableSource.
final <K> Single<Map<K, T>> toMap(Function<? super T, ? extends K> keySelector)
Returns a Single that emits a single HashMap containing all items emitted by the source ObservableSource, mapped by the keys returned by a specified keySelector function.
final <K, V> Single<Map<K, V>> toMap(Function<? super T, ? extends K> keySelector, Function<? super T, ? extends V> valueSelector, Callable<? extends Map<K, V>> mapSupplier)
Returns a Single that emits a single Map, returned by a specified mapFactory function, that contains keys and values extracted from the items emitted by the source ObservableSource.
final <K, V> Single<Map<K, V>> toMap(Function<? super T, ? extends K> keySelector, Function<? super T, ? extends V> valueSelector)
Returns a Single that emits a single HashMap containing values corresponding to items emitted by the source ObservableSource, mapped by the keys returned by a specified keySelector function.
final <K> Single<Map<K, Collection<T>>> toMultimap(Function<? super T, ? extends K> keySelector)
Returns a Single that emits a single HashMap that contains an ArrayList of items emitted by the source ObservableSource keyed by a specified keySelector function.
final <K, V> Single<Map<K, Collection<V>>> toMultimap(Function<? super T, ? extends K> keySelector, Function<? super T, ? extends V> valueSelector, Callable<Map<K, Collection<V>>> mapSupplier)
Returns a Single that emits a single Map, returned by a specified mapFactory function, that contains an ArrayList of values, extracted by a specified valueSelector function from items emitted by the source ObservableSource and keyed by the keySelector function.
final <K, V> Single<Map<K, Collection<V>>> toMultimap(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 source ObservableSource, keyed by a specified keySelector function.
final <K, V> Single<Map<K, Collection<V>>> toMultimap(Function<? super T, ? extends K> keySelector, Function<? super T, ? extends V> valueSelector, Callable<? extends Map<K, Collection<V>>> mapSupplier, Function<? super K, ? extends Collection<? super V>> collectionFactory)
Returns a Single that emits a single Map, returned by a specified mapFactory function, that contains a custom collection of values, extracted by a specified valueSelector function from items emitted by the source ObservableSource, and keyed by the keySelector function.
final Single<List<T>> toSortedList(Comparator<? super T> comparator, int capacityHint)
Returns a Single that emits a list that contains the items emitted by the source ObservableSource, in a sorted order based on a specified comparison function.
final Single<List<T>> toSortedList(Comparator<? super T> comparator)
Returns a Single that emits a list that contains the items emitted by the source ObservableSource, in a sorted order based on a specified comparison function.
final Single<List<T>> toSortedList()
Returns a Single that emits a list that contains the items emitted by the source ObservableSource, in a sorted order.
final Single<List<T>> toSortedList(int capacityHint)
Returns a Single that emits a list that contains the items emitted by the source ObservableSource, in a sorted order.
static <T> Observable<T> unsafeCreate(ObservableSource<T> onSubscribe)
Create an Observable by wrapping an ObservableSource which has to be implemented according to the Reactive-Streams-based Observable specification by handling cancellation correctly; no safeguards are provided by the Observable itself.
final Observable<T> unsubscribeOn(Scheduler scheduler)
Modifies the source ObservableSource so that subscribers will dispose it on a specified Scheduler.
static <T, D> Observable<T> using(Callable<? extends D> resourceSupplier, Function<? super D, ? extends ObservableSource<? extends T>> sourceSupplier, Consumer<? super D> disposer, boolean eager)
Constructs an ObservableSource that creates a dependent resource object which is disposed of just before termination if you have set disposeEagerly to true and a dispose() call does not occur before termination.
static <T, D> Observable<T> using(Callable<? extends D> resourceSupplier, Function<? super D, ? extends ObservableSource<? extends T>> sourceSupplier, Consumer<? super D> disposer)
Constructs an ObservableSource that creates a dependent resource object which is disposed of when the downstream calls dispose().
final <B> Observable<Observable<T>> window(Callable<? extends ObservableSource<B>> boundary)
Returns an Observable that emits windows of items it collects from the source ObservableSource.
final Observable<Observable<T>> window(long timespan, long timeskip, TimeUnit unit, Scheduler scheduler)
Returns an Observable that emits windows of items it collects from the source ObservableSource.
final Observable<Observable<T>> window(long timespan, TimeUnit unit, Scheduler scheduler, long count, boolean restart)
Returns an Observable that emits windows of items it collects from the source ObservableSource.
final <B> Observable<Observable<T>> window(ObservableSource<B> boundary)
Returns an Observable that emits non-overlapping windows of items it collects from the source ObservableSource where the boundary of each window is determined by the items emitted from a specified boundary-governing ObservableSource.
final Observable<Observable<T>> window(long timespan, TimeUnit unit, Scheduler scheduler, long count, boolean restart, int bufferSize)
Returns an Observable that emits windows of items it collects from the source ObservableSource.
final Observable<Observable<T>> window(long timespan, TimeUnit unit, Scheduler scheduler)
Returns an Observable that emits windows of items it collects from the source ObservableSource.
final <B> Observable<Observable<T>> window(ObservableSource<B> boundary, int bufferSize)
Returns an Observable that emits non-overlapping windows of items it collects from the source ObservableSource where the boundary of each window is determined by the items emitted from a specified boundary-governing ObservableSource.
final Observable<Observable<T>> window(long timespan, long timeskip, TimeUnit unit, Scheduler scheduler, int bufferSize)
Returns an Observable that emits windows of items it collects from the source ObservableSource.
final <B> Observable<Observable<T>> window(Callable<? extends ObservableSource<B>> boundary, int bufferSize)
Returns an Observable that emits windows of items it collects from the source ObservableSource.
final Observable<Observable<T>> window(long count)
Returns an Observable that emits windows of items it collects from the source ObservableSource.
final Observable<Observable<T>> window(long count, long skip)
Returns an Observable that emits windows of items it collects from the source ObservableSource.
final <U, V> Observable<Observable<T>> window(ObservableSource<U> openingIndicator, Function<? super U, ? extends ObservableSource<V>> closingIndicator)
Returns an Observable that emits windows of items it collects from the source ObservableSource.
final Observable<Observable<T>> window(long timespan, long timeskip, TimeUnit unit)
Returns an Observable that emits windows of items it collects from the source ObservableSource.
final <U, V> Observable<Observable<T>> window(ObservableSource<U> openingIndicator, Function<? super U, ? extends ObservableSource<V>> closingIndicator, int bufferSize)
Returns an Observable that emits windows of items it collects from the source ObservableSource.
final Observable<Observable<T>> window(long timespan, TimeUnit unit, long count)
Returns an Observable that emits windows of items it collects from the source ObservableSource.
final Observable<Observable<T>> window(long timespan, TimeUnit unit, long count, boolean restart)
Returns an Observable that emits windows of items it collects from the source ObservableSource.
final Observable<Observable<T>> window(long timespan, TimeUnit unit, Scheduler scheduler, long count)
Returns an Observable that emits windows of items it collects from the source ObservableSource.
final Observable<Observable<T>> window(long timespan, TimeUnit unit)
Returns an Observable that emits windows of items it collects from the source ObservableSource.
final Observable<Observable<T>> window(long count, long skip, int bufferSize)
Returns an Observable that emits windows of items it collects from the source ObservableSource.
final <R> Observable<R> withLatestFrom(Iterable<? extends ObservableSource<?>> others, Function<? super Object[], R> combiner)
Combines the value emission from this ObservableSource with the latest emissions from the other ObservableSources via a function to produce the output item.
final <T1, T2, R> Observable<R> withLatestFrom(ObservableSource<T1> o1, ObservableSource<T2> o2, Function3<? super T, ? super T1, ? super T2, R> combiner)
Combines the value emission from this ObservableSource with the latest emissions from the other ObservableSources via a function to produce the output item.
final <T1, T2, T3, T4, R> Observable<R> withLatestFrom(ObservableSource<T1> o1, ObservableSource<T2> o2, ObservableSource<T3> o3, ObservableSource<T4> o4, Function5<? super T, ? super T1, ? super T2, ? super T3, ? super T4, R> combiner)
Combines the value emission from this ObservableSource with the latest emissions from the other ObservableSources via a function to produce the output item.
final <U, R> Observable<R> withLatestFrom(ObservableSource<? extends U> other, BiFunction<? super T, ? super U, ? extends R> combiner)
Merges the specified ObservableSource into this ObservableSource sequence by using the resultSelector function only when the source ObservableSource (this instance) emits an item.
final <T1, T2, T3, R> Observable<R> withLatestFrom(ObservableSource<T1> o1, ObservableSource<T2> o2, ObservableSource<T3> o3, Function4<? super T, ? super T1, ? super T2, ? super T3, R> combiner)
Combines the value emission from this ObservableSource with the latest emissions from the other ObservableSources via a function to produce the output item.
final <R> Observable<R> withLatestFrom(ObservableSource[]<?> others, Function<? super Object[], R> combiner)
Combines the value emission from this ObservableSource with the latest emissions from the other ObservableSources via a function to produce the output item.
static <T> Observable<T> wrap(ObservableSource<T> source)
Wraps an ObservableSource into an Observable if not already an Observable.
static <T1, T2, T3, T4, T5, T6, T7, R> Observable<R> zip(ObservableSource<? extends T1> source1, ObservableSource<? extends T2> source2, ObservableSource<? extends T3> source3, ObservableSource<? extends T4> source4, ObservableSource<? extends T5> source5, ObservableSource<? extends T6> source6, ObservableSource<? extends T7> source7, 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 <T, R> Observable<R> zip(ObservableSource<? extends ObservableSource<? extends T>> sources, Function<? super Object[], ? extends R> zipper)
Returns an Observable that emits the results of a specified combiner function applied to combinations of n items emitted, in sequence, by the n ObservableSources emitted by a specified ObservableSource.
static <T1, T2, R> Observable<R> zip(ObservableSource<? extends T1> source1, ObservableSource<? extends T2> source2, 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> Observable<R> zip(ObservableSource<? extends T1> source1, ObservableSource<? extends T2> source2, ObservableSource<? extends T3> source3, 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, R> Observable<R> zip(ObservableSource<? extends T1> source1, ObservableSource<? extends T2> source2, 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 <T, R> Observable<R> zip(Iterable<? extends ObservableSource<? extends T>> sources, 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 <T1, T2, T3, T4, T5, R> Observable<R> zip(ObservableSource<? extends T1> source1, ObservableSource<? extends T2> source2, ObservableSource<? extends T3> source3, ObservableSource<? extends T4> source4, ObservableSource<? extends T5> source5, 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, R> Observable<R> zip(ObservableSource<? extends T1> source1, ObservableSource<? extends T2> source2, 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, T3, T4, R> Observable<R> zip(ObservableSource<? extends T1> source1, ObservableSource<? extends T2> source2, ObservableSource<? extends T3> source3, ObservableSource<? extends T4> source4, 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, T6, R> Observable<R> zip(ObservableSource<? extends T1> source1, ObservableSource<? extends T2> source2, ObservableSource<? extends T3> source3, ObservableSource<? extends T4> source4, ObservableSource<? extends T5> source5, ObservableSource<? extends T6> source6, 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, T8, R> Observable<R> zip(ObservableSource<? extends T1> source1, ObservableSource<? extends T2> source2, ObservableSource<? extends T3> source3, ObservableSource<? extends T4> source4, ObservableSource<? extends T5> source5, ObservableSource<? extends T6> source6, ObservableSource<? extends T7> source7, ObservableSource<? extends T8> source8, 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> Observable<R> zip(ObservableSource<? extends T1> source1, ObservableSource<? extends T2> source2, ObservableSource<? extends T3> source3, ObservableSource<? extends T4> source4, ObservableSource<? extends T5> source5, ObservableSource<? extends T6> source6, ObservableSource<? extends T7> source7, ObservableSource<? extends T8> source8, ObservableSource<? extends T9> source9, 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> Observable<R> zipArray(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.
static <T, R> Observable<R> zipIterable(Iterable<? extends ObservableSource<? extends T>> sources, 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.
final <U, R> Observable<R> zipWith(ObservableSource<? extends U> other, 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 source ObservableSource and another specified ObservableSource.
final <U, R> Observable<R> zipWith(ObservableSource<? extends U> other, 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 source ObservableSource and another specified ObservableSource.
final <U, R> Observable<R> zipWith(ObservableSource<? extends U> other, 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 source ObservableSource and another specified ObservableSource.
final <U, R> Observable<R> zipWith(Iterable<U> other, 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 source ObservableSource and a specified Iterable sequence.
Protected Methods
abstract void subscribeActual(Observer<? super T> observer)
Operator implementations (both source and intermediate) should implement this method that performs the necessary business logic.
[Expand]
Inherited Methods
From class java.lang.Object
From interface io.reactivex.ObservableSource

Public Constructors

public Observable ()

Public Methods

public final Single<Boolean> all (Predicate<? super T> predicate)

Returns an Observable that emits a Boolean that indicates whether all of the items emitted by the source ObservableSource 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
  • a Single that emits true if all items emitted by the source ObservableSource satisfy the predicate; otherwise, false
See Also

public static Observable<T> amb (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.

Scheduler:
amb does not operate by default on a particular Scheduler.

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
  • an Observable that emits the same sequence as whichever of the source ObservableSources first emitted an item or sent a termination notification
See Also

public static 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.

Scheduler:
ambArray does not operate by default on a particular Scheduler.

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
  • an Observable that emits the same sequence as whichever of the source ObservableSources first emitted an item or sent a termination notification
See Also

public final Observable<T> ambWith (ObservableSource<? extends T> other)

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

Scheduler:
ambWith does not operate by default on a particular Scheduler.

Parameters
other an ObservableSource competing to react first. A subscription to this provided source will occur after subscribing to the current source.
Returns
  • an Observable that emits the same sequence as whichever of the source ObservableSources first emitted an item or sent a termination notification
See Also

public final Single<Boolean> any (Predicate<? super T> predicate)

Returns an Observable that emits true if any item emitted by the source ObservableSource satisfies a specified condition, otherwise false. Note: this always emits false if the source ObservableSource 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 source ObservableSource
Returns
  • a Single that emits a Boolean that indicates whether any item emitted by the source ObservableSource satisfies the predicate
See Also

public final T blockingFirst (T defaultItem)

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

Scheduler:
blockingFirst does not operate by default on a particular Scheduler.

Parameters
defaultItem a default value to return if this Observable emits no items
Returns
  • the first item emitted by this Observable, or the default value if it emits no items
See Also

public final T blockingFirst ()

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

Scheduler:
blockingFirst does not operate by default on a particular Scheduler.

Returns
  • the first item emitted by this Observable
Throws
NoSuchElementException if this Observable emits no items
See Also

public final void blockingForEach (Consumer<? super T> onNext)

Invokes a method on each item emitted by this Observable and blocks until the Observable completes.

Note: This will block even if the underlying Observable is asynchronous.

This is similar to subscribe(Observer), but it blocks. Because it blocks it does not need the onComplete() or onError(Throwable) methods. If the underlying Observable terminates with an error, rather than calling onError, this method will throw an exception.

The difference between this method and subscribe(Consumer) is that the onNext action is executed on the emission thread instead of the current thread.

Scheduler:
blockingForEach does not operate by default on a particular Scheduler.

Parameters
onNext the Consumer to invoke for each item emitted by the Observable
Throws
RuntimeException if an error occurs
See Also

public final Iterable<T> blockingIterable (int bufferSize)

Converts this Observable into an Iterable.

Scheduler:
blockingIterable does not operate by default on a particular Scheduler.

Parameters
bufferSize the number of items to prefetch from the current Observable
Returns
See Also

public final Iterable<T> blockingIterable ()

Converts this Observable into an Iterable.

Scheduler:
blockingIterable does not operate by default on a particular Scheduler.

Returns
See Also

public final T blockingLast ()

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

Scheduler:
blockingLast does not operate by default on a particular Scheduler.

Returns
  • the last item emitted by this Observable
Throws
NoSuchElementException if this Observable emits no items
See Also

public final T blockingLast (T defaultItem)

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

Scheduler:
blockingLast does not operate by default on a particular Scheduler.

Parameters
defaultItem a default value to return if this Observable emits no items
Returns
  • the last item emitted by the Observable, or the default value if it emits no items
See Also

public final Iterable<T> blockingLatest ()

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

If this 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
  • an Iterable that always returns the latest item emitted by this Observable
See Also

public final Iterable<T> blockingMostRecent (T initialValue)

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

Scheduler:
blockingMostRecent does not operate by default on a particular Scheduler.

Parameters
initialValue the initial value that the Iterable sequence will yield if this Observable has not yet emitted an item
Returns
  • an Iterable that on each iteration returns the item that this Observable has most recently emitted
See Also

public final Iterable<T> blockingNext ()

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

Scheduler:
blockingNext does not operate by default on a particular Scheduler.

Returns
  • an Iterable that blocks upon each iteration until this Observable emits a new item, whereupon the Iterable returns that item
See Also

public final T blockingSingle (T defaultItem)

If this 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.

Parameters
defaultItem a default value to return if this Observable emits no items
Returns
  • the single item emitted by this Observable, or the default value if it emits no items
See Also

public final T blockingSingle ()

If this 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.

Returns
  • the single item emitted by this Observable
See Also

public final void blockingSubscribe (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 handler.

Scheduler:
blockingSubscribe does not operate by default on a particular Scheduler.

Parameters
onNext the callback action for each source value

public final void blockingSubscribe (Observer<? super T> subscriber)

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

Scheduler:
blockingSubscribe does not operate by default on a particular Scheduler.
The a dispose() call is composed through.

Parameters
subscriber the subscriber to forward events and calls to in the current thread

public final void blockingSubscribe (Consumer<? super T> onNext, Consumer<? super Throwable> onError)

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

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

public final void blockingSubscribe ()

Runs the source observable to a terminal event, ignoring any values and rethrowing any exception.

Scheduler:
blockingSubscribe does not operate by default on a particular Scheduler.

public final void blockingSubscribe (Consumer<? super T> onNext, Consumer<? super Throwable> onError, Action onComplete)

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

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.

public final Observable<List<T>> buffer (ObservableSource<? extends TOpening> openingIndicator, Function<? super TOpening, ? extends ObservableSource<? extends TClosing>> closingIndicator)

Returns an Observable that emits buffers of items it collects from the source ObservableSource. The resulting ObservableSource emits buffers that it creates when the specified openingIndicator ObservableSource emits an item, and closes when the ObservableSource returned from closingIndicator emits an item.

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

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 ObservableSource emits an item, the associated buffer is emitted.
Returns
  • an Observable that emits buffers, containing items from the source ObservableSource, that are created and closed when the specified ObservableSources emit items
See Also

public final Observable<U> buffer (ObservableSource<? extends TOpening> openingIndicator, Function<? super TOpening, ? extends ObservableSource<? extends TClosing>> closingIndicator, Callable<U> bufferSupplier)

Returns an Observable that emits buffers of items it collects from the source ObservableSource. The resulting ObservableSource emits buffers that it creates when the specified openingIndicator ObservableSource emits an item, and closes when the ObservableSource returned from closingIndicator emits an item.

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

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 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
  • an Observable that emits buffers, containing items from the source ObservableSource, that are created and closed when the specified ObservableSources emit items
See Also

public final Observable<U> buffer (long timespan, long timeskip, TimeUnit unit, Scheduler scheduler, Callable<U> bufferSupplier)

Returns an Observable that emits buffers of items it collects from the source ObservableSource. The resulting ObservableSource 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 source ObservableSource completes or encounters an error, the resulting ObservableSource emits the current buffer and propagates the notification from the source ObservableSource.

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
bufferSupplier a factory function that returns an instance of the collection subclass to be used and returned as the buffer
Returns
  • an Observable that emits new buffers of items emitted by the source ObservableSource periodically after a fixed timespan has elapsed
See Also

public final Observable<List<T>> buffer (long timespan, long timeskip, TimeUnit unit, Scheduler scheduler)

Returns an Observable that emits buffers of items it collects from the source ObservableSource. The resulting ObservableSource 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 source ObservableSource completes or encounters an error, the resulting ObservableSource emits the current buffer and propagates the notification from the source ObservableSource.

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
  • an Observable that emits new buffers of items emitted by the source ObservableSource periodically after a fixed timespan has elapsed
See Also

public final Observable<U> buffer (int count, Callable<U> bufferSupplier)

Returns an Observable that emits buffers of items it collects from the source ObservableSource. The resulting ObservableSource emits connected, non-overlapping buffers, each containing count items. When the source ObservableSource completes or encounters an error, the resulting ObservableSource emits the current buffer and propagates the notification from the source ObservableSource.

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
bufferSupplier a factory function that returns an instance of the collection subclass to be used and returned as the buffer
Returns
  • an Observable that emits connected, non-overlapping buffers, each containing at most count items from the source ObservableSource
See Also

public final Observable<U> buffer (Callable<? extends ObservableSource<B>> boundarySupplier, Callable<U> bufferSupplier)

Returns an Observable that emits buffers of items it collects from the source ObservableSource. The resulting ObservableSource emits connected, non-overlapping buffers. It emits the current buffer and replaces it with a new buffer whenever the ObservableSource produced by the specified closingIndicator emits an item.

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

Parameters
boundarySupplier a Callable that produces an ObservableSource that governs the boundary between buffers. Whenever the source ObservableSource emits an item, buffer emits the current buffer and begins to fill a new one
bufferSupplier a factory function that returns an instance of the collection subclass to be used and returned as the buffer
Returns
  • an Observable that emits a connected, non-overlapping buffer of items from the source ObservableSource each time the ObservableSource created with the closingIndicator argument emits an item
See Also

public final Observable<List<T>> buffer (long timespan, TimeUnit unit, Scheduler scheduler)

Returns an Observable that emits buffers of items it collects from the source ObservableSource. The resulting ObservableSource emits connected, non-overlapping buffers, each of a fixed duration specified by the timespan argument and on the specified scheduler. When the source ObservableSource completes or encounters an error, the resulting ObservableSource emits the current buffer and propagates the notification from the source ObservableSource.

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
  • an Observable that emits connected, non-overlapping buffers of items emitted by the source ObservableSource within a fixed duration
See Also

public final Observable<List<T>> buffer (ObservableSource<B> boundary, int initialCapacity)

Returns an Observable that emits non-overlapping buffered items from the source ObservableSource 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.

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

Parameters
boundary the boundary ObservableSource
initialCapacity the initial capacity of each buffer chunk
Returns
  • an Observable that emits buffered items from the source ObservableSource when the boundary ObservableSource emits an item
See Also

public final Observable<List<T>> buffer (int count)

Returns an Observable that emits buffers of items it collects from the source ObservableSource. The resulting ObservableSource emits connected, non-overlapping buffers, each containing count items. When the source ObservableSource completes or encounters an error, the resulting ObservableSource emits the current buffer and propagates the notification from the source ObservableSource.

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
  • an Observable that emits connected, non-overlapping buffers, each containing at most count items from the source ObservableSource
See Also

public final Observable<List<T>> buffer (Callable<? extends ObservableSource<B>> boundarySupplier)

Returns an Observable that emits buffers of items it collects from the source ObservableSource. The resulting ObservableSource emits connected, non-overlapping buffers. It emits the current buffer and replaces it with a new buffer whenever the ObservableSource produced by the specified closingIndicator emits an item.

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

Parameters
boundarySupplier a Callable that produces an ObservableSource that governs the boundary between buffers. Whenever the source ObservableSource emits an item, buffer emits the current buffer and begins to fill a new one
Returns
  • an Observable that emits a connected, non-overlapping buffer of items from the source ObservableSource each time the ObservableSource created with the closingIndicator argument emits an item
See Also

public final Observable<List<T>> buffer (ObservableSource<B> boundary)

Returns an Observable that emits non-overlapping buffered items from the source ObservableSource 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.

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

Parameters
boundary the boundary ObservableSource
Returns
  • an Observable that emits buffered items from the source ObservableSource when the boundary ObservableSource emits an item
See Also

public final Observable<List<T>> buffer (long timespan, long timeskip, TimeUnit unit)

Returns an Observable that emits buffers of items it collects from the source ObservableSource. The resulting ObservableSource 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 source ObservableSource completes or encounters an error, the resulting ObservableSource emits the current buffer and propagates the notification from the source ObservableSource.

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
  • an Observable that emits new buffers of items emitted by the source ObservableSource periodically after a fixed timespan has elapsed
See Also

public final Observable<List<T>> buffer (long timespan, TimeUnit unit, Scheduler scheduler, int count)

Returns an Observable that emits buffers of items it collects from the source ObservableSource. The resulting ObservableSource 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 source ObservableSource completes or encounters an error, the resulting ObservableSource emits the current buffer and propagates the notification from the source ObservableSource.

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
  • an Observable that emits connected, non-overlapping buffers of items emitted by the source ObservableSource after a fixed duration or when the buffer reaches maximum capacity (whichever occurs first)
See Also

public final Observable<List<T>> buffer (long timespan, TimeUnit unit)

Returns an Observable that emits buffers of items it collects from the source ObservableSource. The resulting ObservableSource emits connected, non-overlapping buffers, each of a fixed duration specified by the timespan argument. When the source ObservableSource completes or encounters an error, the resulting ObservableSource emits the current buffer and propagates the notification from the source ObservableSource.

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
  • an Observable that emits connected, non-overlapping buffers of items emitted by the source ObservableSource within a fixed duration
See Also

public final Observable<U> buffer (long timespan, TimeUnit unit, Scheduler scheduler, int count, Callable<U> bufferSupplier, boolean restartTimerOnMaxSize)

Returns an Observable that emits buffers of items it collects from the source ObservableSource. The resulting ObservableSource 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 source ObservableSource completes or encounters an error, the resulting ObservableSource emits the current buffer and propagates the notification from the source ObservableSource.

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
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
  • an Observable that emits connected, non-overlapping buffers of items emitted by the source ObservableSource after a fixed duration or when the buffer reaches maximum capacity (whichever occurs first)
See Also

public final Observable<U> buffer (ObservableSource<B> boundary, Callable<U> bufferSupplier)

Returns an Observable that emits non-overlapping buffered items from the source ObservableSource 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.

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

Parameters
boundary the boundary ObservableSource
bufferSupplier a factory function that returns an instance of the collection subclass to be used and returned as the buffer
Returns
  • an Observable that emits buffered items from the source ObservableSource when the boundary ObservableSource emits an item
See Also

public final Observable<List<T>> buffer (int count, int skip)

Returns an Observable that emits buffers of items it collects from the source ObservableSource. The resulting ObservableSource emits buffers every skip items, each containing count items. When the source ObservableSource completes or encounters an error, the resulting ObservableSource emits the current buffer and propagates the notification from the source ObservableSource.

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 source ObservableSource 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
  • an Observable that emits buffers for every skip item from the source ObservableSource and containing at most count items
See Also

public final Observable<List<T>> buffer (long timespan, TimeUnit unit, int count)

Returns an Observable that emits buffers of items it collects from the source ObservableSource. The resulting ObservableSource 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 source ObservableSource completes or encounters an error, the resulting ObservableSource emits the current buffer and propagates the notification from the source ObservableSource.

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
  • an Observable that emits connected, non-overlapping buffers of items emitted by the source ObservableSource, after a fixed duration or when the buffer reaches maximum capacity (whichever occurs first)
See Also

public final Observable<U> buffer (int count, int skip, Callable<U> bufferSupplier)

Returns an Observable that emits buffers of items it collects from the source ObservableSource. The resulting ObservableSource emits buffers every skip items, each containing count items. When the source ObservableSource completes or encounters an error, the resulting ObservableSource emits the current buffer and propagates the notification from the source ObservableSource.

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 source ObservableSource 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
  • an Observable that emits buffers for every skip item from the source ObservableSource and containing at most count items
See Also

public static int bufferSize ()

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

Delegates to bufferSize() but is public for convenience.

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

Returns
  • the default 'island' size or capacity-increment hint

public final Observable<T> cache ()

Returns an Observable that subscribes to this ObservableSource lazily, caches all of its events and replays them, in the same order as received, to all the downstream subscribers.

This is useful when you want an ObservableSource to cache responses and you can't control the subscribe/dispose behavior of all the Observers.

The operator subscribes only when the first downstream subscriber subscribes and maintains a single subscription towards this ObservableSource. In contrast, the operator family of replay() that return a ConnectableObservable require an explicit call to connect().

Note: You sacrifice the ability to dispose the origin when you use the cache Observer so be careful not to use this Observer on ObservableSources 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
  • an Observable that, when first subscribed to, caches all of its items and notifications for the benefit of subsequent subscribers
See Also

public final Observable<T> cacheWithInitialCapacity (int initialCapacity)

Returns an Observable that subscribes to this ObservableSource lazily, caches all of its events and replays them, in the same order as received, to all the downstream subscribers.

This is useful when you want an ObservableSource to cache responses and you can't control the subscribe/dispose behavior of all the Observers.

The operator subscribes only when the first downstream subscriber subscribes and maintains a single subscription towards this ObservableSource. In contrast, the operator family of replay() that return a ConnectableObservable require an explicit call to connect().

Note: You sacrifice the ability to dispose the origin when you use the cache Observer so be careful not to use this Observer on ObservableSources 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 autoConnect() or similar.

Parameters
initialCapacity hint for number of items to cache (for optimizing underlying data structure)
Returns
  • an Observable that, when first subscribed to, caches all of its items and notifications for the benefit of subsequent subscribers
See Also

public final Observable<U> cast (Class<U> clazz)

Returns an Observable that emits the items emitted by the source ObservableSource, converted to the specified type.

Scheduler:
cast does not operate by default on a particular Scheduler.

Parameters
clazz the target class type that cast will cast the items emitted by the source ObservableSource into before emitting them from the resulting ObservableSource
Returns
  • an Observable that emits each item from the source ObservableSource after converting it to the specified type
See Also

public final Single<U> collect (Callable<? extends U> initialValueSupplier, BiConsumer<? super U, ? super T> collector)

Collects items emitted by the source ObservableSource 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.

Scheduler:
collect does not operate by default on a particular Scheduler.

Parameters
initialValueSupplier the mutable data structure that will collect the items
collector a function that accepts the state and an emitted item, and modifies state accordingly
Returns
  • a Single that emits the result of collecting the values emitted by the source ObservableSource into a single mutable data structure
See Also

public final Single<U> collectInto (U initialValue, BiConsumer<? super U, ? super T> collector)

Collects items emitted by the source ObservableSource 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.

Scheduler:
collectInto does not operate by default on a particular Scheduler.

Parameters
initialValue the mutable data structure that will collect the items
collector a function that accepts the state and an emitted item, and modifies state accordingly
Returns
  • a Single that emits the result of collecting the values emitted by the source ObservableSource into a single mutable data structure
See Also

public static Observable<R> combineLatest (ObservableSource<? extends T1> source1, ObservableSource<? extends T2> source2, ObservableSource<? extends T3> source3, 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 source ObservableSources each time an item is received from any of the source 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.

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 source ObservableSources
Returns
  • an Observable that emits items that are the result of combining the items emitted by the source ObservableSources by means of the given aggregation function
See Also

public static Observable<R> combineLatest (ObservableSource<? extends T1> source1, ObservableSource<? extends T2> source2, ObservableSource<? extends T3> source3, ObservableSource<? extends T4> source4, ObservableSource<? extends T5> source5, ObservableSource<? extends T6> source6, ObservableSource<? extends T7> source7, ObservableSource<? extends T8> source8, 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 source ObservableSources each time an item is received from any of the source 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.

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 source ObservableSources
Returns
  • an Observable that emits items that are the result of combining the items emitted by the source ObservableSources by means of the given aggregation function
See Also

public static Observable<R> combineLatest (Iterable<? extends ObservableSource<? extends T>> sources, Function<? super Object[], ? extends R> combiner, int bufferSize)

Combines a collection of source ObservableSources by emitting an item that aggregates the latest values of each of the source ObservableSources each time an item is received from any of the source 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.

Parameters
sources the collection of source ObservableSources
combiner the aggregation function used to combine the items emitted by the source ObservableSources
bufferSize the internal buffer size and prefetch amount applied to every source Observable
Returns
  • an Observable that emits items that are the result of combining the items emitted by the source ObservableSources by means of the given aggregation function
See Also

public static Observable<R> combineLatest (Iterable<? extends ObservableSource<? extends T>> sources, 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 source ObservableSources each time an item is received from any of the source 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.

Parameters
sources the collection of source ObservableSources
combiner the aggregation function used to combine the items emitted by the source ObservableSources
Returns
  • an Observable that emits items that are the result of combining the items emitted by the source ObservableSources by means of the given aggregation function
See Also

public static Observable<R> combineLatest (ObservableSource<? extends T1> source1, ObservableSource<? extends T2> source2, ObservableSource<? extends T3> source3, ObservableSource<? extends T4> source4, ObservableSource<? extends T5> source5, 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 source ObservableSources each time an item is received from any of the source 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.

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 source ObservableSources
Returns
  • an Observable that emits items that are the result of combining the items emitted by the source ObservableSources by means of the given aggregation function
See Also

public static Observable<R> combineLatest (ObservableSource<? extends T1> source1, ObservableSource<? extends T2> source2, 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 source ObservableSources each time an item is received from either of the source 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.

Parameters
source1 the first source ObservableSource
source2 the second source ObservableSource
combiner the aggregation function used to combine the items emitted by the source ObservableSources
Returns
  • an Observable that emits items that are the result of combining the items emitted by the source ObservableSources by means of the given aggregation function
See Also

public static Observable<R> combineLatest (ObservableSource<? extends T1> source1, ObservableSource<? extends T2> source2, ObservableSource<? extends T3> source3, ObservableSource<? extends T4> source4, 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 source ObservableSources each time an item is received from any of the source 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.

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 source ObservableSources
Returns
  • an Observable that emits items that are the result of combining the items emitted by the source ObservableSources by means of the given aggregation function
See Also

public static Observable<R> combineLatest (ObservableSource[]<? extends T> sources, 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 source ObservableSources each time an item is received from any of the source 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:
combineLatest does not operate by default on a particular Scheduler.

Parameters
sources the collection of source ObservableSources
combiner the aggregation function used to combine the items emitted by the source ObservableSources
Returns
  • an Observable that emits items that are the result of combining the items emitted by the source ObservableSources by means of the given aggregation function
See Also

public static Observable<R> combineLatest (ObservableSource<? extends T1> source1, ObservableSource<? extends T2> source2, ObservableSource<? extends T3> source3, ObservableSource<? extends T4> source4, ObservableSource<? extends T5> source5, ObservableSource<? extends T6> source6, ObservableSource<? extends T7> source7, 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 source ObservableSources each time an item is received from any of the source 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.

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 source ObservableSources
Returns
  • an Observable that emits items that are the result of combining the items emitted by the source ObservableSources by means of the given aggregation function
See Also

public static Observable<R> combineLatest (ObservableSource[]<? extends T> sources, Function<? super Object[], ? extends R> combiner, int bufferSize)

Combines a collection of source ObservableSources by emitting an item that aggregates the latest values of each of the source ObservableSources each time an item is received from any of the source 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:
combineLatest does not operate by default on a particular Scheduler.

Parameters
sources the collection of source ObservableSources
combiner the aggregation function used to combine the items emitted by the source ObservableSources
bufferSize the internal buffer size and prefetch amount applied to every source Observable
Returns
  • an Observable that emits items that are the result of combining the items emitted by the source ObservableSources by means of the given aggregation function
See Also

public static Observable<R> combineLatest (ObservableSource<? extends T1> source1, ObservableSource<? extends T2> source2, ObservableSource<? extends T3> source3, ObservableSource<? extends T4> source4, ObservableSource<? extends T5> source5, ObservableSource<? extends T6> source6, 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 source ObservableSources each time an item is received from any of the source 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.

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 source ObservableSources
Returns
  • an Observable that emits items that are the result of combining the items emitted by the source ObservableSources by means of the given aggregation function
See Also

public static Observable<R> combineLatest (Function<? super Object[], ? extends R> combiner, int bufferSize, ObservableSource...<? extends T> sources)

Combines a collection of source ObservableSources by emitting an item that aggregates the latest values of each of the source ObservableSources each time an item is received from any of the source 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 there are no ObservableSources provided, 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.

Parameters
combiner the aggregation function used to combine the items emitted by the source ObservableSources
bufferSize the internal buffer size and prefetch amount applied to every source Observable
sources the collection of source ObservableSources
Returns
  • an Observable that emits items that are the result of combining the items emitted by the source ObservableSources by means of the given aggregation function
See Also

public static Observable<R> combineLatest (ObservableSource<? extends T1> source1, ObservableSource<? extends T2> source2, ObservableSource<? extends T3> source3, ObservableSource<? extends T4> source4, ObservableSource<? extends T5> source5, ObservableSource<? extends T6> source6, ObservableSource<? extends T7> source7, ObservableSource<? extends T8> source8, ObservableSource<? extends T9> source9, 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 source ObservableSources each time an item is received from any of the source 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.

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 source ObservableSources
Returns
  • an Observable that emits items that are the result of combining the items emitted by the source ObservableSources by means of the given aggregation function
See Also

public static Observable<R> combineLatestDelayError (Iterable<? extends ObservableSource<? extends T>> sources, Function<? super Object[], ? extends R> combiner, int bufferSize)

Combines a collection of source ObservableSources by emitting an item that aggregates the latest values of each of the source ObservableSources each time an item is received from any of the source 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.

Parameters
sources the collection of source ObservableSources
combiner the aggregation function used to combine the items emitted by the source ObservableSources
bufferSize the internal buffer size and prefetch amount applied to every source Observable
Returns
  • an Observable that emits items that are the result of combining the items emitted by the source ObservableSources by means of the given aggregation function
See Also

public static Observable<R> combineLatestDelayError (Function<? super Object[], ? extends R> combiner, int bufferSize, ObservableSource...<? extends T> sources)

Combines a collection of source ObservableSources by emitting an item that aggregates the latest values of each of the source ObservableSources each time an item is received from any of the source 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 there are no ObservableSources provided, 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.

Parameters
combiner the aggregation function used to combine the items emitted by the source ObservableSources
bufferSize the internal buffer size and prefetch amount applied to every source Observable
sources the collection of source ObservableSources
Returns
  • an Observable that emits items that are the result of combining the items emitted by the source ObservableSources by means of the given aggregation function
See Also

public static Observable<R> combineLatestDelayError (Iterable<? extends ObservableSource<? extends T>> sources, 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 source ObservableSources each time an item is received from any of the source 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.

Parameters
sources the collection of source ObservableSources
combiner the aggregation function used to combine the items emitted by the source ObservableSources
Returns
  • an Observable that emits items that are the result of combining the items emitted by the source ObservableSources by means of the given aggregation function
See Also

public static Observable<R> combineLatestDelayError (ObservableSource[]<? extends T> sources, Function<? super Object[], ? extends R> combiner, int bufferSize)

Combines a collection of source ObservableSources by emitting an item that aggregates the latest values of each of the source ObservableSources each time an item is received from any of the source 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:
combineLatestDelayError does not operate by default on a particular Scheduler.

Parameters
sources the collection of source ObservableSources
combiner the aggregation function used to combine the items emitted by the source ObservableSources
bufferSize the internal buffer size and prefetch amount applied to every source Observable
Returns
  • an Observable that emits items that are the result of combining the items emitted by the source ObservableSources by means of the given aggregation function
See Also

public static Observable<R> combineLatestDelayError (ObservableSource[]<? extends T> sources, 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 source ObservableSources each time an item is received from any of the source 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:
combineLatestDelayError does not operate by default on a particular Scheduler.

Parameters
sources the collection of source ObservableSources
combiner the aggregation function used to combine the items emitted by the source ObservableSources
Returns
  • an Observable that emits items that are the result of combining the items emitted by the source ObservableSources by means of the given aggregation function
See Also

public final Observable<R> compose (ObservableTransformer<? super T, ? extends R> composer)

Transform an ObservableSource by applying a particular Transformer function to it.

This method operates on the ObservableSource itself whereas lift(ObservableOperator) operates on the ObservableSource's Observers.

If the operator you are creating is designed to act on the individual items emitted by a source ObservableSource, use lift(ObservableOperator). If your operator is designed to transform the source ObservableSource 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.

Parameters
composer implements the function that transforms the source ObservableSource
Returns
  • the source ObservableSource, transformed by the transformer function
See Also

public static Observable<T> concat (ObservableSource<? extends T> source1, ObservableSource<? extends T> source2, 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.

Parameters
source1 an ObservableSource to be concatenated
source2 an ObservableSource to be concatenated
source3 an ObservableSource to be concatenated
Returns
  • an Observable that emits items emitted by the three source ObservableSources, one after the other, without interleaving them
See Also

public static Observable<T> concat (ObservableSource<? extends ObservableSource<? extends T>> sources, int prefetch)

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

Scheduler:
concat does not operate by default on a particular Scheduler.

Parameters
sources an ObservableSource that emits ObservableSources
prefetch the number of ObservableSources to prefetch from the sources sequence.
Returns
  • an Observable that emits items all of the items emitted by the ObservableSources emitted by ObservableSources, one after the other, without interleaving them
See Also

public static Observable<T> concat (ObservableSource<? extends ObservableSource<? extends T>> sources)

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

Scheduler:
concat does not operate by default on a particular Scheduler.

Parameters
sources an ObservableSource that emits ObservableSources
Returns
  • an Observable that emits items all of the items emitted by the ObservableSources emitted by ObservableSources, one after the other, without interleaving them
See Also

public static Observable<T> concat (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.

Parameters
source1 an ObservableSource to be concatenated
source2 an ObservableSource to be concatenated
Returns
  • an Observable that emits items emitted by the two source ObservableSources, one after the other, without interleaving them
See Also

public static Observable<T> concat (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.

Parameters
sources the Iterable sequence of ObservableSources
Returns
  • the new Observable instance

public static Observable<T> concat (ObservableSource<? extends T> source1, ObservableSource<? extends T> source2, ObservableSource<? extends T> source3, 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.

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
  • an Observable that emits items emitted by the four source ObservableSources, one after the other, without interleaving them
See Also

public static Observable<T> concatArray (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.

Parameters
sources the array of sources
Returns
  • the new Observable instance
Throws
NullPointerException if sources is null

public static Observable<T> concatArrayDelayError (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.

Parameters
sources the array of sources
Returns
  • the new Observable instance
Throws
NullPointerException if sources is null

public static Observable<T> concatArrayEager (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 source 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.

Parameters
sources a sequence of ObservableSources that need to be eagerly concatenated
Returns
  • the new ObservableSource instance with the specified concatenation behavior

public static Observable<T> concatArrayEager (int maxConcurrency, int prefetch, 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 source 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.

Parameters
maxConcurrency the maximum number of concurrent subscriptions at a time, Integer.MAX_VALUE is interpreted as indication to subscribe to all sources at once
prefetch the number of elements to prefetch from each ObservableSource source
sources a sequence of ObservableSources that need to be eagerly concatenated
Returns
  • the new ObservableSource instance with the specified concatenation behavior

public static Observable<T> concatDelayError (Iterable<? extends ObservableSource<? extends T>> sources)

Concatenates the Iterable sequence of ObservableSources into a single 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.

Parameters
sources the Iterable sequence of ObservableSources
Returns
  • the new ObservableSource with the concatenating behavior

public static Observable<T> concatDelayError (ObservableSource<? extends ObservableSource<? extends T>> sources, int prefetch, 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.

Parameters
sources the ObservableSource sequence of ObservableSources
prefetch the number of elements to prefetch from the outer ObservableSource
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 current ObservableSource terminates
Returns
  • the new ObservableSource with the concatenating behavior

public static Observable<T> concatDelayError (ObservableSource<? extends ObservableSource<? extends T>> sources)

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.

Parameters
sources the ObservableSource sequence of ObservableSources
Returns
  • the new ObservableSource with the concatenating behavior

public static Observable<T> concatEager (ObservableSource<? extends ObservableSource<? extends T>> sources, int maxConcurrency, int prefetch)

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.

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
prefetch the number of elements to prefetch from each inner ObservableSource source
Returns
  • the new ObservableSource instance with the specified concatenation behavior

public static Observable<T> concatEager (Iterable<? extends ObservableSource<? extends T>> sources, int maxConcurrency, int prefetch)

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 source 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.

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
prefetch the number of elements to prefetch from each inner ObservableSource source
Returns
  • the new ObservableSource instance with the specified concatenation behavior

public static Observable<T> concatEager (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 source 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.

Parameters
sources a sequence of ObservableSources that need to be eagerly concatenated
Returns
  • the new ObservableSource instance with the specified concatenation behavior

public static Observable<T> concatEager (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.

Parameters
sources a sequence of ObservableSources that need to be eagerly concatenated
Returns
  • the new ObservableSource instance with the specified concatenation behavior

public final Observable<R> concatMap (Function<? super T, ? extends ObservableSource<? extends R>> mapper, int prefetch)

Returns a new Observable that emits items resulting from applying a function that you supply to each item emitted by the source ObservableSource, where that function returns an ObservableSource, and then emitting the items that result from concatenating those resulting ObservableSources.

Scheduler:
concatMap does not operate by default on a particular Scheduler.

Parameters
mapper a function that, when applied to an item emitted by the source ObservableSource, returns an ObservableSource
prefetch the number of elements to prefetch from the current Observable
Returns
  • an Observable that emits the result of applying the transformation function to each item emitted by the source ObservableSource and concatenating the ObservableSources obtained from this transformation
See Also

public final Observable<R> concatMap (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 source ObservableSource, where that function returns an ObservableSource, and then emitting the items that result from concatenating those resulting ObservableSources.

Scheduler:
concatMap does not operate by default on a particular Scheduler.

Parameters
mapper a function that, when applied to an item emitted by the source ObservableSource, returns an ObservableSource
Returns
  • an Observable that emits the result of applying the transformation function to each item emitted by the source ObservableSource and concatenating the ObservableSources obtained from this transformation
See Also

public final Observable<R> concatMapDelayError (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.

Scheduler:
concatMapDelayError does not operate by default on a particular Scheduler.

Parameters
mapper the function that maps the items of this ObservableSource into the inner ObservableSources.
Returns
  • the new ObservableSource instance with the concatenation behavior

public final Observable<R> concatMapDelayError (Function<? super T, ? extends ObservableSource<? extends R>> mapper, int prefetch, boolean tillTheEnd)

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.

Parameters
mapper the function that maps the items of this ObservableSource into the inner ObservableSources.
prefetch the number of elements to prefetch from the current Observable
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 signalled when the current ObservableSource source terminates
Returns
  • the new ObservableSource instance with the concatenation behavior

public final Observable<R> concatMapEager (Function<? super T, ? extends ObservableSource<? extends R>> mapper)

Maps a sequence of values into ObservableSources and concatenates these ObservableSources eagerly into a single ObservableSource.

Eager concatenation means that once a subscriber subscribes, this operator subscribes to all of the source 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.

Parameters
mapper the function that maps a sequence of values into a sequence of ObservableSources that will be eagerly concatenated
Returns
  • the new ObservableSource instance with the specified concatenation behavior

public final Observable<R> concatMapEager (Function<? super T, ? extends ObservableSource<? extends R>> mapper, int maxConcurrency, int prefetch)

Maps a sequence of values into ObservableSources and concatenates these ObservableSources eagerly into a single ObservableSource.

Eager concatenation means that once a subscriber subscribes, this operator subscribes to all of the source 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.

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
prefetch hints about the number of expected values from each inner ObservableSource, must be positive
Returns
  • the new ObservableSource instance with the specified concatenation behavior

public final Observable<R> concatMapEagerDelayError (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 ObservableSource.

Eager concatenation means that once a subscriber subscribes, this operator subscribes to all of the source 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.

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 signalled when the current ObservableSource source terminates
Returns
  • the new ObservableSource instance with the specified concatenation behavior

public final Observable<R> concatMapEagerDelayError (Function<? super T, ? extends ObservableSource<? extends R>> mapper, int maxConcurrency, int prefetch, boolean tillTheEnd)

Maps a sequence of values into ObservableSources and concatenates these ObservableSources eagerly into a single ObservableSource.

Eager concatenation means that once a subscriber subscribes, this operator subscribes to all of the source 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.

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
prefetch the number of elements to prefetch from each source ObservableSource
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
Returns
  • the new ObservableSource instance with the specified concatenation behavior

public final Observable<U> concatMapIterable (Function<? super T, ? extends Iterable<? extends U>> mapper)

Returns an Observable that concatenate each item emitted by the source ObservableSource 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.

Parameters
mapper a function that returns an Iterable sequence of values for when given an item emitted by the source ObservableSource
Returns
  • an Observable that emits the results of concatenating the items emitted by the source ObservableSource with the values in the Iterables corresponding to those items, as generated by collectionSelector
See Also

public final Observable<U> concatMapIterable (Function<? super T, ? extends Iterable<? extends U>> mapper, int prefetch)

Returns an Observable that concatenate each item emitted by the source ObservableSource 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.

Parameters
mapper a function that returns an Iterable sequence of values for when given an item emitted by the source ObservableSource
prefetch the number of elements to prefetch from the current Observable
Returns
  • an Observable that emits the results of concatenating the items emitted by the source ObservableSource with the values in the Iterables corresponding to those items, as generated by collectionSelector
See Also

public final Observable<T> concatWith (ObservableSource<? extends T> other)

Returns an Observable that emits the items emitted from the current ObservableSource, then the next, one after the other, 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
  • an Observable that emits items emitted by the two source ObservableSources, one after the other, without interleaving them
See Also

public final Single<Boolean> contains (Object element)

Returns an Observable that emits a Boolean that indicates whether the source ObservableSource emitted a specified item.

Scheduler:
contains does not operate by default on a particular Scheduler.

Parameters
element the item to search for in the emissions from the source ObservableSource
Returns
  • a Single that emits true if the specified item is emitted by the source ObservableSource, or false if the source ObservableSource completes without emitting that item
See Also

public final Single<Long> count ()

Returns a Single that counts the total number of items emitted by the source ObservableSource and emits this count as a 64-bit Long.

Scheduler:
count does not operate by default on a particular Scheduler.

Returns
  • a Single that emits a single item: the number of items emitted by the source ObservableSource as a 64-bit Long item
See Also

public static Observable<T> create (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);

 });

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.

Parameters
source the emitter that is called when an Observer subscribes to the returned Observable
Returns
  • the new Observable instance
See Also

public final Observable<T> debounce (long timeout, TimeUnit unit)

Returns an Observable that mirrors the source ObservableSource, except that it drops items emitted by the source ObservableSource 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 source ObservableSource faster than the timeout then no items will be emitted by the resulting ObservableSource.

Information on debounce vs throttle:

Scheduler:
This version of debounce operates by default on the computation Scheduler.

Parameters
timeout the time each item has to be "the most recent" of those emitted by the source ObservableSource to ensure that it's not dropped
unit the TimeUnit for the timeout
Returns
  • an Observable that filters out items from the source ObservableSource that are too quickly followed by newer items
See Also

public final Observable<T> debounce (long timeout, TimeUnit unit, Scheduler scheduler)

Returns an Observable that mirrors the source ObservableSource, except that it drops items emitted by the source ObservableSource 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 source ObservableSource faster than the timeout then no items will be emitted by the resulting ObservableSource.

Information on debounce vs throttle:

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 source ObservableSource 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
  • an Observable that filters out items from the source ObservableSource that are too quickly followed by newer items
See Also

public final Observable<T> debounce (Function<? super T, ? extends ObservableSource<U>> debounceSelector)

Returns an Observable that mirrors the source ObservableSource, except that it drops items emitted by the source ObservableSource that are followed by another item within a computed debounce duration.

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

Parameters
debounceSelector function to retrieve a sequence that indicates the throttle duration for each item
Returns
  • an Observable that omits items emitted by the source ObservableSource that are followed by another item within a computed debounce duration
See Also

public final Observable<T> defaultIfEmpty (T defaultItem)

Returns an Observable that emits the items emitted by the source ObservableSource or a specified default item if the source ObservableSource is empty.

Scheduler:
defaultIfEmpty does not operate by default on a particular Scheduler.

Parameters
defaultItem the item to emit if the source ObservableSource emits no items
Returns
  • an Observable that emits either the specified default item if the source ObservableSource emits no items, or the items emitted by the source ObservableSource
See Also

public static Observable<T> defer (Callable<? 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 Observer 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.

Parameters
supplier the ObservableSource factory function to invoke for each Observer that subscribes to the resulting ObservableSource
Returns
  • an Observable whose Observers' subscriptions trigger an invocation of the given ObservableSource factory function
See Also

public final Observable<T> delay (long delay, TimeUnit unit, boolean delayError)

Returns an Observable that emits the items emitted by the source ObservableSource shifted forward in time by a specified delay. Error notifications from the source ObservableSource are not delayed.

Scheduler:
This version of delay operates by default on the computation Scheduler.

Parameters
delay the delay to shift the source by
unit the TimeUnit in which period is defined
delayError if true, the upstream exception is signalled with the given delay, after all preceding normal elements, if false, the upstream exception is signalled immediately
Returns
  • the source ObservableSource shifted in time by the specified delay
See Also

public final Observable<T> delay (long delay, TimeUnit unit, Scheduler scheduler)

Returns an Observable that emits the items emitted by the source ObservableSource shifted forward in time by a specified delay. Error notifications from the source ObservableSource are not delayed.

Scheduler:
You specify which Scheduler this operator will use

Parameters
delay the delay to shift the source by
unit the time unit of delay
scheduler the Scheduler to use for delaying
Returns
  • the source ObservableSource shifted in time by the specified delay
See Also

public final Observable<T> delay (long delay, TimeUnit unit, Scheduler scheduler, boolean delayError)

Returns an Observable that emits the items emitted by the source ObservableSource shifted forward in time by a specified delay. Error notifications from the source ObservableSource are not delayed.

Scheduler:
You specify which Scheduler this operator will use

Parameters
delay 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 signalled with the given delay, after all preceding normal elements, if false, the upstream exception is signalled immediately
Returns
  • the source ObservableSource shifted in time by the specified delay
See Also

public final Observable<T> delay (Function<? super T, ? extends ObservableSource<U>> itemDelay)

Returns an Observable that delays the emissions of the source ObservableSource via another ObservableSource on a per-item basis.

Note: the resulting ObservableSource will immediately propagate any onError notification from the source ObservableSource.

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

Parameters
itemDelay a function that returns an ObservableSource for each item emitted by the source ObservableSource, which is then used to delay the emission of that item by the resulting ObservableSource until the ObservableSource returned from itemDelay emits an item
Returns
  • an Observable that delays the emissions of the source ObservableSource via another ObservableSource on a per-item basis
See Also

public final Observable<T> delay (ObservableSource<U> subscriptionDelay, Function<? super T, ? extends ObservableSource<V>> itemDelay)

Returns an Observable that delays the subscription to and emissions from the source ObservableSource via another ObservableSource on a per-item basis.

Note: the resulting ObservableSource will immediately propagate any onError notification from the source ObservableSource.

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

Parameters
subscriptionDelay a function that returns an ObservableSource that triggers the subscription to the source ObservableSource once it emits any item
itemDelay a function that returns an ObservableSource for each item emitted by the source ObservableSource, which is then used to delay the emission of that item by the resulting ObservableSource until the ObservableSource returned from itemDelay emits an item
Returns
  • an Observable that delays the subscription and emissions of the source ObservableSource via another ObservableSource on a per-item basis
See Also

public final Observable<T> delay (long delay, TimeUnit unit)

Returns an Observable that emits the items emitted by the source ObservableSource shifted forward in time by a specified delay. Error notifications from the source ObservableSource are not delayed.

Scheduler:
This version of delay operates by default on the computation Scheduler.

Parameters
delay the delay to shift the source by
unit the TimeUnit in which period is defined
Returns
  • the source ObservableSource shifted in time by the specified delay
See Also

public final Observable<T> delaySubscription (long delay, TimeUnit unit, Scheduler scheduler)

Returns an Observable that delays the subscription to the source ObservableSource by a given amount of time, both waiting and subscribing on a given Scheduler.

Scheduler:
You specify which Scheduler this operator will use

Parameters
delay the time to delay the subscription
unit the time unit of delay
scheduler the Scheduler on which the waiting and subscription will happen
Returns
  • an Observable that delays the subscription to the source ObservableSource by a given amount, waiting and subscribing on the given Scheduler
See Also

public final Observable<T> delaySubscription (long delay, TimeUnit unit)

Returns an Observable that delays the subscription to the source ObservableSource by a given amount of time.

Scheduler:
This version of delaySubscription operates by default on the computation Scheduler.

Parameters
delay the time to delay the subscription
unit the time unit of delay
Returns
  • an Observable that delays the subscription to the source ObservableSource by the given amount
See Also

public final Observable<T> delaySubscription (ObservableSource<U> other)

Returns an Observable that delays the subscription to this Observable until the other Observable emits an element or completes normally.

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

Parameters
other the other Observable that should trigger the subscription to this Observable.
Returns
  • an Observable that delays the subscription to this Observable until the other Observable emits an element or completes normally.

public final Observable<T2> dematerialize ()

Returns an Observable that reverses the effect of materialize by transforming the Notification objects emitted by the source ObservableSource into the items or notifications they represent.

Scheduler:
dematerialize does not operate by default on a particular Scheduler.

Returns
  • an Observable that emits the items and notifications embedded in the Notification objects emitted by the source ObservableSource
See Also

public final Observable<T> distinct ()

Returns an Observable that emits all items emitted by the source ObservableSource that are distinct.

Scheduler:
distinct does not operate by default on a particular Scheduler.

Returns
  • an Observable that emits only those items emitted by the source ObservableSource that are distinct from each other
See Also

public final Observable<T> distinct (Function<? super T, K> keySelector)

Returns an Observable that emits all items emitted by the source ObservableSource that are distinct according to a key selector function.

Scheduler:
distinct does not operate by default on a particular Scheduler.

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
  • an Observable that emits those items emitted by the source ObservableSource that have distinct keys
See Also

public final Observable<T> distinct (Function<? super T, K> keySelector, Callable<? extends Collection<? super K>> collectionSupplier)

Returns an Observable that emits all items emitted by the source ObservableSource that are distinct according to a key selector function.

Scheduler:
distinct does not operate by default on a particular Scheduler.

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
  • an Observable that emits those items emitted by the source ObservableSource that have distinct keys
See Also

public final Observable<T> distinctUntilChanged (BiPredicate<? super T, ? super T> comparer)

Returns an Observable that emits all items emitted by the source ObservableSource that are distinct from their immediate predecessors when compared with each other via the provided comparator function.

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
  • an Observable that emits those items from the source ObservableSource that are distinct from their immediate predecessors
See Also

public final Observable<T> distinctUntilChanged (Function<? super T, K> keySelector)

Returns an Observable that emits all items emitted by the source ObservableSource that are distinct from their immediate predecessors, according to a key selector function.

Scheduler:
distinctUntilChanged does not operate by default on a particular Scheduler.

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
  • an Observable that emits those items from the source ObservableSource whose keys are distinct from those of their immediate predecessors
See Also

public final Observable<T> distinctUntilChanged ()

Returns an Observable that emits all items emitted by the source ObservableSource that are distinct from their immediate predecessors.

Scheduler:
distinctUntilChanged does not operate by default on a particular Scheduler.

Returns
  • an Observable that emits those items from the source ObservableSource that are distinct from their immediate predecessors
See Also

public final Observable<T> doAfterNext (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

public final Observable<T> doAfterTerminate (Action onFinally)

Registers an Action to be called when this ObservableSource invokes either onComplete or onError.

Scheduler:
doAfterTerminate does not operate by default on a particular Scheduler.

Parameters
onFinally an Action to be invoked when the source ObservableSource finishes
Returns
  • an Observable that emits the same items as the source ObservableSource, then invokes the Action
See Also

public final Observable<T> doFinally (Action onFinally)

Calls the specified action after this 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 this Observable terminates or gets cancelled
Returns
  • the new Observable instance

public final Observable<T> doOnComplete (Action onComplete)

Modifies the source ObservableSource so that it invokes an action when it calls onComplete.

Scheduler:
doOnComplete does not operate by default on a particular Scheduler.

Parameters
onComplete the action to invoke when the source ObservableSource calls onComplete
Returns
  • the source ObservableSource with the side-effecting behavior applied
See Also

public final Observable<T> doOnDispose (Action onDispose)

Calls the dispose 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 source ObservableSource's Disposable is disposed
Returns
  • the source ObservableSource modified so as to call this Action when appropriate
Throws
NullPointerException if onDispose is null
See Also

public final Observable<T> doOnEach (Observer<? super T> observer)

Modifies the source ObservableSource so that it notifies an Observer for each item and terminal event it emits.

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 source ObservableSource with the side-effecting behavior applied
See Also

public final Observable<T> doOnEach (Consumer<? super Notification<T>> onNotification)

Modifies the source ObservableSource so that it invokes an action for each item it emits.

Scheduler:
doOnEach does not operate by default on a particular Scheduler.

Parameters
onNotification the action to invoke for each item emitted by the source ObservableSource
Returns
  • the source ObservableSource with the side-effecting behavior applied
See Also

public final Observable<T> doOnError (Consumer<? super Throwable> onError)

Modifies the source ObservableSource so that it invokes an action if it calls onError.

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 source ObservableSource calls onError
Returns
  • the source ObservableSource with the side-effecting behavior applied
See Also

public final Observable<T> doOnLifecycle (Consumer<? super Disposable> onSubscribe, Action onDispose)

Calls the appropriate onXXX method (shared between all Observer) for the lifecycle events of the sequence (subscription, cancellation, requesting).

Scheduler:
doOnLifecycle does not operate by default on a particular Scheduler.

Parameters
onSubscribe a Consumer called with the Disposable sent via Observer.onSubscribe()
onDispose called when the downstream disposes the Disposable via dispose()
Returns
  • the source ObservableSource with the side-effecting behavior applied
See Also

public final Observable<T> doOnNext (Consumer<? super T> onNext)

Modifies the source ObservableSource so that it invokes an action when it calls onNext.

Scheduler:
doOnNext does not operate by default on a particular Scheduler.

Parameters
onNext the action to invoke when the source ObservableSource calls onNext
Returns
  • the source ObservableSource with the side-effecting behavior applied
See Also

public final Observable<T> doOnSubscribe (Consumer<? super Disposable> onSubscribe)

Modifies the source ObservableSource so that it invokes the given action when it is subscribed from its subscribers. Each subscription will result in an invocation of the given action except when the source ObservableSource is reference counted, in which case the source ObservableSource 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 source ObservableSource modified so as to call this Consumer when appropriate
See Also

public final Observable<T> doOnTerminate (Action onTerminate)

Modifies the source ObservableSource so that it invokes an action when it 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 source ObservableSource calls onComplete or onError
Returns
  • the source ObservableSource with the side-effecting behavior applied
See Also

public final Single<T> elementAt (long index, T defaultItem)

Returns a Single that emits the item found at a specified index in a sequence of emissions from this 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
  • a Single that emits the item at the specified position in the sequence emitted by the source ObservableSource, or the default item if that index is outside the bounds of the source sequence
Throws
IndexOutOfBoundsException if index is less than 0
See Also

public final Maybe<T> elementAt (long index)

Returns a Maybe that emits the single item at a specified index in a sequence of emissions from this Observable or completes if this 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
  • a Maybe that emits a single item: the item at the specified position in the sequence of those emitted by the source ObservableSource
Throws
IndexOutOfBoundsException if index is less than 0
See Also

public final Single<T> elementAtOrError (long index)

Returns a Single that emits the item found at a specified index in a sequence of emissions from this Observable or signals a NoSuchElementException if this 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
  • a Single that emits the item at the specified position in the sequence emitted by the source ObservableSource, or the default item if that index is outside the bounds of the source sequence
Throws
IndexOutOfBoundsException if index is less than 0
See Also

public static 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.

Returns
See Also

public static Observable<T> error (Callable<? extends Throwable> errorSupplier)

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.

Parameters
errorSupplier a Callable factory to return a Throwable for each individual Observer
Returns
  • an Observable that invokes the Observer's onError method when the Observer subscribes to it
See Also

public static Observable<T> error (Throwable exception)

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.

Parameters
exception the particular Throwable to pass to onError
Returns
  • an Observable that invokes the Observer's onError method when the Observer subscribes to it
See Also

public final Observable<T> filter (Predicate<? super T> predicate)

Filters items emitted by an ObservableSource 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 source ObservableSource, returning true if it passes the filter
Returns
  • an Observable that emits only those items emitted by the source ObservableSource that the filter evaluates as true
See Also

public final Single<T> first (T defaultItem)

Returns a Single that emits only the very first item emitted by the source ObservableSource, or a default item if the source ObservableSource 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 source ObservableSource doesn't emit anything
Returns
  • the new Single instance
See Also

public final Maybe<T> firstElement ()

Returns a Maybe that emits only the very first item emitted by the source ObservableSource, or completes if the source ObservableSource is empty.

Scheduler:
firstElement does not operate by default on a particular Scheduler.

Returns
  • the new Maybe instance
See Also

public final Single<T> firstOrError ()

Returns a Single that emits only the very first item emitted by this Observable or signals a NoSuchElementException if this Observable is empty.

Scheduler:
firstOrError does not operate by default on a particular Scheduler.

Returns
  • the new Single instance
See Also

public final Observable<R> flatMap (Function<? super T, ? extends ObservableSource<? extends U>> mapper, 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 source ObservableSource and a specified collection ObservableSource, while limiting the maximum number of concurrent subscriptions to these ObservableSources.

Scheduler:
flatMap does not operate by default on a particular Scheduler.

Parameters
mapper a function that returns an ObservableSource for each item emitted by the source ObservableSource
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 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 signalling an exception will terminate the whole sequence immediately
maxConcurrency the maximum number of ObservableSources that may be subscribed to concurrently
bufferSize the number of elements to prefetch from the inner ObservableSources.
Returns
  • an Observable that emits the results of applying a function to a pair of values emitted by the source ObservableSource and the collection ObservableSource
See Also

public final Observable<R> flatMap (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 source ObservableSource, where that function returns an ObservableSource, and then merging those resulting ObservableSources and emitting the results of this merger.

Scheduler:
flatMap does not operate by default on a particular Scheduler.

Parameters
mapper a function that, when applied to an item emitted by the source ObservableSource, returns an ObservableSource
Returns
  • an Observable that emits the result of applying the transformation function to each item emitted by the source ObservableSource and merging the results of the ObservableSources obtained from this transformation
See Also

public final Observable<R> flatMap (Function<? super T, ? extends ObservableSource<? extends R>> onNextMapper, Function<Throwable, ? extends ObservableSource<? extends R>> onErrorMapper, Callable<? extends ObservableSource<? extends R>> onCompleteSupplier, int maxConcurrency)

Returns an Observable that applies a function to each item emitted or notification raised by the source ObservableSource 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.

Parameters
onNextMapper a function that returns an ObservableSource to merge for each item emitted by the source ObservableSource
onErrorMapper a function that returns an ObservableSource to merge for an onError notification from the source ObservableSource
onCompleteSupplier a function that returns an ObservableSource to merge for an onComplete notification from the source ObservableSource
maxConcurrency the maximum number of ObservableSources that may be subscribed to concurrently
Returns
  • an Observable that emits the results of merging the ObservableSources returned from applying the specified functions to the emissions and notifications of the source ObservableSource
See Also

public final Observable<R> flatMap (Function<? super T, ? extends ObservableSource<? extends U>> mapper, 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 source ObservableSource and a specified collection ObservableSource, while limiting the maximum number of concurrent subscriptions to these ObservableSources.

Scheduler:
flatMap does not operate by default on a particular Scheduler.

Parameters
mapper a function that returns an ObservableSource for each item emitted by the source ObservableSource
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 ObservableSource
maxConcurrency the maximum number of ObservableSources that may be subscribed to concurrently
Returns
  • an Observable that emits the results of applying a function to a pair of values emitted by the source ObservableSource and the collection ObservableSource
See Also

public final Observable<R> flatMap (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 source ObservableSource, where that function returns an ObservableSource, and then merging those resulting ObservableSources and emitting the results of this merger.

Scheduler:
flatMap does not operate by default on a particular Scheduler.

Parameters
mapper a function that, when applied to an item emitted by the source ObservableSource, 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 signalling an exception will terminate the whole sequence immediately
Returns
  • an Observable that emits the result of applying the transformation function to each item emitted by the source ObservableSource and merging the results of the ObservableSources obtained from this transformation
See Also

public final Observable<R> flatMap (Function<? super T, ? extends ObservableSource<? extends U>> mapper, 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 source ObservableSource and a specified collection ObservableSource.

Scheduler:
flatMap does not operate by default on a particular Scheduler.

Parameters
mapper a function that returns an ObservableSource for each item emitted by the source ObservableSource
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 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 signalling an exception will terminate the whole sequence immediately
Returns
  • an Observable that emits the results of applying a function to a pair of values emitted by the source ObservableSource and the collection ObservableSource
See Also

public final Observable<R> flatMap (Function<? super T, ? extends ObservableSource<? extends R>> onNextMapper, Function<? super Throwable, ? extends ObservableSource<? extends R>> onErrorMapper, Callable<? extends ObservableSource<? extends R>> onCompleteSupplier)

Returns an Observable that applies a function to each item emitted or notification raised by the source ObservableSource 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.

Parameters
onNextMapper a function that returns an ObservableSource to merge for each item emitted by the source ObservableSource
onErrorMapper a function that returns an ObservableSource to merge for an onError notification from the source ObservableSource
onCompleteSupplier a function that returns an ObservableSource to merge for an onComplete notification from the source ObservableSource
Returns
  • an Observable that emits the results of merging the ObservableSources returned from applying the specified functions to the emissions and notifications of the source ObservableSource
See Also

public final Observable<R> flatMap (Function<? super T, ? extends ObservableSource<? extends U>> mapper, 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 source ObservableSource and a specified collection ObservableSource, while limiting the maximum number of concurrent subscriptions to these ObservableSources.

Scheduler:
flatMap does not operate by default on a particular Scheduler.

Parameters
mapper a function that returns an ObservableSource for each item emitted by the source ObservableSource
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 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 signalling an exception will terminate the whole sequence immediately
maxConcurrency the maximum number of ObservableSources that may be subscribed to concurrently
Returns
  • an Observable that emits the results of applying a function to a pair of values emitted by the source ObservableSource and the collection ObservableSource
See Also

public final Observable<R> flatMap (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 source ObservableSource, where that function returns an ObservableSource, and then merging those resulting 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.

Parameters
mapper a function that, when applied to an item emitted by the source ObservableSource, 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 signalling an exception will terminate the whole sequence immediately
maxConcurrency the maximum number of ObservableSources that may be subscribed to concurrently
bufferSize the number of elements to prefetch from each inner ObservableSource
Returns
  • an Observable that emits the result of applying the transformation function to each item emitted by the source ObservableSource and merging the results of the ObservableSources obtained from this transformation
See Also

public final Observable<R> flatMap (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 source ObservableSource, where that function returns an ObservableSource, and then merging those resulting 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.

Parameters
mapper a function that, when applied to an item emitted by the source ObservableSource, 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 signalling an exception will terminate the whole sequence immediately
maxConcurrency the maximum number of ObservableSources that may be subscribed to concurrently
Returns
  • an Observable that emits the result of applying the transformation function to each item emitted by the source ObservableSource and merging the results of the ObservableSources obtained from this transformation
See Also

public final Observable<R> flatMap (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 source ObservableSource, where that function returns an ObservableSource, and then merging those resulting 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.

Parameters
mapper a function that, when applied to an item emitted by the source ObservableSource, returns an ObservableSource
maxConcurrency the maximum number of ObservableSources that may be subscribed to concurrently
Returns
  • an Observable that emits the result of applying the transformation function to each item emitted by the source ObservableSource and merging the results of the ObservableSources obtained from this transformation
See Also

public final Observable<R> flatMap (Function<? super T, ? extends ObservableSource<? extends U>> mapper, BiFunction<? super T, ? super U, ? extends R> resultSelector)

Returns an Observable that emits the results of a specified function to the pair of values emitted by the source ObservableSource and a specified collection ObservableSource.

Scheduler:
flatMap does not operate by default on a particular Scheduler.

Parameters
mapper a function that returns an ObservableSource for each item emitted by the source ObservableSource
resultSelector 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 ObservableSource
Returns
  • an Observable that emits the results of applying a function to a pair of values emitted by the source ObservableSource and the collection ObservableSource
See Also

public final Completable flatMapCompletable (Function<? super T, ? extends CompletableSource> mapper, boolean delayErrors)

Maps each element of the upstream 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 each of them terminates.
Returns
  • the new Completable instance

public final Completable flatMapCompletable (Function<? super T, ? extends CompletableSource> mapper)

Maps each element of the upstream 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

public final Observable<V> flatMapIterable (Function<? super T, ? extends Iterable<? extends U>> mapper, BiFunction<? super T, ? super U, ? extends V> resultSelector)

Returns an Observable that emits the results of applying a function to the pair of values from the source ObservableSource and an Iterable corresponding to that item that is generated by a selector.

Scheduler:
flatMapIterable does not operate by default on a particular Scheduler.

Parameters
mapper a function that returns an Iterable sequence of values for each item emitted by the source ObservableSource
resultSelector a function that returns an item based on the item emitted by the source ObservableSource and the Iterable returned for that item by the collectionSelector
Returns
  • an Observable that emits the items returned by resultSelector for each item in the source ObservableSource
See Also

public final Observable<U> flatMapIterable (Function<? super T, ? extends Iterable<? extends U>> mapper)

Returns an Observable that merges each item emitted by the source ObservableSource with the values in an Iterable corresponding to that item that is generated by a selector.

Scheduler:
flatMapIterable does not operate by default on a particular Scheduler.

Parameters
mapper a function that returns an Iterable sequence of values for when given an item emitted by the source ObservableSource
Returns
  • an Observable that emits the results of merging the items emitted by the source ObservableSource with the values in the Iterables corresponding to those items, as generated by collectionSelector
See Also

public final Observable<R> flatMapMaybe (Function<? super T, ? extends MaybeSource<? extends R>> mapper, boolean delayErrors)

Maps each element of the upstream Observable into MaybeSources, subscribes to them and waits until the upstream and all MaybeSources complete, optionally delaying all errors.

Scheduler:
flatMapMaybe does not operate by default on a particular Scheduler.

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 each of them terminates.
Returns
  • the new Observable instance

public final Observable<R> flatMapMaybe (Function<? super T, ? extends MaybeSource<? extends R>> mapper)

Maps each element of the upstream Observable into MaybeSources, subscribes to them and waits until the upstream and all MaybeSources complete.

Scheduler:
flatMapMaybe does not operate by default on a particular Scheduler.

Parameters
mapper the function that received each source value and transforms them into MaybeSources.
Returns
  • the new Observable instance

public final Observable<R> flatMapSingle (Function<? super T, ? extends SingleSource<? extends R>> mapper)

Maps each element of the upstream Observable into SingleSources, subscribes to them and waits until the upstream and all SingleSources complete.

Scheduler:
flatMapSingle does not operate by default on a particular Scheduler.

Parameters
mapper the function that received each source value and transforms them into SingleSources.
Returns
  • the new Observable instance

public final Observable<R> flatMapSingle (Function<? super T, ? extends SingleSource<? extends R>> mapper, boolean delayErrors)

Maps each element of the upstream Observable into SingleSources, subscribes to them and waits until the upstream and all SingleSources complete, optionally delaying all errors.

Scheduler:
flatMapSingle does not operate by default on a particular Scheduler.

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

public final Disposable forEach (Consumer<? super T> onNext)

Subscribes to the ObservableSource and receives notifications for each element.

Alias to subscribe(Consumer)

Scheduler:
forEach does not operate by default on a particular Scheduler.

Parameters
onNext Consumer to execute for each item.
Returns
  • a Disposable that allows cancelling an asynchronous sequence
Throws
NullPointerException if onNext is null
See Also

public final Disposable forEachWhile (Predicate<? super T> onNext, Consumer<? super Throwable> onError, Action onComplete)

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

Scheduler:
forEachWhile does not operate by default on a particular Scheduler.

Parameters
onNext Predicate to execute for each item.
onError Consumer to execute when an error is emitted.
onComplete Action to execute when completion is signalled.
Returns
  • a Disposable that allows cancelling an asynchronous sequence
Throws
NullPointerException if onNext is null, or if onError is null, or if onComplete is null
See Also

public final Disposable forEachWhile (Predicate<? super T> onNext, Consumer<? super Throwable> onError)

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

Scheduler:
forEachWhile does not operate by default on a particular Scheduler.

Parameters
onNext Predicate to execute for each item.
onError Consumer to execute when an error is emitted.
Returns
  • a Disposable that allows cancelling an asynchronous sequence
Throws
NullPointerException if onNext is null, or if onError is null
See Also

public final Disposable forEachWhile (Predicate<? super T> onNext)

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

If the Observable emits an error, it is wrapped into an OnErrorNotImplementedException and routed to the RxJavaPlugins.onError handler.

Scheduler:
forEachWhile does not operate by default on a particular Scheduler.

Parameters
onNext Predicate to execute for each item.
Returns
  • a Disposable that allows cancelling an asynchronous sequence
Throws
NullPointerException if onNext is null
See Also

public static Observable<T> fromArray (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.

Parameters
items the array of elements
Returns
  • an Observable that emits each item in the source Array
See Also

public static Observable<T> fromCallable (Callable<? extends T> supplier)

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 ObservableSource. That is to say, it makes the function "lazy."

Scheduler:
fromCallable does not operate by default on a particular Scheduler.

Parameters
supplier a function, the execution of which should be deferred; fromCallable will invoke this function only when an observer subscribes to the ObservableSource that fromCallable returns
Returns
  • an Observable whose Observers' subscriptions trigger an invocation of the given function
See Also

public static Observable<T> fromFuture (Future<? extends T> future, Scheduler scheduler)

Converts a Future, operating on a specified Scheduler, into an ObservableSource.

You can convert any object that supports the Future interface into an ObservableSource that emits the return value of the get() method of that object, by passing the object into the from method.

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

Scheduler:
You specify which Scheduler this operator will use

Parameters
future the source Future
scheduler the Scheduler to wait for the Future on. Use a Scheduler such as io() that can block and wait on the Future
Returns
  • an Observable that emits the item from the source Future
See Also

public static Observable<T> fromFuture (Future<? extends T> future, long timeout, TimeUnit unit, Scheduler scheduler)

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

You can convert any object that supports the Future interface into an ObservableSource that emits the return value of the get() method of that object, by passing the object into the from method.

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

Important note: This ObservableSource is blocking; you cannot dispose it.

Scheduler:
fromFuture does not operate by default on a particular Scheduler.

Parameters
future the source Future
timeout the maximum time to wait before calling get
unit the TimeUnit of the timeout argument
scheduler the Scheduler to wait for the Future on. Use a Scheduler such as io() that can block and wait on the Future
Returns
  • an Observable that emits the item from the source Future
See Also

public static Observable<T> fromFuture (Future<? extends T> future, long timeout, TimeUnit unit)

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

You can convert any object that supports the Future interface into an ObservableSource that emits the return value of the get() method of that object, by passing the object into the from method.

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

Important note: This ObservableSource is blocking; you cannot dispose it.

Scheduler:
fromFuture does not operate by default on a particular Scheduler.

Parameters
future the source Future
timeout the maximum time to wait before calling get
unit the TimeUnit of the timeout argument
Returns
  • an Observable that emits the item from the source Future
See Also

public static Observable<T> fromFuture (Future<? extends T> future)

Converts a Future into an ObservableSource.

You can convert any object that supports the Future interface into an ObservableSource that emits the return value of the get() method of that object, by passing the object into the from method.

Important note: This ObservableSource is blocking; you cannot dispose it.

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

Scheduler:
fromFuture does not operate by default on a particular Scheduler.

Parameters
future the source Future
Returns
  • an Observable that emits the item from the source Future
See Also

public static Observable<T> fromIterable (Iterable<? extends T> source)

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

Scheduler:
fromIterable does not operate by default on a particular Scheduler.

Parameters
source the source Iterable sequence
Returns
  • an Observable that emits each item in the source Iterable sequence
See Also

public static Observable<T> fromPublisher (Publisher<? extends T> publisher)

Converts an arbitrary Reactive-Streams Publisher into an Observable.

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.

Parameters
publisher the Publisher to convert
Returns
  • the new Observable instance
Throws
NullPointerException if publisher is null

public static Observable<T> generate (Callable<S> initialState, BiFunction<S, Emitter<T>, S> generator, Consumer<? super S> disposeState)

Returns a cold, synchronous and stateful generator of values.

Scheduler:
generate does not operate by default on a particular Scheduler.

Parameters
initialState the Callable to generate the initial state for each Observer
generator the Function called with the current state whenever a particular downstream Observer has requested a value. 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. Signalling 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 cancelled
Returns
  • the new Observable instance

public static Observable<T> generate (Callable<S> initialState, BiFunction<S, Emitter<T>, S> generator)

Returns a cold, synchronous and stateful generator of values.

Scheduler:
generate does not operate by default on a particular Scheduler.

Parameters
initialState the Callable to generate the initial state for each Observer
generator the Function called with the current state whenever a particular downstream Observer has requested a value. 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. Signalling multiple onNext in a call will make the operator signal IllegalStateException.
Returns
  • the new Observable instance

public static Observable<T> generate (Callable<S> initialState, BiConsumer<S, Emitter<T>> generator)

Returns a cold, synchronous and stateful generator of values.

Scheduler:
generate does not operate by default on a particular Scheduler.

Parameters
initialState the Callable to generate the initial state for each Observer
generator the Consumer called with the current state whenever a particular downstream Observer has requested a value. The callback then should call onNext, onError or onComplete to signal a value or a terminal event. Signalling multiple onNext in a call will make the operator signal IllegalStateException.
Returns
  • the new Observable instance

public static Observable<T> generate (Callable<S> initialState, BiConsumer<S, Emitter<T>> generator, Consumer<? super S> disposeState)

Returns a cold, synchronous and stateful generator of values.

Scheduler:
generate does not operate by default on a particular Scheduler.

Parameters
initialState the Callable to generate the initial state for each Observer
generator the Consumer called with the current state whenever a particular downstream Observer has requested a value. The callback then should call onNext, onError or onComplete to signal a value or a terminal event. Signalling 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 cancelled
Returns
  • the new Observable instance

public static Observable<T> generate (Consumer<Emitter<T>> generator)

Returns a cold, synchronous and stateless generator of values.

Scheduler:
generate does not operate by default on a particular Scheduler.

Parameters
generator the Consumer called whenever a particular downstream Observer has requested a value. The callback then should call onNext, onError or onComplete to signal a value or a terminal event. Signalling multiple onNext in a call will make the operator signal IllegalStateException.
Returns
  • the new Observable instance

public final Observable<GroupedObservable<K, T>> groupBy (Function<? super T, ? extends K> keySelector, boolean delayError)

Groups the items emitted by an ObservableSource according to a specified criterion, and emits these grouped items as GroupedObservables. The emitted GroupedObservableSource allows only a single Observer 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 GroupedObservableSource 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 GroupedObservableSources 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.

Scheduler:
groupBy does not operate by default on a particular Scheduler.

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
  • an ObservableSource that emits GroupedObservables, each of which corresponds to a unique key value and each of which emits those items from the source ObservableSource that share that key value
See Also

public final Observable<GroupedObservable<K, T>> groupBy (Function<? super T, ? extends K> keySelector)

Groups the items emitted by an ObservableSource according to a specified criterion, and emits these grouped items as GroupedObservables. The emitted GroupedObservableSource allows only a single Observer 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 GroupedObservableSource 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 GroupedObservableSources 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.

Scheduler:
groupBy does not operate by default on a particular Scheduler.

Parameters
keySelector a function that extracts the key for each item
Returns
  • an ObservableSource that emits GroupedObservables, each of which corresponds to a unique key value and each of which emits those items from the source ObservableSource that share that key value
See Also

public final Observable<GroupedObservable<K, V>> groupBy (Function<? super T, ? extends K> keySelector, Function<? super T, ? extends V> valueSelector)

Groups the items emitted by an ObservableSource according to a specified criterion, and emits these grouped items as GroupedObservables. The emitted GroupedObservableSource allows only a single Observer 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 GroupedObservableSource 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 GroupedObservableSources 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.

Scheduler:
groupBy does not operate by default on a particular Scheduler.

Parameters
keySelector a function that extracts the key for each item
valueSelector a function that extracts the return element for each item
Returns
  • an ObservableSource that emits GroupedObservables, each of which corresponds to a unique key value and each of which emits those items from the source ObservableSource that share that key value
See Also

public final Observable<GroupedObservable<K, V>> groupBy (Function<? super T, ? extends K> keySelector, Function<? super T, ? extends V> valueSelector, boolean delayError)

Groups the items emitted by an ObservableSource according to a specified criterion, and emits these grouped items as GroupedObservables. The emitted GroupedObservableSource allows only a single Observer 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 GroupedObservableSource 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 GroupedObservableSources 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.

Scheduler:
groupBy does not operate by default on a particular Scheduler.

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
  • an ObservableSource that emits GroupedObservables, each of which corresponds to a unique key value and each of which emits those items from the source ObservableSource that share that key value
See Also

public final Observable<GroupedObservable<K, V>> groupBy (Function<? super T, ? extends K> keySelector, Function<? super T, ? extends V> valueSelector, boolean delayError, int bufferSize)

Groups the items emitted by an ObservableSource according to a specified criterion, and emits these grouped items as GroupedObservables. The emitted GroupedObservableSource allows only a single Observer 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 GroupedObservableSource 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 GroupedObservableSources 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.

Scheduler:
groupBy does not operate by default on a particular Scheduler.

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
  • an ObservableSource that emits GroupedObservables, each of which corresponds to a unique key value and each of which emits those items from the source ObservableSource that share that key value
See Also

public final Observable<R> groupJoin (ObservableSource<? extends TRight> other, Function<? super T, ? extends ObservableSource<TLeftEnd>> leftEnd, Function<? super TRight, ? extends ObservableSource<TRightEnd>> rightEnd, 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.

Parameters
other the other ObservableSource to correlate items from the source ObservableSource with
leftEnd a function that returns an ObservableSource whose emissions indicate the duration of the values of the source ObservableSource
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 ObservableSource
Returns
  • an Observable that emits items based on combining those items emitted by the source ObservableSources whose durations overlap
See Also

public final Observable<T> hide ()

Hides the identity of this 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

public final Completable ignoreElements ()

Ignores all items emitted by the source ObservableSource and only calls onComplete or onError.

Scheduler:
ignoreElements does not operate by default on a particular Scheduler.

Returns
  • the new Completable instance
See Also

public static Observable<Long> interval (long period, TimeUnit unit, 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
  • an Observable that emits a sequential number each time interval
See Also

public static Observable<Long> interval (long period, 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
  • an Observable that emits a sequential number each time interval
See Also

public static Observable<Long> interval (long initialDelay, long period, TimeUnit unit, 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
  • an Observable that emits a 0L after the initialDelay and ever increasing numbers after each period of time thereafter, while running on the given Scheduler
See Also

public static Observable<Long> interval (long initialDelay, long period, 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
  • an Observable that emits a 0L after the initialDelay and ever increasing numbers after each period of time thereafter
See Also

public static Observable<Long> intervalRange (long start, long count, long initialDelay, long period, TimeUnit unit, 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 signalling 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

public static Observable<Long> intervalRange (long start, long count, long initialDelay, long period, 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 signalling 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

public final Single<Boolean> isEmpty ()

Returns an Observable that emits true if the source ObservableSource 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
  • a Single that emits a Boolean
See Also

public final Observable<R> join (ObservableSource<? extends TRight> other, Function<? super T, ? extends ObservableSource<TLeftEnd>> leftEnd, Function<? super TRight, ? extends ObservableSource<TRightEnd>> rightEnd, 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.

Parameters
other the second ObservableSource to join items from
leftEnd a function to select a duration for each item emitted by the source ObservableSource, 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 ObservableSource for any two overlapping items emitted by the two ObservableSources
Returns
  • an Observable that emits items correlating to items emitted by the source ObservableSources that have overlapping durations
See Also

public static Observable<T> just (T item1, T item2, T item3, T item4, T item5, T item6)

Converts six items into an ObservableSource that emits those items.

Scheduler:
just does not operate by default on a particular Scheduler.

Parameters
item1 first item
item2 second item
item3 third item
item4 fourth item
item5 fifth item
item6 sixth item
Returns
  • an Observable that emits each item
See Also

public static Observable<T> just (T item1, T item2)

Converts two items into an ObservableSource that emits those items.

Scheduler:
just does not operate by default on a particular Scheduler.

Parameters
item1 first item
item2 second item
Returns
  • an Observable that emits each item
See Also

public static Observable<T> just (T item1, T item2, T item3, T item4)

Converts four items into an ObservableSource that emits those items.

Scheduler:
just does not operate by default on a particular Scheduler.

Parameters
item1 first item
item2 second item
item3 third item
item4 fourth item
Returns
  • an Observable that emits each item
See Also

public static Observable<T> just (T item)

Returns an Observable that emits a single item and then completes.

To convert any object into an ObservableSource that emits that object, pass that object into the just method.

This is similar to the fromArray(java.lang.Object[]) method, except that from will convert an Iterable object into an ObservableSource that emits each of the items in the Iterable, one at a time, while the just method converts an Iterable into an ObservableSource that emits the entire Iterable as a single item.

Scheduler:
just does not operate by default on a particular Scheduler.

Parameters
item the item to emit
Returns
  • an Observable that emits value as a single item and then completes
See Also

public static Observable<T> just (T item1, T item2, T item3, T item4, T item5)

Converts five items into an ObservableSource that emits those items.

Scheduler:
just does not operate by default on a particular Scheduler.

Parameters
item1 first item
item2 second item
item3 third item
item4 fourth item
item5 fifth item
Returns
  • an Observable that emits each item
See Also

public static Observable<T> just (T item1, T item2, T item3, T item4, T item5, T item6, T item7)

Converts seven items into an ObservableSource that emits those items.

Scheduler:
just does not operate by default on a particular Scheduler.

Parameters
item1 first item
item2 second item
item3 third item
item4 fourth item
item5 fifth item
item6 sixth item
item7 seventh item
Returns
  • an Observable that emits each item
See Also

public static Observable<T> just (T item1, T item2, T item3, T item4, T item5, T item6, T item7, T item8)

Converts eight items into an ObservableSource that emits those items.

Scheduler:
just does not operate by default on a particular Scheduler.

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
  • an Observable that emits each item
See Also

public static 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 ObservableSource that emits those items.

Scheduler:
just does not operate by default on a particular Scheduler.

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
  • an Observable that emits each item
See Also

public static 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 ObservableSource that emits those items.

Scheduler:
just does not operate by default on a particular Scheduler.

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
  • an Observable that emits each item
See Also

public static Observable<T> just (T item1, T item2, T item3)

Converts three items into an ObservableSource that emits those items.

Scheduler:
just does not operate by default on a particular Scheduler.

Parameters
item1 first item
item2 second item
item3 third item
Returns
  • an Observable that emits each item
See Also

public final Single<T> last (T defaultItem)

Returns a Single that emits only the last item emitted by this Observable, or a default item if this 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 source ObservableSource is empty
Returns
  • an Observable that emits only the last item emitted by the source ObservableSource, or a default item if the source ObservableSource is empty
See Also

public final Maybe<T> lastElement ()

Returns a Maybe that emits the last item emitted by this Observable or completes if this Observable is empty.

Scheduler:
lastElement does not operate by default on a particular Scheduler.

Returns
  • a Maybe that emits the last item from the source ObservableSource or notifies observers of an error
See Also

public final Single<T> lastOrError ()

Returns a Single that emits only the last item emitted by this Observable or signals a NoSuchElementException if this Observable is empty.

Scheduler:
lastOrError does not operate by default on a particular Scheduler.

Returns
  • a Single that emits only the last item emitted by the source ObservableSource. If the source ObservableSource completes without emitting any items a NoSuchElementException will be thrown.
See Also

public final Observable<R> lift (ObservableOperator<? extends R, ? super T> lifter)

This method requires advanced knowledge about building operators; please consider other standard composition methods first; Lifts a function to the current ObservableSource and returns a new ObservableSource that when subscribed to will pass the values of the current ObservableSource through the Operator function.

In other words, this allows chaining Observers together on an ObservableSource for acting on the values within the ObservableSource.

ObservableSource.map(...).filter(...).take(5).lift(new OperatorA()).lift(new OperatorB(...)).subscribe()

If the operator you are creating is designed to act on the individual items emitted by a source ObservableSource, use lift. If your operator is designed to transform the source ObservableSource as a whole (for instance, by applying a particular set of existing RxJava operators to it) use compose(ObservableTransformer).

Scheduler:
lift does not operate by default on a particular Scheduler.

Parameters
lifter the Operator that implements the ObservableSource-operating function to be applied to the source ObservableSource
Returns
  • an Observable that is the result of applying the lifted Operator to the source ObservableSource
See Also

public final Observable<R> map (Function<? super T, ? extends R> mapper)

Returns an Observable that applies a specified function to each item emitted by the source ObservableSource and emits the results of these function applications.

Scheduler:
map does not operate by default on a particular Scheduler.

Parameters
mapper a function to apply to each item emitted by the ObservableSource
Returns
  • an Observable that emits the items from the source ObservableSource, transformed by the specified function
See Also

public final Observable<Notification<T>> materialize ()

Returns an Observable that represents all of the emissions and notifications from the source ObservableSource into emissions marked with their original types within Notification objects.

Scheduler:
materialize does not operate by default on a particular Scheduler.

Returns
  • an Observable that emits items that are the result of materializing the items and notifications of the source ObservableSource
See Also

public static Observable<T> merge (Iterable<? extends ObservableSource<? extends T>> sources)

Flattens an Iterable of ObservableSources into one ObservableSource, 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.

Parameters
sources the Iterable of ObservableSources
Returns
  • an Observable that emits items that are the result of flattening the items emitted by the ObservableSources in the Iterable
See Also

public static Observable<T> merge (ObservableSource<? extends ObservableSource<? extends T>> sources)

Flattens an ObservableSource that emits ObservableSources into a single ObservableSource 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.

Parameters
sources an ObservableSource that emits ObservableSources
Returns
  • an Observable that emits items that are the result of flattening the ObservableSources emitted by the source ObservableSource
See Also

public static Observable<T> merge (ObservableSource<? extends T> source1, ObservableSource<? extends T> source2)

Flattens two ObservableSources into a single ObservableSource, 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.

Parameters
source1 an ObservableSource to be merged
source2 an ObservableSource to be merged
Returns
  • an Observable that emits all of the items emitted by the source ObservableSources
See Also

public static Observable<T> merge (Iterable<? extends ObservableSource<? extends T>> sources, int maxConcurrency, int bufferSize)

Flattens an Iterable of ObservableSources into one ObservableSource, 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.

Parameters
sources the Iterable of ObservableSources
maxConcurrency the maximum number of ObservableSources that may be subscribed to concurrently
bufferSize the number of items to prefetch from each inner ObservableSource
Returns
  • an Observable that emits items that are the result of flattening the items emitted by the ObservableSources in the Iterable
Throws
IllegalArgumentException if maxConcurrent is less than or equal to 0
See Also

public static Observable<T> merge (Iterable<? extends ObservableSource<? extends T>> sources, int maxConcurrency)

Flattens an Iterable of ObservableSources into one ObservableSource, 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.

Parameters
sources the Iterable of ObservableSources
maxConcurrency the maximum number of ObservableSources that may be subscribed to concurrently
Returns
  • an Observable that emits items that are the result of flattening the items emitted by the ObservableSources in the Iterable
Throws
IllegalArgumentException if maxConcurrent is less than or equal to 0
See Also

public static Observable<T> merge (ObservableSource<? extends T> source1, ObservableSource<? extends T> source2, ObservableSource<? extends T> source3)

Flattens three ObservableSources into a single ObservableSource, 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.

Parameters
source1 an ObservableSource to be merged
source2 an ObservableSource to be merged
source3 an ObservableSource to be merged
Returns
  • an Observable that emits all of the items emitted by the source ObservableSources
See Also

public static Observable<T> merge (ObservableSource<? extends ObservableSource<? extends T>> sources, int maxConcurrency)

Flattens an ObservableSource that emits ObservableSources into a single ObservableSource 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.

Parameters
sources an ObservableSource that emits ObservableSources
maxConcurrency the maximum number of ObservableSources that may be subscribed to concurrently
Returns
  • an Observable that emits items that are the result of flattening the ObservableSources emitted by the source ObservableSource
Throws
IllegalArgumentException if maxConcurrent is less than or equal to 0
See Also

public static Observable<T> merge (ObservableSource<? extends T> source1, ObservableSource<? extends T> source2, ObservableSource<? extends T> source3, ObservableSource<? extends T> source4)

Flattens four ObservableSources into a single ObservableSource, 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.

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
  • an Observable that emits all of the items emitted by the source ObservableSources
See Also

public static Observable<T> mergeArray (int maxConcurrency, int bufferSize, ObservableSource...<? extends T> sources)

Flattens an Iterable of ObservableSources into one ObservableSource, 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.

Parameters
maxConcurrency the maximum number of ObservableSources that may be subscribed to concurrently
bufferSize the number of items to prefetch from each inner ObservableSource
sources the array of ObservableSources
Returns
  • an Observable that emits items that are the result of flattening the items emitted by the ObservableSources in the Iterable
Throws
IllegalArgumentException if maxConcurrent is less than or equal to 0
See Also

public static Observable<T> mergeArray (ObservableSource...<? extends T> sources)

Flattens an Array of ObservableSources into one ObservableSource, 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.

Parameters
sources the array of ObservableSources
Returns
  • an Observable that emits all of the items emitted by the ObservableSources in the Array
See Also

public static Observable<T> mergeArrayDelayError (ObservableSource...<? extends T> sources)

Flattens an Iterable of ObservableSources into one ObservableSource, in a way that allows an Observer to receive all successfully emitted items from each of the source 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.

Parameters
sources the Iterable of ObservableSources
Returns
  • an Observable that emits items that are the result of flattening the items emitted by the ObservableSources in the Iterable
See Also

public static Observable<T> mergeArrayDelayError (int maxConcurrency, int bufferSize, ObservableSource...<? extends T> sources)

Flattens an array of ObservableSources into one ObservableSource, in a way that allows an Observer to receive all successfully emitted items from each of the source 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.

Parameters
maxConcurrency the maximum number of ObservableSources that may be subscribed to concurrently
bufferSize the number of items to prefetch from each inner ObservableSource
sources the array of ObservableSources
Returns
  • an Observable that emits items that are the result of flattening the items emitted by the ObservableSources in the Iterable
See Also

public static Observable<T> mergeDelayError (ObservableSource<? extends T> source1, ObservableSource<? extends T> source2, ObservableSource<? extends T> source3, ObservableSource<? extends T> source4)

Flattens four ObservableSources into one ObservableSource, in a way that allows an Observer to receive all successfully emitted items from all of the source 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.

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
  • an Observable that emits all of the items that are emitted by the source ObservableSources
See Also

public static Observable<T> mergeDelayError (Iterable<? extends ObservableSource<? extends T>> sources)

Flattens an Iterable of ObservableSources into one ObservableSource, in a way that allows an Observer to receive all successfully emitted items from each of the source 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.

Parameters
sources the Iterable of ObservableSources
Returns
  • an Observable that emits items that are the result of flattening the items emitted by the ObservableSources in the Iterable
See Also

public static Observable<T> mergeDelayError (ObservableSource<? extends T> source1, ObservableSource<? extends T> source2)

Flattens two ObservableSources into one ObservableSource, in a way that allows an Observer to receive all successfully emitted items from each of the source 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.

Parameters
source1 an ObservableSource to be merged
source2 an ObservableSource to be merged
Returns
  • an Observable that emits all of the items that are emitted by the two source ObservableSources
See Also

public static Observable<T> mergeDelayError (ObservableSource<? extends T> source1, ObservableSource<? extends T> source2, ObservableSource<? extends T> source3)

Flattens three ObservableSources into one ObservableSource, in a way that allows an Observer to receive all successfully emitted items from all of the source 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.

Parameters
source1 an ObservableSource to be merged
source2 an ObservableSource to be merged
source3 an ObservableSource to be merged
Returns
  • an Observable that emits all of the items that are emitted by the source ObservableSources
See Also

public static Observable<T> mergeDelayError (ObservableSource<? extends ObservableSource<? extends T>> sources)

Flattens an ObservableSource that emits ObservableSources into one ObservableSource, in a way that allows an Observer to receive all successfully emitted items from all of the source 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.

Parameters
sources an ObservableSource that emits ObservableSources
Returns
  • an Observable that emits all of the items emitted by the ObservableSources emitted by the source ObservableSource
See Also

public static Observable<T> mergeDelayError (Iterable<? extends ObservableSource<? extends T>> sources, int maxConcurrency, int bufferSize)

Flattens an Iterable of ObservableSources into one ObservableSource, in a way that allows an Observer to receive all successfully emitted items from each of the source 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.

Parameters
sources the Iterable of ObservableSources
maxConcurrency the maximum number of ObservableSources that may be subscribed to concurrently
bufferSize the number of items to prefetch from each inner ObservableSource
Returns
  • an Observable that emits items that are the result of flattening the items emitted by the ObservableSources in the Iterable
See Also

public static Observable<T> mergeDelayError (Iterable<? extends ObservableSource<? extends T>> sources, int maxConcurrency)

Flattens an Iterable of ObservableSources into one ObservableSource, in a way that allows an Observer to receive all successfully emitted items from each of the source 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.

Parameters
sources the Iterable of ObservableSources
maxConcurrency the maximum number of ObservableSources that may be subscribed to concurrently
Returns
  • an Observable that emits items that are the result of flattening the items emitted by the ObservableSources in the Iterable
See Also

public static Observable<T> mergeDelayError (ObservableSource<? extends ObservableSource<? extends T>> sources, int maxConcurrency)

Flattens an ObservableSource that emits ObservableSources into one ObservableSource, in a way that allows an Observer to receive all successfully emitted items from all of the source 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.

Parameters
sources an ObservableSource that emits ObservableSources
maxConcurrency the maximum number of ObservableSources that may be subscribed to concurrently
Returns
  • an Observable that emits all of the items emitted by the ObservableSources emitted by the source ObservableSource
See Also

public final Observable<T> mergeWith (ObservableSource<? extends T> other)

Flattens this and another ObservableSource into a single ObservableSource, 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
  • an Observable that emits all of the items emitted by the source ObservableSources
See Also

public static Observable<T> never ()

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

This ObservableSource is useful primarily for testing purposes.

Scheduler:
never does not operate by default on a particular Scheduler.

Returns
  • an Observable that never emits any items or sends any notifications to an Observer
See Also

public final Observable<T> observeOn (Scheduler scheduler, boolean delayError)

Modifies an ObservableSource to perform its emissions and notifications on a specified Scheduler, asynchronously with an unbounded buffer with bufferSize() "island size" and optionally delays onError notifications.

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 upstream
Returns
  • the source ObservableSource modified so that its Observers are notified on the specified Scheduler
See Also

public final Observable<T> observeOn (Scheduler scheduler)

Modifies an ObservableSource to perform its emissions and notifications on a specified Scheduler, asynchronously with an unbounded buffer with 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.

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 source ObservableSource modified so that its Observers are notified on the specified Scheduler
See Also

public final Observable<T> observeOn (Scheduler scheduler, boolean delayError, int bufferSize)

Modifies an ObservableSource to perform its emissions and notifications on a specified Scheduler, asynchronously with an unbounded buffer of configurable "island size" and optionally delays onError notifications.

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 source ObservableSource modified so that its Observers are notified on the specified Scheduler
See Also

public final Observable<U> ofType (Class<U> clazz)

Filters the items emitted by an ObservableSource, only emitting those of the specified type.

Scheduler:
ofType does not operate by default on a particular Scheduler.

Parameters
clazz the class type to filter the items emitted by the source ObservableSource
Returns
  • an Observable that emits items from the source ObservableSource of type clazz
See Also

public final Observable<T> onErrorResumeNext (Function<? super Throwable, ? extends ObservableSource<? extends T>> resumeFunction)

Instructs an ObservableSource to pass control to another ObservableSource rather than invoking onError if it encounters an error.

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
resumeFunction a function that returns an ObservableSource that will take over if the source ObservableSource encounters an error
Returns
  • the original ObservableSource, with appropriately modified behavior
See Also

public final Observable<T> onErrorResumeNext (ObservableSource<? extends T> next)

Instructs an ObservableSource to pass control to another ObservableSource rather than invoking onError if it encounters an error.

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 another ObservableSource (resumeSequence) to an ObservableSource's onErrorResumeNext method, if the original ObservableSource encounters an error, instead of invoking its Observer's onError method, it will instead relinquish control to resumeSequence 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
next the next ObservableSource source that will take over if the source ObservableSource encounters an error
Returns
  • the original ObservableSource, with appropriately modified behavior
See Also

public final Observable<T> onErrorReturn (Function<? super Throwable, ? extends T> valueSupplier)

Instructs an ObservableSource to emit an item (returned by a specified function) rather than invoking onError if it encounters an error.

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
valueSupplier 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 original ObservableSource with appropriately modified behavior
See Also

public final Observable<T> onErrorReturnItem (T item)

Instructs an ObservableSource to emit an item (returned by a specified function) rather than invoking onError if it encounters an error.

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 original ObservableSource with appropriately modified behavior
See Also

public final Observable<T> onExceptionResumeNext (ObservableSource<? extends T> next)

Instructs an ObservableSource to pass control to another ObservableSource rather than invoking onError if it encounters an Exception.

This differs from onErrorResumeNext(ObservableSource) in that this one does not handle Throwable or java.lang.Error but lets those continue through.

By default, when an ObservableSource encounters an exception 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 onExceptionResumeNext method changes this behavior. If you pass another ObservableSource (resumeSequence) to an ObservableSource's onExceptionResumeNext method, if the original ObservableSource encounters an exception, instead of invoking its Observer's onError method, it will instead relinquish control to resumeSequence 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 exception happened.

You can use this to prevent exceptions from propagating or to supply fallback data should exceptions be encountered.

Scheduler:
onExceptionResumeNext does not operate by default on a particular Scheduler.

Parameters
next the next ObservableSource that will take over if the source ObservableSource encounters an exception
Returns
  • the original ObservableSource, with appropriately modified behavior
See Also

public final 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
  • an Observable which out references to the upstream producer and downstream Observer if the sequence is terminated or downstream calls dispose()

public final 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
See Also

public final Observable<R> publish (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 underlying sequence.

Scheduler:
publish does not operate by default on a particular Scheduler.

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
  • an Observable that emits the results of invoking the selector on the items emitted by a ConnectableObservable that shares a single subscription to the underlying sequence
See Also

public static 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
  • an Observable that emits a range of sequential Integers
Throws
IllegalArgumentException if count is less than zero, or if start + count − 1 exceeds Integer.MAX_VALUE
See Also

public static 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
  • an Observable that emits a range of sequential Longs
Throws
IllegalArgumentException if count is less than zero, or if start + count − 1 exceeds Long.MAX_VALUE
See Also

public final Maybe<T> reduce (BiFunction<T, T, T> reducer)

Returns a Maybe that applies a specified accumulator function to the first item emitted by a source ObservableSource, then feeds the result of that function along with the second item emitted by the source ObservableSource into the same function, and so on until all items have been emitted by the source ObservableSource, 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.

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 source ObservableSource, whose result will be used in the next accumulator call
Returns
  • a Maybe that emits a single item that is the result of accumulating the items emitted by the source ObservableSource
See Also

public final Single<R> reduce (R seed, BiFunction<R, ? super T, R> reducer)

Returns a Single that applies a specified accumulator function to the first item emitted by a source ObservableSource and a specified seed value, then feeds the result of that function along with the second item emitted by an ObservableSource into the same function, and so on until all items have been emitted by the source ObservableSource, 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 ObservableSource 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(Callable): 


 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)));
Scheduler:
reduce does not operate by default on a particular Scheduler.

Parameters
seed the initial (seed) accumulator value
reducer an accumulator function to be invoked on each item emitted by the source ObservableSource, the result of which will be used in the next accumulator call
Returns
  • a Single that emits a single item that is the result of accumulating the output from the items emitted by the source ObservableSource
See Also

public final Single<R> reduceWith (Callable<R> seedSupplier, BiFunction<R, ? super T, R> reducer)

Returns a Single that applies a specified accumulator function to the first item emitted by a source ObservableSource and a seed value derived from calling a specified seedSupplier, then feeds the result of that function along with the second item emitted by an ObservableSource into the same function, and so on until all items have been emitted by the source ObservableSource, 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.

Scheduler:
reduceWith does not operate by default on a particular Scheduler.

Parameters
seedSupplier the Callable that provides the initial (seed) accumulator value for each individual Observer
reducer an accumulator function to be invoked on each item emitted by the source ObservableSource, the result of which will be used in the next accumulator call
Returns
  • a Single that emits a single item that is the result of accumulating the output from the items emitted by the source ObservableSource
See Also

public final Observable<T> repeat ()

Returns an Observable that repeats the sequence of items emitted by the source ObservableSource indefinitely.

Scheduler:
repeat does not operate by default on a particular Scheduler.

Returns
  • an Observable that emits the items emitted by the source ObservableSource repeatedly and in sequence
See Also

public final Observable<T> repeat (long times)

Returns an Observable that repeats the sequence of items emitted by the source ObservableSource at most count times.

Scheduler:
repeat does not operate by default on a particular Scheduler.

Parameters
times the number of times the source ObservableSource items are repeated, a count of 0 will yield an empty sequence
Returns
  • an Observable that repeats the sequence of items emitted by the source ObservableSource at most count times
Throws
IllegalArgumentException if count is less than zero
See Also

public final Observable<T> repeatUntil (BooleanSupplier stop)

Returns an Observable that repeats the sequence of items emitted by the source ObservableSource 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 and unless it returns false, the current Observable is resubscribed
Returns
  • the new Observable instance
Throws
NullPointerException if stop is null
See Also

public final Observable<T> repeatWhen (Function<? super Observable<Object>, ? extends ObservableSource<?>> handler)

Returns an Observable that emits the same values as the source ObservableSource 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, this ObservableSource will resubscribe to the source ObservableSource.

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 source ObservableSource modified with repeat logic
See Also

public final Observable<R> replay (Function<? super Observable<T>, ? extends ObservableSource<R>> selector, int bufferSize, 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 source ObservableSource, replaying a maximum of bufferSize items.

Scheduler:
You specify which Scheduler this operator will use

Parameters
selector a selector function, which can use the multicasted sequence as many times as needed, without causing multiple subscriptions to the ObservableSource
bufferSize the buffer size that limits the number of items the connectable ObservableSource can replay
scheduler the Scheduler on which the replay is observed
Returns
  • an Observable that emits items that are the results of invoking the selector on items emitted by a ConnectableObservable that shares a single subscription to the source ObservableSource, replaying no more than bufferSize notifications
See Also

public final Observable<R> replay (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 source ObservableSource, replaying bufferSize notifications.

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

Parameters
selector the selector function, which can use the multicasted sequence as many times as needed, without causing multiple subscriptions to the ObservableSource
bufferSize the buffer size that limits the number of items the connectable ObservableSource can replay
Returns
  • an Observable that emits items that are the results of invoking the selector on items emitted by a ConnectableObservable that shares a single subscription to the source ObservableSource replaying no more than bufferSize items
See Also

public final Observable<R> replay (Function<? super Observable<T>, ? extends ObservableSource<R>> selector, int bufferSize, long time, TimeUnit unit, 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 source ObservableSource, replaying no more than bufferSize items that were emitted within a specified time window.

Scheduler:
You specify which Scheduler this operator will use

Parameters
selector a selector function, which can use the multicasted sequence as many times as needed, without causing multiple subscriptions to the ObservableSource
bufferSize the buffer size that limits the number of items the connectable ObservableSource 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
  • an Observable that emits items that are the results of invoking the selector on items emitted by a ConnectableObservable that shares a single subscription to the source ObservableSource, and replays no more than bufferSize items that were emitted within the window defined by time
Throws
IllegalArgumentException if bufferSize is less than zero
See Also

public final ConnectableObservable<T> replay (int bufferSize, long time, TimeUnit unit)

Returns a ConnectableObservable that shares a single subscription to the source ObservableSource and replays at most bufferSize items that were emitted during a specified time window. A Connectable ObservableSource resembles an ordinary ObservableSource, 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
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
  • a ConnectableObservable that shares a single subscription to the source ObservableSource and replays at most bufferSize items that were emitted during the window defined by time
See Also

public final ConnectableObservable<T> replay (int bufferSize, long time, TimeUnit unit, Scheduler scheduler)

Returns a ConnectableObservable that shares a single subscription to the source ObservableSource and that replays a maximum of bufferSize items that are emitted within a specified time window. A Connectable ObservableSource resembles an ordinary ObservableSource, except that it does not begin emitting items when it is subscribed to, but only when its connect method is called.

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
  • a ConnectableObservable that shares a single subscription to the source ObservableSource and replays at most bufferSize items that were emitted during the window defined by time
Throws
IllegalArgumentException if bufferSize is less than zero
See Also

public final ConnectableObservable<T> replay (int bufferSize)

Returns a ConnectableObservable that shares a single subscription to the source ObservableSource that replays at most bufferSize items emitted by that ObservableSource. A Connectable ObservableSource resembles an ordinary ObservableSource, 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.

Parameters
bufferSize the buffer size that limits the number of items that can be replayed
Returns
  • a ConnectableObservable that shares a single subscription to the source ObservableSource and replays at most bufferSize items emitted by that ObservableSource
See Also

public final ConnectableObservable<T> replay ()

Returns a ConnectableObservable that shares a single subscription to the underlying ObservableSource that will replay all of its items and notifications to any future Observer. A Connectable ObservableSource resembles an ordinary ObservableSource, 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
See Also

public final Observable<R> replay (Function<? super Observable<T>, ? extends ObservableSource<R>> selector, int bufferSize, long time, 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 source ObservableSource, replaying no more than bufferSize items that were emitted within a specified time window.

Scheduler:
This version of replay operates by default on the computation Scheduler.

Parameters
selector a selector function, which can use the multicasted sequence as many times as needed, without causing multiple subscriptions to the ObservableSource
bufferSize the buffer size that limits the number of items the connectable ObservableSource can replay
time the duration of the window in which the replayed items must have been emitted
unit the time unit of time
Returns
  • an Observable that emits items that are the results of invoking the selector on items emitted by a ConnectableObservable that shares a single subscription to the source ObservableSource, and replays no more than bufferSize items that were emitted within the window defined by time
See Also

public final ConnectableObservable<T> replay (long time, TimeUnit unit)

Returns a ConnectableObservable that shares a single subscription to the source ObservableSource and replays all items emitted by that ObservableSource within a specified time window. A Connectable ObservableSource resembles an ordinary ObservableSource, 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
  • a ConnectableObservable that shares a single subscription to the source ObservableSource and replays the items that were emitted during the window defined by time
See Also

public final Observable<R> replay (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 source ObservableSource.

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

Parameters
selector the selector function, which can use the multicasted sequence as many times as needed, without causing multiple subscriptions to the ObservableSource
Returns
  • an Observable that emits items that are the results of invoking the selector on a ConnectableObservable that shares a single subscription to the source ObservableSource
See Also

public final Observable<R> replay (Function<? super Observable<T>, ? extends ObservableSource<R>> selector, 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 source ObservableSource.

Scheduler:
You specify which Scheduler this operator will use

Parameters
selector a selector function, which can use the multicasted sequence as many times as needed, without causing multiple subscriptions to the ObservableSource
scheduler the Scheduler where the replay is observed
Returns
  • an Observable that emits items that are the results of invoking the selector on items emitted by a ConnectableObservable that shares a single subscription to the source ObservableSource, replaying all items
See Also

public final ConnectableObservable<T> replay (Scheduler scheduler)

Returns a ConnectableObservable that shares a single subscription to the source ObservableSource that will replay all of its items and notifications to any future Observer on the given Scheduler. A Connectable ObservableSource resembles an ordinary ObservableSource, except that it does not begin emitting items when it is subscribed to, but only when its connect method is called.

Scheduler:
You specify which Scheduler this operator will use

Parameters
scheduler the Scheduler on which the Observers will observe the emitted items
Returns
See Also

public final ConnectableObservable<T> replay (int bufferSize, Scheduler scheduler)

Returns a ConnectableObservable that shares a single subscription to the source ObservableSource and replays at most bufferSize items emitted by that ObservableSource. A Connectable ObservableSource resembles an ordinary ObservableSource, except that it does not begin emitting items when it is subscribed to, but only when its connect method is called.

Scheduler:
You specify which Scheduler this operator will use

Parameters
bufferSize the buffer size that limits the number of items that can be replayed
scheduler the scheduler on which the Observers will observe the emitted items
Returns
  • a ConnectableObservable that shares a single subscription to the source ObservableSource and replays at most bufferSize items that were emitted by the ObservableSource
See Also

public final Observable<R> replay (Function<? super Observable<T>, ? extends ObservableSource<R>> selector, long time, 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 source ObservableSource, replaying all items that were emitted within a specified time window.

Scheduler:
This version of replay operates by default on the computation Scheduler.

Parameters
selector a selector function, which can use the multicasted sequence as many times as needed, without causing multiple subscriptions to the ObservableSource
time the duration of the window in which the replayed items must have been emitted
unit the time unit of time
Returns
  • an Observable that emits items that are the results of invoking the selector on items emitted by a ConnectableObservable that shares a single subscription to the source ObservableSource, replaying all items that were emitted within the window defined by time
See Also

public final Observable<R> replay (Function<? super Observable<T>, ? extends ObservableSource<R>> selector, long time, TimeUnit unit, 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 source ObservableSource, replaying all items that were emitted within a specified time window.

Scheduler:
You specify which Scheduler this operator will use

Parameters
selector a selector function, which can use the multicasted sequence as many times as needed, without causing multiple subscriptions to the ObservableSource
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
  • an Observable that emits items that are the results of invoking the selector on items emitted by a ConnectableObservable that shares a single subscription to the source ObservableSource, replaying all items that were emitted within the window defined by time
See Also

public final ConnectableObservable<T> replay (long time, TimeUnit unit, Scheduler scheduler)

Returns a ConnectableObservable that shares a single subscription to the source ObservableSource and replays all items emitted by that ObservableSource within a specified time window. A Connectable ObservableSource resembles an ordinary ObservableSource, except that it does not begin emitting items when it is subscribed to, but only when its connect method is called.

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
  • a ConnectableObservable that shares a single subscription to the source ObservableSource and replays the items that were emitted during the window defined by time
See Also

public final Observable<T> retry ()

Returns an Observable that mirrors the source ObservableSource, resubscribing to it if it calls onError (infinite retry count).

If the source ObservableSource calls onError(Throwable), this method will resubscribe to the source ObservableSource rather than propagating the onError call.

Any and all items emitted by the source ObservableSource will be emitted by the resulting ObservableSource, even those emitted during failed subscriptions. For example, if an ObservableSource 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 source ObservableSource modified with retry logic
See Also

public final Observable<T> retry (long times)

Returns an Observable that mirrors the source ObservableSource, resubscribing to it if it calls onError up to a specified number of retries.

If the source ObservableSource calls onError(Throwable), this method will resubscribe to the source ObservableSource for a maximum of count resubscriptions rather than propagating the onError call.

Any and all items emitted by the source ObservableSource will be emitted by the resulting ObservableSource, even those emitted during failed subscriptions. For example, if an ObservableSource 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 number of retry attempts before failing
Returns
  • the source ObservableSource modified with retry logic
See Also

public final Observable<T> retry (long times, 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 repeat
predicate the predicate called with the failure Throwable and should return true to trigger a retry.
Returns
  • the new Observable instance

public final Observable<T> retry (BiPredicate<? super Integer, ? super Throwable> predicate)

Returns an Observable that mirrors the source ObservableSource, 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 source ObservableSource modified with retry logic
See Also

public final Observable<T> retry (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

public final Observable<T> retryUntil (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

public final Observable<T> retryWhen (Function<? super Observable<Throwable>, ? extends ObservableSource<?>> handler)

Returns an Observable that emits the same values as the source ObservableSource with the exception of an onError. An onError notification from the source will result in the emission of a Throwable item to the ObservableSource provided as an argument to the notificationHandler function. If that ObservableSource calls onComplete or onError then retry will call onComplete or onError on the child subscription. Otherwise, this ObservableSource will resubscribe to the source ObservableSource.

Example: This retries 3 times, each time incrementing the number of seconds it waits. 


  ObservableSource.create((Observer<? 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 ObservableSource.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
Scheduler:
retryWhen 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 retry
Returns
  • the source ObservableSource modified with retry logic
See Also

public final void safeSubscribe (Observer<? super T> s)

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
s the incoming Observer instance
Throws
NullPointerException if s is null

public final Observable<T> sample (long period, TimeUnit unit, Scheduler scheduler)

Returns an Observable that emits the most recently emitted item (if any) emitted by the source ObservableSource 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
  • an Observable that emits the results of sampling the items emitted by the source ObservableSource at the specified time interval
See Also

public final Observable<T> sample (long period, TimeUnit unit)

Returns an Observable that emits the most recently emitted item (if any) emitted by the source ObservableSource 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
  • an Observable that emits the results of sampling the items emitted by the source ObservableSource at the specified time interval
See Also

public final Observable<T> sample (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 source ObservableSource since the previous emission from the sampler ObservableSource.

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

Parameters
sampler the ObservableSource to use for sampling the source ObservableSource
Returns
  • an Observable that emits the results of sampling the items emitted by this ObservableSource whenever the sampler ObservableSource emits an item or completes
See Also

public final Observable<T> sample (long period, TimeUnit unit, boolean emitLast)

Returns an Observable that emits the most recently emitted item (if any) emitted by the source ObservableSource 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
  • an Observable that emits the results of sampling the items emitted by the source ObservableSource at the specified time interval
See Also

public final Observable<T> sample (long period, TimeUnit unit, Scheduler scheduler, boolean emitLast)

Returns an Observable that emits the most recently emitted item (if any) emitted by the source ObservableSource 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
  • an Observable that emits the results of sampling the items emitted by the source ObservableSource at the specified time interval
See Also

public final Observable<T> sample (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 source ObservableSource 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

Parameters
sampler the ObservableSource to use for sampling the source ObservableSource
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
  • an Observable that emits the results of sampling the items emitted by this ObservableSource whenever the sampler ObservableSource emits an item or completes
See Also

public final Observable<R> scan (R initialValue, BiFunction<R, ? super T, R> accumulator)

Returns an Observable that applies a specified accumulator function to the first item emitted by a source ObservableSource and a seed value, then feeds the result of that function along with the second item emitted by the source ObservableSource into the same function, and so on until all items have been emitted by the source ObservableSource, emitting the result of each of these iterations.

This sort of function is sometimes called an accumulator.

Note that the ObservableSource 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 ObservableSource 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(Callable): 


 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.

Parameters
initialValue the initial (seed) accumulator item
accumulator an accumulator function to be invoked on each item emitted by the source ObservableSource, whose result will be emitted to Observers via onNext and used in the next accumulator call
Returns
  • an Observable that emits initialValue followed by the results of each call to the accumulator function
See Also

public final Observable<T> scan (BiFunction<T, T, T> accumulator)

Returns an Observable that applies a specified accumulator function to the first item emitted by a source ObservableSource, then feeds the result of that function along with the second item emitted by the source ObservableSource into the same function, and so on until all items have been emitted by the source ObservableSource, emitting the result of each of these iterations.

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 source ObservableSource, whose result will be emitted to Observers via onNext and used in the next accumulator call
Returns
  • an Observable that emits the results of each call to the accumulator function
See Also

public final Observable<R> scanWith (Callable<R> seedSupplier, BiFunction<R, ? super T, R> accumulator)

Returns an Observable that applies a specified accumulator function to the first item emitted by a source ObservableSource and a seed value, then feeds the result of that function along with the second item emitted by the source ObservableSource into the same function, and so on until all items have been emitted by the source ObservableSource, emitting the result of each of these iterations.

This sort of function is sometimes called an accumulator.

Note that the ObservableSource 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.

Parameters
seedSupplier a Callable that returns the initial (seed) accumulator item for each individual Observer
accumulator an accumulator function to be invoked on each item emitted by the source ObservableSource, whose result will be emitted to Observers via onNext and used in the next accumulator call
Returns
  • an Observable that emits initialValue followed by the results of each call to the accumulator function
See Also

public static Single<Boolean> sequenceEqual (ObservableSource<? extends T> source1, 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.

Parameters
source1 the first ObservableSource to compare
source2 the second ObservableSource to compare
bufferSize the number of items to prefetch from the first and second source ObservableSource
Returns
  • a Single that emits a Boolean value that indicates whether the two sequences are the same
See Also

public static Single<Boolean> sequenceEqual (ObservableSource<? extends T> source1, ObservableSource<? extends T> source2, 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.

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 to prefetch from the first and second source ObservableSource
Returns
  • an Observable that emits a Boolean value that indicates whether the two ObservableSource two sequences are the same according to the specified function
See Also

public static Single<Boolean> sequenceEqual (ObservableSource<? extends T> source1, ObservableSource<? extends T> source2, 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.

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
  • a Single that emits a Boolean value that indicates whether the two ObservableSource two sequences are the same according to the specified function
See Also

public static Single<Boolean> sequenceEqual (ObservableSource<? extends T> source1, 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.

Parameters
source1 the first ObservableSource to compare
source2 the second ObservableSource to compare
Returns
  • a Single that emits a Boolean value that indicates whether the two sequences are the same
See Also

public final Observable<T> serialize ()

Forces an ObservableSource's emissions and notifications to be serialized and for it to obey the ObservableSource contract in other ways.

It is possible for an ObservableSource to invoke its Observers' methods asynchronously, perhaps from different threads. This could make such an ObservableSource 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 ObservableSource 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
  • an ObservableSource that is guaranteed to be well-behaved and to make only serialized calls to its observers
See Also

public final Observable<T> share ()

Returns a new ObservableSource that multicasts (shares) the original ObservableSource. As long as there is at least one Observer this ObservableSource will be subscribed and emitting data. When all subscribers have disposed it will dispose the source ObservableSource.

This is an alias for publish().refCount().

Scheduler:
share does not operate by default on a particular Scheduler.

Returns
  • an ObservableSource that upon connection causes the source ObservableSource to emit items to its Observers
See Also

public final Single<T> single (T defaultItem)

Returns a Single that emits the single item emitted by this Observable, if this Observable emits only a single item, or a default item if the source ObservableSource emits no items. If the source ObservableSource emits more than one item, an IllegalArgumentException is signalled instead.

Scheduler:
single does not operate by default on a particular Scheduler.

Parameters
defaultItem a default value to emit if the source ObservableSource emits no item
Returns
  • the new Single instance
See Also

public final Maybe<T> singleElement ()

Returns a Maybe that emits the single item emitted by this Observable if this Observable emits only a single item, otherwise if this Observable emits more than one item or no items, an IllegalArgumentException or NoSuchElementException is signalled respectively.

Scheduler:
singleElement does not operate by default on a particular Scheduler.

Returns
  • a Maybe that emits the single item emitted by the source ObservableSource
See Also

public final Single<T> singleOrError ()

Returns a Single that emits the single item emitted by this Observable if this Observable emits only a single item, otherwise if this Observable completes without emitting any items or emits more than one item a NoSuchElementException or IllegalArgumentException will be signalled respectively.

Scheduler:
singleOrError does not operate by default on a particular Scheduler.

Returns
  • the new Single instance
See Also

public final Observable<T> skip (long count)

Returns an Observable that skips the first count items emitted by the source ObservableSource 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
  • an Observable that is identical to the source ObservableSource except that it does not emit the first count items that the source ObservableSource emits
See Also

public final Observable<T> skip (long time, TimeUnit unit, Scheduler scheduler)

Returns an Observable that skips values emitted by the source ObservableSource 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
  • an Observable that skips values emitted by the source ObservableSource before the time window defined by time and scheduler elapses, and then emits the remainder
See Also

public final Observable<T> skip (long time, TimeUnit unit)

Returns an Observable that skips values emitted by the source ObservableSource 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
  • an Observable that skips values emitted by the source ObservableSource before the time window defined by time elapses and the emits the remainder
See Also

public final Observable<T> skipLast (int count)

Returns an Observable that drops a specified number of items from the end of the sequence emitted by the source ObservableSource.

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 ObservableSource. 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
  • an Observable that emits the items emitted by the source ObservableSource except for the dropped ones at the end
Throws
IndexOutOfBoundsException if count is less than zero
See Also

public final Observable<T> skipLast (long time, TimeUnit unit)

Returns an Observable that drops items emitted by the source ObservableSource 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
Returns
  • an Observable that drops those items emitted by the source ObservableSource in a time window before the source completes defined by time
See Also

public final Observable<T> skipLast (long time, TimeUnit unit, boolean delayError)

Returns an Observable that drops items emitted by the source ObservableSource 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 signalled by the current Observable is delayed until the regular elements are consumed by the downstream; if false, an exception is immediately signalled and all regular elements dropped
Returns
  • an Observable that drops those items emitted by the source ObservableSource in a time window before the source completes defined by time
See Also

public final Observable<T> skipLast (long time, TimeUnit unit, Scheduler scheduler)

Returns an Observable that drops items emitted by the source ObservableSource 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
  • an Observable that drops those items emitted by the source ObservableSource in a time window before the source completes defined by time and scheduler
See Also

public final Observable<T> skipLast (long time, TimeUnit unit, Scheduler scheduler, boolean delayError, int bufferSize)

Returns an Observable that drops items emitted by the source ObservableSource 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 signalled by the current Observable is delayed until the regular elements are consumed by the downstream; if false, an exception is immediately signalled and all regular elements dropped
bufferSize the hint about how many elements to expect to be skipped
Returns
  • an Observable that drops those items emitted by the source ObservableSource in a time window before the source completes defined by time and scheduler
See Also

public final Observable<T> skipLast (long time, TimeUnit unit, Scheduler scheduler, boolean delayError)

Returns an Observable that drops items emitted by the source ObservableSource 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 signalled by the current Observable is delayed until the regular elements are consumed by the downstream; if false, an exception is immediately signalled and all regular elements dropped
Returns
  • an Observable that drops those items emitted by the source ObservableSource in a time window before the source completes defined by time and scheduler
See Also

public final Observable<T> skipUntil (ObservableSource<U> other)

Returns an Observable that skips items emitted by the source ObservableSource until a second ObservableSource emits an item.

Scheduler:
skipUntil does not operate by default on a particular Scheduler.

Parameters
other the second ObservableSource that has to emit an item before the source ObservableSource's elements begin to be mirrored by the resulting ObservableSource
Returns
  • an Observable that skips items from the source ObservableSource until the second ObservableSource emits an item, then emits the remaining items
See Also

public final Observable<T> skipWhile (Predicate<? super T> predicate)

Returns an Observable that skips all items emitted by the source ObservableSource 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 source ObservableSource
Returns
  • an Observable that begins emitting items emitted by the source ObservableSource when the specified predicate becomes false
See Also

public final Observable<T> sorted ()

Returns an Observable that emits the events emitted by source ObservableSource, in a sorted order. Each item emitted by the ObservableSource must implement Comparable with respect to all other items in the sequence.

If any item emitted by this Observable does not implement Comparable with respect to all other items emitted by this 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
  • an Observable that emits the items emitted by the source ObservableSource in sorted order

public final Observable<T> sorted (Comparator<? super T> sortFunction)

Returns an Observable that emits the events emitted by source ObservableSource, 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
sortFunction a function that compares two items emitted by the source ObservableSource and returns an Integer that indicates their sort order
Returns
  • an Observable that emits the items emitted by the source ObservableSource in sorted order

public final Observable<T> startWith (ObservableSource<? extends T> other)

Returns an Observable that emits the items in a specified ObservableSource before it begins to emit items emitted by the source ObservableSource.

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
  • an Observable that emits the items in the specified ObservableSource and then emits the items emitted by the source ObservableSource
See Also

public final Observable<T> startWith (Iterable<? extends T> items)

Returns an Observable that emits the items in a specified Iterable before it begins to emit items emitted by the source ObservableSource.

Scheduler:
startWith does not operate by default on a particular Scheduler.

Parameters
items an Iterable that contains the items you want the modified ObservableSource to emit first
Returns
  • an Observable that emits the items in the specified Iterable and then emits the items emitted by the source ObservableSource
See Also

public final Observable<T> startWith (T item)

Returns an Observable that emits a specified item before it begins to emit items emitted by the source ObservableSource.

Scheduler:
startWith does not operate by default on a particular Scheduler.

Parameters
item the item to emit first
Returns
  • an Observable that emits the specified item before it begins to emit items emitted by the source ObservableSource
See Also

public final Observable<T> startWithArray (T... items)

Returns an Observable that emits the specified items before it begins to emit items emitted by the source ObservableSource.

Scheduler:
startWithArray does not operate by default on a particular Scheduler.

Parameters
items the array of values to emit first
Returns
  • an Observable that emits the specified items before it begins to emit items emitted by the source ObservableSource
See Also

public final Disposable subscribe (Consumer<? super T> onNext, Consumer<? super Throwable> onError, Action onComplete, Consumer<? super Disposable> onSubscribe)

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

Scheduler:
subscribe does not operate by default on a particular Scheduler.

Parameters
onNext the Consumer<T> you have designed to accept emissions from the ObservableSource
onError the Consumer<Throwable> you have designed to accept any error notification from the ObservableSource
onComplete the Action you have designed to accept a completion notification from the ObservableSource
onSubscribe the Consumer that receives the upstream's Disposable
Returns
  • a Disposable reference with which the caller can stop receiving items before the ObservableSource has finished sending them
Throws
NullPointerException if onNext is null, or if onError is null, or if onComplete is null
See Also

public final void subscribe (Observer<? super T> observer)

Subscribes the given Observer to this ObservableSource instance.

Parameters
observer the Observer, not null

public final Disposable subscribe (Consumer<? super T> onNext, Consumer<? super Throwable> onError, Action onComplete)

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

Scheduler:
subscribe does not operate by default on a particular Scheduler.

Parameters
onNext the Consumer<T> you have designed to accept emissions from the ObservableSource
onError the Consumer<Throwable> you have designed to accept any error notification from the ObservableSource
onComplete the Action you have designed to accept a completion notification from the ObservableSource
Returns
  • a Disposable reference with which the caller can stop receiving items before the ObservableSource has finished sending them
Throws
NullPointerException if onNext is null, or if onError is null, or if onComplete is null
See Also

public final Disposable subscribe ()

Subscribes to an ObservableSource and ignores onNext and onComplete emissions.

If the Observable emits an error, it is wrapped into an OnErrorNotImplementedException and routed to the RxJavaPlugins.onError handler.

Scheduler:
subscribe does not operate by default on a particular Scheduler.

Returns
  • a Disposable reference with which the caller can stop receiving items before the ObservableSource has finished sending them
See Also

public final Disposable subscribe (Consumer<? super T> onNext)

Subscribes to an ObservableSource 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 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 ObservableSource
Returns
  • a Disposable reference with which the caller can stop receiving items before the ObservableSource has finished sending them
Throws
NullPointerException if onNext is null
See Also

public final Disposable subscribe (Consumer<? super T> onNext, Consumer<? super Throwable> onError)

Subscribes to an ObservableSource and provides callbacks to handle the items it emits and any error notification it issues.

Scheduler:
subscribe does not operate by default on a particular Scheduler.

Parameters
onNext the Consumer<T> you have designed to accept emissions from the ObservableSource
onError the Consumer<Throwable> you have designed to accept any error notification from the ObservableSource
Returns
  • a Disposable reference with which the caller can stop receiving items before the ObservableSource has finished sending them
Throws
NullPointerException if onNext is null, or if onError is null
See Also

public final Observable<T> subscribeOn (Scheduler scheduler)

Asynchronously subscribes Observers to this ObservableSource on the specified Scheduler.

Scheduler:
You specify which Scheduler this operator will use

Parameters
scheduler the Scheduler to perform subscription actions on
Returns
  • the source ObservableSource modified so that its subscriptions happen on the specified Scheduler
See Also

public final E subscribeWith (E observer)

Subscribes a given Observer (subclass) to this Observable and returns the given Observer as is.

Usage example: 


 Observable<Integer> source = Observable.range(1, 10);
 CompositeDisposable composite = new CompositeDisposable();

 ResourceObserver<Integer> rs = new ResourceObserver<>() {
     // ...
 };

 composite.add(source.subscribeWith(rs));
Scheduler:
subscribeWith does not operate by default on a particular Scheduler.

Parameters
observer the Observer (subclass) to use and return, not null
Returns
  • the input observer
Throws
NullPointerException if observer is null

public final Observable<T> switchIfEmpty (ObservableSource<? extends T> other)

Returns an Observable that emits the items emitted by the source ObservableSource or the items of an alternate ObservableSource if the source ObservableSource 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
  • an ObservableSource that emits the items emitted by the source ObservableSource or the items of an alternate ObservableSource if the source ObservableSource is empty.

public final Observable<R> switchMap (Function<? super T, ? extends ObservableSource<? extends R>> mapper)

Returns a new ObservableSource by applying a function that you supply to each item emitted by the source ObservableSource that returns an ObservableSource, and then emitting the items emitted by the most recently emitted of these ObservableSources.

The resulting ObservableSource completes if both the upstream ObservableSource and the last inner ObservableSource, if any, complete. If the upstream ObservableSource 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.

Parameters
mapper a function that, when applied to an item emitted by the source ObservableSource, returns an ObservableSource
Returns
  • an Observable that emits the items emitted by the ObservableSource returned from applying func to the most recently emitted item emitted by the source ObservableSource
See Also

public final Observable<R> switchMap (Function<? super T, ? extends ObservableSource<? extends R>> mapper, int bufferSize)

Returns a new ObservableSource by applying a function that you supply to each item emitted by the source ObservableSource that returns an ObservableSource, and then emitting the items emitted by the most recently emitted of these ObservableSources.

The resulting ObservableSource completes if both the upstream ObservableSource and the last inner ObservableSource, if any, complete. If the upstream ObservableSource 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.

Parameters
mapper a function that, when applied to an item emitted by the source ObservableSource, returns an ObservableSource
bufferSize the number of elements to prefetch from the current active inner ObservableSource
Returns
  • an Observable that emits the items emitted by the ObservableSource returned from applying func to the most recently emitted item emitted by the source ObservableSource
See Also

public final Observable<R> switchMapDelayError (Function<? super T, ? extends ObservableSource<? extends R>> mapper)

Returns a new ObservableSource by applying a function that you supply to each item emitted by the source ObservableSource 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 ObservableSource completes if both the upstream ObservableSource and the last inner ObservableSource, if any, complete. If the upstream 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 signalled.

Scheduler:
switchMapDelayError does not operate by default on a particular Scheduler.

Parameters
mapper a function that, when applied to an item emitted by the source ObservableSource, returns an ObservableSource
Returns
  • an Observable that emits the items emitted by the ObservableSource returned from applying func to the most recently emitted item emitted by the source ObservableSource
See Also

public final Observable<R> switchMapDelayError (Function<? super T, ? extends ObservableSource<? extends R>> mapper, int bufferSize)

Returns a new ObservableSource by applying a function that you supply to each item emitted by the source ObservableSource 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 ObservableSource completes if both the upstream ObservableSource and the last inner ObservableSource, if any, complete. If the upstream 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 signalled.

Scheduler:
switchMapDelayError does not operate by default on a particular Scheduler.

Parameters
mapper a function that, when applied to an item emitted by the source ObservableSource, returns an ObservableSource
bufferSize the number of elements to prefetch from the current active inner ObservableSource
Returns
  • an Observable that emits the items emitted by the ObservableSource returned from applying func to the most recently emitted item emitted by the source ObservableSource
See Also

public final Observable<R> switchMapSingle (Function<? super T, ? extends SingleSource<? extends R>> mapper)

Returns a new ObservableSource by applying a function that you supply to each item emitted by the source ObservableSource that returns a SingleSource, and then emitting the item emitted by the most recently emitted of these SingleSources.

The resulting ObservableSource completes if both the upstream ObservableSource and the last inner SingleSource, if any, complete. If the upstream ObservableSource 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.

Parameters
mapper a function that, when applied to an item emitted by the source ObservableSource, returns a SingleSource
Returns
  • an Observable that emits the item emitted by the SingleSource returned from applying func to the most recently emitted item emitted by the source ObservableSource
See Also

public final Observable<R> switchMapSingleDelayError (Function<? super T, ? extends SingleSource<? extends R>> mapper)

Returns a new ObservableSource by applying a function that you supply to each item emitted by the source ObservableSource 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 ObservableSource completes if both the upstream ObservableSource and the last inner SingleSource, if any, complete. If the upstream ObservableSource 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 signalled.

Scheduler:
switchMapSingleDelayError does not operate by default on a particular Scheduler.

Parameters
mapper a function that, when applied to an item emitted by the source ObservableSource, returns a SingleSource
Returns
  • an Observable that emits the item emitted by the SingleSource returned from applying func to the most recently emitted item emitted by the source ObservableSource
See Also

public static Observable<T> switchOnNext (ObservableSource<? extends ObservableSource<? extends T>> sources, int bufferSize)

Converts an ObservableSource that emits ObservableSources into an ObservableSource 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 ObservableSource is emitted, switchOnNext stops emitting items from the earlier-emitted ObservableSource and begins emitting items from the new one.

The resulting ObservableSource 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.

Parameters
sources the source ObservableSource that emits ObservableSources
bufferSize the number of items to prefetch from the inner ObservableSources
Returns
  • an Observable that emits the items emitted by the ObservableSource most recently emitted by the source ObservableSource
See Also

public static Observable<T> switchOnNext (ObservableSource<? extends ObservableSource<? extends T>> sources)

Converts an ObservableSource that emits ObservableSources into an ObservableSource 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 ObservableSource is emitted, switchOnNext stops emitting items from the earlier-emitted ObservableSource and begins emitting items from the new one.

The resulting ObservableSource 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.

Parameters
sources the source ObservableSource that emits ObservableSources
Returns
  • an Observable that emits the items emitted by the ObservableSource most recently emitted by the source ObservableSource
See Also

public static Observable<T> switchOnNextDelayError (ObservableSource<? extends ObservableSource<? extends T>> sources, int prefetch)

Converts an ObservableSource that emits ObservableSources into an ObservableSource 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 ObservableSource is emitted, switchOnNext stops emitting items from the earlier-emitted ObservableSource and begins emitting items from the new one.

The resulting ObservableSource 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 signalled.

Scheduler:
switchOnNextDelayError does not operate by default on a particular Scheduler.

Parameters
sources the source ObservableSource that emits ObservableSources
prefetch the number of items to prefetch from the inner ObservableSources
Returns
  • an Observable that emits the items emitted by the ObservableSource most recently emitted by the source ObservableSource
See Also

public static Observable<T> switchOnNextDelayError (ObservableSource<? extends ObservableSource<? extends T>> sources)

Converts an ObservableSource that emits ObservableSources into an ObservableSource 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 ObservableSource is emitted, switchOnNext stops emitting items from the earlier-emitted ObservableSource and begins emitting items from the new one.

The resulting ObservableSource 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 signalled.

Scheduler:
switchOnNextDelayError does not operate by default on a particular Scheduler.

Parameters
sources the source ObservableSource that emits ObservableSources
Returns
  • an Observable that emits the items emitted by the ObservableSource most recently emitted by the source ObservableSource
See Also

public final Observable<T> take (long time, TimeUnit unit)

Returns an Observable that emits those items emitted by source ObservableSource before a specified time runs out.

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
  • an Observable that emits those items emitted by the source ObservableSource before the time runs out
See Also

public final Observable<T> take (long time, TimeUnit unit, Scheduler scheduler)

Returns an Observable that emits those items emitted by source ObservableSource before a specified time (on a specified Scheduler) runs out.

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
  • an Observable that emits those items emitted by the source ObservableSource before the time runs out, according to the specified Scheduler
See Also

public final Observable<T> take (long count)

Returns an Observable that emits only the first count items emitted by the source ObservableSource. If the source emits fewer than count items then all of its items are emitted.

This method returns an ObservableSource that will invoke a subscribing Observer's onNext function a maximum of count times before invoking onComplete.

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

Parameters
count the maximum number of items to emit
Returns
  • an Observable that emits only the first count items emitted by the source ObservableSource, or all of the items from the source ObservableSource if that ObservableSource emits fewer than count items
See Also

public final Observable<T> takeLast (long time, TimeUnit unit, boolean delayError)

Returns an Observable that emits the items from the source ObservableSource that were emitted in a specified window of time before the ObservableSource completed.

Scheduler:
This version of takeLast operates by default on the computation Scheduler.

Parameters
time the length of the time window
unit the time unit of time
delayError if true, an exception signalled by the current Observable is delayed until the regular elements are consumed by the downstream; if false, an exception is immediately signalled and all regular elements dropped
Returns
  • an Observable that emits the items from the source ObservableSource that were emitted in the window of time before the ObservableSource completed specified by time
See Also

public final Observable<T> takeLast (long count, long time, TimeUnit unit, Scheduler scheduler, boolean delayError, int bufferSize)

Returns an Observable that emits at most a specified number of items from the source ObservableSource that were emitted in a specified window of time before the ObservableSource 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 signalled by the current Observable is delayed until the regular elements are consumed by the downstream; if false, an exception is immediately signalled and all regular elements dropped
bufferSize the hint about how many elements to expect to be last
Returns
  • an Observable that emits at most count items from the source ObservableSource that were emitted in a specified window of time before the ObservableSource completed, where the timing information is provided by the given scheduler
Throws
IndexOutOfBoundsException if count is less than zero
See Also

public final Observable<T> takeLast (long time, TimeUnit unit, Scheduler scheduler)

Returns an Observable that emits the items from the source ObservableSource that were emitted in a specified window of time before the ObservableSource 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
  • an Observable that emits the items from the source ObservableSource that were emitted in the window of time before the ObservableSource completed specified by time, where the timing information is provided by scheduler
See Also

public final Observable<T> takeLast (long time, TimeUnit unit, Scheduler scheduler, boolean delayError)

Returns an Observable that emits the items from the source ObservableSource that were emitted in a specified window of time before the ObservableSource 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 signalled by the current Observable is delayed until the regular elements are consumed by the downstream; if false, an exception is immediately signalled and all regular elements dropped
Returns
  • an Observable that emits the items from the source ObservableSource that were emitted in the window of time before the ObservableSource completed specified by time, where the timing information is provided by scheduler
See Also

public final Observable<T> takeLast (int count)

Returns an Observable that emits at most the last count items emitted by the source ObservableSource. 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 source ObservableSource
Returns
  • an Observable that emits at most the last count items emitted by the source ObservableSource
Throws
IndexOutOfBoundsException if count is less than zero
See Also

public final Observable<T> takeLast (long time, TimeUnit unit)

Returns an Observable that emits the items from the source ObservableSource that were emitted in a specified window of time before the ObservableSource completed.

Scheduler:
This version of takeLast operates by default on the computation Scheduler.

Parameters
time the length of the time window
unit the time unit of time
Returns
  • an Observable that emits the items from the source ObservableSource that were emitted in the window of time before the ObservableSource completed specified by time
See Also

public final Observable<T> takeLast (long count, long time, TimeUnit unit)

Returns an Observable that emits at most a specified number of items from the source ObservableSource that were emitted in a specified window of time before the ObservableSource completed.

Scheduler:
takeLast does not operate on any particular scheduler but uses the current time from the computation Scheduler.

Parameters
count the maximum number of items to emit
time the length of the time window
unit the time unit of time
Returns
  • an Observable that emits at most count items from the source ObservableSource that were emitted in a specified window of time before the ObservableSource completed
See Also

public final Observable<T> takeLast (long count, long time, TimeUnit unit, Scheduler scheduler)

Returns an Observable that emits at most a specified number of items from the source ObservableSource that were emitted in a specified window of time before the ObservableSource 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
  • an Observable that emits at most count items from the source ObservableSource that were emitted in a specified window of time before the ObservableSource completed, where the timing information is provided by the given scheduler
Throws
IndexOutOfBoundsException if count is less than zero
See Also

public final Observable<T> takeLast (long time, TimeUnit unit, Scheduler scheduler, boolean delayError, int bufferSize)

Returns an Observable that emits the items from the source ObservableSource that were emitted in a specified window of time before the ObservableSource 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 signalled by the current Observable is delayed until the regular elements are consumed by the downstream; if false, an exception is immediately signalled and all regular elements dropped
bufferSize the hint about how many elements to expect to be last
Returns
  • an Observable that emits the items from the source ObservableSource that were emitted in the window of time before the ObservableSource completed specified by time, where the timing information is provided by scheduler
See Also

public final Observable<T> takeUntil (Predicate<? super T> stopPredicate)

Returns an Observable that emits items emitted by the source 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 source Observable and returns a Boolean
Returns
  • an Observable that first emits items emitted by the source Observable, checks the specified condition after each item, and then completes when the condition is satisfied.
See Also

public final Observable<T> takeUntil (ObservableSource<U> other)

Returns an Observable that emits the items emitted by the source Observable until a second ObservableSource emits an item.

Scheduler:
takeUntil does not operate by default on a particular Scheduler.

Parameters
other the ObservableSource whose first emitted item will cause takeUntil to stop emitting items from the source Observable
Returns
  • an Observable that emits the items emitted by the source Observable until such time as other emits its first item
See Also

public final Observable<T> takeWhile (Predicate<? super T> predicate)

Returns an Observable that emits items emitted by the source ObservableSource 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 source ObservableSource and returns a Boolean
Returns
  • an Observable that emits the items from the source ObservableSource so long as each item satisfies the condition defined by predicate, then completes
See Also

public final TestObserver<T> test (boolean dispose)

Creates a TestObserver, optionally disposes it and then subscribes it to this Observable.

Scheduler:
test does not operate by default on a particular Scheduler.

Parameters
dispose dispose the TestObserver before it is subscribed to this Observable?
Returns
  • the new TestObserver instance

public final TestObserver<T> test ()

Creates a TestObserver and subscribes it to this Observable.

Scheduler:
test does not operate by default on a particular Scheduler.

Returns
  • the new TestObserver instance

public final Observable<T> throttleFirst (long windowDuration, TimeUnit unit)

Returns an Observable that emits only the first item emitted by the source ObservableSource during sequential time windows of a specified duration.

This differs from throttleLast(long, TimeUnit) in that this only tracks passage of time whereas throttleLast(long, TimeUnit) 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
  • an Observable that performs the throttle operation
See Also

public final Observable<T> throttleFirst (long skipDuration, TimeUnit unit, Scheduler scheduler)

Returns an Observable that emits only the first item emitted by the source ObservableSource during sequential time windows of a specified duration, where the windows are managed by a specified Scheduler.

This differs from throttleLast(long, TimeUnit) in that this only tracks passage of time whereas throttleLast(long, TimeUnit) 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
  • an Observable that performs the throttle operation
See Also

public final Observable<T> throttleLast (long intervalDuration, TimeUnit unit, Scheduler scheduler)

Returns an Observable that emits only the last item emitted by the source ObservableSource during sequential time windows of a specified duration, where the duration is governed by a specified Scheduler.

This differs from throttleFirst(long, TimeUnit) in that this ticks along at a scheduled interval whereas throttleFirst(long, TimeUnit) 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 source ObservableSource 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
  • an Observable that performs the throttle operation
See Also

public final Observable<T> throttleLast (long intervalDuration, TimeUnit unit)

Returns an Observable that emits only the last item emitted by the source ObservableSource during sequential time windows of a specified duration.

This differs from throttleFirst(long, TimeUnit) in that this ticks along at a scheduled interval whereas throttleFirst(long, TimeUnit) 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 source ObservableSource will be emitted
unit the unit of time of intervalDuration
Returns
  • an Observable that performs the throttle operation
See Also

public final Observable<T> throttleWithTimeout (long timeout, TimeUnit unit, Scheduler scheduler)

Returns an Observable that only emits those items emitted by the source ObservableSource that are not followed by another emitted item within a specified time window, where the time window is governed by a specified Scheduler.

Note: If the source ObservableSource keeps emitting items more frequently than the length of the time window then no items will be emitted by the resulting ObservableSource.

Information on debounce vs throttle:

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 source ObservableSource in which that ObservableSource emits no items in order for the item to be emitted by the resulting ObservableSource
unit the TimeUnit of timeout
scheduler the Scheduler to use internally to manage the timers that handle the timeout for each item
Returns
  • an Observable that filters out items that are too quickly followed by newer items
See Also

public final Observable<T> throttleWithTimeout (long timeout, TimeUnit unit)

Returns an Observable that only emits those items emitted by the source ObservableSource that are not followed by another emitted item within a specified time window.

Note: If the source ObservableSource keeps emitting items more frequently than the length of the time window then no items will be emitted by the resulting ObservableSource.

Information on debounce vs throttle:

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 source ObservableSource in which that ObservableSource emits no items in order for the item to be emitted by the resulting ObservableSource
unit the TimeUnit of timeout
Returns
  • an Observable that filters out items that are too quickly followed by newer items
See Also

public final Observable<Timed<T>> timeInterval (Scheduler scheduler)

Returns an Observable that emits records of the time interval between consecutive items emitted by the source ObservableSource, 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
  • an Observable that emits time interval information items
See Also

public final Observable<Timed<T>> timeInterval (TimeUnit unit, Scheduler scheduler)

Returns an Observable that emits records of the time interval between consecutive items emitted by the source ObservableSource, 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
  • an Observable that emits time interval information items
See Also

public final Observable<Timed<T>> timeInterval ()

Returns an Observable that emits records of the time interval between consecutive items emitted by the source ObservableSource.

Scheduler:
timeInterval does not operate on any particular scheduler but uses the current time from the computation Scheduler.

Returns
  • an Observable that emits time interval information items
See Also

public final Observable<Timed<T>> timeInterval (TimeUnit unit)

Returns an Observable that emits records of the time interval between consecutive items emitted by the source ObservableSource.

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
  • an Observable that emits time interval information items
See Also

public final Observable<T> timeout (Function<? super T, ? extends ObservableSource<V>> itemTimeoutIndicator, ObservableSource<? extends T> other)

Returns an Observable that mirrors the source ObservableSource, but that switches to a fallback ObservableSource if an item emitted by the source ObservableSource 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.

Parameters
itemTimeoutIndicator a function that returns an ObservableSource, for each item emitted by the source ObservableSource, that determines the timeout window for the subsequent item
other the fallback ObservableSource to switch to if the source ObservableSource times out
Returns
  • an Observable that mirrors the source ObservableSource, but switches to mirroring a fallback ObservableSource if an item emitted by the source ObservableSource takes longer to arrive than the time window defined by the selector for the previously emitted item
See Also

public final Observable<T> timeout (long timeout, TimeUnit timeUnit, Scheduler scheduler, ObservableSource<? extends T> other)

Returns an Observable that mirrors the source ObservableSource 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 resulting ObservableSource 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
timeUnit the unit of time that applies to the timeout argument
scheduler the Scheduler to run the timeout timers on
other the ObservableSource to use as the fallback in case of a timeout
Returns
  • the source ObservableSource modified so that it will switch to the fallback ObservableSource in case of a timeout
See Also

public final Observable<T> timeout (ObservableSource<U> firstTimeoutIndicator, Function<? super T, ? extends ObservableSource<V>> itemTimeoutIndicator, ObservableSource<? extends T> other)

Returns an Observable that mirrors the source ObservableSource, but switches to a fallback ObservableSource if either the first item emitted by the source ObservableSource or any subsequent item doesn't arrive within time windows defined by other ObservableSources.

Scheduler:
This version of timeout operates by default on the immediate Scheduler.

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 source ObservableSource and that determines the timeout window in which the subsequent source item must arrive in order to continue the sequence
other the fallback ObservableSource to switch to if the source ObservableSource times out
Returns
  • an Observable that mirrors the source ObservableSource, but switches to the other ObservableSource if either the first item emitted by the source ObservableSource or any subsequent item doesn't arrive within time windows defined by the timeout selectors
Throws
NullPointerException if itemTimeoutIndicator is null, or if other is null
See Also

public final Observable<T> timeout (long timeout, TimeUnit timeUnit)

Returns an Observable that mirrors the source ObservableSource 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 ObservableSource 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
timeUnit the unit of time that applies to the timeout argument.
Returns
  • the source ObservableSource modified to notify observers of a TimeoutException in case of a timeout
See Also

public final Observable<T> timeout (long timeout, TimeUnit timeUnit, ObservableSource<? extends T> other)

Returns an Observable that mirrors the source ObservableSource 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 ObservableSource 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
timeUnit the unit of time that applies to the timeout argument
other the fallback ObservableSource to use in case of a timeout
Returns
  • the source ObservableSource modified to switch to the fallback ObservableSource in case of a timeout
See Also

public final Observable<T> timeout (ObservableSource<U> firstTimeoutIndicator, Function<? super T, ? extends ObservableSource<V>> itemTimeoutIndicator)

Returns an Observable that mirrors the source ObservableSource, but notifies observers of a TimeoutException if either the first item emitted by the source ObservableSource or any subsequent item doesn't arrive within time windows defined by other ObservableSources.

Scheduler:
This version of timeout operates by default on the immediate Scheduler.

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 source ObservableSource and that determines the timeout window in which the subsequent source item must arrive in order to continue the sequence
Returns
  • an Observable that mirrors the source ObservableSource, but notifies observers of a TimeoutException if either the first item or any subsequent item doesn't arrive within the time windows specified by the timeout selectors
See Also

public final Observable<T> timeout (long timeout, TimeUnit timeUnit, Scheduler scheduler)

Returns an Observable that mirrors the source ObservableSource 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 ObservableSource 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
timeUnit the unit of time that applies to the timeout argument
scheduler the Scheduler to run the timeout timers on
Returns
  • the source ObservableSource modified to notify observers of a TimeoutException in case of a timeout
See Also

public final Observable<T> timeout (Function<? super T, ? extends ObservableSource<V>> itemTimeoutIndicator)

Returns an Observable that mirrors the source ObservableSource, but notifies observers of a TimeoutException if an item emitted by the source ObservableSource 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.

Parameters
itemTimeoutIndicator a function that returns an ObservableSource for each item emitted by the source ObservableSource and that determines the timeout window for the subsequent item
Returns
  • an Observable that mirrors the source ObservableSource, but notifies observers of a TimeoutException if an item emitted by the source ObservableSource takes longer to arrive than the time window defined by the selector for the previously emitted item
See Also

public static Observable<Long> timer (long delay, 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
  • an Observable that 0L after a specified delay, and then completes
See Also

public static Observable<Long> timer (long delay, TimeUnit unit, 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
  • an Observable that emits 0L after a specified delay, on a specified Scheduler, and then completes
Throws
NullPointerException if unit is null, or if scheduler is null
See Also

public final Observable<Timed<T>> timestamp (TimeUnit unit, Scheduler scheduler)

Returns an Observable that emits each item emitted by the source ObservableSource, 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
  • an Observable that emits timestamped items from the source ObservableSource with timestamps provided by the scheduler
See Also

public final Observable<Timed<T>> timestamp ()

Returns an Observable that emits each item emitted by the source ObservableSource, wrapped in a Timed object.

Scheduler:
timestamp does not operate on any particular scheduler but uses the current time from the computation Scheduler.

Returns
  • an Observable that emits timestamped items from the source ObservableSource
See Also

public final Observable<Timed<T>> timestamp (Scheduler scheduler)

Returns an Observable that emits each item emitted by the source ObservableSource, 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
  • an Observable that emits timestamped items from the source ObservableSource with timestamps provided by the scheduler
See Also

public final Observable<Timed<T>> timestamp (TimeUnit unit)

Returns an Observable that emits each item emitted by the source ObservableSource, 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
  • an Observable that emits timestamped items from the source ObservableSource
See Also

public final R to (Function<? super Observable<T>, 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.

Parameters
converter the function that receives the current Observable instance and returns a value
Returns
  • the value returned by the function

public final Flowable<T> toFlowable (BackpressureStrategy strategy)

Converts the current Observable into a Flowable by applying the specified backpressure strategy.

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

public final Future<T> toFuture ()

Returns a Future representing the single value emitted by this Observable.

If the Observable emits more than one item, Future will receive an IllegalArgumentException. If the Observable is empty, Future will receive an NoSuchElementException.

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
  • a Future that expects a single item to be emitted by this Observable
See Also

public final Single<U> toList (Callable<U> collectionSupplier)

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

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, instructing the ObservableSource to compose a list of all of these items and then to invoke the Observer's onNext function once, passing it the entire list, by calling the ObservableSource'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.

Parameters
collectionSupplier the Callable returning the collection (for each individual Observer) to be filled in
Returns
  • a Single that emits a single item: a List containing all of the items emitted by the source ObservableSource
See Also

public final Single<List<T>> toList ()

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

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, instructing the ObservableSource to compose a list of all of these items and then to invoke the Observer's onNext function once, passing it the entire list, by calling the ObservableSource'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
  • a Single that emits a single item: a List containing all of the items emitted by the source ObservableSource
See Also

public final Single<List<T>> toList (int capacityHint)

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

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, instructing the ObservableSource to compose a list of all of these items and then to invoke the Observer's onNext function once, passing it the entire list, by calling the ObservableSource'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
  • a Single that emits a single item: a List containing all of the items emitted by the source ObservableSource
See Also

public final Single<Map<K, T>> toMap (Function<? super T, ? extends K> keySelector)

Returns a Single that emits a single HashMap containing all items emitted by the source ObservableSource, 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.

Scheduler:
toMap does not operate by default on a particular Scheduler.

Parameters
keySelector the function that extracts the key from a source item to be used in the HashMap
Returns
  • a Single that emits a single item: a HashMap containing the mapped items from the source ObservableSource
See Also

public final Single<Map<K, V>> toMap (Function<? super T, ? extends K> keySelector, Function<? super T, ? extends V> valueSelector, Callable<? extends Map<K, V>> mapSupplier)

Returns a Single that emits a single Map, returned by a specified mapFactory function, that contains keys and values extracted from the items emitted by the source ObservableSource.

Scheduler:
toMap does not operate by default on a particular Scheduler.

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
  • a Single that emits a single item: a Map that contains the mapped items emitted by the source ObservableSource
See Also

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

Returns a Single that emits a single HashMap containing values corresponding to items emitted by the source ObservableSource, 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 a single entry that corresponds to the latest of those items.

Scheduler:
toMap does not operate by default on a particular Scheduler.

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
  • a Single that emits a single item: a HashMap containing the mapped items from the source ObservableSource
See Also

public final Single<Map<K, Collection<T>>> toMultimap (Function<? super T, ? extends K> keySelector)

Returns a Single that emits a single HashMap that contains an ArrayList of items emitted by the source ObservableSource keyed by a specified keySelector function.

Scheduler:
toMultimap does not operate by default on a particular Scheduler.

Parameters
keySelector the function that extracts the key from the source items to be used as key in the HashMap
Returns
  • a Single that emits a single item: a HashMap that contains an ArrayList of items mapped from the source ObservableSource
See Also

public final Single<Map<K, Collection<V>>> toMultimap (Function<? super T, ? extends K> keySelector, Function<? super T, ? extends V> valueSelector, Callable<Map<K, Collection<V>>> mapSupplier)

Returns a Single that emits a single Map, returned by a specified mapFactory function, that contains an ArrayList of values, extracted by a specified valueSelector function from items emitted by the source ObservableSource and keyed by the keySelector function.

Scheduler:
toMultimap does not operate by default on a particular Scheduler.

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
  • a Single that emits a single item: a Map that contains a list items mapped from the source ObservableSource
See Also

public final Single<Map<K, Collection<V>>> toMultimap (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 source ObservableSource, keyed by a specified keySelector function.

Scheduler:
toMultimap does not operate by default on a particular Scheduler.

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
  • a Single that emits a single item: a HashMap that contains an ArrayList of items mapped from the source ObservableSource
See Also

public final Single<Map<K, Collection<V>>> toMultimap (Function<? super T, ? extends K> keySelector, Function<? super T, ? extends V> valueSelector, Callable<? extends Map<K, Collection<V>>> mapSupplier, Function<? super K, ? extends Collection<? super V>> collectionFactory)

Returns a Single that emits a single Map, returned by a specified mapFactory function, that contains a custom collection of values, extracted by a specified valueSelector function from items emitted by the source ObservableSource, and keyed by the keySelector function.

Scheduler:
toMultimap does not operate by default on a particular Scheduler.

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
  • a Single that emits a single item: a Map that contains the collection of mapped items from the source ObservableSource
See Also

public final Single<List<T>> toSortedList (Comparator<? super T> comparator, int capacityHint)

Returns a Single that emits a list that contains the items emitted by the source ObservableSource, in a sorted order based on a specified comparison function.

Scheduler:
toSortedList does not operate by default on a particular Scheduler.

Parameters
comparator a function that compares two items emitted by the source ObservableSource and returns an Integer that indicates their sort order
capacityHint the initial capacity of the ArrayList used to accumulate items before sorting
Returns
  • a Single that emits a list that contains the items emitted by the source ObservableSource in sorted order
See Also

public final Single<List<T>> toSortedList (Comparator<? super T> comparator)

Returns a Single that emits a list that contains the items emitted by the source ObservableSource, in a sorted order based on a specified comparison function.

Scheduler:
toSortedList does not operate by default on a particular Scheduler.

Parameters
comparator a function that compares two items emitted by the source ObservableSource and returns an Integer that indicates their sort order
Returns
  • a Single that emits a list that contains the items emitted by the source ObservableSource in sorted order
See Also

public final Single<List<T>> toSortedList ()

Returns a Single that emits a list that contains the items emitted by the source ObservableSource, in a sorted order. Each item emitted by the ObservableSource must implement Comparable with respect to all other items in the sequence.

If any item emitted by this Observable does not implement Comparable with respect to all other items emitted by this Observable, no items will be emitted and the sequence is terminated with a ClassCastException.

Scheduler:
toSortedList does not operate by default on a particular Scheduler.

Returns
  • a Single that emits a list that contains the items emitted by the source ObservableSource in sorted order
See Also

public final Single<List<T>> toSortedList (int capacityHint)

Returns a Single that emits a list that contains the items emitted by the source ObservableSource, in a sorted order. Each item emitted by the ObservableSource must implement Comparable with respect to all other items in the sequence.

If any item emitted by this Observable does not implement Comparable with respect to all other items emitted by this Observable, no items will be emitted and the sequence is terminated with a ClassCastException.

Scheduler:
toSortedList does not operate by default on a particular Scheduler.

Parameters
capacityHint the initial capacity of the ArrayList used to accumulate items before sorting
Returns
  • a Single that emits a list that contains the items emitted by the source ObservableSource in sorted order
See Also

public static Observable<T> unsafeCreate (ObservableSource<T> onSubscribe)

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

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

Parameters
onSubscribe the ObservableSource instance to wrap
Returns
  • the new Observable instance

public final Observable<T> unsubscribeOn (Scheduler scheduler)

Modifies the source ObservableSource so that subscribers will dispose it on a specified 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 source ObservableSource modified so that its dispose() calls happen on the specified Scheduler
See Also

public static Observable<T> using (Callable<? extends D> resourceSupplier, Function<? super D, ? extends ObservableSource<? extends T>> sourceSupplier, Consumer<? super D> disposer, boolean eager)

Constructs an ObservableSource that creates a dependent resource object which is disposed of just before termination if you have set disposeEagerly to true and a dispose() call does not occur before termination. Otherwise resource disposal will occur on a dispose() call. Eager disposal is particularly appropriate for a synchronous ObservableSource that reuses resources. disposeAction will only be called once per subscription.

Scheduler:
using does not operate by default on a particular Scheduler.

Parameters
resourceSupplier the factory function to create a resource object that depends on the ObservableSource
sourceSupplier the factory function to create an ObservableSource
disposer the function that will dispose of the resource
eager if true then disposal will happen either on a dispose() call or just before emission of a terminal event (onComplete or onError).
Returns
  • the ObservableSource whose lifetime controls the lifetime of the dependent resource object
See Also

public static Observable<T> using (Callable<? extends D> resourceSupplier, Function<? super D, ? extends ObservableSource<? extends T>> sourceSupplier, Consumer<? super D> disposer)

Constructs an ObservableSource that creates a dependent resource object which is disposed of when the downstream calls dispose().

Scheduler:
using does not operate by default on a particular Scheduler.

Parameters
resourceSupplier the factory function to create a resource object that depends on the ObservableSource
sourceSupplier the factory function to create an ObservableSource
disposer the function that will dispose of the resource
Returns
  • the ObservableSource whose lifetime controls the lifetime of the dependent resource object
See Also

public final Observable<Observable<T>> window (Callable<? extends ObservableSource<B>> boundary)

Returns an Observable that emits windows of items it collects from the source ObservableSource. The resulting ObservableSource emits connected, non-overlapping windows. It emits the current window and opens a new one whenever the ObservableSource produced by the specified closingIndicator emits an item.

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

Parameters
boundary a Callable that returns an ObservableSource that governs the boundary between windows. When the source ObservableSource emits an item, window emits the current window and begins a new one.
Returns
  • an Observable that emits connected, non-overlapping windows of items from the source ObservableSource whenever closingIndicator emits an item
See Also

public final Observable<Observable<T>> window (long timespan, long timeskip, TimeUnit unit, Scheduler scheduler)

Returns an Observable that emits windows of items it collects from the source ObservableSource. The resulting ObservableSource 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 source ObservableSource completes or ObservableSource completes or encounters an error, the resulting ObservableSource emits the current window and propagates the notification from the source ObservableSource.

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
  • an Observable that emits new windows periodically as a fixed timespan elapses
See Also

public final Observable<Observable<T>> window (long timespan, TimeUnit unit, Scheduler scheduler, long count, boolean restart)

Returns an Observable that emits windows of items it collects from the source ObservableSource. The resulting ObservableSource 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 source ObservableSource completes or encounters an error, the resulting ObservableSource emits the current window and propagates the notification from the source ObservableSource.

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
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
  • an Observable that emits connected, non-overlapping windows of items from the source ObservableSource that were emitted during a fixed duration of time or when the window has reached maximum capacity (whichever occurs first)
See Also

public final Observable<Observable<T>> window (ObservableSource<B> boundary)

Returns an Observable that emits non-overlapping windows of items it collects from the source ObservableSource where the boundary of each window is determined by the items emitted from a specified boundary-governing ObservableSource.

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

Parameters
boundary an ObservableSource whose emitted items close and open windows
Returns
  • an Observable that emits non-overlapping windows of items it collects from the source ObservableSource where the boundary of each window is determined by the items emitted from the boundary ObservableSource
See Also

public final Observable<Observable<T>> window (long timespan, TimeUnit unit, Scheduler scheduler, long count, boolean restart, int bufferSize)

Returns an Observable that emits windows of items it collects from the source ObservableSource. The resulting ObservableSource 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 source ObservableSource completes or encounters an error, the resulting ObservableSource emits the current window and propagates the notification from the source ObservableSource.

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
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
bufferSize the capacity hint for the buffer in the inner windows
Returns
  • an Observable that emits connected, non-overlapping windows of items from the source ObservableSource that were emitted during a fixed duration of time or when the window has reached maximum capacity (whichever occurs first)
See Also

public final Observable<Observable<T>> window (long timespan, TimeUnit unit, Scheduler scheduler)

Returns an Observable that emits windows of items it collects from the source ObservableSource. The resulting ObservableSource emits connected, non-overlapping windows, each of a fixed duration as specified by the timespan argument. When the source ObservableSource completes or encounters an error, the resulting ObservableSource emits the current window and propagates the notification from the source ObservableSource.

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
  • an Observable that emits connected, non-overlapping windows containing items emitted by the source ObservableSource within a fixed duration
See Also

public final Observable<Observable<T>> window (ObservableSource<B> boundary, int bufferSize)

Returns an Observable that emits non-overlapping windows of items it collects from the source ObservableSource where the boundary of each window is determined by the items emitted from a specified boundary-governing ObservableSource.

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

Parameters
boundary an ObservableSource whose emitted items close and open windows
bufferSize the capacity hint for the buffer in the inner windows
Returns
  • an Observable that emits non-overlapping windows of items it collects from the source ObservableSource where the boundary of each window is determined by the items emitted from the boundary ObservableSource
See Also

public final Observable<Observable<T>> window (long timespan, long timeskip, TimeUnit unit, Scheduler scheduler, int bufferSize)

Returns an Observable that emits windows of items it collects from the source ObservableSource. The resulting ObservableSource 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 source ObservableSource completes or ObservableSource completes or encounters an error, the resulting ObservableSource emits the current window and propagates the notification from the source ObservableSource.

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
  • an Observable that emits new windows periodically as a fixed timespan elapses
See Also

public final Observable<Observable<T>> window (Callable<? extends ObservableSource<B>> boundary, int bufferSize)

Returns an Observable that emits windows of items it collects from the source ObservableSource. The resulting ObservableSource emits connected, non-overlapping windows. It emits the current window and opens a new one whenever the ObservableSource produced by the specified closingIndicator emits an item.

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

Parameters
boundary a Callable that returns an ObservableSource that governs the boundary between windows. When the source ObservableSource emits an item, window emits the current window and begins a new one.
bufferSize the capacity hint for the buffer in the inner windows
Returns
  • an Observable that emits connected, non-overlapping windows of items from the source ObservableSource whenever closingIndicator emits an item
See Also

public final Observable<Observable<T>> window (long count)

Returns an Observable that emits windows of items it collects from the source ObservableSource. The resulting ObservableSource emits connected, non-overlapping windows, each containing count items. When the source ObservableSource completes or encounters an error, the resulting ObservableSource emits the current window and propagates the notification from the source ObservableSource.

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
  • an Observable that emits connected, non-overlapping windows, each containing at most count items from the source ObservableSource
Throws
IllegalArgumentException if either count is non-positive
See Also

public final Observable<Observable<T>> window (long count, long skip)

Returns an Observable that emits windows of items it collects from the source ObservableSource. The resulting ObservableSource emits windows every skip items, each containing no more than count items. When the source ObservableSource completes or encounters an error, the resulting ObservableSource emits the current window and propagates the notification from the source ObservableSource.

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
  • an Observable that emits windows every skip items containing at most count items from the source ObservableSource
Throws
IllegalArgumentException if either count or skip is non-positive
See Also

public final Observable<Observable<T>> window (ObservableSource<U> openingIndicator, Function<? super U, ? extends ObservableSource<V>> closingIndicator)

Returns an Observable that emits windows of items it collects from the source ObservableSource. The resulting ObservableSource emits windows that contain those items emitted by the source ObservableSource between the time when the openingIndicator ObservableSource emits an item and when the ObservableSource returned by closingIndicator emits an item.

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

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 ObservableSource emits an item, the associated window is closed and emitted
Returns
  • an Observable that emits windows of items emitted by the source ObservableSource that are governed by the specified window-governing ObservableSources
See Also

public final Observable<Observable<T>> window (long timespan, long timeskip, TimeUnit unit)

Returns an Observable that emits windows of items it collects from the source ObservableSource. The resulting ObservableSource 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 source ObservableSource completes or ObservableSource completes or encounters an error, the resulting ObservableSource emits the current window and propagates the notification from the source ObservableSource.

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
  • an Observable that emits new windows periodically as a fixed timespan elapses
See Also

public final Observable<Observable<T>> window (ObservableSource<U> openingIndicator, Function<? super U, ? extends ObservableSource<V>> closingIndicator, int bufferSize)

Returns an Observable that emits windows of items it collects from the source ObservableSource. The resulting ObservableSource emits windows that contain those items emitted by the source ObservableSource between the time when the openingIndicator ObservableSource emits an item and when the ObservableSource returned by closingIndicator emits an item.

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

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 ObservableSource emits an item, the associated window is closed and emitted
bufferSize the capacity hint for the buffer in the inner windows
Returns
  • an Observable that emits windows of items emitted by the source ObservableSource that are governed by the specified window-governing ObservableSources
See Also

public final Observable<Observable<T>> window (long timespan, TimeUnit unit, long count)

Returns an Observable that emits windows of items it collects from the source ObservableSource. The resulting ObservableSource 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 source ObservableSource completes or encounters an error, the resulting ObservableSource emits the current window and propagates the notification from the source ObservableSource.

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
  • an Observable that emits connected, non-overlapping windows of items from the source ObservableSource that were emitted during a fixed duration of time or when the window has reached maximum capacity (whichever occurs first)
See Also

public final Observable<Observable<T>> window (long timespan, TimeUnit unit, long count, boolean restart)

Returns an Observable that emits windows of items it collects from the source ObservableSource. The resulting ObservableSource 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 source ObservableSource completes or encounters an error, the resulting ObservableSource emits the current window and propagates the notification from the source ObservableSource.

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
  • an Observable that emits connected, non-overlapping windows of items from the source ObservableSource that were emitted during a fixed duration of time or when the window has reached maximum capacity (whichever occurs first)
See Also

public final Observable<Observable<T>> window (long timespan, TimeUnit unit, Scheduler scheduler, long count)

Returns an Observable that emits windows of items it collects from the source ObservableSource. The resulting ObservableSource 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 source ObservableSource completes or encounters an error, the resulting ObservableSource emits the current window and propagates the notification from the source ObservableSource.

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
count the maximum size of each window before it should be emitted
Returns
  • an Observable that emits connected, non-overlapping windows of items from the source ObservableSource that were emitted during a fixed duration of time or when the window has reached maximum capacity (whichever occurs first)
See Also

public final Observable<Observable<T>> window (long timespan, TimeUnit unit)

Returns an Observable that emits windows of items it collects from the source ObservableSource. The resulting ObservableSource emits connected, non-overlapping windows, each of a fixed duration specified by the timespan argument. When the source ObservableSource completes or encounters an error, the resulting ObservableSource emits the current window and propagates the notification from the source ObservableSource.

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
  • an Observable that emits connected, non-overlapping windows representing items emitted by the source ObservableSource during fixed, consecutive durations
See Also

public final Observable<Observable<T>> window (long count, long skip, int bufferSize)

Returns an Observable that emits windows of items it collects from the source ObservableSource. The resulting ObservableSource emits windows every skip items, each containing no more than count items. When the source ObservableSource completes or encounters an error, the resulting ObservableSource emits the current window and propagates the notification from the source ObservableSource.

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
  • an Observable that emits windows every skip items containing at most count items from the source ObservableSource
Throws
IllegalArgumentException if either count or skip is non-positive
See Also

public final Observable<R> withLatestFrom (Iterable<? extends ObservableSource<?>> others, Function<? super Object[], R> combiner)

Combines the value emission from this ObservableSource 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 this ObservableSource 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.

Scheduler:
This operator does not operate by default on a particular Scheduler.

Parameters
others the iterable of other sources
combiner the function called with an array of values from each participating ObservableSource
Returns
  • the new ObservableSource instance

public final Observable<R> withLatestFrom (ObservableSource<T1> o1, ObservableSource<T2> o2, Function3<? super T, ? super T1, ? super T2, R> combiner)

Combines the value emission from this ObservableSource 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 this ObservableSource 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.

Scheduler:
This operator does not operate by default on a particular Scheduler.

Parameters
o1 the first other ObservableSource
o2 the second other ObservableSource
combiner the function called with an array of values from each participating ObservableSource
Returns
  • the new ObservableSource instance

public final Observable<R> withLatestFrom (ObservableSource<T1> o1, ObservableSource<T2> o2, ObservableSource<T3> o3, ObservableSource<T4> o4, Function5<? super T, ? super T1, ? super T2, ? super T3, ? super T4, R> combiner)

Combines the value emission from this ObservableSource 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 this ObservableSource 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.

Scheduler:
This operator does not operate by default on a particular Scheduler.

Parameters
o1 the first other ObservableSource
o2 the second other ObservableSource
o3 the third other ObservableSource
o4 the fourth other ObservableSource
combiner the function called with an array of values from each participating ObservableSource
Returns
  • the new ObservableSource instance

public final Observable<R> withLatestFrom (ObservableSource<? extends U> other, BiFunction<? super T, ? super U, ? extends R> combiner)

Merges the specified ObservableSource into this ObservableSource sequence by using the resultSelector function only when the source ObservableSource (this instance) emits an item.

Scheduler:
This operator, by default, doesn't run any particular Scheduler.

Parameters
other the other ObservableSource
combiner the function to call when this ObservableSource emits an item and the other ObservableSource has already emitted an item, to generate the item to be emitted by the resulting ObservableSource
Returns
  • an Observable that merges the specified ObservableSource into this ObservableSource by using the resultSelector function only when the source ObservableSource sequence (this instance) emits an item
See Also

public final Observable<R> withLatestFrom (ObservableSource<T1> o1, ObservableSource<T2> o2, ObservableSource<T3> o3, Function4<? super T, ? super T1, ? super T2, ? super T3, R> combiner)

Combines the value emission from this ObservableSource 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 this ObservableSource 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.

Scheduler:
This operator does not operate by default on a particular Scheduler.

Parameters
o1 the first other ObservableSource
o2 the second other ObservableSource
o3 the third other ObservableSource
combiner the function called with an array of values from each participating ObservableSource
Returns
  • the new ObservableSource instance

public final Observable<R> withLatestFrom (ObservableSource[]<?> others, Function<? super Object[], R> combiner)

Combines the value emission from this ObservableSource 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 this ObservableSource 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.

Scheduler:
This operator does not operate by default on a particular Scheduler.

Parameters
others the array of other sources
combiner the function called with an array of values from each participating ObservableSource
Returns
  • the new ObservableSource instance

public static Observable<T> wrap (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.

Parameters
source the source ObservableSource instance
Returns
  • the new Observable instance or the same as the source
Throws
NullPointerException if source is null

public static Observable<R> zip (ObservableSource<? extends T1> source1, ObservableSource<? extends T2> source2, ObservableSource<? extends T3> source3, ObservableSource<? extends T4> source4, ObservableSource<? extends T5> source5, ObservableSource<? extends T6> source6, ObservableSource<? extends T7> source7, 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 new ObservableSource will be the result of the function applied to the first item emitted by each source ObservableSource, the second item emitted by the new ObservableSource will be the result of the function applied to the second item emitted by each of those ObservableSources, and so forth.

The resulting ObservableSource<R> returned from zip will invoke onNext as many times as the number of onNext invocations of the source 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.

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 source ObservableSources, results in an item that will be emitted by the resulting ObservableSource
Returns
  • an Observable that emits the zipped results
See Also

public static Observable<R> zip (ObservableSource<? extends ObservableSource<? extends T>> sources, Function<? super Object[], ? extends R> zipper)

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

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

The resulting ObservableSource<R> returned from zip will invoke onNext as many times as the number of onNext invocations of the source 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(just(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.

Parameters
sources an ObservableSource of source ObservableSources
zipper a function that, when applied to an item emitted by each of the ObservableSources emitted by ws, results in an item that will be emitted by the resulting ObservableSource
Returns
  • an Observable that emits the zipped results
See Also

public static Observable<R> zip (ObservableSource<? extends T1> source1, ObservableSource<? extends T2> source2, 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 new ObservableSource 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 new ObservableSource 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 ObservableSource<R> returned from zip will invoke onNext as many times as the number of onNext invocations of the source 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.

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 source ObservableSources, results in an item that will be emitted by the resulting ObservableSource
delayError delay errors from any of the source ObservableSources till the other terminates
bufferSize the number of elements to prefetch from each source ObservableSource
Returns
  • an Observable that emits the zipped results
See Also

public static Observable<R> zip (ObservableSource<? extends T1> source1, ObservableSource<? extends T2> source2, ObservableSource<? extends T3> source3, 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 new ObservableSource 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 new ObservableSource 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 ObservableSource<R> returned from zip will invoke onNext as many times as the number of onNext invocations of the source 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.

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 source ObservableSources, results in an item that will be emitted by the resulting ObservableSource
Returns
  • an Observable that emits the zipped results
See Also

public static Observable<R> zip (ObservableSource<? extends T1> source1, ObservableSource<? extends T2> source2, 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 new ObservableSource 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 new ObservableSource 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 ObservableSource<R> returned from zip will invoke onNext as many times as the number of onNext invocations of the source 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.

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 source ObservableSources, results in an item that will be emitted by the resulting ObservableSource
delayError delay errors from any of the source ObservableSources till the other terminates
Returns
  • an Observable that emits the zipped results
See Also

public static Observable<R> zip (Iterable<? extends ObservableSource<? extends T>> sources, 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 new ObservableSource will be the result of the function applied to the first item emitted by each of the source ObservableSources; the second item emitted by the new ObservableSource will be the result of the function applied to the second item emitted by each of those ObservableSources; and so forth.

The resulting ObservableSource<R> returned from zip will invoke onNext as many times as the number of onNext invocations of the source 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.

Parameters
sources an Iterable of source ObservableSources
zipper a function that, when applied to an item emitted by each of the source ObservableSources, results in an item that will be emitted by the resulting ObservableSource
Returns
  • an Observable that emits the zipped results
See Also

public static Observable<R> zip (ObservableSource<? extends T1> source1, ObservableSource<? extends T2> source2, ObservableSource<? extends T3> source3, ObservableSource<? extends T4> source4, ObservableSource<? extends T5> source5, 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 new ObservableSource 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 new ObservableSource will be the result of the function applied to the second item emitted by each of those ObservableSources; and so forth.

The resulting ObservableSource<R> returned from zip will invoke onNext as many times as the number of onNext invocations of the source 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.

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 source ObservableSources, results in an item that will be emitted by the resulting ObservableSource
Returns
  • an Observable that emits the zipped results
See Also

public static Observable<R> zip (ObservableSource<? extends T1> source1, ObservableSource<? extends T2> source2, 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 new ObservableSource 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 new ObservableSource 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 ObservableSource<R> returned from zip will invoke onNext as many times as the number of onNext invocations of the source 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.

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 source ObservableSources, results in an item that will be emitted by the resulting ObservableSource
Returns
  • an Observable that emits the zipped results
See Also

public static Observable<R> zip (ObservableSource<? extends T1> source1, ObservableSource<? extends T2> source2, ObservableSource<? extends T3> source3, ObservableSource<? extends T4> source4, 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 new ObservableSource 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 new ObservableSource will be the result of the function applied to the second item emitted by each of those ObservableSources; and so forth.

The resulting ObservableSource<R> returned from zip will invoke onNext as many times as the number of onNext invocations of the source 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.

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 source ObservableSources, results in an item that will be emitted by the resulting ObservableSource
Returns
  • an Observable that emits the zipped results
See Also

public static Observable<R> zip (ObservableSource<? extends T1> source1, ObservableSource<? extends T2> source2, ObservableSource<? extends T3> source3, ObservableSource<? extends T4> source4, ObservableSource<? extends T5> source5, ObservableSource<? extends T6> source6, 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 new ObservableSource will be the result of the function applied to the first item emitted by each source ObservableSource, the second item emitted by the new ObservableSource will be the result of the function applied to the second item emitted by each of those ObservableSources, and so forth.

The resulting ObservableSource<R> returned from zip will invoke onNext as many times as the number of onNext invocations of the source 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.

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 source ObservableSources, results in an item that will be emitted by the resulting ObservableSource
Returns
  • an Observable that emits the zipped results
See Also

public static Observable<R> zip (ObservableSource<? extends T1> source1, ObservableSource<? extends T2> source2, ObservableSource<? extends T3> source3, ObservableSource<? extends T4> source4, ObservableSource<? extends T5> source5, ObservableSource<? extends T6> source6, ObservableSource<? extends T7> source7, ObservableSource<? extends T8> source8, 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 new ObservableSource will be the result of the function applied to the first item emitted by each source ObservableSource, the second item emitted by the new ObservableSource will be the result of the function applied to the second item emitted by each of those ObservableSources, and so forth.

The resulting ObservableSource<R> returned from zip will invoke onNext as many times as the number of onNext invocations of the source 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.

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 source ObservableSources, results in an item that will be emitted by the resulting ObservableSource
Returns
  • an Observable that emits the zipped results
See Also

public static Observable<R> zip (ObservableSource<? extends T1> source1, ObservableSource<? extends T2> source2, ObservableSource<? extends T3> source3, ObservableSource<? extends T4> source4, ObservableSource<? extends T5> source5, ObservableSource<? extends T6> source6, ObservableSource<? extends T7> source7, ObservableSource<? extends T8> source8, ObservableSource<? extends T9> source9, 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 new ObservableSource will be the result of the function applied to the first item emitted by each source ObservableSource, the second item emitted by the new ObservableSource will be the result of the function applied to the second item emitted by each of those ObservableSources, and so forth.

The resulting ObservableSource<R> returned from zip will invoke onNext as many times as the number of onNext invocations of the source 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.

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 source ObservableSources, results in an item that will be emitted by the resulting ObservableSource
Returns
  • an Observable that emits the zipped results
See Also

public static Observable<R> zipArray (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.

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

The resulting ObservableSource<R> returned from zip will invoke onNext as many times as the number of onNext invocations of the source 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.

Parameters
zipper a function that, when applied to an item emitted by each of the source ObservableSources, results in an item that will be emitted by the resulting ObservableSource
delayError delay errors signalled by any of the source ObservableSource until all ObservableSources terminate
bufferSize the number of elements to prefetch from each source ObservableSource
sources an array of source ObservableSources
Returns
  • an Observable that emits the zipped results
See Also

public static Observable<R> zipIterable (Iterable<? extends ObservableSource<? extends T>> sources, 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 new ObservableSource will be the result of the function applied to the first item emitted by each of the source ObservableSources; the second item emitted by the new ObservableSource will be the result of the function applied to the second item emitted by each of those ObservableSources; and so forth.

The resulting ObservableSource<R> returned from zip will invoke onNext as many times as the number of onNext invocations of the source 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:
zipIterable does not operate by default on a particular Scheduler.

Parameters
sources an Iterable of source ObservableSources
zipper a function that, when applied to an item emitted by each of the source ObservableSources, results in an item that will be emitted by the resulting ObservableSource
delayError delay errors signalled by any of the source ObservableSource until all ObservableSources terminate
bufferSize the number of elements to prefetch from each source ObservableSource
Returns
  • an Observable that emits the zipped results
See Also

public final Observable<R> zipWith (ObservableSource<? extends U> other, 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 source ObservableSource 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.

Parameters
other the other ObservableSource
zipper a function that combines the pairs of items from the two ObservableSources to generate the items to be emitted by the resulting ObservableSource
Returns
  • an Observable that pairs up values from the source ObservableSource and the other ObservableSource and emits the results of zipFunction applied to these pairs
See Also

public final Observable<R> zipWith (ObservableSource<? extends U> other, 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 source ObservableSource 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.

Parameters
other the other ObservableSource
zipper a function that combines the pairs of items from the two ObservableSources to generate the items to be emitted by the resulting ObservableSource
delayError if true, errors from the current Observable or the other ObservableSource is delayed until both terminate
Returns
  • an Observable that pairs up values from the source ObservableSource and the other ObservableSource and emits the results of zipFunction applied to these pairs
See Also

public final Observable<R> zipWith (ObservableSource<? extends U> other, 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 source ObservableSource 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.

Parameters
other the other ObservableSource
zipper a function that combines the pairs of items from the two ObservableSources to generate the items to be emitted by the resulting ObservableSource
delayError if true, errors from the current Observable or the other ObservableSource is delayed until both terminate
bufferSize the capacity hint for the buffer in the inner windows
Returns
  • an Observable that pairs up values from the source ObservableSource and the other ObservableSource and emits the results of zipFunction applied to these pairs
See Also

public final Observable<R> zipWith (Iterable<U> other, 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 source ObservableSource and a specified Iterable sequence.

Note that the other Iterable is evaluated as items are observed from the source ObservableSource; 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.

Parameters
other the Iterable sequence
zipper a function that combines the pairs of items from the ObservableSource and the Iterable to generate the items to be emitted by the resulting ObservableSource
Returns
  • an Observable that pairs up values from the source ObservableSource and the other Iterable sequence and emits the results of zipFunction applied to these pairs
See Also

Protected Methods

protected abstract void subscribeActual (Observer<? super T> observer)

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

There is no need to call any of the plugin hooks on the current Observable instance or the Subscriber.

Parameters
observer the incoming Observer, never null