rx

Class Observable

java.lang.Object

rx.Observable

Type Parameters:

T - the type of the items emitted by the Observable

Direct Known Subclasses:

ConnectableObservable, GroupedObservable, Subject

public class Observable
extends java.lang.Object

The Observable class that implements the Reactive Pattern.

This class provides methods for subscribing to the Observable as well as delegate methods to the various Observers.

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

For more information see the ReactiveX documentation.

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static interface	Observable.OnSubscribe<T> Invoked when Observable.subscribe is called.
static interface	Observable.Operator<R,T> Operator function for lifting into an Observable.
static interface	Observable.Transformer<T,R> Function that receives the current Observable and should return another Observable, possibly with given element type, in exchange that will be subscribed to by the downstream operators and subscribers.

Constructor Summary

Constructors

Modifier	Constructor and Description
protected	Observable(Observable.OnSubscribe<T> f) Creates an Observable with a Function to execute when it is subscribed to.

Method Summary

Modifier and Type	Method and Description
Observable	all(Func1T,java.lang.Boolean> predicate) Returns an Observable that emits a Boolean that indicates whether all of the items emitted by the source Observable satisfy a condition.
static Observable	amb(java.lang.IterableObservable> sources) Mirrors the one Observable in an Iterable of several Observables that first either emits an item or sends a termination notification.
static Observable	amb(Observable o1, Observable o2) Given two Observables, mirrors the one that first either emits an item or sends a termination notification.
static Observable	amb(Observable o1, Observable o2, Observable o3) Given three Observables, mirrors the one that first either emits an item or sends a termination notification.
static Observable	amb(Observable o1, Observable o2, Observable o3, Observable o4) Given four Observables, mirrors the one that first either emits an item or sends a termination notification.
static Observable	amb(Observable o1, Observable o2, Observable o3, Observable o4, Observable o5) Given five Observables, mirrors the one that first either emits an item or sends a termination notification.
static Observable	amb(Observable o1, Observable o2, Observable o3, Observable o4, Observable o5, Observable o6) Given six Observables, mirrors the one that first either emits an item or sends a termination notification.
static Observable	amb(Observable o1, Observable o2, Observable o3, Observable o4, Observable o5, Observable o6, Observable o7) Given seven Observables, mirrors the one that first either emits an item or sends a termination notification.
static Observable	amb(Observable o1, Observable o2, Observable o3, Observable o4, Observable o5, Observable o6, Observable o7, Observable o8) Given eight Observables, mirrors the one that first either emits an item or sends a termination notification.
static Observable	amb(Observable o1, Observable o2, Observable o3, Observable o4, Observable o5, Observable o6, Observable o7, Observable o8, Observable o9) Given nine Observables, mirrors the one that first either emits an item or sends a termination notification.
Observable<T>	ambWith(ObservableT> t1) Mirrors the Observable (current or provided) that first either emits an item or sends a termination notification.
Observable<T>	asObservable() Portrays a object of an Observable subclass as a simple Observable object.
ObservableT>>	buffer(Func0Observable> bufferClosingSelector) Returns an Observable that emits buffers of items it collects from the source Observable.
ObservableT>>	buffer(int count) Returns an Observable that emits buffers of items it collects from the source Observable.
ObservableT>>	buffer(int count, int skip) Returns an Observable that emits buffers of items it collects from the source Observable.
ObservableT>>	buffer(long timespan, long timeshift, java.util.concurrent.TimeUnit unit) Returns an Observable that emits buffers of items it collects from the source Observable.
ObservableT>>	buffer(long timespan, long timeshift, java.util.concurrent.TimeUnit unit, Scheduler scheduler) Returns an Observable that emits buffers of items it collects from the source Observable.
ObservableT>>	buffer(long timespan, java.util.concurrent.TimeUnit unit) Returns an Observable that emits buffers of items it collects from the source Observable.
ObservableT>>	buffer(long timespan, java.util.concurrent.TimeUnit unit, int count) Returns an Observable that emits buffers of items it collects from the source Observable.
ObservableT>>	buffer(long timespan, java.util.concurrent.TimeUnit unit, int count, Scheduler scheduler) Returns an Observable that emits buffers of items it collects from the source Observable.
ObservableT>>	buffer(long timespan, java.util.concurrent.TimeUnit unit, Scheduler scheduler) Returns an Observable that emits buffers of items it collects from the source Observable.
ObservableT>>	buffer(Observable bufferOpenings, Func1Observable> bufferClosingSelector) Returns an Observable that emits buffers of items it collects from the source Observable.
ObservableT>>	buffer(Observable boundary) Returns an Observable that emits non-overlapping buffered items from the source Observable each time the specified boundary Observable emits an item.
ObservableT>>	buffer(Observable boundary, int initialCapacity) Returns an Observable that emits non-overlapping buffered items from the source Observable each time the specified boundary Observable emits an item.
Observable<T>	cache() Returns an Observable that subscribes to this Observable lazily, caches all of its events and replays them, in the same order as received, to all the downstream subscribers.
Observable<T>	cache(int initialCapacity) Deprecated. Use cacheWithInitialCapacity(int) instead.
Observable<T>	cacheWithInitialCapacity(int initialCapacity) Returns an Observable that subscribes to this Observable lazily, caches all of its events and replays them, in the same order as received, to all the downstream subscribers.
Observable	cast(java.lang.Class klass) Returns an Observable that emits the items emitted by the source Observable, converted to the specified type.
Observable	collect(Func0 stateFactory, Action2T> collector) Collects items emitted by the source Observable into a single mutable data structure and returns an Observable that emits this structure.
static Observable	combineLatest(java.lang.IterableObservable> sources, FuncN combineFunction) Combines a collection of source Observables by emitting an item that aggregates the latest values of each of the source Observables each time an item is received from any of the source Observables, where this aggregation is defined by a specified function.
static Observable	combineLatest(java.util.ListObservable> sources, FuncN combineFunction) Combines a list of source Observables by emitting an item that aggregates the latest values of each of the source Observables each time an item is received from any of the source Observables, where this aggregation is defined by a specified function.
static Observable	combineLatest(Observable o1, Observable o2, Func2 combineFunction) Combines two source Observables by emitting an item that aggregates the latest values of each of the source Observables each time an item is received from either of the source Observables, where this aggregation is defined by a specified function.
static Observable	combineLatest(Observable o1, Observable o2, Observable o3, Func3 combineFunction) Combines three source Observables by emitting an item that aggregates the latest values of each of the source Observables each time an item is received from any of the source Observables, where this aggregation is defined by a specified function.
static Observable	combineLatest(Observable o1, Observable o2, Observable o3, Observable o4, Func4 combineFunction) Combines four source Observables by emitting an item that aggregates the latest values of each of the source Observables each time an item is received from any of the source Observables, where this aggregation is defined by a specified function.
static Observable	combineLatest(Observable o1, Observable o2, Observable o3, Observable o4, Observable o5, Func5 combineFunction) Combines five source Observables by emitting an item that aggregates the latest values of each of the source Observables each time an item is received from any of the source Observables, where this aggregation is defined by a specified function.
static Observable	combineLatest(Observable o1, Observable o2, Observable o3, Observable o4, Observable o5, Observable o6, Func6 combineFunction) Combines six source Observables by emitting an item that aggregates the latest values of each of the source Observables each time an item is received from any of the source Observables, where this aggregation is defined by a specified function.
static Observable	combineLatest(Observable o1, Observable o2, Observable o3, Observable o4, Observable o5, Observable o6, Observable o7, Func7 combineFunction) Combines seven source Observables by emitting an item that aggregates the latest values of each of the source Observables each time an item is received from any of the source Observables, where this aggregation is defined by a specified function.
static Observable	combineLatest(Observable o1, Observable o2, Observable o3, Observable o4, Observable o5, Observable o6, Observable o7, Observable o8, Func8 combineFunction) Combines eight source Observables by emitting an item that aggregates the latest values of each of the source Observables each time an item is received from any of the source Observables, where this aggregation is defined by a specified function.
static Observable	combineLatest(Observable o1, Observable o2, Observable o3, Observable o4, Observable o5, Observable o6, Observable o7, Observable o8, Observable o9, Func9 combineFunction) Combines nine source Observables by emitting an item that aggregates the latest values of each of the source Observables each time an item is received from any of the source Observables, where this aggregation is defined by a specified function.
static Observable	combineLatestDelayError(java.lang.IterableObservable> sources, FuncN combineFunction) Combines a collection of source Observables by emitting an item that aggregates the latest values of each of the source Observables each time an item is received from any of the source Observables, where this aggregation is defined by a specified function and delays any error from the sources until all source Observables terminate.
Observable	compose(Observable.TransformerT,? extends R> transformer) Transform an Observable by applying a particular Transformer function to it.
static Observable	concat(java.lang.IterableObservable> sequences) Flattens an Iterable of Observables into one Observable, one after the other, without interleaving them.
static Observable	concat(ObservableObservable> observables) Returns an Observable that emits the items emitted by each of the Observables emitted by the source Observable, one after the other, without interleaving them.
static Observable	concat(Observable t1, Observable t2) Returns an Observable that emits the items emitted by two Observables, one after the other, without interleaving them.
static Observable	concat(Observable t1, Observable t2, Observable t3) Returns an Observable that emits the items emitted by three Observables, one after the other, without interleaving them.
static Observable	concat(Observable t1, Observable t2, Observable t3, Observable t4) Returns an Observable that emits the items emitted by four Observables, one after the other, without interleaving them.
static Observable	concat(Observable t1, Observable t2, Observable t3, Observable t4, Observable t5) Returns an Observable that emits the items emitted by five Observables, one after the other, without interleaving them.
static Observable	concat(Observable t1, Observable t2, Observable t3, Observable t4, Observable t5, Observable t6) Returns an Observable that emits the items emitted by six Observables, one after the other, without interleaving them.
static Observable	concat(Observable t1, Observable t2, Observable t3, Observable t4, Observable t5, Observable t6, Observable t7) Returns an Observable that emits the items emitted by seven Observables, one after the other, without interleaving them.
static Observable	concat(Observable t1, Observable t2, Observable t3, Observable t4, Observable t5, Observable t6, Observable t7, Observable t8) Returns an Observable that emits the items emitted by eight Observables, one after the other, without interleaving them.
static Observable	concat(Observable t1, Observable t2, Observable t3, Observable t4, Observable t5, Observable t6, Observable t7, Observable t8, Observable t9) Returns an Observable that emits the items emitted by nine Observables, one after the other, without interleaving them.
static Observable	concatDelayError(java.lang.IterableObservable> sources) Concatenates the Iterable sequence of Observables into a single sequence by subscribing to each Observable, one after the other, one at a time and delays any errors till the all inner Observables terminate.
static Observable	concatDelayError(ObservableObservable> sources) Concatenates the Observable sequence of Observables into a single sequence by subscribing to each inner Observable, one after the other, one at a time and delays any errors till the all inner and the outer Observables terminate.
static Observable	concatDelayError(Observable t1, Observable t2) Returns an Observable that emits the items emitted by two Observables, one after the other, without interleaving them, and delays any errors till all Observables terminate.
static Observable	concatDelayError(Observable t1, Observable t2, Observable t3) Returns an Observable that emits the items emitted by three Observables, one after the other, without interleaving them, and delays any errors till all Observables terminate.
static Observable	concatDelayError(Observable t1, Observable t2, Observable t3, Observable t4) Returns an Observable that emits the items emitted by four Observables, one after the other, without interleaving them, and delays any errors till all Observables terminate.
static Observable	concatDelayError(Observable t1, Observable t2, Observable t3, Observable t4, Observable t5) Returns an Observable that emits the items emitted by five Observables, one after the other, without interleaving them, and delays any errors till all Observables terminate.
static Observable	concatDelayError(Observable t1, Observable t2, Observable t3, Observable t4, Observable t5, Observable t6) Returns an Observable that emits the items emitted by six Observables, one after the other, without interleaving them, and delays any errors till all Observables terminate.
static Observable	concatDelayError(Observable t1, Observable t2, Observable t3, Observable t4, Observable t5, Observable t6, Observable t7) Returns an Observable that emits the items emitted by seven Observables, one after the other, without interleaving them, and delays any errors till all Observables terminate.
static Observable	concatDelayError(Observable t1, Observable t2, Observable t3, Observable t4, Observable t5, Observable t6, Observable t7, Observable t8) Returns an Observable that emits the items emitted by eight Observables, one after the other, without interleaving them, and delays any errors till all Observables terminate.
static Observable	concatDelayError(Observable t1, Observable t2, Observable t3, Observable t4, Observable t5, Observable t6, Observable t7, Observable t8, Observable t9) Returns an Observable that emits the items emitted by nine Observables, one after the other, without interleaving them, and delays any errors till all Observables terminate.
static Observable	concatEager(java.lang.IterableObservable> sources) Concatenates a sequence of Observables eagerly into a single stream of values.
static Observable	concatEager(java.lang.IterableObservable> sources, int capacityHint) Concatenates a sequence of Observables eagerly into a single stream of values.
static Observable	concatEager(ObservableObservable> sources) Concatenates an Observable sequence of Observables eagerly into a single stream of values.
static Observable	concatEager(ObservableObservable> sources, int capacityHint) Concatenates an Observable sequence of Observables eagerly into a single stream of values.
static Observable	concatEager(Observable o1, Observable o2) Concatenates two source Observables eagerly into a single stream of values.
static Observable	concatEager(Observable o1, Observable o2, Observable o3) Concatenates three sources eagerly into a single stream of values.
static Observable	concatEager(Observable o1, Observable o2, Observable o3, Observable o4) Concatenates four sources eagerly into a single stream of values.
static Observable	concatEager(Observable o1, Observable o2, Observable o3, Observable o4, Observable o5) Concatenates five sources eagerly into a single stream of values.
static Observable	concatEager(Observable o1, Observable o2, Observable o3, Observable o4, Observable o5, Observable o6) Concatenates six sources eagerly into a single stream of values.
static Observable	concatEager(Observable o1, Observable o2, Observable o3, Observable o4, Observable o5, Observable o6, Observable o7) Concatenates seven sources eagerly into a single stream of values.
static Observable	concatEager(Observable o1, Observable o2, Observable o3, Observable o4, Observable o5, Observable o6, Observable o7, Observable o8) Concatenates eight sources eagerly into a single stream of values.
static Observable	concatEager(Observable o1, Observable o2, Observable o3, Observable o4, Observable o5, Observable o6, Observable o7, Observable o8, Observable o9) Concatenates nine sources eagerly into a single stream of values.
Observable	concatMap(Func1T,? extends Observable> func) Returns a new Observable that emits items resulting from applying a function that you supply to each item emitted by the source Observable, where that function returns an Observable, and then emitting the items that result from concatenating those resulting Observables.
Observable	concatMapDelayError(Func1T,? extends Observable> func) Maps each of the items into an Observable, 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 Observables till all of them terminate.
Observable	concatMapEager(Func1T,? extends Observable> mapper) Maps a sequence of values into Observables and concatenates these Observables eagerly into a single Observable.
Observable	concatMapEager(Func1T,? extends Observable> mapper, int capacityHint) Maps a sequence of values into Observables and concatenates these Observables eagerly into a single Observable.
Observable	concatMapEager(Func1T,? extends Observable> mapper, int capacityHint, int maxConcurrent) Maps a sequence of values into Observables and concatenates these Observables eagerly into a single Observable.
Observable	concatMapIterable(Func1T,? extends java.lang.Iterable> collectionSelector) Returns an Observable that concatenate each item emitted by the source Observable with the values in an Iterable corresponding to that item that is generated by a selector.
Observable<T>	concatWith(ObservableT> t1) Returns an Observable that emits the items emitted from the current Observable, then the next, one after the other, without interleaving them.
Observable	contains(java.lang.Object element) Returns an Observable that emits a Boolean that indicates whether the source Observable emitted a specified item.
Observable	count() Returns an Observable that emits the count of the total number of items emitted by the source Observable.
Observable	countLong() Returns an Observable that counts the total number of items emitted by the source Observable and emits this count as a 64-bit Long.
static Observable	create(Action1<Emitter> emitter, Emitter.BackpressureMode backpressure) Provides an API (via a cold Observable) that bridges the reactive world with the callback-style, generally non-backpressured world.
static Observable	create(AsyncOnSubscribe asyncOnSubscribe) Returns an Observable that respects the back-pressure semantics.
static Observable	create(Observable.OnSubscribe f) Deprecated. 1.2.7 - inherently unsafe, use the other create() methods for basic cases or see unsafeCreate(OnSubscribe) for advanced cases (such as custom operators)
static Observable	create(SyncOnSubscribe syncOnSubscribe) Returns an Observable that respects the back-pressure semantics.
Observable<T>	debounce(Func1T,? extends Observable> debounceSelector) Returns an Observable that mirrors the source Observable, except that it drops items emitted by the source Observable that are followed by another item within a computed debounce duration.
Observable<T>	debounce(long timeout, java.util.concurrent.TimeUnit unit) Returns an Observable that mirrors the source Observable, except that it drops items emitted by the source Observable that are followed by newer items before a timeout value expires.
Observable<T>	debounce(long timeout, java.util.concurrent.TimeUnit unit, Scheduler scheduler) Returns an Observable that mirrors the source Observable, except that it drops items emitted by the source Observable that are followed by newer items before a timeout value expires on a specified Scheduler.
Observable<T>	defaultIfEmpty(T defaultValue) Returns an Observable that emits the items emitted by the source Observable or a specified default item if the source Observable is empty.
static Observable	defer(Func0<Observable> observableFactory) Returns an Observable that calls an Observable factory to create an Observable for each new Observer that subscribes.
Observable<T>	delay(Func0Observable> subscriptionDelay, Func1T,? extends Observable> itemDelay) Returns an Observable that delays the subscription to and emissions from the source Observable via another Observable on a per-item basis.
Observable<T>	delay(Func1T,? extends Observable> itemDelay) Returns an Observable that delays the emissions of the source Observable via another Observable on a per-item basis.
Observable<T>	delay(long delay, java.util.concurrent.TimeUnit unit) Returns an Observable that emits the items emitted by the source Observable shifted forward in time by a specified delay.
Observable<T>	delay(long delay, java.util.concurrent.TimeUnit unit, Scheduler scheduler) Returns an Observable that emits the items emitted by the source Observable shifted forward in time by a specified delay.
Observable<T>	delaySubscription(Func0Observable> subscriptionDelay) Returns an Observable that delays the subscription to the source Observable until a second Observable emits an item.
Observable<T>	delaySubscription(long delay, java.util.concurrent.TimeUnit unit) Returns an Observable that delays the subscription to the source Observable by a given amount of time.
Observable<T>	delaySubscription(long delay, java.util.concurrent.TimeUnit unit, Scheduler scheduler) Returns an Observable that delays the subscription to the source Observable by a given amount of time, both waiting and subscribing on a given Scheduler.
Observable<T>	delaySubscription(Observable other) Returns an Observable that delays the subscription to this Observable until the other Observable emits an element or completes normally.
Observable	dematerialize() Returns an Observable that reverses the effect of materialize by transforming the Notification objects emitted by the source Observable into the items or notifications they represent.
Observable<T>	distinct() Returns an Observable that emits all items emitted by the source Observable that are distinct.
Observable<T>	distinct(Func1T,? extends U> keySelector) Returns an Observable that emits all items emitted by the source Observable that are distinct according to a key selector function.
Observable<T>	distinctUntilChanged() Returns an Observable that emits all items emitted by the source Observable that are distinct from their immediate predecessors.
Observable<T>	distinctUntilChanged(Func1T,? extends U> keySelector) Returns an Observable that emits all items emitted by the source Observable that are distinct from their immediate predecessors, according to a key selector function.
Observable<T>	distinctUntilChanged(Func2T,? super T,java.lang.Boolean> comparator) Returns an Observable that emits all items emitted by the source Observable that are distinct from their immediate predecessors when compared with each other via the provided comparator function.
Observable<T>	doAfterTerminate(Action0 action) Registers an Action0 to be called when this Observable invokes either onCompleted or onError.
Observable<T>	doOnCompleted(Action0 onCompleted) Modifies the source Observable so that it invokes an action when it calls onCompleted.
Observable<T>	doOnEach(Action1<NotificationT>> onNotification) Modifies the source Observable so that it invokes an action for each item and terminal event it emits.
Observable<T>	doOnEach(ObserverT> observer) Modifies the source Observable so that it notifies an Observer for each item and terminal event it emits.
Observable<T>	doOnError(Action1 onError) Modifies the source Observable so that it invokes an action if it calls onError.
Observable<T>	doOnNext(Action1T> onNext) Modifies the source Observable so that it invokes an action when it calls onNext.
Observable<T>	doOnRequest(Action1 onRequest) Modifies the source Observable so that it invokes the given action when it receives a request for more items.
Observable<T>	doOnSubscribe(Action0 subscribe) Modifies the source Observable so that it invokes the given action when it is subscribed from its subscribers.
Observable<T>	doOnTerminate(Action0 onTerminate) Modifies the source Observable so that it invokes an action when it calls onCompleted or onError.
Observable<T>	doOnUnsubscribe(Action0 unsubscribe) Calls the unsubscribe Action0 if the downstream unsubscribes the sequence.
Observable<T>	elementAt(int index) Returns an Observable that emits the single item at a specified index in a sequence of emissions from a source Observable.
Observable<T>	elementAtOrDefault(int index, T defaultValue) Returns an Observable that emits the item found at a specified index in a sequence of emissions from a source Observable, or a default item if that index is out of range.
static Observable	empty() Returns an Observable that emits no items to the Observer and immediately invokes its onCompleted method.
static Observable	error(java.lang.Throwable exception) Returns an Observable that invokes an Observer's onError method when the Observer subscribes to it.
Observable	exists(Func1T,java.lang.Boolean> predicate) Returns an Observable that emits true if any item emitted by the source Observable satisfies a specified condition, otherwise false.
Observable<T>	filter(Func1T,java.lang.Boolean> predicate) Filters items emitted by an Observable by only emitting those that satisfy a specified predicate.
Observable<T>	finallyDo(Action0 action) Deprecated. use doAfterTerminate(Action0) instead.
Observable<T>	first() Returns an Observable that emits only the very first item emitted by the source Observable, or notifies of an NoSuchElementException if the source Observable is empty.
Observable<T>	first(Func1T,java.lang.Boolean> predicate) Returns an Observable that emits only the very first item emitted by the source Observable that satisfies a specified condition, or notifies of an NoSuchElementException if no such items are emitted.
Observable<T>	firstOrDefault(T defaultValue) Returns an Observable that emits only the very first item emitted by the source Observable, or a default item if the source Observable completes without emitting anything.
Observable<T>	firstOrDefault(T defaultValue, Func1T,java.lang.Boolean> predicate) Returns an Observable that emits only the very first item emitted by the source Observable that satisfies a specified condition, or a default item if the source Observable emits no such items.
Observable	flatMap(Func1T,? extends Observable> func) Returns an Observable that emits items based on applying a function that you supply to each item emitted by the source Observable, where that function returns an Observable, and then merging those resulting Observables and emitting the results of this merger.
Observable	flatMap(Func1T,? extends Observable> onNext, Func1Observable> onError, Func0Observable> onCompleted) Returns an Observable that applies a function to each item emitted or notification raised by the source Observable and then flattens the Observables returned from these functions and emits the resulting items.
Observable	flatMap(Func1T,? extends Observable> onNext, Func1Observable> onError, Func0Observable> onCompleted, int maxConcurrent) Returns an Observable that applies a function to each item emitted or notification raised by the source Observable and then flattens the Observables returned from these functions and emits the resulting items, while limiting the maximum number of concurrent subscriptions to these Observables.
Observable	flatMap(Func1T,? extends Observable> func, int maxConcurrent) Returns an Observable that emits items based on applying a function that you supply to each item emitted by the source Observable, where that function returns an Observable, and then merging those resulting Observables and emitting the results of this merger, while limiting the maximum number of concurrent subscriptions to these Observables.
Observable	flatMap(Func1T,? extends Observable> collectionSelector, Func2T,? 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 Observable and a specified collection Observable.
Observable	flatMap(Func1T,? extends Observable> collectionSelector, Func2T,? super U,? extends R> resultSelector, int maxConcurrent) Returns an Observable that emits the results of a specified function to the pair of values emitted by the source Observable and a specified collection Observable, while limiting the maximum number of concurrent subscriptions to these Observables.
Observable<T>	flatMapCompletable(Func1T,? extends Completable> mapper) Maps all upstream values to Completables and runs them together until the upstream and all inner Completables complete normally.
Observable<T>	flatMapCompletable(Func1T,? extends Completable> mapper, boolean delayErrors) Maps all upstream values to Completables and runs them together, optionally delaying any errors, until the upstream and all inner Completables terminate.
Observable<T>	flatMapCompletable(Func1T,? extends Completable> mapper, boolean delayErrors, int maxConcurrency) Maps upstream values to Completables and runs up to the given number of them together at a time, optionally delaying any errors, until the upstream and all inner Completables terminate.
Observable	flatMapIterable(Func1T,? extends java.lang.Iterable> collectionSelector) Returns an Observable that merges each item emitted by the source Observable with the values in an Iterable corresponding to that item that is generated by a selector.
Observable	flatMapIterable(Func1T,? extends java.lang.Iterable> collectionSelector, int maxConcurrent) Returns an Observable that merges each item emitted by the source Observable with the values in an Iterable corresponding to that item that is generated by a selector, while limiting the number of concurrent subscriptions to these Observables.
Observable	flatMapIterable(Func1T,? extends java.lang.Iterable> collectionSelector, Func2T,? super U,? extends R> resultSelector) Returns an Observable that emits the results of applying a function to the pair of values from the source Observable and an Iterable corresponding to that item that is generated by a selector.
Observable	flatMapIterable(Func1T,? extends java.lang.Iterable> collectionSelector, Func2T,? super U,? extends R> resultSelector, int maxConcurrent) Returns an Observable that emits the results of applying a function to the pair of values from the source Observable and an Iterable corresponding to that item that is generated by a selector, while limiting the number of concurrent subscriptions to these Observables.
Observable	flatMapSingle(Func1T,? extends Single> mapper) Maps all upstream values to Singles and runs them together until the upstream and all inner Singles complete normally.
Observable	flatMapSingle(Func1T,? extends Single> mapper, boolean delayErrors) Maps all upstream values to Singles and runs them together, optionally delaying any errors, until the upstream and all inner Singles terminate.
Observable	flatMapSingle(Func1T,? extends Single> mapper, boolean delayErrors, int maxConcurrency) Maps upstream values to Singles and runs up to the given number of them together at a time, optionally delaying any errors, until the upstream and all inner Singles terminate.
void	forEach(Action1T> onNext) Subscribes to the Observable and receives notifications for each element.
void	forEach(Action1T> onNext, Action1 onError) Subscribes to the Observable and receives notifications for each element and error events.
void	forEach(Action1T> onNext, Action1 onError, Action0 onComplete) Subscribes to the Observable and receives notifications for each element and the terminal events.
static Observable	from(java.util.concurrent.Future future) Converts a Future into an Observable.
static Observable	from(java.util.concurrent.Future future, long timeout, java.util.concurrent.TimeUnit unit) Converts a Future into an Observable, with a timeout on the Future.
static Observable	from(java.util.concurrent.Future future, Scheduler scheduler) Converts a Future, operating on a specified Scheduler, into an Observable.
static Observable	from(java.lang.Iterable iterable) Converts an Iterable sequence into an Observable that emits the items in the sequence.
static Observable	from(T[] array) Converts an Array into an Observable that emits the items in the Array.
static Observable	fromCallable(java.util.concurrent.Callable func) Returns an Observable that, when an observer subscribes to it, invokes a function you specify and then emits the value returned from that function.
Observable<GroupedObservableT>>	groupBy(Func1T,? extends K> keySelector) Groups the items emitted by an Observable according to a specified criterion, and emits these grouped items as GroupedObservables.
Observable<GroupedObservable>	groupBy(Func1T,? extends K> keySelector, Func1T,? extends R> elementSelector) Groups the items emitted by an Observable according to a specified criterion, and emits these grouped items as GroupedObservables.
Observable<GroupedObservable>	groupBy(Func1T,? extends K> keySelector, Func1T,? extends R> elementSelector, Func1<Action1,java.util.Map> evictingMapFactory) Deprecated. since 1.3.7, use groupBy(Func1, Func1, int, boolean, Func1) instead which uses much less memory. Please take note of the usage difference involving the evicting action which now expects the value from the map instead of the key.
Observable<GroupedObservable>	groupBy(Func1T,? extends K> keySelector, Func1T,? extends R> elementSelector, int bufferSize, boolean delayError, Func1<Action1,java.util.Map> evictingMapFactory) Groups the items emitted by an Observable according to a specified criterion, and emits these grouped items as GroupedObservables.
Observable	groupJoin(Observable right, Func1T,? extends Observable> leftDuration, Func1Observable> rightDuration, Func2T,? super Observable,? extends R> resultSelector) Returns an Observable that correlates two Observables when they overlap in time and groups the results.
Observable<T>	ignoreElements() Ignores all items emitted by the source Observable and only calls onCompleted or onError.
static Observable	interval(long initialDelay, long period, java.util.concurrent.TimeUnit unit) Returns an Observable that emits a 0L after the initialDelay and ever increasing numbers after each period of time thereafter.
static Observable	interval(long initialDelay, long period, java.util.concurrent.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	interval(long interval, java.util.concurrent.TimeUnit unit) Returns an Observable that emits a sequential number every specified interval of time.
static Observable	interval(long interval, java.util.concurrent.TimeUnit unit, Scheduler scheduler) Returns an Observable that emits a sequential number every specified interval of time, on a specified Scheduler.
Observable	isEmpty() Returns an Observable that emits true if the source Observable is empty, otherwise false.
Observable	join(Observable right, Func1<T,Observable> leftDurationSelector, Func1Observable> rightDurationSelector, Func2<T,TRight,R> resultSelector) Correlates the items emitted by two Observables based on overlapping durations.
static Observable	just(T value) Returns an Observable that emits a single item and then completes.
static Observable	just(T t1, T t2) Converts two items into an Observable that emits those items.
static Observable	just(T t1, T t2, T t3) Converts three items into an Observable that emits those items.
static Observable	just(T t1, T t2, T t3, T t4) Converts four items into an Observable that emits those items.
static Observable	just(T t1, T t2, T t3, T t4, T t5) Converts five items into an Observable that emits those items.
static Observable	just(T t1, T t2, T t3, T t4, T t5, T t6) Converts six items into an Observable that emits those items.
static Observable	just(T t1, T t2, T t3, T t4, T t5, T t6, T t7) Converts seven items into an Observable that emits those items.
static Observable	just(T t1, T t2, T t3, T t4, T t5, T t6, T t7, T t8) Converts eight items into an Observable that emits those items.
static Observable	just(T t1, T t2, T t3, T t4, T t5, T t6, T t7, T t8, T t9) Converts nine items into an Observable that emits those items.
static Observable	just(T t1, T t2, T t3, T t4, T t5, T t6, T t7, T t8, T t9, T t10) Converts ten items into an Observable that emits those items.
Observable<T>	last() Returns an Observable that emits the last item emitted by the source Observable or notifies observers of a NoSuchElementException if the source Observable is empty.
Observable<T>	last(Func1T,java.lang.Boolean> predicate) Returns an Observable that emits only the last item emitted by the source Observable that satisfies a given condition, or notifies of a NoSuchElementException if no such items are emitted.
Observable<T>	lastOrDefault(T defaultValue) Returns an Observable that emits only the last item emitted by the source Observable, or a default item if the source Observable completes without emitting any items.
Observable<T>	lastOrDefault(T defaultValue, Func1T,java.lang.Boolean> predicate) Returns an Observable that emits only the last item emitted by the source Observable that satisfies a specified condition, or a default item if no such item is emitted by the source Observable.
Observable	lift(Observable.OperatorT> operator) This method requires advanced knowledge about building operators; please consider other standard composition methods first; Lifts a function to the current Observable and returns a new Observable that when subscribed to will pass the values of the current Observable through the Operator function.
Observable<T>	limit(int count) Returns an Observable that emits only the first count items emitted by the source Observable.
Observable	map(Func1T,? extends R> func) Returns an Observable that applies a specified function to each item emitted by the source Observable 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 Observable into emissions marked with their original types within Notification objects.
static Observable	merge(java.lang.IterableObservable> sequences) Flattens an Iterable of Observables into one Observable, without any transformation.
static Observable	merge(java.lang.IterableObservable> sequences, int maxConcurrent) Flattens an Iterable of Observables into one Observable, without any transformation, while limiting the number of concurrent subscriptions to these Observables.
static Observable	merge(ObservableObservable> source) Flattens an Observable that emits Observables into a single Observable that emits the items emitted by those Observables, without any transformation.
static Observable	merge(ObservableObservable> source, int maxConcurrent) Flattens an Observable that emits Observables into a single Observable that emits the items emitted by those Observables, without any transformation, while limiting the maximum number of concurrent subscriptions to these Observables.
static Observable	merge(Observable[] sequences) Flattens an Array of Observables into one Observable, without any transformation.
static Observable	merge(Observable[] sequences, int maxConcurrent) Flattens an Array of Observables into one Observable, without any transformation, while limiting the number of concurrent subscriptions to these Observables.
static Observable	merge(Observable t1, Observable t2) Flattens two Observables into a single Observable, without any transformation.
static Observable	merge(Observable t1, Observable t2, Observable t3) Flattens three Observables into a single Observable, without any transformation.
static Observable	merge(Observable t1, Observable t2, Observable t3, Observable t4) Flattens four Observables into a single Observable, without any transformation.
static Observable	merge(Observable t1, Observable t2, Observable t3, Observable t4, Observable t5) Flattens five Observables into a single Observable, without any transformation.
static Observable	merge(Observable t1, Observable t2, Observable t3, Observable t4, Observable t5, Observable t6) Flattens six Observables into a single Observable, without any transformation.
static Observable	merge(Observable t1, Observable t2, Observable t3, Observable t4, Observable t5, Observable t6, Observable t7) Flattens seven Observables into a single Observable, without any transformation.
static Observable	merge(Observable t1, Observable t2, Observable t3, Observable t4, Observable t5, Observable t6, Observable t7, Observable t8) Flattens eight Observables into a single Observable, without any transformation.
static Observable	merge(Observable t1, Observable t2, Observable t3, Observable t4, Observable t5, Observable t6, Observable t7, Observable t8, Observable t9) Flattens nine Observables into a single Observable, without any transformation.
static Observable	mergeDelayError(java.lang.IterableObservable> sequences) Flattens an Iterable of Observables into one Observable, in a way that allows an Observer to receive all successfully emitted items from each of the source Observables without being interrupted by an error notification from one of them.
static Observable	mergeDelayError(java.lang.IterableObservable> sequences, int maxConcurrent) Flattens an Iterable of Observables into one Observable, in a way that allows an Observer to receive all successfully emitted items from each of the source Observables without being interrupted by an error notification from one of them, while limiting the number of concurrent subscriptions to these Observables.
static Observable	mergeDelayError(ObservableObservable> source) Flattens an Observable that emits Observables into one Observable, in a way that allows an Observer to receive all successfully emitted items from all of the source Observables without being interrupted by an error notification from one of them.
static Observable	mergeDelayError(ObservableObservable> source, int maxConcurrent) Flattens an Observable that emits Observables into one Observable, in a way that allows an Observer to receive all successfully emitted items from all of the source Observables without being interrupted by an error notification from one of them, while limiting the number of concurrent subscriptions to these Observables.
static Observable	mergeDelayError(Observable t1, Observable t2) Flattens two Observables into one Observable, in a way that allows an Observer to receive all successfully emitted items from each of the source Observables without being interrupted by an error notification from one of them.
static Observable	mergeDelayError(Observable t1, Observable t2, Observable t3) Flattens three Observables into one Observable, in a way that allows an Observer to receive all successfully emitted items from all of the source Observables without being interrupted by an error notification from one of them.
static Observable	mergeDelayError(Observable t1, Observable t2, Observable t3, Observable t4) Flattens four Observables into one Observable, in a way that allows an Observer to receive all successfully emitted items from all of the source Observables without being interrupted by an error notification from one of them.
static Observable	mergeDelayError(Observable t1, Observable t2, Observable t3, Observable t4, Observable t5) Flattens five Observables into one Observable, in a way that allows an Observer to receive all successfully emitted items from all of the source Observables without being interrupted by an error notification from one of them.
static Observable	mergeDelayError(Observable t1, Observable t2, Observable t3, Observable t4, Observable t5, Observable t6) Flattens six Observables into one Observable, in a way that allows an Observer to receive all successfully emitted items from all of the source Observables without being interrupted by an error notification from one of them.
static Observable	mergeDelayError(Observable t1, Observable t2, Observable t3, Observable t4, Observable t5, Observable t6, Observable t7) Flattens seven Observables into one Observable, in a way that allows an Observer to receive all successfully emitted items from all of the source Observables without being interrupted by an error notification from one of them.
static Observable	mergeDelayError(Observable t1, Observable t2, Observable t3, Observable t4, Observable t5, Observable t6, Observable t7, Observable t8) Flattens eight Observables into one Observable, in a way that allows an Observer to receive all successfully emitted items from all of the source Observables without being interrupted by an error notification from one of them.
static Observable	mergeDelayError(Observable t1, Observable t2, Observable t3, Observable t4, Observable t5, Observable t6, Observable t7, Observable t8, Observable t9) Flattens nine Observables into one Observable, in a way that allows an Observer to receive all successfully emitted items from all of the source Observables without being interrupted by an error notification from one of them.
Observable<T>	mergeWith(ObservableT> t1) Flattens this and another Observable into a single Observable, without any transformation.
Observable<Observable<T>>	nest() Converts the source Observable into an Observable> that emits the source Observable as its single emission.
static Observable	never() Returns an Observable that never sends any items or notifications to an Observer.
Observable<T>	observeOn(Scheduler scheduler) Modifies an Observable to perform its emissions and notifications on a specified Scheduler, asynchronously with a bounded buffer of RxRingBuffer.SIZE slots.
Observable<T>	observeOn(Scheduler scheduler, boolean delayError) Modifies an Observable to perform its emissions and notifications on a specified Scheduler, asynchronously with a bounded buffer and optionally delays onError notifications.
Observable<T>	observeOn(Scheduler scheduler, boolean delayError, int bufferSize) Modifies an Observable to perform its emissions and notifications on a specified Scheduler, asynchronously with a bounded buffer of configurable size and optionally delays onError notifications.
Observable<T>	observeOn(Scheduler scheduler, int bufferSize) Modifies an Observable to perform its emissions and notifications on a specified Scheduler, asynchronously with a bounded buffer of configurable size.
Observable	ofType(java.lang.Class klass) Filters the items emitted by an Observable, only emitting those of the specified type.
Observable<T>	onBackpressureBuffer() Instructs an Observable that is emitting items faster than its observer can consume them to buffer these items indefinitely until they can be emitted.
Observable<T>	onBackpressureBuffer(long capacity) Instructs an Observable that is emitting items faster than its observer can consume them to buffer up to a given amount of items until they can be emitted.
Observable<T>	onBackpressureBuffer(long capacity, Action0 onOverflow) Instructs an Observable that is emitting items faster than its observer can consume them to buffer up to a given amount of items until they can be emitted.
Observable<T>	onBackpressureBuffer(long capacity, Action0 onOverflow, BackpressureOverflow.Strategy overflowStrategy) Instructs an Observable that is emitting items faster than its observer can consume them to buffer up to a given amount of items until they can be emitted.
Observable<T>	onBackpressureDrop() Instructs an Observable that is emitting items faster than its observer can consume them to discard, rather than emit, those items that its observer is not prepared to observe.
Observable<T>	onBackpressureDrop(Action1T> onDrop) Instructs an Observable that is emitting items faster than its observer can consume them to discard, rather than emit, those items that its observer is not prepared to observe.
Observable<T>	onBackpressureLatest() Instructs an Observable that is emitting items faster than its observer can consume them to hold onto the latest value and emit that on request.
Observable<T>	onErrorResumeNext(Func1ObservableT>> resumeFunction) Instructs an Observable to pass control to another Observable rather than invoking onError if it encounters an error.
Observable<T>	onErrorResumeNext(ObservableT> resumeSequence) Instructs an Observable to pass control to another Observable rather than invoking onError if it encounters an error.
Observable<T>	onErrorReturn(Func1T> resumeFunction) Instructs an Observable to emit an item (returned by a specified function) rather than invoking onError if it encounters an error.
Observable<T>	onExceptionResumeNext(ObservableT> resumeSequence) Instructs an Observable to pass control to another Observable rather than invoking onError if it encounters an Exception.
Observable<T>	onTerminateDetach() Nulls out references to the upstream producer and downstream Subscriber if the sequence is terminated or downstream unsubscribes.
ConnectableObservable<T>	publish() Returns a ConnectableObservable, which is a variety of Observable that waits until its connect method is called before it begins emitting items to those Observers that have subscribed to it.
Observable	publish(Func1Observable<T>,? extends Observable> 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	range(int start, int count) Returns an Observable that emits a sequence of Integers within a specified range.
static Observable	range(int start, int count, Scheduler scheduler) Returns an Observable that emits a sequence of Integers within a specified range, on a specified Scheduler.
Observable<T>	rebatchRequests(int n) Requests n initially from the upstream and then 75% of n subsequently after 75% of n values have been emitted to the downstream.
Observable<T>	reduce(Func2<T,T,T> accumulator) Returns an Observable that applies a specified accumulator function to the first item emitted by a source Observable, then feeds the result of that function along with the second item emitted by the source Observable into the same function, and so on until all items have been emitted by the source Observable, and emits the final result from the final call to your function as its sole item.
Observable	reduce(R initialValue, Func2T,R> accumulator) Returns an Observable that applies a specified accumulator function to the first item emitted by a source Observable and a specified seed value, then feeds the result of that function along with the second item emitted by an Observable into the same function, and so on until all items have been emitted by the source Observable, 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 Observable indefinitely.
Observable<T>	repeat(long count) Returns an Observable that repeats the sequence of items emitted by the source Observable at most count times.
Observable<T>	repeat(long count, Scheduler scheduler) Returns an Observable that repeats the sequence of items emitted by the source Observable at most count times, on a particular Scheduler.
Observable<T>	repeat(Scheduler scheduler) Returns an Observable that repeats the sequence of items emitted by the source Observable indefinitely, on a particular Scheduler.
Observable<T>	repeatWhen(Func1Observable,? extends Observable> notificationHandler) Returns an Observable that emits the same values as the source Observable with the exception of an onCompleted.
Observable<T>	repeatWhen(Func1Observable,? extends Observable> notificationHandler, Scheduler scheduler) Returns an Observable that emits the same values as the source Observable with the exception of an onCompleted.
ConnectableObservable<T>	replay() Returns a ConnectableObservable that shares a single subscription to the underlying Observable that will replay all of its items and notifications to any future Observer.
Observable	replay(Func1Observable<T>,? extends Observable> 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 Observable.
Observable	replay(Func1Observable<T>,? extends Observable> 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 Observable, replaying bufferSize notifications.
Observable	replay(Func1Observable<T>,? extends Observable> selector, int bufferSize, long time, java.util.concurrent.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 Observable, replaying no more than bufferSize items that were emitted within a specified time window.
Observable	replay(Func1Observable<T>,? extends Observable> selector, int bufferSize, long time, java.util.concurrent.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 Observable, replaying no more than bufferSize items that were emitted within a specified time window.
Observable	replay(Func1Observable<T>,? extends Observable> 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 Observable, replaying a maximum of bufferSize items.
Observable	replay(Func1Observable<T>,? extends Observable> selector, long time, java.util.concurrent.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 Observable, replaying all items that were emitted within a specified time window.
Observable	replay(Func1Observable<T>,? extends Observable> selector, long time, java.util.concurrent.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 Observable, replaying all items that were emitted within a specified time window.
Observable	replay(Func1Observable<T>,? extends Observable> 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 Observable.
ConnectableObservable<T>	replay(int bufferSize) Returns a ConnectableObservable that shares a single subscription to the source Observable that replays at most bufferSize items emitted by that Observable.
ConnectableObservable<T>	replay(int bufferSize, long time, java.util.concurrent.TimeUnit unit) Returns a ConnectableObservable that shares a single subscription to the source Observable and replays at most bufferSize items that were emitted during a specified time window.
ConnectableObservable<T>	replay(int bufferSize, long time, java.util.concurrent.TimeUnit unit, Scheduler scheduler) Returns a ConnectableObservable that shares a single subscription to the source Observable 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 Observable and replays at most bufferSize items emitted by that Observable.
ConnectableObservable<T>	replay(long time, java.util.concurrent.TimeUnit unit) Returns a ConnectableObservable that shares a single subscription to the source Observable and replays all items emitted by that Observable within a specified time window.
ConnectableObservable<T>	replay(long time, java.util.concurrent.TimeUnit unit, Scheduler scheduler) Returns a ConnectableObservable that shares a single subscription to the source Observable and replays all items emitted by that Observable within a specified time window.
ConnectableObservable<T>	replay(Scheduler scheduler) Returns a ConnectableObservable that shares a single subscription to the source Observable 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 Observable, resubscribing to it if it calls onError (infinite retry count).
Observable<T>	retry(Func2 predicate) Returns an Observable that mirrors the source Observable, resubscribing to it if it calls onError and the predicate returns true for that specific exception and retry count.
Observable<T>	retry(long count) Returns an Observable that mirrors the source Observable, resubscribing to it if it calls onError up to a specified number of retries.
Observable<T>	retryWhen(Func1Observable,? extends Observable> notificationHandler) Returns an Observable that emits the same values as the source observable with the exception of an onError.
Observable<T>	retryWhen(Func1Observable,? extends Observable> notificationHandler, Scheduler scheduler) Returns an Observable that emits the same values as the source observable with the exception of an onError.
Observable<T>	sample(long period, java.util.concurrent.TimeUnit unit) Returns an Observable that emits the most recently emitted item (if any) emitted by the source Observable within periodic time intervals.
Observable<T>	sample(long period, java.util.concurrent.TimeUnit unit, Scheduler scheduler) Returns an Observable that emits the most recently emitted item (if any) emitted by the source Observable within periodic time intervals, where the intervals are defined on a particular Scheduler.
Observable<T>	sample(Observable sampler) Returns an Observable that, when the specified sampler Observable emits an item or completes, emits the most recently emitted item (if any) emitted by the source Observable since the previous emission from the sampler Observable.
Observable<T>	scan(Func2<T,T,T> accumulator) Returns an Observable that applies a specified accumulator function to the first item emitted by a source Observable, then feeds the result of that function along with the second item emitted by the source Observable into the same function, and so on until all items have been emitted by the source Observable, emitting the result of each of these iterations.
Observable	scan(R initialValue, Func2T,R> accumulator) Returns an Observable that applies a specified accumulator function to the first item emitted by a source Observable and a seed value, then feeds the result of that function along with the second item emitted by the source Observable into the same function, and so on until all items have been emitted by the source Observable, emitting the result of each of these iterations.
static Observable	sequenceEqual(Observable first, Observable second) Returns an Observable that emits a Boolean value that indicates whether two Observable sequences are the same by comparing the items emitted by each Observable pairwise.
static Observable	sequenceEqual(Observable first, Observable second, Func2 equality) Returns an Observable that emits a Boolean value that indicates whether two Observable sequences are the same by comparing the items emitted by each Observable pairwise based on the results of a specified equality function.
Observable<T>	serialize() Forces an Observable's emissions and notifications to be serialized and for it to obey the Observable contract in other ways.
Observable<T>	share() Returns a new Observable that multicasts (shares) the original Observable.
Observable<T>	single() Returns an Observable that emits the single item emitted by the source Observable, if that Observable emits only a single item.
Observable<T>	single(Func1T,java.lang.Boolean> predicate) Returns an Observable that emits the single item emitted by the source Observable that matches a specified predicate, if that Observable emits one such item.
Observable<T>	singleOrDefault(T defaultValue) Returns an Observable that emits the single item emitted by the source Observable, if that Observable emits only a single item, or a default item if the source Observable emits no items.
Observable<T>	singleOrDefault(T defaultValue, Func1T,java.lang.Boolean> predicate) Returns an Observable that emits the single item emitted by the source Observable that matches a predicate, if that Observable emits only one such item, or a default item if the source Observable emits no such items.
Observable<T>	skip(int count) Returns an Observable that skips the first count items emitted by the source Observable and emits the remainder.
Observable<T>	skip(long time, java.util.concurrent.TimeUnit unit) Returns an Observable that skips values emitted by the source Observable before a specified time window elapses.
Observable<T>	skip(long time, java.util.concurrent.TimeUnit unit, Scheduler scheduler) Returns an Observable that skips values emitted by the source Observable 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 Observable.
Observable<T>	skipLast(long time, java.util.concurrent.TimeUnit unit) Returns an Observable that drops items emitted by the source Observable during a specified time window before the source completes.
Observable<T>	skipLast(long time, java.util.concurrent.TimeUnit unit, Scheduler scheduler) Returns an Observable that drops items emitted by the source Observable during a specified time window (defined on a specified scheduler) before the source completes.
Observable<T>	skipUntil(Observable other) Returns an Observable that skips items emitted by the source Observable until a second Observable emits an item.
Observable<T>	skipWhile(Func1T,java.lang.Boolean> predicate) Returns an Observable that skips all items emitted by the source Observable 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 Observable, in a sorted order.
Observable<T>	sorted(Func2T,? super T,java.lang.Integer> sortFunction) Returns an Observable that emits the events emitted by source Observable, in a sorted order based on a specified comparison function.
Observable<T>	startWith(java.lang.Iterable<T> values) Returns an Observable that emits the items in a specified Iterable before it begins to emit items emitted by the source Observable.
Observable<T>	startWith(Observable<T> values) Returns an Observable that emits the items in a specified Observable before it begins to emit items emitted by the source Observable.
Observable<T>	startWith(T t1) Returns an Observable that emits a specified item before it begins to emit items emitted by the source Observable.
Observable<T>	startWith(T t1, T t2) Returns an Observable that emits the specified items before it begins to emit items emitted by the source Observable.
Observable<T>	startWith(T t1, T t2, T t3) Returns an Observable that emits the specified items before it begins to emit items emitted by the source Observable.
Observable<T>	startWith(T t1, T t2, T t3, T t4) Returns an Observable that emits the specified items before it begins to emit items emitted by the source Observable.
Observable<T>	startWith(T t1, T t2, T t3, T t4, T t5) Returns an Observable that emits the specified items before it begins to emit items emitted by the source Observable.
Observable<T>	startWith(T t1, T t2, T t3, T t4, T t5, T t6) Returns an Observable that emits the specified items before it begins to emit items emitted by the source Observable.
Observable<T>	startWith(T t1, T t2, T t3, T t4, T t5, T t6, T t7) Returns an Observable that emits the specified items before it begins to emit items emitted by the source Observable.
Observable<T>	startWith(T t1, T t2, T t3, T t4, T t5, T t6, T t7, T t8) Returns an Observable that emits the specified items before it begins to emit items emitted by the source Observable.
Observable<T>	startWith(T t1, T t2, T t3, T t4, T t5, T t6, T t7, T t8, T t9) Returns an Observable that emits the specified items before it begins to emit items emitted by the source Observable.
Subscription	subscribe() Subscribes to an Observable and ignores onNext and onCompleted emissions.
Subscription	subscribe(Action1T> onNext) Subscribes to an Observable and provides a callback to handle the items it emits.
Subscription	subscribe(Action1T> onNext, Action1 onError) Subscribes to an Observable and provides callbacks to handle the items it emits and any error notification it issues.
Subscription	subscribe(Action1T> onNext, Action1 onError, Action0 onCompleted) Subscribes to an Observable and provides callbacks to handle the items it emits and any error or completion notification it issues.
Subscription	subscribe(ObserverT> observer) Subscribes to an Observable and provides an Observer that implements functions to handle the items the Observable emits and any error or completion notification it issues.
Subscription	subscribe(SubscriberT> subscriber) Subscribes to an Observable and provides a Subscriber that implements functions to handle the items the Observable emits and any error or completion notification it issues.
Observable<T>	subscribeOn(Scheduler scheduler) Asynchronously subscribes Observers to this Observable on the specified Scheduler.
Observable<T>	subscribeOn(Scheduler scheduler, boolean requestOn) Asynchronously subscribes Observers to this Observable on the specified Scheduler and optionally reroutes requests from other threads to the same Scheduler thread.
Observable<T>	switchIfEmpty(ObservableT> alternate) Returns an Observable that emits the items emitted by the source Observable or the items of an alternate Observable if the source Observable is empty.
Observable	switchMap(Func1T,? extends Observable> func) Returns a new Observable by applying a function that you supply to each item emitted by the source Observable that returns an Observable, and then emitting the items emitted by the most recently emitted of these Observables.
Observable	switchMapDelayError(Func1T,? extends Observable> func) Returns a new Observable by applying a function that you supply to each item emitted by the source Observable that returns an Observable, and then emitting the items emitted by the most recently emitted of these Observables and delays any error until all Observables terminate.
static Observable	switchOnNext(ObservableObservable> sequenceOfSequences) Converts an Observable that emits Observables into an Observable that emits the items emitted by the most recently emitted of those Observables.
static Observable	switchOnNextDelayError(ObservableObservable> sequenceOfSequences) Converts an Observable that emits Observables into an Observable that emits the items emitted by the most recently emitted of those Observables and delays any exception until all Observables terminate.
Observable<T>	take(int count) Returns an Observable that emits only the first count items emitted by the source Observable.
Observable<T>	take(long time, java.util.concurrent.TimeUnit unit) Returns an Observable that emits those items emitted by source Observable before a specified time runs out.
Observable<T>	take(long time, java.util.concurrent.TimeUnit unit, Scheduler scheduler) Returns an Observable that emits those items emitted by source Observable before a specified time (on a specified Scheduler) runs out.
Observable<T>	takeFirst(Func1T,java.lang.Boolean> predicate) Returns an Observable that emits only the very first item emitted by the source Observable that satisfies a specified condition.
Observable<T>	takeLast(int count) Returns an Observable that emits at most the last count items emitted by the source Observable.
Observable<T>	takeLast(int count, long time, java.util.concurrent.TimeUnit unit) Returns an Observable that emits at most a specified number of items from the source Observable that were emitted in a specified window of time before the Observable completed.
Observable<T>	takeLast(int count, long time, java.util.concurrent.TimeUnit unit, Scheduler scheduler) Returns an Observable that emits at most a specified number of items from the source Observable that were emitted in a specified window of time before the Observable completed, where the timing information is provided by a given Scheduler.
Observable<T>	takeLast(long time, java.util.concurrent.TimeUnit unit) Returns an Observable that emits the items from the source Observable that were emitted in a specified window of time before the Observable completed.
Observable<T>	takeLast(long time, java.util.concurrent.TimeUnit unit, Scheduler scheduler) Returns an Observable that emits the items from the source Observable that were emitted in a specified window of time before the Observable completed, where the timing information is provided by a specified Scheduler.
ObservableT>>	takeLastBuffer(int count) Returns an Observable that emits a single List containing at most the last count elements emitted by the source Observable.
ObservableT>>	takeLastBuffer(int count, long time, java.util.concurrent.TimeUnit unit) Returns an Observable that emits a single List containing at most count items from the source Observable that were emitted during a specified window of time before the source Observable completed.
ObservableT>>	takeLastBuffer(int count, long time, java.util.concurrent.TimeUnit unit, Scheduler scheduler) Returns an Observable that emits a single List containing at most count items from the source Observable that were emitted during a specified window of time (on a specified Scheduler) before the source Observable completed.
ObservableT>>	takeLastBuffer(long time, java.util.concurrent.TimeUnit unit) Returns an Observable that emits a single List containing those items from the source Observable that were emitted during a specified window of time before the source Observable completed.
ObservableT>>	takeLastBuffer(long time, java.util.concurrent.TimeUnit unit, Scheduler scheduler) Returns an Observable that emits a single List containing those items from the source Observable that were emitted during a specified window of time before the source Observable completed, where the timing information is provided by the given Scheduler.
Observable<T>	takeUntil(Func1T,java.lang.Boolean> 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>	takeUntil(Observable other) Returns an Observable that emits the items emitted by the source Observable until a second Observable emits an item.
Observable<T>	takeWhile(Func1T,java.lang.Boolean> predicate) Returns an Observable that emits items emitted by the source Observable so long as each item satisfied a specified condition, and then completes as soon as this condition is not satisfied.
AssertableSubscriber<T>	test() Creates a AssertableSubscriber that requests Long.MAX_VALUE and subscribes it to this Observable.
AssertableSubscriber<T>	test(long initialRequestAmount) Creates an AssertableSubscriber with the initial request amount and subscribes it to this Observable.
Observable<T>	throttleFirst(long windowDuration, java.util.concurrent.TimeUnit unit) Returns an Observable that emits only the first item emitted by the source Observable during sequential time windows of a specified duration.
Observable<T>	throttleFirst(long skipDuration, java.util.concurrent.TimeUnit unit, Scheduler scheduler) Returns an Observable that emits only the first item emitted by the source Observable during sequential time windows of a specified duration, where the windows are managed by a specified Scheduler.
Observable<T>	throttleLast(long intervalDuration, java.util.concurrent.TimeUnit unit) Returns an Observable that emits only the last item emitted by the source Observable during sequential time windows of a specified duration.
Observable<T>	throttleLast(long intervalDuration, java.util.concurrent.TimeUnit unit, Scheduler scheduler) Returns an Observable that emits only the last item emitted by the source Observable during sequential time windows of a specified duration, where the duration is governed by a specified Scheduler.
Observable<T>	throttleWithTimeout(long timeout, java.util.concurrent.TimeUnit unit) Returns an Observable that only emits those items emitted by the source Observable that are not followed by another emitted item within a specified time window.
Observable<T>	throttleWithTimeout(long timeout, java.util.concurrent.TimeUnit unit, Scheduler scheduler) Returns an Observable that only emits those items emitted by the source Observable that are not followed by another emitted item within a specified time window, where the time window is governed by a specified Scheduler.
Observable<TimeInterval<T>>	timeInterval() Returns an Observable that emits records of the time interval between consecutive items emitted by the source Observable.
Observable<TimeInterval<T>>	timeInterval(Scheduler scheduler) Returns an Observable that emits records of the time interval between consecutive items emitted by the source Observable, where this interval is computed on a specified Scheduler.
Observable<T>	timeout(Func0Observable> firstTimeoutSelector, Func1T,? extends Observable> timeoutSelector) Returns an Observable that mirrors the source Observable, but notifies observers of a TimeoutException if either the first item emitted by the source Observable or any subsequent item doesn't arrive within time windows defined by other Observables.
Observable<T>	timeout(Func0Observable> firstTimeoutSelector, Func1T,? extends Observable> timeoutSelector, ObservableT> other) Returns an Observable that mirrors the source Observable, but switches to a fallback Observable if either the first item emitted by the source Observable or any subsequent item doesn't arrive within time windows defined by other Observables.
Observable<T>	timeout(Func1T,? extends Observable> timeoutSelector) Returns an Observable that mirrors the source Observable, but notifies observers of a TimeoutException if an item emitted by the source Observable doesn't arrive within a window of time after the emission of the previous item, where that period of time is measured by an Observable that is a function of the previous item.
Observable<T>	timeout(Func1T,? extends Observable> timeoutSelector, ObservableT> other) Returns an Observable that mirrors the source Observable, but that switches to a fallback Observable if an item emitted by the source Observable doesn't arrive within a window of time after the emission of the previous item, where that period of time is measured by an Observable that is a function of the previous item.
Observable<T>	timeout(long timeout, java.util.concurrent.TimeUnit timeUnit) Returns an Observable that mirrors the source Observable but applies a timeout policy for each emitted item.
Observable<T>	timeout(long timeout, java.util.concurrent.TimeUnit timeUnit, ObservableT> other) Returns an Observable that mirrors the source Observable but applies a timeout policy for each emitted item.
Observable<T>	timeout(long timeout, java.util.concurrent.TimeUnit timeUnit, ObservableT> other, Scheduler scheduler) Returns an Observable that mirrors the source Observable but applies a timeout policy for each emitted item using a specified Scheduler.
Observable<T>	timeout(long timeout, java.util.concurrent.TimeUnit timeUnit, Scheduler scheduler) Returns an Observable that mirrors the source Observable but applies a timeout policy for each emitted item, where this policy is governed on a specified Scheduler.
static Observable	timer(long initialDelay, long period, java.util.concurrent.TimeUnit unit) Deprecated. use interval(long, long, TimeUnit) instead
static Observable	timer(long initialDelay, long period, java.util.concurrent.TimeUnit unit, Scheduler scheduler) Deprecated. use interval(long, long, TimeUnit, Scheduler) instead
static Observable	timer(long delay, java.util.concurrent.TimeUnit unit) Returns an Observable that emits 0L after a specified delay, and then completes.
static Observable	timer(long delay, java.util.concurrent.TimeUnit unit, Scheduler scheduler) Returns an Observable that emits 0L after a specified delay, on a specified Scheduler, and then completes.
Observable<Timestamped<T>>	timestamp() Returns an Observable that emits each item emitted by the source Observable, wrapped in a Timestamped object.
Observable<Timestamped<T>>	timestamp(Scheduler scheduler) Returns an Observable that emits each item emitted by the source Observable, wrapped in a Timestamped object whose timestamps are provided by a specified Scheduler.
R	to(Func1Observable<T>,R> converter) Calls the specified converter function during assembly time and returns its resulting value.
BlockingObservable<T>	toBlocking() Converts an Observable into a BlockingObservable (an Observable with blocking operators).
Completable	toCompletable() Returns a Completable that discards all onNext emissions (similar to ignoreAllElements()) and calls onCompleted when this source observable calls onCompleted.
ObservableT>>	toList() Returns an Observable that emits a single item, a list composed of all the items emitted by the source Observable.
ObservableT>>	toMap(Func1T,? extends K> keySelector) Returns an Observable that emits a single HashMap containing all items emitted by the source Observable, mapped by the keys returned by a specified keySelector function.
Observable>	toMap(Func1T,? extends K> keySelector, Func1T,? extends V> valueSelector) Returns an Observable that emits a single HashMap containing values corresponding to items emitted by the source Observable, mapped by the keys returned by a specified keySelector function.
Observable>	toMap(Func1T,? extends K> keySelector, Func1T,? extends V> valueSelector, Func0> mapFactory) Returns an Observable that emits a single Map, returned by a specified mapFactory function, that contains keys and values extracted from the items emitted by the source Observable.
ObservableT>>>	toMultimap(Func1T,? extends K> keySelector) Returns an Observable that emits a single HashMap that contains an ArrayList of items emitted by the source Observable keyed by a specified keySelector function.
Observable>>	toMultimap(Func1T,? extends K> keySelector, Func1T,? extends V> valueSelector) Returns an Observable that emits a single HashMap that contains an ArrayList of values extracted by a specified valueSelector function from items emitted by the source Observable, keyed by a specified keySelector function.
Observable>>	toMultimap(Func1T,? extends K> keySelector, Func1T,? extends V> valueSelector, Func0>> mapFactory) Returns an Observable that emits a single Map, returned by a specified mapFactory function, that contains an ArrayList of values, extracted by a specified valueSelector function from items emitted by the source Observable and keyed by the keySelector function.
Observable>>	toMultimap(Func1T,? extends K> keySelector, Func1T,? extends V> valueSelector, Func0>> mapFactory, Func1> collectionFactory) Returns an Observable 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 Observable, and keyed by the keySelector function.
Single<T>	toSingle() Returns a Single that emits the single item emitted by the source Observable, if that Observable emits only a single item.
ObservableT>>	toSortedList() Returns an Observable that emits a list that contains the items emitted by the source Observable, in a sorted order.
ObservableT>>	toSortedList(Func2T,? super T,java.lang.Integer> sortFunction) Returns an Observable that emits a list that contains the items emitted by the source Observable, in a sorted order based on a specified comparison function.
ObservableT>>	toSortedList(Func2T,? super T,java.lang.Integer> sortFunction, int initialCapacity) Returns an Observable that emits a list that contains the items emitted by the source Observable, in a sorted order based on a specified comparison function.
ObservableT>>	toSortedList(int initialCapacity) Returns an Observable that emits a list that contains the items emitted by the source Observable, in a sorted order.
static Observable	unsafeCreate(Observable.OnSubscribe f) Returns an Observable that executes the given OnSubscribe action for each individual Subscriber that subscribes; unsubscription and backpressure must be implemented manually.
Subscription	unsafeSubscribe(SubscriberT> subscriber) Subscribes to an Observable and invokes Observable.OnSubscribe function without any contract protection, error handling, unsubscribe, or execution hooks.
Observable<T>	unsubscribeOn(Scheduler scheduler) Modifies the source Observable so that subscribers will unsubscribe from it on a specified Scheduler.
static Observable	using(Func0 resourceFactory, Func1Observable> observableFactory, Action1 disposeAction) Constructs an Observable that creates a dependent resource object which is disposed of on unsubscription.
static Observable	using(Func0 resourceFactory, Func1Observable> observableFactory, Action1 disposeAction, boolean disposeEagerly) Constructs an Observable that creates a dependent resource object which is disposed of just before termination if you have set disposeEagerly to true and unsubscription does not occur before termination.
Observable<Observable<T>>	window(Func0Observable> closingSelector) Returns an Observable that emits windows of items it collects from the source Observable.
Observable<Observable<T>>	window(int count) Returns an Observable that emits windows of items it collects from the source Observable.
Observable<Observable<T>>	window(int count, int skip) Returns an Observable that emits windows of items it collects from the source Observable.
Observable<Observable<T>>	window(long timespan, long timeshift, java.util.concurrent.TimeUnit unit) Returns an Observable that emits windows of items it collects from the source Observable.
Observable<Observable<T>>	window(long timespan, long timeshift, java.util.concurrent.TimeUnit unit, int count, Scheduler scheduler) Returns an Observable that emits windows of items it collects from the source Observable.
Observable<Observable<T>>	window(long timespan, long timeshift, java.util.concurrent.TimeUnit unit, Scheduler scheduler) Returns an Observable that emits windows of items it collects from the source Observable.
Observable<Observable<T>>	window(long timespan, java.util.concurrent.TimeUnit unit) Returns an Observable that emits windows of items it collects from the source Observable.
Observable<Observable<T>>	window(long timespan, java.util.concurrent.TimeUnit unit, int count) Returns an Observable that emits windows of items it collects from the source Observable.
Observable<Observable<T>>	window(long timespan, java.util.concurrent.TimeUnit unit, int count, Scheduler scheduler) Returns an Observable that emits windows of items it collects from the source Observable.
Observable<Observable<T>>	window(long timespan, java.util.concurrent.TimeUnit unit, Scheduler scheduler) Returns an Observable that emits windows of items it collects from the source Observable.
Observable<Observable<T>>	window(Observable windowOpenings, Func1Observable> closingSelector) Returns an Observable that emits windows of items it collects from the source Observable.
Observable<Observable<T>>	window(Observable boundary) Returns an Observable that emits non-overlapping windows of items it collects from the source Observable where the boundary of each window is determined by the items emitted from a specified boundary-governing Observable.
Observable	withLatestFrom(java.lang.Iterable<Observable> others, FuncN combiner) Combines the value emission from this Observable with the latest emissions from the other Observables via a function to produce the output item.
Observable	withLatestFrom(Observable[] others, FuncN combiner) Combines the value emission from this Observable with the latest emissions from the other Observables via a function to produce the output item.
Observable	withLatestFrom(Observable other, Func2T,? super U,? extends R> resultSelector) Merges the specified Observable into this Observable sequence by using the resultSelector function only when the source Observable (this instance) emits an item.
Observable	withLatestFrom(Observable o1, Observable o2, Func3T,? super T1,? super T2,R> combiner) Combines the value emission from this Observable with the latest emissions from the other Observables via a function to produce the output item.
Observable	withLatestFrom(Observable o1, Observable o2, Observable o3, Func4T,? super T1,? super T2,? super T3,R> combiner) Combines the value emission from this Observable with the latest emissions from the other Observables via a function to produce the output item.
Observable	withLatestFrom(Observable o1, Observable o2, Observable o3, Observable o4, Func5T,? super T1,? super T2,? super T3,? super T4,R> combiner) Combines the value emission from this Observable with the latest emissions from the other Observables via a function to produce the output item.
Observable	withLatestFrom(Observable o1, Observable o2, Observable o3, Observable o4, Observable o5, Func6T,? super T1,? super T2,? super T3,? super T4,? super T5,R> combiner) Combines the value emission from this Observable with the latest emissions from the other Observables via a function to produce the output item.
Observable	withLatestFrom(Observable o1, Observable o2, Observable o3, Observable o4, Observable o5, Observable o6, Func7T,? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,R> combiner) Combines the value emission from this Observable with the latest emissions from the other Observables via a function to produce the output item.
Observable	withLatestFrom(Observable o1, Observable o2, Observable o3, Observable o4, Observable o5, Observable o6, Observable o7, Func8T,? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,R> combiner) Combines the value emission from this Observable with the latest emissions from the other Observables via a function to produce the output item.
Observable	withLatestFrom(Observable o1, Observable o2, Observable o3, Observable o4, Observable o5, Observable o6, Observable o7, Observable o8, Func9T,? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,R> combiner) Combines the value emission from this Observable with the latest emissions from the other Observables via a function to produce the output item.
static Observable	zip(java.lang.IterableObservable> ws, FuncN zipFunction) 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 Observables.
static Observable	zip(Observable[] ws, FuncN zipFunction) 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 Observables.
static Observable	zip(ObservableObservable> ws, FuncN zipFunction) Returns an Observable that emits the results of a specified combiner function applied to combinations of n items emitted, in sequence, by the n Observables emitted by a specified Observable.
static Observable	zip(Observable o1, Observable o2, Func2 zipFunction) Returns an Observable that emits the results of a specified combiner function applied to combinations of two items emitted, in sequence, by two other Observables.
static Observable	zip(Observable o1, Observable o2, Observable o3, Func3 zipFunction) Returns an Observable that emits the results of a specified combiner function applied to combinations of three items emitted, in sequence, by three other Observables.
static Observable	zip(Observable o1, Observable o2, Observable o3, Observable o4, Func4 zipFunction) Returns an Observable that emits the results of a specified combiner function applied to combinations of four items emitted, in sequence, by four other Observables.
static Observable	zip(Observable o1, Observable o2, Observable o3, Observable o4, Observable o5, Func5 zipFunction) Returns an Observable that emits the results of a specified combiner function applied to combinations of five items emitted, in sequence, by five other Observables.
static Observable	zip(Observable o1, Observable o2, Observable o3, Observable o4, Observable o5, Observable o6, Func6 zipFunction) Returns an Observable that emits the results of a specified combiner function applied to combinations of six items emitted, in sequence, by six other Observables.
static Observable	zip(Observable o1, Observable o2, Observable o3, Observable o4, Observable o5, Observable o6, Observable o7, Func7 zipFunction) Returns an Observable that emits the results of a specified combiner function applied to combinations of seven items emitted, in sequence, by seven other Observables.
static Observable	zip(Observable o1, Observable o2, Observable o3, Observable o4, Observable o5, Observable o6, Observable o7, Observable o8, Func8 zipFunction) Returns an Observable that emits the results of a specified combiner function applied to combinations of eight items emitted, in sequence, by eight other Observables.
static Observable	zip(Observable o1, Observable o2, Observable o3, Observable o4, Observable o5, Observable o6, Observable o7, Observable o8, Observable o9, Func9 zipFunction) Returns an Observable that emits the results of a specified combiner function applied to combinations of nine items emitted, in sequence, by nine other Observables.
Observable	zipWith(java.lang.Iterable other, Func2T,? super T2,? extends R> zipFunction) Returns an Observable that emits items that are the result of applying a specified function to pairs of values, one each from the source Observable and a specified Iterable sequence.
Observable	zipWith(Observable other, Func2T,? super T2,? extends R> zipFunction) Returns an Observable that emits items that are the result of applying a specified function to pairs of values, one each from the source Observable and another specified Observable.

Methods inherited from class java.lang.Object

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

Constructor Detail

Observable

protected Observable(Observable.OnSubscribe<T> f)

Creates an Observable with a Function to execute when it is subscribed to.

Note: Use unsafeCreate(OnSubscribe) to create an Observable, instead of this constructor, unless you specifically have a need for inheritance.

Parameters:

f - Observable.OnSubscribe to be executed when subscribe(Subscriber) is called

Method Detail

create

@Deprecated
public static  Observable create(Observable.OnSubscribe f)

Deprecated. 1.2.7 - inherently unsafe, use the other create() methods for basic cases or see unsafeCreate(OnSubscribe) for advanced cases (such as custom operators)

Constructs an Observable in an unsafe manner, that is, unsubscription and backpressure handling is the responsibility of the OnSubscribe implementation.

Type Parameters:

T - the value type emitted

Parameters:

f - the callback to execute for each individual Subscriber that subscribes to the returned Observable

Returns:

the new Observable instance

See Also:

create(SyncOnSubscribe), create(AsyncOnSubscribe), create(Action1, rx.Emitter.BackpressureMode)

create

public static  Observable create(Action1<Emitter> emitter,
                                       Emitter.BackpressureMode backpressure)

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

Example:

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

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

     AutoCloseable c = api.someMethod(listener);

     emitter.setCancellation(c::close);

 }, BackpressureMode.BUFFER);
 

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

History: 1.2.7 - experimental

Type Parameters:

T - the element type

Parameters:

emitter - the emitter that is called when a Subscriber subscribes to the returned Observable

backpressure - the backpressure mode to apply if the downstream Subscriber doesn't request (fast) enough

Returns:

the new Observable instance

Since:

1.3

See Also:

Emitter, Emitter.BackpressureMode, Cancellable

unsafeCreate

public static  Observable unsafeCreate(Observable.OnSubscribe f)

Returns an Observable that executes the given OnSubscribe action for each individual Subscriber that subscribes; unsubscription and backpressure must be implemented manually.

Write the function you pass to create so that it behaves as an Observable: It should invoke the Subscriber's onNext, onError, and onCompleted methods appropriately.

A well-formed Observable must invoke either the Subscriber's onCompleted method exactly once or its onError method exactly once.

See Rx Design Guidelines (PDF) for detailed information.

Backpressure:

The OnSubscribe instance provided is responsible to be backpressure-aware or document the fact that the consumer of the returned Observable has to apply one of the onBackpressureXXX operators.

Scheduler:

unsafeCreate does not operate by default on a particular Scheduler.

History: 1.2.7 - experimental

Type Parameters:

T - the type of the items that this Observable emits

Parameters:

f - a function that accepts an Subscriber, and invokes its onNext, onError, and onCompleted methods as appropriate

Returns:

an Observable that, when a Subscriber subscribes to it, will execute the specified function

Since:

1.3

See Also:

ReactiveX operators documentation: Create

create

public static  Observable create(SyncOnSubscribe syncOnSubscribe)

Returns an Observable that respects the back-pressure semantics. When the returned Observable is subscribed to it will initiate the given SyncOnSubscribe's life cycle for generating events.

Note: the SyncOnSubscribe provides a generic way to fulfill data by iterating over a (potentially stateful) function (e.g. reading data off of a channel, a parser, ). If your data comes directly from an asynchronous/potentially concurrent source then consider using the asynchronous overload.

See Rx Design Guidelines (PDF) for detailed information.

Backpressure:

The operator honors backpressure and generates values on-demand (when requested).

Scheduler:

create does not operate by default on a particular Scheduler.

Type Parameters:

T - the type of the items that this Observable emits

S - the state type

Parameters:

syncOnSubscribe - an implementation of SyncOnSubscribe. There are many static creation methods on the class for convenience.

Returns:

an Observable that, when a Subscriber subscribes to it, will execute the specified function

Since:

1.2

See Also:

SyncOnSubscribe.createSingleState(Func0, Action2), SyncOnSubscribe.createSingleState(Func0, Action2, Action1), SyncOnSubscribe.createStateful(Func0, Func2), SyncOnSubscribe.createStateful(Func0, Func2, Action1), SyncOnSubscribe.createStateless(Action1), SyncOnSubscribe.createStateless(Action1, Action0), ReactiveX operators documentation: Create

create

@Beta
public static  Observable create(AsyncOnSubscribe asyncOnSubscribe)

Returns an Observable that respects the back-pressure semantics. When the returned Observable is subscribed to it will initiate the given AsyncOnSubscribe's life cycle for generating events.

Note: the AsyncOnSubscribe is useful for observable sources of data that are necessarily asynchronous (RPC, external services, etc). Typically most use cases can be solved with the synchronous overload.

See Rx Design Guidelines (PDF) for detailed information.

Backpressure:

The operator honors backpressure and generates values on-demand (when requested).

Scheduler:

create does not operate by default on a particular Scheduler.

Type Parameters:

T - the type of the items that this Observable emits

S - the state type

Parameters:

asyncOnSubscribe - an implementation of AsyncOnSubscribe. There are many static creation methods on the class for convenience.

Returns:

an Observable that, when a Subscriber subscribes to it, will execute the specified function

Since:

1.3 - beta

See Also:

AsyncOnSubscribe.createSingleState(Func0, Action3), AsyncOnSubscribe.createSingleState(Func0, Action3, Action1), AsyncOnSubscribe.createStateful(Func0, Func3), AsyncOnSubscribe.createStateful(Func0, Func3, Action1), AsyncOnSubscribe.createStateless(Action2), AsyncOnSubscribe.createStateless(Action2, Action0), ReactiveX operators documentation: Create

lift

public final  Observable lift(Observable.OperatorT> operator)

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

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

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

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

Backpressure:

The Operator instance provided is responsible to be backpressure-aware or document the fact that the consumer of the returned Observable has to apply one of the onBackpressureXXX operators.

Scheduler:

lift does not operate by default on a particular Scheduler.

Type Parameters:

R - the output value type

Parameters:

operator - the Operator that implements the Observable-operating function to be applied to the source Observable

Returns:

an Observable that is the result of applying the lifted Operator to the source Observable

See Also:

RxJava wiki: Implementing Your Own Operators

compose

public  Observable compose(Observable.TransformerT,? extends R> transformer)

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

This method operates on the Observable itself whereas lift(rx.Observable.Operator) operates on the Observable's Subscribers or Observers.

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

Backpressure:

The operator itself doesn't interfere with the backpressure behavior which only depends on what kind of Observable the transformer returns.

Scheduler:

compose does not operate by default on a particular Scheduler.

Type Parameters:

R - the value type of the output Observable

Parameters:

transformer - implements the function that transforms the source Observable

Returns:

the source Observable, transformed by the transformer function

See Also:

RxJava wiki: Implementing Your Own Operators

to

public final  R to(Func1Observable<T>,R> converter)

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

This allows fluent conversion to any other type.

Type Parameters:

R - the resulting object type

Parameters:

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

Returns:

the value returned by the function

Since:

1.3

toSingle

public Single<T> toSingle()

Returns a Single that emits the single item emitted by the source Observable, if that Observable emits only a single item. If the source Observable emits more than one item or no items, notify of an IllegalArgumentException or NoSuchElementException respectively.

Backpressure:

The operator ignores backpressure on the source Observable and the returned Single does not have a notion of backpressure.

Scheduler:

toSingle does not operate by default on a particular Scheduler.

Returns:

a Single that emits the single item emitted by the source Observable

Throws:

java.lang.IllegalArgumentException - if the source observable emits more than one item

java.util.NoSuchElementException - if the source observable emits no items

Since:

1.2

See Also:

ReactiveX documentation: Single

toCompletable

public Completable toCompletable()

Returns a Completable that discards all onNext emissions (similar to ignoreAllElements()) and calls onCompleted when this source observable calls onCompleted. Error terminal events are propagated.

Backpressure:

The operator ignores backpressure on the source Observable and the returned Completable does not have a notion of backpressure.

Scheduler:

toCompletable does not operate by default on a particular Scheduler.

Returns:

a Completable that calls onCompleted on it's subscriber when the source Observable calls onCompleted

Since:

1.3

See Also:

ReactiveX documentation: Completable

amb

public static  Observable amb(java.lang.IterableObservable> sources)

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

Backpressure:

The operator itself doesn't interfere with backpressure which is determined by the winning Observable's backpressure behavior.

Scheduler:

amb does not operate by default on a particular Scheduler.

Type Parameters:

T - the common element type

Parameters:

sources - an Iterable of Observable sources competing to react first

Returns:

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

See Also:

ReactiveX operators documentation: Amb

amb

public static  Observable amb(Observable o1,
                                    Observable o2)

Given two Observables, mirrors the one that first either emits an item or sends a termination notification.

Backpressure:

The operator itself doesn't interfere with backpressure which is determined by the winning Observable's backpressure behavior.

Scheduler:

amb does not operate by default on a particular Scheduler.

Type Parameters:

T - the common element type

Parameters:

o1 - an Observable competing to react first

o2 - an Observable competing to react first

Returns:

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

See Also:

ReactiveX operators documentation: Amb

amb

public static  Observable amb(Observable o1,
                                    Observable o2,
                                    Observable o3)

Given three Observables, mirrors the one that first either emits an item or sends a termination notification.

Backpressure:

The operator itself doesn't interfere with backpressure which is determined by the winning Observable's backpressure behavior.

Scheduler:

amb does not operate by default on a particular Scheduler.

Type Parameters:

T - the common element base type

Parameters:

o1 - an Observable competing to react first

o2 - an Observable competing to react first

o3 - an Observable competing to react first

Returns:

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

See Also:

ReactiveX operators documentation: Amb

amb

public static  Observable amb(Observable o1,
                                    Observable o2,
                                    Observable o3,
                                    Observable o4)

Given four Observables, mirrors the one that first either emits an item or sends a termination notification.

Backpressure:

The operator itself doesn't interfere with backpressure which is determined by the winning Observable's backpressure behavior.

Scheduler:

amb does not operate by default on a particular Scheduler.

Type Parameters:

T - the common element base type

Parameters:

o1 - an Observable competing to react first

o2 - an Observable competing to react first

o3 - an Observable competing to react first

o4 - an Observable competing to react first

Returns:

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

See Also:

ReactiveX operators documentation: Amb

amb

public static  Observable amb(Observable o1,
                                    Observable o2,
                                    Observable o3,
                                    Observable o4,
                                    Observable o5)

Given five Observables, mirrors the one that first either emits an item or sends a termination notification.

Backpressure:

The operator itself doesn't interfere with backpressure which is determined by the winning Observable's backpressure behavior.

Scheduler:

amb does not operate by default on a particular Scheduler.

Type Parameters:

T - the common element base type

Parameters:

o1 - an Observable competing to react first

o2 - an Observable competing to react first

o3 - an Observable competing to react first

o4 - an Observable competing to react first

o5 - an Observable competing to react first

Returns:

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

See Also:

ReactiveX operators documentation: Amb

amb

public static  Observable amb(Observable o1,
                                    Observable o2,
                                    Observable o3,
                                    Observable o4,
                                    Observable o5,
                                    Observable o6)

Given six Observables, mirrors the one that first either emits an item or sends a termination notification.

Backpressure:

The operator itself doesn't interfere with backpressure which is determined by the winning Observable's backpressure behavior.

Scheduler:

amb does not operate by default on a particular Scheduler.

Type Parameters:

T - the common element base type

Parameters:

o1 - an Observable competing to react first

o2 - an Observable competing to react first

o3 - an Observable competing to react first

o4 - an Observable competing to react first

o5 - an Observable competing to react first

o6 - an Observable competing to react first

Returns:

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

See Also:

ReactiveX operators documentation: Amb

amb

public static  Observable amb(Observable o1,
                                    Observable o2,
                                    Observable o3,
                                    Observable o4,
                                    Observable o5,
                                    Observable o6,
                                    Observable o7)

Given seven Observables, mirrors the one that first either emits an item or sends a termination notification.

Backpressure:

The operator itself doesn't interfere with backpressure which is determined by the winning Observable's backpressure behavior.

Scheduler:

amb does not operate by default on a particular Scheduler.

Type Parameters:

T - the common element base type

Parameters:

o1 - an Observable competing to react first

o2 - an Observable competing to react first

o3 - an Observable competing to react first

o4 - an Observable competing to react first

o5 - an Observable competing to react first

o6 - an Observable competing to react first

o7 - an Observable competing to react first

Returns:

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

See Also:

ReactiveX operators documentation: Amb

amb

public static  Observable amb(Observable o1,
                                    Observable o2,
                                    Observable o3,
                                    Observable o4,
                                    Observable o5,
                                    Observable o6,
                                    Observable o7,
                                    Observable o8)

Given eight Observables, mirrors the one that first either emits an item or sends a termination notification.

Backpressure:

The operator itself doesn't interfere with backpressure which is determined by the winning Observable's backpressure behavior.

Scheduler:

amb does not operate by default on a particular Scheduler.

Type Parameters:

T - the common element base type

Parameters:

o1 - an Observable competing to react first

o2 - an Observable competing to react first

o3 - an Observable competing to react first

o4 - an Observable competing to react first

o5 - an Observable competing to react first

o6 - an Observable competing to react first

o7 - an Observable competing to react first

o8 - an observable competing to react first

Returns:

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

See Also:

ReactiveX operators documentation: Amb

amb

public static  Observable amb(Observable o1,
                                    Observable o2,
                                    Observable o3,
                                    Observable o4,
                                    Observable o5,
                                    Observable o6,
                                    Observable o7,
                                    Observable o8,
                                    Observable o9)

Given nine Observables, mirrors the one that first either emits an item or sends a termination notification.

Backpressure:

The operator itself doesn't interfere with backpressure which is determined by the winning Observable's backpressure behavior.

Scheduler:

amb does not operate by default on a particular Scheduler.

Type Parameters:

T - the common element base type

Parameters:

o1 - an Observable competing to react first

o2 - an Observable competing to react first

o3 - an Observable competing to react first

o4 - an Observable competing to react first

o5 - an Observable competing to react first

o6 - an Observable competing to react first

o7 - an Observable competing to react first

o8 - an Observable competing to react first

o9 - an Observable competing to react first

Returns:

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

See Also:

ReactiveX operators documentation: Amb

combineLatest

public static  Observable combineLatest(Observable o1,
                                                    Observable o2,
                                                    Func2 combineFunction)

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

Backpressure:

The returned Observable honors backpressure from downstream. The source Observables are requested in a bounded manner, however, their backpressure is not enforced (the operator won't signal MissingBackpressureException) and may lead to OutOfMemoryError due to internal buffer bloat.

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:

o1 - the first source Observable

o2 - the second source Observable

combineFunction - the aggregation function used to combine the items emitted by the source Observables

Returns:

an Observable that emits items that are the result of combining the items emitted by the source Observables by means of the given aggregation function

See Also:

ReactiveX operators documentation: CombineLatest

combineLatest

public static  Observable combineLatest(Observable o1,
                                                       Observable o2,
                                                       Observable o3,
                                                       Func3 combineFunction)

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

Backpressure:

The returned Observable honors backpressure from downstream. The source Observables are requested in a bounded manner, however, their backpressure is not enforced (the operator won't signal MissingBackpressureException) and may lead to OutOfMemoryError due to internal buffer bloat.

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:

o1 - the first source Observable

o2 - the second source Observable

o3 - the third source Observable

combineFunction - the aggregation function used to combine the items emitted by the source Observables

Returns:

an Observable that emits items that are the result of combining the items emitted by the source Observables by means of the given aggregation function

See Also:

ReactiveX operators documentation: CombineLatest

combineLatest

public static  Observable combineLatest(Observable o1,
                                                          Observable o2,
                                                          Observable o3,
                                                          Observable o4,
                                                          Func4 combineFunction)

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

Backpressure:

The returned Observable honors backpressure from downstream. The source Observables are requested in a bounded manner, however, their backpressure is not enforced (the operator won't signal MissingBackpressureException) and may lead to OutOfMemoryError due to internal buffer bloat.

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:

o1 - the first source Observable

o2 - the second source Observable

o3 - the third source Observable

o4 - the fourth source Observable

combineFunction - the aggregation function used to combine the items emitted by the source Observables

Returns:

an Observable that emits items that are the result of combining the items emitted by the source Observables by means of the given aggregation function

See Also:

ReactiveX operators documentation: CombineLatest

combineLatest

public static  Observable combineLatest(Observable o1,
                                                             Observable o2,
                                                             Observable o3,
                                                             Observable o4,
                                                             Observable o5,
                                                             Func5 combineFunction)

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

Backpressure:

The returned Observable honors backpressure from downstream. The source Observables are requested in a bounded manner, however, their backpressure is not enforced (the operator won't signal MissingBackpressureException) and may lead to OutOfMemoryError due to internal buffer bloat.

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:

o1 - the first source Observable

o2 - the second source Observable

o3 - the third source Observable

o4 - the fourth source Observable

o5 - the fifth source Observable

combineFunction - the aggregation function used to combine the items emitted by the source Observables

Returns:

an Observable that emits items that are the result of combining the items emitted by the source Observables by means of the given aggregation function

See Also:

ReactiveX operators documentation: CombineLatest

combineLatest

public static  Observable combineLatest(Observable o1,
                                                                Observable o2,
                                                                Observable o3,
                                                                Observable o4,
                                                                Observable o5,
                                                                Observable o6,
                                                                Func6 combineFunction)

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

Backpressure:

The returned Observable honors backpressure from downstream. The source Observables are requested in a bounded manner, however, their backpressure is not enforced (the operator won't signal MissingBackpressureException) and may lead to OutOfMemoryError due to internal buffer bloat.

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:

o1 - the first source Observable

o2 - the second source Observable

o3 - the third source Observable

o4 - the fourth source Observable

o5 - the fifth source Observable

o6 - the sixth source Observable

combineFunction - the aggregation function used to combine the items emitted by the source Observables

Returns:

an Observable that emits items that are the result of combining the items emitted by the source Observables by means of the given aggregation function

See Also:

ReactiveX operators documentation: CombineLatest

combineLatest

public static  Observable combineLatest(Observable o1,
                                                                   Observable o2,
                                                                   Observable o3,
                                                                   Observable o4,
                                                                   Observable o5,
                                                                   Observable o6,
                                                                   Observable o7,
                                                                   Func7 combineFunction)

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

Backpressure:

The returned Observable honors backpressure from downstream. The source Observables are requested in a bounded manner, however, their backpressure is not enforced (the operator won't signal MissingBackpressureException) and may lead to OutOfMemoryError due to internal buffer bloat.

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:

o1 - the first source Observable

o2 - the second source Observable

o3 - the third source Observable

o4 - the fourth source Observable

o5 - the fifth source Observable

o6 - the sixth source Observable

o7 - the seventh source Observable

combineFunction - the aggregation function used to combine the items emitted by the source Observables

Returns:

an Observable that emits items that are the result of combining the items emitted by the source Observables by means of the given aggregation function

See Also:

ReactiveX operators documentation: CombineLatest

combineLatest

public static  Observable combineLatest(Observable o1,
                                                                      Observable o2,
                                                                      Observable o3,
                                                                      Observable o4,
                                                                      Observable o5,
                                                                      Observable o6,
                                                                      Observable o7,
                                                                      Observable o8,
                                                                      Func8 combineFunction)

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

Backpressure:

The returned Observable honors backpressure from downstream. The source Observables are requested in a bounded manner, however, their backpressure is not enforced (the operator won't signal MissingBackpressureException) and may lead to OutOfMemoryError due to internal buffer bloat.

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:

o1 - the first source Observable

o2 - the second source Observable

o3 - the third source Observable

o4 - the fourth source Observable

o5 - the fifth source Observable

o6 - the sixth source Observable

o7 - the seventh source Observable

o8 - the eighth source Observable

combineFunction - the aggregation function used to combine the items emitted by the source Observables

Returns:

an Observable that emits items that are the result of combining the items emitted by the source Observables by means of the given aggregation function

See Also:

ReactiveX operators documentation: CombineLatest

combineLatest

public static  Observable combineLatest(Observable o1,
                                                                         Observable o2,
                                                                         Observable o3,
                                                                         Observable o4,
                                                                         Observable o5,
                                                                         Observable o6,
                                                                         Observable o7,
                                                                         Observable o8,
                                                                         Observable o9,
                                                                         Func9 combineFunction)

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

Backpressure:

The returned Observable honors backpressure from downstream. The source Observables are requested in a bounded manner, however, their backpressure is not enforced (the operator won't signal MissingBackpressureException) and may lead to OutOfMemoryError due to internal buffer bloat.

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:

o1 - the first source Observable

o2 - the second source Observable

o3 - the third source Observable

o4 - the fourth source Observable

o5 - the fifth source Observable

o6 - the sixth source Observable

o7 - the seventh source Observable

o8 - the eighth source Observable

o9 - the ninth source Observable

combineFunction - the aggregation function used to combine the items emitted by the source Observables

Returns:

an Observable that emits items that are the result of combining the items emitted by the source Observables by means of the given aggregation function

See Also:

ReactiveX operators documentation: CombineLatest

combineLatest

public static  Observable combineLatest(java.util.ListObservable> sources,
                                                FuncN combineFunction)

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

Backpressure:

The returned Observable honors backpressure from downstream. The source Observables are requested in a bounded manner, however, their backpressure is not enforced (the operator won't signal MissingBackpressureException) and may lead to OutOfMemoryError due to internal buffer bloat.

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 list of source Observables

combineFunction - the aggregation function used to combine the items emitted by the source Observables

Returns:

an Observable that emits items that are the result of combining the items emitted by the source Observables by means of the given aggregation function

See Also:

ReactiveX operators documentation: CombineLatest

combineLatest

public static  Observable combineLatest(java.lang.IterableObservable> sources,
                                                FuncN combineFunction)

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

Backpressure:

The returned Observable honors backpressure from downstream. The source Observables are requested in a bounded manner, however, their backpressure is not enforced (the operator won't signal MissingBackpressureException) and may lead to OutOfMemoryError due to internal buffer bloat.

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 Observables

combineFunction - the aggregation function used to combine the items emitted by the source Observables

Returns:

an Observable that emits items that are the result of combining the items emitted by the source Observables by means of the given aggregation function

See Also:

ReactiveX operators documentation: CombineLatest

combineLatestDelayError

public static  Observable combineLatestDelayError(java.lang.IterableObservable> sources,
                                                          FuncN combineFunction)

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

Backpressure:

The returned Observable honors backpressure from downstream. The source Observables are requested in a bounded manner, however, their backpressure is not enforced (the operator won't signal MissingBackpressureException) and may lead to OutOfMemoryError due to internal buffer bloat.

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 Observables

combineFunction - the aggregation function used to combine the items emitted by the source Observables

Returns:

an Observable that emits items that are the result of combining the items emitted by the source Observables by means of the given aggregation function

See Also:

ReactiveX operators documentation: CombineLatest

concat

public static  Observable concat(java.lang.IterableObservable> sequences)

Flattens an Iterable of Observables into one Observable, one after the other, without interleaving them.

Backpressure:

The operator honors backpressure from downstream. The Observable sources are expected to honor backpressure as well. If any of the source Observables violate this, it may throw an IllegalStateException when the source Observable completes.

Scheduler:

concat does not operate by default on a particular Scheduler.

Type Parameters:

T - the common element base type

Parameters:

sequences - the Iterable of Observables

Returns:

an Observable that emits items that are the result of flattening the items emitted by the Observables in the Iterable, one after the other, without interleaving them

See Also:

ReactiveX operators documentation: Concat

concat

public static  Observable concat(ObservableObservable> observables)

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

Backpressure:

The operator honors backpressure from downstream. Both the outer and inner Observable sources are expected to honor backpressure as well. If the outer violates this, a MissingBackpressureException is signalled. If any of the inner Observables violates this, it may throw an IllegalStateException when an inner Observable completes.

Scheduler:

concat does not operate by default on a particular Scheduler.

Type Parameters:

T - the common element base type

Parameters:

observables - an Observable that emits Observables

Returns:

an Observable that emits items all of the items emitted by the Observables emitted by observables, one after the other, without interleaving them

See Also:

ReactiveX operators documentation: Concat

concat

public static  Observable concat(Observable t1,
                                       Observable t2)

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

Backpressure:

The operator honors backpressure from downstream. The Observable sources are expected to honor backpressure as well. If any of the source Observables violate this, it may throw an IllegalStateException when the source Observable completes.

Scheduler:

concat does not operate by default on a particular Scheduler.

Type Parameters:

T - the common element base type

Parameters:

t1 - an Observable to be concatenated

t2 - an Observable to be concatenated

Returns:

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

See Also:

ReactiveX operators documentation: Concat

concat

public static  Observable concat(Observable t1,
                                       Observable t2,
                                       Observable t3)

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

Backpressure:

The operator honors backpressure from downstream. The Observable sources are expected to honor backpressure as well. If any of the source Observables violate this, it may throw an IllegalStateException when the source Observable completes.

Scheduler:

concat does not operate by default on a particular Scheduler.

Type Parameters:

T - the common element base type

Parameters:

t1 - an Observable to be concatenated

t2 - an Observable to be concatenated

t3 - an Observable to be concatenated

Returns:

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

See Also:

ReactiveX operators documentation: Concat

concat

public static  Observable concat(Observable t1,
                                       Observable t2,
                                       Observable t3,
                                       Observable t4)

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

Backpressure:

The operator honors backpressure from downstream. The Observable sources are expected to honor backpressure as well. If any of the source Observables violate this, it may throw an IllegalStateException when the source Observable completes.

Scheduler:

concat does not operate by default on a particular Scheduler.

Type Parameters:

T - the common element base type

Parameters:

t1 - an Observable to be concatenated

t2 - an Observable to be concatenated

t3 - an Observable to be concatenated

t4 - an Observable to be concatenated

Returns:

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

See Also:

ReactiveX operators documentation: Concat

concat

public static  Observable concat(Observable t1,
                                       Observable t2,
                                       Observable t3,
                                       Observable t4,
                                       Observable t5)

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

Backpressure:

The operator honors backpressure from downstream. The Observable sources are expected to honor backpressure as well. If any of the source Observables violate this, it may throw an IllegalStateException when the source Observable completes.

Scheduler:

concat does not operate by default on a particular Scheduler.

Type Parameters:

T - the common element base type

Parameters:

t1 - an Observable to be concatenated

t2 - an Observable to be concatenated

t3 - an Observable to be concatenated

t4 - an Observable to be concatenated

t5 - an Observable to be concatenated

Returns:

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

See Also:

ReactiveX operators documentation: Concat

concat

public static  Observable concat(Observable t1,
                                       Observable t2,
                                       Observable t3,
                                       Observable t4,
                                       Observable t5,
                                       Observable t6)

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

Backpressure:

The operator honors backpressure from downstream. The Observable sources are expected to honor backpressure as well. If any of the source Observables violate this, it may throw an IllegalStateException when the source Observable completes.

Scheduler:

concat does not operate by default on a particular Scheduler.

Type Parameters:

T - the common element base type

Parameters:

t1 - an Observable to be concatenated

t2 - an Observable to be concatenated

t3 - an Observable to be concatenated

t4 - an Observable to be concatenated

t5 - an Observable to be concatenated

t6 - an Observable to be concatenated

Returns:

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

See Also:

ReactiveX operators documentation: Concat

concat

public static  Observable concat(Observable t1,
                                       Observable t2,
                                       Observable t3,
                                       Observable t4,
                                       Observable t5,
                                       Observable t6,
                                       Observable t7)

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

Backpressure:

The operator honors backpressure from downstream. The Observable sources are expected to honor backpressure as well. If any of the source Observables violate this, it may throw an IllegalStateException when the source Observable completes.

Scheduler:

concat does not operate by default on a particular Scheduler.

Type Parameters:

T - the common element base type

Parameters:

t1 - an Observable to be concatenated

t2 - an Observable to be concatenated

t3 - an Observable to be concatenated

t4 - an Observable to be concatenated

t5 - an Observable to be concatenated

t6 - an Observable to be concatenated

t7 - an Observable to be concatenated

Returns:

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

See Also:

ReactiveX operators documentation: Concat

concat

public static  Observable concat(Observable t1,
                                       Observable t2,
                                       Observable t3,
                                       Observable t4,
                                       Observable t5,
                                       Observable t6,
                                       Observable t7,
                                       Observable t8)

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

Backpressure:

The operator honors backpressure from downstream. The Observable sources are expected to honor backpressure as well. If any of the source Observables violate this, it may throw an IllegalStateException when the source Observable completes.

Scheduler:

concat does not operate by default on a particular Scheduler.

Type Parameters:

T - the common element base type

Parameters:

t1 - an Observable to be concatenated

t2 - an Observable to be concatenated

t3 - an Observable to be concatenated

t4 - an Observable to be concatenated

t5 - an Observable to be concatenated

t6 - an Observable to be concatenated

t7 - an Observable to be concatenated

t8 - an Observable to be concatenated

Returns:

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

See Also:

ReactiveX operators documentation: Concat

concat

public static  Observable concat(Observable t1,
                                       Observable t2,
                                       Observable t3,
                                       Observable t4,
                                       Observable t5,
                                       Observable t6,
                                       Observable t7,
                                       Observable t8,
                                       Observable t9)

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

Backpressure:

The operator honors backpressure from downstream. The Observable sources are expected to honor backpressure as well. If any of the source Observables violate this, it may throw an IllegalStateException when the source Observable completes.

Scheduler:

concat does not operate by default on a particular Scheduler.

Type Parameters:

T - the common element base type

Parameters:

t1 - an Observable to be concatenated

t2 - an Observable to be concatenated

t3 - an Observable to be concatenated

t4 - an Observable to be concatenated

t5 - an Observable to be concatenated

t6 - an Observable to be concatenated

t7 - an Observable to be concatenated

t8 - an Observable to be concatenated

t9 - an Observable to be concatenated

Returns:

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

See Also:

ReactiveX operators documentation: Concat

concatDelayError

public static  Observable concatDelayError(ObservableObservable> sources)

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

Backpressure:

concatDelayError fully supports backpressure.

Scheduler:

concatDelayError does not operate by default on a particular Scheduler.

Type Parameters:

T - the common element base type

Parameters:

sources - the Observable sequence of Observables

Returns:

the new Observable with the concatenating behavior

Since:

1.3

concatDelayError

public static  Observable concatDelayError(java.lang.IterableObservable> sources)

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

Backpressure:

The operator honors backpressure from downstream. Both the outer and inner Observable sources are expected to honor backpressure as well. If the outer violates this, a MissingBackpressureException is signalled. If any of the inner Observables violates this, it may throw an IllegalStateException when an inner Observable completes.

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 Observables

Returns:

the new Observable with the concatenating behavior

Since:

1.3

concatDelayError

public static  Observable concatDelayError(Observable t1,
                                                 Observable t2)

Returns an Observable that emits the items emitted by two Observables, one after the other, without interleaving them, and delays any errors till all Observables terminate.

Backpressure:

The operator honors backpressure from downstream. The Observable sources are expected to honor backpressure as well. If any of the source Observables violate this, it may throw an IllegalStateException when the source Observable completes.

Scheduler:

concatDelayError does not operate by default on a particular Scheduler.

Type Parameters:

T - the common element base type

Parameters:

t1 - an Observable to be concatenated

t2 - an Observable to be concatenated

Returns:

an Observable with the concatenating behavior

Since:

1.3

concatDelayError

public static  Observable concatDelayError(Observable t1,
                                                 Observable t2,
                                                 Observable t3)

Returns an Observable that emits the items emitted by three Observables, one after the other, without interleaving them, and delays any errors till all Observables terminate.

Backpressure:

The operator honors backpressure from downstream. The Observable sources are expected to honor backpressure as well. If any of the source Observables violate this, it may throw an IllegalStateException when the source Observable completes.

Scheduler:

concatDelayError does not operate by default on a particular Scheduler.

Type Parameters:

T - the common element base type

Parameters:

t1 - an Observable to be concatenated

t2 - an Observable to be concatenated

t3 - an Observable to be concatenated

Returns:

an Observable with the concatenating behavior

Since:

1.3

concatDelayError

public static  Observable concatDelayError(Observable t1,
                                                 Observable t2,
                                                 Observable t3,
                                                 Observable t4)

Returns an Observable that emits the items emitted by four Observables, one after the other, without interleaving them, and delays any errors till all Observables terminate.

Backpressure:

The operator honors backpressure from downstream. The Observable sources are expected to honor backpressure as well. If any of the source Observables violate this, it may throw an IllegalStateException when the source Observable completes.

Scheduler:

concatDelayError does not operate by default on a particular Scheduler.

Type Parameters:

T - the common element base type

Parameters:

t1 - an Observable to be concatenated

t2 - an Observable to be concatenated

t3 - an Observable to be concatenated

t4 - an Observable to be concatenated

Returns:

an Observable with the concatenating behavior

Since:

1.3

concatDelayError

public static  Observable concatDelayError(Observable t1,
                                                 Observable t2,
                                                 Observable t3,
                                                 Observable t4,
                                                 Observable t5)

Returns an Observable that emits the items emitted by five Observables, one after the other, without interleaving them, and delays any errors till all Observables terminate.

Backpressure:

The operator honors backpressure from downstream. The Observable sources are expected to honor backpressure as well. If any of the source Observables violate this, it may throw an IllegalStateException when the source Observable completes.

Scheduler:

concatDelayError does not operate by default on a particular Scheduler.

Type Parameters:

T - the common element base type

Parameters:

t1 - an Observable to be concatenated

t2 - an Observable to be concatenated

t3 - an Observable to be concatenated

t4 - an Observable to be concatenated

t5 - an Observable to be concatenated

Returns:

an Observable with the concatenating behavior

Since:

1.3

concatDelayError

public static  Observable concatDelayError(Observable t1,
                                                 Observable t2,
                                                 Observable t3,
                                                 Observable t4,
                                                 Observable t5,
                                                 Observable t6)

Returns an Observable that emits the items emitted by six Observables, one after the other, without interleaving them, and delays any errors till all Observables terminate.

Backpressure:

The operator honors backpressure from downstream. The Observable sources are expected to honor backpressure as well. If any of the source Observables violate this, it may throw an IllegalStateException when the source Observable completes.

Scheduler:

concatDelayError does not operate by default on a particular Scheduler.

Type Parameters:

T - the common element base type

Parameters:

t1 - an Observable to be concatenated

t2 - an Observable to be concatenated

t3 - an Observable to be concatenated

t4 - an Observable to be concatenated

t5 - an Observable to be concatenated

t6 - an Observable to be concatenated

Returns:

an Observable with the concatenating behavior

Since:

1.3

concatDelayError

public static  Observable concatDelayError(Observable t1,
                                                 Observable t2,
                                                 Observable t3,
                                                 Observable t4,
                                                 Observable t5,
                                                 Observable t6,
                                                 Observable t7)

Returns an Observable that emits the items emitted by seven Observables, one after the other, without interleaving them, and delays any errors till all Observables terminate.

Backpressure:

The operator honors backpressure from downstream. The Observable sources are expected to honor backpressure as well. If any of the source Observables violate this, it may throw an IllegalStateException when the source Observable completes.

Scheduler:

concatDelayError does not operate by default on a particular Scheduler.

Type Parameters:

T - the common element base type

Parameters:

t1 - an Observable to be concatenated

t2 - an Observable to be concatenated

t3 - an Observable to be concatenated

t4 - an Observable to be concatenated

t5 - an Observable to be concatenated

t6 - an Observable to be concatenated

t7 - an Observable to be concatenated

Returns:

an Observable with the concatenating behavior

Since:

1.3

concatDelayError

public static  Observable concatDelayError(Observable t1,
                                                 Observable t2,
                                                 Observable t3,
                                                 Observable t4,
                                                 Observable t5,
                                                 Observable t6,
                                                 Observable t7,
                                                 Observable t8)

Returns an Observable that emits the items emitted by eight Observables, one after the other, without interleaving them, and delays any errors till all Observables terminate.

Backpressure:

The operator honors backpressure from downstream. The Observable sources are expected to honor backpressure as well. If any of the source Observables violate this, it may throw an IllegalStateException when the source Observable completes.

Scheduler:

concatDelayError does not operate by default on a particular Scheduler.

Type Parameters:

T - the common element base type

Parameters:

t1 - an Observable to be concatenated

t2 - an Observable to be concatenated

t3 - an Observable to be concatenated

t4 - an Observable to be concatenated

t5 - an Observable to be concatenated

t6 - an Observable to be concatenated

t7 - an Observable to be concatenated

t8 - an Observable to be concatenated

Returns:

an Observable with the concatenating behavior

Since:

1.3

concatDelayError

public static  Observable concatDelayError(Observable t1,
                                                 Observable t2,
                                                 Observable t3,
                                                 Observable t4,
                                                 Observable t5,
                                                 Observable t6,
                                                 Observable t7,
                                                 Observable t8,
                                                 Observable t9)

Returns an Observable that emits the items emitted by nine Observables, one after the other, without interleaving them, and delays any errors till all Observables terminate.

Backpressure:

The operator honors backpressure from downstream. The Observable sources are expected to honor backpressure as well. If any of the source Observables violate this, it may throw an IllegalStateException when the source Observable completes.

Scheduler:

concatDelayError does not operate by default on a particular Scheduler.

Type Parameters:

T - the common element base type

Parameters:

t1 - an Observable to be concatenated

t2 - an Observable to be concatenated

t3 - an Observable to be concatenated

t4 - an Observable to be concatenated

t5 - an Observable to be concatenated

t6 - an Observable to be concatenated

t7 - an Observable to be concatenated

t8 - an Observable to be concatenated

t9 - an Observable to be concatenated

Returns:

an Observable with the concatenating behavior

Since:

1.3

defer

public static  Observable defer(Func0<Observable> observableFactory)

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

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

Backpressure:

The operator itself doesn't interfere with backpressure which is determined by the Observable returned by the observableFactory.

Scheduler:

defer does not operate by default on a particular Scheduler.

Type Parameters:

T - the type of the items emitted by the Observable

Parameters:

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

Returns:

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

See Also:

ReactiveX operators documentation: Defer

empty

public static  Observable empty()

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

Backpressure:

This source doesn't produce any elements and effectively ignores downstream backpressure.

Scheduler:

empty does not operate by default on a particular Scheduler.

Type Parameters:

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

Returns:

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

See Also:

ReactiveX operators documentation: Empty

error

public static  Observable error(java.lang.Throwable exception)

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

Backpressure:

This source doesn't produce any elements and effectively ignores downstream backpressure.

Scheduler:

error does not operate by default on a particular Scheduler.

Type Parameters:

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

Parameters:

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

from

public static  Observable from(java.util.concurrent.Future future)

Converts a Future into an Observable.

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

Important note: This Observable is blocking; you cannot unsubscribe from it.

Backpressure:

The operator honors backpressure from downstream.

Scheduler:

from does not operate by default on a particular Scheduler.

Type Parameters:

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

Parameters:

future - the source Future

Returns:

an Observable that emits the item from the source Future

See Also:

ReactiveX operators documentation: From

from

public static  Observable from(java.util.concurrent.Future future,
                                     long timeout,
                                     java.util.concurrent.TimeUnit unit)

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

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

Important note: This Observable is blocking; you cannot unsubscribe from it.

Backpressure:

The operator honors backpressure from downstream.

Scheduler:

from does not operate by default on a particular Scheduler.

Type Parameters:

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

Parameters:

future - the source Future

timeout - the maximum time to wait before calling get

unit - the TimeUnit of the timeout argument

Returns:

an Observable that emits the item from the source Future

See Also:

ReactiveX operators documentation: From

from

public static  Observable from(java.util.concurrent.Future future,
                                     Scheduler scheduler)

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

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

Backpressure:

The operator honors backpressure from downstream.

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 Observable

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

from

public static  Observable from(java.lang.Iterable iterable)

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

Backpressure:

The operator honors backpressure from downstream and iterates the given iterable on demand (i.e., when requested).

Scheduler:

from does not operate by default on a particular Scheduler.

Type Parameters:

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

Parameters:

iterable - the source Iterable sequence

Returns:

an Observable that emits each item in the source Iterable sequence

See Also:

ReactiveX operators documentation: From

from

public static  Observable from(T[] array)

Converts an Array into an Observable that emits the items in the Array.

Backpressure:

The operator honors backpressure from downstream and iterates the given array on demand (i.e., when requested).

Scheduler:

from does not operate by default on a particular Scheduler.

Type Parameters:

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

Parameters:

array - the source Array

Returns:

an Observable that emits each item in the source Array

See Also:

ReactiveX operators documentation: From

fromCallable

public static  Observable fromCallable(java.util.concurrent.Callable func)

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

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

Backpressure:

The operator honors backpressure from downstream.

Scheduler:

fromCallable does not operate by default on a particular Scheduler.

Type Parameters:

T - the type of the item emitted by the Observable

Parameters:

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

Returns:

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

Since:

1.2

See Also:

defer(Func0)

interval

public static Observable interval(long interval,
                                                  java.util.concurrent.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:

interval - interval 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

public static Observable interval(long interval,
                                                  java.util.concurrent.TimeUnit unit,
                                                  Scheduler scheduler)

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

Backpressure:

The operator generates values based on time and ignores downstream backpressure which may lead to MissingBackpressureException at some point in the chain. Consumers should consider applying one of the onBackpressureXXX operators as well.

Scheduler:

you specify which Scheduler this operator will use

Parameters:

interval - interval 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

interval

public static Observable interval(long initialDelay,
                                                  long period,
                                                  java.util.concurrent.TimeUnit unit)

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

Backpressure:

The operator generates values based on time and ignores downstream backpressure which may lead to MissingBackpressureException at some point in the chain. Consumers should consider applying one of the onBackpressureXXX operators as well.

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

public static Observable interval(long initialDelay,
                                                  long period,
                                                  java.util.concurrent.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.

Backpressure:

The operator generates values based on time and ignores downstream backpressure which may lead to MissingBackpressureException at some point in the chain. Consumers should consider applying one of the onBackpressureXXX operators as well.

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

just

public static  Observable just(T value)

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

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

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

Backpressure:

The operator honors backpressure from downstream.

Scheduler:

just does not operate by default on a particular Scheduler.

Type Parameters:

T - the type of that item

Parameters:

value - the item to emit

Returns:

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

See Also:

ReactiveX operators documentation: Just

just

public static  Observable just(T t1,
                                     T t2)

Converts two items into an Observable that emits those items.

Backpressure:

The operator honors backpressure from downstream and signals each value on-demand (i.e., when requested).

Scheduler:

just does not operate by default on a particular Scheduler.

Type Parameters:

T - the type of these items

Parameters:

t1 - first item

t2 - second item

Returns:

an Observable that emits each item

See Also:

ReactiveX operators documentation: Just

just

public static  Observable just(T t1,
                                     T t2,
                                     T t3)

Converts three items into an Observable that emits those items.

Backpressure:

The operator honors backpressure from downstream and signals each value on-demand (i.e., when requested).

Scheduler:

just does not operate by default on a particular Scheduler.

Type Parameters:

T - the type of these items

Parameters:

t1 - first item

t2 - second item

t3 - third item

Returns:

an Observable that emits each item

See Also:

ReactiveX operators documentation: Just

just

public static  Observable just(T t1,
                                     T t2,
                                     T t3,
                                     T t4)

Converts four items into an Observable that emits those items.

Backpressure:

The operator honors backpressure from downstream and signals each value on-demand (i.e., when requested).

Scheduler:

just does not operate by default on a particular Scheduler.

Type Parameters:

T - the type of these items

Parameters:

t1 - first item

t2 - second item

t3 - third item

t4 - fourth item

Returns:

an Observable that emits each item

See Also:

ReactiveX operators documentation: Just

just

public static  Observable just(T t1,
                                     T t2,
                                     T t3,
                                     T t4,
                                     T t5)

Converts five items into an Observable that emits those items.

Backpressure:

The operator honors backpressure from downstream and signals each value on-demand (i.e., when requested).

Scheduler:

just does not operate by default on a particular Scheduler.

Type Parameters:

T - the type of these items

Parameters:

t1 - first item

t2 - second item

t3 - third item

t4 - fourth item

t5 - fifth item

Returns:

an Observable that emits each item

See Also:

ReactiveX operators documentation: Just

just

public static  Observable just(T t1,
                                     T t2,
                                     T t3,
                                     T t4,
                                     T t5,
                                     T t6)

Converts six items into an Observable that emits those items.

Backpressure:

The operator honors backpressure from downstream and signals each value on-demand (i.e., when requested).

Scheduler:

just does not operate by default on a particular Scheduler.

Type Parameters:

T - the type of these items

Parameters:

t1 - first item

t2 - second item

t3 - third item

t4 - fourth item

t5 - fifth item

t6 - sixth item

Returns:

an Observable that emits each item

See Also:

ReactiveX operators documentation: Just

just

public static  Observable just(T t1,
                                     T t2,
                                     T t3,
                                     T t4,
                                     T t5,
                                     T t6,
                                     T t7)

Converts seven items into an Observable that emits those items.

Backpressure:

The operator honors backpressure from downstream and signals each value on-demand (i.e., when requested).

Scheduler:

just does not operate by default on a particular Scheduler.

Type Parameters:

T - the type of these items

Parameters:

t1 - first item

t2 - second item

t3 - third item

t4 - fourth item

t5 - fifth item

t6 - sixth item

t7 - seventh item

Returns:

an Observable that emits each item

See Also:

ReactiveX operators documentation: Just

just

public static  Observable just(T t1,
                                     T t2,
                                     T t3,
                                     T t4,
                                     T t5,
                                     T t6,
                                     T t7,
                                     T t8)

Converts eight items into an Observable that emits those items.

Backpressure:

The operator honors backpressure from downstream and signals each value on-demand (i.e., when requested).

Scheduler:

just does not operate by default on a particular Scheduler.

Type Parameters:

T - the type of these items

Parameters:

t1 - first item

t2 - second item

t3 - third item

t4 - fourth item

t5 - fifth item

t6 - sixth item

t7 - seventh item

t8 - eighth item

Returns:

an Observable that emits each item

See Also:

ReactiveX operators documentation: Just

just

public static  Observable just(T t1,
                                     T t2,
                                     T t3,
                                     T t4,
                                     T t5,
                                     T t6,
                                     T t7,
                                     T t8,
                                     T t9)

Converts nine items into an Observable that emits those items.

Backpressure:

The operator honors backpressure from downstream and signals each value on-demand (i.e., when requested).

Scheduler:

just does not operate by default on a particular Scheduler.

Type Parameters:

T - the type of these items

Parameters:

t1 - first item

t2 - second item

t3 - third item

t4 - fourth item

t5 - fifth item

t6 - sixth item

t7 - seventh item

t8 - eighth item

t9 - ninth item

Returns:

an Observable that emits each item

See Also:

ReactiveX operators documentation: Just

just

public static  Observable just(T t1,
                                     T t2,
                                     T t3,
                                     T t4,
                                     T t5,
                                     T t6,
                                     T t7,
                                     T t8,
                                     T t9,
                                     T t10)

Converts ten items into an Observable that emits those items.

Backpressure:

The operator honors backpressure from downstream and signals each value on-demand (i.e., when requested).

Scheduler:

just does not operate by default on a particular Scheduler.

Type Parameters:

T - the type of these items

Parameters:

t1 - first item

t2 - second item

t3 - third item

t4 - fourth item

t5 - fifth item

t6 - sixth item

t7 - seventh item

t8 - eighth item

t9 - ninth item

t10 - tenth item

Returns:

an Observable that emits each item

See Also:

ReactiveX operators documentation: Just

merge

public static  Observable merge(java.lang.IterableObservable> sequences)

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

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

Backpressure:

The operator honors backpressure from downstream. The source Observables are expected to honor backpressure; if violated, the operator may signal MissingBackpressureException.

Scheduler:

merge does not operate by default on a particular Scheduler.

Type Parameters:

T - the common element base type

Parameters:

sequences - the Iterable of Observables

Returns:

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

See Also:

ReactiveX operators documentation: Merge

merge

public static  Observable merge(java.lang.IterableObservable> sequences,
                                      int maxConcurrent)

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

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

Backpressure:

The operator honors backpressure from downstream. The source Observables are expected to honor backpressure; if violated, the operator may signal MissingBackpressureException.

Scheduler:

merge does not operate by default on a particular Scheduler.

Type Parameters:

T - the common element base type

Parameters:

sequences - the Iterable of Observables

maxConcurrent - the maximum number of Observables that may be subscribed to concurrently

Returns:

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

Throws:

java.lang.IllegalArgumentException - if maxConcurrent is less than or equal to 0

See Also:

ReactiveX operators documentation: Merge

merge

public static  Observable merge(ObservableObservable> source)

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

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

Backpressure:

The operator honors backpressure from downstream. The outer Observable is consumed in unbounded mode (i.e., no backpressure is applied to it). The inner Observables are expected to honor backpressure; if violated, the operator may signal MissingBackpressureException.

Scheduler:

merge does not operate by default on a particular Scheduler.

Type Parameters:

T - the common element base type

Parameters:

source - an Observable that emits Observables

Returns:

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

See Also:

ReactiveX operators documentation: Merge

merge

public static  Observable merge(ObservableObservable> source,
                                      int maxConcurrent)

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

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

Backpressure:

The operator honors backpressure from downstream. Both the outer and inner Observables are expected to honor backpressure; if violated, the operator may signal MissingBackpressureException.

Scheduler:

merge does not operate by default on a particular Scheduler.

Type Parameters:

T - the common element base type

Parameters:

source - an Observable that emits Observables

maxConcurrent - the maximum number of Observables that may be subscribed to concurrently

Returns:

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

Throws:

java.lang.IllegalArgumentException - if maxConcurrent is less than or equal to 0

Since:

1.1.0

See Also:

ReactiveX operators documentation: Merge

merge

public static  Observable merge(Observable t1,
                                      Observable t2)

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

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

Backpressure:

The operator honors backpressure from downstream. The source Observables are expected to honor backpressure; if violated, the operator may signal MissingBackpressureException.

Scheduler:

merge does not operate by default on a particular Scheduler.

Type Parameters:

T - the common element base type

Parameters:

t1 - an Observable to be merged

t2 - an Observable to be merged

Returns:

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

See Also:

ReactiveX operators documentation: Merge

merge

public static  Observable merge(Observable t1,
                                      Observable t2,
                                      Observable t3)

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

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

Backpressure:

The operator honors backpressure from downstream. The source Observables are expected to honor backpressure; if violated, the operator may signal MissingBackpressureException.

Scheduler:

merge does not operate by default on a particular Scheduler.

Type Parameters:

T - the common element base type

Parameters:

t1 - an Observable to be merged

t2 - an Observable to be merged

t3 - an Observable to be merged

Returns:

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

See Also:

ReactiveX operators documentation: Merge

merge

public static  Observable merge(Observable t1,
                                      Observable t2,
                                      Observable t3,
                                      Observable t4)

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

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

Backpressure:

The operator honors backpressure from downstream. The source Observables are expected to honor backpressure; if violated, the operator may signal MissingBackpressureException.

Scheduler:

merge does not operate by default on a particular Scheduler.

Type Parameters:

T - the common element base type

Parameters:

t1 - an Observable to be merged

t2 - an Observable to be merged

t3 - an Observable to be merged

t4 - an Observable to be merged

Returns:

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

See Also:

ReactiveX operators documentation: Merge

merge

public static  Observable merge(Observable t1,
                                      Observable t2,
                                      Observable t3,
                                      Observable t4,
                                      Observable t5)

Flattens five Observables into a single Observable, without any transformation.

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

Backpressure:

The operator honors backpressure from downstream. The source Observables are expected to honor backpressure; if violated, the operator may signal MissingBackpressureException.

Scheduler:

merge does not operate by default on a particular Scheduler.

Type Parameters:

T - the common element base type

Parameters:

t1 - an Observable to be merged

t2 - an Observable to be merged

t3 - an Observable to be merged

t4 - an Observable to be merged

t5 - an Observable to be merged

Returns:

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

See Also:

ReactiveX operators documentation: Merge

merge

public static  Observable merge(Observable t1,
                                      Observable t2,
                                      Observable t3,
                                      Observable t4,
                                      Observable t5,
                                      Observable t6)

Flattens six Observables into a single Observable, without any transformation.

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

Backpressure:

The operator honors backpressure from downstream. The source Observables are expected to honor backpressure; if violated, the operator may signal MissingBackpressureException.

Scheduler:

merge does not operate by default on a particular Scheduler.

Type Parameters:

T - the common element base type

Parameters:

t1 - an Observable to be merged

t2 - an Observable to be merged

t3 - an Observable to be merged

t4 - an Observable to be merged

t5 - an Observable to be merged

t6 - an Observable to be merged

Returns:

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

See Also:

ReactiveX operators documentation: Merge

merge

public static  Observable merge(Observable t1,
                                      Observable t2,
                                      Observable t3,
                                      Observable t4,
                                      Observable t5,
                                      Observable t6,
                                      Observable t7)

Flattens seven Observables into a single Observable, without any transformation.

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

Backpressure:

The operator honors backpressure from downstream. The source Observables are expected to honor backpressure; if violated, the operator may signal MissingBackpressureException.

Scheduler:

merge does not operate by default on a particular Scheduler.

Type Parameters:

T - the common element base type

Parameters:

t1 - an Observable to be merged

t2 - an Observable to be merged

t3 - an Observable to be merged

t4 - an Observable to be merged

t5 - an Observable to be merged

t6 - an Observable to be merged

t7 - an Observable to be merged

Returns:

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

See Also:

ReactiveX operators documentation: Merge

merge

public static  Observable merge(Observable t1,
                                      Observable t2,
                                      Observable t3,
                                      Observable t4,
                                      Observable t5,
                                      Observable t6,
                                      Observable t7,
                                      Observable t8)

Flattens eight Observables into a single Observable, without any transformation.

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

Backpressure:

The operator honors backpressure from downstream. The source Observables are expected to honor backpressure; if violated, the operator may signal MissingBackpressureException.

Scheduler:

merge does not operate by default on a particular Scheduler.

Type Parameters:

T - the common element base type

Parameters:

t1 - an Observable to be merged

t2 - an Observable to be merged

t3 - an Observable to be merged

t4 - an Observable to be merged

t5 - an Observable to be merged

t6 - an Observable to be merged

t7 - an Observable to be merged

t8 - an Observable to be merged

Returns:

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

See Also:

ReactiveX operators documentation: Merge

merge

public static  Observable merge(Observable t1,
                                      Observable t2,
                                      Observable t3,
                                      Observable t4,
                                      Observable t5,
                                      Observable t6,
                                      Observable t7,
                                      Observable t8,
                                      Observable t9)

Flattens nine Observables into a single Observable, without any transformation.

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

Backpressure:

The operator honors backpressure from downstream. The source Observables are expected to honor backpressure; if violated, the operator may signal MissingBackpressureException.

Scheduler:

merge does not operate by default on a particular Scheduler.

Type Parameters:

T - the common element base type

Parameters:

t1 - an Observable to be merged

t2 - an Observable to be merged

t3 - an Observable to be merged

t4 - an Observable to be merged

t5 - an Observable to be merged

t6 - an Observable to be merged

t7 - an Observable to be merged

t8 - an Observable to be merged

t9 - an Observable to be merged

Returns:

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

See Also:

ReactiveX operators documentation: Merge

merge

public static  Observable merge(Observable[] sequences)

Flattens an Array of Observables into one Observable, without any transformation.

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

Backpressure:

The operator honors backpressure from downstream. The source Observables are expected to honor backpressure; if violated, the operator may signal MissingBackpressureException.

Scheduler:

merge does not operate by default on a particular Scheduler.

Type Parameters:

T - the common element base type

Parameters:

sequences - the Array of Observables

Returns:

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

See Also:

ReactiveX operators documentation: Merge

merge

public static  Observable merge(Observable[] sequences,
                                      int maxConcurrent)

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

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

Backpressure:

The operator honors backpressure from downstream. The source Observables are expected to honor backpressure; if violated, the operator may signal MissingBackpressureException.

Scheduler:

merge does not operate by default on a particular Scheduler.

Type Parameters:

T - the common element base type

Parameters:

sequences - the Array of Observables

maxConcurrent - the maximum number of Observables that may be subscribed to concurrently

Returns:

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

Since:

1.1.0

See Also:

ReactiveX operators documentation: Merge

mergeDelayError

public static  Observable mergeDelayError(ObservableObservable> source)

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

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

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

Backpressure:

The operator honors backpressure from downstream. The outer Observable is consumed in unbounded mode (i.e., no backpressure is applied to it). The inner Observables are expected to honor backpressure; if violated, the operator may signal MissingBackpressureException.

Scheduler:

mergeDelayError does not operate by default on a particular Scheduler.

Type Parameters:

T - the common element base type

Parameters:

source - an Observable that emits Observables

Returns:

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

See Also:

ReactiveX operators documentation: Merge

mergeDelayError

public static  Observable mergeDelayError(ObservableObservable> source,
                                                int maxConcurrent)

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

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

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

Backpressure:

The operator honors backpressure from downstream. Both the outer and inner Observables are expected to honor backpressure; if violated, the operator may signal MissingBackpressureException.

Scheduler:

mergeDelayError does not operate by default on a particular Scheduler.

Type Parameters:

T - the common element base type

Parameters:

source - an Observable that emits Observables

maxConcurrent - the maximum number of Observables that may be subscribed to concurrently

Returns:

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

Since:

1.3

See Also:

ReactiveX operators documentation: Merge

mergeDelayError

public static  Observable mergeDelayError(java.lang.IterableObservable> sequences)

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

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

Even if multiple merged Observables 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:

sequences - the Iterable of Observables

Returns:

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

See Also:

ReactiveX operators documentation: Merge

mergeDelayError

public static  Observable mergeDelayError(java.lang.IterableObservable> sequences,
                                                int maxConcurrent)

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

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

Even if multiple merged Observables 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:

sequences - the Iterable of Observables

maxConcurrent - the maximum number of Observables that may be subscribed to concurrently

Returns:

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

See Also:

ReactiveX operators documentation: Merge

mergeDelayError

public static  Observable mergeDelayError(Observable t1,
                                                Observable t2)

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

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

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

Backpressure:

The operator honors backpressure from downstream. The source Observables are expected to honor backpressure; if violated, the operator may signal MissingBackpressureException.

Scheduler:

mergeDelayError does not operate by default on a particular Scheduler.

Type Parameters:

T - the common element base type

Parameters:

t1 - an Observable to be merged

t2 - an Observable to be merged

Returns:

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

See Also:

ReactiveX operators documentation: Merge

mergeDelayError

public static  Observable mergeDelayError(Observable t1,
                                                Observable t2,
                                                Observable t3)

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

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

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

Backpressure:

The operator honors backpressure from downstream. The source Observables are expected to honor backpressure; if violated, the operator may signal MissingBackpressureException.

Scheduler:

mergeDelayError does not operate by default on a particular Scheduler.

Type Parameters:

T - the common element base type

Parameters:

t1 - an Observable to be merged

t2 - an Observable to be merged

t3 - an Observable to be merged

Returns:

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

See Also:

ReactiveX operators documentation: Merge

mergeDelayError

public static  Observable mergeDelayError(Observable t1,
                                                Observable t2,
                                                Observable t3,
                                                Observable t4)

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

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

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

Backpressure:

The operator honors backpressure from downstream. The source Observables are expected to honor backpressure; if violated, the operator may signal MissingBackpressureException.

Scheduler:

mergeDelayError does not operate by default on a particular Scheduler.

Type Parameters:

T - the common element base type

Parameters:

t1 - an Observable to be merged

t2 - an Observable to be merged

t3 - an Observable to be merged

t4 - an Observable to be merged

Returns:

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

See Also:

ReactiveX operators documentation: Merge

mergeDelayError

public static  Observable mergeDelayError(Observable t1,
                                                Observable t2,
                                                Observable t3,
                                                Observable t4,
                                                Observable t5)

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

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

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

Backpressure:

The operator honors backpressure from downstream. The source Observables are expected to honor backpressure; if violated, the operator may signal MissingBackpressureException.

Scheduler:

mergeDelayError does not operate by default on a particular Scheduler.

Type Parameters:

T - the common element base type

Parameters:

t1 - an Observable to be merged

t2 - an Observable to be merged

t3 - an Observable to be merged

t4 - an Observable to be merged

t5 - an Observable to be merged

Returns:

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

See Also:

ReactiveX operators documentation: Merge

mergeDelayError

public static  Observable mergeDelayError(Observable t1,
                                                Observable t2,
                                                Observable t3,
                                                Observable t4,
                                                Observable t5,
                                                Observable t6)

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

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

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

Backpressure:

The operator honors backpressure from downstream. The source Observables are expected to honor backpressure; if violated, the operator may signal MissingBackpressureException.

Scheduler:

mergeDelayError does not operate by default on a particular Scheduler.

Type Parameters:

T - the common element base type

Parameters:

t1 - an Observable to be merged

t2 - an Observable to be merged

t3 - an Observable to be merged

t4 - an Observable to be merged

t5 - an Observable to be merged

t6 - an Observable to be merged

Returns:

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

See Also:

ReactiveX operators documentation: Merge

mergeDelayError

public static  Observable mergeDelayError(Observable t1,
                                                Observable t2,
                                                Observable t3,
                                                Observable t4,
                                                Observable t5,
                                                Observable t6,
                                                Observable t7)

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

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

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

Backpressure:

The operator honors backpressure from downstream. The source Observables are expected to honor backpressure; if violated, the operator may signal MissingBackpressureException.

Scheduler:

mergeDelayError does not operate by default on a particular Scheduler.

Type Parameters:

T - the common element base type

Parameters:

t1 - an Observable to be merged

t2 - an Observable to be merged

t3 - an Observable to be merged

t4 - an Observable to be merged

t5 - an Observable to be merged

t6 - an Observable to be merged

t7 - an Observable to be merged

Returns:

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

See Also:

ReactiveX operators documentation: Merge

mergeDelayError

public static  Observable mergeDelayError(Observable t1,
                                                Observable t2,
                                                Observable t3,
                                                Observable t4,
                                                Observable t5,
                                                Observable t6,
                                                Observable t7,
                                                Observable t8)

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

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

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

Backpressure:

The operator honors backpressure from downstream. The source Observables are expected to honor backpressure; if violated, the operator may signal MissingBackpressureException.

Scheduler:

mergeDelayError does not operate by default on a particular Scheduler.

Type Parameters:

T - the common element base type

Parameters:

t1 - an Observable to be merged

t2 - an Observable to be merged

t3 - an Observable to be merged

t4 - an Observable to be merged

t5 - an Observable to be merged

t6 - an Observable to be merged

t7 - an Observable to be merged

t8 - an Observable to be merged

Returns:

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

See Also:

ReactiveX operators documentation: Merge

mergeDelayError

public static  Observable mergeDelayError(Observable t1,
                                                Observable t2,
                                                Observable t3,
                                                Observable t4,
                                                Observable t5,
                                                Observable t6,
                                                Observable t7,
                                                Observable t8,
                                                Observable t9)

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

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

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

Backpressure:

The operator honors backpressure from downstream. The source Observables are expected to honor backpressure; if violated, the operator may signal MissingBackpressureException.

Scheduler:

mergeDelayError does not operate by default on a particular Scheduler.

Type Parameters:

T - the common element base type

Parameters:

t1 - an Observable to be merged

t2 - an Observable to be merged

t3 - an Observable to be merged

t4 - an Observable to be merged

t5 - an Observable to be merged

t6 - an Observable to be merged

t7 - an Observable to be merged

t8 - an Observable to be merged

t9 - an Observable to be merged

Returns:

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

See Also:

ReactiveX operators documentation: Merge

nest

public final Observable<Observable<T>> nest()

Converts the source Observable into an Observable> that emits the source Observable as its single emission.

Backpressure:

The operator honors backpressure from downstream.

Scheduler:

nest does not operate by default on a particular Scheduler.

Returns:

an Observable that emits a single item: the source Observable

See Also:

ReactiveX operators documentation: To

never

public static  Observable never()

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

This Observable is useful primarily for testing purposes.

Backpressure:

This source doesn't produce any elements and effectively ignores downstream backpressure.

Scheduler:

never does not operate by default on a particular Scheduler.

Type Parameters:

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

Returns:

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

See Also:

ReactiveX operators documentation: Never

range

public static Observable range(int start,
                                                  int count)

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

Backpressure:

The operator honors backpressure from downstream and signals values on-demand (i.e., when requested).

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:

java.lang.IllegalArgumentException - if count is less than zero, or if start + count − 1 exceeds Integer.MAX_VALUE

See Also:

ReactiveX operators documentation: Range

range

public static Observable range(int start,
                                                  int count,
                                                  Scheduler scheduler)

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

Backpressure:

The operator honors backpressure from downstream and signals values on-demand (i.e., when requested).

Scheduler:

you specify which Scheduler this operator will use

Parameters:

start - the value of the first Integer in the sequence

count - the number of sequential Integers to generate

scheduler - the Scheduler to run the generator loop on

Returns:

an Observable that emits a range of sequential Integers

See Also:

ReactiveX operators documentation: Range

sequenceEqual

public static  Observable sequenceEqual(Observable first,
                                                              Observable second)

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

Scheduler:

sequenceEqual does not operate by default on a particular Scheduler.

Type Parameters:

T - the type of items emitted by each Observable

Parameters:

first - the first Observable to compare

second - the second Observable to compare

Returns:

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

See Also:

ReactiveX operators documentation: SequenceEqual

sequenceEqual

public static  Observable sequenceEqual(Observable first,
                                                              Observable second,
                                                              Func2 equality)

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

Backpressure:

The operator honors backpressure from downstream. The source Observables are expected to honor backpressure; if violated, the operator signals a MissingBackpressureException.

Scheduler:

sequenceEqual does not operate by default on a particular Scheduler.

Type Parameters:

T - the type of items emitted by each Observable

Parameters:

first - the first Observable to compare

second - the second Observable to compare

equality - a function used to compare items emitted by each Observable

Returns:

an Observable that emits a Boolean value that indicates whether the two Observable two sequences are the same according to the specified function

See Also:

ReactiveX operators documentation: SequenceEqual

switchOnNext

public static  Observable switchOnNext(ObservableObservable> sequenceOfSequences)

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

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

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

Backpressure:

The operator honors backpressure from downstream. The outer Observable is consumed in an unbounded manner (i.e., without backpressure) and the inner Observables are expected to honor backpressure but it is not enforced; the operator won't signal a MissingBackpressureException but the violation may lead to OutOfMemoryError due to internal buffer bloat.

Scheduler:

switchOnNext does not operate by default on a particular Scheduler.

Type Parameters:

T - the item type

Parameters:

sequenceOfSequences - the source Observable that emits Observables

Returns:

an Observable that emits the items emitted by the Observable most recently emitted by the source Observable

See Also:

ReactiveX operators documentation: Switch

switchOnNextDelayError

public static  Observable switchOnNextDelayError(ObservableObservable> sequenceOfSequences)

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

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

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

Backpressure:

The operator honors backpressure from downstream. The outer Observable is consumed in an unbounded manner (i.e., without backpressure) and the inner Observables are expected to honor backpressure but it is not enforced; the operator won't signal a MissingBackpressureException but the violation may lead to OutOfMemoryError due to internal buffer bloat.

Scheduler:

switchOnNext does not operate by default on a particular Scheduler.

Type Parameters:

T - the item type

Parameters:

sequenceOfSequences - the source Observable that emits Observables

Returns:

an Observable that emits the items emitted by the Observable most recently emitted by the source Observable

Since:

1.3

See Also:

ReactiveX operators documentation: Switch

timer

@Deprecated
public static Observable timer(long initialDelay,
                                                           long period,
                                                           java.util.concurrent.TimeUnit unit)

Deprecated. use interval(long, long, TimeUnit) instead

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

Backpressure:

This operator does not support backpressure as it uses time. If the downstream needs a slower rate it should slow the timer or use something like onBackpressureDrop(rx.functions.Action1).

Scheduler:

timer operates by default on the computation Scheduler.

Parameters:

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

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

unit - the time unit for both initialDelay and period

Returns:

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

See Also:

ReactiveX operators documentation: Timer

timer

@Deprecated
public static Observable timer(long initialDelay,
                                                           long period,
                                                           java.util.concurrent.TimeUnit unit,
                                                           Scheduler scheduler)

Deprecated. use interval(long, long, TimeUnit, Scheduler) instead

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

Backpressure:

This operator does not support backpressure as it uses time. If the downstream needs a slower rate it should slow the timer or use something like onBackpressureDrop(rx.functions.Action1).

Scheduler:

you specify which Scheduler this operator will use

Parameters:

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

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

unit - the time unit for both initialDelay and period

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

Returns:

an Observable that emits a 0L after the initialDelay and ever increasing numbers after each period of time thereafter, while running on the given Scheduler

See Also:

ReactiveX operators documentation: Timer

timer

public static Observable timer(long delay,
                                               java.util.concurrent.TimeUnit unit)

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

Backpressure:

This operator does not support backpressure as it uses time. If the downstream needs a slower rate it should slow the timer or use something like onBackpressureDrop(rx.functions.Action1).

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 emits one item after a specified delay, and then completes

See Also:

ReactiveX operators documentation: Timer

timer

public static Observable timer(long delay,
                                               java.util.concurrent.TimeUnit unit,
                                               Scheduler scheduler)

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

Backpressure:

This operator does not support backpressure as it uses time. If the downstream needs a slower rate it should slow the timer or use something like onBackpressureDrop(rx.functions.Action1).

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 one item after a specified delay, on a specified Scheduler, and then completes

See Also:

ReactiveX operators documentation: Timer

using

public static  Observable using(Func0 resourceFactory,
                                               Func1Observable> observableFactory,
                                               Action1 disposeAction)

Constructs an Observable that creates a dependent resource object which is disposed of on unsubscription.

Backpressure:

The operator is a pass-through for backpressure and otherwise depends on the backpressure support of the Observable returned by the resourceFactory.

Scheduler:

using does not operate by default on a particular Scheduler.

Type Parameters:

T - the element type of the generated Observable

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

Parameters:

resourceFactory - the factory function to create a resource object that depends on the Observable

observableFactory - the factory function to create an Observable

disposeAction - the function that will dispose of the resource

Returns:

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

See Also:

ReactiveX operators documentation: Using

using

public static  Observable using(Func0 resourceFactory,
                                               Func1Observable> observableFactory,
                                               Action1 disposeAction,
                                               boolean disposeEagerly)

Constructs an Observable that creates a dependent resource object which is disposed of just before termination if you have set disposeEagerly to true and unsubscription does not occur before termination. Otherwise resource disposal will occur on unsubscription. Eager disposal is particularly appropriate for a synchronous Observable that reuses resources. disposeAction will only be called once per subscription.

Backpressure:

The operator is a pass-through for backpressure and otherwise depends on the backpressure support of the Observable returned by the resourceFactory.

Scheduler:

using does not operate by default on a particular Scheduler.

Type Parameters:

T - the element type of the generated Observable

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

Parameters:

resourceFactory - the factory function to create a resource object that depends on the Observable

observableFactory - the factory function to create an Observable

disposeAction - the function that will dispose of the resource

disposeEagerly - if true then disposal will happen either on unsubscription or just before emission of a terminal event (onComplete or onError).

Returns:

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

Since:

1.3

See Also:

ReactiveX operators documentation: Using

zip

public static  Observable zip(java.lang.IterableObservable> ws,
                                    FuncN zipFunction)

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

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

The resulting Observable returned from zip will invoke onNext as many times as the number of onNext invocations of the source Observable 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 unsubscribing the other sources. Therefore, it is possible those other sources will never be able to run to completion (and thus not calling doOnCompleted()). 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 unsubscribe B immediately. For example:

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

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

Backpressure:

The operator expects backpressure from the sources and honors backpressure from the downstream. (I.e., zipping with interval(long, TimeUnit) may result in MissingBackpressureException, use one of the onBackpressureX to handle similar, backpressure-ignoring sources.

Scheduler:

zip does not operate by default on a particular Scheduler.

Type Parameters:

R - the zipped result type

Parameters:

ws - an Iterable of source Observables

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

Returns:

an Observable that emits the zipped results

See Also:

ReactiveX operators documentation: Zip

zip

public static  Observable zip(Observable[] ws,
                                    FuncN zipFunction)

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

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

The resulting Observable returned from zip will invoke onNext as many times as the number of onNext invocations of the source Observable 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 unsubscribing the other sources. Therefore, it is possible those other sources will never be able to run to completion (and thus not calling doOnCompleted()). 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 unsubscribe B immediately. For example:

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

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

Backpressure:

The operator expects backpressure from the sources and honors backpressure from the downstream. (I.e., zipping with interval(long, TimeUnit) may result in MissingBackpressureException, use one of the onBackpressureX to handle similar, backpressure-ignoring sources.

Scheduler:

zip does not operate by default on a particular Scheduler.

Type Parameters:

R - the result type

Parameters:

ws - an array of source Observables

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

Returns:

an Observable that emits the zipped results

Since:

1.3

See Also:

ReactiveX operators documentation: Zip

zip

public static  Observable zip(ObservableObservable> ws,
                                    FuncN zipFunction)

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

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

The resulting Observable returned from zip will invoke onNext as many times as the number of onNext invocations of the source Observable 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 unsubscribing the other sources. Therefore, it is possible those other sources will never be able to run to completion (and thus not calling doOnCompleted()). 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 unsubscribe B immediately. For example:

zip(just(range(1, 5).doOnCompleted(action1), range(6, 5).doOnCompleted(action2)), (a) -> a)

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

Backpressure:

The operator expects backpressure from the sources and honors backpressure from the downstream. (I.e., zipping with interval(long, TimeUnit) may result in MissingBackpressureException, use one of the onBackpressureX to handle similar, backpressure-ignoring sources.

Scheduler:

zip does not operate by default on a particular Scheduler.

Type Parameters:

R - the zipped result type

Parameters:

ws - an Observable of source Observables

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

Returns:

an Observable that emits the zipped results

See Also:

ReactiveX operators documentation: Zip

zip

public static  Observable zip(Observable o1,
                                          Observable o2,
                                          Func2 zipFunction)

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

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

The resulting Observable returned from zip will invoke onNext as many times as the number of onNext invocations of the source Observable 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 unsubscribing the other sources. Therefore, it is possible those other sources will never be able to run to completion (and thus not calling doOnCompleted()). 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 unsubscribe B immediately. For example:

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

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

Backpressure:

The operator expects backpressure from the sources and honors backpressure from the downstream. (I.e., zipping with interval(long, TimeUnit) may result in MissingBackpressureException, use one of the onBackpressureX to handle similar, backpressure-ignoring sources.

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:

o1 - the first source Observable

o2 - a second source Observable

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

Returns:

an Observable that emits the zipped results

See Also:

ReactiveX operators documentation: Zip

zip

public static  Observable zip(Observable o1,
                                             Observable o2,
                                             Observable o3,
                                             Func3 zipFunction)

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

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

The resulting Observable returned from zip will invoke onNext as many times as the number of onNext invocations of the source Observable 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 unsubscribing the other sources. Therefore, it is possible those other sources will never be able to run to completion (and thus not calling doOnCompleted()). 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 unsubscribe B immediately. For example:

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

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

Backpressure:

The operator expects backpressure from the sources and honors backpressure from the downstream. (I.e., zipping with interval(long, TimeUnit) may result in MissingBackpressureException, use one of the onBackpressureX to handle similar, backpressure-ignoring sources.

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:

o1 - the first source Observable

o2 - a second source Observable

o3 - a third source Observable

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

Returns:

an Observable that emits the zipped results

See Also:

ReactiveX operators documentation: Zip

zip

public static  Observable zip(Observable o1,
                                                Observable o2,
                                                Observable o3,
                                                Observable o4,
                                                Func4 zipFunction)

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

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

The resulting Observable returned from zip will invoke onNext as many times as the number of onNext invocations of the source Observable 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 unsubscribing the other sources. Therefore, it is possible those other sources will never be able to run to completion (and thus not calling doOnCompleted()). 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 unsubscribe B immediately. For example:

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

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

Backpressure:

The operator expects backpressure from the sources and honors backpressure from the downstream. (I.e., zipping with interval(long, TimeUnit) may result in MissingBackpressureException, use one of the onBackpressureX to handle similar, backpressure-ignoring sources.

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:

o1 - the first source Observable

o2 - a second source Observable

o3 - a third source Observable

o4 - a fourth source Observable

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

Returns:

an Observable that emits the zipped results

See Also:

ReactiveX operators documentation: Zip

zip

public static  Observable zip(Observable o1,
                                                   Observable o2,
                                                   Observable o3,
                                                   Observable o4,
                                                   Observable o5,
                                                   Func5 zipFunction)

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

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

The resulting Observable returned from zip will invoke onNext as many times as the number of onNext invocations of the source Observable 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 unsubscribing the other sources. Therefore, it is possible those other sources will never be able to run to completion (and thus not calling doOnCompleted()). 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 unsubscribe B immediately. For example:

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

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

Backpressure:

The operator expects backpressure from the sources and honors backpressure from the downstream. (I.e., zipping with interval(long, TimeUnit) may result in MissingBackpressureException, use one of the onBackpressureX to handle similar, backpressure-ignoring sources.

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:

o1 - the first source Observable

o2 - a second source Observable

o3 - a third source Observable

o4 - a fourth source Observable

o5 - a fifth source Observable

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

Returns:

an Observable that emits the zipped results

See Also:

ReactiveX operators documentation: Zip

zip

public static  Observable zip(Observable o1,
                                                      Observable o2,
                                                      Observable o3,
                                                      Observable o4,
                                                      Observable o5,
                                                      Observable o6,
                                                      Func6 zipFunction)

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

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

The resulting Observable returned from zip will invoke onNext as many times as the number of onNext invocations of the source Observable 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 unsubscribing the other sources. Therefore, it is possible those other sources will never be able to run to completion (and thus not calling doOnCompleted()). 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 unsubscribe B immediately. For example:

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

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

Backpressure:

The operator expects backpressure from the sources and honors backpressure from the downstream. (I.e., zipping with interval(long, TimeUnit) may result in MissingBackpressureException, use one of the onBackpressureX to handle similar, backpressure-ignoring sources.

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:

o1 - the first source Observable

o2 - a second source Observable

o3 - a third source Observable

o4 - a fourth source Observable

o5 - a fifth source Observable

o6 - a sixth source Observable

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

Returns:

an Observable that emits the zipped results

See Also:

ReactiveX operators documentation: Zip

zip

public static  Observable zip(Observable o1,
                                                         Observable o2,
                                                         Observable o3,
                                                         Observable o4,
                                                         Observable o5,
                                                         Observable o6,
                                                         Observable o7,
                                                         Func7 zipFunction)

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

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

The resulting Observable returned from zip will invoke onNext as many times as the number of onNext invocations of the source Observable 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 unsubscribing the other sources. Therefore, it is possible those other sources will never be able to run to completion (and thus not calling doOnCompleted()). 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 unsubscribe B immediately. For example:

zip(range(1, 5).doOnCompleted(action1), range(6, 5).doOnCompleted(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 doOnUnsubscribed() as well or use using() to do cleanup in case of completion or unsubscription.

Backpressure:

The operator expects backpressure from the sources and honors backpressure from the downstream. (I.e., zipping with interval(long, TimeUnit) may result in MissingBackpressureException, use one of the onBackpressureX to handle similar, backpressure-ignoring sources.

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:

o1 - the first source Observable

o2 - a second source Observable

o3 - a third source Observable

o4 - a fourth source Observable

o5 - a fifth source Observable

o6 - a sixth source Observable

o7 - a seventh source Observable

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

Returns:

an Observable that emits the zipped results

See Also:

ReactiveX operators documentation: Zip

zip

public static  Observable zip(Observable o1,
                                                            Observable o2,
                                                            Observable o3,
                                                            Observable o4,
                                                            Observable o5,
                                                            Observable o6,
                                                            Observable o7,
                                                            Observable o8,
                                                            Func8 zipFunction)

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

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

The resulting Observable returned from zip will invoke onNext as many times as the number of onNext invocations of the source Observable 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 unsubscribing the other sources. Therefore, it is possible those other sources will never be able to run to completion (and thus not calling doOnCompleted()). 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 unsubscribe B immediately. For example:

zip(range(1, 5).doOnCompleted(action1), range(6, 5).doOnCompleted(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 doOnUnsubscribed() as well or use using() to do cleanup in case of completion or unsubscription.

Backpressure:

The operator expects backpressure from the sources and honors backpressure from the downstream. (I.e., zipping with interval(long, TimeUnit) may result in MissingBackpressureException, use one of the onBackpressureX to handle similar, backpressure-ignoring sources.

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:

o1 - the first source Observable

o2 - a second source Observable

o3 - a third source Observable

o4 - a fourth source Observable

o5 - a fifth source Observable

o6 - a sixth source Observable

o7 - a seventh source Observable

o8 - an eighth source Observable

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

Returns:

an Observable that emits the zipped results

See Also:

ReactiveX operators documentation: Zip

zip

public static  Observable zip(Observable o1,
                                                               Observable o2,
                                                               Observable o3,
                                                               Observable o4,
                                                               Observable o5,
                                                               Observable o6,
                                                               Observable o7,
                                                               Observable o8,
                                                               Observable o9,
                                                               Func9 zipFunction)

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

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

The resulting Observable returned from zip will invoke onNext as many times as the number of onNext invocations of the source Observable 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 unsubscribing the other sources. Therefore, it is possible those other sources will never be able to run to completion (and thus not calling doOnCompleted()). 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 unsubscribe B immediately. For example:

zip(range(1, 5).doOnCompleted(action1), range(6, 5).doOnCompleted(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 doOnUnsubscribed() as well or use using() to do cleanup in case of completion or unsubscription.

Backpressure:

The operator expects backpressure from the sources and honors backpressure from the downstream. (I.e., zipping with interval(long, TimeUnit) may result in MissingBackpressureException, use one of the onBackpressureX to handle similar, backpressure-ignoring sources.

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:

o1 - the first source Observable

o2 - a second source Observable

o3 - a third source Observable

o4 - a fourth source Observable

o5 - a fifth source Observable

o6 - a sixth source Observable

o7 - a seventh source Observable

o8 - an eighth source Observable

o9 - a ninth source Observable

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

Returns:

an Observable that emits the zipped results

See Also:

ReactiveX operators documentation: Zip

all

public final Observable all(Func1T,java.lang.Boolean> predicate)

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

Backpressure:

The operator honors backpressure from downstream and consumes the source Observable in an unbounded manner (i.e., without applying backpressure).

Scheduler:

all does not operate by default on a particular Scheduler.

Parameters:

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

Returns:

an Observable that emits true if all items emitted by the source Observable satisfy the predicate; otherwise, false

See Also:

ReactiveX operators documentation: All

ambWith

public final Observable<T> ambWith(ObservableT> t1)

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

Backpressure:

The operator itself doesn't interfere with backpressure which is determined by the winning Observable's backpressure behavior.

Scheduler:

amb does not operate by default on a particular Scheduler.

Parameters:

t1 - an Observable competing to react first

Returns:

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

See Also:

ReactiveX operators documentation: Amb

asObservable

public final Observable<T> asObservable()

Portrays a object of an Observable subclass as a simple Observable object. This is useful, for instance, when you have an implementation of a subclass of Observable but you want to hide the properties and methods of this subclass from whomever you are passing the Observable to.

Backpressure:

The operator itself doesn't interfere with backpressure which is determined by this Observable's backpressure behavior.

Scheduler:

asObservable does not operate by default on a particular Scheduler.

Returns:

an Observable that hides the identity of this Observable

buffer

public final  ObservableT>> buffer(Func0Observable> bufferClosingSelector)

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

Backpressure:

This operator does not support backpressure as it is instead controlled by the given Observables and buffers data. It requests Long.MAX_VALUE upstream and does not obey downstream requests.

Scheduler:

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

Type Parameters:

TClosing - the value type of the boundary-providing Observable

Parameters:

bufferClosingSelector - a Func0 that produces an Observable that governs the boundary between buffers. Whenever the source Observable 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 Observable each time the Observable created with the bufferClosingSelector argument emits an item

See Also:

ReactiveX operators documentation: Buffer

buffer

public final ObservableT>> buffer(int count)

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

Backpressure:

The operator honors backpressure from downstream and expects the source Observable to honor it as well, although not enforced; violation may lead to MissingBackpressureException somewhere downstream.

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 Observable

See Also:

ReactiveX operators documentation: Buffer

buffer

public final ObservableT>> buffer(int count,
                                                  int skip)

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

Backpressure:

The operator honors backpressure from downstream and expects the source Observable to honor it as well, although not enforced; violation may lead to MissingBackpressureException somewhere downstream.

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 Observable should be skipped before starting a new buffer. Note that when skip and count are equal, this is the same operation as buffer(int).

Returns:

an Observable that emits buffers for every skip item from the source Observable and containing at most count items

See Also:

ReactiveX operators documentation: Buffer

buffer

public final ObservableT>> buffer(long timespan,
                                                  long timeshift,
                                                  java.util.concurrent.TimeUnit unit)

Returns an Observable that emits buffers of items it collects from the source Observable. The resulting Observable starts a new buffer periodically, as determined by the timeshift argument. It emits each buffer after a fixed timespan, specified by the timespan argument. When the source Observable completes or encounters an error, the resulting Observable emits the current buffer and propagates the notification from the source Observable.

Backpressure:

This operator does not support backpressure as it uses time. It requests Long.MAX_VALUE upstream and does not obey downstream requests.

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

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

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

Returns:

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

See Also:

ReactiveX operators documentation: Buffer

buffer

public final ObservableT>> buffer(long timespan,
                                                  long timeshift,
                                                  java.util.concurrent.TimeUnit unit,
                                                  Scheduler scheduler)

Returns an Observable that emits buffers of items it collects from the source Observable. The resulting Observable starts a new buffer periodically, as determined by the timeshift argument, and on the specified scheduler. It emits each buffer after a fixed timespan, specified by the timespan argument. When the source Observable completes or encounters an error, the resulting Observable emits the current buffer and propagates the notification from the source Observable.

Backpressure:

This operator does not support backpressure as it uses time. It requests Long.MAX_VALUE upstream and does not obey downstream requests.

Scheduler:

you specify which Scheduler this operator will use

Parameters:

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

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

unit - the unit of time that applies to the timespan and timeshift 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 Observable periodically after a fixed timespan has elapsed

See Also:

ReactiveX operators documentation: Buffer

buffer

public final ObservableT>> buffer(long timespan,
                                                  java.util.concurrent.TimeUnit unit)

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

Backpressure:

This operator does not support backpressure as it uses time. It requests Long.MAX_VALUE upstream and does not obey downstream requests.

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 Observable within a fixed duration

See Also:

ReactiveX operators documentation: Buffer

buffer

public final ObservableT>> buffer(long timespan,
                                                  java.util.concurrent.TimeUnit unit,
                                                  int count)

Returns an Observable that emits buffers of items it collects from the source Observable. The resulting Observable emits connected, non-overlapping buffers, each of a fixed duration specified by the timespan argument or a maximum size specified by the count argument (whichever is reached first). When the source Observable completes or encounters an error, the resulting Observable emits the current buffer and propagates the notification from the source Observable.

Backpressure:

This operator does not support backpressure as it uses time. It requests Long.MAX_VALUE upstream and does not obey downstream requests.

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 Observable, after a fixed duration or when the buffer reaches maximum capacity (whichever occurs first)

See Also:

ReactiveX operators documentation: Buffer

buffer

public final ObservableT>> buffer(long timespan,
                                                  java.util.concurrent.TimeUnit unit,
                                                  int count,
                                                  Scheduler scheduler)

Returns an Observable that emits buffers of items it collects from the source Observable. The resulting Observable emits connected, non-overlapping buffers, each of a fixed duration specified by the timespan argument as measured on the specified scheduler, or a maximum size specified by the count argument (whichever is reached first). When the source Observable completes or encounters an error, the resulting Observable emits the current buffer and propagates the notification from the source Observable.

Backpressure:

This operator does not support backpressure as it uses time. It requests Long.MAX_VALUE upstream and does not obey downstream requests.

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

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

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 Observable after a fixed duration or when the buffer reaches maximum capacity (whichever occurs first)

See Also:

ReactiveX operators documentation: Buffer

buffer

public final ObservableT>> buffer(long timespan,
                                                  java.util.concurrent.TimeUnit unit,
                                                  Scheduler scheduler)

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

Backpressure:

This operator does not support backpressure as it uses time. It requests Long.MAX_VALUE upstream and does not obey downstream requests.

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 Observable within a fixed duration

See Also:

ReactiveX operators documentation: Buffer

buffer

public final  ObservableT>> buffer(Observable bufferOpenings,
                                                                      Func1Observable> bufferClosingSelector)

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

Backpressure:

This operator does not support backpressure as it is instead controlled by the given Observables and buffers data. It requests Long.MAX_VALUE upstream and does not obey downstream requests.

Scheduler:

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

Type Parameters:

TOpening - the element type of the buffer-opening Observable

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

Parameters:

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

bufferClosingSelector - the Func1 that is used to produce an Observable for every buffer created. When this Observable emits an item, the associated buffer is emitted.

Returns:

an Observable that emits buffers, containing items from the source Observable, that are created and closed when the specified Observables emit items

See Also:

ReactiveX operators documentation: Buffer

buffer

public final  ObservableT>> buffer(Observable boundary)

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

Completion of either the source or the boundary Observable causes the returned Observable to emit the latest buffer and complete.

Backpressure:

This operator does not support backpressure as it is instead controlled by the Observable boundary and buffers data. It requests Long.MAX_VALUE upstream and does not obey downstream requests.

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 Observable

Returns:

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

See Also:

buffer(rx.Observable, int), ReactiveX operators documentation: Buffer

buffer

public final  ObservableT>> buffer(Observable boundary,
                                                      int initialCapacity)

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

Completion of either the source or the boundary Observable causes the returned Observable to emit the latest buffer and complete.

Backpressure:

This operator does not support backpressure as it is instead controlled by the Observable boundary and buffers data. It requests Long.MAX_VALUE upstream and does not obey downstream requests.

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 Observable

initialCapacity - the initial capacity of each buffer chunk

Returns:

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

See Also:

ReactiveX operators documentation: Buffer, buffer(rx.Observable, int)

cache

public final Observable<T> cache()

Returns an Observable that subscribes to this Observable 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 Observable to cache responses and you can't control the subscribe/unsubscribe behavior of all the Subscribers.

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

Note: You sacrifice the ability to unsubscribe from the origin when you use the cache Observer so be careful not to use this Observer on Observables that emit an infinite or very large number of items that will use up memory. A possible workaround is to apply `takeUntil` with a predicate or another source before (and perhaps after) the application of cache().

 AtomicBoolean shouldStop = new AtomicBoolean();

 source.takeUntil(v -> shouldStop.get())
       .cache()
       .takeUntil(v -> shouldStop.get())
       .subscribe(...);
 

Since the operator doesn't allow clearing the cached values either, the possible workaround is to forget all references to it via onTerminateDetach() applied along with the previous workaround:

 AtomicBoolean shouldStop = new AtomicBoolean();

 source.takeUntil(v -> shouldStop.get())
       .onTerminateDetach()
       .cache()
       .takeUntil(v -> shouldStop.get())
       .onTerminateDetach()
       .subscribe(...);
 

Backpressure:

The operator consumes this Observable in an unbounded fashion but respects the backpressure of each downstream Subscriber individually.

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

cache

@Deprecated
public final Observable<T> cache(int initialCapacity)

Deprecated. Use cacheWithInitialCapacity(int) instead.

Caches and shares everything from this Observable and uses the initialCapacity to reduce the number of times the internal buffer needs resizing.

Parameters:

initialCapacity - the capacity to start with

Returns:

the new Observable instance with the specific behavior.

See Also:

cacheWithInitialCapacity(int)

cacheWithInitialCapacity

public final Observable<T> cacheWithInitialCapacity(int initialCapacity)

Returns an Observable that subscribes to this Observable 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 Observable to cache responses and you can't control the subscribe/unsubscribe behavior of all the Subscribers.

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

Note: You sacrifice the ability to unsubscribe from the origin when you use the cache Observer so be careful not to use this Observer on Observables that emit an infinite or very large number of items that will use up memory. A possible workaround is to apply `takeUntil` with a predicate or another source before (and perhaps after) the application of cache().

 AtomicBoolean shouldStop = new AtomicBoolean();

 source.takeUntil(v -> shouldStop.get())
       .cache()
       .takeUntil(v -> shouldStop.get())
       .subscribe(...);
 

Since the operator doesn't allow clearing the cached values either, the possible workaround is to forget all references to it via onTerminateDetach() applied along with the previous workaround:

 AtomicBoolean shouldStop = new AtomicBoolean();

 source.takeUntil(v -> shouldStop.get())
       .onTerminateDetach()
       .cache()
       .takeUntil(v -> shouldStop.get())
       .onTerminateDetach()
       .subscribe(...);
 

Backpressure:

The operator consumes this Observable in an unbounded fashion but respects the backpressure of each downstream Subscriber individually.

Scheduler:

cache 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

public final  Observable cast(java.lang.Class klass)

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

Backpressure:

The operator doesn't interfere with backpressure which is determined by the source Observable's backpressure behavior.

Scheduler:

cast does not operate by default on a particular Scheduler.

Type Parameters:

R - the output value type cast to

Parameters:

klass - the target class type that cast will cast the items emitted by the source Observable into before emitting them from the resulting Observable

Returns:

an Observable that emits each item from the source Observable after converting it to the specified type

See Also:

ReactiveX operators documentation: Map

collect

public final  Observable collect(Func0 stateFactory,
                                       Action2T> collector)

Collects items emitted by the source Observable into a single mutable data structure and returns an Observable that emits this structure.

This is a simplified version of reduce that does not need to return the state on each pass.

Backpressure:

This operator does not support backpressure because by intent it will receive all values and reduce them to a single onNext.

Scheduler:

collect does not operate by default on a particular Scheduler.

Type Parameters:

R - the accumulator and output type

Parameters:

stateFactory - 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:

an Observable that emits the result of collecting the values emitted by the source Observable into a single mutable data structure

See Also:

ReactiveX operators documentation: Reduce

concatMap

public final  Observable concatMap(Func1T,? extends Observable> func)

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

Backpressure:

The operator honors backpressure from downstream. Both this and the inner Observables are expected to honor backpressure as well. If the source Observable violates the rule, the operator will signal a MissingBackpressureException. If any of the inner Observables doesn't honor backpressure, that may throw an IllegalStateException when that Observable completes.

Scheduler:

concatMap does not operate by default on a particular Scheduler.

Type Parameters:

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

Parameters:

func - a function that, when applied to an item emitted by the source Observable, returns an Observable

Returns:

an Observable that emits the result of applying the transformation function to each item emitted by the source Observable and concatenating the Observables obtained from this transformation

See Also:

ReactiveX operators documentation: FlatMap

concatMapDelayError

public final  Observable concatMapDelayError(Func1T,? extends Observable> func)

Maps each of the items into an Observable, 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 Observables till all of them terminate.

Backpressure:

The operator honors backpressure from downstream. Both this and the inner Observables are expected to honor backpressure as well. If the source Observable violates the rule, the operator will signal a MissingBackpressureException. If any of the inner Observables doesn't honor backpressure, that may throw an IllegalStateException when that Observable completes.

Scheduler:

concatMapDelayError does not operate by default on a particular Scheduler.

Type Parameters:

R - the result value type

Parameters:

func - the function that maps the items of this Observable into the inner Observables.

Returns:

the new Observable instance with the concatenation behavior

Since:

1.3

concatMapIterable

public final  Observable concatMapIterable(Func1T,? extends java.lang.Iterable> collectionSelector)

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

Backpressure:

The operator honors backpressure from downstream. The source Observables is expected to honor backpressure as well. If the source Observable violates the rule, the operator will signal a MissingBackpressureException.

Scheduler:

concatMapIterable does not operate by default on a particular Scheduler.

Type Parameters:

R - the type of item emitted by the resulting Observable

Parameters:

collectionSelector - a function that returns an Iterable sequence of values for when given an item emitted by the source Observable

Returns:

an Observable that emits the results of concatenating the items emitted by the source Observable with the values in the Iterables corresponding to those items, as generated by collectionSelector

See Also:

ReactiveX operators documentation: FlatMap

concatWith

public final Observable<T> concatWith(ObservableT> t1)

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

Backpressure:

The operator honors backpressure from downstream. Both this and the other Observables are expected to honor backpressure as well. If any of then violates this rule, it may throw an IllegalStateException when the source Observable completes.

Scheduler:

concat does not operate by default on a particular Scheduler.

Parameters:

t1 - an Observable to be concatenated after the current

Returns:

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

See Also:

ReactiveX operators documentation: Concat

contains

public final Observable contains(java.lang.Object element)

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

Backpressure:

The operator honors backpressure from downstream and consumes the source Observable in an unbounded manner (i.e., without applying backpressure).

Scheduler:

contains does not operate by default on a particular Scheduler.

Parameters:

element - the item to search for in the emissions from the source Observable

Returns:

an Observable that emits true if the specified item is emitted by the source Observable, or false if the source Observable completes without emitting that item

See Also:

ReactiveX operators documentation: Contains

count

public final Observable count()

Returns an Observable that emits the count of the total number of items emitted by the source Observable.

Backpressure:

The operator honors backpressure from downstream and consumes the source Observable in an unbounded manner (i.e., without applying backpressure).

Scheduler:

count does not operate by default on a particular Scheduler.

Returns:

an Observable that emits a single item: the number of elements emitted by the source Observable

See Also:

ReactiveX operators documentation: Count, countLong()

countLong

public final Observable countLong()

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

Backpressure:

The operator honors backpressure from downstream and consumes the source Observable in an unbounded manner (i.e., without applying backpressure).

Scheduler:

countLong does not operate by default on a particular Scheduler.

Returns:

an Observable that emits a single item: the number of items emitted by the source Observable as a 64-bit Long item

See Also:

ReactiveX operators documentation: Count, count()

debounce

public final  Observable<T> debounce(Func1T,? extends Observable> debounceSelector)

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

Backpressure:

This operator does not support backpressure as it uses the debounceSelector to mark boundaries.

Scheduler:

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

Type Parameters:

U - the debounce value type (ignored)

Parameters:

debounceSelector - function to retrieve a sequence that indicates the throttle duration for each item

Returns:

an Observable that omits items emitted by the source Observable that are followed by another item within a computed debounce duration

See Also:

ReactiveX operators documentation: Debounce, RxJava wiki: Backpressure

debounce

public final Observable<T> debounce(long timeout,
                                    java.util.concurrent.TimeUnit unit)

Returns an Observable that mirrors the source Observable, except that it drops items emitted by the source Observable that are followed by newer items before a timeout value expires. The timer resets on each emission.

Note: If items keep being emitted by the source Observable faster than the timeout then no items will be emitted by the resulting Observable.

Information on debounce vs throttle:

• Debounce and Throttle: visual explanation
• Debouncing: javascript methods
• Javascript - don't spam your server: debounce and throttle

Backpressure:

This operator does not support backpressure as it uses time to control data flow.

Scheduler:

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

Parameters:

timeout - the time each item has to be "the most recent" of those emitted by the source Observable to ensure that it's not dropped

unit - the TimeUnit for the timeout

Returns:

an Observable that filters out items from the source Observable that are too quickly followed by newer items

See Also:

ReactiveX operators documentation: Debounce, RxJava wiki: Backpressure, throttleWithTimeout(long, TimeUnit)

debounce

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

Returns an Observable that mirrors the source Observable, except that it drops items emitted by the source Observable that are followed by newer items before a timeout value expires on a specified Scheduler. The timer resets on each emission.

Note: If items keep being emitted by the source Observable faster than the timeout then no items will be emitted by the resulting Observable.

Information on debounce vs throttle:

• Debounce and Throttle: visual explanation
• Debouncing: javascript methods
• Javascript - don't spam your server: debounce and throttle

Backpressure:

This operator does not support backpressure as it uses time to control data flow.

Scheduler:

you specify which Scheduler this operator will use

Parameters:

timeout - the time each item has to be "the most recent" of those emitted by the source Observable to ensure that it's not dropped

unit - the unit of time for the specified timeout

scheduler - the Scheduler to use internally to manage the timers that handle the timeout for each item

Returns:

an Observable that filters out items from the source Observable that are too quickly followed by newer items

See Also:

ReactiveX operators documentation: Debounce, RxJava wiki: Backpressure, throttleWithTimeout(long, TimeUnit, Scheduler)

defaultIfEmpty

public final Observable<T> defaultIfEmpty(T defaultValue)

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

Backpressure:

If the source Observable is empty, this operator is guaranteed to honor backpressure from downstream. If the source Observable is non-empty, it is expected to honor backpressure as well; if the rule is violated, a MissingBackpressureException may get signalled somewhere downstream.

Scheduler:

defaultIfEmpty does not operate by default on a particular Scheduler.

Parameters:

defaultValue - the item to emit if the source Observable emits no items

Returns:

an Observable that emits either the specified default item if the source Observable emits no items, or the items emitted by the source Observable

See Also:

ReactiveX operators documentation: DefaultIfEmpty

switchIfEmpty

public final Observable<T> switchIfEmpty(ObservableT> alternate)

Returns an Observable that emits the items emitted by the source Observable or the items of an alternate Observable if the source Observable is empty.

Backpressure:

If the source Observable is empty, the alternate Observable is expected to honor backpressure. If the source Observable is non-empty, it is expected to honor backpressure as instead. In either case, if violated, a MissingBackpressureException may get signalled somewhere downstream.

Scheduler:

switchIfEmpty does not operate by default on a particular Scheduler.

Parameters:

alternate - the alternate Observable to subscribe to if the source does not emit any items

Returns:

an Observable that emits the items emitted by the source Observable or the items of an alternate Observable if the source Observable is empty.

Throws:

java.lang.NullPointerException - if alternate is null

Since:

1.1.0

delay

public final  Observable<T> delay(Func0Observable> subscriptionDelay,
                                       Func1T,? extends Observable> itemDelay)

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

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

Backpressure:

The operator doesn't interfere with the backpressure behavior which is determined by the source Observable. All of the other Observables supplied by the functions are consumed in an unbounded manner (i.e., no backpressure applied to them).

Scheduler:

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

Type Parameters:

U - the subscription delay value type (ignored)

V - the item delay value type (ignored)

Parameters:

subscriptionDelay - a function that returns an Observable that triggers the subscription to the source Observable once it emits any item

itemDelay - a function that returns an Observable for each item emitted by the source Observable, which is then used to delay the emission of that item by the resulting Observable until the Observable returned from itemDelay emits an item

Returns:

an Observable that delays the subscription and emissions of the source Observable via another Observable on a per-item basis

See Also:

ReactiveX operators documentation: Delay

delay

public final  Observable<T> delay(Func1T,? extends Observable> itemDelay)

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

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

Backpressure:

The operator doesn't interfere with the backpressure behavior which is determined by the source Observable. All of the other Observables supplied by the function are consumed in an unbounded manner (i.e., no backpressure applied to them).

Scheduler:

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

Type Parameters:

U - the item delay value type (ignored)

Parameters:

itemDelay - a function that returns an Observable for each item emitted by the source Observable, which is then used to delay the emission of that item by the resulting Observable until the Observable returned from itemDelay emits an item

Returns:

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

See Also:

ReactiveX operators documentation: Delay

delay

public final Observable<T> delay(long delay,
                                 java.util.concurrent.TimeUnit unit)

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

Backpressure:

The operator doesn't interfere with the backpressure behavior which is determined by the source Observable.

Scheduler:

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

Parameters:

delay - the delay to shift the source by

unit - the TimeUnit in which period is defined

Returns:

the source Observable shifted in time by the specified delay

See Also:

ReactiveX operators documentation: Delay

delay

public final Observable<T> delay(long delay,
                                 java.util.concurrent.TimeUnit unit,
                                 Scheduler scheduler)

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

Backpressure:

The operator doesn't interfere with the backpressure behavior which is determined by the source Observable.

Scheduler:

you specify which Scheduler this operator will use

Parameters:

delay - the delay to shift the source by

unit - the time unit of delay

scheduler - the Scheduler to use for delaying

Returns:

the source Observable shifted in time by the specified delay

See Also:

ReactiveX operators documentation: Delay

delaySubscription

public final Observable<T> delaySubscription(long delay,
                                             java.util.concurrent.TimeUnit unit)

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

Backpressure:

The operator doesn't interfere with the backpressure behavior which is determined by the source Observable.

Scheduler:

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

Parameters:

delay - the time to delay the subscription

unit - the time unit of delay

Returns:

an Observable that delays the subscription to the source Observable by the given amount

See Also:

ReactiveX operators documentation: Delay

delaySubscription

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

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

Backpressure:

The operator doesn't interfere with the backpressure behavior which is determined by the source Observable.

Scheduler:

you specify which Scheduler this operator will use

Parameters:

delay - the time to delay the subscription

unit - the time unit of delay

scheduler - the Scheduler on which the waiting and subscription will happen

Returns:

an Observable that delays the subscription to the source Observable by a given amount, waiting and subscribing on the given Scheduler

See Also:

ReactiveX operators documentation: Delay

delaySubscription

public final  Observable<T> delaySubscription(Func0Observable> subscriptionDelay)

Returns an Observable that delays the subscription to the source Observable until a second Observable emits an item.

Backpressure:

The operator doesn't interfere with the backpressure behavior which is determined by the source Observable. The other Observables supplied by the function is consumed in an unbounded manner (i.e., no backpressure applied to it).

Scheduler:

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

Type Parameters:

U - the element type of the delaying Observable

Parameters:

subscriptionDelay - a function that returns an Observable that triggers the subscription to the source Observable once it emits any item

Returns:

an Observable that delays the subscription to the source Observable until the Observable returned by subscriptionDelay emits an item

See Also:

ReactiveX operators documentation: Delay

delaySubscription

public final  Observable<T> delaySubscription(Observable other)

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

Backpressure:

The operator forwards the backpressure requests to this Observable once the subscription happens and requests Long.MAX_VALUE from the other Observable

Scheduler:

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

Type Parameters:

U - the value type of the other Observable, irrelevant

Parameters:

other - the other Observable that should trigger the subscription to this Observable.

Returns:

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

Since:

1.3

dematerialize

public final  Observable dematerialize()

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

Backpressure:

The operator doesn't interfere with backpressure which is determined by the source Observable's backpressure behavior.

Scheduler:

dematerialize does not operate by default on a particular Scheduler.

Type Parameters:

T2 - the output value type

Returns:

an Observable that emits the items and notifications embedded in the Notification objects emitted by the source Observable

Throws:

OnErrorNotImplementedException - if the source Observable is not of type Observable>

See Also:

ReactiveX operators documentation: Dematerialize

distinct

public final Observable<T> distinct()

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

Backpressure:

The operator doesn't interfere with backpressure which is determined by the source Observable's backpressure behavior.

Scheduler:

distinct does not operate by default on a particular Scheduler.

Returns:

an Observable that emits only those items emitted by the source Observable that are distinct from each other

See Also:

ReactiveX operators documentation: Distinct

distinct

public final  Observable<T> distinct(Func1T,? extends U> keySelector)

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

Backpressure:

The operator doesn't interfere with backpressure which is determined by the source Observable's backpressure behavior.

Scheduler:

distinct does not operate by default on a particular Scheduler.

Type Parameters:

U - the key type

Parameters:

keySelector - a function that projects an emitted item to a key value that is used to decide whether an item is distinct from another one or not

Returns:

an Observable that emits those items emitted by the source Observable that have distinct keys

See Also:

ReactiveX operators documentation: Distinct

distinctUntilChanged

public final Observable<T> distinctUntilChanged()

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

Backpressure:

The operator doesn't interfere with backpressure which is determined by the source Observable's backpressure behavior.

Scheduler:

distinctUntilChanged does not operate by default on a particular Scheduler.

Returns:

an Observable that emits those items from the source Observable that are distinct from their immediate predecessors

See Also:

ReactiveX operators documentation: Distinct

distinctUntilChanged

public final  Observable<T> distinctUntilChanged(Func1T,? extends U> keySelector)

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

Backpressure:

The operator doesn't interfere with backpressure which is determined by the source Observable's backpressure behavior.

Scheduler:

distinctUntilChanged does not operate by default on a particular Scheduler.

Type Parameters:

U - the key type

Parameters:

keySelector - a function that projects an emitted item to a key value that is used to decide whether an item is distinct from another one or not

Returns:

an Observable that emits those items from the source Observable whose keys are distinct from those of their immediate predecessors

See Also:

ReactiveX operators documentation: Distinct

distinctUntilChanged

public final Observable<T> distinctUntilChanged(Func2T,? super T,java.lang.Boolean> comparator)

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

Backpressure:

The operator doesn't interfere with backpressure which is determined by the source Observable's backpressure behavior.

Scheduler:

distinctUntilChanged does not operate by default on a particular Scheduler.

Parameters:

comparator - the function that receives the previous item and the current item and is expected to return true if the two are equal, thus skipping the current value.

Returns:

an Observable that emits those items from the source Observable that are distinct from their immediate predecessors

Since:

1.3

See Also:

ReactiveX operators documentation: Distinct

doOnCompleted

public final Observable<T> doOnCompleted(Action0 onCompleted)

Modifies the source Observable so that it invokes an action when it calls onCompleted.

Backpressure:

The operator doesn't interfere with backpressure which is determined by the source Observable's backpressure behavior.

Scheduler:

doOnCompleted does not operate by default on a particular Scheduler.

Parameters:

onCompleted - the action to invoke when the source Observable calls onCompleted

Returns:

the source Observable with the side-effecting behavior applied

See Also:

ReactiveX operators documentation: Do

doOnEach

public final Observable<T> doOnEach(Action1<NotificationT>> onNotification)

Modifies the source Observable so that it invokes an action for each item and terminal event it emits.

Backpressure:

The operator doesn't interfere with backpressure which is determined by the source Observable's backpressure behavior.

Scheduler:

doOnEach does not operate by default on a particular Scheduler.

Parameters:

onNotification - the action to invoke for each item emitted by the source Observable

Returns:

the source Observable with the side-effecting behavior applied

See Also:

ReactiveX operators documentation: Do

doOnEach

public final Observable<T> doOnEach(ObserverT> observer)

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

In case the onError of the supplied observer throws, the downstream will receive a composite exception containing the original exception and the exception thrown by onError. If either the onNext or the onCompleted method of the supplied observer throws, the downstream will be terminated and will receive this thrown exception.

Backpressure:

The operator doesn't interfere with backpressure which is determined by the source Observable's backpressure behavior.

Scheduler:

doOnEach does not operate by default on a particular Scheduler.

Parameters:

observer - the observer to be notified about onNext, onError and onCompleted events on its respective methods before the actual downstream Subscriber gets notified.

Returns:

the source Observable with the side-effecting behavior applied

See Also:

ReactiveX operators documentation: Do

doOnError

public final Observable<T> doOnError(Action1 onError)

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

In case the onError action throws, the downstream will receive a composite exception containing the original exception and the exception thrown by onError.

Backpressure:

The operator doesn't interfere with backpressure which is determined by the source Observable's backpressure behavior.

Scheduler:

doOnError does not operate by default on a particular Scheduler.

Parameters:

onError - the action to invoke if the source Observable calls onError

Returns:

the source Observable with the side-effecting behavior applied

See Also:

ReactiveX operators documentation: Do

doOnNext

public final Observable<T> doOnNext(Action1T> onNext)

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

Backpressure:

The operator doesn't interfere with backpressure which is determined by the source Observable's backpressure behavior.

Scheduler:

doOnNext does not operate by default on a particular Scheduler.

Parameters:

onNext - the action to invoke when the source Observable calls onNext

Returns:

the source Observable with the side-effecting behavior applied

See Also:

ReactiveX operators documentation: Do

doOnRequest

public final Observable<T> doOnRequest(Action1 onRequest)

Modifies the source Observable so that it invokes the given action when it receives a request for more items.

Note: This operator is for tracing the internal behavior of back-pressure request patterns and generally intended for debugging use.

Backpressure:

The operator doesn't interfere with backpressure which is determined by the source Observable's backpressure behavior.

Scheduler:

doOnRequest does not operate by default on a particular Scheduler.

Parameters:

onRequest - the action that gets called when an observer requests items from this Observable

Returns:

the source Observable modified so as to call this Action when appropriate

Since:

1.2

See Also:

ReactiveX operators documentation: Do

doOnSubscribe

public final Observable<T> doOnSubscribe(Action0 subscribe)

Modifies the source Observable so that it invokes the given action when it is subscribed from its subscribers. Each subscription will result in an invocation of the given action except when the source Observable is reference counted, in which case the source Observable will invoke the given action for the first subscription.

Backpressure:

The operator doesn't interfere with backpressure which is determined by the source Observable's backpressure behavior.

Scheduler:

doOnSubscribe does not operate by default on a particular Scheduler.

Parameters:

subscribe - the action that gets called when an observer subscribes to the source Observable

Returns:

the source Observable modified so as to call this Action when appropriate

See Also:

ReactiveX operators documentation: Do

doOnTerminate

public final Observable<T> doOnTerminate(Action0 onTerminate)

Modifies the source Observable so that it invokes an action when it calls onCompleted or onError.

This differs from finallyDo in that this happens before the onCompleted or onError notification.

Backpressure:

The operator doesn't interfere with backpressure which is determined by the source Observable's backpressure behavior.

Scheduler:

doOnTerminate does not operate by default on a particular Scheduler.

Parameters:

onTerminate - the action to invoke when the source Observable calls onCompleted or onError

Returns:

the source Observable with the side-effecting behavior applied

See Also:

ReactiveX operators documentation: Do, finallyDo(Action0)

doOnUnsubscribe

public final Observable<T> doOnUnsubscribe(Action0 unsubscribe)

Calls the unsubscribe Action0 if the downstream unsubscribes the sequence.

The action is shared between subscriptions and thus may be called concurrently from multiple threads; the action must be thread safe.

If the action throws a runtime exception, that exception is rethrown by the unsubscribe() call, sometimes as a CompositeException if there were multiple exceptions along the way.

Note that terminal events trigger the action unless the Observable is subscribed to via unsafeSubscribe().

Backpressure:

doOnUnsubscribe does not interact with backpressure requests or value delivery; backpressure behavior is preserved between its upstream and its downstream.

Scheduler:

doOnUnsubscribe does not operate by default on a particular Scheduler.

Parameters:

unsubscribe - the action that gets called when the source Observable is unsubscribed

Returns:

the source Observable modified so as to call this Action when appropriate

See Also:

ReactiveX operators documentation: Do

concatEager

public static  Observable concatEager(Observable o1,
                                            Observable o2)

Concatenates two source Observables eagerly into a single stream of values.

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

Backpressure:

Backpressure is honored towards the downstream, however, due to the eagerness requirement, sources are subscribed to in unbounded mode and their values are queued up in an unbounded buffer.

Scheduler:

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

Type Parameters:

T - the value type

Parameters:

o1 - the first source

o2 - the second source

Returns:

the new Observable instance with the specified concatenation behavior

Since:

1.3

concatEager

public static  Observable concatEager(Observable o1,
                                            Observable o2,
                                            Observable o3)

Concatenates three sources eagerly into a single stream of values.

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

Backpressure:

Backpressure is honored towards the downstream, however, due to the eagerness requirement, sources are subscribed to in unbounded mode and their values are queued up in an unbounded buffer.

Scheduler:

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

Type Parameters:

T - the value type

Parameters:

o1 - the first source

o2 - the second source

o3 - the third source

Returns:

the new Observable instance with the specified concatenation behavior

Since:

1.3

concatEager

public static  Observable concatEager(Observable o1,
                                            Observable o2,
                                            Observable o3,
                                            Observable o4)

Concatenates four sources eagerly into a single stream of values.

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

Backpressure:

Backpressure is honored towards the downstream, however, due to the eagerness requirement, sources are subscribed to in unbounded mode and their values are queued up in an unbounded buffer.

Scheduler:

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

Type Parameters:

T - the value type

Parameters:

o1 - the first source

o2 - the second source

o3 - the third source

o4 - the fourth source

Returns:

the new Observable instance with the specified concatenation behavior

Since:

1.3

concatEager

public static  Observable concatEager(Observable o1,
                                            Observable o2,
                                            Observable o3,
                                            Observable o4,
                                            Observable o5)

Concatenates five sources eagerly into a single stream of values.

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

Backpressure:

Backpressure is honored towards the downstream, however, due to the eagerness requirement, sources are subscribed to in unbounded mode and their values are queued up in an unbounded buffer.

Scheduler:

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

Type Parameters:

T - the value type

Parameters:

o1 - the first source

o2 - the second source

o3 - the third source

o4 - the fourth source

o5 - the fifth source

Returns:

the new Observable instance with the specified concatenation behavior

Since:

1.3

concatEager

public static  Observable concatEager(Observable o1,
                                            Observable o2,
                                            Observable o3,
                                            Observable o4,
                                            Observable o5,
                                            Observable o6)

Concatenates six sources eagerly into a single stream of values.

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

Backpressure:

Backpressure is honored towards the downstream, however, due to the eagerness requirement, sources are subscribed to in unbounded mode and their values are queued up in an unbounded buffer.

Scheduler:

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

Type Parameters:

T - the value type

Parameters:

o1 - the first source

o2 - the second source

o3 - the third source

o4 - the fourth source

o5 - the fifth source

o6 - the sixth source

Returns:

the new Observable instance with the specified concatenation behavior

Since:

1.3

concatEager

public static  Observable concatEager(Observable o1,
                                            Observable o2,
                                            Observable o3,
                                            Observable o4,
                                            Observable o5,
                                            Observable o6,
                                            Observable o7)

Concatenates seven sources eagerly into a single stream of values.

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

Backpressure:

Backpressure is honored towards the downstream, however, due to the eagerness requirement, sources are subscribed to in unbounded mode and their values are queued up in an unbounded buffer.

Scheduler:

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

Type Parameters:

T - the value type

Parameters:

o1 - the first source

o2 - the second source

o3 - the third source

o4 - the fourth source

o5 - the fifth source

o6 - the sixth source

o7 - the seventh source

Returns:

the new Observable instance with the specified concatenation behavior

Since:

1.3

concatEager

public static  Observable concatEager(Observable o1,
                                            Observable o2,
                                            Observable o3,
                                            Observable o4,
                                            Observable o5,
                                            Observable o6,
                                            Observable o7,
                                            Observable o8)

Concatenates eight sources eagerly into a single stream of values.

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

Backpressure:

Backpressure is honored towards the downstream, however, due to the eagerness requirement, sources are subscribed to in unbounded mode and their values are queued up in an unbounded buffer.

Scheduler:

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

Type Parameters:

T - the value type

Parameters:

o1 - the first source

o2 - the second source

o3 - the third source

o4 - the fourth source

o5 - the fifth source

o6 - the sixth source

o7 - the seventh source

o8 - the eighth source

Returns:

the new Observable instance with the specified concatenation behavior

Since:

1.3

concatEager

public static  Observable concatEager(Observable o1,
                                            Observable o2,
                                            Observable o3,
                                            Observable o4,
                                            Observable o5,
                                            Observable o6,
                                            Observable o7,
                                            Observable o8,
                                            Observable o9)

Concatenates nine sources eagerly into a single stream of values.

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

Backpressure:

Backpressure is honored towards the downstream, however, due to the eagerness requirement, sources are subscribed to in unbounded mode and their values are queued up in an unbounded buffer.

Scheduler:

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

Type Parameters:

T - the value type

Parameters:

o1 - the first source

o2 - the second source

o3 - the third source

o4 - the fourth source

o5 - the fifth source

o6 - the sixth source

o7 - the seventh source

o8 - the eighth source

o9 - the ninth source

Returns:

the new Observable instance with the specified concatenation behavior

Since:

1.3

concatEager

public static  Observable concatEager(java.lang.IterableObservable> sources)

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

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

Backpressure:

Backpressure is honored towards the downstream, however, due to the eagerness requirement, sources are subscribed to in unbounded mode and their values are queued up in an unbounded buffer.

Scheduler:

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

Type Parameters:

T - the value type

Parameters:

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

Returns:

the new Observable instance with the specified concatenation behavior

Since:

1.3

concatEager

public static  Observable concatEager(java.lang.IterableObservable> sources,
                                            int capacityHint)

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

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

Backpressure:

Backpressure is honored towards the downstream, however, due to the eagerness requirement, sources are subscribed to in unbounded mode and their values are queued up in an unbounded buffer.

Scheduler:

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

Type Parameters:

T - the value type

Parameters:

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

capacityHint - hints about the number of expected source sequence values

Returns:

the new Observable instance with the specified concatenation behavior

Since:

1.3

concatEager

public static  Observable concatEager(ObservableObservable> sources)

Concatenates an Observable sequence of Observables eagerly into a single stream of values.

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

Backpressure:

Backpressure is honored towards the downstream, however, due to the eagerness requirement, sources are subscribed to in unbounded mode and their values are queued up in an unbounded buffer.

Scheduler:

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

Type Parameters:

T - the value type

Parameters:

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

Returns:

the new Observable instance with the specified concatenation behavior

Since:

1.3

concatEager

public static  Observable concatEager(ObservableObservable> sources,
                                            int capacityHint)

Concatenates an Observable sequence of Observables eagerly into a single stream of values.

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

Backpressure:

Backpressure is honored towards the downstream, however, due to the eagerness requirement, sources are subscribed to in unbounded mode and their values are queued up in an unbounded buffer.

Scheduler:

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

Type Parameters:

T - the value type

Parameters:

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

capacityHint - hints about the number of expected source sequence values

Returns:

the new Observable instance with the specified concatenation behavior

Since:

1.3

concatMapEager

public final  Observable concatMapEager(Func1T,? extends Observable> mapper)

Maps a sequence of values into Observables and concatenates these Observables eagerly into a single Observable.

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

Backpressure:

Backpressure is honored towards the downstream, however, due to the eagerness requirement, sources are subscribed to in unbounded mode and their values are queued up in an unbounded buffer.

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 Observables that will be eagerly concatenated

Returns:

the new Observable instance with the specified concatenation behavior

Since:

1.3

concatMapEager

public final  Observable concatMapEager(Func1T,? extends Observable> mapper,
                                              int capacityHint)

Maps a sequence of values into Observables and concatenates these Observables eagerly into a single Observable.

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

Backpressure:

Backpressure is honored towards the downstream, however, due to the eagerness requirement, sources are subscribed to in unbounded mode and their values are queued up in an unbounded buffer.

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 Observables that will be eagerly concatenated

capacityHint - hints about the number of expected source sequence values

Returns:

the new Observable instance with the specified concatenation behavior

Since:

1.3

concatMapEager

public final  Observable concatMapEager(Func1T,? extends Observable> mapper,
                                              int capacityHint,
                                              int maxConcurrent)

Maps a sequence of values into Observables and concatenates these Observables eagerly into a single Observable.

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

Backpressure:

Backpressure is honored towards the downstream, however, due to the eagerness requirement, sources are subscribed to in unbounded mode and their values are queued up in an unbounded buffer.

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 Observables that will be eagerly concatenated

capacityHint - hints about the number of expected source sequence values

maxConcurrent - the maximum number of concurrent subscribed observables

Returns:

the new Observable instance with the specified concatenation behavior

Since:

1.3

elementAt

public final Observable<T> elementAt(int index)

Returns an Observable that emits the single item at a specified index in a sequence of emissions from a source Observable.

Backpressure:

The operator honors backpressure from downstream and consumes the source Observable in an unbounded manner (i.e., no backpressure applied to it).

Scheduler:

elementAt does not operate by default on a particular Scheduler.

Parameters:

index - the zero-based index of the item to retrieve

Returns:

an Observable that emits a single item: the item at the specified position in the sequence of those emitted by the source Observable

Throws:

java.lang.IndexOutOfBoundsException - if index is greater than or equal to the number of items emitted by the source Observable, or if index is less than 0

See Also:

ReactiveX operators documentation: ElementAt

elementAtOrDefault

public final Observable<T> elementAtOrDefault(int index,
                                              T defaultValue)

Returns an Observable that emits the item found at a specified index in a sequence of emissions from a source Observable, or a default item if that index is out of range.

Backpressure:

The operator honors backpressure from downstream and consumes the source Observable in an unbounded manner (i.e., no backpressure applied to it).

Scheduler:

elementAtOrDefault does not operate by default on a particular Scheduler.

Parameters:

index - the zero-based index of the item to retrieve

defaultValue - the default item

Returns:

an Observable that emits the item at the specified position in the sequence emitted by the source Observable, or the default item if that index is outside the bounds of the source sequence

Throws:

java.lang.IndexOutOfBoundsException - if index is less than 0

See Also:

ReactiveX operators documentation: ElementAt

exists

public final Observable exists(Func1T,java.lang.Boolean> predicate)

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

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

Backpressure:

The operator honors backpressure from downstream and consumes the source Observable in an unbounded manner (i.e., no backpressure applied to it).

Scheduler:

exists does not operate by default on a particular Scheduler.

Parameters:

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

Returns:

an Observable that emits a Boolean that indicates whether any item emitted by the source Observable satisfies the predicate

See Also:

ReactiveX operators documentation: Contains

filter

public final Observable<T> filter(Func1T,java.lang.Boolean> predicate)

Filters items emitted by an Observable by only emitting those that satisfy a specified predicate.

Backpressure:

The operator doesn't interfere with backpressure which is determined by the source Observable's backpressure behavior.

Scheduler:

filter does not operate by default on a particular Scheduler.

Parameters:

predicate - a function that evaluates each item emitted by the source Observable, returning true if it passes the filter

Returns:

an Observable that emits only those items emitted by the source Observable that the filter evaluates as true

See Also:

ReactiveX operators documentation: Filter

finallyDo

@Deprecated
public final Observable<T> finallyDo(Action0 action)

Deprecated. use doAfterTerminate(Action0) instead.

Registers an Action0 to be called when this Observable invokes either onCompleted or onError.

Backpressure:

The operator doesn't interfere with backpressure which is determined by the source Observable's backpressure behavior.

Scheduler:

finallyDo does not operate by default on a particular Scheduler.

Parameters:

action - an Action0 to be invoked when the source Observable finishes

Returns:

an Observable that emits the same items as the source Observable, then invokes the Action0

See Also:

ReactiveX operators documentation: Do, doOnTerminate(Action0)

doAfterTerminate

public final Observable<T> doAfterTerminate(Action0 action)

Registers an Action0 to be called when this Observable invokes either onCompleted or onError.

Backpressure:

The operator doesn't interfere with backpressure which is determined by the source Observable's backpressure behavior.

Scheduler:

doAfterTerminate does not operate by default on a particular Scheduler.

Parameters:

action - an Action0 to be invoked when the source Observable finishes

Returns:

an Observable that emits the same items as the source Observable, then invokes the Action0

See Also:

ReactiveX operators documentation: Do, doOnTerminate(Action0)

first

public final Observable<T> first()

Returns an Observable that emits only the very first item emitted by the source Observable, or notifies of an NoSuchElementException if the source Observable is empty.

Backpressure:

The operator honors backpressure from downstream and consumes the source Observable in an unbounded manner (i.e., without applying backpressure).

Scheduler:

first does not operate by default on a particular Scheduler.

Returns:

an Observable that emits only the very first item emitted by the source Observable, or raises an NoSuchElementException if the source Observable is empty

See Also:

ReactiveX operators documentation: First

first

public final Observable<T> first(Func1T,java.lang.Boolean> predicate)

Returns an Observable that emits only the very first item emitted by the source Observable that satisfies a specified condition, or notifies of an NoSuchElementException if no such items are emitted.

Backpressure:

The operator honors backpressure from downstream and consumes the source Observable in an unbounded manner (i.e., without applying backpressure).

Scheduler:

first does not operate by default on a particular Scheduler.

Parameters:

predicate - the condition that an item emitted by the source Observable has to satisfy

Returns:

an Observable that emits only the very first item emitted by the source Observable that satisfies the predicate, or raises an NoSuchElementException if no such items are emitted

See Also:

ReactiveX operators documentation: First

firstOrDefault

public final Observable<T> firstOrDefault(T defaultValue)

Returns an Observable that emits only the very first item emitted by the source Observable, or a default item if the source Observable completes without emitting anything.

Backpressure:

The operator honors backpressure from downstream and consumes the source Observable in an unbounded manner (i.e., without applying backpressure).

Scheduler:

firstOrDefault does not operate by default on a particular Scheduler.

Parameters:

defaultValue - the default item to emit if the source Observable doesn't emit anything

Returns:

an Observable that emits only the very first item from the source, or a default item if the source Observable completes without emitting any items

See Also:

ReactiveX operators documentation: First

firstOrDefault

public final Observable<T> firstOrDefault(T defaultValue,
                                          Func1T,java.lang.Boolean> predicate)

Returns an Observable that emits only the very first item emitted by the source Observable that satisfies a specified condition, or a default item if the source Observable emits no such items.

Backpressure:

The operator honors backpressure from downstream and consumes the source Observable in an unbounded manner (i.e., without applying backpressure).

Scheduler:

firstOrDefault does not operate by default on a particular Scheduler.

Parameters:

predicate - the condition any item emitted by the source Observable has to satisfy

defaultValue - the default item to emit if the source Observable doesn't emit anything that satisfies the predicate

Returns:

an Observable that emits only the very first item emitted by the source Observable that satisfies the predicate, or a default item if the source Observable emits no such items

See Also:

ReactiveX operators documentation: First

flatMap

public final  Observable flatMap(Func1T,? extends Observable> func)

Returns an Observable that emits items based on applying a function that you supply to each item emitted by the source Observable, where that function returns an Observable, and then merging those resulting Observables and emitting the results of this merger.

Backpressure:

The operator honors backpressure from downstream. The outer Observable is consumed in unbounded mode (i.e., no backpressure is applied to it). The inner Observables are expected to honor backpressure; if violated, the operator may signal MissingBackpressureException.

Scheduler:

flatMap does not operate by default on a particular Scheduler.

Type Parameters:

R - the value type of the inner Observables and the output type

Parameters:

func - a function that, when applied to an item emitted by the source Observable, returns an Observable

Returns:

an Observable that emits the result of applying the transformation function to each item emitted by the source Observable and merging the results of the Observables obtained from this transformation

See Also:

ReactiveX operators documentation: FlatMap

flatMap

public final  Observable flatMap(Func1T,? extends Observable> func,
                                       int maxConcurrent)

Returns an Observable that emits items based on applying a function that you supply to each item emitted by the source Observable, where that function returns an Observable, and then merging those resulting Observables and emitting the results of this merger, while limiting the maximum number of concurrent subscriptions to these Observables.

Backpressure:

The operator honors backpressure from downstream. Both the outer and inner Observables are expected to honor backpressure; if violated, the operator may signal MissingBackpressureException.

Scheduler:

flatMap does not operate by default on a particular Scheduler.

Type Parameters:

R - the value type of the inner Observables and the output type

Parameters:

func - a function that, when applied to an item emitted by the source Observable, returns an Observable

maxConcurrent - the maximum number of Observables that may be subscribed to concurrently

Returns:

an Observable that emits the result of applying the transformation function to each item emitted by the source Observable and merging the results of the Observables obtained from this transformation

Since:

1.2

See Also:

ReactiveX operators documentation: FlatMap

flatMap

public final  Observable flatMap(Func1T,? extends Observable> onNext,
                                       Func1Observable> onError,
                                       Func0Observable> onCompleted)

Returns an Observable that applies a function to each item emitted or notification raised by the source Observable and then flattens the Observables returned from these functions and emits the resulting items.

Backpressure:

The operator honors backpressure from downstream. The outer Observable is consumed in unbounded mode (i.e., no backpressure is applied to it). The inner Observables are expected to honor backpressure; if violated, the operator may signal MissingBackpressureException.

Scheduler:

flatMap does not operate by default on a particular Scheduler.

Type Parameters:

R - the result type

Parameters:

onNext - a function that returns an Observable to merge for each item emitted by the source Observable

onError - a function that returns an Observable to merge for an onError notification from the source Observable

onCompleted - a function that returns an Observable to merge for an onCompleted notification from the source Observable

Returns:

an Observable that emits the results of merging the Observables returned from applying the specified functions to the emissions and notifications of the source Observable

See Also:

ReactiveX operators documentation: FlatMap

flatMap

public final  Observable flatMap(Func1T,? extends Observable> onNext,
                                       Func1Observable> onError,
                                       Func0Observable> onCompleted,
                                       int maxConcurrent)

Returns an Observable that applies a function to each item emitted or notification raised by the source Observable and then flattens the Observables returned from these functions and emits the resulting items, while limiting the maximum number of concurrent subscriptions to these Observables.

Backpressure:

The operator honors backpressure from downstream. Both the outer and inner Observables are expected to honor backpressure; if violated, the operator may signal MissingBackpressureException.

Scheduler:

flatMap does not operate by default on a particular Scheduler.

Type Parameters:

R - the result type

Parameters:

onNext - a function that returns an Observable to merge for each item emitted by the source Observable

onError - a function that returns an Observable to merge for an onError notification from the source Observable

onCompleted - a function that returns an Observable to merge for an onCompleted notification from the source Observable

maxConcurrent - the maximum number of Observables that may be subscribed to concurrently

Returns:

an Observable that emits the results of merging the Observables returned from applying the specified functions to the emissions and notifications of the source Observable

Since:

1.2

See Also:

ReactiveX operators documentation: FlatMap

flatMap

public final  Observable flatMap(Func1T,? extends Observable> collectionSelector,
                                         Func2T,? 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 Observable and a specified collection Observable.

The operator honors backpressure from downstream. The outer Observable is consumed in unbounded mode (i.e., no backpressure is applied to it). The inner Observables are expected to honor backpressure; if violated, the operator may signal MissingBackpressureException.

Scheduler:

flatMap does not operate by default on a particular Scheduler.

Type Parameters:

U - the type of items emitted by the collection Observable

R - the type of items emitted by the resulting Observable

Parameters:

collectionSelector - a function that returns an Observable for each item emitted by the source Observable

resultSelector - a function that combines one item emitted by each of the source and collection Observables and returns an item to be emitted by the resulting Observable

Returns:

an Observable that emits the results of applying a function to a pair of values emitted by the source Observable and the collection Observable

See Also:

ReactiveX operators documentation: FlatMap

flatMap

public final  Observable flatMap(Func1T,? extends Observable> collectionSelector,
                                         Func2T,? super U,? extends R> resultSelector,
                                         int maxConcurrent)

Returns an Observable that emits the results of a specified function to the pair of values emitted by the source Observable and a specified collection Observable, while limiting the maximum number of concurrent subscriptions to these Observables.

Backpressure:

The operator honors backpressure from downstream. Both the outer and inner Observables are expected to honor backpressure; if violated, the operator may signal MissingBackpressureException.

Scheduler:

flatMap does not operate by default on a particular Scheduler.

Type Parameters:

U - the type of items emitted by the collection Observable

R - the type of items emitted by the resulting Observable

Parameters:

collectionSelector - a function that returns an Observable for each item emitted by the source Observable

resultSelector - a function that combines one item emitted by each of the source and collection Observables and returns an item to be emitted by the resulting Observable

maxConcurrent - the maximum number of Observables that may be subscribed to concurrently

Returns:

an Observable that emits the results of applying a function to a pair of values emitted by the source Observable and the collection Observable

Since:

1.2

See Also:

ReactiveX operators documentation: FlatMap

flatMapCompletable

public final Observable<T> flatMapCompletable(Func1T,? extends Completable> mapper)

Maps all upstream values to Completables and runs them together until the upstream and all inner Completables complete normally.

Backpressure:

The operator consumes items from upstream in an unbounded manner and ignores downstream backpressure as it doesn't emit items but only terminal event.

Scheduler:

flatMapCompletable does not operate by default on a particular Scheduler.

History: 1.2.7 - experimental

Parameters:

mapper - the function that receives an upstream value and turns it into a Completable to be merged.

Returns:

the new Observable instance

Since:

1.3

See Also:

flatMapCompletable(Func1, boolean, int)

flatMapCompletable

public final Observable<T> flatMapCompletable(Func1T,? extends Completable> mapper,
                                              boolean delayErrors)

Maps all upstream values to Completables and runs them together, optionally delaying any errors, until the upstream and all inner Completables terminate.

Backpressure:

The operator consumes items from upstream in an unbounded manner and ignores downstream backpressure as it doesn't emit items but only terminal event.

Scheduler:

flatMapCompletable does not operate by default on a particular Scheduler.

History: 1.2.7 - experimental

Parameters:

mapper - the function that receives an upstream value and turns it into a Completable to be merged.

delayErrors - if true, errors from the upstream and from the inner Completables get delayed till the all of them terminate.

Returns:

the new Observable instance

Since:

1.3

See Also:

flatMapCompletable(Func1, boolean, int)

flatMapCompletable

public final Observable<T> flatMapCompletable(Func1T,? extends Completable> mapper,
                                              boolean delayErrors,
                                              int maxConcurrency)

Maps upstream values to Completables and runs up to the given number of them together at a time, optionally delaying any errors, until the upstream and all inner Completables terminate.

Backpressure:

The operator consumes at most maxConcurrent items from upstream and one-by-one after as the inner Completables terminate. The operator ignores downstream backpressure as it doesn't emit items but only the terminal event.

Scheduler:

flatMapCompletable does not operate by default on a particular Scheduler.

History: 1.2.7 - experimental

Parameters:

mapper - the function that receives an upstream value and turns it into a Completable to be merged.

delayErrors - if true, errors from the upstream and from the inner Completables get delayed till the all of them terminate.

maxConcurrency - the maximum number of inner Completables to run at a time

Returns:

the new Observable instance

Since:

1.3

flatMapIterable

public final  Observable flatMapIterable(Func1T,? extends java.lang.Iterable> collectionSelector)

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

Backpressure:

The operator honors backpressure from downstream. The source Observables is expected to honor backpressure as well. If the source Observable violates the rule, the operator will signal a MissingBackpressureException.

Scheduler:

flatMapIterable does not operate by default on a particular Scheduler.

Type Parameters:

R - the type of item emitted by the resulting Observable

Parameters:

collectionSelector - a function that returns an Iterable sequence of values for when given an item emitted by the source Observable

Returns:

an Observable that emits the results of merging the items emitted by the source Observable with the values in the Iterables corresponding to those items, as generated by collectionSelector

See Also:

ReactiveX operators documentation: FlatMap

flatMapIterable

public final  Observable flatMapIterable(Func1T,? extends java.lang.Iterable> collectionSelector,
                                               int maxConcurrent)

Returns an Observable that merges each item emitted by the source Observable with the values in an Iterable corresponding to that item that is generated by a selector, while limiting the number of concurrent subscriptions to these Observables.

Backpressure:

The operator honors backpressure from downstream. The source Observables is expected to honor backpressure as well. If the source Observable violates the rule, the operator will signal a MissingBackpressureException.

Scheduler:

flatMapIterable does not operate by default on a particular Scheduler.

Type Parameters:

R - the type of item emitted by the resulting Observable

Parameters:

collectionSelector - a function that returns an Iterable sequence of values for when given an item emitted by the source Observable

maxConcurrent - the maximum number of Observables that may be subscribed to concurrently

Returns:

an Observable that emits the results of merging the items emitted by the source Observable with the values in the Iterables corresponding to those items, as generated by collectionSelector

Throws:

java.lang.IllegalArgumentException - if maxConcurrent is less than or equal to 0

Since:

1.2

See Also:

ReactiveX operators documentation: FlatMap

flatMapIterable

public final  Observable flatMapIterable(Func1T,? extends java.lang.Iterable> collectionSelector,
                                                 Func2T,? super U,? extends R> resultSelector)

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

Backpressure:

The operator honors backpressure from downstream and the source Observables is consumed in an unbounded manner (i.e., no backpressure is applied to it).

Scheduler:

flatMapIterable does not operate by default on a particular Scheduler.

Type Parameters:

U - the collection element type

R - the type of item emitted by the resulting Observable

Parameters:

collectionSelector - a function that returns an Iterable sequence of values for each item emitted by the source Observable

resultSelector - a function that returns an item based on the item emitted by the source Observable and the Iterable returned for that item by the collectionSelector

Returns:

an Observable that emits the items returned by resultSelector for each item in the source Observable

See Also:

ReactiveX operators documentation: FlatMap

flatMapIterable

public final  Observable flatMapIterable(Func1T,? extends java.lang.Iterable> collectionSelector,
                                                 Func2T,? super U,? extends R> resultSelector,
                                                 int maxConcurrent)

Returns an Observable that emits the results of applying a function to the pair of values from the source Observable and an Iterable corresponding to that item that is generated by a selector, while limiting the number of concurrent subscriptions to these Observables.

Backpressure:

The operator honors backpressure from downstream. The source Observables is expected to honor backpressure as well. If the source Observable violates the rule, the operator will signal a MissingBackpressureException.

Scheduler:

flatMapIterable does not operate by default on a particular Scheduler.

Type Parameters:

U - the collection element type

R - the type of item emitted by the resulting Observable

Parameters:

collectionSelector - a function that returns an Iterable sequence of values for each item emitted by the source Observable

resultSelector - a function that returns an item based on the item emitted by the source Observable and the Iterable returned for that item by the collectionSelector

maxConcurrent - the maximum number of Observables that may be subscribed to concurrently

Returns:

an Observable that emits the items returned by resultSelector for each item in the source Observable

Throws:

java.lang.IllegalArgumentException - if maxConcurrent is less than or equal to 0

Since:

1.2

See Also:

ReactiveX operators documentation: FlatMap

flatMapSingle

public final  Observable flatMapSingle(Func1T,? extends Single> mapper)

Maps all upstream values to Singles and runs them together until the upstream and all inner Singles complete normally.

Backpressure:

The operator consumes items from upstream in an unbounded manner and honors downstream backpressure.

Scheduler:

flatMapSingle does not operate by default on a particular Scheduler.

History: 1.2.7 - experimental

Type Parameters:

R - the value type of the inner Singles and the resulting Observable

Parameters:

mapper - the function that receives an upstream value and turns it into a Single to be merged.

Returns:

the new Observable instance

Since:

1.3

See Also:

flatMapSingle(Func1, boolean, int)

flatMapSingle

public final  Observable flatMapSingle(Func1T,? extends Single> mapper,
                                             boolean delayErrors)

Maps all upstream values to Singles and runs them together, optionally delaying any errors, until the upstream and all inner Singles terminate.

Backpressure:

The operator consumes items from upstream in an unbounded manner and honors downstream backpressure.

Scheduler:

flatMapSingle does not operate by default on a particular Scheduler.

History: 1.2.7 - experimental

Type Parameters:

R - the value type of the inner Singles and the resulting Observable

Parameters:

mapper - the function that receives an upstream value and turns it into a Single to be merged.

delayErrors - if true, errors from the upstream and from the inner Singles get delayed till the all of them terminate.

Returns:

the new Observable instance

Since:

1.3

See Also:

flatMapSingle(Func1, boolean, int)

flatMapSingle

public final  Observable flatMapSingle(Func1T,? extends Single> mapper,
                                             boolean delayErrors,
                                             int maxConcurrency)

Maps upstream values to Singles and runs up to the given number of them together at a time, optionally delaying any errors, until the upstream and all inner Singles terminate.

Backpressure:

The operator consumes at most maxConcurrent items from upstream and one-by-one after as the inner Singles terminate. The operator honors downstream backpressure.

Scheduler:

flatMapSingle does not operate by default on a particular Scheduler.

History: 1.2.7 - experimental

Type Parameters:

R - the value type of the inner Singles and the resulting Observable

Parameters:

mapper - the function that receives an upstream value and turns it into a Single to be merged.

delayErrors - if true, errors from the upstream and from the inner Singles get delayed till the all of them terminate.

maxConcurrency - the maximum number of inner Singles to run at a time

Returns:

the new Observable instance

Since:

1.3

forEach

public final void forEach(Action1T> onNext)

Subscribes to the Observable and receives notifications for each element.

Alias to subscribe(Action1)

Backpressure:

The operator consumes the source Observable in an unbounded manner (i.e., no backpressure is applied to it).

Scheduler:

forEach does not operate by default on a particular Scheduler.

Parameters:

onNext - Action1 to execute for each item.

Throws:

java.lang.IllegalArgumentException - if onNext is null

OnErrorNotImplementedException - if the Observable calls onError

See Also:

ReactiveX operators documentation: Subscribe

forEach

public final void forEach(Action1T> onNext,
                          Action1 onError)

Subscribes to the Observable and receives notifications for each element and error events.

Alias to subscribe(Action1, Action1)

Backpressure:

The operator consumes the source Observable in an unbounded manner (i.e., no backpressure is applied to it).

Scheduler:

forEach does not operate by default on a particular Scheduler.

Parameters:

onNext - Action1 to execute for each item.

onError - Action1 to execute when an error is emitted.

Throws:

java.lang.IllegalArgumentException - if onNext is null, or if onError is null

OnErrorNotImplementedException - if the Observable calls onError

See Also:

ReactiveX operators documentation: Subscribe

forEach

public final void forEach(Action1T> onNext,
                          Action1 onError,
                          Action0 onComplete)

Subscribes to the Observable and receives notifications for each element and the terminal events.

Alias to subscribe(Action1, Action1, Action0)

Backpressure:

The operator consumes the source Observable in an unbounded manner (i.e., no backpressure is applied to it).

Scheduler:

forEach does not operate by default on a particular Scheduler.

Parameters:

onNext - Action1 to execute for each item.

onError - Action1 to execute when an error is emitted.

onComplete - Action0 to execute when completion is signalled.

Throws:

java.lang.IllegalArgumentException - if onNext is null, or if onError is null, or if onComplete is null

OnErrorNotImplementedException - if the Observable calls onError

See Also:

ReactiveX operators documentation: Subscribe

groupBy

public final  Observable<GroupedObservable> groupBy(Func1T,? extends K> keySelector,
                                                              Func1T,? extends R> elementSelector)

Groups the items emitted by an Observable according to a specified criterion, and emits these grouped items as GroupedObservables. The emitted GroupedObservable allows only a single Subscriber during its lifetime and if this Subscriber unsubscribes before the source terminates, the next emission by the source having the same key will trigger a new GroupedObservable emission.

Note: A GroupedObservable will cache the items it is to emit until such time as it is subscribed to. For this reason, in order to avoid memory leaks, you should not simply ignore those GroupedObservables that do not concern you. Instead, you can signal to them that they may discard their buffers by applying an operator like ignoreElements() to them.

Backpressure:

Both the returned and its inner Observables honor backpressure and the source Observable is consumed in a bounded mode (i.e., requested a fixed amount upfront and replenished based on downstream consumption). Note that both the returned and its inner Observables use unbounded internal buffers and if the source Observable doesn't honor backpressure, that may lead to OutOfMemoryError.

Scheduler:

groupBy does not operate by default on a particular Scheduler.

Type Parameters:

K - the key type

R - the element type

Parameters:

keySelector - a function that extracts the key for each item

elementSelector - a function that extracts the return element for each item

Returns:

an Observable that emits GroupedObservables, each of which corresponds to a unique key value and each of which emits those items from the source Observable that share that key value

See Also:

ReactiveX operators documentation: GroupBy

groupBy

@Deprecated
public final  Observable<GroupedObservable> groupBy(Func1T,? extends K> keySelector,
                                                                          Func1T,? extends R> elementSelector,
                                                                          Func1<Action1,java.util.Map> evictingMapFactory)

Deprecated. since 1.3.7, use groupBy(Func1, Func1, int, boolean, Func1) instead which uses much less memory. Please take note of the usage difference involving the evicting action which now expects the value from the map instead of the key.

Groups the items emitted by an Observable according to a specified criterion, and emits these grouped items as GroupedObservables. The emitted GroupedObservable allows only a single Subscriber during its lifetime and if this Subscriber unsubscribes before the source terminates, the next emission by the source having the same key will trigger a new GroupedObservable emission.

Note: A GroupedObservable will cache the items it is to emit until such time as it is subscribed to. For this reason, in order to avoid memory leaks, you should not simply ignore those GroupedObservables that do not concern you. Instead, you can signal to them that they may discard their buffers by applying an operator like ignoreElements() to them.

Backpressure:

Both the returned and its inner Observables honor backpressure and the source Observable is consumed in a bounded mode (i.e., requested a fixed amount upfront and replenished based on downstream consumption). Note that both the returned and its inner Observables use unbounded internal buffers and if the source Observable doesn't honor backpressure, that may lead to OutOfMemoryError.

Scheduler:

groupBy does not operate by default on a particular Scheduler.

Type Parameters:

K - the key type

R - the element type

Parameters:

keySelector - a function that extracts the key for each item

elementSelector - a function that extracts the return element for each item

evictingMapFactory - a function that given an eviction action returns a Map instance that will be used to assign items to the appropriate GroupedObservables. The Map instance must be thread-safe and any eviction must trigger a call to the supplied action (synchronously or asynchronously). This can be used to limit the size of the map by evicting keys by maximum size or access time for instance. Here's an example using Guava's CacheBuilder from v19.0:

            
            Func1, Map> mapFactory
              = action -> CacheBuilder.newBuilder()
                  .maximumSize(1000)
                  .expireAfterAccess(12, TimeUnit.HOURS)
                  .removalListener(notification -> action.call(notification.getKey()))
                  . build().asMap();
            
            

Returns:

an Observable that emits GroupedObservables, each of which corresponds to a unique key value and each of which emits those items from the source Observable that share that key value

Throws:

java.lang.NullPointerException - if evictingMapFactory is null

Since:

1.3

See Also:

ReactiveX operators documentation: GroupBy

groupBy

@Experimental
public final  Observable<GroupedObservable> groupBy(Func1T,? extends K> keySelector,
                                                                            Func1T,? extends R> elementSelector,
                                                                            int bufferSize,
                                                                            boolean delayError,
                                                                            Func1<Action1,java.util.Map> evictingMapFactory)

Groups the items emitted by an Observable according to a specified criterion, and emits these grouped items as GroupedObservables. The emitted GroupedObservable allows only a single Subscriber during its lifetime and if this Subscriber unsubscribes before the source terminates, the next emission by the source having the same key will trigger a new GroupedObservable emission.

Note: A GroupedObservable will cache the items it is to emit until such time as it is subscribed to. For this reason, in order to avoid memory leaks, you should not simply ignore those GroupedObservables that do not concern you. Instead, you can signal to them that they may discard their buffers by applying an operator like ignoreElements() to them.

Backpressure:

Both the returned and its inner Observables honor backpressure and the source Observable is consumed in a bounded mode (i.e., requested a fixed amount upfront and replenished based on downstream consumption). Note that both the returned and its inner Observables use unbounded internal buffers and if the source Observable doesn't honor backpressure, that may lead to OutOfMemoryError.

Scheduler:

groupBy does not operate by default on a particular Scheduler.

Type Parameters:

K - the key type

R - the element type

Parameters:

keySelector - a function that extracts the key for each item

elementSelector - a function that extracts the return element for each item

bufferSize - the size of the buffer (RxRingBuffer.SIZE may be suitable).

delayError - if and only if false then onError emissions can shortcut onNext emissions (emissions may be buffered)

evictingMapFactory - a function that given an eviction action returns a Map instance that will be used to assign items to the appropriate GroupedObservables. The Map instance must be thread-safe and any eviction must trigger a call to the supplied action (synchronously or asynchronously). This can be used to limit the size of the map by evicting entries by map maximum size or access time for instance. Here's an example using Guava's CacheBuilder from v24.0:

            
            Func1, Map> mapFactory 
              = action -> CacheBuilder.newBuilder()
                  .maximumSize(1000)
                  .expireAfterAccess(12, TimeUnit.HOURS)
                  .removalListener(entry -> action.call(entry.getValue()))
                  . build().asMap();
            
            

Returns:

an Observable that emits GroupedObservables, each of which corresponds to a unique key value and each of which emits those items from the source Observable that share that key value

Throws:

java.lang.NullPointerException - if evictingMapFactory is null

Since:

1.3.7

See Also:

ReactiveX operators documentation: GroupBy

groupBy

public final  Observable<GroupedObservableT>> groupBy(Func1T,? extends K> keySelector)

Groups the items emitted by an Observable according to a specified criterion, and emits these grouped items as GroupedObservables. The emitted GroupedObservable allows only a single Subscriber during its lifetime and if this Subscriber unsubscribes before the source terminates, the next emission by the source having the same key will trigger a new GroupedObservable emission.

Note: A GroupedObservable will cache the items it is to emit until such time as it is subscribed to. For this reason, in order to avoid memory leaks, you should not simply ignore those GroupedObservables that do not concern you. Instead, you can signal to them that they may discard their buffers by applying an operator like ignoreElements() to them.

Scheduler:

groupBy does not operate by default on a particular Scheduler.

Type Parameters:

K - the key type

Parameters:

keySelector - a function that extracts the key for each item

Returns:

an Observable that emits GroupedObservables, each of which corresponds to a unique key value and each of which emits those items from the source Observable that share that key value

See Also:

ReactiveX operators documentation: GroupBy

groupJoin

public final  Observable groupJoin(Observable right,
                                                  Func1T,? extends Observable> leftDuration,
                                                  Func1Observable> rightDuration,
                                                  Func2T,? super Observable,? extends R> resultSelector)

Returns an Observable that correlates two Observables when they overlap in time and groups the results.

There are no guarantees in what order the items get combined when multiple items from one or both source Observables overlap.

Backpressure:

The operator doesn't support backpressure and consumes all participating Observables in an unbounded mode (i.e., not applying any backpressure to them).

Scheduler:

groupJoin does not operate by default on a particular Scheduler.

Type Parameters:

T2 - the value type of the right Observable source

D1 - the element type of the left duration Observables

D2 - the element type of the right duration Observables

R - the result type

Parameters:

right - the other Observable to correlate items from the source Observable with

leftDuration - a function that returns an Observable whose emissions indicate the duration of the values of the source Observable

rightDuration - a function that returns an Observable whose emissions indicate the duration of the values of the right Observable

resultSelector - a function that takes an item emitted by each Observable and returns the value to be emitted by the resulting Observable

Returns:

an Observable that emits items based on combining those items emitted by the source Observables whose durations overlap

See Also:

ReactiveX operators documentation: Join

ignoreElements

public final Observable<T> ignoreElements()

Ignores all items emitted by the source Observable and only calls onCompleted or onError.

Backpressure:

This operator ignores backpressure as it doesn't emit any elements and consumes the source Observable in an unbounded manner (i.e., no backpressure is applied to it).

Scheduler:

ignoreElements does not operate by default on a particular Scheduler.

Returns:

an empty Observable that only calls onCompleted or onError, based on which one is called by the source Observable

See Also:

ReactiveX operators documentation: IgnoreElements

isEmpty

public final Observable isEmpty()

Returns an Observable that emits true if the source Observable is empty, otherwise false.

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

Backpressure:

The operator honors backpressure from downstream and consumes the source Observable in an unbounded manner (i.e., without applying backpressure).

Scheduler:

isEmpty does not operate by default on a particular Scheduler.

Returns:

an Observable that emits a Boolean

See Also:

ReactiveX operators documentation: Contains

join

public final  Observable join(Observable right,
                                                                        Func1<T,Observable> leftDurationSelector,
                                                                        Func1Observable> rightDurationSelector,
                                                                        Func2<T,TRight,R> resultSelector)

Correlates the items emitted by two Observables based on overlapping durations.

There are no guarantees in what order the items get combined when multiple items from one or both source Observables overlap.

Backpressure:

The operator doesn't support backpressure and consumes all participating Observables in an unbounded mode (i.e., not applying any backpressure to them).

Scheduler:

join does not operate by default on a particular Scheduler.

Type Parameters:

TRight - the value type of the right Observable source

TLeftDuration - the element type of the left duration Observables

TRightDuration - the element type of the right duration Observables

R - the result type

Parameters:

right - the second Observable to join items from

leftDurationSelector - a function to select a duration for each item emitted by the source Observable, used to determine overlap

rightDurationSelector - a function to select a duration for each item emitted by the right Observable, used to determine overlap

resultSelector - a function that computes an item to be emitted by the resulting Observable for any two overlapping items emitted by the two Observables

Returns:

an Observable that emits items correlating to items emitted by the source Observables that have overlapping durations

See Also:

ReactiveX operators documentation: Join

last

public final Observable<T> last()

Returns an Observable that emits the last item emitted by the source Observable or notifies observers of a NoSuchElementException if the source Observable is empty.

Backpressure:

The operator honors backpressure from downstream and consumes the source Observable in an unbounded manner (i.e., without applying backpressure).

Scheduler:

last does not operate by default on a particular Scheduler.

Returns:

an Observable that emits the last item from the source Observable or notifies observers of an error

See Also:

ReactiveX operators documentation: Last

last

public final Observable<T> last(Func1T,java.lang.Boolean> predicate)

Returns an Observable that emits only the last item emitted by the source Observable that satisfies a given condition, or notifies of a NoSuchElementException if no such items are emitted.

Backpressure:

The operator honors backpressure from downstream and consumes the source Observable in an unbounded manner (i.e., without applying backpressure).

Scheduler:

last does not operate by default on a particular Scheduler.

Parameters:

predicate - the condition any source emitted item has to satisfy

Returns:

an Observable that emits only the last item satisfying the given condition from the source, or an NoSuchElementException if no such items are emitted

Throws:

java.lang.IllegalArgumentException - if no items that match the predicate are emitted by the source Observable

See Also:

ReactiveX operators documentation: Last

lastOrDefault

public final Observable<T> lastOrDefault(T defaultValue)

Returns an Observable that emits only the last item emitted by the source Observable, or a default item if the source Observable completes without emitting any items.

Backpressure:

The operator honors backpressure from downstream and consumes the source Observable in an unbounded manner (i.e., without applying backpressure).

Scheduler:

lastOrDefault does not operate by default on a particular Scheduler.

Parameters:

defaultValue - the default item to emit if the source Observable is empty

Returns:

an Observable that emits only the last item emitted by the source Observable, or a default item if the source Observable is empty

See Also:

ReactiveX operators documentation: Last

lastOrDefault

public final Observable<T> lastOrDefault(T defaultValue,
                                         Func1T,java.lang.Boolean> predicate)

Returns an Observable that emits only the last item emitted by the source Observable that satisfies a specified condition, or a default item if no such item is emitted by the source Observable.

Backpressure:

The operator honors backpressure from downstream and consumes the source Observable in an unbounded manner (i.e., without applying backpressure to it).

Scheduler:

lastOrDefault does not operate by default on a particular Scheduler.

Parameters:

defaultValue - the default item to emit if the source Observable doesn't emit anything that satisfies the specified predicate

predicate - the condition any item emitted by the source Observable has to satisfy

Returns:

an Observable that emits only the last item emitted by the source Observable that satisfies the given condition, or a default item if no such item is emitted by the source Observable

See Also:

ReactiveX operators documentation: Last

limit

public final Observable<T> limit(int count)

Returns an Observable that emits only the first count items emitted by the source Observable.

Alias of take(int) to match Java 8 Stream API naming convention.

This method returns an Observable that will invoke a subscribing Observer's onNext function a maximum of count times before invoking onCompleted.

Backpressure:

The operator doesn't interfere with backpressure which is determined by the source Observable's backpressure behavior in case the first request is smaller than the count. Otherwise, the source Observable is consumed in an unbounded manner (i.e., without applying backpressure to it).

Scheduler:

limit does not operate by default on a particular Scheduler.

Parameters:

count - the maximum number of items to emit

Returns:

an Observable that emits only the first count items emitted by the source Observable, or all of the items from the source Observable if that Observable emits fewer than count items

See Also:

ReactiveX operators documentation: Take

map

public final  Observable map(Func1T,? extends R> func)

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

Backpressure:

The operator doesn't interfere with backpressure which is determined by the source Observable's backpressure behavior.

Scheduler:

map does not operate by default on a particular Scheduler.

Type Parameters:

R - the output type

Parameters:

func - a function to apply to each item emitted by the Observable

Returns:

an Observable that emits the items from the source Observable, transformed by the specified function

See Also:

ReactiveX operators documentation: Map

materialize

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

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

Backpressure:

The operator honors backpressure from downstream and expects it from the source Observable. If this expectation is violated, the operator may throw an IllegalStateException.

Scheduler:

materialize does not operate by default on a particular Scheduler.

Returns:

an Observable that emits items that are the result of materializing the items and notifications of the source Observable

See Also:

ReactiveX operators documentation: Materialize

mergeWith

public final Observable<T> mergeWith(ObservableT> t1)

Flattens this and another Observable into a single Observable, without any transformation.

You can combine items emitted by multiple Observables so that they appear as a single Observable, by using the mergeWith method.

Backpressure:

The operator honors backpressure from downstream. This and the other Observables are expected to honor backpressure; if violated, the operator may signal MissingBackpressureException.

Scheduler:

mergeWith does not operate by default on a particular Scheduler.

Parameters:

t1 - an Observable to be merged

Returns:

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

See Also:

ReactiveX operators documentation: Merge

observeOn

public final Observable<T> observeOn(Scheduler scheduler)

Modifies an Observable to perform its emissions and notifications on a specified Scheduler, asynchronously with a bounded buffer of RxRingBuffer.SIZE slots.

Note that onError notifications will cut ahead of onNext notifications on the emission thread if Scheduler is truly asynchronous. If strict event ordering is required, consider using the observeOn(Scheduler, boolean) overload.

Backpressure:

This operator honors backpressure from downstream and expects it from the source Observable. Violating this expectation will lead to MissingBackpressureException. This is the most common operator where the exception pops up; look for sources up the chain that don't support backpressure, such as interval, timer, {code PublishSubject} or BehaviorSubject and apply any of the onBackpressureXXX operators before applying observeOn itself.

Scheduler:

you specify which Scheduler this operator will use

Parameters:

scheduler - the Scheduler to notify Observers on

Returns:

the source Observable modified so that its Observers are notified on the specified Scheduler

See Also:

ReactiveX operators documentation: ObserveOn, RxJava Threading Examples, subscribeOn(rx.Scheduler), observeOn(Scheduler, int), observeOn(Scheduler, boolean), observeOn(Scheduler, boolean, int)

observeOn

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

Modifies an Observable to perform its emissions and notifications on a specified Scheduler, asynchronously with a bounded buffer of configurable size.

Note that onError notifications will cut ahead of onNext notifications on the emission thread if Scheduler is truly asynchronous. If strict event ordering is required, consider using the observeOn(Scheduler, boolean) overload.

Backpressure:

This operator honors backpressure from downstream and expects it from the source Observable. Violating this expectation will lead to MissingBackpressureException. This is the most common operator where the exception pops up; look for sources up the chain that don't support backpressure, such as interval, timer, {code PublishSubject} or BehaviorSubject and apply any of the onBackpressureXXX operators before applying observeOn itself.

Scheduler:

you specify which Scheduler this operator will use

Parameters:

scheduler - the Scheduler to notify Observers on

bufferSize - the size of the buffer.

Returns:

the source Observable modified so that its Observers are notified on the specified Scheduler

See Also:

ReactiveX operators documentation: ObserveOn, RxJava Threading Examples, subscribeOn(rx.Scheduler), observeOn(Scheduler), observeOn(Scheduler, boolean), observeOn(Scheduler, boolean, int)

observeOn

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

Modifies an Observable to perform its emissions and notifications on a specified Scheduler, asynchronously with a bounded buffer and optionally delays onError notifications.

Backpressure:

This operator honors backpressure from downstream and expects it from the source Observable. Violating this expectation will lead to MissingBackpressureException. This is the most common operator where the exception pops up; look for sources up the chain that don't support backpressure, such as interval, timer, {code PublishSubject} or BehaviorSubject and apply any of the onBackpressureXXX operators before applying observeOn itself.

Scheduler:

you specify which Scheduler this operator will use

Parameters:

scheduler - the Scheduler to notify Observers on

delayError - indicates if the onError notification may not cut ahead of onNext notification on the other side of the scheduling boundary. If true a sequence ending in onError will be replayed in the same order as was received from upstream

Returns:

the source Observable modified so that its Observers are notified on the specified Scheduler

See Also:

ReactiveX operators documentation: ObserveOn, RxJava Threading Examples, subscribeOn(rx.Scheduler), observeOn(Scheduler), observeOn(Scheduler, int), observeOn(Scheduler, boolean, int)

observeOn

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

Modifies an Observable to perform its emissions and notifications on a specified Scheduler, asynchronously with a bounded buffer of configurable size and optionally delays onError notifications.

Backpressure:

This operator honors backpressure from downstream and expects it from the source Observable. Violating this expectation will lead to MissingBackpressureException. This is the most common operator where the exception pops up; look for sources up the chain that don't support backpressure, such as interval, timer, {code PublishSubject} or BehaviorSubject and apply any of the onBackpressureXXX operators before applying observeOn itself.

Scheduler:

you specify which Scheduler this operator will use

Parameters:

scheduler - the Scheduler to notify Observers on

delayError - indicates if the onError notification may not cut ahead of onNext notification on the other side of the scheduling boundary. If true a sequence ending in onError will be replayed in the same order as was received from upstream

bufferSize - the size of the buffer.

Returns:

the source Observable modified so that its Observers are notified on the specified Scheduler

See Also:

ReactiveX operators documentation: ObserveOn, RxJava Threading Examples, subscribeOn(rx.Scheduler), observeOn(Scheduler), observeOn(Scheduler, int), observeOn(Scheduler, boolean)

ofType

public final  Observable ofType(java.lang.Class klass)

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

Backpressure:

The operator doesn't interfere with backpressure which is determined by the source Observable's backpressure behavior.

Scheduler:

ofType does not operate by default on a particular Scheduler.

Type Parameters:

R - the output type

Parameters:

klass - the class type to filter the items emitted by the source Observable

Returns:

an Observable that emits items from the source Observable of type klass

See Also:

ReactiveX operators documentation: Filter

onBackpressureBuffer

public final Observable<T> onBackpressureBuffer()

Instructs an Observable that is emitting items faster than its observer can consume them to buffer these items indefinitely until they can be emitted.

Backpressure:

The operator honors backpressure from downstream and consumes the source Observable in an unbounded manner (i.e., not applying backpressure to it).

Scheduler:

onBackpressureBuffer does not operate by default on a particular Scheduler.

Returns:

the source Observable modified to buffer items to the extent system resources allow

See Also:

ReactiveX operators documentation: backpressure operators

onBackpressureBuffer

public final Observable<T> onBackpressureBuffer(long capacity)

Instructs an Observable that is emitting items faster than its observer can consume them to buffer up to a given amount of items until they can be emitted. The resulting Observable will onError emitting a BufferOverflowException as soon as the buffer's capacity is exceeded, dropping all undelivered items, and unsubscribing from the source.

Backpressure:

The operator honors backpressure from downstream and consumes the source Observable in an unbounded manner (i.e., not applying backpressure to it).

Scheduler:

onBackpressureBuffer does not operate by default on a particular Scheduler.

Parameters:

capacity - number of slots available in the buffer.

Returns:

the source Observable modified to buffer items up to the given capacity.

Since:

1.1.0

See Also:

ReactiveX operators documentation: backpressure operators

onBackpressureBuffer

public final Observable<T> onBackpressureBuffer(long capacity,
                                                Action0 onOverflow)

Instructs an Observable that is emitting items faster than its observer can consume them to buffer up to a given amount of items until they can be emitted. The resulting Observable will onError emitting a BufferOverflowException as soon as the buffer's capacity is exceeded, dropping all undelivered items, unsubscribing from the source, and notifying the producer with onOverflow.

Backpressure:

The operator honors backpressure from downstream and consumes the source Observable in an unbounded manner (i.e., not applying backpressure to it).

Scheduler:

onBackpressureBuffer does not operate by default on a particular Scheduler.

Parameters:

capacity - number of slots available in the buffer.

onOverflow - action to execute if an item needs to be buffered, but there are no available slots. Null is allowed.

Returns:

the source Observable modified to buffer items up to the given capacity

Since:

1.1.0

See Also:

ReactiveX operators documentation: backpressure operators

onBackpressureBuffer

public final Observable<T> onBackpressureBuffer(long capacity,
                                                Action0 onOverflow,
                                                BackpressureOverflow.Strategy overflowStrategy)

Instructs an Observable that is emitting items faster than its observer can consume them to buffer up to a given amount of items until they can be emitted. The resulting Observable will behave as determined by overflowStrategy if the buffer capacity is exceeded.

• BackpressureOverflow.Strategy.ON_OVERFLOW_ERROR (default) will onError dropping all undelivered items, unsubscribing from the source, and notifying the producer with onOverflow.
• BackpressureOverflow.Strategy.ON_OVERFLOW_DROP_LATEST will drop any new items emitted by the producer while the buffer is full, without generating any onError. Each drop will however invoke onOverflow to signal the overflow to the producer.
j
• BackpressureOverflow.Strategy.ON_OVERFLOW_DROP_OLDEST will drop the oldest items in the buffer in order to make room for newly emitted ones. Overflow will not generate anonError, but each drop will invoke onOverflow to signal the overflow to the producer.

Backpressure:

The operator honors backpressure from downstream and consumes the source Observable in an unbounded manner (i.e., not applying backpressure to it).

Scheduler:

onBackpressureBuffer does not operate by default on a particular Scheduler.

Parameters:

capacity - number of slots available in the buffer.

onOverflow - action to execute if an item needs to be buffered, but there are no available slots. Null is allowed.

overflowStrategy - how should the Observable react to buffer overflows. Null is not allowed.

Returns:

the source Observable modified to buffer items up to the given capacity

Since:

1.3

See Also:

ReactiveX operators documentation: backpressure operators

onBackpressureDrop

public final Observable<T> onBackpressureDrop(Action1T> onDrop)

Instructs an Observable that is emitting items faster than its observer can consume them to discard, rather than emit, those items that its observer is not prepared to observe.

If the downstream request count hits 0 then the Observable will refrain from calling onNext until the observer invokes request(n) again to increase the request count.

Backpressure:

The operator honors backpressure from downstream and consumes the source Observable in an unbounded manner (i.e., not applying backpressure to it).

Scheduler:

onBackpressureDrop does not operate by default on a particular Scheduler.

Parameters:

onDrop - the action to invoke for each item dropped. onDrop action should be fast and should never block.

Returns:

the source Observable modified to drop onNext notifications on overflow

Since:

1.1.0

See Also:

ReactiveX operators documentation: backpressure operators

onBackpressureDrop

public final Observable<T> onBackpressureDrop()

Instructs an Observable that is emitting items faster than its observer can consume them to discard, rather than emit, those items that its observer is not prepared to observe.

If the downstream request count hits 0 then the Observable will refrain from calling onNext until the observer invokes request(n) again to increase the request count.

Backpressure:

The operator honors backpressure from downstream and consumes the source Observable in an unbounded manner (i.e., not applying backpressure to it).

Scheduler:

onBackpressureDrop does not operate by default on a particular Scheduler.

Returns:

the source Observable modified to drop onNext notifications on overflow

See Also:

ReactiveX operators documentation: backpressure operators

onBackpressureLatest

public final Observable<T> onBackpressureLatest()

Instructs an Observable that is emitting items faster than its observer can consume them to hold onto the latest value and emit that on request.

Its behavior is logically equivalent to toBlocking().latest() with the exception that the downstream is not blocking while requesting more values.

Note that if the upstream Observable does support backpressure, this operator ignores that capability and doesn't propagate any backpressure requests from downstream.

Note that due to the nature of how backpressure requests are propagated through subscribeOn/observeOn, requesting more than 1 from downstream doesn't guarantee a continuous delivery of onNext events.

Backpressure:

The operator honors backpressure from downstream and consumes the source Observable in an unbounded manner (i.e., not applying backpressure to it).

Scheduler:

onBackpressureLatest does not operate by default on a particular Scheduler.

Returns:

the source Observable modified so that it emits the most recently-received item upon request

Since:

1.1.0

onErrorResumeNext

public final Observable<T> onErrorResumeNext(Func1ObservableT>> resumeFunction)

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

By default, when an Observable encounters an error that prevents it from emitting the expected item to its Observer, the Observable invokes its Observer's onError method, and then quits without invoking any more of its Observer's methods. The onErrorResumeNext method changes this behavior. If you pass a function that returns an Observable (resumeFunction) to onErrorResumeNext, if the original Observable encounters an error, instead of invoking its Observer's onError method, it will instead relinquish control to the Observable returned from resumeFunction, which will invoke the Observer's onNext method if it is able to do so. In such a case, because no Observable necessarily invokes onError, the Observer may never know that an error happened.

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

Backpressure:

The operator honors backpressure from downstream. This and the resuming Observables are expected to honor backpressure as well. If any of them violate this expectation, the operator may throw an IllegalStateException when the source Observable completes or a MissingBackpressureException is signalled somewhere downstream.

Scheduler:

onErrorResumeNext does not operate by default on a particular Scheduler.

Parameters:

resumeFunction - a function that returns an Observable that will take over if the source Observable encounters an error

Returns:

the original Observable, with appropriately modified behavior

See Also:

ReactiveX operators documentation: Catch

onErrorResumeNext

public final Observable<T> onErrorResumeNext(ObservableT> resumeSequence)

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

By default, when an Observable encounters an error that prevents it from emitting the expected item to its Observer, the Observable invokes its Observer's onError method, and then quits without invoking any more of its Observer's methods. The onErrorResumeNext method changes this behavior. If you pass another Observable (resumeSequence) to an Observable's onErrorResumeNext method, if the original Observable encounters an error, instead of invoking its Observer's onError method, it will instead relinquish control to resumeSequence which will invoke the Observer's onNext method if it is able to do so. In such a case, because no Observable necessarily invokes onError, the Observer may never know that an error happened.

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

Backpressure:

The operator honors backpressure from downstream. This and the resuming Observables are expected to honor backpressure as well. If any of them violate this expectation, the operator may throw an IllegalStateException when the source Observable completes or MissingBackpressureException is signalled somewhere downstream.

Scheduler:

onErrorResumeNext does not operate by default on a particular Scheduler.

Parameters:

resumeSequence - a function that returns an Observable that will take over if the source Observable encounters an error

Returns:

the original Observable, with appropriately modified behavior

See Also:

ReactiveX operators documentation: Catch

onErrorReturn

public final Observable<T> onErrorReturn(Func1T> resumeFunction)

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

By default, when an Observable encounters an error that prevents it from emitting the expected item to its Observer, the Observable invokes its Observer's onError method, and then quits without invoking any more of its Observer's methods. The onErrorReturn method changes this behavior. If you pass a function (resumeFunction) to an Observable's onErrorReturn method, if the original Observable encounters an error, instead of invoking its Observer's onError method, it will instead emit the return value of resumeFunction.

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

Backpressure:

The operator honors backpressure from downstream. The source Observables is expected to honor backpressure as well. If it this expectation is violated, the operator may throw IllegalStateException when the source Observable completes or MissingBackpressureException is signalled somewhere downstream.

Scheduler:

onErrorReturn does not operate by default on a particular Scheduler.

Parameters:

resumeFunction - a function that returns an item that the new Observable will emit if the source Observable encounters an error

Returns:

the original Observable with appropriately modified behavior

See Also:

ReactiveX operators documentation: Catch

onExceptionResumeNext

public final Observable<T> onExceptionResumeNext(ObservableT> resumeSequence)

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

This differs from onErrorResumeNext(rx.functions.Func1>) in that this one does not handle Throwable or Error but lets those continue through.

By default, when an Observable encounters an exception that prevents it from emitting the expected item to its Observer, the Observable invokes its Observer's onError method, and then quits without invoking any more of its Observer's methods. The onExceptionResumeNext method changes this behavior. If you pass another Observable (resumeSequence) to an Observable's onExceptionResumeNext method, if the original Observable encounters an exception, instead of invoking its Observer's onError method, it will instead relinquish control to resumeSequence which will invoke the Observer's onNext method if it is able to do so. In such a case, because no Observable necessarily invokes onError, the Observer may never know that an exception happened.

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

Backpressure:

The operator honors backpressure from downstream. This and the resuming Observables are expected to honor backpressure as well. If any of them violate this expectation, the operator may throw an IllegalStateException when the source Observable completes or MissingBackpressureException is signalled somewhere downstream.

Scheduler:

onExceptionResumeNext does not operate by default on a particular Scheduler.

Parameters:

resumeSequence - a function that returns an Observable that will take over if the source Observable encounters an exception

Returns:

the original Observable, with appropriately modified behavior

See Also:

ReactiveX operators documentation: Catch

onTerminateDetach

public final Observable<T> onTerminateDetach()

Nulls out references to the upstream producer and downstream Subscriber if the sequence is terminated or downstream unsubscribes.

Backpressure:

The operator doesn't interfere with backpressure which is determined by the source Observable's backpressure behavior.

Scheduler:

onTerminateDetach does not operate by default on a particular Scheduler.

Returns:

an Observable which out references to the upstream producer and downstream Subscriber if the sequence is terminated or downstream unsubscribes

Since:

1.3

publish

public final ConnectableObservable<T> publish()

Returns a ConnectableObservable, which is a variety of Observable that waits until its connect method is called before it begins emitting items to those Observers that have subscribed to it.

Backpressure:

The returned ConnectableObservable honors backpressure for each of its Subscribers and expects the source Observable to honor backpressure as well. If this expectation is violated, the operator will signal a MissingBackpressureException to its Subscribers and disconnect.

Scheduler:

publish does not operate by default on a particular Scheduler.

Returns:

a ConnectableObservable that upon connection causes the source Observable to emit items to its Observers

See Also:

ReactiveX operators documentation: Publish

publish

public final  Observable publish(Func1Observable<T>,? extends Observable> 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.

Backpressure:

The operator expects the source Observable to honor backpressure and if this expectation is violated, the operator will signal a MissingBackpressureException through the Observable provided to the function. Since the Observable returned by the selector may be independent from the provided Observable to the function, the output's backpressure behavior is determined by this returned Observable.

Scheduler:

publish does not operate by default on a particular Scheduler.

Type Parameters:

R - the type of items emitted by the resulting Observable

Parameters:

selector - a function that can use the multicasted source sequence as many times as needed, without causing multiple subscriptions to the source sequence. Subscribers to the given source will receive all notifications of the source from the time of the subscription forward.

Returns:

an Observable that emits the results of invoking the selector on the items emitted by a ConnectableObservable that shares a single subscription to the underlying sequence

See Also:

ReactiveX operators documentation: Publish

rebatchRequests

public final Observable<T> rebatchRequests(int n)

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

This operator allows preventing the downstream to trigger unbounded mode via request(Long.MAX_VALUE) or compensate for the per-item overhead of small and frequent requests.

Backpressure:

The operator expects backpressure from upstream and honors backpressure from downstream.

Scheduler:

rebatchRequests does not operate by default on a particular Scheduler.

Parameters:

n - the initial request amount, further request will happen after 75% of this value

Returns:

the Observable that rebatches request amounts from downstream

Since:

1.3

reduce

public final Observable<T> reduce(Func2<T,T,T> accumulator)

Returns an Observable that applies a specified accumulator function to the first item emitted by a source Observable, then feeds the result of that function along with the second item emitted by the source Observable into the same function, and so on until all items have been emitted by the source Observable, and emits the final result from the final call to your function as its sole item.

This technique, which is called "reduce" here, is sometimes called "aggregate," "fold," "accumulate," "compress," or "inject" in other programming contexts. Groovy, for instance, has an inject method that does a similar operation on lists.

Backpressure:

The operator honors backpressure of its downstream consumer and consumes the upstream source in unbounded mode.

Scheduler:

reduce does not operate by default on a particular Scheduler.

Parameters:

accumulator - an accumulator function to be invoked on each item emitted by the source Observable, whose result will be used in the next accumulator call

Returns:

an Observable that emits a single item that is the result of accumulating the items emitted by the source Observable

Throws:

java.lang.IllegalArgumentException - if the source Observable emits no items

See Also:

ReactiveX operators documentation: Reduce, Wikipedia: Fold (higher-order function)

reduce

public final  Observable reduce(R initialValue,
                                      Func2T,R> accumulator)

Returns an Observable that applies a specified accumulator function to the first item emitted by a source Observable and a specified seed value, then feeds the result of that function along with the second item emitted by an Observable into the same function, and so on until all items have been emitted by the source Observable, emitting the final result from the final call to your function as its sole item.

This technique, which is called "reduce" here, is sometimes called "aggregate," "fold," "accumulate," "compress," or "inject" in other programming contexts. Groovy, for instance, has an inject method that does a similar operation on lists.

Note that the initialValue is shared among all subscribers to the resulting Observable and may cause problems if it is mutable. To make sure each subscriber gets its own value, defer the application of this operator via defer(Func0):

 Observable source = ...
 Observable.defer(() -> source.reduce(new ArrayList<>(), (list, item) -> list.add(item)));

 // alternatively, by using compose to stay fluent

 source.compose(o ->
     Observable.defer(() -> o.reduce(new ArrayList<>(), (list, item) -> list.add(item)))
 );
 

Backpressure:

The operator honors backpressure of its downstream consumer and consumes the upstream source in unbounded mode.

Scheduler:

reduce does not operate by default on a particular Scheduler.

Type Parameters:

R - the accumulator and output value type

Parameters:

initialValue - the initial (seed) accumulator value

accumulator - an accumulator function to be invoked on each item emitted by the source Observable, the result of which will be used in the next accumulator call

Returns:

an Observable that emits a single item that is the result of accumulating the output from the items emitted by the source Observable

See Also:

ReactiveX operators documentation: Reduce, Wikipedia: Fold (higher-order function)

repeat

public final Observable<T> repeat()

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

Backpressure:

The operator honors downstream backpressure and expects the source Observable to honor backpressure as well. If this expectation is violated, the operator may throw an IllegalStateException.

Scheduler:

repeat operates by default on the trampoline Scheduler.

Returns:

an Observable that emits the items emitted by the source Observable repeatedly and in sequence

See Also:

ReactiveX operators documentation: Repeat

repeat

public final Observable<T> repeat(Scheduler scheduler)

Returns an Observable that repeats the sequence of items emitted by the source Observable indefinitely, on a particular Scheduler.

Backpressure:

The operator honors downstream backpressure and expects the source Observable to honor backpressure as well. If this expectation is violated, the operator may throw an IllegalStateException.

Scheduler:

you specify which Scheduler this operator will use

Parameters:

scheduler - the Scheduler to emit the items on

Returns:

an Observable that emits the items emitted by the source Observable repeatedly and in sequence

See Also:

ReactiveX operators documentation: Repeat

repeat

public final Observable<T> repeat(long count)

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

Backpressure:

The operator honors downstream backpressure and expects the source Observable to honor backpressure as well. If this expectation is violated, the operator may throw an IllegalStateException.

Scheduler:

repeat operates by default on the trampoline Scheduler.

Parameters:

count - the number of times the source Observable items are repeated, a count of 0 will yield an empty sequence

Returns:

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

Throws:

java.lang.IllegalArgumentException - if count is less than zero

See Also:

ReactiveX operators documentation: Repeat

repeat

public final Observable<T> repeat(long count,
                                  Scheduler scheduler)

Returns an Observable that repeats the sequence of items emitted by the source Observable at most count times, on a particular Scheduler.

Backpressure:

The operator honors downstream backpressure and expects the source Observable to honor backpressure as well. If this expectation is violated, the operator may throw an IllegalStateException.

Scheduler:

you specify which Scheduler this operator will use

Parameters:

count - the number of times the source Observable items are repeated, a count of 0 will yield an empty sequence

scheduler - the Scheduler to emit the items on

Returns:

an Observable that repeats the sequence of items emitted by the source Observable at most count times on a particular Scheduler

See Also:

ReactiveX operators documentation: Repeat

repeatWhen

public final Observable<T> repeatWhen(Func1Observable,? extends Observable> notificationHandler,
                                      Scheduler scheduler)

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

Backpressure:

The operator honors downstream backpressure and expects the source Observable to honor backpressure as well. If this expectation is violated, the operator may throw an IllegalStateException.

Scheduler:

you specify which Scheduler this operator will use

Parameters:

notificationHandler - receives an Observable of notifications with which a user can complete or error, aborting the repeat.

scheduler - the Scheduler to emit the items on

Returns:

the source Observable modified with repeat logic

See Also:

ReactiveX operators documentation: Repeat

repeatWhen

public final Observable<T> repeatWhen(Func1Observable,? extends Observable> notificationHandler)

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

Backpressure:

The operator honors downstream backpressure and expects the source Observable to honor backpressure as well. If this expectation is violated, the operator may throw an IllegalStateException.

Scheduler:

repeatWhen operates by default on the trampoline Scheduler.

Parameters:

notificationHandler - receives an Observable of notifications with which a user can complete or error, aborting the repeat.

Returns:

the source Observable modified with repeat logic

See Also:

ReactiveX operators documentation: Repeat

replay

public final ConnectableObservable<T> replay()

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

Backpressure:

This operator supports backpressure. Note that the upstream requests are determined by the child Subscriber which requests the largest amount: i.e., two child Subscribers with requests of 10 and 100 will request 100 elements from the underlying Observable sequence.

Scheduler:

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

Returns:

a ConnectableObservable that upon connection causes the source Observable to emit its items to its Observers

See Also:

ReactiveX operators documentation: Replay

replay

public final  Observable replay(Func1Observable<T>,? extends Observable> 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 Observable.

Backpressure:

This operator supports backpressure. Note that the upstream requests are determined by the child Subscriber which requests the largest amount: i.e., two child Subscribers with requests of 10 and 100 will request 100 elements from the underlying Observable sequence.

Scheduler:

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

Type Parameters:

R - the type of items emitted by the resulting Observable

Parameters:

selector - the selector function, which can use the multicasted sequence as many times as needed, without causing multiple subscriptions to the Observable

Returns:

an Observable that emits items that are the results of invoking the selector on a ConnectableObservable that shares a single subscription to the source Observable

See Also:

ReactiveX operators documentation: Replay

replay

public final  Observable replay(Func1Observable<T>,? extends Observable> 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 Observable, replaying bufferSize notifications.

Backpressure:

This operator supports backpressure. Note that the upstream requests are determined by the child Subscriber which requests the largest amount: i.e., two child Subscribers with requests of 10 and 100 will request 100 elements from the underlying Observable sequence.

Scheduler:

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

Type Parameters:

R - the type of items emitted by the resulting Observable

Parameters:

selector - the selector function, which can use the multicasted sequence as many times as needed, without causing multiple subscriptions to the Observable

bufferSize - the buffer size that limits the number of items the connectable observable can replay

Returns:

an Observable that emits items that are the results of invoking the selector on items emitted by a ConnectableObservable that shares a single subscription to the source Observable replaying no more than bufferSize items

See Also:

ReactiveX operators documentation: Replay

replay

public final  Observable replay(Func1Observable<T>,? extends Observable> selector,
                                      int bufferSize,
                                      long time,
                                      java.util.concurrent.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 Observable, replaying no more than bufferSize items that were emitted within a specified time window.

Backpressure:

This operator supports backpressure. Note that the upstream requests are determined by the child Subscriber which requests the largest amount: i.e., two child Subscribers with requests of 10 and 100 will request 100 elements from the underlying Observable sequence.

Scheduler:

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

Type Parameters:

R - the type of items emitted by the resulting Observable

Parameters:

selector - a selector function, which can use the multicasted sequence as many times as needed, without causing multiple subscriptions to the Observable

bufferSize - the buffer size that limits the number of items the connectable observable can replay

time - the duration of the window in which the replayed items must have been emitted

unit - the time unit of time

Returns:

an Observable that emits items that are the results of invoking the selector on items emitted by a ConnectableObservable that shares a single subscription to the source Observable, and replays no more than bufferSize items that were emitted within the window defined by time

See Also:

ReactiveX operators documentation: Replay

replay

public final  Observable replay(Func1Observable<T>,? extends Observable> selector,
                                      int bufferSize,
                                      long time,
                                      java.util.concurrent.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 Observable, replaying no more than bufferSize items that were emitted within a specified time window.

Backpressure:

This operator supports backpressure. Note that the upstream requests are determined by the child Subscriber which requests the largest amount: i.e., two child Subscribers with requests of 10 and 100 will request 100 elements from the underlying Observable sequence.

Scheduler:

you specify which Scheduler this operator will use

Type Parameters:

R - the type of items emitted by the resulting Observable

Parameters:

selector - a selector function, which can use the multicasted sequence as many times as needed, without causing multiple subscriptions to the Observable

bufferSize - the buffer size that limits the number of items the connectable observable can replay

time - the duration of the window in which the replayed items must have been emitted

unit - the time unit of time

scheduler - the Scheduler that is the time source for the window

Returns:

an Observable that emits items that are the results of invoking the selector on items emitted by a ConnectableObservable that shares a single subscription to the source Observable, and replays no more than bufferSize items that were emitted within the window defined by time

Throws:

java.lang.IllegalArgumentException - if bufferSize is less than zero

See Also:

ReactiveX operators documentation: Replay

replay

public final  Observable replay(Func1Observable<T>,? extends Observable> 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 Observable, replaying a maximum of bufferSize items.

Backpressure:

This operator supports backpressure. Note that the upstream requests are determined by the child Subscriber which requests the largest amount: i.e., two child Subscribers with requests of 10 and 100 will request 100 elements from the underlying Observable sequence.

Scheduler:

you specify which Scheduler this operator will use

Type Parameters:

R - the type of items emitted by the resulting Observable

Parameters:

selector - a selector function, which can use the multicasted sequence as many times as needed, without causing multiple subscriptions to the Observable

bufferSize - the buffer size that limits the number of items the connectable observable can replay

scheduler - the Scheduler on which the replay is observed

Returns:

an Observable that emits items that are the results of invoking the selector on items emitted by a ConnectableObservable that shares a single subscription to the source Observable, replaying no more than bufferSize notifications

See Also:

ReactiveX operators documentation: Replay

replay

public final  Observable replay(Func1Observable<T>,? extends Observable> selector,
                                      long time,
                                      java.util.concurrent.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 Observable, replaying all items that were emitted within a specified time window.

Backpressure:

This operator supports backpressure. Note that the upstream requests are determined by the child Subscriber which requests the largest amount: i.e., two child Subscribers with requests of 10 and 100 will request 100 elements from the underlying Observable sequence.

Scheduler:

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

Type Parameters:

R - the type of items emitted by the resulting Observable

Parameters:

selector - a selector function, which can use the multicasted sequence as many times as needed, without causing multiple subscriptions to the Observable

time - the duration of the window in which the replayed items must have been emitted

unit - the time unit of time

Returns:

an Observable that emits items that are the results of invoking the selector on items emitted by a ConnectableObservable that shares a single subscription to the source Observable, replaying all items that were emitted within the window defined by time

See Also:

ReactiveX operators documentation: Replay

replay

public final  Observable replay(Func1Observable<T>,? extends Observable> selector,
                                      long time,
                                      java.util.concurrent.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 Observable, replaying all items that were emitted within a specified time window.

Backpressure:

This operator supports backpressure. Note that the upstream requests are determined by the child Subscriber which requests the largest amount: i.e., two child Subscribers with requests of 10 and 100 will request 100 elements from the underlying Observable sequence.

Scheduler:

you specify which Scheduler this operator will use

Type Parameters:

R - the type of items emitted by the resulting Observable

Parameters:

selector - a selector function, which can use the multicasted sequence as many times as needed, without causing multiple subscriptions to the Observable

time - the duration of the window in which the replayed items must have been emitted

unit - the time unit of time

scheduler - the scheduler that is the time source for the window

Returns:

an Observable that emits items that are the results of invoking the selector on items emitted by a ConnectableObservable that shares a single subscription to the source Observable, replaying all items that were emitted within the window defined by time

See Also:

ReactiveX operators documentation: Replay

replay

public final  Observable replay(Func1Observable<T>,? extends Observable> 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 Observable.

Backpressure:

This operator supports backpressure. Note that the upstream requests are determined by the child Subscriber which requests the largest amount: i.e., two child Subscribers with requests of 10 and 100 will request 100 elements from the underlying Observable sequence.

Scheduler:

you specify which Scheduler this operator will use

Type Parameters:

R - the type of items emitted by the resulting Observable

Parameters:

selector - a selector function, which can use the multicasted sequence as many times as needed, without causing multiple subscriptions to the Observable

scheduler - the Scheduler where the replay is observed

Returns:

an Observable that emits items that are the results of invoking the selector on items emitted by a ConnectableObservable that shares a single subscription to the source Observable, replaying all items

See Also:

ReactiveX operators documentation: Replay

replay

public final ConnectableObservable<T> replay(int bufferSize)

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

Backpressure:

This operator supports backpressure. Note that the upstream requests are determined by the child Subscriber which requests the largest amount: i.e., two child Subscribers with requests of 10 and 100 will request 100 elements from the underlying Observable sequence.

Scheduler:

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

Parameters:

bufferSize - the buffer size that limits the number of items that can be replayed

Returns:

a ConnectableObservable that shares a single subscription to the source Observable and replays at most bufferSize items emitted by that Observable

See Also:

ReactiveX operators documentation: Replay

replay

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

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

Backpressure:

This operator supports backpressure. Note that the upstream requests are determined by the child Subscriber which requests the largest amount: i.e., two child Subscribers with requests of 10 and 100 will request 100 elements from the underlying Observable sequence.

Scheduler:

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

Parameters:

bufferSize - the buffer size that limits the number of items that can be replayed

time - the duration of the window in which the replayed items must have been emitted

unit - the time unit of time

Returns:

a ConnectableObservable that shares a single subscription to the source Observable and replays at most bufferSize items that were emitted during the window defined by time

See Also:

ReactiveX operators documentation: Replay

replay

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

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

Backpressure:

This operator supports backpressure. Note that the upstream requests are determined by the child Subscriber which requests the largest amount: i.e., two child Subscribers with requests of 10 and 100 will request 100 elements from the underlying Observable sequence.

Scheduler:

you specify which Scheduler this operator will use

Parameters:

bufferSize - the buffer size that limits the number of items that can be replayed

time - the duration of the window in which the replayed items must have been emitted

unit - the time unit of time

scheduler - the scheduler that is used as a time source for the window

Returns:

a ConnectableObservable that shares a single subscription to the source Observable and replays at most bufferSize items that were emitted during the window defined by time

Throws:

java.lang.IllegalArgumentException - if bufferSize is less than zero

See Also:

ReactiveX operators documentation: Replay

replay

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

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

Backpressure:

This operator supports backpressure. Note that the upstream requests are determined by the child Subscriber which requests the largest amount: i.e., two child Subscribers with requests of 10 and 100 will request 100 elements from the underlying Observable sequence.

Scheduler:

you specify which Scheduler this operator will use

Parameters:

bufferSize - the buffer size that limits the number of items that can be replayed

scheduler - the scheduler on which the Observers will observe the emitted items

Returns:

a ConnectableObservable that shares a single subscription to the source Observable and replays at most bufferSize items that were emitted by the Observable

See Also:

ReactiveX operators documentation: Replay

replay

public final ConnectableObservable<T> replay(long time,
                                             java.util.concurrent.TimeUnit unit)

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

Backpressure:

This operator supports backpressure. Note that the upstream requests are determined by the child Subscriber which requests the largest amount: i.e., two child Subscribers with requests of 10 and 100 will request 100 elements from the underlying Observable sequence.

Scheduler:

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

Parameters:

time - the duration of the window in which the replayed items must have been emitted

unit - the time unit of time

Returns:

a ConnectableObservable that shares a single subscription to the source Observable and replays the items that were emitted during the window defined by time

See Also:

ReactiveX operators documentation: Replay

replay

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

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

Backpressure:

This operator supports backpressure. Note that the upstream requests are determined by the child Subscriber which requests the largest amount: i.e., two child Subscribers with requests of 10 and 100 will request 100 elements from the underlying Observable sequence.

Scheduler:

you specify which Scheduler this operator will use

Parameters:

time - the duration of the window in which the replayed items must have been emitted

unit - the time unit of time

scheduler - the Scheduler that is the time source for the window

Returns:

a ConnectableObservable that shares a single subscription to the source Observable and replays the items that were emitted during the window defined by time

See Also:

ReactiveX operators documentation: Replay

replay

public final ConnectableObservable<T> replay(Scheduler scheduler)

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

Backpressure:

This operator supports backpressure. Note that the upstream requests are determined by the child Subscriber which requests the largest amount: i.e., two child Subscribers with requests of 10 and 100 will request 100 elements from the underlying Observable sequence.

Scheduler:

you specify which Scheduler this operator will use

Parameters:

scheduler - the Scheduler on which the Observers will observe the emitted items

Returns:

a ConnectableObservable that shares a single subscription to the source Observable that will replay all of its items and notifications to any future Observer on the given Scheduler

See Also:

ReactiveX operators documentation: Replay

retry

public final Observable<T> retry()

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

If the source Observable calls Observer.onError(java.lang.Throwable), this method will resubscribe to the source Observable rather than propagating the onError call.

Any and all items emitted by the source Observable will be emitted by the resulting Observable, even those emitted during failed subscriptions. For example, if an Observable fails at first but emits [1, 2] then succeeds the second time and emits [1, 2, 3, 4, 5] then the complete sequence of emissions and notifications would be [1, 2, 1, 2, 3, 4, 5, onCompleted].

Backpressure:

The operator honors downstream backpressure and expects the source Observable to honor backpressure as well. If this expectation is violated, the operator may throw an IllegalStateException.

Scheduler:

retry operates by default on the trampoline Scheduler.

Returns:

the source Observable modified with retry logic

See Also:

ReactiveX operators documentation: Retry

retry

public final Observable<T> retry(long count)

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

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

Any and all items emitted by the source Observable will be emitted by the resulting Observable, even those emitted during failed subscriptions. For example, if an Observable fails at first but emits [1, 2] then succeeds the second time and emits [1, 2, 3, 4, 5] then the complete sequence of emissions and notifications would be [1, 2, 1, 2, 3, 4, 5, onCompleted].

Backpressure:

The operator honors downstream backpressure and expects the source Observable to honor backpressure as well. If this expectation is violated, the operator may throw an IllegalStateException.

Scheduler:

retry operates by default on the trampoline Scheduler.

Parameters:

count - number of retry attempts before failing

Returns:

the source Observable modified with retry logic

See Also:

ReactiveX operators documentation: Retry

retry

public final Observable<T> retry(Func2 predicate)

Returns an Observable that mirrors the source Observable, resubscribing to it if it calls onError and the predicate returns true for that specific exception and retry count.

Backpressure:

The operator honors downstream backpressure and expects the source Observable to honor backpressure as well. If this expectation is violated, the operator may throw an IllegalStateException.

Scheduler:

retry operates by default on the trampoline Scheduler.

Parameters:

predicate - the predicate that determines if a resubscription may happen in case of a specific exception and retry count

Returns:

the source Observable modified with retry logic

See Also:

retry(), ReactiveX operators documentation: Retry

retryWhen

public final Observable<T> retryWhen(Func1Observable,? extends Observable> notificationHandler)

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

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

  Observable.create((Subscriber super String> s) -> {
      System.out.println("subscribing");
      s.onError(new RuntimeException("always fails"));
  }).retryWhen(attempts -> {
      return attempts.zipWith(Observable.range(1, 3), (n, i) -> i).flatMap(i -> {
          System.out.println("delay retry by " + i + " second(s)");
          return Observable.timer(i, TimeUnit.SECONDS);
      });
  }).toBlocking().forEach(System.out::println);
 

Output is:

 
 subscribing
 delay retry by 1 second(s)
 subscribing
 delay retry by 2 second(s)
 subscribing
 delay retry by 3 second(s)
 subscribing
  

Backpressure:

The operator honors downstream backpressure and expects the source Observable to honor backpressure as well. If this expectation is violated, the operator may throw an IllegalStateException.

Scheduler:

retryWhen operates by default on the trampoline Scheduler.

Parameters:

notificationHandler - receives an Observable of notifications with which a user can complete or error, aborting the retry

Returns:

the source Observable modified with retry logic

See Also:

ReactiveX operators documentation: Retry

retryWhen

public final Observable<T> retryWhen(Func1Observable,? extends Observable> notificationHandler,
                                     Scheduler scheduler)

Returns an Observable that emits the same values as the source observable with the exception of an onError. An onError will cause the emission of the Throwable that cause the error to the Observable returned from notificationHandler. If that Observable calls onComplete or onError then retry will call onCompleted or onError on the child subscription. Otherwise, this Observable will resubscribe to the source observable, on a particular Scheduler.

Backpressure:

The operator honors downstream backpressure and expects the source Observable to honor backpressure as well. If this expectation is violated, the operator may throw an IllegalStateException.

Scheduler:

you specify which Scheduler this operator will use

Parameters:

notificationHandler - receives an Observable of notifications with which a user can complete or error, aborting the retry

scheduler - the Scheduler on which to subscribe to the source Observable

Returns:

the source Observable modified with retry logic

See Also:

ReactiveX operators documentation: Retry

sample

public final Observable<T> sample(long period,
                                  java.util.concurrent.TimeUnit unit)

Returns an Observable that emits the most recently emitted item (if any) emitted by the source Observable within periodic time intervals.

Backpressure:

This operator does not support backpressure as it uses time to control data flow.

Scheduler:

sample operates by default on the computation Scheduler.

Parameters:

period - the sampling rate

unit - the TimeUnit in which period is defined

Returns:

an Observable that emits the results of sampling the items emitted by the source Observable at the specified time interval

See Also:

ReactiveX operators documentation: Sample, RxJava wiki: Backpressure, throttleLast(long, TimeUnit)

sample

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

Returns an Observable that emits the most recently emitted item (if any) emitted by the source Observable within periodic time intervals, where the intervals are defined on a particular Scheduler.

Backpressure:

This operator does not support backpressure as it uses time to control data flow.

Scheduler:

you specify which Scheduler this operator will use

Parameters:

period - the sampling rate

unit - the TimeUnit in which period is defined

scheduler - the Scheduler to use when sampling

Returns:

an Observable that emits the results of sampling the items emitted by the source Observable at the specified time interval

See Also:

ReactiveX operators documentation: Sample, RxJava wiki: Backpressure, throttleLast(long, TimeUnit, Scheduler)

sample

public final  Observable<T> sample(Observable sampler)

Returns an Observable that, when the specified sampler Observable emits an item or completes, emits the most recently emitted item (if any) emitted by the source Observable since the previous emission from the sampler Observable.

Backpressure:

This operator does not support backpressure as it uses the emissions of the sampler Observable to control data flow.

Scheduler:

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

Type Parameters:

U - the element type of the sampler Observable

Parameters:

sampler - the Observable to use for sampling the source Observable

Returns:

an Observable that emits the results of sampling the items emitted by this Observable whenever the sampler Observable emits an item or completes

See Also:

ReactiveX operators documentation: Sample, RxJava wiki: Backpressure

scan

public final Observable<T> scan(Func2<T,T,T> accumulator)

Returns an Observable that applies a specified accumulator function to the first item emitted by a source Observable, then feeds the result of that function along with the second item emitted by the source Observable into the same function, and so on until all items have been emitted by the source Observable, emitting the result of each of these iterations.

This sort of function is sometimes called an accumulator.

Backpressure:

The operator honors downstream backpressure and expects the source Observable to honor backpressure as well. Violating this expectation, a MissingBackpressureException may get signalled somewhere downstream.

Scheduler:

scan does not operate by default on a particular Scheduler.

Parameters:

accumulator - an accumulator function to be invoked on each item emitted by the source Observable, whose result will be emitted to Observers via onNext and used in the next accumulator call

Returns:

an Observable that emits the results of each call to the accumulator function

See Also:

ReactiveX operators documentation: Scan

scan

public final  Observable scan(R initialValue,
                                    Func2T,R> accumulator)

Returns an Observable that applies a specified accumulator function to the first item emitted by a source Observable and a seed value, then feeds the result of that function along with the second item emitted by the source Observable into the same function, and so on until all items have been emitted by the source Observable, emitting the result of each of these iterations.

This sort of function is sometimes called an accumulator.

Note that the Observable that results from this method will emit initialValue as its first emitted item.

Note that the initialValue is shared among all subscribers to the resulting Observable and may cause problems if it is mutable. To make sure each subscriber gets its own value, defer the application of this operator via defer(Func0):

 Observable source = ...
 Observable.defer(() -> source.scan(new ArrayList<>(), (list, item) -> list.add(item)));

 // alternatively, by using compose to stay fluent

 source.compose(o ->
     Observable.defer(() -> o.scan(new ArrayList<>(), (list, item) -> list.add(item)))
 );
 

Backpressure:

The operator honors downstream backpressure and expects the source Observable to honor backpressure as well. Violating this expectation, a MissingBackpressureException may get signalled somewhere downstream.

Scheduler:

scan does not operate by default on a particular Scheduler.

Type Parameters:

R - the initial, accumulator and result type

Parameters:

initialValue - the initial (seed) accumulator item

accumulator - an accumulator function to be invoked on each item emitted by the source Observable, whose result will be emitted to Observers via onNext and used in the next accumulator call

Returns:

an Observable that emits initialValue followed by the results of each call to the accumulator function

See Also:

ReactiveX operators documentation: Scan

serialize

public final Observable<T> serialize()

Forces an Observable's emissions and notifications to be serialized and for it to obey the Observable contract in other ways.

It is possible for an Observable to invoke its Subscribers' methods asynchronously, perhaps from different threads. This could make such an Observable poorly-behaved, in that it might try to invoke onCompleted or onError before one of its onNext invocations, or it might call onNext from two different threads concurrently. You can force such an Observable to be well-behaved and sequential by applying the serialize method to it.

Backpressure:

The operator doesn't interfere with backpressure which is determined by the source Observable's backpressure behavior.

Scheduler:

serialize does not operate by default on a particular Scheduler.

Returns:

an Observable that is guaranteed to be well-behaved and to make only serialized calls to its observers

See Also:

ReactiveX operators documentation: Serialize

share

public final Observable<T> share()

Returns a new Observable that multicasts (shares) the original Observable. As long as there is at least one Subscriber this Observable will be subscribed and emitting data. When all subscribers have unsubscribed it will unsubscribe from the source Observable.

This is an alias for publish().ConnectableObservable.refCount().

Backpressure:

The operator honors backpressure and and expects the source Observable to honor backpressure as well. If this expectation is violated, the operator will signal a MissingBackpressureException to its Subscribers.

Scheduler:

share does not operate by default on a particular Scheduler.

Returns:

an Observable that upon connection causes the source Observable to emit items to its Observers

See Also:

ReactiveX operators documentation: RefCount

single

public final Observable<T> single()

Returns an Observable that emits the single item emitted by the source Observable, if that Observable emits only a single item. If the source Observable emits more than one item or no items, notify of an IllegalArgumentException or NoSuchElementException respectively.

Backpressure:

The operator honors backpressure from downstream and consumes the source Observable in an unbounded manner (i.e., without applying backpressure).

Scheduler:

single does not operate by default on a particular Scheduler.

Returns:

an Observable that emits the single item emitted by the source Observable

Throws:

java.lang.IllegalArgumentException - if the source emits more than one item

java.util.NoSuchElementException - if the source emits no items

See Also:

ReactiveX operators documentation: First

single

public final Observable<T> single(Func1T,java.lang.Boolean> predicate)

Returns an Observable that emits the single item emitted by the source Observable that matches a specified predicate, if that Observable emits one such item. If the source Observable emits more than one such item or no such items, notify of an IllegalArgumentException or NoSuchElementException respectively.

Backpressure:

The operator honors backpressure from downstream and consumes the source Observable in an unbounded manner (i.e., without applying backpressure).

Scheduler:

single does not operate by default on a particular Scheduler.

Parameters:

predicate - a predicate function to evaluate items emitted by the source Observable

Returns:

an Observable that emits the single item emitted by the source Observable that matches the predicate

Throws:

java.lang.IllegalArgumentException - if the source Observable emits more than one item that matches the predicate

java.util.NoSuchElementException - if the source Observable emits no item that matches the predicate

See Also:

ReactiveX operators documentation: First

singleOrDefault

public final Observable<T> singleOrDefault(T defaultValue)

Returns an Observable that emits the single item emitted by the source Observable, if that Observable emits only a single item, or a default item if the source Observable emits no items. If the source Observable emits more than one item, throw an IllegalArgumentException.

Backpressure:

The operator honors backpressure from downstream and consumes the source Observable in an unbounded manner (i.e., without applying backpressure).

Scheduler:

singleOrDefault does not operate by default on a particular Scheduler.

Parameters:

defaultValue - a default value to emit if the source Observable emits no item

Returns:

an Observable that emits the single item emitted by the source Observable, or a default item if the source Observable is empty

Throws:

java.lang.IllegalArgumentException - if the source Observable emits more than one item

See Also:

ReactiveX operators documentation: First

singleOrDefault

public final Observable<T> singleOrDefault(T defaultValue,
                                           Func1T,java.lang.Boolean> predicate)

Returns an Observable that emits the single item emitted by the source Observable that matches a predicate, if that Observable emits only one such item, or a default item if the source Observable emits no such items. If the source Observable emits more than one such item, throw an IllegalArgumentException.

Backpressure:

The operator honors backpressure from downstream and consumes the source Observable in an unbounded manner (i.e., without applying backpressure).

Scheduler:

singleOrDefault does not operate by default on a particular Scheduler.

Parameters:

defaultValue - a default item to emit if the source Observable emits no matching items

predicate - a predicate function to evaluate items emitted by the source Observable

Returns:

an Observable that emits the single item emitted by the source Observable that matches the predicate, or the default item if no emitted item matches the predicate

Throws:

java.lang.IllegalArgumentException - if the source Observable emits more than one item that matches the predicate

See Also:

ReactiveX operators documentation: First

skip

public final Observable<T> skip(int count)

Returns an Observable that skips the first count items emitted by the source Observable and emits the remainder.

Backpressure:

The operator doesn't interfere with backpressure which is determined by the source Observable's backpressure behavior.

Scheduler:

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

Parameters:

count - the number of items to skip

Returns:

an Observable that is identical to the source Observable except that it does not emit the first count items that the source Observable emits

See Also:

ReactiveX operators documentation: Skip

skip

public final Observable<T> skip(long time,
                                java.util.concurrent.TimeUnit unit)

Returns an Observable that skips values emitted by the source Observable before a specified time window elapses.

Backpressure:

The operator doesn't support backpressure as it uses time to skip arbitrary number of elements and thus has to consume the source Observable in an unbounded manner (i.e., no backpressure applied to it).

Scheduler:

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

Parameters:

time - the length of the time window to skip

unit - the time unit of time

Returns:

an Observable that skips values emitted by the source Observable before the time window defined by time elapses and the emits the remainder

See Also:

ReactiveX operators documentation: Skip

skip

public final Observable<T> skip(long time,
                                java.util.concurrent.TimeUnit unit,
                                Scheduler scheduler)

Returns an Observable that skips values emitted by the source Observable before a specified time window on a specified Scheduler elapses.

Backpressure:

The operator doesn't support backpressure as it uses time to skip arbitrary number of elements and thus has to consume the source Observable in an unbounded manner (i.e., no backpressure applied to it).

Scheduler:

you specify which Scheduler this operator will use

Parameters:

time - the length of the time window to skip

unit - the time unit of time

scheduler - the Scheduler on which the timed wait happens

Returns:

an Observable that skips values emitted by the source Observable before the time window defined by time and scheduler elapses, and then emits the remainder

See Also:

ReactiveX operators documentation: Skip

skipLast

public final Observable<T> skipLast(int count)

Returns an Observable that drops a specified number of items from the end of the sequence emitted by the source Observable.

This Observer accumulates a queue long enough to store the first count items. As more items are received, items are taken from the front of the queue and emitted by the returned Observable. This causes such items to be delayed.

Backpressure:

The operator doesn't interfere with backpressure which is determined by the source Observable's backpressure behavior.

Scheduler:

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

Parameters:

count - number of items to drop from the end of the source sequence

Returns:

an Observable that emits the items emitted by the source Observable except for the dropped ones at the end

Throws:

java.lang.IndexOutOfBoundsException - if count is less than zero

See Also:

ReactiveX operators documentation: SkipLast

skipLast

public final Observable<T> skipLast(long time,
                                    java.util.concurrent.TimeUnit unit)

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

Note: this action will cache the latest items arriving in the specified time window.

Backpressure:

The operator doesn't support backpressure as it uses time to skip arbitrary number of elements and thus has to consume the source Observable in an unbounded manner (i.e., no backpressure applied to it).

Scheduler:

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

Parameters:

time - the length of the time window

unit - the time unit of time

Returns:

an Observable that drops those items emitted by the source Observable in a time window before the source completes defined by time

See Also:

ReactiveX operators documentation: SkipLast

skipLast

public final Observable<T> skipLast(long time,
                                    java.util.concurrent.TimeUnit unit,
                                    Scheduler scheduler)

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

Note: this action will cache the latest items arriving in the specified time window.

Backpressure:

The operator doesn't support backpressure as it uses time to skip arbitrary number of elements and thus has to consume the source Observable in an unbounded manner (i.e., no backpressure applied to it).

Scheduler:

you specify which Scheduler this operator will use

Parameters:

time - the length of the time window

unit - the time unit of time

scheduler - the scheduler used as the time source

Returns:

an Observable that drops those items emitted by the source Observable in a time window before the source completes defined by time and scheduler

See Also:

ReactiveX operators documentation: SkipLast

skipUntil

public final  Observable<T> skipUntil(Observable other)

Returns an Observable that skips items emitted by the source Observable until a second Observable emits an item.

Backpressure:

The operator doesn't interfere with backpressure which is determined by the source Observable's backpressure behavior.

Scheduler:

skipUntil does not operate by default on a particular Scheduler.

Type Parameters:

U - the element type of the other Observable

Parameters:

other - the second Observable that has to emit an item before the source Observable's elements begin to be mirrored by the resulting Observable

Returns:

an Observable that skips items from the source Observable until the second Observable emits an item, then emits the remaining items

See Also:

ReactiveX operators documentation: SkipUntil

skipWhile

public final Observable<T> skipWhile(Func1T,java.lang.Boolean> predicate)

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

Backpressure:

The operator doesn't interfere with backpressure which is determined by the source Observable's backpressure behavior.

Scheduler:

skipWhile does not operate by default on a particular Scheduler.

Parameters:

predicate - a function to test each item emitted from the source Observable

Returns:

an Observable that begins emitting items emitted by the source Observable when the specified predicate becomes false

See Also:

ReactiveX operators documentation: SkipWhile

startWith

public final Observable<T> startWith(Observable<T> values)

Returns an Observable that emits the items in a specified Observable before it begins to emit items emitted by the source Observable.

Backpressure:

The operator honors backpressure from downstream. Both this and the other Observables are expected to honor backpressure as well. If any of then violates this rule, it may throw an IllegalStateException when the source Observable completes.

Scheduler:

startWith does not operate by default on a particular Scheduler.

Parameters:

values - an Observable that contains the items you want the modified Observable to emit first

Returns:

an Observable that emits the items in the specified Observable and then emits the items emitted by the source Observable

See Also:

ReactiveX operators documentation: StartWith

startWith

public final Observable<T> startWith(java.lang.Iterable<T> values)

Returns an Observable that emits the items in a specified Iterable before it begins to emit items emitted by the source Observable.

Backpressure:

The operator honors backpressure from downstream. The source Observable is expected to honor backpressure as well. If it violates this rule, it may throw an IllegalStateException when the source Observable completes.

Scheduler:

startWith does not operate by default on a particular Scheduler.

Parameters:

values - an Iterable that contains the items you want the modified Observable to emit first

Returns:

an Observable that emits the items in the specified Iterable and then emits the items emitted by the source Observable

See Also:

ReactiveX operators documentation: StartWith

startWith

public final Observable<T> startWith(T t1)

Returns an Observable that emits a specified item before it begins to emit items emitted by the source Observable.

Backpressure:

The operator honors backpressure from downstream. The source Observable is expected to honor backpressure as well. If it violates this rule, it may throw an IllegalStateException when the source Observable completes.

Scheduler:

startWith does not operate by default on a particular Scheduler.

Parameters:

t1 - the item to emit

Returns:

an Observable that emits the specified item before it begins to emit items emitted by the source Observable

See Also:

ReactiveX operators documentation: StartWith

startWith

public final Observable<T> startWith(T t1,
                                     T t2)

Returns an Observable that emits the specified items before it begins to emit items emitted by the source Observable.

Backpressure:

The operator honors backpressure from downstream. The source Observable is expected to honor backpressure as well. If it violates this rule, it may throw an IllegalStateException when the source Observable completes.

Scheduler:

startWith does not operate by default on a particular Scheduler.

Parameters:

t1 - the first item to emit

t2 - the second item to emit

Returns:

an Observable that emits the specified items before it begins to emit items emitted by the source Observable

See Also:

ReactiveX operators documentation: StartWith

startWith

public final Observable<T> startWith(T t1,
                                     T t2,
                                     T t3)

Returns an Observable that emits the specified items before it begins to emit items emitted by the source Observable.

Backpressure:

The operator honors backpressure from downstream. The source Observable is expected to honor backpressure as well. If it violates this rule, it may throw an IllegalStateException when the source Observable completes.

Scheduler:

startWith does not operate by default on a particular Scheduler.

Parameters:

t1 - the first item to emit

t2 - the second item to emit

t3 - the third item to emit

Returns:

an Observable that emits the specified items before it begins to emit items emitted by the source Observable

See Also:

ReactiveX operators documentation: StartWith

startWith

public final Observable<T> startWith(T t1,
                                     T t2,
                                     T t3,
                                     T t4)

Returns an Observable that emits the specified items before it begins to emit items emitted by the source Observable.

Backpressure:

The operator honors backpressure from downstream. The source Observable is expected to honor backpressure as well. If it violates this rule, it may throw an IllegalStateException when the source Observable completes.

Scheduler:

startWith does not operate by default on a particular Scheduler.

Parameters:

t1 - the first item to emit

t2 - the second item to emit

t3 - the third item to emit

t4 - the fourth item to emit

Returns:

an Observable that emits the specified items before it begins to emit items emitted by the source Observable

See Also:

ReactiveX operators documentation: StartWith

startWith

public final Observable<T> startWith(T t1,
                                     T t2,
                                     T t3,
                                     T t4,
                                     T t5)

Returns an Observable that emits the specified items before it begins to emit items emitted by the source Observable.

Backpressure:

The operator honors backpressure from downstream. The source Observable is expected to honor backpressure as well. If it violates this rule, it may throw an IllegalStateException when the source Observable completes.

Scheduler:

startWith does not operate by default on a particular Scheduler.

Parameters:

t1 - the first item to emit

t2 - the second item to emit

t3 - the third item to emit

t4 - the fourth item to emit

t5 - the fifth item to emit

Returns:

an Observable that emits the specified items before it begins to emit items emitted by the source Observable

See Also:

ReactiveX operators documentation: StartWith

startWith

public final Observable<T> startWith(T t1,
                                     T t2,
                                     T t3,
                                     T t4,
                                     T t5,
                                     T t6)

Returns an Observable that emits the specified items before it begins to emit items emitted by the source Observable.

Backpressure:

The operator honors backpressure from downstream. The source Observable is expected to honor backpressure as well. If it violates this rule, it may throw an IllegalStateException when the source Observable completes.

Scheduler:

startWith does not operate by default on a particular Scheduler.

Parameters:

t1 - the first item to emit

t2 - the second item to emit

t3 - the third item to emit

t4 - the fourth item to emit

t5 - the fifth item to emit

t6 - the sixth item to emit

Returns:

an Observable that emits the specified items before it begins to emit items emitted by the source Observable

See Also:

ReactiveX operators documentation: StartWith

startWith

public final Observable<T> startWith(T t1,
                                     T t2,
                                     T t3,
                                     T t4,
                                     T t5,
                                     T t6,
                                     T t7)

Returns an Observable that emits the specified items before it begins to emit items emitted by the source Observable.

Backpressure:

The operator honors backpressure from downstream. The source Observable is expected to honor backpressure as well. If it violates this rule, it may throw an IllegalStateException when the source Observable completes.

Scheduler:

startWith does not operate by default on a particular Scheduler.

Parameters:

t1 - the first item to emit

t2 - the second item to emit

t3 - the third item to emit

t4 - the fourth item to emit

t5 - the fifth item to emit

t6 - the sixth item to emit

t7 - the seventh item to emit

Returns:

an Observable that emits the specified items before it begins to emit items emitted by the source Observable

See Also:

ReactiveX operators documentation: StartWith

startWith

public final Observable<T> startWith(T t1,
                                     T t2,
                                     T t3,
                                     T t4,
                                     T t5,
                                     T t6,
                                     T t7,
                                     T t8)

Returns an Observable that emits the specified items before it begins to emit items emitted by the source Observable.

Backpressure:

The operator honors backpressure from downstream. The source Observable is expected to honor backpressure as well. If it violates this rule, it may throw an IllegalStateException when the source Observable completes.

Scheduler:

startWith does not operate by default on a particular Scheduler.

Parameters:

t1 - the first item to emit

t2 - the second item to emit

t3 - the third item to emit

t4 - the fourth item to emit

t5 - the fifth item to emit

t6 - the sixth item to emit

t7 - the seventh item to emit

t8 - the eighth item to emit

Returns:

an Observable that emits the specified items before it begins to emit items emitted by the source Observable

See Also:

ReactiveX operators documentation: StartWith

startWith

public final Observable<T> startWith(T t1,
                                     T t2,
                                     T t3,
                                     T t4,
                                     T t5,
                                     T t6,
                                     T t7,
                                     T t8,
                                     T t9)

Returns an Observable that emits the specified items before it begins to emit items emitted by the source Observable.

Backpressure:

The operator honors backpressure from downstream. The source Observable is expected to honor backpressure as well. If it violates this rule, it may throw an IllegalStateException when the source Observable completes.

Scheduler:

startWith does not operate by default on a particular Scheduler.

Parameters:

t1 - the first item to emit

t2 - the second item to emit

t3 - the third item to emit

t4 - the fourth item to emit

t5 - the fifth item to emit

t6 - the sixth item to emit

t7 - the seventh item to emit

t8 - the eighth item to emit

t9 - the ninth item to emit

Returns:

an Observable that emits the specified items before it begins to emit items emitted by the source Observable

See Also:

ReactiveX operators documentation: StartWith

subscribe

public final Subscription subscribe()

Subscribes to an Observable and ignores onNext and onCompleted emissions. If an onError emission arrives then OnErrorNotImplementedException is thrown.

Backpressure:

The operator consumes the source Observable in an unbounded manner (i.e., no backpressure is applied to it).

Scheduler:

subscribe does not operate by default on a particular Scheduler.

Returns:

a Subscription reference with which the Observer can stop receiving items before the Observable has finished sending them

Throws:

OnErrorNotImplementedException - if the Observable tries to call onError

See Also:

ReactiveX operators documentation: Subscribe

subscribe

public final Subscription subscribe(Action1T> onNext)

Subscribes to an Observable and provides a callback to handle the items it emits.

Backpressure:

The operator consumes the source Observable in an unbounded manner (i.e., no backpressure is applied to it).

Scheduler:

subscribe does not operate by default on a particular Scheduler.

Parameters:

onNext - the Action1 you have designed to accept emissions from the Observable

Returns:

a Subscription reference with which the Observer can stop receiving items before the Observable has finished sending them

Throws:

java.lang.IllegalArgumentException - if onNext is null

OnErrorNotImplementedException - if the Observable calls onError

See Also:

ReactiveX operators documentation: Subscribe

subscribe

public final Subscription subscribe(Action1T> onNext,
                                    Action1 onError)

Subscribes to an Observable and provides callbacks to handle the items it emits and any error notification it issues.

Backpressure:

The operator consumes the source Observable in an unbounded manner (i.e., no backpressure is applied to it).

Scheduler:

subscribe does not operate by default on a particular Scheduler.

Parameters:

onNext - the Action1 you have designed to accept emissions from the Observable

onError - the Action1 you have designed to accept any error notification from the Observable

Returns:

a Subscription reference with which the Observer can stop receiving items before the Observable has finished sending them

Throws:

java.lang.IllegalArgumentException - if onNext is null, or if onError is null

See Also:

ReactiveX operators documentation: Subscribe

subscribe

public final Subscription subscribe(Action1T> onNext,
                                    Action1 onError,
                                    Action0 onCompleted)

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

Backpressure:

The operator consumes the source Observable in an unbounded manner (i.e., no backpressure is applied to it).

Scheduler:

subscribe does not operate by default on a particular Scheduler.

Parameters:

onNext - the Action1 you have designed to accept emissions from the Observable

onError - the Action1 you have designed to accept any error notification from the Observable

onCompleted - the Action0 you have designed to accept a completion notification from the Observable

Returns:

a Subscription reference with which the Observer can stop receiving items before the Observable has finished sending them

Throws:

java.lang.IllegalArgumentException - if onNext is null, or if onError is null, or if onComplete is null

See Also:

ReactiveX operators documentation: Subscribe

subscribe

public final Subscription subscribe(ObserverT> observer)

Subscribes to an Observable and provides an Observer that implements functions to handle the items the Observable emits and any error or completion notification it issues.

Backpressure:

The operator consumes the source Observable in an unbounded manner (i.e., no backpressure is applied to it).

Scheduler:

subscribe does not operate by default on a particular Scheduler.

Parameters:

observer - the Observer that will handle emissions and notifications from the Observable

Returns:

a Subscription reference with which the Observer can stop receiving items before the Observable has completed

See Also:

ReactiveX operators documentation: Subscribe

unsafeSubscribe

public final Subscription unsafeSubscribe(SubscriberT> subscriber)

Subscribes to an Observable and invokes Observable.OnSubscribe function without any contract protection, error handling, unsubscribe, or execution hooks.

Use this only for implementing an Observable.Operator that requires nested subscriptions. For other purposes, use subscribe(Subscriber) which ensures the Observable contract and other functionality.

Backpressure:

The operator doesn't interfere with backpressure which is determined by the source Observable's backpressure behavior.

Scheduler:

unsafeSubscribe does not operate by default on a particular Scheduler.

Parameters:

subscriber - the Subscriber that will handle emissions and notifications from the Observable

Returns:

a Subscription reference with which the Subscriber can stop receiving items before the Observable has completed

subscribe

public final Subscription subscribe(SubscriberT> subscriber)

Subscribes to an Observable and provides a Subscriber that implements functions to handle the items the Observable emits and any error or completion notification it issues.

A typical implementation of subscribe does the following:

1. It stores a reference to the Subscriber in a collection object, such as a List object.
2. It returns a reference to the Subscription interface. This enables Subscribers to unsubscribe, that is, to stop receiving items and notifications before the Observable completes, which also invokes the Subscriber's onCompleted method.

An Observable instance is responsible for accepting all subscriptions and notifying all Subscribers. Unless the documentation for a particular Observable implementation indicates otherwise, Subscriber should make no assumptions about the order in which multiple Subscribers will receive their notifications.

For more information see the ReactiveX documentation.

Backpressure:

The operator doesn't interfere with backpressure which is determined by the source Observable's backpressure behavior.

Scheduler:

subscribe does not operate by default on a particular Scheduler.

Parameters:

subscriber - the Subscriber that will handle emissions and notifications from the Observable

Returns:

a Subscription reference with which Subscribers that are Observers can unsubscribe from the Observable

Throws:

java.lang.IllegalStateException - if subscribe is unable to obtain an OnSubscribe<> function

java.lang.IllegalArgumentException - if the Subscriber provided as the argument to subscribe is null

OnErrorNotImplementedException - if the Subscriber's onError method is null

java.lang.RuntimeException - if the Subscriber's onError method itself threw a Throwable

See Also:

ReactiveX operators documentation: Subscribe

subscribeOn

public final Observable<T> subscribeOn(Scheduler scheduler)

Asynchronously subscribes Observers to this Observable on the specified Scheduler.

If there is a create(Action1, rx.Emitter.BackpressureMode) type source up in the chain, it is recommended to use subscribeOn(scheduler, false) instead to avoid same-pool deadlock because requests pile up behind a eager/blocking emitter.

Backpressure:

The operator doesn't interfere with backpressure amount which is determined by the source Observable's backpressure behavior. However, the upstream is requested from the given scheduler thread.

Scheduler:

you specify which Scheduler this operator will use

Parameters:

scheduler - the Scheduler to perform subscription actions on

Returns:

the source Observable modified so that its subscriptions happen on the specified Scheduler

See Also:

ReactiveX operators documentation: SubscribeOn, RxJava Threading Examples, observeOn(rx.Scheduler), subscribeOn(Scheduler, boolean)

subscribeOn

public final Observable<T> subscribeOn(Scheduler scheduler,
                                       boolean requestOn)

Asynchronously subscribes Observers to this Observable on the specified Scheduler and optionally reroutes requests from other threads to the same Scheduler thread.

If there is a create(Action1, rx.Emitter.BackpressureMode) type source up in the chain, it is recommended to have requestOn false to avoid same-pool deadlock because requests pile up behind a eager/blocking emitter.

Backpressure:

The operator doesn't interfere with backpressure amount which is determined by the source Observable's backpressure behavior. However, the upstream is requested from the given scheduler if requestOn is true.

Scheduler:

you specify which Scheduler this operator will use

History: 1.2.7 - experimental

Parameters:

scheduler - the Scheduler to perform subscription actions on

requestOn - if true, requests are rerouted to the given Scheduler as well (strong pipelining) if false, requests coming from any thread are simply forwarded to the upstream on the same thread (weak pipelining)

Returns:

the source Observable modified so that its subscriptions happen on the specified Scheduler

Since:

1.3

See Also:

ReactiveX operators documentation: SubscribeOn, RxJava Threading Examples, observeOn(rx.Scheduler), subscribeOn(Scheduler)

switchMap

public final  Observable switchMap(Func1T,? extends Observable> func)

Returns a new Observable by applying a function that you supply to each item emitted by the source Observable that returns an Observable, and then emitting the items emitted by the most recently emitted of these Observables.

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

Backpressure:

The operator honors backpressure from downstream. The outer Observable is consumed in an unbounded manner (i.e., without backpressure) and the inner Observables are expected to honor backpressure but it is not enforced; the operator won't signal a MissingBackpressureException but the violation may lead to OutOfMemoryError due to internal buffer bloat.

Scheduler:

switchMap does not operate by default on a particular Scheduler.

Type Parameters:

R - the element type of the inner Observables and the output

Parameters:

func - a function that, when applied to an item emitted by the source Observable, returns an Observable

Returns:

an Observable that emits the items emitted by the Observable returned from applying func to the most recently emitted item emitted by the source Observable

See Also:

ReactiveX operators documentation: FlatMap

switchMapDelayError

public final  Observable switchMapDelayError(Func1T,? extends Observable> func)

Returns a new Observable by applying a function that you supply to each item emitted by the source Observable that returns an Observable, and then emitting the items emitted by the most recently emitted of these Observables and delays any error until all Observables terminate.

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

Backpressure:

The operator honors backpressure from downstream. The outer Observable is consumed in an unbounded manner (i.e., without backpressure) and the inner Observables are expected to honor backpressure but it is not enforced; the operator won't signal a MissingBackpressureException but the violation may lead to OutOfMemoryError due to internal buffer bloat.

Scheduler:

switchMap does not operate by default on a particular Scheduler.

Type Parameters:

R - the element type of the inner Observables and the output

Parameters:

func - a function that, when applied to an item emitted by the source Observable, returns an Observable

Returns:

an Observable that emits the items emitted by the Observable returned from applying func to the most recently emitted item emitted by the source Observable

Since:

1.3

See Also:

ReactiveX operators documentation: FlatMap

take

public final Observable<T> take(int count)

Returns an Observable that emits only the first count items emitted by the source Observable. If the source emits fewer than count items then all of its items are emitted.

This method returns an Observable that will invoke a subscribing Observer's onNext function a maximum of count times before invoking onCompleted.

Backpressure:

The operator doesn't interfere with backpressure which is determined by the source Observable's backpressure behavior in case the first request is smaller than the count. Otherwise, the source Observable is consumed in an unbounded manner (i.e., without applying backpressure to it).

Scheduler:

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

Parameters:

count - the maximum number of items to emit

Returns:

an Observable that emits only the first count items emitted by the source Observable, or all of the items from the source Observable if that Observable emits fewer than count items

See Also:

ReactiveX operators documentation: Take

take

public final Observable<T> take(long time,
                                java.util.concurrent.TimeUnit unit)

Returns an Observable that emits those items emitted by source Observable before a specified time runs out.

If time runs out before the Observable completes normally, the onComplete event will be signaled on the default computation Scheduler.

Backpressure:

The operator doesn't interfere with backpressure which is determined by the source Observable's backpressure behavior.

Scheduler:

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

Parameters:

time - the length of the time window

unit - the time unit of time

Returns:

an Observable that emits those items emitted by the source Observable before the time runs out

See Also:

ReactiveX operators documentation: Take

take

public final Observable<T> take(long time,
                                java.util.concurrent.TimeUnit unit,
                                Scheduler scheduler)

Returns an Observable that emits those items emitted by source Observable before a specified time (on a specified Scheduler) runs out.

If time runs out before the Observable completes normally, the onComplete event will be signaled on the provided Scheduler.

Backpressure:

The operator doesn't interfere with backpressure which is determined by the source Observable's backpressure behavior.

Scheduler:

you specify which Scheduler this operator will use

Parameters:

time - the length of the time window

unit - the time unit of time

scheduler - the Scheduler used for time source

Returns:

an Observable that emits those items emitted by the source Observable before the time runs out, according to the specified Scheduler

See Also:

ReactiveX operators documentation: Take

takeFirst

public final Observable<T> takeFirst(Func1T,java.lang.Boolean> predicate)

Returns an Observable that emits only the very first item emitted by the source Observable that satisfies a specified condition.

Backpressure:

The operator doesn't interfere with backpressure which is determined by the source Observable's backpressure behavior.

Scheduler:

takeFirst does not operate by default on a particular Scheduler.

Parameters:

predicate - the condition any item emitted by the source Observable has to satisfy

Returns:

an Observable that emits only the very first item emitted by the source Observable that satisfies the given condition, or that completes without emitting anything if the source Observable completes without emitting a single condition-satisfying item

See Also:

ReactiveX operators documentation: First

takeLast

public final Observable<T> takeLast(int count)

Returns an Observable that emits at most the last count items emitted by the source Observable. If the source emits fewer than count items then all of its items are emitted.

Backpressure:

The operator honors backpressure from downstream if the count is non-zero; ignores backpressure if the count is zero as it doesn't signal any values.

Scheduler:

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

Parameters:

count - the maximum number of items to emit from the end of the sequence of items emitted by the source Observable

Returns:

an Observable that emits at most the last count items emitted by the source Observable

Throws:

java.lang.IndexOutOfBoundsException - if count is less than zero

See Also:

ReactiveX operators documentation: TakeLast

takeLast

public final Observable<T> takeLast(int count,
                                    long time,
                                    java.util.concurrent.TimeUnit unit)

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

Backpressure:

The operator honors backpressure from downstream and consumes the source Observable in an unbounded manner (i.e., no backpressure is applied to it).

Scheduler:

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

Parameters:

count - the maximum number of items to emit

time - the length of the time window

unit - the time unit of time

Returns:

an Observable that emits at most count items from the source Observable that were emitted in a specified window of time before the Observable completed

See Also:

ReactiveX operators documentation: TakeLast

takeLast

public final Observable<T> takeLast(int count,
                                    long time,
                                    java.util.concurrent.TimeUnit unit,
                                    Scheduler scheduler)

Returns an Observable that emits at most a specified number of items from the source Observable that were emitted in a specified window of time before the Observable completed, where the timing information is provided by a given Scheduler.

Backpressure:

The operator honors backpressure from downstream and consumes the source Observable in an unbounded manner (i.e., no backpressure is applied to it).

Scheduler:

you specify which Scheduler this operator will use

Parameters:

count - the maximum number of items to emit

time - the length of the time window

unit - the time unit of time

scheduler - the Scheduler that provides the timestamps for the observed items

Returns:

an Observable that emits at most count items from the source Observable that were emitted in a specified window of time before the Observable completed, where the timing information is provided by the given scheduler

Throws:

java.lang.IndexOutOfBoundsException - if count is less than zero

See Also:

ReactiveX operators documentation: TakeLast

takeLast

public final Observable<T> takeLast(long time,
                                    java.util.concurrent.TimeUnit unit)

Returns an Observable that emits the items from the source Observable that were emitted in a specified window of time before the Observable completed.

Backpressure:

The operator honors backpressure from downstream and consumes the source Observable in an unbounded manner (i.e., no backpressure is applied to it) but note that this may lead to OutOfMemoryError due to internal buffer bloat. Consider using takeLast(int, long, TimeUnit) in this case.

behavior.

Scheduler:

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

Parameters:

time - the length of the time window

unit - the time unit of time

Returns:

an Observable that emits the items from the source Observable that were emitted in the window of time before the Observable completed specified by time

See Also:

ReactiveX operators documentation: TakeLast

takeLast

public final Observable<T> takeLast(long time,
                                    java.util.concurrent.TimeUnit unit,
                                    Scheduler scheduler)

Returns an Observable that emits the items from the source Observable that were emitted in a specified window of time before the Observable completed, where the timing information is provided by a specified Scheduler.

Backpressure:

The operator honors backpressure from downstream and consumes the source Observable in an unbounded manner (i.e., no backpressure is applied to it) but note that this may lead to OutOfMemoryError due to internal buffer bloat. Consider using takeLast(int, long, TimeUnit, Scheduler) in this case.

Scheduler:

you specify which Scheduler this operator will use

Parameters:

time - the length of the time window

unit - the time unit of time

scheduler - the Scheduler that provides the timestamps for the Observed items

Returns:

an Observable that emits the items from the source Observable that were emitted in the window of time before the Observable completed specified by time, where the timing information is provided by scheduler

See Also:

ReactiveX operators documentation: TakeLast

takeLastBuffer

public final ObservableT>> takeLastBuffer(int count)

Returns an Observable that emits a single List containing at most the last count elements emitted by the source Observable. If the source emits fewer than count items then the emitted List will contain all of the source emissions.

Backpressure:

The operator honors backpressure from downstream and consumes the source Observable in an unbounded manner (i.e., without applying backpressure to it).

Scheduler:

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

Parameters:

count - the maximum number of items to emit in the list

Returns:

an Observable that emits a single list containing at most the last count elements emitted by the source Observable

See Also:

ReactiveX operators documentation: TakeLast

takeLastBuffer

public final ObservableT>> takeLastBuffer(int count,
                                                          long time,
                                                          java.util.concurrent.TimeUnit unit)

Returns an Observable that emits a single List containing at most count items from the source Observable that were emitted during a specified window of time before the source Observable completed.

Backpressure:

The operator honors backpressure from downstream and consumes the source Observable in an unbounded manner (i.e., without applying backpressure to it).

Scheduler:

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

Parameters:

count - the maximum number of items to emit

time - the length of the time window

unit - the time unit of time

Returns:

an Observable that emits a single List containing at most count items emitted by the source Observable during the time window defined by time before the source Observable completed

See Also:

ReactiveX operators documentation: TakeLast

takeLastBuffer

public final ObservableT>> takeLastBuffer(int count,
                                                          long time,
                                                          java.util.concurrent.TimeUnit unit,
                                                          Scheduler scheduler)

Returns an Observable that emits a single List containing at most count items from the source Observable that were emitted during a specified window of time (on a specified Scheduler) before the source Observable completed.

Backpressure:

The operator honors backpressure from downstream and consumes the source Observable in an unbounded manner (i.e., without applying backpressure to it).

Scheduler:

you specify which Scheduler this operator will use

Parameters:

count - the maximum number of items to emit

time - the length of the time window

unit - the time unit of time

scheduler - the Scheduler that provides the timestamps for the observed items

Returns:

an Observable that emits a single List containing at most count items emitted by the source Observable during the time window defined by time before the source Observable completed

See Also:

ReactiveX operators documentation: TakeLast

takeLastBuffer

public final ObservableT>> takeLastBuffer(long time,
                                                          java.util.concurrent.TimeUnit unit)

Returns an Observable that emits a single List containing those items from the source Observable that were emitted during a specified window of time before the source Observable completed.

Backpressure:

The operator honors backpressure from downstream and consumes the source Observable in an unbounded manner (i.e., without applying backpressure to it).

Scheduler:

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

Parameters:

time - the length of the time window

unit - the time unit of time

Returns:

an Observable that emits a single List containing the items emitted by the source Observable during the time window defined by time before the source Observable completed

See Also:

ReactiveX operators documentation: TakeLast

takeLastBuffer

public final ObservableT>> takeLastBuffer(long time,
                                                          java.util.concurrent.TimeUnit unit,
                                                          Scheduler scheduler)

Returns an Observable that emits a single List containing those items from the source Observable that were emitted during a specified window of time before the source Observable completed, where the timing information is provided by the given Scheduler.

Backpressure:

The operator honors backpressure from downstream and consumes the source Observable in an unbounded manner (i.e., without applying backpressure to it).

Scheduler:

you specify which Scheduler this operator will use

Parameters:

time - the length of the time window

unit - the time unit of time

scheduler - the Scheduler that provides the timestamps for the observed items

Returns:

an Observable that emits a single List containing the items emitted by the source Observable during the time window defined by time before the source Observable completed, where the timing information is provided by scheduler

See Also:

ReactiveX operators documentation: TakeLast

takeUntil

public final  Observable<T> takeUntil(Observable other)

Returns an Observable that emits the items emitted by the source Observable until a second Observable emits an item.

Backpressure:

The operator doesn't interfere with backpressure which is determined by the source Observable's backpressure behavior.

Scheduler:

takeUntil does not operate by default on a particular Scheduler.

Type Parameters:

E - the type of items emitted by other

Parameters:

other - the Observable whose first emitted item will cause takeUntil to stop emitting items from the source Observable

Returns:

an Observable that emits the items emitted by the source Observable until such time as other emits its first item

See Also:

ReactiveX operators documentation: TakeUntil

takeWhile

public final Observable<T> takeWhile(Func1T,java.lang.Boolean> predicate)

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

Backpressure:

The operator doesn't interfere with backpressure which is determined by the source Observable's backpressure behavior.

Scheduler:

takeWhile does not operate by default on a particular Scheduler.

Parameters:

predicate - a function that evaluates an item emitted by the source Observable and returns a Boolean

Returns:

an Observable that emits the items from the source Observable so long as each item satisfies the condition defined by predicate, then completes

See Also:

ReactiveX operators documentation: TakeWhile, takeUntil(Func1)

takeUntil

public final Observable<T> takeUntil(Func1T,java.lang.Boolean> stopPredicate)

Returns an Observable that emits items emitted by the source Observable, checks the specified predicate for each item, and then completes when the condition is satisfied.

The difference between this operator and takeWhile(Func1) is that here, the condition is evaluated after the item is emitted.

Backpressure:

The operator is a pass-through for backpressure; the backpressure behavior is determined by the upstream source and the downstream consumer.

Scheduler:

takeWhile does not operate by default on a particular Scheduler.

Parameters:

stopPredicate - a function that evaluates an item emitted by the source Observable and returns a Boolean

Returns:

an Observable that first emits items emitted by the source Observable, checks the specified condition after each item, and then completes when the condition is satisfied.

Since:

1.1.0

See Also:

ReactiveX operators documentation: TakeUntil, takeWhile(Func1)

throttleFirst

public final Observable<T> throttleFirst(long windowDuration,
                                         java.util.concurrent.TimeUnit unit)

Returns an Observable that emits only the first item emitted by the source Observable during sequential time windows of a specified duration.

This differs from throttleLast(long, java.util.concurrent.TimeUnit) in that this only tracks passage of time whereas throttleLast(long, java.util.concurrent.TimeUnit) ticks at scheduled intervals.

Backpressure:

This operator does not support backpressure as it uses time to control data flow.

Scheduler:

throttleFirst operates by default on the computation Scheduler.

Parameters:

windowDuration - time to wait before emitting another item after emitting the last item

unit - the unit of time of windowDuration

Returns:

an Observable that performs the throttle operation

See Also:

ReactiveX operators documentation: Sample, RxJava wiki: Backpressure

throttleFirst

public final Observable<T> throttleFirst(long skipDuration,
                                         java.util.concurrent.TimeUnit unit,
                                         Scheduler scheduler)

Returns an Observable that emits only the first item emitted by the source Observable during sequential time windows of a specified duration, where the windows are managed by a specified Scheduler.

This differs from throttleLast(long, java.util.concurrent.TimeUnit) in that this only tracks passage of time whereas throttleLast(long, java.util.concurrent.TimeUnit) ticks at scheduled intervals.

Backpressure:

This operator does not support backpressure as it uses time to control data flow.

Scheduler:

you specify which Scheduler this operator will use

Parameters:

skipDuration - time to wait before emitting another item after emitting the last item

unit - the unit of time of skipDuration

scheduler - the Scheduler to use internally to manage the timers that handle timeout for each event

Returns:

an Observable that performs the throttle operation

See Also:

ReactiveX operators documentation: Sample, RxJava wiki: Backpressure

throttleLast

public final Observable<T> throttleLast(long intervalDuration,
                                        java.util.concurrent.TimeUnit unit)

Returns an Observable that emits only the last item emitted by the source Observable during sequential time windows of a specified duration.

This differs from throttleFirst(long, java.util.concurrent.TimeUnit) in that this ticks along at a scheduled interval whereas throttleFirst(long, java.util.concurrent.TimeUnit) does not tick, it just tracks passage of time.

Backpressure:

This operator does not support backpressure as it uses time to control data flow.

Scheduler:

throttleLast operates by default on the computation Scheduler.

Parameters:

intervalDuration - duration of windows within which the last item emitted by the source Observable will be emitted

unit - the unit of time of intervalDuration

Returns:

an Observable that performs the throttle operation

See Also:

ReactiveX operators documentation: Sample, RxJava wiki: Backpressure, sample(long, TimeUnit)

throttleLast

public final Observable<T> throttleLast(long intervalDuration,
                                        java.util.concurrent.TimeUnit unit,
                                        Scheduler scheduler)

Returns an Observable that emits only the last item emitted by the source Observable during sequential time windows of a specified duration, where the duration is governed by a specified Scheduler.

This differs from throttleFirst(long, java.util.concurrent.TimeUnit) in that this ticks along at a scheduled interval whereas throttleFirst(long, java.util.concurrent.TimeUnit) does not tick, it just tracks passage of time.

Backpressure:

This operator does not support backpressure as it uses time to control data flow.

Scheduler:

you specify which Scheduler this operator will use

Parameters:

intervalDuration - duration of windows within which the last item emitted by the source Observable will be emitted

unit - the unit of time of intervalDuration

scheduler - the Scheduler to use internally to manage the timers that handle timeout for each event

Returns:

an Observable that performs the throttle operation

See Also:

ReactiveX operators documentation: Sample, RxJava wiki: Backpressure, sample(long, TimeUnit, Scheduler)

throttleWithTimeout

public final Observable<T> throttleWithTimeout(long timeout,
                                               java.util.concurrent.TimeUnit unit)

Returns an Observable that only emits those items emitted by the source Observable that are not followed by another emitted item within a specified time window.

Note: If the source Observable keeps emitting items more frequently than the length of the time window then no items will be emitted by the resulting Observable.

Information on debounce vs throttle:

• Debounce and Throttle: visual explanation
• Debouncing: javascript methods
• Javascript - don't spam your server: debounce and throttle

Backpressure:

This operator does not support backpressure as it uses time to control data flow.

Scheduler:

throttleWithTimeout operates by default on the computation Scheduler.

Parameters:

timeout - the length of the window of time that must pass after the emission of an item from the source Observable in which that Observable emits no items in order for the item to be emitted by the resulting Observable

unit - the TimeUnit of timeout

Returns:

an Observable that filters out items that are too quickly followed by newer items

See Also:

ReactiveX operators documentation: Debounce, RxJava wiki: Backpressure, debounce(long, TimeUnit)

throttleWithTimeout

public final Observable<T> throttleWithTimeout(long timeout,
                                               java.util.concurrent.TimeUnit unit,
                                               Scheduler scheduler)

Returns an Observable that only emits those items emitted by the source Observable that are not followed by another emitted item within a specified time window, where the time window is governed by a specified Scheduler.

Note: If the source Observable keeps emitting items more frequently than the length of the time window then no items will be emitted by the resulting Observable.

Information on debounce vs throttle:

• Debounce and Throttle: visual explanation
• Debouncing: javascript methods
• Javascript - don't spam your server: debounce and throttle

Backpressure:

This operator does not support backpressure as it uses time to control data flow.

Scheduler:

you specify which Scheduler this operator will use

Parameters:

timeout - the length of the window of time that must pass after the emission of an item from the source Observable in which that Observable emits no items in order for the item to be emitted by the resulting Observable

unit - the TimeUnit of timeout

scheduler - the Scheduler to use internally to manage the timers that handle the timeout for each item

Returns:

an Observable that filters out items that are too quickly followed by newer items

See Also:

ReactiveX operators documentation: Debounce, RxJava wiki: Backpressure, debounce(long, TimeUnit, Scheduler)

timeInterval

public final Observable<TimeInterval<T>> timeInterval()

Returns an Observable that emits records of the time interval between consecutive items emitted by the source Observable.

Backpressure:

The operator doesn't interfere with backpressure which is determined by the source Observable's backpressure behavior.

Scheduler:

timeInterval does not operate on any particular scheduler but uses the current time from the computation Scheduler.

Returns:

an Observable that emits time interval information items

See Also:

ReactiveX operators documentation: TimeInterval

timeInterval

public final Observable<TimeInterval<T>> timeInterval(Scheduler scheduler)

Returns an Observable that emits records of the time interval between consecutive items emitted by the source Observable, where this interval is computed on a specified Scheduler.

Backpressure:

The operator doesn't interfere with backpressure which is determined by the source Observable's backpressure behavior.

Scheduler:

The operator does not operate on any particular scheduler but uses the current time from the specified Scheduler.

Parameters:

scheduler - the Scheduler used to compute time intervals

Returns:

an Observable that emits time interval information items

See Also:

ReactiveX operators documentation: TimeInterval

timeout

public final  Observable<T> timeout(Func0Observable> firstTimeoutSelector,
                                         Func1T,? extends Observable> timeoutSelector)

Returns an Observable that mirrors the source Observable, but notifies observers of a TimeoutException if either the first item emitted by the source Observable or any subsequent item doesn't arrive within time windows defined by other Observables.

Backpressure:

The operator honors backpressure from downstream. Both this and the returned Observables are expected to honor backpressure as well. If any of then violates this rule, it may throw an IllegalStateException when the Observable completes.

Scheduler:

This version of timeout operates by default on the immediate Scheduler.

Type Parameters:

U - the first timeout value type (ignored)

V - the subsequent timeout value type (ignored)

Parameters:

firstTimeoutSelector - a function that returns an Observable that determines the timeout window for the first source item

timeoutSelector - a function that returns an Observable for each item emitted by the source Observable and that determines the timeout window in which the subsequent source item must arrive in order to continue the sequence

Returns:

an Observable that mirrors the source Observable, but notifies observers of a TimeoutException if either the first item or any subsequent item doesn't arrive within the time windows specified by the timeout selectors

See Also:

ReactiveX operators documentation: Timeout

timeout

public final  Observable<T> timeout(Func0Observable> firstTimeoutSelector,
                                         Func1T,? extends Observable> timeoutSelector,
                                         ObservableT> other)

Returns an Observable that mirrors the source Observable, but switches to a fallback Observable if either the first item emitted by the source Observable or any subsequent item doesn't arrive within time windows defined by other Observables.

Backpressure:

The operator honors backpressure from downstream. The Observable sources are expected to honor backpressure as well. If any of the source Observables violate this, it may throw an IllegalStateException when the source Observable completes.

Scheduler:

This version of timeout operates by default on the immediate Scheduler.

Type Parameters:

U - the first timeout value type (ignored)

V - the subsequent timeout value type (ignored)

Parameters:

firstTimeoutSelector - a function that returns an Observable which determines the timeout window for the first source item

timeoutSelector - a function that returns an Observable for each item emitted by the source Observable and that determines the timeout window in which the subsequent source item must arrive in order to continue the sequence

other - the fallback Observable to switch to if the source Observable times out

Returns:

an Observable that mirrors the source Observable, but switches to the other Observable if either the first item emitted by the source Observable or any subsequent item doesn't arrive within time windows defined by the timeout selectors

Throws:

java.lang.NullPointerException - if timeoutSelector is null

See Also:

ReactiveX operators documentation: Timeout

timeout

public final  Observable<T> timeout(Func1T,? extends Observable> timeoutSelector)

Returns an Observable that mirrors the source Observable, but notifies observers of a TimeoutException if an item emitted by the source Observable doesn't arrive within a window of time after the emission of the previous item, where that period of time is measured by an Observable that is a function of the previous item.

Note: The arrival of the first source item is never timed out.

Backpressure:

The operator honors backpressure from downstream. The Observable sources are expected to honor backpressure as well. If any of the source Observables violate this, it may throw an IllegalStateException when the source Observable completes.

Scheduler:

This version of timeout operates by default on the immediate Scheduler.

Type Parameters:

V - the timeout value type (ignored)

Parameters:

timeoutSelector - a function that returns an observable for each item emitted by the source Observable and that determines the timeout window for the subsequent item

Returns:

an Observable that mirrors the source Observable, but notifies observers of a TimeoutException if an item emitted by the source Observable takes longer to arrive than the time window defined by the selector for the previously emitted item

See Also:

ReactiveX operators documentation: Timeout

timeout

public final  Observable<T> timeout(Func1T,? extends Observable> timeoutSelector,
                                       ObservableT> other)

Returns an Observable that mirrors the source Observable, but that switches to a fallback Observable if an item emitted by the source Observable doesn't arrive within a window of time after the emission of the previous item, where that period of time is measured by an Observable that is a function of the previous item.

Note: The arrival of the first source item is never timed out.

Backpressure:

The operator honors backpressure from downstream. The Observable sources are expected to honor backpressure as well. If any of the source Observables violate this, it may throw an IllegalStateException when the source Observable completes.

Scheduler:

This version of timeout operates by default on the immediate Scheduler.

Type Parameters:

V - the timeout value type (ignored)

Parameters:

timeoutSelector - a function that returns an Observable, for each item emitted by the source Observable, that determines the timeout window for the subsequent item

other - the fallback Observable to switch to if the source Observable times out

Returns:

an Observable that mirrors the source Observable, but switches to mirroring a fallback Observable if an item emitted by the source Observable takes longer to arrive than the time window defined by the selector for the previously emitted item

See Also:

ReactiveX operators documentation: Timeout

timeout

public final Observable<T> timeout(long timeout,
                                   java.util.concurrent.TimeUnit timeUnit)

Returns an Observable that mirrors the source Observable but applies a timeout policy for each emitted item. If the next item isn't emitted within the specified timeout duration starting from its predecessor, the resulting Observable terminates and notifies observers of a TimeoutException.

Backpressure:

The operator doesn't interfere with backpressure which is determined by the source Observable's backpressure behavior.

Scheduler:

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

Parameters:

timeout - maximum duration between emitted items before a timeout occurs

timeUnit - the unit of time that applies to the timeout argument.

Returns:

the source Observable modified to notify observers of a TimeoutException in case of a timeout

See Also:

ReactiveX operators documentation: Timeout

timeout

public final Observable<T> timeout(long timeout,
                                   java.util.concurrent.TimeUnit timeUnit,
                                   ObservableT> other)

Returns an Observable that mirrors the source Observable but applies a timeout policy for each emitted item. If the next item isn't emitted within the specified timeout duration starting from its predecessor, the resulting Observable begins instead to mirror a fallback Observable.

Backpressure:

The operator honors backpressure from downstream. The Observable sources are expected to honor backpressure as well. If any of the source Observables violate this, it may throw an IllegalStateException when the source Observable completes.

Scheduler:

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

Parameters:

timeout - maximum duration between items before a timeout occurs

timeUnit - the unit of time that applies to the timeout argument

other - the fallback Observable to use in case of a timeout

Returns:

the source Observable modified to switch to the fallback Observable in case of a timeout

See Also:

ReactiveX operators documentation: Timeout

timeout

public final Observable<T> timeout(long timeout,
                                   java.util.concurrent.TimeUnit timeUnit,
                                   ObservableT> other,
                                   Scheduler scheduler)

Returns an Observable that mirrors the source Observable but applies a timeout policy for each emitted item using a specified Scheduler. If the next item isn't emitted within the specified timeout duration starting from its predecessor, the resulting Observable begins instead to mirror a fallback Observable.

Backpressure:

The operator honors backpressure from downstream. The Observable sources are expected to honor backpressure as well. If any of the source Observables violate this, it may throw an IllegalStateException when the source Observable completes.

Scheduler:

you specify which Scheduler this operator will use

Parameters:

timeout - maximum duration between items before a timeout occurs

timeUnit - the unit of time that applies to the timeout argument

other - the Observable to use as the fallback in case of a timeout

scheduler - the Scheduler to run the timeout timers on

Returns:

the source Observable modified so that it will switch to the fallback Observable in case of a timeout

See Also:

ReactiveX operators documentation: Timeout

timeout

public final Observable<T> timeout(long timeout,
                                   java.util.concurrent.TimeUnit timeUnit,
                                   Scheduler scheduler)

Returns an Observable that mirrors the source Observable but applies a timeout policy for each emitted item, where this policy is governed on a specified Scheduler. If the next item isn't emitted within the specified timeout duration starting from its predecessor, the resulting Observable terminates and notifies observers of a TimeoutException.

Backpressure:

The operator doesn't interfere with backpressure which is determined by the source Observable's backpressure behavior.

Scheduler:

you specify which Scheduler this operator will use

Parameters:

timeout - maximum duration between items before a timeout occurs

timeUnit - the unit of time that applies to the timeout argument

scheduler - the Scheduler to run the timeout timers on

Returns:

the source Observable modified to notify observers of a TimeoutException in case of a timeout

See Also:

ReactiveX operators documentation: Timeout

timestamp

public final Observable<Timestamped<T>> timestamp()

Returns an Observable that emits each item emitted by the source Observable, wrapped in a Timestamped object.

Backpressure:

The operator doesn't interfere with backpressure which is determined by the source Observable's backpressure behavior.

Scheduler:

timestamp does not operate on any particular scheduler but uses the current time from the computation Scheduler.

Returns:

an Observable that emits timestamped items from the source Observable

See Also:

ReactiveX operators documentation: Timestamp

timestamp

public final Observable<Timestamped<T>> timestamp(Scheduler scheduler)

Returns an Observable that emits each item emitted by the source Observable, wrapped in a Timestamped object whose timestamps are provided by a specified Scheduler.

Backpressure:

The operator doesn't interfere with backpressure which is determined by the source Observable's backpressure behavior.

Scheduler:

The operator does not operate on any particular scheduler but uses the current time from the specified Scheduler.

Parameters:

scheduler - the Scheduler to use as a time source

Returns:

an Observable that emits timestamped items from the source Observable with timestamps provided by the scheduler

See Also:

ReactiveX operators documentation: Timestamp

toBlocking

public final BlockingObservable<T> toBlocking()

Converts an Observable into a BlockingObservable (an Observable with blocking operators).

Backpressure:

The operator doesn't interfere with backpressure which is determined by the source Observable's backpressure behavior.

Scheduler:

toBlocking does not operate by default on a particular Scheduler.

Returns:

a BlockingObservable version of this Observable

See Also:

ReactiveX operators documentation: To

toList

public final ObservableT>> toList()

Returns an Observable that emits a single item, a list composed of all the items emitted by the source Observable.

Normally, an Observable that returns multiple items will do so by invoking its Observer's onNext method for each such item. You can change this behavior, instructing the Observable to compose a list of all of these items and then to invoke the Observer's onNext function once, passing it the entire list, by calling the Observable's toList method prior to calling its subscribe() method.

Be careful not to use this operator on Observables that emit infinite or very large numbers of items, as you do not have the option to unsubscribe.

Backpressure:

The operator honors backpressure from downstream and consumes the source Observable in an unbounded manner (i.e., without applying backpressure to it).

Scheduler:

toList does not operate by default on a particular Scheduler.

Returns:

an Observable that emits a single item: a List containing all of the items emitted by the source Observable

See Also:

ReactiveX operators documentation: To

toMap

public final  ObservableT>> toMap(Func1T,? extends K> keySelector)

Returns an Observable that emits a single HashMap containing all items emitted by the source Observable, mapped by the keys returned by a specified keySelector function.

If more than one source item maps to the same key, the HashMap will contain the latest of those items.

Backpressure:

The operator honors backpressure from downstream and consumes the source Observable in an unbounded manner (i.e., without applying backpressure to it).

Scheduler:

toMap does not operate by default on a particular Scheduler.

Type Parameters:

K - the key type of the Map

Parameters:

keySelector - the function that extracts the key from a source item to be used in the HashMap

Returns:

an Observable that emits a single item: a HashMap containing the mapped items from the source Observable

See Also:

ReactiveX operators documentation: To

toMap

public final  Observable> toMap(Func1T,? extends K> keySelector,
                                                        Func1T,? extends V> valueSelector)

Returns an Observable that emits a single HashMap containing values corresponding to items emitted by the source Observable, mapped by the keys returned by a specified keySelector function.

If more than one source item maps to the same key, the HashMap will contain a single entry that corresponds to the latest of those items.

Backpressure:

The operator honors backpressure from downstream and consumes the source Observable in an unbounded manner (i.e., without applying backpressure to it).

Scheduler:

toMap does not operate by default on a particular Scheduler.

Type Parameters:

K - the key type of the Map

V - the value type of the Map

Parameters:

keySelector - the function that extracts the key from a source item to be used in the HashMap

valueSelector - the function that extracts the value from a source item to be used in the HashMap

Returns:

an Observable that emits a single item: a HashMap containing the mapped items from the source Observable

See Also:

ReactiveX operators documentation: To

toMap

public final  Observable> toMap(Func1T,? extends K> keySelector,
                                                        Func1T,? extends V> valueSelector,
                                                        Func0> mapFactory)

Returns an Observable that emits a single Map, returned by a specified mapFactory function, that contains keys and values extracted from the items emitted by the source Observable.

Backpressure:

The operator honors backpressure from downstream and consumes the source Observable in an unbounded manner (i.e., without applying backpressure to it).

Scheduler:

toMap does not operate by default on a particular Scheduler.

Type Parameters:

K - the key type of the Map

V - the value type of the Map

Parameters:

keySelector - the function that extracts the key from a source item to be used in the Map

valueSelector - the function that extracts the value from the source items to be used as value in the Map

mapFactory - the function that returns a Map instance to be used

Returns:

an Observable that emits a single item: a Map that contains the mapped items emitted by the source Observable

See Also:

ReactiveX operators documentation: To

toMultimap

public final  ObservableT>>> toMultimap(Func1T,? extends K> keySelector)

Returns an Observable that emits a single HashMap that contains an ArrayList of items emitted by the source Observable keyed by a specified keySelector function.

Backpressure:

This operator does not support backpressure as by intent it is requesting and buffering everything.

Scheduler:

toMultiMap does not operate by default on a particular Scheduler.

Type Parameters:

K - the key type of the Map

Parameters:

keySelector - the function that extracts the key from the source items to be used as key in the HashMap

Returns:

an Observable that emits a single item: a HashMap that contains an ArrayList of items mapped from the source Observable

See Also:

ReactiveX operators documentation: To

toMultimap

public final  Observable>> toMultimap(Func1T,? extends K> keySelector,
                                                                                   Func1T,? extends V> valueSelector)

Returns an Observable that emits a single HashMap that contains an ArrayList of values extracted by a specified valueSelector function from items emitted by the source Observable, keyed by a specified keySelector function.

Backpressure:

The operator honors backpressure from downstream and consumes the source Observable in an unbounded manner (i.e., without applying backpressure to it).

Scheduler:

toMultiMap does not operate by default on a particular Scheduler.

Type Parameters:

K - the key type of the Map

V - the value type of the Map

Parameters:

keySelector - the function that extracts a key from the source items to be used as key in the HashMap

valueSelector - the function that extracts a value from the source items to be used as value in the HashMap

Returns:

an Observable that emits a single item: a HashMap that contains an ArrayList of items mapped from the source Observable

See Also:

ReactiveX operators documentation: To

toMultimap

public final  Observable>> toMultimap(Func1T,? extends K> keySelector,
                                                                                   Func1T,? extends V> valueSelector,
                                                                                   Func0>> mapFactory)

Returns an Observable that emits a single Map, returned by a specified mapFactory function, that contains an ArrayList of values, extracted by a specified valueSelector function from items emitted by the source Observable and keyed by the keySelector function.

Backpressure:

The operator honors backpressure from downstream and consumes the source Observable in an unbounded manner (i.e., without applying backpressure to it).

Scheduler:

toMultiMap does not operate by default on a particular Scheduler.

Type Parameters:

K - the key type of the Map

V - the value type of the Map

Parameters:

keySelector - the function that extracts a key from the source items to be used as the key in the Map

valueSelector - the function that extracts a value from the source items to be used as the value in the Map

mapFactory - the function that returns a Map instance to be used

Returns:

an Observable that emits a single item: a Map that contains a list items mapped from the source Observable

See Also:

ReactiveX operators documentation: To

toMultimap

public final  Observable>> toMultimap(Func1T,? extends K> keySelector,
                                                                                   Func1T,? extends V> valueSelector,
                                                                                   Func0>> mapFactory,
                                                                                   Func1> collectionFactory)

Returns an Observable 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 Observable, and keyed by the keySelector function.

Backpressure:

The operator honors backpressure from downstream and consumes the source Observable in an unbounded manner (i.e., without applying backpressure to it).

Scheduler:

toMultiMap does not operate by default on a particular Scheduler.

Type Parameters:

K - the key type of the Map

V - the value type of the Map

Parameters:

keySelector - the function that extracts a key from the source items to be used as the key in the Map

valueSelector - the function that extracts a value from the source items to be used as the value in the Map

mapFactory - the function that returns a Map instance to be used

collectionFactory - the function that returns a Collection instance for a particular key to be used in the Map

Returns:

an Observable that emits a single item: a Map that contains the collection of mapped items from the source Observable

See Also:

ReactiveX operators documentation: To

toSortedList

public final ObservableT>> toSortedList()

Returns an Observable that emits a list that contains the items emitted by the source Observable, in a sorted order. Each item emitted by the Observable must implement Comparable with respect to all other items in the sequence.

Backpressure:

The operator honors backpressure from downstream and consumes the source Observable in an unbounded manner (i.e., without applying backpressure to it).

Scheduler:

toSortedList does not operate by default on a particular Scheduler.

Returns:

an Observable that emits a list that contains the items emitted by the source Observable in sorted order

Throws:

java.lang.ClassCastException - if any item emitted by the Observable does not implement Comparable with respect to all other items emitted by the Observable

See Also:

ReactiveX operators documentation: To

toSortedList

public final ObservableT>> toSortedList(Func2T,? super T,java.lang.Integer> sortFunction)

Returns an Observable that emits a list that contains the items emitted by the source Observable, in a sorted order based on a specified comparison function.

Backpressure:

The operator honors backpressure from downstream and consumes the source Observable in an unbounded manner (i.e., without applying backpressure to it).

Scheduler:

toSortedList does not operate by default on a particular Scheduler.

Parameters:

sortFunction - a function that compares two items emitted by the source Observable and returns an Integer that indicates their sort order

Returns:

an Observable that emits a list that contains the items emitted by the source Observable in sorted order

See Also:

ReactiveX operators documentation: To

toSortedList

public final ObservableT>> toSortedList(int initialCapacity)

Returns an Observable that emits a list that contains the items emitted by the source Observable, in a sorted order. Each item emitted by the Observable must implement Comparable with respect to all other items in the sequence.

Backpressure:

The operator honors backpressure from downstream and consumes the source Observable in an unbounded manner (i.e., without applying backpressure to it).

Scheduler:

toSortedList does not operate by default on a particular Scheduler.

Parameters:

initialCapacity - the initial capacity of the ArrayList used to accumulate items before sorting

Returns:

an Observable that emits a list that contains the items emitted by the source Observable in sorted order

Throws:

java.lang.ClassCastException - if any item emitted by the Observable does not implement Comparable with respect to all other items emitted by the Observable

Since:

1.3

See Also:

ReactiveX operators documentation: To

toSortedList

public final ObservableT>> toSortedList(Func2T,? super T,java.lang.Integer> sortFunction,
                                                        int initialCapacity)

Returns an Observable that emits a list that contains the items emitted by the source Observable, in a sorted order based on a specified comparison function.

Backpressure:

The operator honors backpressure from downstream and consumes the source Observable in an unbounded manner (i.e., without applying backpressure to it).

Scheduler:

toSortedList does not operate by default on a particular Scheduler.

Parameters:

sortFunction - a function that compares two items emitted by the source Observable and returns an Integer that indicates their sort order

initialCapacity - the initial capacity of the ArrayList used to accumulate items before sorting

Returns:

an Observable that emits a list that contains the items emitted by the source Observable in sorted order

Since:

1.3

See Also:

ReactiveX operators documentation: To

sorted

public final Observable<T> sorted()

Returns an Observable that emits the events emitted by source Observable, in a sorted order. Each item emitted by the Observable must implement Comparable with respect to all other items in the sequence.

Note that calling sorted with long, non-terminating or infinite sources might cause OutOfMemoryError

Backpressure:

The operator honors backpressure from downstream and consumes the source Observable in an unbounded manner (i.e., without applying backpressure to it).

Scheduler:

sorted does not operate by default on a particular Scheduler.

Returns:

an Observable that emits the items emitted by the source Observable in sorted order

Throws:

java.lang.ClassCastException - if any item emitted by the Observable does not implement Comparable with respect to all other items emitted by the Observable

Since:

1.3

sorted

public final Observable<T> sorted(Func2T,? super T,java.lang.Integer> sortFunction)

Returns an Observable that emits the events emitted by source Observable, in a sorted order based on a specified comparison function.

Note that calling sorted with long, non-terminating or infinite sources might cause OutOfMemoryError

Backpressure:

The operator honors backpressure from downstream and consumes the source Observable in an unbounded manner (i.e., without applying backpressure to it).

Scheduler:

sorted does not operate by default on a particular Scheduler.

Parameters:

sortFunction - a function that compares two items emitted by the source Observable and returns an Integer that indicates their sort order

Returns:

an Observable that emits the items emitted by the source Observable in sorted order

Since:

1.3

unsubscribeOn

public final Observable<T> unsubscribeOn(Scheduler scheduler)

Modifies the source Observable so that subscribers will unsubscribe from it on a specified Scheduler.

Backpressure:

The operator doesn't interfere with backpressure which is determined by the source Observable's backpressure behavior.

Scheduler:

you specify which Scheduler this operator will use

Parameters:

scheduler - the Scheduler to perform unsubscription actions on

Returns:

the source Observable modified so that its unsubscriptions happen on the specified Scheduler

See Also:

ReactiveX operators documentation: SubscribeOn

withLatestFrom

public final  Observable withLatestFrom(Observable other,
                                                Func2T,? super U,? extends R> resultSelector)

Merges the specified Observable into this Observable sequence by using the resultSelector function only when the source Observable (this instance) emits an item.

Backpressure:

The operator is a pass-through for backpressure: the backpressure support depends on the upstream and downstream's backpressure behavior. The other Observable is consumed in an unbounded fashion.

Scheduler:

This operator, by default, doesn't run any particular Scheduler.

Type Parameters:

U - the element type of the other Observable

R - the result type of the combination

Parameters:

other - the other Observable

resultSelector - the function to call when this Observable emits an item and the other Observable has already emitted an item, to generate the item to be emitted by the resulting Observable

Returns:

an Observable that merges the specified Observable into this Observable by using the resultSelector function only when the source Observable sequence (this instance) emits an item

Since:

1.3

See Also:

ReactiveX operators documentation: CombineLatest

withLatestFrom

public final  Observable withLatestFrom(Observable o1,
                                                    Observable o2,
                                                    Func3T,? super T1,? super T2,R> combiner)

Combines the value emission from this Observable with the latest emissions from the other Observables via a function to produce the output item.

Note that this operator doesn't emit anything until all other sources have produced at least one value. The resulting emission only happens when this Observable emits (and not when any of the other sources emit, unlike combineLatest). If a source doesn't produce any value and just completes, the sequence is completed immediately.

Backpressure:

This operator is a pass-through for backpressure behavior between the source Observable and the downstream Subscriber. The other Observables are consumed in an unbounded manner.

Scheduler:

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

Type Parameters:

T1 - the first other source's value type

T2 - the second other source's value type

R - the result value type

Parameters:

o1 - the first other Observable

o2 - the second other Observable

combiner - the function called with an array of values from each participating observable

Returns:

the new Observable instance

Since:

1.3

withLatestFrom

public final  Observable withLatestFrom(Observable o1,
                                                       Observable o2,
                                                       Observable o3,
                                                       Func4T,? super T1,? super T2,? super T3,R> combiner)

Combines the value emission from this Observable with the latest emissions from the other Observables via a function to produce the output item.

Note that this operator doesn't emit anything until all other sources have produced at least one value. The resulting emission only happens when this Observable emits (and not when any of the other sources emit, unlike combineLatest). If a source doesn't produce any value and just completes, the sequence is completed immediately.

Backpressure:

This operator is a pass-through for backpressure behavior between the source Observable and the downstream Subscriber. The other Observables are consumed in an unbounded manner.

Scheduler:

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

Type Parameters:

T1 - the first other source's value type

T2 - the second other source's value type

T3 - the third other source's value type

R - the result value type

Parameters:

o1 - the first other Observable

o2 - the second other Observable

o3 - the third other Observable

combiner - the function called with an array of values from each participating observable

Returns:

the new Observable instance

Since:

1.3

withLatestFrom

public final  Observable withLatestFrom(Observable o1,
                                                          Observable o2,
                                                          Observable o3,
                                                          Observable o4,
                                                          Func5T,? super T1,? super T2,? super T3,? super T4,R> combiner)

Combines the value emission from this Observable with the latest emissions from the other Observables via a function to produce the output item.

Note that this operator doesn't emit anything until all other sources have produced at least one value. The resulting emission only happens when this Observable emits (and not when any of the other sources emit, unlike combineLatest). If a source doesn't produce any value and just completes, the sequence is completed immediately.

Backpressure:

This operator is a pass-through for backpressure behavior between the source Observable and the downstream Subscriber. The other Observables are consumed in an unbounded manner.

Scheduler:

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

Type Parameters:

T1 - the first other source's value type

T2 - the second other source's value type

T3 - the third other source's value type

T4 - the fourth other source's value type

R - the result value type

Parameters:

o1 - the first other Observable

o2 - the second other Observable

o3 - the third other Observable

o4 - the fourth other Observable

combiner - the function called with an array of values from each participating observable

Returns:

the new Observable instance

Since:

1.3

withLatestFrom

public final  Observable withLatestFrom(Observable o1,
                                                             Observable o2,
                                                             Observable o3,
                                                             Observable o4,
                                                             Observable o5,
                                                             Func6T,? super T1,? super T2,? super T3,? super T4,? super T5,R> combiner)

Combines the value emission from this Observable with the latest emissions from the other Observables via a function to produce the output item.

Note that this operator doesn't emit anything until all other sources have produced at least one value. The resulting emission only happens when this Observable emits (and not when any of the other sources emit, unlike combineLatest). If a source doesn't produce any value and just completes, the sequence is completed immediately.

Backpressure:

This operator is a pass-through for backpressure behavior between the source Observable and the downstream Subscriber. The other Observables are consumed in an unbounded manner.

Scheduler:

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

Type Parameters:

T1 - the first other source's value type

T2 - the second other source's value type

T3 - the third other source's value type

T4 - the fourth other source's value type

T5 - the fifth other source's value type

R - the result value type

Parameters:

o1 - the first other Observable

o2 - the second other Observable

o3 - the third other Observable

o4 - the fourth other Observable

o5 - the fifth other Observable

combiner - the function called with an array of values from each participating observable

Returns:

the new Observable instance

Since:

1.3

withLatestFrom

public final  Observable withLatestFrom(Observable o1,
                                                                Observable o2,
                                                                Observable o3,
                                                                Observable o4,
                                                                Observable o5,
                                                                Observable o6,
                                                                Func7T,? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,R> combiner)

Combines the value emission from this Observable with the latest emissions from the other Observables via a function to produce the output item.

Note that this operator doesn't emit anything until all other sources have produced at least one value. The resulting emission only happens when this Observable emits (and not when any of the other sources emit, unlike combineLatest). If a source doesn't produce any value and just completes, the sequence is completed immediately.

Backpressure:

This operator is a pass-through for backpressure behavior between the source Observable and the downstream Subscriber. The other Observables are consumed in an unbounded manner.

Scheduler:

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

Type Parameters:

T1 - the first other source's value type

T2 - the second other source's value type

T3 - the third other source's value type

T4 - the fourth other source's value type

T5 - the fifth other source's value type

T6 - the sixth other source's value type

R - the result value type

Parameters:

o1 - the first other Observable

o2 - the second other Observable

o3 - the third other Observable

o4 - the fourth other Observable

o5 - the fifth other Observable

o6 - the sixth other Observable

combiner - the function called with an array of values from each participating observable

Returns:

the new Observable instance

Since:

1.3

withLatestFrom

public final  Observable withLatestFrom(Observable o1,
                                                                   Observable o2,
                                                                   Observable o3,
                                                                   Observable o4,
                                                                   Observable o5,
                                                                   Observable o6,
                                                                   Observable o7,
                                                                   Func8T,? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,R> combiner)

Combines the value emission from this Observable with the latest emissions from the other Observables via a function to produce the output item.

Note that this operator doesn't emit anything until all other sources have produced at least one value. The resulting emission only happens when this Observable emits (and not when any of the other sources emit, unlike combineLatest). If a source doesn't produce any value and just completes, the sequence is completed immediately.

Backpressure:

This operator is a pass-through for backpressure behavior between the source Observable and the downstream Subscriber. The other Observables are consumed in an unbounded manner.

Scheduler:

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

Type Parameters:

T1 - the first other source's value type

T2 - the second other source's value type

T3 - the third other source's value type

T4 - the fourth other source's value type

T5 - the fifth other source's value type

T6 - the sixth other source's value type

T7 - the seventh other source's value type

R - the result value type

Parameters:

o1 - the first other Observable

o2 - the second other Observable

o3 - the third other Observable

o4 - the fourth other Observable

o5 - the fifth other Observable

o6 - the sixth other Observable

o7 - the seventh other Observable

combiner - the function called with an array of values from each participating observable

Returns:

the new Observable instance

Since:

1.3

withLatestFrom

public final  Observable withLatestFrom(Observable o1,
                                                                      Observable o2,
                                                                      Observable o3,
                                                                      Observable o4,
                                                                      Observable o5,
                                                                      Observable o6,
                                                                      Observable o7,
                                                                      Observable o8,
                                                                      Func9T,? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,R> combiner)

Combines the value emission from this Observable with the latest emissions from the other Observables via a function to produce the output item.

Note that this operator doesn't emit anything until all other sources have produced at least one value. The resulting emission only happens when this Observable emits (and not when any of the other sources emit, unlike combineLatest). If a source doesn't produce any value and just completes, the sequence is completed immediately.

Backpressure:

This operator is a pass-through for backpressure behavior between the source Observable and the downstream Subscriber. The other Observables are consumed in an unbounded manner.

Scheduler:

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

Type Parameters:

T1 - the first other source's value type

T2 - the second other source's value type

T3 - the third other source's value type

T4 - the fourth other source's value type

T5 - the fifth other source's value type

T6 - the sixth other source's value type

T7 - the seventh other source's value type

T8 - the eighth other source's value type

R - the result value type

Parameters:

o1 - the first other Observable

o2 - the second other Observable

o3 - the third other Observable

o4 - the fourth other Observable

o5 - the fifth other Observable

o6 - the sixth other Observable

o7 - the seventh other Observable

o8 - the eighth other Observable

combiner - the function called with an array of values from each participating observable

Returns:

the new Observable instance

Since:

1.3

withLatestFrom

public final  Observable withLatestFrom(Observable[] others,
                                              FuncN combiner)

Combines the value emission from this Observable with the latest emissions from the other Observables via a function to produce the output item.

Note that this operator doesn't emit anything until all other sources have produced at least one value. The resulting emission only happens when this Observable emits (and not when any of the other sources emit, unlike combineLatest). If a source doesn't produce any value and just completes, the sequence is completed immediately.

Backpressure:

This operator is a pass-through for backpressure behavior between the source Observable and the downstream Subscriber. The other Observables are consumed in an unbounded manner.

Scheduler:

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

Type Parameters:

R - the result value type

Parameters:

others - the array of other sources

combiner - the function called with an array of values from each participating observable

Returns:

the new Observable instance

Since:

1.3

withLatestFrom

public final  Observable withLatestFrom(java.lang.Iterable<Observable> others,
                                              FuncN combiner)

Combines the value emission from this Observable with the latest emissions from the other Observables via a function to produce the output item.

Note that this operator doesn't emit anything until all other sources have produced at least one value. The resulting emission only happens when this Observable emits (and not when any of the other sources emit, unlike combineLatest). If a source doesn't produce any value and just completes, the sequence is completed immediately.

Backpressure:

This operator is a pass-through for backpressure behavior between the source Observable and the downstream Subscriber. The other Observables are consumed in an unbounded manner.

Scheduler:

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

Type Parameters:

R - the result value type

Parameters:

others - the iterable of other sources

combiner - the function called with an array of values from each participating observable

Returns:

the new Observable instance

Since:

1.3

window

public final  Observable<Observable<T>> window(Func0Observable> closingSelector)

Returns an Observable that emits windows of items it collects from the source Observable. The resulting Observable emits connected, non-overlapping windows. It emits the current window and opens a new one whenever the Observable produced by the specified closingSelector emits an item.

Backpressure:

The operator consumes the source Observable in an unbounded manner. The returned Observable doesn't support backpressure as it uses the closingSelector to control the creation of windows. The returned inner Observables honor backpressure but have an unbounded inner buffer that may lead to OutOfMemoryError if left unconsumed.

Scheduler:

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

Type Parameters:

TClosing - the element type of the boundary Observable

Parameters:

closingSelector - a Func0 that returns an Observable that governs the boundary between windows. When the source Observable emits an item, window emits the current window and begins a new one.

Returns:

an Observable that emits connected, non-overlapping windows of items from the source Observable whenever closingSelector emits an item

See Also:

ReactiveX operators documentation: Window

window

public final Observable<Observable<T>> window(int count)

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

Backpressure:

The operator honors backpressure of its inner and outer subscribers, however, the inner Observable uses an unbounded buffer that may hold at most count elements.

Scheduler:

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

Parameters:

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

Returns:

an Observable that emits connected, non-overlapping windows, each containing at most count items from the source Observable

Throws:

java.lang.IllegalArgumentException - if either count is non-positive

See Also:

ReactiveX operators documentation: Window

window

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

Returns an Observable that emits windows of items it collects from the source Observable. The resulting Observable emits windows every skip items, each containing no more than count items. When the source Observable completes or encounters an error, the resulting Observable emits the current window and propagates the notification from the source Observable.

Backpressure:

The operator honors backpressure of its inner and outer subscribers, however, the inner Observable uses an unbounded buffer that may hold at most count elements.

Scheduler:

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

Parameters:

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

skip - how many items need to be skipped before starting a new window. Note that if skip and count are equal this is the same operation as window(int).

Returns:

an Observable that emits windows every skip items containing at most count items from the source Observable

Throws:

java.lang.IllegalArgumentException - if either count or skip is non-positive

See Also:

ReactiveX operators documentation: Window

window

public final Observable<Observable<T>> window(long timespan,
                                              long timeshift,
                                              java.util.concurrent.TimeUnit unit)

Returns an Observable that emits windows of items it collects from the source Observable. The resulting Observable starts a new window periodically, as determined by the timeshift argument. It emits each window after a fixed timespan, specified by the timespan argument. When the source Observable completes or Observable completes or encounters an error, the resulting Observable emits the current window and propagates the notification from the source Observable.

Backpressure:

The operator consumes the source Observable in an unbounded manner. The returned Observable doesn't support backpressure as it uses time to control the creation of windows. The returned inner Observables honor backpressure but have an unbounded inner buffer that may lead to OutOfMemoryError if left unconsumed.

Scheduler:

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

Parameters:

timespan - the period of time each window collects items before it should be emitted

timeshift - the period of time after which a new window will be created

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

Returns:

an Observable that emits new windows periodically as a fixed timespan elapses

See Also:

ReactiveX operators documentation: Window

window

public final Observable<Observable<T>> window(long timespan,
                                              long timeshift,
                                              java.util.concurrent.TimeUnit unit,
                                              Scheduler scheduler)

Returns an Observable that emits windows of items it collects from the source Observable. The resulting Observable starts a new window periodically, as determined by the timeshift argument. It emits each window after a fixed timespan, specified by the timespan argument. When the source Observable completes or Observable completes or encounters an error, the resulting Observable emits the current window and propagates the notification from the source Observable.

Backpressure:

The operator consumes the source Observable in an unbounded manner. The returned Observable doesn't support backpressure as it uses time to control the creation of windows. The returned inner Observables honor backpressure but have an unbounded inner buffer that may lead to OutOfMemoryError if left unconsumed.

Scheduler:

you specify which Scheduler this operator will use

Parameters:

timespan - the period of time each window collects items before it should be emitted

timeshift - the period of time after which a new window will be created

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

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

Returns:

an Observable that emits new windows periodically as a fixed timespan elapses

See Also:

ReactiveX operators documentation: Window

window

public final Observable<Observable<T>> window(long timespan,
                                              long timeshift,
                                              java.util.concurrent.TimeUnit unit,
                                              int count,
                                              Scheduler scheduler)

Returns an Observable that emits windows of items it collects from the source Observable. The resulting Observable starts a new window periodically, as determined by the timeshift argument or a maximum size as specified by the count argument (whichever is reached first). It emits each window after a fixed timespan, specified by the timespan argument. When the source Observable completes or Observable completes or encounters an error, the resulting Observable emits the current window and propagates the notification from the source Observable.

Backpressure:

The operator consumes the source Observable in an unbounded manner. The returned Observable doesn't support backpressure as it uses time to control the creation of windows. The returned inner Observables honor backpressure and may hold up to count elements at most.

Scheduler:

you specify which Scheduler this operator will use

Parameters:

timespan - the period of time each window collects items before it should be emitted

timeshift - the period of time after which a new window will be created

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

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

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

Returns:

an Observable that emits new windows periodically as a fixed timespan elapses

See Also:

ReactiveX operators documentation: Window

window

public final Observable<Observable<T>> window(long timespan,
                                              java.util.concurrent.TimeUnit unit)

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

Backpressure:

The operator consumes the source Observable in an unbounded manner. The returned Observable doesn't support backpressure as it uses time to control the creation of windows. The returned inner Observables honor backpressure and may hold up to count elements at most.

Scheduler:

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

Parameters:

timespan - the period of time each window collects items before it should be emitted and replaced with a new window

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

Returns:

an Observable that emits connected, non-overlapping windows representing items emitted by the source Observable during fixed, consecutive durations

See Also:

ReactiveX operators documentation: Window

window

public final Observable<Observable<T>> window(long timespan,
                                              java.util.concurrent.TimeUnit unit,
                                              int count)

Returns an Observable that emits windows of items it collects from the source Observable. The resulting Observable emits connected, non-overlapping windows, each of a fixed duration as specified by the timespan argument or a maximum size as specified by the count argument (whichever is reached first). When the source Observable completes or encounters an error, the resulting Observable emits the current window and propagates the notification from the source Observable.

Backpressure:

The operator consumes the source Observable in an unbounded manner. The returned Observable doesn't support backpressure as it uses time to control the creation of windows. The returned inner Observables honor backpressure and may hold up to count elements at most.

Scheduler:

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

Parameters:

timespan - the period of time each window collects items before it should be emitted and replaced with a new window

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

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

Returns:

an Observable that emits connected, non-overlapping windows of items from the source Observable that were emitted during a fixed duration of time or when the window has reached maximum capacity (whichever occurs first)

See Also:

ReactiveX operators documentation: Window

window

public final Observable<Observable<T>> window(long timespan,
                                              java.util.concurrent.TimeUnit unit,
                                              int count,
                                              Scheduler scheduler)

Returns an Observable that emits windows of items it collects from the source Observable. The resulting Observable emits connected, non-overlapping windows, each of a fixed duration specified by the timespan argument or a maximum size specified by the count argument (whichever is reached first). When the source Observable completes or encounters an error, the resulting Observable emits the current window and propagates the notification from the source Observable.

Backpressure:

The operator consumes the source Observable in an unbounded manner. The returned Observable doesn't support backpressure as it uses time to control the creation of windows. The returned inner Observables honor backpressure and may hold up to count elements at most.

Scheduler:

you specify which Scheduler this operator will use

Parameters:

timespan - the period of time each window collects items before it should be emitted and replaced with a new window

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

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

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

Returns:

an Observable that emits connected, non-overlapping windows of items from the source Observable that were emitted during a fixed duration of time or when the window has reached maximum capacity (whichever occurs first)

See Also:

ReactiveX operators documentation: Window

window

public final Observable<Observable<T>> window(long timespan,
                                              java.util.concurrent.TimeUnit unit,
                                              Scheduler scheduler)

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

Backpressure:

The operator consumes the source Observable in an unbounded manner. The returned Observable doesn't support backpressure as it uses time to control the creation of windows. The returned inner Observables honor backpressure but have an unbounded inner buffer that may lead to OutOfMemoryError if left unconsumed.

Scheduler:

you specify which Scheduler this operator will use

Parameters:

timespan - the period of time each window collects items before it should be emitted and replaced with a new window

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

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

Returns:

an Observable that emits connected, non-overlapping windows containing items emitted by the source Observable within a fixed duration

See Also:

ReactiveX operators documentation: Window

window

public final  Observable<Observable<T>> window(Observable windowOpenings,
                                                                  Func1Observable> closingSelector)

Returns an Observable that emits windows of items it collects from the source Observable. The resulting Observable emits windows that contain those items emitted by the source Observable between the time when the windowOpenings Observable emits an item and when the Observable returned by closingSelector emits an item.

Backpressure:

The outer Observable of this operator doesn't support backpressure because the emission of new inner Observables are controlled by the windowOpenings Observable. The inner Observables honor backpressure and buffer everything until the associated closing Observable signals or completes.

Scheduler:

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

Type Parameters:

TOpening - the element type of the window-opening Observable

TClosing - the element type of the window-closing Observables

Parameters:

windowOpenings - an Observable that, when it emits an item, causes another window to be created

closingSelector - a Func1 that produces an Observable for every window created. When this Observable emits an item, the associated window is closed and emitted

Returns:

an Observable that emits windows of items emitted by the source Observable that are governed by the specified window-governing Observables

See Also:

ReactiveX operators documentation: Window

window

public final  Observable<Observable<T>> window(Observable boundary)

Returns an Observable that emits non-overlapping windows of items it collects from the source Observable where the boundary of each window is determined by the items emitted from a specified boundary-governing Observable.

Backpressure:

The outer Observable of this operator does not support backpressure as it uses a boundary Observable to control data flow. The inner Observables honor backpressure and buffer everything until the boundary signals the next element.

Scheduler:

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

Type Parameters:

U - the window element type (ignored)

Parameters:

boundary - an Observable whose emitted items close and open windows

Returns:

an Observable that emits non-overlapping windows of items it collects from the source Observable where the boundary of each window is determined by the items emitted from the boundary Observable

See Also:

ReactiveX operators documentation: Window

zipWith

public final  Observable zipWith(java.lang.Iterable other,
                                          Func2T,? super T2,? extends R> zipFunction)

Returns an Observable that emits items that are the result of applying a specified function to pairs of values, one each from the source Observable and a specified Iterable sequence.

Note that the other Iterable is evaluated as items are observed from the source Observable; it is not pre-consumed. This allows you to zip infinite streams on either side.

Backpressure:

The operator expects backpressure from the sources and honors backpressure from the downstream. (I.e., zipping with interval(long, TimeUnit) may result in MissingBackpressureException, use one of the onBackpressureX to handle similar, backpressure-ignoring sources.

Scheduler:

zipWith does not operate by default on a particular Scheduler.

Type Parameters:

T2 - the type of items in the other Iterable

R - the type of items emitted by the resulting Observable

Parameters:

other - the Iterable sequence

zipFunction - a function that combines the pairs of items from the Observable and the Iterable to generate the items to be emitted by the resulting Observable

Returns:

an Observable that pairs up values from the source Observable and the other Iterable sequence and emits the results of zipFunction applied to these pairs

See Also:

ReactiveX operators documentation: Zip

zipWith

public final  Observable zipWith(Observable other,
                                          Func2T,? super T2,? extends R> zipFunction)

Returns an Observable that emits items that are the result of applying a specified function to pairs of values, one each from the source Observable and another specified Observable.

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 unsubscribing the other sources. Therefore, it is possible those other sources will never be able to run to completion (and thus not calling doOnCompleted()). 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 unsubscribe B immediately. For example:

range(1, 5).doOnCompleted(action1).zipWith(range(6, 5).doOnCompleted(action2), (a, b) -> a + b)

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

Backpressure:

The operator expects backpressure from the sources and honors backpressure from the downstream. (I.e., zipping with interval(long, TimeUnit) may result in MissingBackpressureException, use one of the onBackpressureX to handle similar, backpressure-ignoring sources.

Scheduler:

zipWith does not operate by default on a particular Scheduler.

Type Parameters:

T2 - the type of items emitted by the other Observable

R - the type of items emitted by the resulting Observable

Parameters:

other - the other Observable

zipFunction - a function that combines the pairs of items from the two Observables to generate the items to be emitted by the resulting Observable

Returns:

an Observable that pairs up values from the source Observable and the other Observable and emits the results of zipFunction applied to these pairs

See Also:

ReactiveX operators documentation: Zip

test

public final AssertableSubscriber<T> test()

Creates a AssertableSubscriber that requests Long.MAX_VALUE and subscribes it to this Observable.

Backpressure:

The returned AssertableSubscriber consumes this Observable in an unbounded fashion.

Scheduler:

test does not operate by default on a particular Scheduler.

History: 1.2.3 - experimental

Returns:

the new AssertableSubscriber instance

Since:

1.3

test

public final AssertableSubscriber<T> test(long initialRequestAmount)

Creates an AssertableSubscriber with the initial request amount and subscribes it to this Observable.

Backpressure:

The returned AssertableSubscriber requests the given initialRequest amount upfront.

Scheduler:

test does not operate by default on a particular Scheduler.

History: 1.2.3 - experimental

Parameters:

initialRequestAmount - the amount to request from upstream upfront, non-negative (not verified)

Returns:

the new AssertableSubscriber instance

Since:

1.3