io.reactivex

Class Observable<T>

java.lang.Object

io.reactivex.Observable<T>

Type Parameters:

T - the type of the items emitted by the Observable

All Implemented Interfaces:

ObservableSource<T>

Direct Known Subclasses:

ConnectableObservable, GroupedObservable, Subject

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

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

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

The Observable's operators, by default, run with a buffer size of 128 elements (see Flowable.bufferSize()), that can be overridden globally via the system parameter 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 dispose of a flow.

The Observable follows the protocol

      onSubscribe onNext* (onError | onComplete)?
 

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

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

Example:

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

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

See Also:

Flowable, DisposableObserver

Constructor Summary

Constructors

Constructor and Description
Observable()

Method Summary

Modifier and Type	Method and Description
Single<Boolean>	all(Predicate<? super T> predicate) Returns a Single 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.
Observable<T>	ambWith(ObservableSource<? extends T> other) Mirrors the ObservableSource (current or provided) that first either emits an item or sends a termination notification.
Single<Boolean>	any(Predicate<? super T> predicate) Returns a Single that emits true if any item emitted by the source ObservableSource satisfies a specified condition, otherwise false.
<R> R	as(ObservableConverter<T,? extends R> converter) Calls the specified converter function during assembly time and returns its resulting value.
T	blockingFirst() Returns the first item emitted by this Observable, or throws NoSuchElementException if it emits no items.
T	blockingFirst(T defaultItem) Returns the first item emitted by this Observable, or a default value if it emits no items.
void	blockingForEach(Consumer<? super T> onNext) Consumes the upstream Observable in a blocking fashion and invokes the given Consumer with each upstream item on the current thread until the upstream terminates.
Iterable<T>	blockingIterable() Converts this Observable into an Iterable.
Iterable<T>	blockingIterable(int bufferSize) Converts this Observable into an Iterable.
T	blockingLast() Returns the last item emitted by this Observable, or throws NoSuchElementException if this Observable emits no items.
T	blockingLast(T defaultItem) Returns the last item emitted by this Observable, or a default value if it emits no items.
Iterable<T>	blockingLatest() Returns an Iterable that returns the latest item emitted by this Observable, waiting if necessary for one to become available.
Iterable<T>	blockingMostRecent(T initialValue) Returns an Iterable that always returns the item most recently emitted by this Observable.
Iterable<T>	blockingNext() Returns an Iterable that blocks until this Observable emits another item, then returns that item.
T	blockingSingle() If this Observable completes after emitting a single item, return that item, otherwise throw a NoSuchElementException.
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.
void	blockingSubscribe() Runs the source observable to a terminal event, ignoring any values and rethrowing any exception.
void	blockingSubscribe(Consumer<? super T> onNext) Subscribes to the source and calls the given callbacks on the current thread.
void	blockingSubscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError) Subscribes to the source and calls the given callbacks on the current thread.
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.
void	blockingSubscribe(Observer<? super T> observer) Subscribes to the source and calls the Observer methods on the current thread.
<B> Observable<List<T>>	buffer(Callable<? extends ObservableSource<B>> boundarySupplier) Returns an Observable that emits buffers of items it collects from the source ObservableSource.
<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.
Observable<List<T>>	buffer(int count) Returns an Observable that emits buffers of items it collects from the source ObservableSource.
<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.
Observable<List<T>>	buffer(int count, int skip) Returns an Observable that emits buffers of items it collects from the source ObservableSource.
<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.
Observable<List<T>>	buffer(long timespan, long timeskip, TimeUnit unit) Returns an Observable that emits buffers of items it collects from the source ObservableSource.
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.
<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.
Observable<List<T>>	buffer(long timespan, TimeUnit unit) Returns an Observable that emits buffers of items it collects from the source ObservableSource.
Observable<List<T>>	buffer(long timespan, TimeUnit unit, int count) Returns an Observable that emits buffers of items it collects from the source ObservableSource.
Observable<List<T>>	buffer(long timespan, TimeUnit unit, Scheduler scheduler) Returns an Observable that emits buffers of items it collects from the source ObservableSource.
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.
<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.
<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.
<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.
<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.
<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.
<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.
static int	bufferSize() Returns the default 'island' size or capacity-increment hint for unbounded buffers.
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.
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.
<U> Observable<U>	cast(Class<U> clazz) Returns an Observable that emits the items emitted by the source ObservableSource, converted to the specified type.
<U> Single<U>	collect(Callable<? extends U> initialValueSupplier, BiConsumer<? super U,? super T> collector) Collects items emitted by the finite source ObservableSource into a single mutable data structure and returns a Single that emits this structure.
<U> Single<U>	collectInto(U initialValue, BiConsumer<? super U,? super T> collector) Collects items emitted by the finite source ObservableSource into a single mutable data structure and returns a Single that emits this structure.
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 <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 <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(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 <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,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,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,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 <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,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 <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 <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 <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(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(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(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 <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.
<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(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 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 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 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(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 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(int maxConcurrency, int prefetch, ObservableSource<? extends T>... sources) Concatenates an array of ObservableSources eagerly into a single stream of values.
static <T> Observable<T>	concatArrayEager(ObservableSource<? extends T>... sources) Concatenates an array of ObservableSources eagerly into a single stream of values.
static <T> Observable<T>	concatArrayEagerDelayError(int maxConcurrency, int prefetch, ObservableSource<? extends T>... sources) Concatenates an array of ObservableSources eagerly into a single stream of values and delaying any errors until all sources terminate.
static <T> Observable<T>	concatArrayEagerDelayError(ObservableSource<? extends T>... sources) Concatenates an array of ObservableSources eagerly into a single stream of values and delaying any errors until all sources terminate.
static <T> 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) 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, 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>	concatEager(Iterable<? extends ObservableSource<? extends T>> sources) Concatenates a 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(ObservableSource<? extends ObservableSource<? extends T>> sources) Concatenates an ObservableSource sequence of ObservableSources eagerly into a single stream of values.
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.
<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.
<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.
Completable	concatMapCompletable(Function<? super T,? extends CompletableSource> mapper) Maps each element of the upstream Observable into CompletableSources, subscribes to them one at a time in order and waits until the upstream and all CompletableSources complete.
Completable	concatMapCompletable(Function<? super T,? extends CompletableSource> mapper, int capacityHint) Maps each element of the upstream Observable into CompletableSources, subscribes to them one at a time in order and waits until the upstream and all CompletableSources complete.
Completable	concatMapCompletableDelayError(Function<? super T,? extends CompletableSource> mapper) Maps the upstream items into CompletableSources and subscribes to them one after the other terminates, delaying all errors till both this Observable and all inner CompletableSources terminate.
Completable	concatMapCompletableDelayError(Function<? super T,? extends CompletableSource> mapper, boolean tillTheEnd) Maps the upstream items into CompletableSources and subscribes to them one after the other terminates, optionally delaying all errors till both this Observable and all inner CompletableSources terminate.
Completable	concatMapCompletableDelayError(Function<? super T,? extends CompletableSource> mapper, boolean tillTheEnd, int prefetch) Maps the upstream items into CompletableSources and subscribes to them one after the other terminates, optionally delaying all errors till both this Observable and all inner CompletableSources terminate.
<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.
<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.
<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.
<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.
<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.
<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.
<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.
<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.
<R> Observable<R>	concatMapMaybe(Function<? super T,? extends MaybeSource<? extends R>> mapper) Maps the upstream items into MaybeSources and subscribes to them one after the other succeeds or completes, emits their success value if available or terminates immediately if either this Observable or the current inner MaybeSource fail.
<R> Observable<R>	concatMapMaybe(Function<? super T,? extends MaybeSource<? extends R>> mapper, int prefetch) Maps the upstream items into MaybeSources and subscribes to them one after the other succeeds or completes, emits their success value if available or terminates immediately if either this Observable or the current inner MaybeSource fail.
<R> Observable<R>	concatMapMaybeDelayError(Function<? super T,? extends MaybeSource<? extends R>> mapper) Maps the upstream items into MaybeSources and subscribes to them one after the other terminates, emits their success value if available and delaying all errors till both this Observable and all inner MaybeSources terminate.
<R> Observable<R>	concatMapMaybeDelayError(Function<? super T,? extends MaybeSource<? extends R>> mapper, boolean tillTheEnd) Maps the upstream items into MaybeSources and subscribes to them one after the other terminates, emits their success value if available and optionally delaying all errors till both this Observable and all inner MaybeSources terminate.
<R> Observable<R>	concatMapMaybeDelayError(Function<? super T,? extends MaybeSource<? extends R>> mapper, boolean tillTheEnd, int prefetch) Maps the upstream items into MaybeSources and subscribes to them one after the other terminates, emits their success value if available and optionally delaying all errors till both this Observable and all inner MaybeSources terminate.
<R> Observable<R>	concatMapSingle(Function<? super T,? extends SingleSource<? extends R>> mapper) Maps the upstream items into SingleSources and subscribes to them one after the other succeeds, emits their success values or terminates immediately if either this Observable or the current inner SingleSource fail.
<R> Observable<R>	concatMapSingle(Function<? super T,? extends SingleSource<? extends R>> mapper, int prefetch) Maps the upstream items into SingleSources and subscribes to them one after the other succeeds, emits their success values or terminates immediately if either this Observable or the current inner SingleSource fail.
<R> Observable<R>	concatMapSingleDelayError(Function<? super T,? extends SingleSource<? extends R>> mapper) Maps the upstream items into SingleSources and subscribes to them one after the other succeeds or fails, emits their success values and delays all errors till both this Observable and all inner SingleSources terminate.
<R> Observable<R>	concatMapSingleDelayError(Function<? super T,? extends SingleSource<? extends R>> mapper, boolean tillTheEnd) Maps the upstream items into SingleSources and subscribes to them one after the other succeeds or fails, emits their success values and optionally delays all errors till both this Observable and all inner SingleSources terminate.
<R> Observable<R>	concatMapSingleDelayError(Function<? super T,? extends SingleSource<? extends R>> mapper, boolean tillTheEnd, int prefetch) Maps the upstream items into SingleSources and subscribes to them one after the other succeeds or fails, emits their success values and optionally delays errors till both this Observable and all inner SingleSources terminate.
Observable<T>	concatWith(CompletableSource other) Returns an Observable that emits items from this Observable and when it completes normally, the other CompletableSource is subscribed to and the returned Observable emits its terminal events.
Observable<T>	concatWith(MaybeSource<? extends T> other) Returns an Observable that emits the items from this Observable followed by the success item or terminal events of the other MaybeSource.
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.
Observable<T>	concatWith(SingleSource<? extends T> other) Returns an Observable that emits the items from this Observable followed by the success item or error event of the other SingleSource.
Single<Boolean>	contains(Object element) Returns a Single that emits a Boolean that indicates whether the source ObservableSource emitted a specified item.
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.
<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.
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.
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.
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.
<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.
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.
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.
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.
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.
<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.
Observable<T>	delaySubscription(long delay, TimeUnit unit) Returns an Observable that delays the subscription to the source ObservableSource by a given amount of time.
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.
<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.
<T2> Observable<T2>	dematerialize() Deprecated. in 2.2.4; inherently type-unsafe as it overrides the output generic type. Use dematerialize(Function) instead.
<R> Observable<R>	dematerialize(Function<? super T,Notification<R>> selector) Returns an Observable that reverses the effect of materialize by transforming the Notification objects extracted from the source items via a selector function into their respective Observer signal types.
Observable<T>	distinct() Returns an Observable that emits all items emitted by the source ObservableSource that are distinct based on Object.equals(Object) comparison.
<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 and based on Object.equals(Object) comparison of the objects returned by the key selector function.
<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 and based on Object.equals(Object) comparison of the objects returned by the key selector function.
Observable<T>	distinctUntilChanged() Returns an Observable that emits all items emitted by the source ObservableSource that are distinct from their immediate predecessors based on Object.equals(Object) comparison.
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.
<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 and based on Object.equals(Object) comparison of those objects returned by the key selector function.
Observable<T>	doAfterNext(Consumer<? super T> onAfterNext) Calls the specified consumer with the current item after this item has been emitted to the downstream.
Observable<T>	doAfterTerminate(Action onFinally) Registers an Action to be called when this ObservableSource invokes either onComplete or onError.
Observable<T>	doFinally(Action onFinally) Calls the specified action after this Observable signals onError or onCompleted or gets disposed by the downstream.
Observable<T>	doOnComplete(Action onComplete) Modifies the source ObservableSource so that it invokes an action when it calls onComplete.
Observable<T>	doOnDispose(Action onDispose) Calls the dispose Action if the downstream disposes the sequence.
Observable<T>	doOnEach(Consumer<? super Notification<T>> onNotification) Modifies the source ObservableSource so that it invokes an action for each item it emits.
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.
Observable<T>	doOnError(Consumer<? super Throwable> onError) Modifies the source ObservableSource so that it invokes an action if it calls onError.
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, disposal).
Observable<T>	doOnNext(Consumer<? super T> onNext) Modifies the source ObservableSource so that it invokes an action when it calls onNext.
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.
Observable<T>	doOnTerminate(Action onTerminate) Modifies the source ObservableSource so that it invokes an action when it calls onComplete or onError.
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.
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.
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.
Observable<T>	filter(Predicate<? super T> predicate) Filters items emitted by an ObservableSource by only emitting those that satisfy a specified predicate.
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.
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.
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.
<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.
<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.
<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.
<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.
<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.
<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.
<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.
<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.
<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.
<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.
<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.
<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.
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.
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.
<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.
<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.
<R> Observable<R>	flatMapMaybe(Function<? super T,? extends MaybeSource<? extends R>> mapper) Maps each element of the upstream Observable into MaybeSources, subscribes to all of them and merges their onSuccess values, in no particular order, into a single Observable sequence.
<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 merges their onSuccess values, in no particular order, into a single Observable sequence, optionally delaying all errors.
<R> Observable<R>	flatMapSingle(Function<? super T,? extends SingleSource<? extends R>> mapper) Maps each element of the upstream Observable into SingleSources, subscribes to all of them and merges their onSuccess values, in no particular order, into a single Observable sequence.
<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 merges their onSuccess values, in no particular order, into a single Observable sequence, optionally delaying all errors.
Disposable	forEach(Consumer<? super T> onNext) Subscribes to the ObservableSource and receives notifications for each element.
Disposable	forEachWhile(Predicate<? super T> onNext) Subscribes to the ObservableSource and receives notifications for each element until the onNext Predicate returns false.
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.
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.
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) Converts a Future into an ObservableSource.
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, 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, Scheduler scheduler) Converts a Future, operating on a specified Scheduler, 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, 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,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, BiFunction<S,Emitter<T>,S> 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.
<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.
<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.
<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.
<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.
<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.
<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.
Observable<T>	hide() Hides the identity of this Observable and its Disposable.
Completable	ignoreElements() Ignores all items emitted by the source ObservableSource and only calls onComplete or onError.
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>	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 period, TimeUnit unit) Returns an Observable that emits a sequential number every specified interval of time.
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>	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.
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.
Single<Boolean>	isEmpty() Returns a Single that emits true if the source ObservableSource is empty, otherwise false.
<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 item) Returns an Observable that signals the given (constant reference) item and then completes.
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) Converts three 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 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) Converts six 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.
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.
Maybe<T>	lastElement() Returns a Maybe that emits the last item emitted by this Observable or completes if this Observable is empty.
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.
<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; Returns an Observable which, when subscribed to, invokes the apply(Observer) method of the provided ObservableOperator for each individual downstream Observer and allows the insertion of a custom operator by accessing the downstream's Observer during this subscription phase and providing a new Observer, containing the custom operator's intended business logic, that will be used in the subscription process going further upstream.
<R> 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.
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(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(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(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 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) Flattens two ObservableSources into a single ObservableSource, without any transformation.
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 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(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>	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>	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(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(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(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(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.
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 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.
Observable<T>	mergeWith(CompletableSource other) Relays the items of this Observable and completes only when the other CompletableSource completes as well.
Observable<T>	mergeWith(MaybeSource<? extends T> other) Merges the sequence of items of this Observable with the success value of the other MaybeSource or waits both to complete normally if the MaybeSource is empty.
Observable<T>	mergeWith(ObservableSource<? extends T> other) Flattens this and another ObservableSource into a single ObservableSource, without any transformation.
Observable<T>	mergeWith(SingleSource<? extends T> other) Merges the sequence of items of this Observable with the success value of the other SingleSource.
static <T> Observable<T>	never() Returns an Observable that never sends any items or notifications to an Observer.
Observable<T>	observeOn(Scheduler scheduler) Modifies an ObservableSource to perform its emissions and notifications on a specified Scheduler, asynchronously with an unbounded buffer with Flowable.bufferSize() "island size".
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 Flowable.bufferSize() "island size" and optionally delays onError notifications.
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.
<U> Observable<U>	ofType(Class<U> clazz) Filters the items emitted by an ObservableSource, only emitting those of the specified type.
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.
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.
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.
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.
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.
Observable<T>	onTerminateDetach() Nulls out references to the upstream producer and downstream Observer if the sequence is terminated or downstream calls dispose().
ConnectableObservable<T>	publish() Returns a ConnectableObservable, which is a variety of ObservableSource that waits until its connect method is called before it begins emitting items to those Observers that have subscribed to it.
<R> 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.
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 finite source ObservableSource, and emits the final result from the final call to your function as its sole item.
<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 finite source ObservableSource, emitting the final result from the final call to your function as its sole item.
<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 finite source ObservableSource, emitting the final result from the final call to your function as its sole item.
Observable<T>	repeat() Returns an Observable that repeats the sequence of items emitted by the source ObservableSource indefinitely.
Observable<T>	repeat(long times) Returns an Observable that repeats the sequence of items emitted by the source ObservableSource at most count times.
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.
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.
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.
<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.
<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.
<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.
<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.
<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.
<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.
<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.
<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.
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.
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.
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.
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.
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.
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.
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.
Observable<T>	retry() Returns an Observable that mirrors the source ObservableSource, resubscribing to it if it calls onError (infinite retry count).
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.
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.
Observable<T>	retry(long times, Predicate<? super Throwable> predicate) Retries at most times or until the predicate returns false, whichever happens first.
Observable<T>	retry(Predicate<? super Throwable> predicate) Retries the current Observable if the predicate returns true.
Observable<T>	retryUntil(BooleanSupplier stop) Retries until the given stop function returns true.
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.
void	safeSubscribe(Observer<? super T> observer) Subscribes to the current Observable and wraps the given Observer into a SafeObserver (if not already a SafeObserver) that deals with exceptions thrown by a misbehaving Observer (that doesn't follow the Reactive Streams specification).
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.
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.
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.
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.
<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.
<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.
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.
<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.
<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) 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) 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, 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, 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.
Observable<T>	serialize() Forces an ObservableSource's emissions and notifications to be serialized and for it to obey the ObservableSource contract in other ways.
Observable<T>	share() Returns a new ObservableSource that multicasts (and shares a single subscription to) the original ObservableSource.
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.
Maybe<T>	singleElement() Returns a Maybe that completes if this Observable is empty or emits the single item emitted by this Observable, or signals an IllegalArgumentException if this Observable emits more than one item.
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.
Observable<T>	skip(long count) Returns an Observable that skips the first count items emitted by the source ObservableSource and emits the remainder.
Observable<T>	skip(long time, TimeUnit unit) Returns an Observable that skips values emitted by the source ObservableSource before a specified time window elapses.
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.
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.
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.
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.
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.
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.
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.
<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.
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.
Observable<T>	sorted() Returns an Observable that emits the events emitted by source ObservableSource, in a sorted order.
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.
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.
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.
Observable<T>	startWith(T item) Returns an Observable that emits a specified item before it begins to emit items emitted by the source ObservableSource.
Observable<T>	startWithArray(T... items) Returns an Observable that emits the specified items before it begins to emit items emitted by the source ObservableSource.
Disposable	subscribe() Subscribes to an ObservableSource and ignores onNext and onComplete emissions.
Disposable	subscribe(Consumer<? super T> onNext) Subscribes to an ObservableSource and provides a callback to handle the items it emits.
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.
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.
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.
void	subscribe(Observer<? super T> observer) Subscribes the given Observer to this ObservableSource instance.
protected abstract void	subscribeActual(Observer<? super T> observer) Operator implementations (both source and intermediate) should implement this method that performs the necessary business logic and handles the incoming Observers.
Observable<T>	subscribeOn(Scheduler scheduler) Asynchronously subscribes Observers to this ObservableSource on the specified Scheduler.
<E extends Observer<? super T>> E	subscribeWith(E observer) Subscribes a given Observer (subclass) to this Observable and returns the given Observer as is.
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.
<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.
<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.
Completable	switchMapCompletable(Function<? super T,? extends CompletableSource> mapper) Maps the upstream values into CompletableSources, subscribes to the newer one while disposing the subscription to the previous CompletableSource, thus keeping at most one active CompletableSource running.
Completable	switchMapCompletableDelayError(Function<? super T,? extends CompletableSource> mapper) Maps the upstream values into CompletableSources, subscribes to the newer one while disposing the subscription to the previous CompletableSource, thus keeping at most one active CompletableSource running and delaying any main or inner errors until all of them terminate.
<R> 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.
<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.
<R> Observable<R>	switchMapMaybe(Function<? super T,? extends MaybeSource<? extends R>> mapper) Maps the upstream items into MaybeSources and switches (subscribes) to the newer ones while disposing the older ones (and ignoring their signals) and emits the latest success value of the current one if available while failing immediately if this Observable or any of the active inner MaybeSources fail.
<R> Observable<R>	switchMapMaybeDelayError(Function<? super T,? extends MaybeSource<? extends R>> mapper) Maps the upstream items into MaybeSources and switches (subscribes) to the newer ones while disposing the older ones (and ignoring their signals) and emits the latest success value of the current one if available, delaying errors from this Observable or the inner MaybeSources until all terminate.
<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.
<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) 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, 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>	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.
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.
Observable<T>	take(long count) Returns an Observable that emits only the first count items emitted by the source ObservableSource.
Observable<T>	take(long time, TimeUnit unit) Returns an Observable that emits those items emitted by source ObservableSource before a specified time runs out.
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.
Observable<T>	takeLast(int count) Returns an Observable that emits at most the last count items emitted by the source ObservableSource.
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.
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.
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.
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.
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.
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.
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.
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.
<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.
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.
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.
TestObserver<T>	test() Creates a TestObserver and subscribes it to this Observable.
TestObserver<T>	test(boolean dispose) Creates a TestObserver, optionally disposes it and then subscribes it to this Observable.
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.
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.
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.
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.
Observable<T>	throttleLatest(long timeout, TimeUnit unit) Throttles items from the upstream Observable by first emitting the next item from upstream, then periodically emitting the latest item (if any) when the specified timeout elapses between them.
Observable<T>	throttleLatest(long timeout, TimeUnit unit, boolean emitLast) Throttles items from the upstream Observable by first emitting the next item from upstream, then periodically emitting the latest item (if any) when the specified timeout elapses between them.
Observable<T>	throttleLatest(long timeout, TimeUnit unit, Scheduler scheduler) Throttles items from the upstream Observable by first emitting the next item from upstream, then periodically emitting the latest item (if any) when the specified timeout elapses between them.
Observable<T>	throttleLatest(long timeout, TimeUnit unit, Scheduler scheduler, boolean emitLast) Throttles items from the upstream Observable by first emitting the next item from upstream, then periodically emitting the latest item (if any) when the specified timeout elapses between them.
Observable<T>	throttleWithTimeout(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.
Observable<T>	throttleWithTimeout(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.
Observable<Timed<T>>	timeInterval() Returns an Observable that emits records of the time interval between consecutive items emitted by the source ObservableSource.
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.
Observable<Timed<T>>	timeInterval(TimeUnit unit) Returns an Observable that emits records of the time interval between consecutive items emitted by the source ObservableSource.
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.
<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.
<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.
Observable<T>	timeout(long timeout, TimeUnit timeUnit) Returns an Observable that mirrors the source ObservableSource but applies a timeout policy for each emitted item.
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.
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.
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.
<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.
<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.
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.
Observable<Timed<T>>	timestamp() Returns an Observable that emits each item emitted by the source ObservableSource, wrapped in a Timed object.
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.
Observable<Timed<T>>	timestamp(TimeUnit unit) Returns an Observable that emits each item emitted by the source ObservableSource, wrapped in a Timed object.
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.
<R> R	to(Function<? super Observable<T>,R> converter) Calls the specified converter function during assembly time and returns its resulting value.
Flowable<T>	toFlowable(BackpressureStrategy strategy) Converts the current Observable into a Flowable by applying the specified backpressure strategy.
Future<T>	toFuture() Returns a Future representing the only value emitted by this Observable.
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.
<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.
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.
<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 finite source ObservableSource, mapped by the keys returned by a specified keySelector function.
<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 finite source ObservableSource, mapped by the keys returned by a specified keySelector function.
<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 finite source ObservableSource.
<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 finite source ObservableSource keyed by a specified keySelector function.
<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 finite source ObservableSource, keyed by a specified keySelector function.
<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.
<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 finite source ObservableSource and keyed by the keySelector function.
Single<List<T>>	toSortedList() Returns a Single that emits a list that contains the items emitted by the finite source ObservableSource, in a sorted order.
Single<List<T>>	toSortedList(Comparator<? super T> comparator) Returns a Single that emits a list that contains the items emitted by the finite source ObservableSource, in a sorted order based on a specified comparison function.
Single<List<T>>	toSortedList(Comparator<? super T> comparator, int capacityHint) Returns a Single that emits a list that contains the items emitted by the finite source ObservableSource, in a sorted order based on a specified comparison function.
Single<List<T>>	toSortedList(int capacityHint) Returns a Single that emits a list that contains the items emitted by the finite 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 disposal correctly; no safeguards are provided by the Observable itself.
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) Constructs an ObservableSource that creates a dependent resource object which is disposed of when the downstream calls dispose().
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.
<B> Observable<Observable<T>>	window(Callable<? extends ObservableSource<B>> boundary) Returns an Observable that emits windows of items it collects from the source ObservableSource.
<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.
Observable<Observable<T>>	window(long count) Returns an Observable that emits windows of items it collects from the source ObservableSource.
Observable<Observable<T>>	window(long count, long skip) Returns an Observable that emits windows of items it collects from the source ObservableSource.
Observable<Observable<T>>	window(long count, long skip, int bufferSize) Returns an Observable that emits windows of items it collects from the source ObservableSource.
Observable<Observable<T>>	window(long timespan, long timeskip, TimeUnit unit) Returns an Observable that emits windows of items it collects from the source ObservableSource.
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.
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.
Observable<Observable<T>>	window(long timespan, TimeUnit unit) Returns an Observable that emits windows of items it collects from the source ObservableSource.
Observable<Observable<T>>	window(long timespan, TimeUnit unit, long count) Returns an Observable that emits windows of items it collects from the source ObservableSource.
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.
Observable<Observable<T>>	window(long timespan, TimeUnit unit, Scheduler scheduler) Returns an Observable that emits windows of items it collects from the source ObservableSource.
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.
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.
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.
<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.
<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.
<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.
<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.
<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.
<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.
<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.
<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.
<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.
<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.
static <T> Observable<T>	wrap(ObservableSource<T> source) Wraps an ObservableSource into an Observable if not already an Observable.
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 <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) Returns an Observable that emits the results of a specified combiner function applied to combinations of two items emitted, in sequence, by two other ObservableSources.
static <T1,T2,R> 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 <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,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,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,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,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 <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.
<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.
<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.
<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.
<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.

Methods inherited from class java.lang.Object

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

Constructor Detail

Observable

public Observable()

Method Detail

amb

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

Type Parameters:

T - the common element type

Parameters:

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

Returns:

an Observable that emits the same sequence as whichever of the source ObservableSources first emitted an item or sent a termination notification

See Also:

ReactiveX operators documentation: Amb

ambArray

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

Scheduler:

ambArray does not operate by default on a particular Scheduler.

Type Parameters:

T - the common element type

Parameters:

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

Returns:

an Observable that emits the same sequence as whichever of the source ObservableSources first emitted an item or sent a termination notification

See Also:

ReactiveX operators documentation: Amb

bufferSize

public static int bufferSize()

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

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

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

Returns:

the default 'island' size or capacity-increment hint

combineLatest

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

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.

Type Parameters:

T - the common base type of source values

R - the result type

Parameters:

sources - the collection of source ObservableSources

combiner - the aggregation function used to combine the items emitted by the 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:

ReactiveX operators documentation: CombineLatest

combineLatest

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

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

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

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

Scheduler:

combineLatest does not operate by default on a particular Scheduler.

Type Parameters:

T - the common base type of source values

R - the result type

Parameters:

sources - the collection of source ObservableSources

combiner - the aggregation function used to combine the items emitted by the 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:

ReactiveX operators documentation: CombineLatest

combineLatest

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

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

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

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

Scheduler:

combineLatest does not operate by default on a particular Scheduler.

Type Parameters:

T - the common base type of source values

R - the result type

Parameters:

sources - the collection of source ObservableSources

combiner - the aggregation function used to combine the items emitted by the 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:

ReactiveX operators documentation: CombineLatest

combineLatest

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

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.

Type Parameters:

T - the common base type of source values

R - the result type

Parameters:

sources - the collection of source ObservableSources

combiner - the aggregation function used to combine the items emitted by the 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:

ReactiveX operators documentation: CombineLatest

combineLatest

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

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.

Type Parameters:

T - the common base type of source values

R - the result type

Parameters:

sources - the collection of source ObservableSources

combiner - the aggregation function used to combine the items emitted by the 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:

ReactiveX operators documentation: CombineLatest

combineLatest

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

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

Scheduler:

combineLatest does not operate by default on a particular Scheduler.

Type Parameters:

T1 - the element type of the first source

T2 - the element type of the second source

R - the combined output type

Parameters:

source1 - the first source ObservableSource

source2 - the second source ObservableSource

combiner - the aggregation function used to combine the items emitted by the 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:

ReactiveX operators documentation: CombineLatest

combineLatest

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

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

Scheduler:

combineLatest does not operate by default on a particular Scheduler.

Type Parameters:

T1 - the element type of the first source

T2 - the element type of the second source

T3 - the element type of the third source

R - the combined output type

Parameters:

source1 - the first source ObservableSource

source2 - the second source ObservableSource

source3 - the third source ObservableSource

combiner - the aggregation function used to combine the items emitted by the 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:

ReactiveX operators documentation: CombineLatest

combineLatest

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

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

Scheduler:

combineLatest does not operate by default on a particular Scheduler.

Type Parameters:

T1 - the element type of the first source

T2 - the element type of the second source

T3 - the element type of the third source

T4 - the element type of the fourth source

R - the combined output type

Parameters:

source1 - the first source ObservableSource

source2 - the second source ObservableSource

source3 - the third source ObservableSource

source4 - the fourth source ObservableSource

combiner - the aggregation function used to combine the items emitted by the 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:

ReactiveX operators documentation: CombineLatest

combineLatest

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

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

Scheduler:

combineLatest does not operate by default on a particular Scheduler.

Type Parameters:

T1 - the element type of the first source

T2 - the element type of the second source

T3 - the element type of the third source

T4 - the element type of the fourth source

T5 - the element type of the fifth source

R - the combined output type

Parameters:

source1 - the first source ObservableSource

source2 - the second source ObservableSource

source3 - the third source ObservableSource

source4 - the fourth source ObservableSource

source5 - the fifth source ObservableSource

combiner - the aggregation function used to combine the items emitted by the 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:

ReactiveX operators documentation: CombineLatest

combineLatest

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

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

Scheduler:

combineLatest does not operate by default on a particular Scheduler.

Type Parameters:

T1 - the element type of the first source

T2 - the element type of the second source

T3 - the element type of the third source

T4 - the element type of the fourth source

T5 - the element type of the fifth source

T6 - the element type of the sixth source

R - the combined output type

Parameters:

source1 - the first source ObservableSource

source2 - the second source ObservableSource

source3 - the third source ObservableSource

source4 - the fourth source ObservableSource

source5 - the fifth source ObservableSource

source6 - the sixth source ObservableSource

combiner - the aggregation function used to combine the items emitted by the 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:

ReactiveX operators documentation: CombineLatest

combineLatest

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

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

Scheduler:

combineLatest does not operate by default on a particular Scheduler.

Type Parameters:

T1 - the element type of the first source

T2 - the element type of the second source

T3 - the element type of the third source

T4 - the element type of the fourth source

T5 - the element type of the fifth source

T6 - the element type of the sixth source

T7 - the element type of the seventh source

R - the combined output type

Parameters:

source1 - the first source ObservableSource

source2 - the second source ObservableSource

source3 - the third source ObservableSource

source4 - the fourth source ObservableSource

source5 - the fifth source ObservableSource

source6 - the sixth source ObservableSource

source7 - the seventh source ObservableSource

combiner - the aggregation function used to combine the items emitted by the 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:

ReactiveX operators documentation: CombineLatest

combineLatest

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

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

Scheduler:

combineLatest does not operate by default on a particular Scheduler.

Type Parameters:

T1 - the element type of the first source

T2 - the element type of the second source

T3 - the element type of the third source

T4 - the element type of the fourth source

T5 - the element type of the fifth source

T6 - the element type of the sixth source

T7 - the element type of the seventh source

T8 - the element type of the eighth source

R - the combined output type

Parameters:

source1 - the first source ObservableSource

source2 - the second source ObservableSource

source3 - the third source ObservableSource

source4 - the fourth source ObservableSource

source5 - the fifth source ObservableSource

source6 - the sixth source ObservableSource

source7 - the seventh source ObservableSource

source8 - the eighth source ObservableSource

combiner - the aggregation function used to combine the items emitted by the 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:

ReactiveX operators documentation: CombineLatest

combineLatest

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

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

Scheduler:

combineLatest does not operate by default on a particular Scheduler.

Type Parameters:

T1 - the element type of the first source

T2 - the element type of the second source

T3 - the element type of the third source

T4 - the element type of the fourth source

T5 - the element type of the fifth source

T6 - the element type of the sixth source

T7 - the element type of the seventh source

T8 - the element type of the eighth source

T9 - the element type of the ninth source

R - the combined output type

Parameters:

source1 - the first source ObservableSource

source2 - the second source ObservableSource

source3 - the third source ObservableSource

source4 - the fourth source ObservableSource

source5 - the fifth source ObservableSource

source6 - the sixth source ObservableSource

source7 - the seventh source ObservableSource

source8 - the eighth source ObservableSource

source9 - the ninth source ObservableSource

combiner - the aggregation function used to combine the items emitted by the 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:

ReactiveX operators documentation: CombineLatest

combineLatestDelayError

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

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.

Type Parameters:

T - the common base type of source values

R - the result type

Parameters:

sources - the collection of source ObservableSources

combiner - the aggregation function used to combine the items emitted by the 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:

ReactiveX operators documentation: CombineLatest

combineLatestDelayError

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

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.

Type Parameters:

T - the common base type of source values

R - the result type

Parameters:

sources - the collection of source ObservableSources

combiner - the aggregation function used to combine the items emitted by the 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:

ReactiveX operators documentation: CombineLatest

combineLatestDelayError

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

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.

Type Parameters:

T - the common base type of source values

R - the result type

Parameters:

sources - the collection of source ObservableSources

combiner - the aggregation function used to combine the items emitted by the 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:

ReactiveX operators documentation: CombineLatest

combineLatestDelayError

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

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

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

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

Scheduler:

combineLatestDelayError does not operate by default on a particular Scheduler.

Type Parameters:

T - the common base type of source values

R - the result type

Parameters:

sources - the collection of source ObservableSources

combiner - the aggregation function used to combine the items emitted by the 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:

ReactiveX operators documentation: CombineLatest

combineLatestDelayError

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

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

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

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

Scheduler:

combineLatestDelayError does not operate by default on a particular Scheduler.

Type Parameters:

T - the common base type of source values

R - the result type

Parameters:

sources - the collection of source ObservableSources

combiner - the aggregation function used to combine the items emitted by the 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:

ReactiveX operators documentation: CombineLatest

concat

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

Scheduler:

concat does not operate by default on a particular Scheduler.

Type Parameters:

T - the common value type of the sources

Parameters:

sources - the Iterable sequence of ObservableSources

Returns:

the new Observable instance

concat

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

Scheduler:

concat does not operate by default on a particular Scheduler.

Type Parameters:

T - the common element base type

Parameters:

sources - an ObservableSource that emits ObservableSources

Returns:

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:

ReactiveX operators documentation: Concat

concat

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

Scheduler:

concat does not operate by default on a particular Scheduler.

Type Parameters:

T - the common element base type

Parameters:

sources - an ObservableSource that emits ObservableSources

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:

ReactiveX operators documentation: Concat

concat

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

Scheduler:

concat does not operate by default on a particular Scheduler.

Type Parameters:

T - the common element base type

Parameters:

source1 - an ObservableSource to be concatenated

source2 - an ObservableSource to be concatenated

Returns:

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

See Also:

ReactiveX operators documentation: Concat

concat

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

Scheduler:

concat does not operate by default on a particular Scheduler.

Type Parameters:

T - the common element base type

Parameters:

source1 - an ObservableSource to be concatenated

source2 - an ObservableSource to be concatenated

source3 - an ObservableSource to be concatenated

Returns:

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

See Also:

ReactiveX operators documentation: Concat

concat

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

Scheduler:

concat does not operate by default on a particular Scheduler.

Type Parameters:

T - the common element base type

Parameters:

source1 - an ObservableSource to be concatenated

source2 - an ObservableSource to be concatenated

source3 - an ObservableSource to be concatenated

source4 - an ObservableSource to be concatenated

Returns:

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

See Also:

ReactiveX operators documentation: Concat

concatArray

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

Type Parameters:

T - the common base value type

Parameters:

sources - the array of sources

Returns:

the new Observable instance

Throws:

NullPointerException - if sources is null

concatArrayDelayError

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

Scheduler:

concatArrayDelayError does not operate by default on a particular Scheduler.

Type Parameters:

T - the common base value type

Parameters:

sources - the array of sources

Returns:

the new Observable instance

Throws:

NullPointerException - if sources is null

concatArrayEager

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

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

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

Type Parameters:

T - the value type

Parameters:

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

Returns:

the new ObservableSource instance with the specified concatenation behavior

Since:

2.0

concatArrayEager

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

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

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

Type Parameters:

T - the value type

Parameters:

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

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

prefetch - the number of elements to prefetch from each ObservableSource source

Returns:

the new ObservableSource instance with the specified concatenation behavior

Since:

2.0

concatArrayEagerDelayError

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

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

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.

Type Parameters:

T - the value type

Parameters:

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

Returns:

the new Observable instance with the specified concatenation behavior

Since:

2.2.1 - experimental

concatArrayEagerDelayError

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

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

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

Type Parameters:

T - the value type

Parameters:

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

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

prefetch - the number of elements to prefetch from each ObservableSource source

Returns:

the new Observable instance with the specified concatenation behavior

Since:

2.2.1 - experimental

concatDelayError

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

Scheduler:

concatDelayError does not operate by default on a particular Scheduler.

Type Parameters:

T - the common element base type

Parameters:

sources - the Iterable sequence of ObservableSources

Returns:

the new ObservableSource with the concatenating behavior

concatDelayError

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

Scheduler:

concatDelayError does not operate by default on a particular Scheduler.

Type Parameters:

T - the common element base type

Parameters:

sources - the ObservableSource sequence of ObservableSources

Returns:

the new ObservableSource with the concatenating behavior

concatDelayError

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

Scheduler:

concatDelayError does not operate by default on a particular Scheduler.

Type Parameters:

T - the common element base type

Parameters:

sources - the ObservableSource sequence of ObservableSources

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

concatEager

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

Type Parameters:

T - the value type

Parameters:

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

Returns:

the new ObservableSource instance with the specified concatenation behavior

Since:

2.0

concatEager

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

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

Scheduler:

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

Type Parameters:

T - the value type

Parameters:

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

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

prefetch - the number of elements to prefetch from each inner ObservableSource source

Returns:

the new ObservableSource instance with the specified concatenation behavior

Since:

2.0

concatEager

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

Type Parameters:

T - the value type

Parameters:

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

Returns:

the new ObservableSource instance with the specified concatenation behavior

Since:

2.0

concatEager

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

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.

Type Parameters:

T - the value type

Parameters:

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

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

prefetch - the number of elements to prefetch from each inner ObservableSource source

Returns:

the new ObservableSource instance with the specified concatenation behavior

Since:

2.0

create

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

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.

Type Parameters:

T - the element type

Parameters:

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

Returns:

the new Observable instance

See Also:

ObservableOnSubscribe, ObservableEmitter, Cancellable

defer

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

Type Parameters:

T - the type of the items emitted by the ObservableSource

Parameters:

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

Returns:

an Observable whose Observers' subscriptions trigger an invocation of the given ObservableSource factory function

See Also:

ReactiveX operators documentation: Defer

empty

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

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

Scheduler:

empty does not operate by default on a particular Scheduler.

Type Parameters:

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

Returns:

an Observable that emits no items to the Observer but immediately invokes the Observer's onComplete method

See Also:

ReactiveX operators documentation: Empty

error

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

Scheduler:

error does not operate by default on a particular Scheduler.

Type Parameters:

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

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:

ReactiveX operators documentation: Throw

error

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

Type Parameters:

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

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:

ReactiveX operators documentation: Throw

fromArray

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

Type Parameters:

T - the type of items in the Array and the type of items to be emitted by the resulting ObservableSource

Parameters:

items - the array of elements

Returns:

an Observable that emits each item in the source Array

See Also:

ReactiveX operators documentation: From

fromCallable

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

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.

Error handling:

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

Type Parameters:

T - the type of the item emitted by the ObservableSource

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

Since:

2.0

See Also:

defer(Callable)

fromFuture

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public static <T> 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 Future.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, disposing the Observable won't cancel the future. If necessary, one can use composition to achieve the cancellation effect: futureObservableSource.doOnDispose(() -> future.cancel(true));.

Scheduler:

fromFuture does not operate by default on a particular Scheduler.

Type Parameters:

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

Parameters:

future - the source Future

Returns:

an Observable that emits the item from the source Future

See Also:

ReactiveX operators documentation: From

fromFuture

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

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

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

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

Scheduler:

fromFuture does not operate by default on a particular Scheduler.

Type Parameters:

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

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:

ReactiveX operators documentation: From

fromFuture

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

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

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

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

Scheduler:

fromFuture does not operate by default on a particular Scheduler.

Type Parameters:

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

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 Schedulers.io() that can block and wait on the Future

Returns:

an Observable that emits the item from the source Future

See Also:

ReactiveX operators documentation: From

fromFuture

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="custom")
public static <T> 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 Future.get() method of that object, by passing the object into the from method.

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

Scheduler:

You specify which Scheduler this operator will use.

Type Parameters:

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

Parameters:

future - the source Future

scheduler - the Scheduler to wait for the Future on. Use a Scheduler such as Schedulers.io() that can block and wait on the Future

Returns:

an Observable that emits the item from the source Future

See Also:

ReactiveX operators documentation: From

fromIterable

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

Type Parameters:

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

Parameters:

source - the source Iterable sequence

Returns:

an Observable that emits each item in the source Iterable sequence

See Also:

ReactiveX operators documentation: From

fromPublisher

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

Converts an arbitrary Reactive Streams Publisher into an Observable.

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

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

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

Backpressure:

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

Scheduler:

fromPublisher does not operate by default on a particular Scheduler.

Type Parameters:

T - the value type of the flow

Parameters:

publisher - the Publisher to convert

Returns:

the new Observable instance

Throws:

NullPointerException - if publisher is null

See Also:

create(ObservableOnSubscribe)

generate

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

Returns a cold, synchronous and stateless generator of values.

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

Scheduler:

generate does not operate by default on a particular Scheduler.

Type Parameters:

T - the generated value type

Parameters:

generator - the Consumer called 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

generate

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

Returns a cold, synchronous and stateful generator of values.

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

Scheduler:

generate does not operate by default on a particular Scheduler.

Type Parameters:

S - the type of the per-Observer state

T - the generated value type

Parameters:

initialState - the 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

generate

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

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

Scheduler:

generate does not operate by default on a particular Scheduler.

Type Parameters:

S - the type of the per-Observer state

T - the generated value type

Parameters:

initialState - the 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 disposed

Returns:

the new Observable instance

generate

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

Returns a cold, synchronous and stateful generator of values.

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

Scheduler:

generate does not operate by default on a particular Scheduler.

Type Parameters:

S - the type of the per-Observer state

T - the generated value type

Parameters:

initialState - the 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

generate

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

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

Scheduler:

generate does not operate by default on a particular Scheduler.

Type Parameters:

S - the type of the per-Observer state

T - the generated value type

Parameters:

initialState - the 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 disposed

Returns:

the new Observable instance

interval

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

Since:

1.0.12

See Also:

ReactiveX operators documentation: Interval

interval

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

Since:

1.0.12

See Also:

ReactiveX operators documentation: Interval

interval

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

ReactiveX operators documentation: Interval

interval

@CheckReturnValue
 @SchedulerSupport(value="custom")
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:

ReactiveX operators documentation: Interval

intervalRange

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

intervalRange

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

just

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

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

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

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

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

Scheduler:

just does not operate by default on a particular Scheduler.

Type Parameters:

T - the type of that item

Parameters:

item - the item to emit

Returns:

an Observable that emits value as a single item and then completes

See Also:

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

just

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

Type Parameters:

T - the type of these items

Parameters:

item1 - first item

item2 - second item

Returns:

an Observable that emits each item

See Also:

ReactiveX operators documentation: Just

just

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

Type Parameters:

T - the type of these items

Parameters:

item1 - first item

item2 - second item

item3 - third item

Returns:

an Observable that emits each item

See Also:

ReactiveX operators documentation: Just

just

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

Type Parameters:

T - the type of these items

Parameters:

item1 - first item

item2 - second item

item3 - third item

item4 - fourth item

Returns:

an Observable that emits each item

See Also:

ReactiveX operators documentation: Just

just

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

Scheduler:

just does not operate by default on a particular Scheduler.

Type Parameters:

T - the type of these items

Parameters:

item1 - first item

item2 - second item

item3 - third item

item4 - fourth item

item5 - fifth item

Returns:

an Observable that emits each item

See Also:

ReactiveX operators documentation: Just

just

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

Scheduler:

just does not operate by default on a particular Scheduler.

Type Parameters:

T - the type of these items

Parameters:

item1 - first item

item2 - second item

item3 - third item

item4 - fourth item

item5 - fifth item

item6 - sixth item

Returns:

an Observable that emits each item

See Also:

ReactiveX operators documentation: Just

just

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

Scheduler:

just does not operate by default on a particular Scheduler.

Type Parameters:

T - the type of these items

Parameters:

item1 - first item

item2 - second item

item3 - third item

item4 - fourth item

item5 - fifth item

item6 - sixth item

item7 - seventh item

Returns:

an Observable that emits each item

See Also:

ReactiveX operators documentation: Just

just

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

Scheduler:

just does not operate by default on a particular Scheduler.

Type Parameters:

T - the type of these items

Parameters:

item1 - first item

item2 - second item

item3 - third item

item4 - fourth item

item5 - fifth item

item6 - sixth item

item7 - seventh item

item8 - eighth item

Returns:

an Observable that emits each item

See Also:

ReactiveX operators documentation: Just

just

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

Scheduler:

just does not operate by default on a particular Scheduler.

Type Parameters:

T - the type of these items

Parameters:

item1 - first item

item2 - second item

item3 - third item

item4 - fourth item

item5 - fifth item

item6 - sixth item

item7 - seventh item

item8 - eighth item

item9 - ninth item

Returns:

an Observable that emits each item

See Also:

ReactiveX operators documentation: Just

just

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

Scheduler:

just does not operate by default on a particular Scheduler.

Type Parameters:

T - the type of these items

Parameters:

item1 - first item

item2 - second item

item3 - third item

item4 - fourth item

item5 - fifth item

item6 - sixth item

item7 - seventh item

item8 - eighth item

item9 - ninth item

item10 - tenth item

Returns:

an Observable that emits each item

See Also:

ReactiveX operators documentation: Just

merge

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

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

Scheduler:

merge does not operate by default on a particular Scheduler.

Error handling:

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

Type Parameters:

T - the common element base type

Parameters:

sources - the Iterable of ObservableSources

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

bufferSize - the number of items 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:

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

mergeArray

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

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

Scheduler:

mergeArray does not operate by default on a particular Scheduler.

Error handling:

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

Type Parameters:

T - the common element base type

Parameters:

sources - the array of ObservableSources

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

bufferSize - the number of items 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:

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

merge

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

Error handling:

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

Type Parameters:

T - the common element base type

Parameters:

sources - the Iterable of ObservableSources

Returns:

an Observable that emits items that are the result of flattening the items emitted by the ObservableSources in the Iterable

See Also:

ReactiveX operators documentation: Merge, mergeDelayError(Iterable)

merge

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

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

Scheduler:

merge does not operate by default on a particular Scheduler.

Error handling:

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

Type Parameters:

T - the common element base type

Parameters:

sources - the Iterable of ObservableSources

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

Returns:

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:

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

merge

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

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

Scheduler:

merge does not operate by default on a particular Scheduler.

Error handling:

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

Type Parameters:

T - the common element base type

Parameters:

sources - an ObservableSource that emits ObservableSources

Returns:

an Observable that emits items that are the result of flattening the ObservableSources emitted by the source ObservableSource

See Also:

ReactiveX operators documentation: Merge, mergeDelayError(ObservableSource)

merge

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

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

Scheduler:

merge does not operate by default on a particular Scheduler.

Error handling:

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

Type Parameters:

T - the common element base type

Parameters:

sources - an ObservableSource that emits ObservableSources

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

Returns:

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

Since:

1.1.0

See Also:

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

merge

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

Error handling:

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

Type Parameters:

T - the common element base type

Parameters:

source1 - an ObservableSource to be merged

source2 - an ObservableSource to be merged

Returns:

an Observable that emits all of the items emitted by the source ObservableSources

See Also:

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

merge

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

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

Scheduler:

merge does not operate by default on a particular Scheduler.

Error handling:

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

Type Parameters:

T - the common element base type

Parameters:

source1 - an ObservableSource to be merged

source2 - an ObservableSource to be merged

source3 - an ObservableSource to be merged

Returns:

an Observable that emits all of the items emitted by the source ObservableSources

See Also:

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

merge

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

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

Scheduler:

merge does not operate by default on a particular Scheduler.

Error handling:

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

Type Parameters:

T - the common element base type

Parameters:

source1 - an ObservableSource to be merged

source2 - an ObservableSource to be merged

source3 - an ObservableSource to be merged

source4 - an ObservableSource to be merged

Returns:

an Observable that emits all of the items emitted by the source ObservableSources

See Also:

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

mergeArray

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

Error handling:

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

Type Parameters:

T - the common element base type

Parameters:

sources - the array of ObservableSources

Returns:

an Observable that emits all of the items emitted by the ObservableSources in the Array

See Also:

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

mergeDelayError

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

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

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

Scheduler:

mergeDelayError does not operate by default on a particular Scheduler.

Type Parameters:

T - the common element base type

Parameters:

sources - the Iterable of ObservableSources

Returns:

an Observable that emits items that are the result of flattening the items emitted by the ObservableSources in the Iterable

See Also:

ReactiveX operators documentation: Merge

mergeDelayError

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

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

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

Scheduler:

mergeDelayError does not operate by default on a particular Scheduler.

Type Parameters:

T - the common element base type

Parameters:

sources - the Iterable of ObservableSources

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

bufferSize - the number of items 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:

ReactiveX operators documentation: Merge

mergeArrayDelayError

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

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

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

Scheduler:

mergeArrayDelayError does not operate by default on a particular Scheduler.

Type Parameters:

T - the common element base type

Parameters:

sources - the array of ObservableSources

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

bufferSize - the number of items 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:

ReactiveX operators documentation: Merge

mergeDelayError

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

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

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

Scheduler:

mergeDelayError does not operate by default on a particular Scheduler.

Type Parameters:

T - the common element base type

Parameters:

sources - the Iterable of ObservableSources

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

Returns:

an Observable that emits items that are the result of flattening the items emitted by the ObservableSources in the Iterable

See Also:

ReactiveX operators documentation: Merge

mergeDelayError

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

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

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

Scheduler:

mergeDelayError does not operate by default on a particular Scheduler.

Type Parameters:

T - the common element base type

Parameters:

sources - an ObservableSource that emits ObservableSources

Returns:

an Observable that emits all of the items emitted by the ObservableSources emitted by the source ObservableSource

See Also:

ReactiveX operators documentation: Merge

mergeDelayError

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

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

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

Scheduler:

mergeDelayError does not operate by default on a particular Scheduler.

Type Parameters:

T - the common element base type

Parameters:

sources - an ObservableSource that emits ObservableSources

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

Returns:

an Observable that emits all of the items emitted by the ObservableSources emitted by the source ObservableSource

Since:

2.0

See Also:

ReactiveX operators documentation: Merge

mergeDelayError

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

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

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

Scheduler:

mergeDelayError does not operate by default on a particular Scheduler.

Type Parameters:

T - the common element base type

Parameters:

source1 - an ObservableSource to be merged

source2 - an ObservableSource to be merged

Returns:

an Observable that emits all of the items that are emitted by the two source ObservableSources

See Also:

ReactiveX operators documentation: Merge

mergeDelayError

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

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

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

Scheduler:

mergeDelayError does not operate by default on a particular Scheduler.

Type Parameters:

T - the common element base type

Parameters:

source1 - an ObservableSource to be merged

source2 - an ObservableSource to be merged

source3 - an ObservableSource to be merged

Returns:

an Observable that emits all of the items that are emitted by the source ObservableSources

See Also:

ReactiveX operators documentation: Merge

mergeDelayError

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

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

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

Scheduler:

mergeDelayError does not operate by default on a particular Scheduler.

Type Parameters:

T - the common element base type

Parameters:

source1 - an ObservableSource to be merged

source2 - an ObservableSource to be merged

source3 - an ObservableSource to be merged

source4 - an ObservableSource to be merged

Returns:

an Observable that emits all of the items that are emitted by the source ObservableSources

See Also:

ReactiveX operators documentation: Merge

mergeArrayDelayError

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

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

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

Scheduler:

mergeArrayDelayError does not operate by default on a particular Scheduler.

Type Parameters:

T - the common element base type

Parameters:

sources - the 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:

ReactiveX operators documentation: Merge

never

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

Type Parameters:

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

Returns:

an Observable that never emits any items or sends any notifications to an Observer

See Also:

ReactiveX operators documentation: Never

range

@CheckReturnValue
 @SchedulerSupport(value="none")
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:

ReactiveX operators documentation: Range

rangeLong

@CheckReturnValue
 @SchedulerSupport(value="none")
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:

ReactiveX operators documentation: Range

sequenceEqual

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

Scheduler:

sequenceEqual does not operate by default on a particular Scheduler.

Type Parameters:

T - the type of items emitted by each ObservableSource

Parameters:

source1 - the first ObservableSource to compare

source2 - the second ObservableSource to compare

Returns:

a Single that emits a Boolean value that indicates whether the two sequences are the same

See Also:

ReactiveX operators documentation: SequenceEqual

sequenceEqual

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

Scheduler:

sequenceEqual does not operate by default on a particular Scheduler.

Type Parameters:

T - the type of items emitted by each ObservableSource

Parameters:

source1 - the first ObservableSource to compare

source2 - the second ObservableSource to compare

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

Returns:

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:

ReactiveX operators documentation: SequenceEqual

sequenceEqual

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

Scheduler:

sequenceEqual does not operate by default on a particular Scheduler.

Type Parameters:

T - the type of items emitted by each ObservableSource

Parameters:

source1 - the first ObservableSource to compare

source2 - the second ObservableSource to compare

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

bufferSize - the number of items 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:

ReactiveX operators documentation: SequenceEqual

sequenceEqual

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

Scheduler:

sequenceEqual does not operate by default on a particular Scheduler.

Type Parameters:

T - the type of items emitted by each ObservableSource

Parameters:

source1 - the first ObservableSource to compare

source2 - the second ObservableSource to compare

bufferSize - the number of items 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:

ReactiveX operators documentation: SequenceEqual

switchOnNext

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

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.

Type Parameters:

T - the item type

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:

ReactiveX operators documentation: Switch

switchOnNext

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

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.

Type Parameters:

T - the item type

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:

ReactiveX operators documentation: Switch

switchOnNextDelayError

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

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.

Type Parameters:

T - the item type

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

Since:

2.0

See Also:

ReactiveX operators documentation: Switch

switchOnNextDelayError

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

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.

Type Parameters:

T - the item type

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

Since:

2.0

See Also:

ReactiveX operators documentation: Switch

timer

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

ReactiveX operators documentation: Timer

timer

@CheckReturnValue
 @SchedulerSupport(value="custom")
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:

ReactiveX operators documentation: Timer

unsafeCreate

@CheckReturnValue
 @SchedulerSupport(value="none")
public 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 disposal correctly; no safeguards are provided by the Observable itself.

Scheduler:

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

Type Parameters:

T - the value type emitted

Parameters:

onSubscribe - the ObservableSource instance to wrap

Returns:

the new Observable instance

using

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

Scheduler:

using does not operate by default on a particular Scheduler.

Type Parameters:

T - the element type of the generated ObservableSource

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

Parameters:

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

sourceSupplier - the factory function to create an ObservableSource

disposer - the function that will dispose of the resource

Returns:

the ObservableSource whose lifetime controls the lifetime of the dependent resource object

See Also:

ReactiveX operators documentation: Using

using

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

Type Parameters:

T - the element type of the generated ObservableSource

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

Parameters:

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

sourceSupplier - the factory function to create an ObservableSource

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

Since:

2.0

See Also:

ReactiveX operators documentation: Using

wrap

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

Type Parameters:

T - the value type

Parameters:

source - the source ObservableSource instance

Returns:

the new Observable instance or the same as the source

Throws:

NullPointerException - if source is null

zip

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

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.

Type Parameters:

T - the common value type

R - the zipped result type

Parameters:

sources - an Iterable of source ObservableSources

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

Returns:

an Observable that emits the zipped results

See Also:

ReactiveX operators documentation: Zip

zip

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

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.

Type Parameters:

T - the value type of the inner ObservableSources

R - the zipped result type

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:

ReactiveX operators documentation: Zip

zip

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

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.

Type Parameters:

T1 - the value type of the first source

T2 - the value type of the second source

R - the zipped result type

Parameters:

source1 - the first source ObservableSource

source2 - a second source ObservableSource

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

Returns:

an Observable that emits the zipped results

See Also:

ReactiveX operators documentation: Zip

zip

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

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.

Type Parameters:

T1 - the value type of the first source

T2 - the value type of the second source

R - the zipped result type

Parameters:

source1 - the first source ObservableSource

source2 - a second source ObservableSource

zipper - a function that, when applied to an item emitted by each of the 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:

ReactiveX operators documentation: Zip

zip

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

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.

Type Parameters:

T1 - the value type of the first source

T2 - the value type of the second source

R - the zipped result type

Parameters:

source1 - the first source ObservableSource

source2 - a second source ObservableSource

zipper - a function that, when applied to an item emitted by each of the 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:

ReactiveX operators documentation: Zip

zip

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

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.

Type Parameters:

T1 - the value type of the first source

T2 - the value type of the second source

T3 - the value type of the third source

R - the zipped result type

Parameters:

source1 - the first source ObservableSource

source2 - a second source ObservableSource

source3 - a third source ObservableSource

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

Returns:

an Observable that emits the zipped results

See Also:

ReactiveX operators documentation: Zip

zip

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

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.

Type Parameters:

T1 - the value type of the first source

T2 - the value type of the second source

T3 - the value type of the third source

T4 - the value type of the fourth source

R - the zipped result type

Parameters:

source1 - the first source ObservableSource

source2 - a second source ObservableSource

source3 - a third source ObservableSource

source4 - a fourth source ObservableSource

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

Returns:

an Observable that emits the zipped results

See Also:

ReactiveX operators documentation: Zip

zip

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

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.

Type Parameters:

T1 - the value type of the first source

T2 - the value type of the second source

T3 - the value type of the third source

T4 - the value type of the fourth source

T5 - the value type of the fifth source

R - the zipped result type

Parameters:

source1 - the first source ObservableSource

source2 - a second source ObservableSource

source3 - a third source ObservableSource

source4 - a fourth source ObservableSource

source5 - a fifth source ObservableSource

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

Returns:

an Observable that emits the zipped results

See Also:

ReactiveX operators documentation: Zip

zip

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

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.

Type Parameters:

T1 - the value type of the first source

T2 - the value type of the second source

T3 - the value type of the third source

T4 - the value type of the fourth source

T5 - the value type of the fifth source

T6 - the value type of the sixth source

R - the zipped result type

Parameters:

source1 - the first source ObservableSource

source2 - a second source ObservableSource

source3 - a third source ObservableSource

source4 - a fourth source ObservableSource

source5 - a fifth source ObservableSource

source6 - a sixth source ObservableSource

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

Returns:

an Observable that emits the zipped results

See Also:

ReactiveX operators documentation: Zip

zip

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

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.

Type Parameters:

T1 - the value type of the first source

T2 - the value type of the second source

T3 - the value type of the third source

T4 - the value type of the fourth source

T5 - the value type of the fifth source

T6 - the value type of the sixth source

T7 - the value type of the seventh source

R - the zipped result type

Parameters:

source1 - the first source ObservableSource

source2 - a second source ObservableSource

source3 - a third source ObservableSource

source4 - a fourth source ObservableSource

source5 - a fifth source ObservableSource

source6 - a sixth source ObservableSource

source7 - a seventh source ObservableSource

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

Returns:

an Observable that emits the zipped results

See Also:

ReactiveX operators documentation: Zip

zip

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

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.

Type Parameters:

T1 - the value type of the first source

T2 - the value type of the second source

T3 - the value type of the third source

T4 - the value type of the fourth source

T5 - the value type of the fifth source

T6 - the value type of the sixth source

T7 - the value type of the seventh source

T8 - the value type of the eighth source

R - the zipped result type

Parameters:

source1 - the first source ObservableSource

source2 - a second source ObservableSource

source3 - a third source ObservableSource

source4 - a fourth source ObservableSource

source5 - a fifth source ObservableSource

source6 - a sixth source ObservableSource

source7 - a seventh source ObservableSource

source8 - an eighth source ObservableSource

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

Returns:

an Observable that emits the zipped results

See Also:

ReactiveX operators documentation: Zip

zip

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

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.

Type Parameters:

T1 - the value type of the first source

T2 - the value type of the second source

T3 - the value type of the third source

T4 - the value type of the fourth source

T5 - the value type of the fifth source

T6 - the value type of the sixth source

T7 - the value type of the seventh source

T8 - the value type of the eighth source

T9 - the value type of the ninth source

R - the zipped result type

Parameters:

source1 - the first source ObservableSource

source2 - a second source ObservableSource

source3 - a third source ObservableSource

source4 - a fourth source ObservableSource

source5 - a fifth source ObservableSource

source6 - a sixth source ObservableSource

source7 - a seventh source ObservableSource

source8 - an eighth source ObservableSource

source9 - a ninth source ObservableSource

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

Returns:

an Observable that emits the zipped results

See Also:

ReactiveX operators documentation: Zip

zipArray

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

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.

Type Parameters:

T - the common element type

R - the result type

Parameters:

sources - an array of source ObservableSources

zipper - a function that, when applied to an item emitted by each of the 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:

ReactiveX operators documentation: Zip

zipIterable

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

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.

Type Parameters:

T - the common source value type

R - the zipped result type

Parameters:

sources - an Iterable of source ObservableSources

zipper - a function that, when applied to an item emitted by each of the 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:

ReactiveX operators documentation: Zip

all

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

Returns a Single 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:

ReactiveX operators documentation: All

ambWith

@CheckReturnValue
 @SchedulerSupport(value="none")
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:

ReactiveX operators documentation: Amb

any

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

Returns a Single 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:

ReactiveX operators documentation: Contains

as

@CheckReturnValue
 @SchedulerSupport(value="none")
public final <R> R as(@NonNull ObservableConverter<T,? extends R> converter)

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

This allows fluent conversion to any other type.

Scheduler:

as does not operate by default on a particular Scheduler.

History: 2.1.7 - experimental

Type Parameters:

R - the resulting object type

Parameters:

converter - the function that receives the current Observable instance and returns a value

Returns:

the converted value

Throws:

NullPointerException - if converter is null

Since:

2.2

blockingFirst

@CheckReturnValue
 @SchedulerSupport(value="none")
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:

ReactiveX documentation: First

blockingFirst

@CheckReturnValue
 @SchedulerSupport(value="none")
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:

ReactiveX documentation: First

blockingForEach

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

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

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

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

Scheduler:

blockingForEach does not operate by default on a particular Scheduler.

Error handling:

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

Parameters:

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

Throws:

RuntimeException - if an error occurs

See Also:

ReactiveX documentation: Subscribe, subscribe(Consumer)

blockingIterable

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

Converts this Observable into an Iterable.

Scheduler:

blockingIterable does not operate by default on a particular Scheduler.

Returns:

an Iterable version of this Observable

See Also:

ReactiveX documentation: To

blockingIterable

@CheckReturnValue
 @SchedulerSupport(value="none")
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:

an Iterable version of this Observable

See Also:

ReactiveX documentation: To

blockingLast

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

Error handling:

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

Returns:

the last item emitted by this Observable

Throws:

NoSuchElementException - if this Observable emits no items

See Also:

ReactiveX documentation: Last

blockingLast

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

Error handling:

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

Parameters:

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

Returns:

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

See Also:

ReactiveX documentation: Last

blockingLatest

@CheckReturnValue
 @SchedulerSupport(value="none")
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:

ReactiveX documentation: First

blockingMostRecent

@CheckReturnValue
 @SchedulerSupport(value="none")
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:

ReactiveX documentation: First

blockingNext

@CheckReturnValue
 @SchedulerSupport(value="none")
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:

ReactiveX documentation: TakeLast

blockingSingle

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

Error handling:

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

Returns:

the single item emitted by this Observable

See Also:

ReactiveX documentation: First

blockingSingle

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

Error handling:

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

Parameters:

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

Returns:

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

See Also:

ReactiveX documentation: First

toFuture

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

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

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

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

Scheduler:

toFuture does not operate by default on a particular Scheduler.

Returns:

a Future that expects a single item to be emitted by this Observable

See Also:

ReactiveX documentation: To

blockingSubscribe

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

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

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

Scheduler:

blockingSubscribe does not operate by default on a particular Scheduler.

Since:

2.0

See Also:

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

blockingSubscribe

@SchedulerSupport(value="none")
public final void blockingSubscribe(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. Using the overloads blockingSubscribe(Consumer, Consumer) or blockingSubscribe(Consumer, Consumer, Action) instead is recommended.

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

Scheduler:

blockingSubscribe does not operate by default on a particular Scheduler.

Parameters:

onNext - the callback action for each source value

Since:

2.0

See Also:

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

blockingSubscribe

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

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

Scheduler:

blockingSubscribe does not operate by default on a particular Scheduler.

Parameters:

onNext - the callback action for each source value

onError - the callback action for an error event

Since:

2.0

See Also:

blockingSubscribe(Consumer, Consumer, Action)

blockingSubscribe

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

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

Scheduler:

blockingSubscribe does not operate by default on a particular Scheduler.

Parameters:

onNext - the callback action for each source value

onError - the callback action for an error event

onComplete - the callback action for the completion event.

Since:

2.0

blockingSubscribe

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

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

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

Scheduler:

blockingSubscribe does not operate by default on a particular Scheduler.

The a dispose() call is composed through.

Parameters:

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

Since:

2.0

buffer

@CheckReturnValue
 @SchedulerSupport(value="none")
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, the resulting ObservableSource emits the current buffer and propagates the notification from the source ObservableSource. Note that if the source ObservableSource issues an onError notification the event is passed on immediately without first emitting the buffer it is in the process of assembling.

Scheduler:

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

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:

ReactiveX operators documentation: Buffer

buffer

@CheckReturnValue
 @SchedulerSupport(value="none")
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, the resulting ObservableSource emits the current buffer and propagates the notification from the source ObservableSource. Note that if the source ObservableSource issues an onError notification the event is passed on immediately without first emitting the buffer it is in the process of assembling.

Scheduler:

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

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:

ReactiveX operators documentation: Buffer

buffer

@CheckReturnValue
 @SchedulerSupport(value="none")
public 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. The resulting ObservableSource emits buffers every skip items, each containing count items. When the source ObservableSource completes, the resulting ObservableSource emits the current buffer and propagates the notification from the source ObservableSource. Note that if the source ObservableSource issues an onError notification the event is passed on immediately without first emitting the buffer it is in the process of assembling.

Scheduler:

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

Type Parameters:

U - the collection subclass type to buffer into

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:

ReactiveX operators documentation: Buffer

buffer

@CheckReturnValue
 @SchedulerSupport(value="none")
public 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. The resulting ObservableSource emits connected, non-overlapping buffers, each containing count items. When the source ObservableSource completes, the resulting ObservableSource emits the current buffer and propagates the notification from the source ObservableSource. Note that if the source ObservableSource issues an onError notification the event is passed on immediately without first emitting the buffer it is in the process of assembling.

Scheduler:

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

Type Parameters:

U - the collection subclass type to buffer into

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:

ReactiveX operators documentation: Buffer

buffer

@CheckReturnValue
 @SchedulerSupport(value="io.reactivex:computation")
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, the resulting ObservableSource emits the current buffer and propagates the notification from the source ObservableSource. Note that if the source ObservableSource issues an onError notification the event is passed on immediately without first emitting the buffer it is in the process of assembling.

Scheduler:

This version of buffer 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:

ReactiveX operators documentation: Buffer

buffer

@CheckReturnValue
 @SchedulerSupport(value="custom")
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, the resulting ObservableSource emits the current buffer and propagates the notification from the source ObservableSource. Note that if the source ObservableSource issues an onError notification the event is passed on immediately without first emitting the buffer it is in the process of assembling.

Scheduler:

You specify which Scheduler this operator will use.

Parameters:

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

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

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

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

Returns:

an Observable that emits new buffers of items emitted by the source ObservableSource periodically after a fixed timespan has elapsed

See Also:

ReactiveX operators documentation: Buffer

buffer

@CheckReturnValue
 @SchedulerSupport(value="custom")
public 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. 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, the resulting ObservableSource emits the current buffer and propagates the notification from the source ObservableSource. Note that if the source ObservableSource issues an onError notification the event is passed on immediately without first emitting the buffer it is in the process of assembling.

Scheduler:

You specify which Scheduler this operator will use.

Type Parameters:

U - the collection subclass type to buffer into

Parameters:

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

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

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

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

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

Returns:

an Observable that emits new buffers of items emitted by the source ObservableSource periodically after a fixed timespan has elapsed

See Also:

ReactiveX operators documentation: Buffer

buffer

@CheckReturnValue
 @SchedulerSupport(value="io.reactivex:computation")
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, the resulting ObservableSource emits the current buffer and propagates the notification from the source ObservableSource. Note that if the source ObservableSource issues an onError notification the event is passed on immediately without first emitting the buffer it is in the process of assembling.

Scheduler:

This version of buffer 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:

ReactiveX operators documentation: Buffer

buffer

@CheckReturnValue
 @SchedulerSupport(value="io.reactivex:computation")
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, the resulting ObservableSource emits the current buffer and propagates the notification from the source ObservableSource. Note that if the source ObservableSource issues an onError notification the event is passed on immediately without first emitting the buffer it is in the process of assembling.

Scheduler:

This version of buffer 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:

ReactiveX operators documentation: Buffer

buffer

@CheckReturnValue
 @SchedulerSupport(value="custom")
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, the resulting ObservableSource emits the current buffer and propagates the notification from the source ObservableSource. Note that if the source ObservableSource issues an onError notification the event is passed on immediately without first emitting the buffer it is in the process of assembling.

Scheduler:

You specify which Scheduler this operator will use.

Parameters:

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

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

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

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

Returns:

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:

ReactiveX operators documentation: Buffer

buffer

@CheckReturnValue
 @SchedulerSupport(value="custom")
public 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. 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, the resulting ObservableSource emits the current buffer and propagates the notification from the source ObservableSource. Note that if the source ObservableSource issues an onError notification the event is passed on immediately without first emitting the buffer it is in the process of assembling.

Scheduler:

You specify which Scheduler this operator will use.

Type Parameters:

U - the collection subclass type to buffer into

Parameters:

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

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

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

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

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

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

Returns:

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:

ReactiveX operators documentation: Buffer

buffer

@CheckReturnValue
 @SchedulerSupport(value="custom")
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, the resulting ObservableSource emits the current buffer and propagates the notification from the source ObservableSource. Note that if the source ObservableSource issues an onError notification the event is passed on immediately without first emitting the buffer it is in the process of assembling.

Scheduler:

You specify which Scheduler this operator will use.

Parameters:

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

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

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

Returns:

an Observable that emits connected, non-overlapping buffers of items emitted by the source ObservableSource within a fixed duration

See Also:

ReactiveX operators documentation: Buffer

buffer

@CheckReturnValue
 @SchedulerSupport(value="none")
public 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. 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. If any of the source ObservableSource, openingIndicator or closingIndicator issues an onError notification the event is passed on immediately without first emitting the buffer it is in the process of assembling.

Scheduler:

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

Type Parameters:

TOpening - the element type of the buffer-opening ObservableSource

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

Parameters:

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

closingIndicator - the Function that is used to produce an ObservableSource for every buffer created. When this 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:

ReactiveX operators documentation: Buffer

buffer

@CheckReturnValue
 @SchedulerSupport(value="none")
public 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. 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. If any of the source ObservableSource, openingIndicator or closingIndicator issues an onError notification the event is passed on immediately without first emitting the buffer it is in the process of assembling.

Scheduler:

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

Type Parameters:

U - the collection subclass type to buffer into

TOpening - the element type of the buffer-opening ObservableSource

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

Parameters:

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

closingIndicator - the Function that is used to produce an ObservableSource for every buffer created. When this 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:

ReactiveX operators documentation: Buffer

buffer

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

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

Scheduler:

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

Type Parameters:

B - the boundary value type (ignored)

Parameters:

boundary - the boundary ObservableSource

Returns:

an Observable that emits buffered items from the source ObservableSource when the boundary ObservableSource emits an item

See Also:

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

buffer

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

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

Scheduler:

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

Type Parameters:

B - the boundary value type (ignored)

Parameters:

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:

ReactiveX operators documentation: Buffer, buffer(ObservableSource)

buffer

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

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

Scheduler:

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

Type Parameters:

U - the collection subclass type to buffer into

B - the boundary value type (ignored)

Parameters:

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:

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

buffer

@CheckReturnValue
 @SchedulerSupport(value="none")
public 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. 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 boundarySupplier emits an item.

If either the source ObservableSource or the boundary ObservableSource issues an onError notification the event is passed on immediately without first emitting the buffer it is in the process of assembling.

Scheduler:

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

Type Parameters:

B - the value type of the boundary-providing ObservableSource

Parameters:

boundarySupplier - a Callable that produces an ObservableSource that governs the boundary between buffers. Whenever the supplied 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:

ReactiveX operators documentation: Buffer

buffer

@CheckReturnValue
 @SchedulerSupport(value="none")
public 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. 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 boundarySupplier emits an item.

If either the source ObservableSource or the boundary ObservableSource issues an onError notification the event is passed on immediately without first emitting the buffer it is in the process of assembling.

Scheduler:

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

Type Parameters:

U - the collection subclass type to buffer into

B - the value type of the boundary-providing ObservableSource

Parameters:

boundarySupplier - a Callable that produces an ObservableSource that governs the boundary between buffers. Whenever the supplied 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:

ReactiveX operators documentation: Buffer

cache

@CheckReturnValue
 @SchedulerSupport(value="none")
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 ConnectableObservable.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:

ReactiveX operators documentation: Replay

cacheWithInitialCapacity

@CheckReturnValue
 @SchedulerSupport(value="none")
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 ConnectableObservable.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 ConnectableObservable.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:

ReactiveX operators documentation: Replay

cast

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

Scheduler:

cast does not operate by default on a particular Scheduler.

Type Parameters:

U - the output value type cast to

Parameters:

clazz - the target class 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:

ReactiveX operators documentation: Map

collect

@CheckReturnValue
 @SchedulerSupport(value="none")
public final <U> Single<U> collect(Callable<? extends U> initialValueSupplier,
        BiConsumer<? super U,? super T> collector)

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

Note that this operator requires the upstream to signal onComplete for the accumulator object to be emitted. Sources that are infinite and never complete will never emit anything through this operator and an infinite source may lead to a fatal OutOfMemoryError.

Scheduler:

collect does not operate by default on a particular Scheduler.

Type Parameters:

U - the accumulator and output type

Parameters:

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:

ReactiveX operators documentation: Reduce

collectInto

@CheckReturnValue
 @SchedulerSupport(value="none")
public final <U> Single<U> collectInto(U initialValue,
        BiConsumer<? super U,? super T> collector)

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

Note that this operator requires the upstream to signal onComplete for the accumulator object to be emitted. Sources that are infinite and never complete will never emit anything through this operator and an infinite source may lead to a fatal OutOfMemoryError.

Scheduler:

collectInto does not operate by default on a particular Scheduler.

Type Parameters:

U - the accumulator and output type

Parameters:

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:

ReactiveX operators documentation: Reduce

compose

@CheckReturnValue
 @SchedulerSupport(value="none")
public final <R> 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(io.reactivex.ObservableOperator<? extends R, ? super T>) operates on the ObservableSource's Observers.

If the operator you are creating is designed to act on the individual items emitted by a source ObservableSource, use lift(io.reactivex.ObservableOperator<? extends R, ? super T>). 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.

Type Parameters:

R - the value type of the output ObservableSource

Parameters:

composer - implements the function that transforms the source ObservableSource

Returns:

the source ObservableSource, transformed by the transformer function

See Also:

RxJava wiki: Implementing Your Own Operators

concatMap

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

Scheduler:

concatMap does not operate by default on a particular Scheduler.

Type Parameters:

R - the type of the inner ObservableSource sources and thus the output type

Parameters:

mapper - a function that, when applied to an item emitted by the 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:

ReactiveX operators documentation: FlatMap

concatMap

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

Scheduler:

concatMap does not operate by default on a particular Scheduler.

Type Parameters:

R - the type of the inner ObservableSource sources and thus the output type

Parameters:

mapper - a function that, when applied to an item emitted by the 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:

ReactiveX operators documentation: FlatMap

concatMapDelayError

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

Scheduler:

concatMapDelayError does not operate by default on a particular Scheduler.

Type Parameters:

R - the result value type

Parameters:

mapper - the function that maps the items of this ObservableSource into the inner ObservableSources.

Returns:

the new ObservableSource instance with the concatenation behavior

concatMapDelayError

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

Scheduler:

concatMapDelayError does not operate by default on a particular Scheduler.

Type Parameters:

R - the result value type

Parameters:

mapper - the function that maps the items of 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

concatMapEager

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

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.

Type Parameters:

R - the value type

Parameters:

mapper - the function that maps a sequence of values into a sequence of ObservableSources that will be eagerly concatenated

Returns:

the new ObservableSource instance with the specified concatenation behavior

Since:

2.0

concatMapEager

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

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.

Type Parameters:

R - the value type

Parameters:

mapper - the function that maps a sequence of values into a sequence of ObservableSources that will be eagerly concatenated

maxConcurrency - the maximum number of concurrent subscribed ObservableSources

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

Since:

2.0

concatMapEagerDelayError

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

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.

Type Parameters:

R - the value type

Parameters:

mapper - the function that maps a sequence of values into a sequence of ObservableSources that will be eagerly concatenated

tillTheEnd - if true, all errors from the outer and inner ObservableSource sources are delayed until the end, if false, an error from the main source is signalled when the current ObservableSource source terminates

Returns:

the new ObservableSource instance with the specified concatenation behavior

Since:

2.0

concatMapEagerDelayError

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

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.

Type Parameters:

R - the value type

Parameters:

mapper - the function that maps a sequence of values into a sequence of ObservableSources that will be eagerly concatenated

maxConcurrency - the maximum number of concurrent subscribed ObservableSources

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

Since:

2.0

concatMapCompletable

@CheckReturnValue
 @SchedulerSupport(value="none")
public final Completable concatMapCompletable(Function<? super T,? extends CompletableSource> mapper)

Maps each element of the upstream Observable into CompletableSources, subscribes to them one at a time in order and waits until the upstream and all CompletableSources complete.

Scheduler:

concatMapCompletable does not operate by default on a particular Scheduler.

History: 2.1.6 - experimental

Parameters:

mapper - a function that, when applied to an item emitted by the source ObservableSource, returns a CompletableSource

Returns:

a Completable that signals onComplete when the upstream and all CompletableSources complete

Since:

2.2

concatMapCompletable

@CheckReturnValue
 @SchedulerSupport(value="none")
public final Completable concatMapCompletable(Function<? super T,? extends CompletableSource> mapper,
        int capacityHint)

Maps each element of the upstream Observable into CompletableSources, subscribes to them one at a time in order and waits until the upstream and all CompletableSources complete.

Scheduler:

concatMapCompletable does not operate by default on a particular Scheduler.

History: 2.1.6 - experimental

Parameters:

mapper - a function that, when applied to an item emitted by the source ObservableSource, returns a CompletableSource

capacityHint - the number of upstream items expected to be buffered until the current CompletableSource, mapped from the current item, completes.

Returns:

a Completable that signals onComplete when the upstream and all CompletableSources complete

Since:

2.2

concatMapCompletableDelayError

@CheckReturnValue
 @SchedulerSupport(value="none")
public final Completable concatMapCompletableDelayError(Function<? super T,? extends CompletableSource> mapper)

Maps the upstream items into CompletableSources and subscribes to them one after the other terminates, delaying all errors till both this Observable and all inner CompletableSources terminate.

Scheduler:

concatMapCompletableDelayError does not operate by default on a particular Scheduler.

History: 2.1.11 - experimental

Parameters:

mapper - the function called with the upstream item and should return a CompletableSource to become the next source to be subscribed to

Returns:

a new Completable instance

Since:

2.2

See Also:

concatMapCompletable(Function, int)

concatMapCompletableDelayError

@CheckReturnValue
 @SchedulerSupport(value="none")
public final Completable concatMapCompletableDelayError(Function<? super T,? extends CompletableSource> mapper,
        boolean tillTheEnd)

Maps the upstream items into CompletableSources and subscribes to them one after the other terminates, optionally delaying all errors till both this Observable and all inner CompletableSources terminate.

Scheduler:

concatMapCompletableDelayError does not operate by default on a particular Scheduler.

History: 2.1.11 - experimental

Parameters:

mapper - the function called with the upstream item and should return a CompletableSource to become the next source to be subscribed to

tillTheEnd - If true, errors from this Observable or any of the inner CompletableSources are delayed until all of them terminate. If false, an error from this Observable is delayed until the current inner CompletableSource terminates and only then is it emitted to the downstream.

Returns:

a new Completable instance

Since:

2.2

See Also:

concatMapCompletable(Function)

concatMapCompletableDelayError

@CheckReturnValue
 @SchedulerSupport(value="none")
public final Completable concatMapCompletableDelayError(Function<? super T,? extends CompletableSource> mapper,
        boolean tillTheEnd,
        int prefetch)

Maps the upstream items into CompletableSources and subscribes to them one after the other terminates, optionally delaying all errors till both this Observable and all inner CompletableSources terminate.

Scheduler:

concatMapCompletableDelayError does not operate by default on a particular Scheduler.

History: 2.1.11 - experimental

Parameters:

mapper - the function called with the upstream item and should return a CompletableSource to become the next source to be subscribed to

tillTheEnd - If true, errors from this Observable or any of the inner CompletableSources are delayed until all of them terminate. If false, an error from this Observable is delayed until the current inner CompletableSource terminates and only then is it emitted to the downstream.

prefetch - The number of upstream items to prefetch so that fresh items are ready to be mapped when a previous CompletableSource terminates. The operator replenishes after half of the prefetch amount has been consumed and turned into CompletableSources.

Returns:

a new Completable instance

Since:

2.2

See Also:

concatMapCompletable(Function, int)

concatMapIterable

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

Scheduler:

concatMapIterable does not operate by default on a particular Scheduler.

Type Parameters:

U - the type of item emitted by the resulting ObservableSource

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:

ReactiveX operators documentation: FlatMap

concatMapIterable

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

Scheduler:

concatMapIterable does not operate by defaul