Movatterモバイル変換

Type Parameters:

T - the type of the items emitted by the Observable

All Implemented Interfaces:

ObservableSource<T>

Direct Known Subclasses:

ConnectableObservable,GroupedObservable,Subject

public abstract classObservable<T>extendsObjectimplementsObservableSource<T>

      onSubscribe onNext* (onError | onComplete)?

 Disposable d = Observable.just("Hello world!")     .delay(1, TimeUnit.SECONDS)     .subscribeWith(new DisposableObserver<String>() {         @Override public void onStart() {             System.out.println("Start!");         }         @Override public void onNext(String t) {             System.out.println(t);         }         @Override public void onError(Throwable t) {             t.printStackTrace();         }         @Override public void onComplete() {             System.out.println("Done!");         }     }); Thread.sleep(500); // the sequence can now be disposed via dispose() d.dispose();

See Also:

Flowable,DisposableObserver

• Constructor Summary

  Constructors 

  Constructor and Description
  Observable()

• Method Summary

  All Methods Static Methods Instance Methods Abstract Methods Concrete Methods Deprecated Methods 

  Modifier and Type	Method and Description
  Single<Boolean>	all(Predicate<? superT> predicate) Returns a Single that emits a Boolean that indicates whether all of the items emitted by the source ObservableSource satisfy a condition.
  static <T> Observable<T>	amb(Iterable<? extendsObservableSource<? extends T>> sources) Mirrors the one ObservableSource in an Iterable of several ObservableSources that first either emits an item or sends a termination notification.
  static <T> Observable<T>	ambArray(ObservableSource<? extends T>... sources) Mirrors the one ObservableSource in an array of several ObservableSources that first either emits an item or sends a termination notification.
  Observable<T>	ambWith(ObservableSource<? extendsT> other) Mirrors the ObservableSource (current or provided) that first either emits an item or sends a termination notification.
  Single<Boolean>	any(Predicate<? superT> predicate) Returns a Single that emitstrue if any item emitted by the source ObservableSource satisfies a specified condition, otherwisefalse.
  <R> R	as(ObservableConverter<T,? extends R> converter) Calls the specified converter function during assembly time and returns its resulting value.
  T	blockingFirst() Returns the first item emitted by thisObservable, or throwsNoSuchElementException if it emits no items.
  T	blockingFirst(T defaultItem) Returns the first item emitted by thisObservable, or a default value if it emits no items.
  void	blockingForEach(Consumer<? superT> onNext) Consumes the upstreamObservable in a blocking fashion and invokes the givenConsumer with each upstream item on thecurrent thread until the upstream terminates.
  Iterable<T>	blockingIterable() Converts thisObservable into anIterable.
  Iterable<T>	blockingIterable(int bufferSize) Converts thisObservable into anIterable.
  T	blockingLast() Returns the last item emitted by thisObservable, or throwsNoSuchElementException if thisObservable emits no items.
  T	blockingLast(T defaultItem) Returns the last item emitted by thisObservable, or a default value if it emits no items.
  Iterable<T>	blockingLatest() Returns anIterable that returns the latest item emitted by thisObservable, waiting if necessary for one to become available.
  Iterable<T>	blockingMostRecent(T initialValue) Returns anIterable that always returns the item most recently emitted by thisObservable.
  Iterable<T>	blockingNext() Returns anIterable that blocks until thisObservable emits another item, then returns that item.
  T	blockingSingle() If thisObservable completes after emitting a single item, return that item, otherwise throw aNoSuchElementException.
  T	blockingSingle(T defaultItem) If thisObservable completes after emitting a single item, return that item; if it emits more than one item, throw anIllegalArgumentException; if it emits no items, return a default value.
  void	blockingSubscribe() Runs the source observable to a terminal event, ignoring any values and rethrowing any exception.
  void	blockingSubscribe(Consumer<? superT> onNext) Subscribes to the source and calls the given callbackson the current thread.
  void	blockingSubscribe(Consumer<? superT> onNext,Consumer<? superThrowable> onError) Subscribes to the source and calls the given callbackson the current thread.
  void	blockingSubscribe(Consumer<? superT> onNext,Consumer<? superThrowable> onError,Action onComplete) Subscribes to the source and calls the given callbackson the current thread.
  void	blockingSubscribe(Observer<? superT> observer) Subscribes to the source and calls theObserver methodson the current thread.
  <B> Observable<List<T>>	buffer(Callable<? extendsObservableSource<B>> boundarySupplier) Returns an Observable that emits buffers of items it collects from the source ObservableSource.
  <B,U extendsCollection<? superT>> Observable<U>	buffer(Callable<? extendsObservableSource<B>> boundarySupplier,Callable<U> bufferSupplier) Returns an Observable that emits buffers of items it collects from the source ObservableSource.
  Observable<List<T>>	buffer(int count) Returns an Observable that emits buffers of items it collects from the source ObservableSource.
  <U extendsCollection<? superT>> Observable<U>	buffer(int count,Callable<U> bufferSupplier) Returns an Observable that emits buffers of items it collects from the source ObservableSource.
  Observable<List<T>>	buffer(int count, int skip) Returns an Observable that emits buffers of items it collects from the source ObservableSource.
  <U extendsCollection<? superT>> Observable<U>	buffer(int count, int skip,Callable<U> bufferSupplier) Returns an Observable that emits buffers of items it collects from the source ObservableSource.
  Observable<List<T>>	buffer(long timespan, long timeskip,TimeUnit unit) Returns an Observable that emits buffers of items it collects from the source ObservableSource.
  Observable<List<T>>	buffer(long timespan, long timeskip,TimeUnit unit,Scheduler scheduler) Returns an Observable that emits buffers of items it collects from the source ObservableSource.
  <U extendsCollection<? superT>> Observable<U>	buffer(long timespan, long timeskip,TimeUnit unit,Scheduler scheduler,Callable<U> bufferSupplier) Returns an Observable that emits buffers of items it collects from the source ObservableSource.
  Observable<List<T>>	buffer(long timespan,TimeUnit unit) Returns an Observable that emits buffers of items it collects from the source ObservableSource.
  Observable<List<T>>	buffer(long timespan,TimeUnit unit, int count) Returns an Observable that emits buffers of items it collects from the source ObservableSource.
  Observable<List<T>>	buffer(long timespan,TimeUnit unit,Scheduler scheduler) Returns an Observable that emits buffers of items it collects from the source ObservableSource.
  Observable<List<T>>	buffer(long timespan,TimeUnit unit,Scheduler scheduler, int count) Returns an Observable that emits buffers of items it collects from the source ObservableSource.
  <U extendsCollection<? superT>> Observable<U>	buffer(long timespan,TimeUnit unit,Scheduler scheduler, int count,Callable<U> bufferSupplier, boolean restartTimerOnMaxSize) Returns an Observable that emits buffers of items it collects from the source ObservableSource.
  <TOpening,TClosing> Observable<List<T>>	buffer(ObservableSource<? extends TOpening> openingIndicator,Function<? super TOpening,? extendsObservableSource<? extends TClosing>> closingIndicator) Returns an Observable that emits buffers of items it collects from the source ObservableSource.
  <TOpening,TClosing,U extendsCollection<? superT>> Observable<U>	buffer(ObservableSource<? extends TOpening> openingIndicator,Function<? super TOpening,? extendsObservableSource<? extends TClosing>> closingIndicator,Callable<U> bufferSupplier) Returns an Observable that emits buffers of items it collects from the source ObservableSource.
  <B> Observable<List<T>>	buffer(ObservableSource<B> boundary) Returns an Observable that emits non-overlapping buffered items from the source ObservableSource each time the specified boundary ObservableSource emits an item.
  <B,U extendsCollection<? superT>> Observable<U>	buffer(ObservableSource<B> boundary,Callable<U> bufferSupplier) Returns an Observable that emits non-overlapping buffered items from the source ObservableSource each time the specified boundary ObservableSource emits an item.
  <B> Observable<List<T>>	buffer(ObservableSource<B> boundary, int initialCapacity) Returns an Observable that emits non-overlapping buffered items from the source ObservableSource each time the specified boundary ObservableSource emits an item.
  static int	bufferSize() Returns the default 'island' size or capacity-increment hint for unbounded buffers.
  Observable<T>	cache() Returns an Observable that subscribes to this ObservableSource lazily, caches all of its events and replays them, in the same order as received, to all the downstream subscribers.
  Observable<T>	cacheWithInitialCapacity(int initialCapacity) Returns an Observable that subscribes to this ObservableSource lazily, caches all of its events and replays them, in the same order as received, to all the downstream subscribers.
  <U> Observable<U>	cast(Class<U> clazz) Returns an Observable that emits the items emitted by the source ObservableSource, converted to the specified type.
  <U> Single<U>	collect(Callable<? extends U> initialValueSupplier,BiConsumer<? super U,? superT> collector) Collects items emitted by the finite source ObservableSource into a single mutable data structure and returns a Single that emits this structure.
  <U> Single<U>	collectInto(U initialValue,BiConsumer<? super U,? superT> collector) Collects items emitted by the finite source ObservableSource into a single mutable data structure and returns a Single that emits this structure.
  static <T,R> Observable<R>	combineLatest(Function<? superObject[],? extends R> combiner, int bufferSize,ObservableSource<? extends T>... sources) Combines a collection of source ObservableSources by emitting an item that aggregates the latest values of each of the source ObservableSources each time an item is received from any of the source ObservableSources, where this aggregation is defined by a specified function.
  static <T,R> Observable<R>	combineLatest(Iterable<? extendsObservableSource<? extends T>> sources,Function<? superObject[],? extends R> combiner) Combines a collection of source ObservableSources by emitting an item that aggregates the latest values of each of the source ObservableSources each time an item is received from any of the source ObservableSources, where this aggregation is defined by a specified function.
  static <T,R> Observable<R>	combineLatest(Iterable<? extendsObservableSource<? extends T>> sources,Function<? superObject[],? extends R> combiner, int bufferSize) Combines a collection of source ObservableSources by emitting an item that aggregates the latest values of each of the source ObservableSources each time an item is received from any of the source ObservableSources, where this aggregation is defined by a specified function.
  static <T,R> Observable<R>	combineLatest(ObservableSource<? extends T>[] sources,Function<? superObject[],? extends R> combiner) Combines a collection of source ObservableSources by emitting an item that aggregates the latest values of each of the source ObservableSources each time an item is received from any of the source ObservableSources, where this aggregation is defined by a specified function.
  static <T,R> Observable<R>	combineLatest(ObservableSource<? extends T>[] sources,Function<? superObject[],? extends R> combiner, int bufferSize) Combines a collection of source ObservableSources by emitting an item that aggregates the latest values of each of the source ObservableSources each time an item is received from any of the source ObservableSources, where this aggregation is defined by a specified function.
  static <T1,T2,R> Observable<R>	combineLatest(ObservableSource<? extends T1> source1,ObservableSource<? extends T2> source2,BiFunction<? super T1,? super T2,? extends R> combiner) Combines two source ObservableSources by emitting an item that aggregates the latest values of each of the source ObservableSources each time an item is received from either of the source ObservableSources, where this aggregation is defined by a specified function.
  static <T1,T2,T3,R> Observable<R>	combineLatest(ObservableSource<? extends T1> source1,ObservableSource<? extends T2> source2,ObservableSource<? extends T3> source3,Function3<? super T1,? super T2,? super T3,? extends R> combiner) Combines three source ObservableSources by emitting an item that aggregates the latest values of each of the source ObservableSources each time an item is received from any of the source ObservableSources, where this aggregation is defined by a specified function.
  static <T1,T2,T3,T4,R> Observable<R>	combineLatest(ObservableSource<? extends T1> source1,ObservableSource<? extends T2> source2,ObservableSource<? extends T3> source3,ObservableSource<? extends T4> source4,Function4<? super T1,? super T2,? super T3,? super T4,? extends R> combiner) Combines four source ObservableSources by emitting an item that aggregates the latest values of each of the source ObservableSources each time an item is received from any of the source ObservableSources, where this aggregation is defined by a specified function.
  static <T1,T2,T3,T4,T5,R> Observable<R>	combineLatest(ObservableSource<? extends T1> source1,ObservableSource<? extends T2> source2,ObservableSource<? extends T3> source3,ObservableSource<? extends T4> source4,ObservableSource<? extends T5> source5,Function5<? super T1,? super T2,? super T3,? super T4,? super T5,? extends R> combiner) Combines five source ObservableSources by emitting an item that aggregates the latest values of each of the source ObservableSources each time an item is received from any of the source ObservableSources, where this aggregation is defined by a specified function.
  static <T1,T2,T3,T4,T5,T6,R> Observable<R>	combineLatest(ObservableSource<? extends T1> source1,ObservableSource<? extends T2> source2,ObservableSource<? extends T3> source3,ObservableSource<? extends T4> source4,ObservableSource<? extends T5> source5,ObservableSource<? extends T6> source6,Function6<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? extends R> combiner) Combines six source ObservableSources by emitting an item that aggregates the latest values of each of the source ObservableSources each time an item is received from any of the source ObservableSources, where this aggregation is defined by a specified function.
  static <T1,T2,T3,T4,T5,T6,T7,R> Observable<R>	combineLatest(ObservableSource<? extends T1> source1,ObservableSource<? extends T2> source2,ObservableSource<? extends T3> source3,ObservableSource<? extends T4> source4,ObservableSource<? extends T5> source5,ObservableSource<? extends T6> source6,ObservableSource<? extends T7> source7,Function7<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? extends R> combiner) Combines seven source ObservableSources by emitting an item that aggregates the latest values of each of the source ObservableSources each time an item is received from any of the source ObservableSources, where this aggregation is defined by a specified function.
  static <T1,T2,T3,T4,T5,T6,T7,T8,R> Observable<R>	combineLatest(ObservableSource<? extends T1> source1,ObservableSource<? extends T2> source2,ObservableSource<? extends T3> source3,ObservableSource<? extends T4> source4,ObservableSource<? extends T5> source5,ObservableSource<? extends T6> source6,ObservableSource<? extends T7> source7,ObservableSource<? extends T8> source8,Function8<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? extends R> combiner) Combines eight source ObservableSources by emitting an item that aggregates the latest values of each of the source ObservableSources each time an item is received from any of the source ObservableSources, where this aggregation is defined by a specified function.
  static <T1,T2,T3,T4,T5,T6,T7,T8,T9,R> Observable<R>	combineLatest(ObservableSource<? extends T1> source1,ObservableSource<? extends T2> source2,ObservableSource<? extends T3> source3,ObservableSource<? extends T4> source4,ObservableSource<? extends T5> source5,ObservableSource<? extends T6> source6,ObservableSource<? extends T7> source7,ObservableSource<? extends T8> source8,ObservableSource<? extends T9> source9,Function9<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? super T9,? extends R> combiner) Combines nine source ObservableSources by emitting an item that aggregates the latest values of each of the source ObservableSources each time an item is received from any of the source ObservableSources, where this aggregation is defined by a specified function.
  static <T,R> Observable<R>	combineLatestDelayError(Function<? superObject[],? extends R> combiner, int bufferSize,ObservableSource<? extends T>... sources) Combines a collection of source ObservableSources by emitting an item that aggregates the latest values of each of the source ObservableSources each time an item is received from any of the source ObservableSources, where this aggregation is defined by a specified function and delays any error from the sources until all source ObservableSources terminate.
  static <T,R> Observable<R>	combineLatestDelayError(Iterable<? extendsObservableSource<? extends T>> sources,Function<? superObject[],? extends R> combiner) Combines a collection of source ObservableSources by emitting an item that aggregates the latest values of each of the source ObservableSources each time an item is received from any of the source ObservableSources, where this aggregation is defined by a specified function and delays any error from the sources until all source ObservableSources terminate.
  static <T,R> Observable<R>	combineLatestDelayError(Iterable<? extendsObservableSource<? extends T>> sources,Function<? superObject[],? extends R> combiner, int bufferSize) Combines a collection of source ObservableSources by emitting an item that aggregates the latest values of each of the source ObservableSources each time an item is received from any of the source ObservableSources, where this aggregation is defined by a specified function and delays any error from the sources until all source ObservableSources terminate.
  static <T,R> Observable<R>	combineLatestDelayError(ObservableSource<? extends T>[] sources,Function<? superObject[],? extends R> combiner) Combines a collection of source ObservableSources by emitting an item that aggregates the latest values of each of the source ObservableSources each time an item is received from any of the source ObservableSources, where this aggregation is defined by a specified function.
  static <T,R> Observable<R>	combineLatestDelayError(ObservableSource<? extends T>[] sources,Function<? superObject[],? extends R> combiner, int bufferSize) Combines a collection of source ObservableSources by emitting an item that aggregates the latest values of each of the source ObservableSources each time an item is received from any of the source ObservableSources, where this aggregation is defined by a specified function and delays any error from the sources until all source ObservableSources terminate.
  <R> Observable<R>	compose(ObservableTransformer<? superT,? extends R> composer) Transform an ObservableSource by applying a particular Transformer function to it.
  static <T> Observable<T>	concat(Iterable<? extendsObservableSource<? extends T>> sources) Concatenates elements of each ObservableSource provided via an Iterable sequence into a single sequence of elements without interleaving them.
  static <T> Observable<T>	concat(ObservableSource<? extendsObservableSource<? extends T>> sources) Returns an Observable that emits the items emitted by each of the ObservableSources emitted by the source ObservableSource, one after the other, without interleaving them.
  static <T> Observable<T>	concat(ObservableSource<? extendsObservableSource<? extends T>> sources, int prefetch) Returns an Observable that emits the items emitted by each of the ObservableSources emitted by the source ObservableSource, one after the other, without interleaving them.
  static <T> Observable<T>	concat(ObservableSource<? extends T> source1,ObservableSource<? extends T> source2) Returns an Observable that emits the items emitted by two ObservableSources, one after the other, without interleaving them.
  static <T> Observable<T>	concat(ObservableSource<? extends T> source1,ObservableSource<? extends T> source2,ObservableSource<? extends T> source3) Returns an Observable that emits the items emitted by three ObservableSources, one after the other, without interleaving them.
  static <T> Observable<T>	concat(ObservableSource<? extends T> source1,ObservableSource<? extends T> source2,ObservableSource<? extends T> source3,ObservableSource<? extends T> source4) Returns an Observable that emits the items emitted by four ObservableSources, one after the other, without interleaving them.
  static <T> Observable<T>	concatArray(ObservableSource<? extends T>... sources) Concatenates a variable number of ObservableSource sources.
  static <T> Observable<T>	concatArrayDelayError(ObservableSource<? extends T>... sources) Concatenates a variable number of ObservableSource sources and delays errors from any of them till all terminate.
  static <T> Observable<T>	concatArrayEager(int maxConcurrency, int prefetch,ObservableSource<? extends T>... sources) Concatenates an array of ObservableSources eagerly into a single stream of values.
  static <T> Observable<T>	concatArrayEager(ObservableSource<? extends T>... sources) Concatenates an array of ObservableSources eagerly into a single stream of values.
  static <T> Observable<T>	concatArrayEagerDelayError(int maxConcurrency, int prefetch,ObservableSource<? extends T>... sources) Concatenates an array ofObservableSources eagerly into a single stream of values and delaying any errors until all sources terminate.
  static <T> Observable<T>	concatArrayEagerDelayError(ObservableSource<? extends T>... sources) Concatenates an array ofObservableSources eagerly into a single stream of values and delaying any errors until all sources terminate.
  static <T> Observable<T>	concatDelayError(Iterable<? extendsObservableSource<? extends T>> sources) Concatenates the Iterable sequence of ObservableSources into a single sequence by subscribing to each ObservableSource, one after the other, one at a time and delays any errors till the all inner ObservableSources terminate.
  static <T> Observable<T>	concatDelayError(ObservableSource<? extendsObservableSource<? extends T>> sources) Concatenates the ObservableSource sequence of ObservableSources into a single sequence by subscribing to each inner ObservableSource, one after the other, one at a time and delays any errors till the all inner and the outer ObservableSources terminate.
  static <T> Observable<T>	concatDelayError(ObservableSource<? extendsObservableSource<? extends T>> sources, int prefetch, boolean tillTheEnd) Concatenates the ObservableSource sequence of ObservableSources into a single sequence by subscribing to each inner ObservableSource, one after the other, one at a time and delays any errors till the all inner and the outer ObservableSources terminate.
  static <T> Observable<T>	concatEager(Iterable<? extendsObservableSource<? extends T>> sources) Concatenates a sequence of ObservableSources eagerly into a single stream of values.
  static <T> Observable<T>	concatEager(Iterable<? extendsObservableSource<? extends T>> sources, int maxConcurrency, int prefetch) Concatenates a sequence of ObservableSources eagerly into a single stream of values.
  static <T> Observable<T>	concatEager(ObservableSource<? extendsObservableSource<? extends T>> sources) Concatenates an ObservableSource sequence of ObservableSources eagerly into a single stream of values.
  static <T> Observable<T>	concatEager(ObservableSource<? extendsObservableSource<? extends T>> sources, int maxConcurrency, int prefetch) Concatenates an ObservableSource sequence of ObservableSources eagerly into a single stream of values.
  <R> Observable<R>	concatMap(Function<? superT,? extendsObservableSource<? extends R>> mapper) Returns a new Observable that emits items resulting from applying a function that you supply to each item emitted by the source ObservableSource, where that function returns an ObservableSource, and then emitting the items that result from concatenating those resulting ObservableSources.
  <R> Observable<R>	concatMap(Function<? superT,? extendsObservableSource<? extends R>> mapper, int prefetch) Returns a new Observable that emits items resulting from applying a function that you supply to each item emitted by the source ObservableSource, where that function returns an ObservableSource, and then emitting the items that result from concatenating those resulting ObservableSources.
  Completable	concatMapCompletable(Function<? superT,? extendsCompletableSource> mapper) Maps each element of the upstream Observable into CompletableSources, subscribes to them one at a time in order and waits until the upstream and all CompletableSources complete.
  Completable	concatMapCompletable(Function<? superT,? extendsCompletableSource> mapper, int capacityHint) Maps each element of the upstream Observable into CompletableSources, subscribes to them one at a time in order and waits until the upstream and all CompletableSources complete.
  Completable	concatMapCompletableDelayError(Function<? superT,? extendsCompletableSource> mapper) Maps the upstream items intoCompletableSources and subscribes to them one after the other terminates, delaying all errors till both thisObservable and all innerCompletableSources terminate.
  Completable	concatMapCompletableDelayError(Function<? superT,? extendsCompletableSource> mapper, boolean tillTheEnd) Maps the upstream items intoCompletableSources and subscribes to them one after the other terminates, optionally delaying all errors till both thisObservable and all innerCompletableSources terminate.
  Completable	concatMapCompletableDelayError(Function<? superT,? extendsCompletableSource> mapper, boolean tillTheEnd, int prefetch) Maps the upstream items intoCompletableSources and subscribes to them one after the other terminates, optionally delaying all errors till both thisObservable and all innerCompletableSources terminate.
  <R> Observable<R>	concatMapDelayError(Function<? superT,? extendsObservableSource<? extends R>> mapper) Maps each of the items into an ObservableSource, subscribes to them one after the other, one at a time and emits their values in order while delaying any error from either this or any of the inner ObservableSources till all of them terminate.
  <R> Observable<R>	concatMapDelayError(Function<? superT,? extendsObservableSource<? extends R>> mapper, int prefetch, boolean tillTheEnd) Maps each of the items into an ObservableSource, subscribes to them one after the other, one at a time and emits their values in order while delaying any error from either this or any of the inner ObservableSources till all of them terminate.
  <R> Observable<R>	concatMapEager(Function<? superT,? extendsObservableSource<? extends R>> mapper) Maps a sequence of values into ObservableSources and concatenates these ObservableSources eagerly into a single ObservableSource.
  <R> Observable<R>	concatMapEager(Function<? superT,? extendsObservableSource<? extends R>> mapper, int maxConcurrency, int prefetch) Maps a sequence of values into ObservableSources and concatenates these ObservableSources eagerly into a single ObservableSource.
  <R> Observable<R>	concatMapEagerDelayError(Function<? superT,? extendsObservableSource<? extends R>> mapper, boolean tillTheEnd) Maps a sequence of values into ObservableSources and concatenates these ObservableSources eagerly into a single ObservableSource.
  <R> Observable<R>	concatMapEagerDelayError(Function<? superT,? extendsObservableSource<? extends R>> mapper, int maxConcurrency, int prefetch, boolean tillTheEnd) Maps a sequence of values into ObservableSources and concatenates these ObservableSources eagerly into a single ObservableSource.
  <U> Observable<U>	concatMapIterable(Function<? superT,? extendsIterable<? extends U>> mapper) Returns an Observable that concatenate each item emitted by the source ObservableSource with the values in an Iterable corresponding to that item that is generated by a selector.
  <U> Observable<U>	concatMapIterable(Function<? superT,? extendsIterable<? extends U>> mapper, int prefetch) Returns an Observable that concatenate each item emitted by the source ObservableSource with the values in an Iterable corresponding to that item that is generated by a selector.
  <R> Observable<R>	concatMapMaybe(Function<? superT,? extendsMaybeSource<? extends R>> mapper) Maps the upstream items intoMaybeSources and subscribes to them one after the other succeeds or completes, emits their success value if available or terminates immediately if either thisObservable or the current innerMaybeSource fail.
  <R> Observable<R>	concatMapMaybe(Function<? superT,? extendsMaybeSource<? extends R>> mapper, int prefetch) Maps the upstream items intoMaybeSources and subscribes to them one after the other succeeds or completes, emits their success value if available or terminates immediately if either thisObservable or the current innerMaybeSource fail.
  <R> Observable<R>	concatMapMaybeDelayError(Function<? superT,? extendsMaybeSource<? extends R>> mapper) Maps the upstream items intoMaybeSources and subscribes to them one after the other terminates, emits their success value if available and delaying all errors till both thisObservable and all innerMaybeSources terminate.
  <R> Observable<R>	concatMapMaybeDelayError(Function<? superT,? extendsMaybeSource<? extends R>> mapper, boolean tillTheEnd) Maps the upstream items intoMaybeSources and subscribes to them one after the other terminates, emits their success value if available and optionally delaying all errors till both thisObservable and all innerMaybeSources terminate.
  <R> Observable<R>	concatMapMaybeDelayError(Function<? superT,? extendsMaybeSource<? extends R>> mapper, boolean tillTheEnd, int prefetch) Maps the upstream items intoMaybeSources and subscribes to them one after the other terminates, emits their success value if available and optionally delaying all errors till both thisObservable and all innerMaybeSources terminate.
  <R> Observable<R>	concatMapSingle(Function<? superT,? extendsSingleSource<? extends R>> mapper) Maps the upstream items intoSingleSources and subscribes to them one after the other succeeds, emits their success values or terminates immediately if either thisObservable or the current innerSingleSource fail.
  <R> Observable<R>	concatMapSingle(Function<? superT,? extendsSingleSource<? extends R>> mapper, int prefetch) Maps the upstream items intoSingleSources and subscribes to them one after the other succeeds, emits their success values or terminates immediately if either thisObservable or the current innerSingleSource fail.
  <R> Observable<R>	concatMapSingleDelayError(Function<? superT,? extendsSingleSource<? extends R>> mapper) Maps the upstream items intoSingleSources and subscribes to them one after the other succeeds or fails, emits their success values and delays all errors till both thisObservable and all innerSingleSources terminate.
  <R> Observable<R>	concatMapSingleDelayError(Function<? superT,? extendsSingleSource<? extends R>> mapper, boolean tillTheEnd) Maps the upstream items intoSingleSources and subscribes to them one after the other succeeds or fails, emits their success values and optionally delays all errors till both thisObservable and all innerSingleSources terminate.
  <R> Observable<R>	concatMapSingleDelayError(Function<? superT,? extendsSingleSource<? extends R>> mapper, boolean tillTheEnd, int prefetch) Maps the upstream items intoSingleSources and subscribes to them one after the other succeeds or fails, emits their success values and optionally delays errors till both thisObservable and all innerSingleSources terminate.
  Observable<T>	concatWith(CompletableSource other) Returns anObservable that emits items from thisObservable and when it completes normally, the otherCompletableSource is subscribed to and the returnedObservable emits its terminal events.
  Observable<T>	concatWith(MaybeSource<? extendsT> other) Returns anObservable that emits the items from thisObservable followed by the success item or terminal events of the otherMaybeSource.
  Observable<T>	concatWith(ObservableSource<? extendsT> other) Returns an Observable that emits the items emitted from the current ObservableSource, then the next, one after the other, without interleaving them.
  Observable<T>	concatWith(SingleSource<? extendsT> other) Returns anObservable that emits the items from thisObservable followed by the success item or error event of the otherSingleSource.
  Single<Boolean>	contains(Object element) Returns a Single that emits a Boolean that indicates whether the source ObservableSource emitted a specified item.
  Single<Long>	count() Returns a Single that counts the total number of items emitted by the source ObservableSource and emits this count as a 64-bit Long.
  static <T> Observable<T>	create(ObservableOnSubscribe<T> source) Provides an API (via a cold Observable) that bridges the reactive world with the callback-style world.
  <U> Observable<T>	debounce(Function<? superT,? extendsObservableSource<U>> debounceSelector) Returns an Observable that mirrors the source ObservableSource, except that it drops items emitted by the source ObservableSource that are followed by another item within a computed debounce duration.
  Observable<T>	debounce(long timeout,TimeUnit unit) Returns an Observable that mirrors the source ObservableSource, except that it drops items emitted by the source ObservableSource that are followed by newer items before a timeout value expires.
  Observable<T>	debounce(long timeout,TimeUnit unit,Scheduler scheduler) Returns an Observable that mirrors the source ObservableSource, except that it drops items emitted by the source ObservableSource that are followed by newer items before a timeout value expires on a specified Scheduler.
  Observable<T>	defaultIfEmpty(T defaultItem) Returns an Observable that emits the items emitted by the source ObservableSource or a specified default item if the source ObservableSource is empty.
  static <T> Observable<T>	defer(Callable<? extendsObservableSource<? extends T>> supplier) Returns an Observable that calls an ObservableSource factory to create an ObservableSource for each new Observer that subscribes.
  <U> Observable<T>	delay(Function<? superT,? extendsObservableSource<U>> itemDelay) Returns an Observable that delays the emissions of the source ObservableSource via another ObservableSource on a per-item basis.
  Observable<T>	delay(long delay,TimeUnit unit) Returns an Observable that emits the items emitted by the source ObservableSource shifted forward in time by a specified delay.
  Observable<T>	delay(long delay,TimeUnit unit, boolean delayError) Returns an Observable that emits the items emitted by the source ObservableSource shifted forward in time by a specified delay.
  Observable<T>	delay(long delay,TimeUnit unit,Scheduler scheduler) Returns an Observable that emits the items emitted by the source ObservableSource shifted forward in time by a specified delay.
  Observable<T>	delay(long delay,TimeUnit unit,Scheduler scheduler, boolean delayError) Returns an Observable that emits the items emitted by the source ObservableSource shifted forward in time by a specified delay.
  <U,V> Observable<T>	delay(ObservableSource<U> subscriptionDelay,Function<? superT,? extendsObservableSource<V>> itemDelay) Returns an Observable that delays the subscription to and emissions from the source ObservableSource via another ObservableSource on a per-item basis.
  Observable<T>	delaySubscription(long delay,TimeUnit unit) Returns an Observable that delays the subscription to the source ObservableSource by a given amount of time.
  Observable<T>	delaySubscription(long delay,TimeUnit unit,Scheduler scheduler) Returns an Observable that delays the subscription to the source ObservableSource by a given amount of time, both waiting and subscribing on a given Scheduler.
  <U> Observable<T>	delaySubscription(ObservableSource<U> other) Returns an Observable that delays the subscription to this Observable until the other Observable emits an element or completes normally.
  <T2> Observable<T2>	dematerialize() Deprecated.  in 2.2.4; inherently type-unsafe as it overrides the output generic type. Usedematerialize(Function) instead.
  <R> Observable<R>	dematerialize(Function<? superT,Notification<R>> selector) Returns an Observable that reverses the effect ofmaterialize by transforming theNotification objects extracted from the source items via a selector function into their respectiveObserver signal types.
  Observable<T>	distinct() Returns an Observable that emits all items emitted by the source ObservableSource that are distinct based onObject.equals(Object) comparison.
  <K> Observable<T>	distinct(Function<? superT,K> keySelector) Returns an Observable that emits all items emitted by the source ObservableSource that are distinct according to a key selector function and based onObject.equals(Object) comparison of the objects returned by the key selector function.
  <K> Observable<T>	distinct(Function<? superT,K> keySelector,Callable<? extendsCollection<? super K>> collectionSupplier) Returns an Observable that emits all items emitted by the source ObservableSource that are distinct according to a key selector function and based onObject.equals(Object) comparison of the objects returned by the key selector function.
  Observable<T>	distinctUntilChanged() Returns an Observable that emits all items emitted by the source ObservableSource that are distinct from their immediate predecessors based onObject.equals(Object) comparison.
  Observable<T>	distinctUntilChanged(BiPredicate<? superT,? superT> comparer) Returns an Observable that emits all items emitted by the source ObservableSource that are distinct from their immediate predecessors when compared with each other via the provided comparator function.
  <K> Observable<T>	distinctUntilChanged(Function<? superT,K> keySelector) Returns an Observable that emits all items emitted by the source ObservableSource that are distinct from their immediate predecessors, according to a key selector function and based onObject.equals(Object) comparison of those objects returned by the key selector function.
  Observable<T>	doAfterNext(Consumer<? superT> onAfterNext) Calls the specified consumer with the current item after this item has been emitted to the downstream.
  Observable<T>	doAfterTerminate(Action onFinally) Registers anAction to be called when this ObservableSource invokes eitheronComplete oronError.
  Observable<T>	doFinally(Action onFinally) Calls the specified action after this Observable signals onError or onCompleted or gets disposed by the downstream.
  Observable<T>	doOnComplete(Action onComplete) Modifies the source ObservableSource so that it invokes an action when it callsonComplete.
  Observable<T>	doOnDispose(Action onDispose) Calls the disposeAction if the downstream disposes the sequence.
  Observable<T>	doOnEach(Consumer<? superNotification<T>> onNotification) Modifies the source ObservableSource so that it invokes an action for each item it emits.
  Observable<T>	doOnEach(Observer<? superT> observer) Modifies the source ObservableSource so that it notifies an Observer for each item and terminal event it emits.
  Observable<T>	doOnError(Consumer<? superThrowable> onError) Modifies the source ObservableSource so that it invokes an action if it callsonError.
  Observable<T>	doOnLifecycle(Consumer<? superDisposable> onSubscribe,Action onDispose) Calls the appropriate onXXX method (shared between all Observer) for the lifecycle events of the sequence (subscription, disposal).
  Observable<T>	doOnNext(Consumer<? superT> onNext) Modifies the source ObservableSource so that it invokes an action when it callsonNext.
  Observable<T>	doOnSubscribe(Consumer<? superDisposable> onSubscribe) Modifies the sourceObservableSource so that it invokes the given action when it is subscribed from its subscribers.
  Observable<T>	doOnTerminate(Action onTerminate) Modifies the source ObservableSource so that it invokes an action when it callsonComplete oronError.
  Maybe<T>	elementAt(long index) Returns a Maybe that emits the single item at a specified index in a sequence of emissions from this Observable or completes if this Observable signals fewer elements than index.
  Single<T>	elementAt(long index,T defaultItem) Returns a Single that emits the item found at a specified index in a sequence of emissions from this Observable, or a default item if that index is out of range.
  Single<T>	elementAtOrError(long index) Returns a Single that emits the item found at a specified index in a sequence of emissions from this Observable or signals aNoSuchElementException if this Observable signals fewer elements than index.
  static <T> Observable<T>	empty() Returns an Observable that emits no items to theObserver and immediately invokes itsonComplete method.
  static <T> Observable<T>	error(Callable<? extendsThrowable> errorSupplier) Returns an Observable that invokes anObserver'sonError method when the Observer subscribes to it.
  static <T> Observable<T>	error(Throwable exception) Returns an Observable that invokes anObserver'sonError method when the Observer subscribes to it.
  Observable<T>	filter(Predicate<? superT> predicate) Filters items emitted by an ObservableSource by only emitting those that satisfy a specified predicate.
  Single<T>	first(T defaultItem) Returns a Single that emits only the very first item emitted by the source ObservableSource, or a default item if the source ObservableSource completes without emitting any items.
  Maybe<T>	firstElement() Returns a Maybe that emits only the very first item emitted by the source ObservableSource, or completes if the source ObservableSource is empty.
  Single<T>	firstOrError() Returns a Single that emits only the very first item emitted by this Observable or signals aNoSuchElementException if this Observable is empty.
  <R> Observable<R>	flatMap(Function<? superT,? extendsObservableSource<? extends R>> mapper) Returns an Observable that emits items based on applying a function that you supply to each item emitted by the source ObservableSource, where that function returns an ObservableSource, and then merging those resulting ObservableSources and emitting the results of this merger.
  <R> Observable<R>	flatMap(Function<? superT,? extendsObservableSource<? extends R>> mapper, boolean delayErrors) Returns an Observable that emits items based on applying a function that you supply to each item emitted by the source ObservableSource, where that function returns an ObservableSource, and then merging those resulting ObservableSources and emitting the results of this merger.
  <R> Observable<R>	flatMap(Function<? superT,? extendsObservableSource<? extends R>> mapper, boolean delayErrors, int maxConcurrency) Returns an Observable that emits items based on applying a function that you supply to each item emitted by the source ObservableSource, where that function returns an ObservableSource, and then merging those resulting ObservableSources and emitting the results of this merger, while limiting the maximum number of concurrent subscriptions to these ObservableSources.
  <R> Observable<R>	flatMap(Function<? superT,? extendsObservableSource<? extends R>> mapper, boolean delayErrors, int maxConcurrency, int bufferSize) Returns an Observable that emits items based on applying a function that you supply to each item emitted by the source ObservableSource, where that function returns an ObservableSource, and then merging those resulting ObservableSources and emitting the results of this merger, while limiting the maximum number of concurrent subscriptions to these ObservableSources.
  <R> Observable<R>	flatMap(Function<? superT,? extendsObservableSource<? extends R>> onNextMapper,Function<? superThrowable,? extendsObservableSource<? extends R>> onErrorMapper,Callable<? extendsObservableSource<? extends R>> onCompleteSupplier) Returns an Observable that applies a function to each item emitted or notification raised by the source ObservableSource and then flattens the ObservableSources returned from these functions and emits the resulting items.
  <R> Observable<R>	flatMap(Function<? superT,? extendsObservableSource<? extends R>> onNextMapper,Function<Throwable,? extendsObservableSource<? extends R>> onErrorMapper,Callable<? extendsObservableSource<? extends R>> onCompleteSupplier, int maxConcurrency) Returns an Observable that applies a function to each item emitted or notification raised by the source ObservableSource and then flattens the ObservableSources returned from these functions and emits the resulting items, while limiting the maximum number of concurrent subscriptions to these ObservableSources.
  <R> Observable<R>	flatMap(Function<? superT,? extendsObservableSource<? extends R>> mapper, int maxConcurrency) Returns an Observable that emits items based on applying a function that you supply to each item emitted by the source ObservableSource, where that function returns an ObservableSource, and then merging those resulting ObservableSources and emitting the results of this merger, while limiting the maximum number of concurrent subscriptions to these ObservableSources.
  <U,R> Observable<R>	flatMap(Function<? superT,? extendsObservableSource<? extends U>> mapper,BiFunction<? superT,? super U,? extends R> resultSelector) Returns an Observable that emits the results of a specified function to the pair of values emitted by the source ObservableSource and a specified collection ObservableSource.
  <U,R> Observable<R>	flatMap(Function<? superT,? extendsObservableSource<? extends U>> mapper,BiFunction<? superT,? super U,? extends R> combiner, boolean delayErrors) Returns an Observable that emits the results of a specified function to the pair of values emitted by the source ObservableSource and a specified collection ObservableSource.
  <U,R> Observable<R>	flatMap(Function<? superT,? extendsObservableSource<? extends U>> mapper,BiFunction<? superT,? super U,? extends R> combiner, boolean delayErrors, int maxConcurrency) Returns an Observable that emits the results of a specified function to the pair of values emitted by the source ObservableSource and a specified collection ObservableSource, while limiting the maximum number of concurrent subscriptions to these ObservableSources.
  <U,R> Observable<R>	flatMap(Function<? superT,? extendsObservableSource<? extends U>> mapper,BiFunction<? superT,? super U,? extends R> combiner, boolean delayErrors, int maxConcurrency, int bufferSize) Returns an Observable that emits the results of a specified function to the pair of values emitted by the source ObservableSource and a specified collection ObservableSource, while limiting the maximum number of concurrent subscriptions to these ObservableSources.
  <U,R> Observable<R>	flatMap(Function<? superT,? extendsObservableSource<? extends U>> mapper,BiFunction<? superT,? super U,? extends R> combiner, int maxConcurrency) Returns an Observable that emits the results of a specified function to the pair of values emitted by the source ObservableSource and a specified collection ObservableSource, while limiting the maximum number of concurrent subscriptions to these ObservableSources.
  Completable	flatMapCompletable(Function<? superT,? extendsCompletableSource> mapper) Maps each element of the upstream Observable into CompletableSources, subscribes to them and waits until the upstream and all CompletableSources complete.
  Completable	flatMapCompletable(Function<? superT,? extendsCompletableSource> mapper, boolean delayErrors) Maps each element of the upstream Observable into CompletableSources, subscribes to them and waits until the upstream and all CompletableSources complete, optionally delaying all errors.
  <U> Observable<U>	flatMapIterable(Function<? superT,? extendsIterable<? extends U>> mapper) Returns an Observable that merges each item emitted by the source ObservableSource with the values in an Iterable corresponding to that item that is generated by a selector.
  <U,V> Observable<V>	flatMapIterable(Function<? superT,? extendsIterable<? extends U>> mapper,BiFunction<? superT,? super U,? extends V> resultSelector) Returns an Observable that emits the results of applying a function to the pair of values from the source ObservableSource and an Iterable corresponding to that item that is generated by a selector.
  <R> Observable<R>	flatMapMaybe(Function<? superT,? extendsMaybeSource<? extends R>> mapper) Maps each element of the upstream Observable into MaybeSources, subscribes to all of them and merges their onSuccess values, in no particular order, into a single Observable sequence.
  <R> Observable<R>	flatMapMaybe(Function<? superT,? extendsMaybeSource<? extends R>> mapper, boolean delayErrors) Maps each element of the upstream Observable into MaybeSources, subscribes to them and merges their onSuccess values, in no particular order, into a single Observable sequence, optionally delaying all errors.
  <R> Observable<R>	flatMapSingle(Function<? superT,? extendsSingleSource<? extends R>> mapper) Maps each element of the upstream Observable into SingleSources, subscribes to all of them and merges their onSuccess values, in no particular order, into a single Observable sequence.
  <R> Observable<R>	flatMapSingle(Function<? superT,? extendsSingleSource<? extends R>> mapper, boolean delayErrors) Maps each element of the upstream Observable into SingleSources, subscribes to them and merges their onSuccess values, in no particular order, into a single Observable sequence, optionally delaying all errors.
  Disposable	forEach(Consumer<? superT> onNext) Subscribes to theObservableSource and receives notifications for each element.
  Disposable	forEachWhile(Predicate<? superT> onNext) Subscribes to theObservableSource and receives notifications for each element until the onNext Predicate returns false.
  Disposable	forEachWhile(Predicate<? superT> onNext,Consumer<? superThrowable> onError) Subscribes to theObservableSource and receives notifications for each element and error events until the onNext Predicate returns false.
  Disposable	forEachWhile(Predicate<? superT> onNext,Consumer<? superThrowable> onError,Action onComplete) Subscribes to theObservableSource and receives notifications for each element and the terminal events until the onNext Predicate returns false.
  static <T> Observable<T>	fromArray(T... items) Converts an Array into an ObservableSource that emits the items in the Array.
  static <T> Observable<T>	fromCallable(Callable<? extends T> supplier) Returns an Observable that, when an observer subscribes to it, invokes a function you specify and then emits the value returned from that function.
  static <T> Observable<T>	fromFuture(Future<? extends T> future) Converts aFuture into an ObservableSource.
  static <T> Observable<T>	fromFuture(Future<? extends T> future, long timeout,TimeUnit unit) Converts aFuture into an ObservableSource, with a timeout on the Future.
  static <T> Observable<T>	fromFuture(Future<? extends T> future, long timeout,TimeUnit unit,Scheduler scheduler) Converts aFuture into an ObservableSource, with a timeout on the Future.
  static <T> Observable<T>	fromFuture(Future<? extends T> future,Scheduler scheduler) Converts aFuture, operating on a specifiedScheduler, into an ObservableSource.
  static <T> Observable<T>	fromIterable(Iterable<? extends T> source) Converts anIterable sequence into an ObservableSource that emits the items in the sequence.
  static <T> Observable<T>	fromPublisher(Publisher<? extends T> publisher) Converts an arbitrary Reactive Streams Publisher into an Observable.
  static <T,S> Observable<T>	generate(Callable<S> initialState,BiConsumer<S,Emitter<T>> generator) Returns a cold, synchronous and stateful generator of values.
  static <T,S> Observable<T>	generate(Callable<S> initialState,BiConsumer<S,Emitter<T>> generator,Consumer<? super S> disposeState) Returns a cold, synchronous and stateful generator of values.
  static <T,S> Observable<T>	generate(Callable<S> initialState,BiFunction<S,Emitter<T>,S> generator) Returns a cold, synchronous and stateful generator of values.
  static <T,S> Observable<T>	generate(Callable<S> initialState,BiFunction<S,Emitter<T>,S> generator,Consumer<? super S> disposeState) Returns a cold, synchronous and stateful generator of values.
  static <T> Observable<T>	generate(Consumer<Emitter<T>> generator) Returns a cold, synchronous and stateless generator of values.
  <K> Observable<GroupedObservable<K,T>>	groupBy(Function<? superT,? extends K> keySelector) Groups the items emitted by anObservableSource according to a specified criterion, and emits these grouped items asGroupedObservables.
  <K> Observable<GroupedObservable<K,T>>	groupBy(Function<? superT,? extends K> keySelector, boolean delayError) Groups the items emitted by anObservableSource according to a specified criterion, and emits these grouped items asGroupedObservables.
  <K,V> Observable<GroupedObservable<K,V>>	groupBy(Function<? superT,? extends K> keySelector,Function<? superT,? extends V> valueSelector) Groups the items emitted by anObservableSource according to a specified criterion, and emits these grouped items asGroupedObservables.
  <K,V> Observable<GroupedObservable<K,V>>	groupBy(Function<? superT,? extends K> keySelector,Function<? superT,? extends V> valueSelector, boolean delayError) Groups the items emitted by anObservableSource according to a specified criterion, and emits these grouped items asGroupedObservables.
  <K,V> Observable<GroupedObservable<K,V>>	groupBy(Function<? superT,? extends K> keySelector,Function<? superT,? extends V> valueSelector, boolean delayError, int bufferSize) Groups the items emitted by anObservableSource according to a specified criterion, and emits these grouped items asGroupedObservables.
  <TRight,TLeftEnd,TRightEnd,R> Observable<R>	groupJoin(ObservableSource<? extends TRight> other,Function<? superT,? extendsObservableSource<TLeftEnd>> leftEnd,Function<? super TRight,? extendsObservableSource<TRightEnd>> rightEnd,BiFunction<? superT,? superObservable<TRight>,? extends R> resultSelector) Returns an Observable that correlates two ObservableSources when they overlap in time and groups the results.
  Observable<T>	hide() Hides the identity of this Observable and its Disposable.
  Completable	ignoreElements() Ignores all items emitted by the source ObservableSource and only callsonComplete oronError.
  staticObservable<Long>	interval(long initialDelay, long period,TimeUnit unit) Returns an Observable that emits a0L after theinitialDelay and ever increasing numbers after eachperiod of time thereafter.
  staticObservable<Long>	interval(long initialDelay, long period,TimeUnit unit,Scheduler scheduler) Returns an Observable that emits a0L after theinitialDelay and ever increasing numbers after eachperiod of time thereafter, on a specifiedScheduler.
  staticObservable<Long>	interval(long period,TimeUnit unit) Returns an Observable that emits a sequential number every specified interval of time.
  staticObservable<Long>	interval(long period,TimeUnit unit,Scheduler scheduler) Returns an Observable that emits a sequential number every specified interval of time, on a specified Scheduler.
  staticObservable<Long>	intervalRange(long start, long count, long initialDelay, long period,TimeUnit unit) Signals a range of long values, the first after some initial delay and the rest periodically after.
  staticObservable<Long>	intervalRange(long start, long count, long initialDelay, long period,TimeUnit unit,Scheduler scheduler) Signals a range of long values, the first after some initial delay and the rest periodically after.
  Single<Boolean>	isEmpty() Returns a Single that emitstrue if the source ObservableSource is empty, otherwisefalse.
  <TRight,TLeftEnd,TRightEnd,R> Observable<R>	join(ObservableSource<? extends TRight> other,Function<? superT,? extendsObservableSource<TLeftEnd>> leftEnd,Function<? super TRight,? extendsObservableSource<TRightEnd>> rightEnd,BiFunction<? superT,? super TRight,? extends R> resultSelector) Correlates the items emitted by two ObservableSources based on overlapping durations.
  static <T> Observable<T>	just(T item) Returns an Observable that signals the given (constant reference) item and then completes.
  static <T> Observable<T>	just(T item1, T item2) Converts two items into an ObservableSource that emits those items.
  static <T> Observable<T>	just(T item1, T item2, T item3) Converts three items into an ObservableSource that emits those items.
  static <T> Observable<T>	just(T item1, T item2, T item3, T item4) Converts four items into an ObservableSource that emits those items.
  static <T> Observable<T>	just(T item1, T item2, T item3, T item4, T item5) Converts five items into an ObservableSource that emits those items.
  static <T> Observable<T>	just(T item1, T item2, T item3, T item4, T item5, T item6) Converts six items into an ObservableSource that emits those items.
  static <T> Observable<T>	just(T item1, T item2, T item3, T item4, T item5, T item6, T item7) Converts seven items into an ObservableSource that emits those items.
  static <T> Observable<T>	just(T item1, T item2, T item3, T item4, T item5, T item6, T item7, T item8) Converts eight items into an ObservableSource that emits those items.
  static <T> Observable<T>	just(T item1, T item2, T item3, T item4, T item5, T item6, T item7, T item8, T item9) Converts nine items into an ObservableSource that emits those items.
  static <T> Observable<T>	just(T item1, T item2, T item3, T item4, T item5, T item6, T item7, T item8, T item9, T item10) Converts ten items into an ObservableSource that emits those items.
  Single<T>	last(T defaultItem) Returns a Single that emits only the last item emitted by this Observable, or a default item if this Observable completes without emitting any items.
  Maybe<T>	lastElement() Returns a Maybe that emits the last item emitted by this Observable or completes if this Observable is empty.
  Single<T>	lastOrError() Returns a Single that emits only the last item emitted by this Observable or signals aNoSuchElementException if this Observable is empty.
  <R> Observable<R>	lift(ObservableOperator<? extends R,? superT> lifter) This method requires advanced knowledge about building operators, please consider other standard composition methods first; Returns anObservable which, when subscribed to, invokes theapply(Observer) method of the providedObservableOperator for each individual downstreamObserver and allows the insertion of a custom operator by accessing the downstream'sObserver during this subscription phase and providing a newObserver, containing the custom operator's intended business logic, that will be used in the subscription process going further upstream.
  <R> Observable<R>	map(Function<? superT,? extends R> mapper) Returns an Observable that applies a specified function to each item emitted by the source ObservableSource and emits the results of these function applications.
  Observable<Notification<T>>	materialize() Returns an Observable that represents all of the emissionsand notifications from the source ObservableSource into emissions marked with their original types withinNotification objects.
  static <T> Observable<T>	merge(Iterable<? extendsObservableSource<? extends T>> sources) Flattens an Iterable of ObservableSources into one ObservableSource, without any transformation.
  static <T> Observable<T>	merge(Iterable<? extendsObservableSource<? extends T>> sources, int maxConcurrency) Flattens an Iterable of ObservableSources into one ObservableSource, without any transformation, while limiting the number of concurrent subscriptions to these ObservableSources.
  static <T> Observable<T>	merge(Iterable<? extendsObservableSource<? extends T>> sources, int maxConcurrency, int bufferSize) Flattens an Iterable of ObservableSources into one ObservableSource, without any transformation, while limiting the number of concurrent subscriptions to these ObservableSources.
  static <T> Observable<T>	merge(ObservableSource<? extendsObservableSource<? extends T>> sources) Flattens an ObservableSource that emits ObservableSources into a single ObservableSource that emits the items emitted by those ObservableSources, without any transformation.
  static <T> Observable<T>	merge(ObservableSource<? extendsObservableSource<? extends T>> sources, int maxConcurrency) Flattens an ObservableSource that emits ObservableSources into a single ObservableSource that emits the items emitted by those ObservableSources, without any transformation, while limiting the maximum number of concurrent subscriptions to these ObservableSources.
  static <T> Observable<T>	merge(ObservableSource<? extends T> source1,ObservableSource<? extends T> source2) Flattens two ObservableSources into a single ObservableSource, without any transformation.
  static <T> Observable<T>	merge(ObservableSource<? extends T> source1,ObservableSource<? extends T> source2,ObservableSource<? extends T> source3) Flattens three ObservableSources into a single ObservableSource, without any transformation.
  static <T> Observable<T>	merge(ObservableSource<? extends T> source1,ObservableSource<? extends T> source2,ObservableSource<? extends T> source3,ObservableSource<? extends T> source4) Flattens four ObservableSources into a single ObservableSource, without any transformation.
  static <T> Observable<T>	mergeArray(int maxConcurrency, int bufferSize,ObservableSource<? extends T>... sources) Flattens an Iterable of ObservableSources into one ObservableSource, without any transformation, while limiting the number of concurrent subscriptions to these ObservableSources.
  static <T> Observable<T>	mergeArray(ObservableSource<? extends T>... sources) Flattens an Array of ObservableSources into one ObservableSource, without any transformation.
  static <T> Observable<T>	mergeArrayDelayError(int maxConcurrency, int bufferSize,ObservableSource<? extends T>... sources) Flattens an array of ObservableSources into one ObservableSource, in a way that allows an Observer to receive all successfully emitted items from each of the source ObservableSources without being interrupted by an error notification from one of them, while limiting the number of concurrent subscriptions to these ObservableSources.
  static <T> Observable<T>	mergeArrayDelayError(ObservableSource<? extends T>... sources) Flattens an Iterable of ObservableSources into one ObservableSource, in a way that allows an Observer to receive all successfully emitted items from each of the source ObservableSources without being interrupted by an error notification from one of them.
  static <T> Observable<T>	mergeDelayError(Iterable<? extendsObservableSource<? extends T>> sources) Flattens an Iterable of ObservableSources into one ObservableSource, in a way that allows an Observer to receive all successfully emitted items from each of the source ObservableSources without being interrupted by an error notification from one of them.
  static <T> Observable<T>	mergeDelayError(Iterable<? extendsObservableSource<? extends T>> sources, int maxConcurrency) Flattens an Iterable of ObservableSources into one ObservableSource, in a way that allows an Observer to receive all successfully emitted items from each of the source ObservableSources without being interrupted by an error notification from one of them, while limiting the number of concurrent subscriptions to these ObservableSources.
  static <T> Observable<T>	mergeDelayError(Iterable<? extendsObservableSource<? extends T>> sources, int maxConcurrency, int bufferSize) Flattens an Iterable of ObservableSources into one ObservableSource, in a way that allows an Observer to receive all successfully emitted items from each of the source ObservableSources without being interrupted by an error notification from one of them, while limiting the number of concurrent subscriptions to these ObservableSources.
  static <T> Observable<T>	mergeDelayError(ObservableSource<? extendsObservableSource<? extends T>> sources) Flattens an ObservableSource that emits ObservableSources into one ObservableSource, in a way that allows an Observer to receive all successfully emitted items from all of the source ObservableSources without being interrupted by an error notification from one of them.
  static <T> Observable<T>	mergeDelayError(ObservableSource<? extendsObservableSource<? extends T>> sources, int maxConcurrency) Flattens an ObservableSource that emits ObservableSources into one ObservableSource, in a way that allows an Observer to receive all successfully emitted items from all of the source ObservableSources without being interrupted by an error notification from one of them, while limiting the number of concurrent subscriptions to these ObservableSources.
  static <T> Observable<T>	mergeDelayError(ObservableSource<? extends T> source1,ObservableSource<? extends T> source2) Flattens two ObservableSources into one ObservableSource, in a way that allows an Observer to receive all successfully emitted items from each of the source ObservableSources without being interrupted by an error notification from one of them.
  static <T> Observable<T>	mergeDelayError(ObservableSource<? extends T> source1,ObservableSource<? extends T> source2,ObservableSource<? extends T> source3) Flattens three ObservableSources into one ObservableSource, in a way that allows an Observer to receive all successfully emitted items from all of the source ObservableSources without being interrupted by an error notification from one of them.
  static <T> Observable<T>	mergeDelayError(ObservableSource<? extends T> source1,ObservableSource<? extends T> source2,ObservableSource<? extends T> source3,ObservableSource<? extends T> source4) Flattens four ObservableSources into one ObservableSource, in a way that allows an Observer to receive all successfully emitted items from all of the source ObservableSources without being interrupted by an error notification from one of them.
  Observable<T>	mergeWith(CompletableSource other) Relays the items of this Observable and completes only when the other CompletableSource completes as well.
  Observable<T>	mergeWith(MaybeSource<? extendsT> other) Merges the sequence of items of this Observable with the success value of the other MaybeSource or waits both to complete normally if the MaybeSource is empty.
  Observable<T>	mergeWith(ObservableSource<? extendsT> other) Flattens this and another ObservableSource into a single ObservableSource, without any transformation.
  Observable<T>	mergeWith(SingleSource<? extendsT> other) Merges the sequence of items of this Observable with the success value of the other SingleSource.
  static <T> Observable<T>	never() Returns an Observable that never sends any items or notifications to anObserver.
  Observable<T>	observeOn(Scheduler scheduler) Modifies an ObservableSource to perform its emissions and notifications on a specifiedScheduler, asynchronously with an unbounded buffer withFlowable.bufferSize() "island size".
  Observable<T>	observeOn(Scheduler scheduler, boolean delayError) Modifies an ObservableSource to perform its emissions and notifications on a specifiedScheduler, asynchronously with an unbounded buffer withFlowable.bufferSize() "island size" and optionally delays onError notifications.
  Observable<T>	observeOn(Scheduler scheduler, boolean delayError, int bufferSize) Modifies an ObservableSource to perform its emissions and notifications on a specifiedScheduler, asynchronously with an unbounded buffer of configurable "island size" and optionally delays onError notifications.
  <U> Observable<U>	ofType(Class<U> clazz) Filters the items emitted by an ObservableSource, only emitting those of the specified type.
  Observable<T>	onErrorResumeNext(Function<? superThrowable,? extendsObservableSource<? extendsT>> resumeFunction) Instructs an ObservableSource to pass control to another ObservableSource rather than invokingonError if it encounters an error.
  Observable<T>	onErrorResumeNext(ObservableSource<? extendsT> next) Instructs an ObservableSource to pass control to another ObservableSource rather than invokingonError if it encounters an error.
  Observable<T>	onErrorReturn(Function<? superThrowable,? extendsT> valueSupplier) Instructs an ObservableSource to emit an item (returned by a specified function) rather than invokingonError if it encounters an error.
  Observable<T>	onErrorReturnItem(T item) Instructs an ObservableSource to emit an item (returned by a specified function) rather than invokingonError if it encounters an error.
  Observable<T>	onExceptionResumeNext(ObservableSource<? extendsT> next) Instructs an ObservableSource to pass control to another ObservableSource rather than invokingonError if it encounters anException.
  Observable<T>	onTerminateDetach() Nulls out references to the upstream producer and downstream Observer if the sequence is terminated or downstream calls dispose().
  ConnectableObservable<T>	publish() Returns aConnectableObservable, which is a variety of ObservableSource that waits until itsconnect method is called before it begins emitting items to thoseObservers that have subscribed to it.
  <R> Observable<R>	publish(Function<? superObservable<T>,? extendsObservableSource<R>> selector) Returns an Observable that emits the results of invoking a specified selector on items emitted by aConnectableObservable that shares a single subscription to the underlying sequence.
  staticObservable<Integer>	range(int start, int count) Returns an Observable that emits a sequence of Integers within a specified range.
  staticObservable<Long>	rangeLong(long start, long count) Returns an Observable that emits a sequence of Longs within a specified range.
  Maybe<T>	reduce(BiFunction<T,T,T> reducer) Returns a Maybe that applies a specified accumulator function to the first item emitted by a source ObservableSource, then feeds the result of that function along with the second item emitted by the source ObservableSource into the same function, and so on until all items have been emitted by the finite source ObservableSource, and emits the final result from the final call to your function as its sole item.
  <R> Single<R>	reduce(R seed,BiFunction<R,? superT,R> reducer) Returns a Single that applies a specified accumulator function to the first item emitted by a source ObservableSource and a specified seed value, then feeds the result of that function along with the second item emitted by an ObservableSource into the same function, and so on until all items have been emitted by the finite source ObservableSource, emitting the final result from the final call to your function as its sole item.
  <R> Single<R>	reduceWith(Callable<R> seedSupplier,BiFunction<R,? superT,R> reducer) Returns a Single that applies a specified accumulator function to the first item emitted by a source ObservableSource and a seed value derived from calling a specified seedSupplier, then feeds the result of that function along with the second item emitted by an ObservableSource into the same function, and so on until all items have been emitted by the finite source ObservableSource, emitting the final result from the final call to your function as its sole item.
  Observable<T>	repeat() Returns an Observable that repeats the sequence of items emitted by the source ObservableSource indefinitely.
  Observable<T>	repeat(long times) Returns an Observable that repeats the sequence of items emitted by the source ObservableSource at mostcount times.
  Observable<T>	repeatUntil(BooleanSupplier stop) Returns an Observable that repeats the sequence of items emitted by the source ObservableSource until the provided stop function returns true.
  Observable<T>	repeatWhen(Function<? superObservable<Object>,? extendsObservableSource<?>> handler) Returns an Observable that emits the same values as the source ObservableSource with the exception of anonComplete.
  ConnectableObservable<T>	replay() Returns aConnectableObservable that shares a single subscription to the underlying ObservableSource that will replay all of its items and notifications to any futureObserver.
  <R> Observable<R>	replay(Function<? superObservable<T>,? extendsObservableSource<R>> selector) Returns an Observable that emits items that are the results of invoking a specified selector on the items emitted by aConnectableObservable that shares a single subscription to the source ObservableSource.
  <R> Observable<R>	replay(Function<? superObservable<T>,? extendsObservableSource<R>> selector, int bufferSize) Returns an Observable that emits items that are the results of invoking a specified selector on items emitted by aConnectableObservable that shares a single subscription to the source ObservableSource, replayingbufferSize notifications.
  <R> Observable<R>	replay(Function<? superObservable<T>,? extendsObservableSource<R>> selector, int bufferSize, long time,TimeUnit unit) Returns an Observable that emits items that are the results of invoking a specified selector on items emitted by aConnectableObservable that shares a single subscription to the source ObservableSource, replaying no more thanbufferSize items that were emitted within a specified time window.
  <R> Observable<R>	replay(Function<? superObservable<T>,? extendsObservableSource<R>> selector, int bufferSize, long time,TimeUnit unit,Scheduler scheduler) Returns an Observable that emits items that are the results of invoking a specified selector on items emitted by aConnectableObservable that shares a single subscription to the source ObservableSource, replaying no more thanbufferSize items that were emitted within a specified time window.
  <R> Observable<R>	replay(Function<? superObservable<T>,? extendsObservableSource<R>> selector, int bufferSize,Scheduler scheduler) Returns an Observable that emits items that are the results of invoking a specified selector on items emitted by aConnectableObservable that shares a single subscription to the source ObservableSource, replaying a maximum ofbufferSize items.
  <R> Observable<R>	replay(Function<? superObservable<T>,? extendsObservableSource<R>> selector, long time,TimeUnit unit) Returns an Observable that emits items that are the results of invoking a specified selector on items emitted by aConnectableObservable that shares a single subscription to the source ObservableSource, replaying all items that were emitted within a specified time window.
  <R> Observable<R>	replay(Function<? superObservable<T>,? extendsObservableSource<R>> selector, long time,TimeUnit unit,Scheduler scheduler) Returns an Observable that emits items that are the results of invoking a specified selector on items emitted by aConnectableObservable that shares a single subscription to the source ObservableSource, replaying all items that were emitted within a specified time window.
  <R> Observable<R>	replay(Function<? superObservable<T>,? extendsObservableSource<R>> selector,Scheduler scheduler) Returns an Observable that emits items that are the results of invoking a specified selector on items emitted by aConnectableObservable that shares a single subscription to the source ObservableSource.
  ConnectableObservable<T>	replay(int bufferSize) Returns aConnectableObservable that shares a single subscription to the source ObservableSource that replays at mostbufferSize items emitted by that ObservableSource.
  ConnectableObservable<T>	replay(int bufferSize, long time,TimeUnit unit) Returns aConnectableObservable that shares a single subscription to the source ObservableSource and replays at mostbufferSize items that were emitted during a specified time window.
  ConnectableObservable<T>	replay(int bufferSize, long time,TimeUnit unit,Scheduler scheduler) Returns aConnectableObservable that shares a single subscription to the source ObservableSource and that replays a maximum ofbufferSize items that are emitted within a specified time window.
  ConnectableObservable<T>	replay(int bufferSize,Scheduler scheduler) Returns aConnectableObservable that shares a single subscription to the source ObservableSource and replays at mostbufferSize items emitted by that ObservableSource.
  ConnectableObservable<T>	replay(long time,TimeUnit unit) Returns aConnectableObservable that shares a single subscription to the source ObservableSource and replays all items emitted by that ObservableSource within a specified time window.
  ConnectableObservable<T>	replay(long time,TimeUnit unit,Scheduler scheduler) Returns aConnectableObservable that shares a single subscription to the source ObservableSource and replays all items emitted by that ObservableSource within a specified time window.
  ConnectableObservable<T>	replay(Scheduler scheduler) Returns aConnectableObservable that shares a single subscription to the source ObservableSource that will replay all of its items and notifications to any futureObserver on the givenScheduler.
  Observable<T>	retry() Returns an Observable that mirrors the source ObservableSource, resubscribing to it if it callsonError (infinite retry count).
  Observable<T>	retry(BiPredicate<? superInteger,? superThrowable> predicate) Returns an Observable that mirrors the source ObservableSource, resubscribing to it if it callsonError and the predicate returns true for that specific exception and retry count.
  Observable<T>	retry(long times) Returns an Observable that mirrors the source ObservableSource, resubscribing to it if it callsonError up to a specified number of retries.
  Observable<T>	retry(long times,Predicate<? superThrowable> predicate) Retries at most times or until the predicate returns false, whichever happens first.
  Observable<T>	retry(Predicate<? superThrowable> predicate) Retries the current Observable if the predicate returns true.
  Observable<T>	retryUntil(BooleanSupplier stop) Retries until the given stop function returns true.
  Observable<T>	retryWhen(Function<? superObservable<Throwable>,? extendsObservableSource<?>> handler) Returns an Observable that emits the same values as the source ObservableSource with the exception of anonError.
  void	safeSubscribe(Observer<? superT> observer) Subscribes to the current Observable and wraps the given Observer into a SafeObserver (if not already a SafeObserver) that deals with exceptions thrown by a misbehaving Observer (that doesn't follow the Reactive Streams specification).
  Observable<T>	sample(long period,TimeUnit unit) Returns an Observable that emits the most recently emitted item (if any) emitted by the source ObservableSource within periodic time intervals.
  Observable<T>	sample(long period,TimeUnit unit, boolean emitLast) Returns an Observable that emits the most recently emitted item (if any) emitted by the source ObservableSource within periodic time intervals and optionally emit the very last upstream item when the upstream completes.
  Observable<T>	sample(long period,TimeUnit unit,Scheduler scheduler) Returns an Observable that emits the most recently emitted item (if any) emitted by the source ObservableSource within periodic time intervals, where the intervals are defined on a particular Scheduler.
  Observable<T>	sample(long period,TimeUnit unit,Scheduler scheduler, boolean emitLast) Returns an Observable that emits the most recently emitted item (if any) emitted by the source ObservableSource within periodic time intervals, where the intervals are defined on a particular Scheduler and optionally emit the very last upstream item when the upstream completes.
  <U> Observable<T>	sample(ObservableSource<U> sampler) Returns an Observable that, when the specifiedsampler ObservableSource emits an item or completes, emits the most recently emitted item (if any) emitted by the source ObservableSource since the previous emission from thesampler ObservableSource.
  <U> Observable<T>	sample(ObservableSource<U> sampler, boolean emitLast) Returns an Observable that, when the specifiedsampler ObservableSource emits an item or completes, emits the most recently emitted item (if any) emitted by the source ObservableSource since the previous emission from thesampler ObservableSource and optionally emit the very last upstream item when the upstream or other ObservableSource complete.
  Observable<T>	scan(BiFunction<T,T,T> accumulator) Returns an Observable that applies a specified accumulator function to the first item emitted by a source ObservableSource, then feeds the result of that function along with the second item emitted by the source ObservableSource into the same function, and so on until all items have been emitted by the source ObservableSource, emitting the result of each of these iterations.
  <R> Observable<R>	scan(R initialValue,BiFunction<R,? superT,R> accumulator) Returns an Observable that applies a specified accumulator function to the first item emitted by a source ObservableSource and a seed value, then feeds the result of that function along with the second item emitted by the source ObservableSource into the same function, and so on until all items have been emitted by the source ObservableSource, emitting the result of each of these iterations.
  <R> Observable<R>	scanWith(Callable<R> seedSupplier,BiFunction<R,? superT,R> accumulator) Returns an Observable that applies a specified accumulator function to the first item emitted by a source ObservableSource and a seed value, then feeds the result of that function along with the second item emitted by the source ObservableSource into the same function, and so on until all items have been emitted by the source ObservableSource, emitting the result of each of these iterations.
  static <T> Single<Boolean>	sequenceEqual(ObservableSource<? extends T> source1,ObservableSource<? extends T> source2) Returns a Single that emits a Boolean value that indicates whether two ObservableSource sequences are the same by comparing the items emitted by each ObservableSource pairwise.
  static <T> Single<Boolean>	sequenceEqual(ObservableSource<? extends T> source1,ObservableSource<? extends T> source2,BiPredicate<? super T,? super T> isEqual) Returns a Single that emits a Boolean value that indicates whether two ObservableSource sequences are the same by comparing the items emitted by each ObservableSource pairwise based on the results of a specified equality function.
  static <T> Single<Boolean>	sequenceEqual(ObservableSource<? extends T> source1,ObservableSource<? extends T> source2,BiPredicate<? super T,? super T> isEqual, int bufferSize) Returns a Single that emits a Boolean value that indicates whether two ObservableSource sequences are the same by comparing the items emitted by each ObservableSource pairwise based on the results of a specified equality function.
  static <T> Single<Boolean>	sequenceEqual(ObservableSource<? extends T> source1,ObservableSource<? extends T> source2, int bufferSize) Returns a Single that emits a Boolean value that indicates whether two ObservableSource sequences are the same by comparing the items emitted by each ObservableSource pairwise.
  Observable<T>	serialize() Forces an ObservableSource's emissions and notifications to be serialized and for it to obeythe ObservableSource contract in other ways.
  Observable<T>	share() Returns a newObservableSource that multicasts (and shares a single subscription to) the originalObservableSource.
  Single<T>	single(T defaultItem) Returns a Single that emits the single item emitted by this Observable, if this Observable emits only a single item, or a default item if the source ObservableSource emits no items.
  Maybe<T>	singleElement() Returns a Maybe that completes if this Observable is empty or emits the single item emitted by this Observable, or signals anIllegalArgumentException if this Observable emits more than one item.
  Single<T>	singleOrError() Returns a Single that emits the single item emitted by this Observable if this Observable emits only a single item, otherwise if this Observable completes without emitting any items or emits more than one item aNoSuchElementException orIllegalArgumentException will be signalled respectively.
  Observable<T>	skip(long count) Returns an Observable that skips the firstcount items emitted by the source ObservableSource and emits the remainder.
  Observable<T>	skip(long time,TimeUnit unit) Returns an Observable that skips values emitted by the source ObservableSource before a specified time window elapses.
  Observable<T>	skip(long time,TimeUnit unit,Scheduler scheduler) Returns an Observable that skips values emitted by the source ObservableSource before a specified time window on a specifiedScheduler elapses.
  Observable<T>	skipLast(int count) Returns an Observable that drops a specified number of items from the end of the sequence emitted by the source ObservableSource.
  Observable<T>	skipLast(long time,TimeUnit unit) Returns an Observable that drops items emitted by the source ObservableSource during a specified time window before the source completes.
  Observable<T>	skipLast(long time,TimeUnit unit, boolean delayError) Returns an Observable that drops items emitted by the source ObservableSource during a specified time window before the source completes.
  Observable<T>	skipLast(long time,TimeUnit unit,Scheduler scheduler) Returns an Observable that drops items emitted by the source ObservableSource during a specified time window (defined on a specified scheduler) before the source completes.
  Observable<T>	skipLast(long time,TimeUnit unit,Scheduler scheduler, boolean delayError) Returns an Observable that drops items emitted by the source ObservableSource during a specified time window (defined on a specified scheduler) before the source completes.
  Observable<T>	skipLast(long time,TimeUnit unit,Scheduler scheduler, boolean delayError, int bufferSize) Returns an Observable that drops items emitted by the source ObservableSource during a specified time window (defined on a specified scheduler) before the source completes.
  <U> Observable<T>	skipUntil(ObservableSource<U> other) Returns an Observable that skips items emitted by the source ObservableSource until a second ObservableSource emits an item.
  Observable<T>	skipWhile(Predicate<? superT> predicate) Returns an Observable that skips all items emitted by the source ObservableSource as long as a specified condition holds true, but emits all further source items as soon as the condition becomes false.
  Observable<T>	sorted() Returns an Observable that emits the events emitted by source ObservableSource, in a sorted order.
  Observable<T>	sorted(Comparator<? superT> sortFunction) Returns an Observable that emits the events emitted by source ObservableSource, in a sorted order based on a specified comparison function.
  Observable<T>	startWith(Iterable<? extendsT> items) Returns an Observable that emits the items in a specifiedIterable before it begins to emit items emitted by the source ObservableSource.
  Observable<T>	startWith(ObservableSource<? extendsT> other) Returns an Observable that emits the items in a specifiedObservableSource before it begins to emit items emitted by the source ObservableSource.
  Observable<T>	startWith(T item) Returns an Observable that emits a specified item before it begins to emit items emitted by the source ObservableSource.
  Observable<T>	startWithArray(T... items) Returns an Observable that emits the specified items before it begins to emit items emitted by the source ObservableSource.
  Disposable	subscribe() Subscribes to an ObservableSource and ignoresonNext andonComplete emissions.
  Disposable	subscribe(Consumer<? superT> onNext) Subscribes to an ObservableSource and provides a callback to handle the items it emits.
  Disposable	subscribe(Consumer<? superT> onNext,Consumer<? superThrowable> onError) Subscribes to an ObservableSource and provides callbacks to handle the items it emits and any error notification it issues.
  Disposable	subscribe(Consumer<? superT> onNext,Consumer<? superThrowable> onError,Action onComplete) Subscribes to an ObservableSource and provides callbacks to handle the items it emits and any error or completion notification it issues.
  Disposable	subscribe(Consumer<? superT> onNext,Consumer<? superThrowable> onError,Action onComplete,Consumer<? superDisposable> onSubscribe) Subscribes to an ObservableSource and provides callbacks to handle the items it emits and any error or completion notification it issues.
  void	subscribe(Observer<? superT> observer) Subscribes the given Observer to this ObservableSource instance.
  protected abstract void	subscribeActual(Observer<? superT> observer) Operator implementations (both source and intermediate) should implement this method that performs the necessary business logic and handles the incomingObservers.
  Observable<T>	subscribeOn(Scheduler scheduler) Asynchronously subscribes Observers to this ObservableSource on the specifiedScheduler.
  <E extendsObserver<? superT>> E	subscribeWith(E observer) Subscribes a given Observer (subclass) to this Observable and returns the given Observer as is.
  Observable<T>	switchIfEmpty(ObservableSource<? extendsT> other) Returns an Observable that emits the items emitted by the source ObservableSource or the items of an alternate ObservableSource if the source ObservableSource is empty.
  <R> Observable<R>	switchMap(Function<? superT,? extendsObservableSource<? extends R>> mapper) Returns a new ObservableSource by applying a function that you supply to each item emitted by the source ObservableSource that returns an ObservableSource, and then emitting the items emitted by the most recently emitted of these ObservableSources.
  <R> Observable<R>	switchMap(Function<? superT,? extendsObservableSource<? extends R>> mapper, int bufferSize) Returns a new ObservableSource by applying a function that you supply to each item emitted by the source ObservableSource that returns an ObservableSource, and then emitting the items emitted by the most recently emitted of these ObservableSources.
  Completable	switchMapCompletable(Function<? superT,? extendsCompletableSource> mapper) Maps the upstream values intoCompletableSources, subscribes to the newer one while disposing the subscription to the previousCompletableSource, thus keeping at most one activeCompletableSource running.
  Completable	switchMapCompletableDelayError(Function<? superT,? extendsCompletableSource> mapper) Maps the upstream values intoCompletableSources, subscribes to the newer one while disposing the subscription to the previousCompletableSource, thus keeping at most one activeCompletableSource running and delaying any main or inner errors until all of them terminate.
  <R> Observable<R>	switchMapDelayError(Function<? superT,? extendsObservableSource<? extends R>> mapper) Returns a new ObservableSource by applying a function that you supply to each item emitted by the source ObservableSource that returns an ObservableSource, and then emitting the items emitted by the most recently emitted of these ObservableSources and delays any error until all ObservableSources terminate.
  <R> Observable<R>	switchMapDelayError(Function<? superT,? extendsObservableSource<? extends R>> mapper, int bufferSize) Returns a new ObservableSource by applying a function that you supply to each item emitted by the source ObservableSource that returns an ObservableSource, and then emitting the items emitted by the most recently emitted of these ObservableSources and delays any error until all ObservableSources terminate.
  <R> Observable<R>	switchMapMaybe(Function<? superT,? extendsMaybeSource<? extends R>> mapper) Maps the upstream items intoMaybeSources and switches (subscribes) to the newer ones while disposing the older ones (and ignoring their signals) and emits the latest success value of the current one if available while failing immediately if thisObservable or any of the active innerMaybeSources fail.
  <R> Observable<R>	switchMapMaybeDelayError(Function<? superT,? extendsMaybeSource<? extends R>> mapper) Maps the upstream items intoMaybeSources and switches (subscribes) to the newer ones while disposing the older ones (and ignoring their signals) and emits the latest success value of the current one if available, delaying errors from thisObservable or the innerMaybeSources until all terminate.
  <R> Observable<R>	switchMapSingle(Function<? superT,? extendsSingleSource<? extends R>> mapper) Returns a new ObservableSource by applying a function that you supply to each item emitted by the source ObservableSource that returns a SingleSource, and then emitting the item emitted by the most recently emitted of these SingleSources.
  <R> Observable<R>	switchMapSingleDelayError(Function<? superT,? extendsSingleSource<? extends R>> mapper) Returns a new ObservableSource by applying a function that you supply to each item emitted by the source ObservableSource that returns a SingleSource, and then emitting the item emitted by the most recently emitted of these SingleSources and delays any error until all SingleSources terminate.
  static <T> Observable<T>	switchOnNext(ObservableSource<? extendsObservableSource<? extends T>> sources) Converts an ObservableSource that emits ObservableSources into an ObservableSource that emits the items emitted by the most recently emitted of those ObservableSources.
  static <T> Observable<T>	switchOnNext(ObservableSource<? extendsObservableSource<? extends T>> sources, int bufferSize) Converts an ObservableSource that emits ObservableSources into an ObservableSource that emits the items emitted by the most recently emitted of those ObservableSources.
  static <T> Observable<T>	switchOnNextDelayError(ObservableSource<? extendsObservableSource<? extends T>> sources) Converts an ObservableSource that emits ObservableSources into an ObservableSource that emits the items emitted by the most recently emitted of those ObservableSources and delays any exception until all ObservableSources terminate.
  static <T> Observable<T>	switchOnNextDelayError(ObservableSource<? extendsObservableSource<? extends T>> sources, int prefetch) Converts an ObservableSource that emits ObservableSources into an ObservableSource that emits the items emitted by the most recently emitted of those ObservableSources and delays any exception until all ObservableSources terminate.
  Observable<T>	take(long count) Returns an Observable that emits only the firstcount items emitted by the source ObservableSource.
  Observable<T>	take(long time,TimeUnit unit) Returns an Observable that emits those items emitted by source ObservableSource before a specified time runs out.
  Observable<T>	take(long time,TimeUnit unit,Scheduler scheduler) Returns an Observable that emits those items emitted by source ObservableSource before a specified time (on a specified Scheduler) runs out.
  Observable<T>	takeLast(int count) Returns an Observable that emits at most the lastcount items emitted by the source ObservableSource.
  Observable<T>	takeLast(long count, long time,TimeUnit unit) Returns an Observable that emits at most a specified number of items from the source ObservableSource that were emitted in a specified window of time before the ObservableSource completed.
  Observable<T>	takeLast(long count, long time,TimeUnit unit,Scheduler scheduler) Returns an Observable that emits at most a specified number of items from the source ObservableSource that were emitted in a specified window of time before the ObservableSource completed, where the timing information is provided by a given Scheduler.
  Observable<T>	takeLast(long count, long time,TimeUnit unit,Scheduler scheduler, boolean delayError, int bufferSize) Returns an Observable that emits at most a specified number of items from the source ObservableSource that were emitted in a specified window of time before the ObservableSource completed, where the timing information is provided by a given Scheduler.
  Observable<T>	takeLast(long time,TimeUnit unit) Returns an Observable that emits the items from the source ObservableSource that were emitted in a specified window of time before the ObservableSource completed.
  Observable<T>	takeLast(long time,TimeUnit unit, boolean delayError) Returns an Observable that emits the items from the source ObservableSource that were emitted in a specified window of time before the ObservableSource completed.
  Observable<T>	takeLast(long time,TimeUnit unit,Scheduler scheduler) Returns an Observable that emits the items from the source ObservableSource that were emitted in a specified window of time before the ObservableSource completed, where the timing information is provided by a specified Scheduler.
  Observable<T>	takeLast(long time,TimeUnit unit,Scheduler scheduler, boolean delayError) Returns an Observable that emits the items from the source ObservableSource that were emitted in a specified window of time before the ObservableSource completed, where the timing information is provided by a specified Scheduler.
  Observable<T>	takeLast(long time,TimeUnit unit,Scheduler scheduler, boolean delayError, int bufferSize) Returns an Observable that emits the items from the source ObservableSource that were emitted in a specified window of time before the ObservableSource completed, where the timing information is provided by a specified Scheduler.
  <U> Observable<T>	takeUntil(ObservableSource<U> other) Returns an Observable that emits the items emitted by the source Observable until a second ObservableSource emits an item.
  Observable<T>	takeUntil(Predicate<? superT> stopPredicate) Returns an Observable that emits items emitted by the source Observable, checks the specified predicate for each item, and then completes when the condition is satisfied.
  Observable<T>	takeWhile(Predicate<? superT> predicate) Returns an Observable that emits items emitted by the source ObservableSource so long as each item satisfied a specified condition, and then completes as soon as this condition is not satisfied.
  TestObserver<T>	test() Creates a TestObserver and subscribes it to this Observable.
  TestObserver<T>	test(boolean dispose) Creates a TestObserver, optionally disposes it and then subscribes it to this Observable.
  Observable<T>	throttleFirst(long windowDuration,TimeUnit unit) Returns an Observable that emits only the first item emitted by the source ObservableSource during sequential time windows of a specified duration.
  Observable<T>	throttleFirst(long skipDuration,TimeUnit unit,Scheduler scheduler) Returns an Observable that emits only the first item emitted by the source ObservableSource during sequential time windows of a specified duration, where the windows are managed by a specified Scheduler.
  Observable<T>	throttleLast(long intervalDuration,TimeUnit unit) Returns an Observable that emits only the last item emitted by the source ObservableSource during sequential time windows of a specified duration.
  Observable<T>	throttleLast(long intervalDuration,TimeUnit unit,Scheduler scheduler) Returns an Observable that emits only the last item emitted by the source ObservableSource during sequential time windows of a specified duration, where the duration is governed by a specified Scheduler.
  Observable<T>	throttleLatest(long timeout,TimeUnit unit) Throttles items from the upstreamObservable by first emitting the next item from upstream, then periodically emitting the latest item (if any) when the specified timeout elapses between them.
  Observable<T>	throttleLatest(long timeout,TimeUnit unit, boolean emitLast) Throttles items from the upstreamObservable by first emitting the next item from upstream, then periodically emitting the latest item (if any) when the specified timeout elapses between them.
  Observable<T>	throttleLatest(long timeout,TimeUnit unit,Scheduler scheduler) Throttles items from the upstreamObservable by first emitting the next item from upstream, then periodically emitting the latest item (if any) when the specified timeout elapses between them.
  Observable<T>	throttleLatest(long timeout,TimeUnit unit,Scheduler scheduler, boolean emitLast) Throttles items from the upstreamObservable by first emitting the next item from upstream, then periodically emitting the latest item (if any) when the specified timeout elapses between them.
  Observable<T>	throttleWithTimeout(long timeout,TimeUnit unit) Returns an Observable that mirrors the source ObservableSource, except that it drops items emitted by the source ObservableSource that are followed by newer items before a timeout value expires.
  Observable<T>	throttleWithTimeout(long timeout,TimeUnit unit,Scheduler scheduler) Returns an Observable that mirrors the source ObservableSource, except that it drops items emitted by the source ObservableSource that are followed by newer items before a timeout value expires on a specified Scheduler.
  Observable<Timed<T>>	timeInterval() Returns an Observable that emits records of the time interval between consecutive items emitted by the source ObservableSource.
  Observable<Timed<T>>	timeInterval(Scheduler scheduler) Returns an Observable that emits records of the time interval between consecutive items emitted by the source ObservableSource, where this interval is computed on a specified Scheduler.
  Observable<Timed<T>>	timeInterval(TimeUnit unit) Returns an Observable that emits records of the time interval between consecutive items emitted by the source ObservableSource.
  Observable<Timed<T>>	timeInterval(TimeUnit unit,Scheduler scheduler) Returns an Observable that emits records of the time interval between consecutive items emitted by the source ObservableSource, where this interval is computed on a specified Scheduler.
  <V> Observable<T>	timeout(Function<? superT,? extendsObservableSource<V>> itemTimeoutIndicator) Returns an Observable that mirrors the source ObservableSource, but notifies observers of aTimeoutException if an item emitted by the source ObservableSource doesn't arrive within a window of time after the emission of the previous item, where that period of time is measured by an ObservableSource that is a function of the previous item.
  <V> Observable<T>	timeout(Function<? superT,? extendsObservableSource<V>> itemTimeoutIndicator,ObservableSource<? extendsT> other) Returns an Observable that mirrors the source ObservableSource, but that switches to a fallback ObservableSource if an item emitted by the source ObservableSource doesn't arrive within a window of time after the emission of the previous item, where that period of time is measured by an ObservableSource that is a function of the previous item.
  Observable<T>	timeout(long timeout,TimeUnit timeUnit) Returns an Observable that mirrors the source ObservableSource but applies a timeout policy for each emitted item.
  Observable<T>	timeout(long timeout,TimeUnit timeUnit,ObservableSource<? extendsT> other) Returns an Observable that mirrors the source ObservableSource but applies a timeout policy for each emitted item.
  Observable<T>	timeout(long timeout,TimeUnit timeUnit,Scheduler scheduler) Returns an Observable that mirrors the source ObservableSource but applies a timeout policy for each emitted item, where this policy is governed on a specified Scheduler.
  Observable<T>	timeout(long timeout,TimeUnit timeUnit,Scheduler scheduler,ObservableSource<? extendsT> other) Returns an Observable that mirrors the source ObservableSource but applies a timeout policy for each emitted item using a specified Scheduler.
  <U,V> Observable<T>	timeout(ObservableSource<U> firstTimeoutIndicator,Function<? superT,? extendsObservableSource<V>> itemTimeoutIndicator) Returns an Observable that mirrors the source ObservableSource, but notifies observers of aTimeoutException if either the first item emitted by the source ObservableSource or any subsequent item doesn't arrive within time windows defined by other ObservableSources.
  <U,V> Observable<T>	timeout(ObservableSource<U> firstTimeoutIndicator,Function<? superT,? extendsObservableSource<V>> itemTimeoutIndicator,ObservableSource<? extendsT> other) Returns an Observable that mirrors the source ObservableSource, but switches to a fallback ObservableSource if either the first item emitted by the source ObservableSource or any subsequent item doesn't arrive within time windows defined by other ObservableSources.
  staticObservable<Long>	timer(long delay,TimeUnit unit) Returns an Observable that emits0L after a specified delay, and then completes.
  staticObservable<Long>	timer(long delay,TimeUnit unit,Scheduler scheduler) Returns an Observable that emits0L after a specified delay, on a specified Scheduler, and then completes.
  Observable<Timed<T>>	timestamp() Returns an Observable that emits each item emitted by the source ObservableSource, wrapped in aTimed object.
  Observable<Timed<T>>	timestamp(Scheduler scheduler) Returns an Observable that emits each item emitted by the source ObservableSource, wrapped in aTimed object whose timestamps are provided by a specified Scheduler.
  Observable<Timed<T>>	timestamp(TimeUnit unit) Returns an Observable that emits each item emitted by the source ObservableSource, wrapped in aTimed object.
  Observable<Timed<T>>	timestamp(TimeUnit unit,Scheduler scheduler) Returns an Observable that emits each item emitted by the source ObservableSource, wrapped in aTimed object whose timestamps are provided by a specified Scheduler.
  <R> R	to(Function<? superObservable<T>,R> converter) Calls the specified converter function during assembly time and returns its resulting value.
  Flowable<T>	toFlowable(BackpressureStrategy strategy) Converts the current Observable into a Flowable by applying the specified backpressure strategy.
  Future<T>	toFuture() Returns aFuture representing the only value emitted by thisObservable.
  Single<List<T>>	toList() Returns a Single that emits a single item, a list composed of all the items emitted by the finite source ObservableSource.
  <U extendsCollection<? superT>> Single<U>	toList(Callable<U> collectionSupplier) Returns a Single that emits a single item, a list composed of all the items emitted by the finite source ObservableSource.
  Single<List<T>>	toList(int capacityHint) Returns a Single that emits a single item, a list composed of all the items emitted by the finite source ObservableSource.
  <K> Single<Map<K,T>>	toMap(Function<? superT,? extends K> keySelector) Returns a Single that emits a single HashMap containing all items emitted by the finite source ObservableSource, mapped by the keys returned by a specifiedkeySelector function.
  <K,V> Single<Map<K,V>>	toMap(Function<? superT,? extends K> keySelector,Function<? superT,? extends V> valueSelector) Returns a Single that emits a single HashMap containing values corresponding to items emitted by the finite source ObservableSource, mapped by the keys returned by a specifiedkeySelector function.
  <K,V> Single<Map<K,V>>	toMap(Function<? superT,? extends K> keySelector,Function<? superT,? extends V> valueSelector,Callable<? extendsMap<K,V>> mapSupplier) Returns a Single that emits a single Map, returned by a specifiedmapFactory function, that contains keys and values extracted from the items emitted by the finite source ObservableSource.
  <K> Single<Map<K,Collection<T>>>	toMultimap(Function<? superT,? extends K> keySelector) Returns a Single that emits a single HashMap that contains an ArrayList of items emitted by the finite source ObservableSource keyed by a specifiedkeySelector function.
  <K,V> Single<Map<K,Collection<V>>>	toMultimap(Function<? superT,? extends K> keySelector,Function<? superT,? extends V> valueSelector) Returns a Single that emits a single HashMap that contains an ArrayList of values extracted by a specifiedvalueSelector function from items emitted by the finite source ObservableSource, keyed by a specifiedkeySelector function.
  <K,V> Single<Map<K,Collection<V>>>	toMultimap(Function<? superT,? extends K> keySelector,Function<? superT,? extends V> valueSelector,Callable<? extendsMap<K,Collection<V>>> mapSupplier,Function<? super K,? extendsCollection<? super V>> collectionFactory) Returns a Single that emits a single Map, returned by a specifiedmapFactory function, that contains a custom collection of values, extracted by a specifiedvalueSelector function from items emitted by the source ObservableSource, and keyed by thekeySelector function.
  <K,V> Single<Map<K,Collection<V>>>	toMultimap(Function<? superT,? extends K> keySelector,Function<? superT,? extends V> valueSelector,Callable<Map<K,Collection<V>>> mapSupplier) Returns a Single that emits a single Map, returned by a specifiedmapFactory function, that contains an ArrayList of values, extracted by a specifiedvalueSelector function from items emitted by the finite source ObservableSource and keyed by thekeySelector function.
  Single<List<T>>	toSortedList() Returns a Single that emits a list that contains the items emitted by the finite source ObservableSource, in a sorted order.
  Single<List<T>>	toSortedList(Comparator<? superT> comparator) Returns a Single that emits a list that contains the items emitted by the finite source ObservableSource, in a sorted order based on a specified comparison function.
  Single<List<T>>	toSortedList(Comparator<? superT> comparator, int capacityHint) Returns a Single that emits a list that contains the items emitted by the finite source ObservableSource, in a sorted order based on a specified comparison function.
  Single<List<T>>	toSortedList(int capacityHint) Returns a Single that emits a list that contains the items emitted by the finite source ObservableSource, in a sorted order.
  static <T> Observable<T>	unsafeCreate(ObservableSource<T> onSubscribe) Create an Observable by wrapping an ObservableSourcewhich has to be implemented according to the Reactive Streams based Observable specification by handling disposal correctly; no safeguards are provided by the Observable itself.
  Observable<T>	unsubscribeOn(Scheduler scheduler) Modifies the source ObservableSource so that subscribers will dispose it on a specifiedScheduler.
  static <T,D> Observable<T>	using(Callable<? extends D> resourceSupplier,Function<? super D,? extendsObservableSource<? extends T>> sourceSupplier,Consumer<? super D> disposer) Constructs an ObservableSource that creates a dependent resource object which is disposed of when the downstream calls dispose().
  static <T,D> Observable<T>	using(Callable<? extends D> resourceSupplier,Function<? super D,? extendsObservableSource<? extends T>> sourceSupplier,Consumer<? super D> disposer, boolean eager) Constructs an ObservableSource that creates a dependent resource object which is disposed of just before termination if you have setdisposeEagerly totrue and a dispose() call does not occur before termination.
  <B> Observable<Observable<T>>	window(Callable<? extendsObservableSource<B>> boundary) Returns an Observable that emits windows of items it collects from the source ObservableSource.
  <B> Observable<Observable<T>>	window(Callable<? extendsObservableSource<B>> boundary, int bufferSize) Returns an Observable that emits windows of items it collects from the source ObservableSource.
  Observable<Observable<T>>	window(long count) Returns an Observable that emits windows of items it collects from the source ObservableSource.
  Observable<Observable<T>>	window(long count, long skip) Returns an Observable that emits windows of items it collects from the source ObservableSource.
  Observable<Observable<T>>	window(long count, long skip, int bufferSize) Returns an Observable that emits windows of items it collects from the source ObservableSource.
  Observable<Observable<T>>	window(long timespan, long timeskip,TimeUnit unit) Returns an Observable that emits windows of items it collects from the source ObservableSource.
  Observable<Observable<T>>	window(long timespan, long timeskip,TimeUnit unit,Scheduler scheduler) Returns an Observable that emits windows of items it collects from the source ObservableSource.
  Observable<Observable<T>>	window(long timespan, long timeskip,TimeUnit unit,Scheduler scheduler, int bufferSize) Returns an Observable that emits windows of items it collects from the source ObservableSource.
  Observable<Observable<T>>	window(long timespan,TimeUnit unit) Returns an Observable that emits windows of items it collects from the source ObservableSource.
  Observable<Observable<T>>	window(long timespan,TimeUnit unit, long count) Returns an Observable that emits windows of items it collects from the source ObservableSource.
  Observable<Observable<T>>	window(long timespan,TimeUnit unit, long count, boolean restart) Returns an Observable that emits windows of items it collects from the source ObservableSource.
  Observable<Observable<T>>	window(long timespan,TimeUnit unit,Scheduler scheduler) Returns an Observable that emits windows of items it collects from the source ObservableSource.
  Observable<Observable<T>>	window(long timespan,TimeUnit unit,Scheduler scheduler, long count) Returns an Observable that emits windows of items it collects from the source ObservableSource.
  Observable<Observable<T>>	window(long timespan,TimeUnit unit,Scheduler scheduler, long count, boolean restart) Returns an Observable that emits windows of items it collects from the source ObservableSource.
  Observable<Observable<T>>	window(long timespan,TimeUnit unit,Scheduler scheduler, long count, boolean restart, int bufferSize) Returns an Observable that emits windows of items it collects from the source ObservableSource.
  <B> Observable<Observable<T>>	window(ObservableSource<B> boundary) Returns an Observable that emits non-overlapping windows of items it collects from the source ObservableSource where the boundary of each window is determined by the items emitted from a specified boundary-governing ObservableSource.
  <B> Observable<Observable<T>>	window(ObservableSource<B> boundary, int bufferSize) Returns an Observable that emits non-overlapping windows of items it collects from the source ObservableSource where the boundary of each window is determined by the items emitted from a specified boundary-governing ObservableSource.
  <U,V> Observable<Observable<T>>	window(ObservableSource<U> openingIndicator,Function<? super U,? extendsObservableSource<V>> closingIndicator) Returns an Observable that emits windows of items it collects from the source ObservableSource.
  <U,V> Observable<Observable<T>>	window(ObservableSource<U> openingIndicator,Function<? super U,? extendsObservableSource<V>> closingIndicator, int bufferSize) Returns an Observable that emits windows of items it collects from the source ObservableSource.
  <R> Observable<R>	withLatestFrom(Iterable<? extendsObservableSource<?>> others,Function<? superObject[],R> combiner) Combines the value emission from this ObservableSource with the latest emissions from the other ObservableSources via a function to produce the output item.
  <R> Observable<R>	withLatestFrom(ObservableSource<?>[] others,Function<? superObject[],R> combiner) Combines the value emission from this ObservableSource with the latest emissions from the other ObservableSources via a function to produce the output item.
  <U,R> Observable<R>	withLatestFrom(ObservableSource<? extends U> other,BiFunction<? superT,? super U,? extends R> combiner) Merges the specified ObservableSource into this ObservableSource sequence by using theresultSelector function only when the source ObservableSource (this instance) emits an item.
  <T1,T2,R> Observable<R>	withLatestFrom(ObservableSource<T1> o1,ObservableSource<T2> o2,Function3<? superT,? super T1,? super T2,R> combiner) Combines the value emission from this ObservableSource with the latest emissions from the other ObservableSources via a function to produce the output item.
  <T1,T2,T3,R> Observable<R>	withLatestFrom(ObservableSource<T1> o1,ObservableSource<T2> o2,ObservableSource<T3> o3,Function4<? superT,? super T1,? super T2,? super T3,R> combiner) Combines the value emission from this ObservableSource with the latest emissions from the other ObservableSources via a function to produce the output item.
  <T1,T2,T3,T4,R> Observable<R>	withLatestFrom(ObservableSource<T1> o1,ObservableSource<T2> o2,ObservableSource<T3> o3,ObservableSource<T4> o4,Function5<? superT,? super T1,? super T2,? super T3,? super T4,R> combiner) Combines the value emission from this ObservableSource with the latest emissions from the other ObservableSources via a function to produce the output item.
  static <T> Observable<T>	wrap(ObservableSource<T> source) Wraps an ObservableSource into an Observable if not already an Observable.
  static <T,R> Observable<R>	zip(Iterable<? extendsObservableSource<? extends T>> sources,Function<? superObject[],? extends R> zipper) Returns an Observable that emits the results of a specified combiner function applied to combinations of items emitted, in sequence, by an Iterable of other ObservableSources.
  static <T,R> Observable<R>	zip(ObservableSource<? extendsObservableSource<? extends T>> sources,Function<? superObject[],? extends R> zipper) Returns an Observable that emits the results of a specified combiner function applied to combinations ofn items emitted, in sequence, by then ObservableSources emitted by a specified ObservableSource.
  static <T1,T2,R> Observable<R>	zip(ObservableSource<? extends T1> source1,ObservableSource<? extends T2> source2,BiFunction<? super T1,? super T2,? extends R> zipper) Returns an Observable that emits the results of a specified combiner function applied to combinations of two items emitted, in sequence, by two other ObservableSources.
  static <T1,T2,R> Observable<R>	zip(ObservableSource<? extends T1> source1,ObservableSource<? extends T2> source2,BiFunction<? super T1,? super T2,? extends R> zipper, boolean delayError) Returns an Observable that emits the results of a specified combiner function applied to combinations of two items emitted, in sequence, by two other ObservableSources.
  static <T1,T2,R> Observable<R>	zip(ObservableSource<? extends T1> source1,ObservableSource<? extends T2> source2,BiFunction<? super T1,? super T2,? extends R> zipper, boolean delayError, int bufferSize) Returns an Observable that emits the results of a specified combiner function applied to combinations of two items emitted, in sequence, by two other ObservableSources.
  static <T1,T2,T3,R> Observable<R>	zip(ObservableSource<? extends T1> source1,ObservableSource<? extends T2> source2,ObservableSource<? extends T3> source3,Function3<? super T1,? super T2,? super T3,? extends R> zipper) Returns an Observable that emits the results of a specified combiner function applied to combinations of three items emitted, in sequence, by three other ObservableSources.
  static <T1,T2,T3,T4,R> Observable<R>	zip(ObservableSource<? extends T1> source1,ObservableSource<? extends T2> source2,ObservableSource<? extends T3> source3,ObservableSource<? extends T4> source4,Function4<? super T1,? super T2,? super T3,? super T4,? extends R> zipper) Returns an Observable that emits the results of a specified combiner function applied to combinations of four items emitted, in sequence, by four other ObservableSources.
  static <T1,T2,T3,T4,T5,R> Observable<R>	zip(ObservableSource<? extends T1> source1,ObservableSource<? extends T2> source2,ObservableSource<? extends T3> source3,ObservableSource<? extends T4> source4,ObservableSource<? extends T5> source5,Function5<? super T1,? super T2,? super T3,? super T4,? super T5,? extends R> zipper) Returns an Observable that emits the results of a specified combiner function applied to combinations of five items emitted, in sequence, by five other ObservableSources.
  static <T1,T2,T3,T4,T5,T6,R> Observable<R>	zip(ObservableSource<? extends T1> source1,ObservableSource<? extends T2> source2,ObservableSource<? extends T3> source3,ObservableSource<? extends T4> source4,ObservableSource<? extends T5> source5,ObservableSource<? extends T6> source6,Function6<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? extends R> zipper) Returns an Observable that emits the results of a specified combiner function applied to combinations of six items emitted, in sequence, by six other ObservableSources.
  static <T1,T2,T3,T4,T5,T6,T7,R> Observable<R>	zip(ObservableSource<? extends T1> source1,ObservableSource<? extends T2> source2,ObservableSource<? extends T3> source3,ObservableSource<? extends T4> source4,ObservableSource<? extends T5> source5,ObservableSource<? extends T6> source6,ObservableSource<? extends T7> source7,Function7<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? extends R> zipper) Returns an Observable that emits the results of a specified combiner function applied to combinations of seven items emitted, in sequence, by seven other ObservableSources.
  static <T1,T2,T3,T4,T5,T6,T7,T8,R> Observable<R>	zip(ObservableSource<? extends T1> source1,ObservableSource<? extends T2> source2,ObservableSource<? extends T3> source3,ObservableSource<? extends T4> source4,ObservableSource<? extends T5> source5,ObservableSource<? extends T6> source6,ObservableSource<? extends T7> source7,ObservableSource<? extends T8> source8,Function8<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? extends R> zipper) Returns an Observable that emits the results of a specified combiner function applied to combinations of eight items emitted, in sequence, by eight other ObservableSources.
  static <T1,T2,T3,T4,T5,T6,T7,T8,T9,R> Observable<R>	zip(ObservableSource<? extends T1> source1,ObservableSource<? extends T2> source2,ObservableSource<? extends T3> source3,ObservableSource<? extends T4> source4,ObservableSource<? extends T5> source5,ObservableSource<? extends T6> source6,ObservableSource<? extends T7> source7,ObservableSource<? extends T8> source8,ObservableSource<? extends T9> source9,Function9<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? super T9,? extends R> zipper) Returns an Observable that emits the results of a specified combiner function applied to combinations of nine items emitted, in sequence, by nine other ObservableSources.
  static <T,R> Observable<R>	zipArray(Function<? superObject[],? extends R> zipper, boolean delayError, int bufferSize,ObservableSource<? extends T>... sources) Returns an Observable that emits the results of a specified combiner function applied to combinations of items emitted, in sequence, by an array of other ObservableSources.
  static <T,R> Observable<R>	zipIterable(Iterable<? extendsObservableSource<? extends T>> sources,Function<? superObject[],? extends R> zipper, boolean delayError, int bufferSize) Returns an Observable that emits the results of a specified combiner function applied to combinations of items emitted, in sequence, by an Iterable of other ObservableSources.
  <U,R> Observable<R>	zipWith(Iterable<U> other,BiFunction<? superT,? super U,? extends R> zipper) Returns an Observable that emits items that are the result of applying a specified function to pairs of values, one each from the source ObservableSource and a specified Iterable sequence.
  <U,R> Observable<R>	zipWith(ObservableSource<? extends U> other,BiFunction<? superT,? super U,? extends R> zipper) Returns an Observable that emits items that are the result of applying a specified function to pairs of values, one each from the source ObservableSource and another specified ObservableSource.
  <U,R> Observable<R>	zipWith(ObservableSource<? extends U> other,BiFunction<? superT,? super U,? extends R> zipper, boolean delayError) Returns an Observable that emits items that are the result of applying a specified function to pairs of values, one each from the source ObservableSource and another specified ObservableSource.
  <U,R> Observable<R>	zipWith(ObservableSource<? extends U> other,BiFunction<? superT,? super U,? extends R> zipper, boolean delayError, int bufferSize) Returns an Observable that emits items that are the result of applying a specified function to pairs of values, one each from the source ObservableSource and another specified ObservableSource.

  • Methods inherited from class java.lang.Object

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

• Constructor Detail

  • Observable

    public Observable()

• Method Detail

  • amb

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

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

    

    Scheduler:

    amb does not operate by default on a particularScheduler.

    Type Parameters:

    T - the common element type

    Parameters:

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

    Returns:

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

    See Also:

    ReactiveX operators documentation: Amb

  • ambArray

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

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

    

    Scheduler:

    ambArray does not operate by default on a particularScheduler.

    Type Parameters:

    T - the common element type

    Parameters:

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

    Returns:

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

    See Also:

    ReactiveX operators documentation: Amb

  • bufferSize

    public static int bufferSize()

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

    Delegates toFlowable.bufferSize() but is public for convenience.

    The value can be overridden via system parameterrx2.buffer-sizebefore theFlowable class is loaded.

    Returns:

    the default 'island' size or capacity-increment hint

  • combineLatest

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

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

    Note on method signature: since Java doesn't allow creating a generic array withnew T[], the implementation of this operator has to create anObject[] instead. Unfortunately, aFunction<Integer[], R> passed to the method would trigger aClassCastException.

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

    If there are no ObservableSources provided, the resulting sequence completes immediately without emitting any items and without any calls to the combiner function.

    

    Scheduler:

    combineLatest does not operate by default on a particularScheduler.

    Type Parameters:

    T - the common base type of source values

    R - the result type

    Parameters:

    sources - the collection of source ObservableSources

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

    bufferSize - the internal buffer size and prefetch amount applied to every source Observable

    Returns:

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

    See Also:

    ReactiveX operators documentation: CombineLatest

  • combineLatest

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

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

    Note on method signature: since Java doesn't allow creating a generic array withnew T[], the implementation of this operator has to create anObject[] instead. Unfortunately, aFunction<Integer[], R> passed to the method would trigger aClassCastException.

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

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

    

    Scheduler:

    combineLatest does not operate by default on a particularScheduler.

    Type Parameters:

    T - the common base type of source values

    R - the result type

    Parameters:

    sources - the collection of source ObservableSources

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

    Returns:

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

    See Also:

    ReactiveX operators documentation: CombineLatest

  • combineLatest

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

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

    Note on method signature: since Java doesn't allow creating a generic array withnew T[], the implementation of this operator has to create anObject[] instead. Unfortunately, aFunction<Integer[], R> passed to the method would trigger aClassCastException.

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

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

    

    Scheduler:

    combineLatest does not operate by default on a particularScheduler.

    Type Parameters:

    T - the common base type of source values

    R - the result type

    Parameters:

    sources - the collection of source ObservableSources

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

    bufferSize - the internal buffer size and prefetch amount applied to every source Observable

    Returns:

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

    See Also:

    ReactiveX operators documentation: CombineLatest

  • combineLatest

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

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

    Note on method signature: since Java doesn't allow creating a generic array withnew T[], the implementation of this operator has to create anObject[] instead. Unfortunately, aFunction<Integer[], R> passed to the method would trigger aClassCastException.

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

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

    

    Scheduler:

    combineLatest does not operate by default on a particularScheduler.

    Type Parameters:

    T - the common base type of source values

    R - the result type

    Parameters:

    sources - the collection of source ObservableSources

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

    Returns:

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

    See Also:

    ReactiveX operators documentation: CombineLatest

  • combineLatest

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

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

    Note on method signature: since Java doesn't allow creating a generic array withnew T[], the implementation of this operator has to create anObject[] instead. Unfortunately, aFunction<Integer[], R> passed to the method would trigger aClassCastException.

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

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

    

    Scheduler:

    combineLatest does not operate by default on a particularScheduler.

    Type Parameters:

    T - the common base type of source values

    R - the result type

    Parameters:

    sources - the collection of source ObservableSources

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

    bufferSize - the internal buffer size and prefetch amount applied to every source Observable

    Returns:

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

    See Also:

    ReactiveX operators documentation: CombineLatest

  • combineLatest

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

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

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

    

    Scheduler:

    combineLatest does not operate by default on a particularScheduler.

    Type Parameters:

    T1 - the element type of the first source

    T2 - the element type of the second source

    R - the combined output type

    Parameters:

    source1 - the first source ObservableSource

    source2 - the second source ObservableSource

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

    Returns:

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

    See Also:

    ReactiveX operators documentation: CombineLatest

  • combineLatest

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

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

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

    

    Scheduler:

    combineLatest does not operate by default on a particularScheduler.

    Type Parameters:

    T1 - the element type of the first source

    T2 - the element type of the second source

    T3 - the element type of the third source

    R - the combined output type

    Parameters:

    source1 - the first source ObservableSource

    source2 - the second source ObservableSource

    source3 - the third source ObservableSource

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

    Returns:

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

    See Also:

    ReactiveX operators documentation: CombineLatest

  • combineLatest

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

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

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

    

    Scheduler:

    combineLatest does not operate by default on a particularScheduler.

    Type Parameters:

    T1 - the element type of the first source

    T2 - the element type of the second source

    T3 - the element type of the third source

    T4 - the element type of the fourth source

    R - the combined output type

    Parameters:

    source1 - the first source ObservableSource

    source2 - the second source ObservableSource

    source3 - the third source ObservableSource

    source4 - the fourth source ObservableSource

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

    Returns:

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

    See Also:

    ReactiveX operators documentation: CombineLatest

  • combineLatest

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

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

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

    

    Scheduler:

    combineLatest does not operate by default on a particularScheduler.

    Type Parameters:

    T1 - the element type of the first source

    T2 - the element type of the second source

    T3 - the element type of the third source

    T4 - the element type of the fourth source

    T5 - the element type of the fifth source

    R - the combined output type

    Parameters:

    source1 - the first source ObservableSource

    source2 - the second source ObservableSource

    source3 - the third source ObservableSource

    source4 - the fourth source ObservableSource

    source5 - the fifth source ObservableSource

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

    Returns:

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

    See Also:

    ReactiveX operators documentation: CombineLatest

  • combineLatest

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

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

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

    

    Scheduler:

    combineLatest does not operate by default on a particularScheduler.

    Type Parameters:

    T1 - the element type of the first source

    T2 - the element type of the second source

    T3 - the element type of the third source

    T4 - the element type of the fourth source

    T5 - the element type of the fifth source

    T6 - the element type of the sixth source

    R - the combined output type

    Parameters:

    source1 - the first source ObservableSource

    source2 - the second source ObservableSource

    source3 - the third source ObservableSource

    source4 - the fourth source ObservableSource

    source5 - the fifth source ObservableSource

    source6 - the sixth source ObservableSource

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

    Returns:

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

    See Also:

    ReactiveX operators documentation: CombineLatest

  • combineLatest

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

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

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

    

    Scheduler:

    combineLatest does not operate by default on a particularScheduler.

    Type Parameters:

    T1 - the element type of the first source

    T2 - the element type of the second source

    T3 - the element type of the third source

    T4 - the element type of the fourth source

    T5 - the element type of the fifth source

    T6 - the element type of the sixth source

    T7 - the element type of the seventh source

    R - the combined output type

    Parameters:

    source1 - the first source ObservableSource

    source2 - the second source ObservableSource

    source3 - the third source ObservableSource

    source4 - the fourth source ObservableSource

    source5 - the fifth source ObservableSource

    source6 - the sixth source ObservableSource

    source7 - the seventh source ObservableSource

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

    Returns:

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

    See Also:

    ReactiveX operators documentation: CombineLatest

  • combineLatest

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

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

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

    

    Scheduler:

    combineLatest does not operate by default on a particularScheduler.

    Type Parameters:

    T1 - the element type of the first source

    T2 - the element type of the second source

    T3 - the element type of the third source

    T4 - the element type of the fourth source

    T5 - the element type of the fifth source

    T6 - the element type of the sixth source

    T7 - the element type of the seventh source

    T8 - the element type of the eighth source

    R - the combined output type

    Parameters:

    source1 - the first source ObservableSource

    source2 - the second source ObservableSource

    source3 - the third source ObservableSource

    source4 - the fourth source ObservableSource

    source5 - the fifth source ObservableSource

    source6 - the sixth source ObservableSource

    source7 - the seventh source ObservableSource

    source8 - the eighth source ObservableSource

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

    Returns:

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

    See Also:

    ReactiveX operators documentation: CombineLatest

  • combineLatest

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

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

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

    

    Scheduler:

    combineLatest does not operate by default on a particularScheduler.

    Type Parameters:

    T1 - the element type of the first source

    T2 - the element type of the second source

    T3 - the element type of the third source

    T4 - the element type of the fourth source

    T5 - the element type of the fifth source

    T6 - the element type of the sixth source

    T7 - the element type of the seventh source

    T8 - the element type of the eighth source

    T9 - the element type of the ninth source

    R - the combined output type

    Parameters:

    source1 - the first source ObservableSource

    source2 - the second source ObservableSource

    source3 - the third source ObservableSource

    source4 - the fourth source ObservableSource

    source5 - the fifth source ObservableSource

    source6 - the sixth source ObservableSource

    source7 - the seventh source ObservableSource

    source8 - the eighth source ObservableSource

    source9 - the ninth source ObservableSource

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

    Returns:

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

    See Also:

    ReactiveX operators documentation: CombineLatest

  • combineLatestDelayError

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

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

    

    Note on method signature: since Java doesn't allow creating a generic array withnew T[], the implementation of this operator has to create anObject[] instead. Unfortunately, aFunction<Integer[], R> passed to the method would trigger aClassCastException.

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

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

    Scheduler:

    combineLatestDelayError does not operate by default on a particularScheduler.

    Type Parameters:

    T - the common base type of source values

    R - the result type

    Parameters:

    sources - the collection of source ObservableSources

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

    Returns:

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

    See Also:

    ReactiveX operators documentation: CombineLatest

  • combineLatestDelayError

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

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

    

    Note on method signature: since Java doesn't allow creating a generic array withnew T[], the implementation of this operator has to create anObject[] instead. Unfortunately, aFunction<Integer[], R> passed to the method would trigger aClassCastException.

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

    If there are no ObservableSources provided, the resulting sequence completes immediately without emitting any items and without any calls to the combiner function.

    Scheduler:

    combineLatestDelayError does not operate by default on a particularScheduler.

    Type Parameters:

    T - the common base type of source values

    R - the result type

    Parameters:

    sources - the collection of source ObservableSources

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

    bufferSize - the internal buffer size and prefetch amount applied to every source Observable

    Returns:

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

    See Also:

    ReactiveX operators documentation: CombineLatest

  • combineLatestDelayError

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

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

    Note on method signature: since Java doesn't allow creating a generic array withnew T[], the implementation of this operator has to create anObject[] instead. Unfortunately, aFunction<Integer[], R> passed to the method would trigger aClassCastException.

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

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

    

    Scheduler:

    combineLatestDelayError does not operate by default on a particularScheduler.

    Type Parameters:

    T - the common base type of source values

    R - the result type

    Parameters:

    sources - the collection of source ObservableSources

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

    bufferSize - the internal buffer size and prefetch amount applied to every source Observable

    Returns:

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

    See Also:

    ReactiveX operators documentation: CombineLatest

  • combineLatestDelayError

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

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

    Note on method signature: since Java doesn't allow creating a generic array withnew T[], the implementation of this operator has to create anObject[] instead. Unfortunately, aFunction<Integer[], R> passed to the method would trigger aClassCastException.

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

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

    

    Scheduler:

    combineLatestDelayError does not operate by default on a particularScheduler.

    Type Parameters:

    T - the common base type of source values

    R - the result type

    Parameters:

    sources - the collection of source ObservableSources

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

    Returns:

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

    See Also:

    ReactiveX operators documentation: CombineLatest

  • combineLatestDelayError

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

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

    Note on method signature: since Java doesn't allow creating a generic array withnew T[], the implementation of this operator has to create anObject[] instead. Unfortunately, aFunction<Integer[], R> passed to the method would trigger aClassCastException.

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

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

    

    Scheduler:

    combineLatestDelayError does not operate by default on a particularScheduler.

    Type Parameters:

    T - the common base type of source values

    R - the result type

    Parameters:

    sources - the collection of source ObservableSources

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

    bufferSize - the internal buffer size and prefetch amount applied to every source Observable

    Returns:

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

    See Also:

    ReactiveX operators documentation: CombineLatest

  • concat

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

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

    

    Scheduler:

    concat does not operate by default on a particularScheduler.

    Type Parameters:

    T - the common value type of the sources

    Parameters:

    sources - the Iterable sequence of ObservableSources

    Returns:

    the new Observable instance

  • concat

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

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

    

    Scheduler:

    concat does not operate by default on a particularScheduler.

    Type Parameters:

    T - the common element base type

    Parameters:

    sources - an ObservableSource that emits ObservableSources

    Returns:

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

    See Also:

    ReactiveX operators documentation: Concat

  • concat

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

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

    

    Scheduler:

    concat does not operate by default on a particularScheduler.

    Type Parameters:

    T - the common element base type

    Parameters:

    sources - an ObservableSource that emits ObservableSources

    prefetch - the number of ObservableSources to prefetch from the sources sequence.

    Returns:

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

    See Also:

    ReactiveX operators documentation: Concat

  • concat

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

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

    

    Scheduler:

    concat does not operate by default on a particularScheduler.

    Type Parameters:

    T - the common element base type

    Parameters:

    source1 - an ObservableSource to be concatenated

    source2 - an ObservableSource to be concatenated

    Returns:

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

    See Also:

    ReactiveX operators documentation: Concat

  • concat

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

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

    

    Scheduler:

    concat does not operate by default on a particularScheduler.

    Type Parameters:

    T - the common element base type

    Parameters:

    source1 - an ObservableSource to be concatenated

    source2 - an ObservableSource to be concatenated

    source3 - an ObservableSource to be concatenated

    Returns:

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

    See Also:

    ReactiveX operators documentation: Concat

  • concat

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

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

    

    Scheduler:

    concat does not operate by default on a particularScheduler.

    Type Parameters:

    T - the common element base type

    Parameters:

    source1 - an ObservableSource to be concatenated

    source2 - an ObservableSource to be concatenated

    source3 - an ObservableSource to be concatenated

    source4 - an ObservableSource to be concatenated

    Returns:

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

    See Also:

    ReactiveX operators documentation: Concat

  • concatArray

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

    Concatenates a variable number of ObservableSource sources.

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

    

    Scheduler:

    concatArray does not operate by default on a particularScheduler.

    Type Parameters:

    T - the common base value type

    Parameters:

    sources - the array of sources

    Returns:

    the new Observable instance

    Throws:

    NullPointerException - if sources is null

  • concatArrayDelayError

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

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

    

    Scheduler:

    concatArrayDelayError does not operate by default on a particularScheduler.

    Type Parameters:

    T - the common base value type

    Parameters:

    sources - the array of sources

    Returns:

    the new Observable instance

    Throws:

    NullPointerException - if sources is null

  • concatArrayEager

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

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

    

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

    Scheduler:

    This method does not operate by default on a particularScheduler.

    Type Parameters:

    T - the value type

    Parameters:

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

    Returns:

    the new ObservableSource instance with the specified concatenation behavior

    Since:

    2.0

  • concatArrayEager

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

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

    

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

    Scheduler:

    This method does not operate by default on a particularScheduler.

    Type Parameters:

    T - the value type

    Parameters:

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

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

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

    Returns:

    the new ObservableSource instance with the specified concatenation behavior

    Since:

    2.0

  • concatArrayEagerDelayError

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

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

    

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

    Scheduler:

    This method does not operate by default on a particularScheduler.

    Type Parameters:

    T - the value type

    Parameters:

    sources - an array ofObservableSources that need to be eagerly concatenated

    Returns:

    the new Observable instance with the specified concatenation behavior

    Since:

    2.2.1 - experimental

  • concatArrayEagerDelayError

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

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

    

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

    Scheduler:

    This method does not operate by default on a particularScheduler.

    Type Parameters:

    T - the value type

    Parameters:

    sources - an array ofObservableSources that need to be eagerly concatenated

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

    prefetch - the number of elements to prefetch from eachObservableSource source

    Returns:

    the new Observable instance with the specified concatenation behavior

    Since:

    2.2.1 - experimental

  • concatDelayError

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

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

    

    Scheduler:

    concatDelayError does not operate by default on a particularScheduler.

    Type Parameters:

    T - the common element base type

    Parameters:

    sources - the Iterable sequence of ObservableSources

    Returns:

    the new ObservableSource with the concatenating behavior

  • concatDelayError

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

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

    

    Scheduler:

    concatDelayError does not operate by default on a particularScheduler.

    Type Parameters:

    T - the common element base type

    Parameters:

    sources - the ObservableSource sequence of ObservableSources

    Returns:

    the new ObservableSource with the concatenating behavior

  • concatDelayError

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

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

    

    Scheduler:

    concatDelayError does not operate by default on a particularScheduler.

    Type Parameters:

    T - the common element base type

    Parameters:

    sources - the ObservableSource sequence of ObservableSources

    prefetch - the number of elements to prefetch from the outer ObservableSource

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

    Returns:

    the new ObservableSource with the concatenating behavior

  • concatEager

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

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

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

    

    Scheduler:

    This method does not operate by default on a particularScheduler.

    Type Parameters:

    T - the value type

    Parameters:

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

    Returns:

    the new ObservableSource instance with the specified concatenation behavior

    Since:

    2.0

  • concatEager

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

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

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

    

    Scheduler:

    This method does not operate by default on a particularScheduler.

    Type Parameters:

    T - the value type

    Parameters:

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

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

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

    Returns:

    the new ObservableSource instance with the specified concatenation behavior

    Since:

    2.0

  • concatEager

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

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

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

    

    Scheduler:

    This method does not operate by default on a particularScheduler.

    Type Parameters:

    T - the value type

    Parameters:

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

    Returns:

    the new ObservableSource instance with the specified concatenation behavior

    Since:

    2.0

  • concatEager

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

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

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

    

    Scheduler:

    This method does not operate by default on a particularScheduler.

    Type Parameters:

    T - the value type

    Parameters:

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

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

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

    Returns:

    the new ObservableSource instance with the specified concatenation behavior

    Since:

    2.0

  • create

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

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

    Example:

     Observable.<Event>create(emitter -> {     Callback listener = new Callback() {         @Override         public void onEvent(Event e) {             emitter.onNext(e);             if (e.isLast()) {                 emitter.onComplete();             }         }         @Override         public void onFailure(Exception e) {             emitter.onError(e);         }     };     AutoCloseable c = api.someMethod(listener);     emitter.setCancellable(c::close); });

    

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

    Scheduler:

    create does not operate by default on a particularScheduler.

    Type Parameters:

    T - the element type

    Parameters:

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

    Returns:

    the new Observable instance

    See Also:

    ObservableOnSubscribe,ObservableEmitter,Cancellable

  • defer

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

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

    

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

    Scheduler:

    defer does not operate by default on a particularScheduler.

    Type Parameters:

    T - the type of the items emitted by the ObservableSource

    Parameters:

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

    Returns:

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

    See Also:

    ReactiveX operators documentation: Defer

  • empty

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

    Returns an Observable that emits no items to theObserver and immediately invokes itsonComplete method.

    

    Scheduler:

    empty does not operate by default on a particularScheduler.

    Type Parameters:

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

    Returns:

    an Observable that emits no items to theObserver but immediately invokes theObserver'sonComplete method

    See Also:

    ReactiveX operators documentation: Empty

  • error

    @CheckReturnValue@NonNull@SchedulerSupport(value="none")public static <T> Observable<T> error(Callable<? extendsThrowable> errorSupplier)

    Returns an Observable that invokes anObserver'sonError method when the Observer subscribes to it.

    

    Scheduler:

    error does not operate by default on a particularScheduler.

    Type Parameters:

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

    Parameters:

    errorSupplier - a Callable factory to return a Throwable for each individual Observer

    Returns:

    an Observable that invokes theObserver'sonError method when the Observer subscribes to it

    See Also:

    ReactiveX operators documentation: Throw

  • error

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

    Returns an Observable that invokes anObserver'sonError method when the Observer subscribes to it.

    

    Scheduler:

    error does not operate by default on a particularScheduler.

    Type Parameters:

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

    Parameters:

    exception - the particular Throwable to pass toonError

    Returns:

    an Observable that invokes theObserver'sonError method when the Observer subscribes to it

    See Also:

    ReactiveX operators documentation: Throw

  • fromArray

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

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

    

    Scheduler:

    fromArray does not operate by default on a particularScheduler.

    Type Parameters:

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

    Parameters:

    items - the array of elements

    Returns:

    an Observable that emits each item in the source Array

    See Also:

    ReactiveX operators documentation: From

  • fromCallable

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

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

    

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

    Scheduler:

    fromCallable does not operate by default on a particularScheduler.

    Error handling:

    If theCallable throws an exception, the respectiveThrowable is delivered to the downstream viaObserver.onError(Throwable), except when the downstream has disposed thisObservable source. In this latter case, theThrowable is delivered to the global error handler viaRxJavaPlugins.onError(Throwable) as anUndeliverableException.

    Type Parameters:

    T - the type of the item emitted by the ObservableSource

    Parameters:

    supplier - a function, the execution of which should be deferred;fromCallable will invoke this function only when an observer subscribes to the ObservableSource thatfromCallable returns

    Returns:

    an Observable whoseObservers' subscriptions trigger an invocation of the given function

    Since:

    2.0

    See Also:

    defer(Callable)

  • fromFuture

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

    Converts aFuture into an ObservableSource.

    

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

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

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

    Scheduler:

    fromFuture does not operate by default on a particularScheduler.

    Type Parameters:

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

    Parameters:

    future - the sourceFuture

    Returns:

    an Observable that emits the item from the sourceFuture

    See Also:

    ReactiveX operators documentation: From

  • fromFuture

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

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

    

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

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

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

    Scheduler:

    fromFuture does not operate by default on a particularScheduler.

    Type Parameters:

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

    Parameters:

    future - the sourceFuture

    timeout - the maximum time to wait before callingget

    unit - theTimeUnit of thetimeout argument

    Returns:

    an Observable that emits the item from the sourceFuture

    See Also:

    ReactiveX operators documentation: From

  • fromFuture

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

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

    

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

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

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

    Scheduler:

    fromFuture does not operate by default on a particularScheduler.

    Type Parameters:

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

    Parameters:

    future - the sourceFuture

    timeout - the maximum time to wait before callingget

    unit - theTimeUnit of thetimeout argument

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

    Returns:

    an Observable that emits the item from the sourceFuture

    See Also:

    ReactiveX operators documentation: From

  • fromFuture

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

    Converts aFuture, operating on a specifiedScheduler, into an ObservableSource.

    

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

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

    Scheduler:

    You specify whichScheduler this operator will use.

    Type Parameters:

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

    Parameters:

    future - the sourceFuture

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

    Returns:

    an Observable that emits the item from the sourceFuture

    See Also:

    ReactiveX operators documentation: From

  • fromIterable

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

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

    

    Scheduler:

    fromIterable does not operate by default on a particularScheduler.

    Type Parameters:

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

    Parameters:

    source - the sourceIterable sequence

    Returns:

    an Observable that emits each item in the sourceIterable sequence

    See Also:

    ReactiveX operators documentation: From

  • fromPublisher

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

    Converts an arbitrary Reactive Streams Publisher into an Observable.

    

    ThePublisher must follow theReactive Streams specification. Violating the specification may result in undefined behavior.

    If possible, usecreate(ObservableOnSubscribe) to create a source-likeObservable instead.

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

    Backpressure:

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

    Scheduler:

    fromPublisher does not operate by default on a particularScheduler.

    Type Parameters:

    T - the value type of the flow

    Parameters:

    publisher - the Publisher to convert

    Returns:

    the new Observable instance

    Throws:

    NullPointerException - if publisher is null

    See Also:

    create(ObservableOnSubscribe)

  • generate

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

    Returns a cold, synchronous and stateless generator of values.

    

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

    Scheduler:

    generate does not operate by default on a particularScheduler.

    Type Parameters:

    T - the generated value type

    Parameters:

    generator - the Consumer called whenever a particular downstream Observer has requested a value. The callback then should callonNext,onError oronComplete to signal a value or a terminal event. Signalling multipleonNext in a call will make the operator signalIllegalStateException.

    Returns:

    the new Observable instance

  • generate

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

    Returns a cold, synchronous and stateful generator of values.

    

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

    Scheduler:

    generate does not operate by default on a particularScheduler.

    Type Parameters:

    S - the type of the per-Observer state

    T - the generated value type

    Parameters:

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

    generator - the Consumer called with the current state whenever a particular downstream Observer has requested a value. The callback then should callonNext,onError oronComplete to signal a value or a terminal event. Signalling multipleonNext in a call will make the operator signalIllegalStateException.

    Returns:

    the new Observable instance

  • generate

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

    Returns a cold, synchronous and stateful generator of values.

    

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

    Scheduler:

    generate does not operate by default on a particularScheduler.

    Type Parameters:

    S - the type of the per-Observer state

    T - the generated value type

    Parameters:

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

    generator - the Consumer called with the current state whenever a particular downstream Observer has requested a value. The callback then should callonNext,onError oronComplete to signal a value or a terminal event. Signalling multipleonNext in a call will make the operator signalIllegalStateException.

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

    Returns:

    the new Observable instance

  • generate

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

    Returns a cold, synchronous and stateful generator of values.

    

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

    Scheduler:

    generate does not operate by default on a particularScheduler.

    Type Parameters:

    S - the type of the per-Observer state

    T - the generated value type

    Parameters:

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

    generator - the Function called with the current state whenever a particular downstream Observer has requested a value. The callback then should callonNext,onError oronComplete to signal a value or a terminal event and should return a (new) state for the next invocation. Signalling multipleonNext in a call will make the operator signalIllegalStateException.

    Returns:

    the new Observable instance

  • generate

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

    Returns a cold, synchronous and stateful generator of values.

    

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

    Scheduler:

    generate does not operate by default on a particularScheduler.

    Type Parameters:

    S - the type of the per-Observer state

    T - the generated value type

    Parameters:

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

    generator - the Function called with the current state whenever a particular downstream Observer has requested a value. The callback then should callonNext,onError oronComplete to signal a value or a terminal event and should return a (new) state for the next invocation. Signalling multipleonNext in a call will make the operator signalIllegalStateException.

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

    Returns:

    the new Observable instance

  • interval

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

    Returns an Observable that emits a0L after theinitialDelay and ever increasing numbers after eachperiod of time thereafter.

    

    Scheduler:

    interval operates by default on thecomputationScheduler.

    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 bothinitialDelay andperiod

    Returns:

    an Observable that emits a 0L after theinitialDelay and ever increasing numbers after eachperiod of time thereafter

    Since:

    1.0.12

    See Also:

    ReactiveX operators documentation: Interval

  • interval

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

    Returns an Observable that emits a0L after theinitialDelay and ever increasing numbers after eachperiod of time thereafter, on a specifiedScheduler.

    

    Scheduler:

    You specify whichScheduler 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 bothinitialDelay andperiod

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

    Returns:

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

    Since:

    1.0.12

    See Also:

    ReactiveX operators documentation: Interval

  • interval

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

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

    

    Scheduler:

    interval operates by default on thecomputationScheduler.

    Parameters:

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

    unit - time units to use for the interval size

    Returns:

    an Observable that emits a sequential number each time interval

    See Also:

    ReactiveX operators documentation: Interval

  • interval

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

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

    

    Scheduler:

    You specify whichScheduler this operator will use.

    Parameters:

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

    unit - time units to use for the interval size

    scheduler - the Scheduler to use for scheduling the items

    Returns:

    an Observable that emits a sequential number each time interval

    See Also:

    ReactiveX operators documentation: Interval

  • intervalRange

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

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

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

    

    Scheduler:

    intervalRange by default operates on thecomputationScheduler.

    Parameters:

    start - that start value of the range

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

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

    period - the period between subsequent values

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

    Returns:

    the new Observable instance

  • intervalRange

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

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

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

    *

    Scheduler:

    you provide theScheduler.

    Parameters:

    start - that start value of the range

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

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

    period - the period between subsequent values

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

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

    Returns:

    the new Observable instance

  • just

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

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

    

    Note that the item is taken and re-emitted as is and not computed by any means byjust. UsefromCallable(Callable) to generate a single item on demand (whenObservers subscribe to it).

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

    To emit the items of anIterable sequence (such as aList), usefromIterable(Iterable).

    Scheduler:

    just does not operate by default on a particularScheduler.

    Type Parameters:

    T - the type of that item

    Parameters:

    item - the item to emit

    Returns:

    an Observable that emitsvalue as a single item and then completes

    See Also:

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

  • just

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

    Converts two items into an ObservableSource that emits those items.

    

    Scheduler:

    just does not operate by default on a particularScheduler.

    Type Parameters:

    T - the type of these items

    Parameters:

    item1 - first item

    item2 - second item

    Returns:

    an Observable that emits each item

    See Also:

    ReactiveX operators documentation: Just

  • just

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

    Converts three items into an ObservableSource that emits those items.

    

    Scheduler:

    just does not operate by default on a particularScheduler.

    Type Parameters:

    T - the type of these items

    Parameters:

    item1 - first item

    item2 - second item

    item3 - third item

    Returns:

    an Observable that emits each item

    See Also:

    ReactiveX operators documentation: Just

  • just

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

    Converts four items into an ObservableSource that emits those items.

    

    Scheduler:

    just does not operate by default on a particularScheduler.

    Type Parameters:

    T - the type of these items

    Parameters:

    item1 - first item

    item2 - second item

    item3 - third item

    item4 - fourth item

    Returns:

    an Observable that emits each item

    See Also:

    ReactiveX operators documentation: Just

  • just

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

    Converts five items into an ObservableSource that emits those items.

    

    Scheduler:

    just does not operate by default on a particularScheduler.

    Type Parameters:

    T - the type of these items

    Parameters:

    item1 - first item

    item2 - second item

    item3 - third item

    item4 - fourth item

    item5 - fifth item

    Returns:

    an Observable that emits each item

    See Also:

    ReactiveX operators documentation: Just

  • just

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

    Converts six items into an ObservableSource that emits those items.

    

    Scheduler:

    just does not operate by default on a particularScheduler.

    Type Parameters:

    T - the type of these items

    Parameters:

    item1 - first item

    item2 - second item

    item3 - third item

    item4 - fourth item

    item5 - fifth item

    item6 - sixth item

    Returns:

    an Observable that emits each item

    See Also:

    ReactiveX operators documentation: Just

  • just

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

    Converts seven items into an ObservableSource that emits those items.

    

    Scheduler:

    just does not operate by default on a particularScheduler.

    Type Parameters:

    T - the type of these items

    Parameters:

    item1 - first item

    item2 - second item

    item3 - third item

    item4 - fourth item

    item5 - fifth item

    item6 - sixth item

    item7 - seventh item

    Returns:

    an Observable that emits each item

    See Also:

    ReactiveX operators documentation: Just

  • just

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

    Converts eight items into an ObservableSource that emits those items.

    

    Scheduler:

    just does not operate by default on a particularScheduler.

    Type Parameters:

    T - the type of these items

    Parameters:

    item1 - first item

    item2 - second item

    item3 - third item

    item4 - fourth item

    item5 - fifth item

    item6 - sixth item

    item7 - seventh item

    item8 - eighth item

    Returns:

    an Observable that emits each item

    See Also:

    ReactiveX operators documentation: Just

  • just

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

    Converts nine items into an ObservableSource that emits those items.

    

    Scheduler:

    just does not operate by default on a particularScheduler.

    Type Parameters:

    T - the type of these items

    Parameters:

    item1 - first item

    item2 - second item

    item3 - third item

    item4 - fourth item

    item5 - fifth item

    item6 - sixth item

    item7 - seventh item

    item8 - eighth item

    item9 - ninth item

    Returns:

    an Observable that emits each item

    See Also:

    ReactiveX operators documentation: Just

  • just

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

    Converts ten items into an ObservableSource that emits those items.

    

    Scheduler:

    just does not operate by default on a particularScheduler.

    Type Parameters:

    T - the type of these items

    Parameters:

    item1 - first item

    item2 - second item

    item3 - third item

    item4 - fourth item

    item5 - fifth item

    item6 - sixth item

    item7 - seventh item

    item8 - eighth item

    item9 - ninth item

    item10 - tenth item

    Returns:

    an Observable that emits each item

    See Also:

    ReactiveX operators documentation: Just

  • merge

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

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

    

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

    Scheduler:

    merge does not operate by default on a particularScheduler.

    Error handling:

    If any of the sourceObservableSources signal aThrowable viaonError, the resultingObservable terminates with thatThrowable and all other sourceObservableSources are disposed. If more than oneObservableSource signals an error, the resultingObservable may terminate with the first one's error or, depending on the concurrency of the sources, may terminate with aCompositeException containing two or more of the various error signals.Throwables that didn't make into the composite will be sent (individually) to the global error handler viaRxJavaPlugins.onError(Throwable) method asUndeliverableException errors. Similarly,Throwables signaled by source(s) after the returnedObservable has been disposed or terminated with a (composite) error will be sent to the same global error handler. UsemergeDelayError(Iterable, int, int) to merge sources and terminate only when all sourceObservableSources have completed or failed with an error.

    Type Parameters:

    T - the common element base type

    Parameters:

    sources - the Iterable of ObservableSources

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

    bufferSize - the number of items to prefetch from each inner ObservableSource

    Returns:

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

    Throws:

    IllegalArgumentException - ifmaxConcurrent is less than or equal to 0

    See Also:

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

  • mergeArray

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

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

    

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

    Scheduler:

    mergeArray does not operate by default on a particularScheduler.

    Error handling:

    If any of the sourceObservableSources signal aThrowable viaonError, the resultingObservable terminates with thatThrowable and all other sourceObservableSources are disposed. If more than oneObservableSource signals an error, the resultingObservable may terminate with the first one's error or, depending on the concurrency of the sources, may terminate with aCompositeException containing two or more of the various error signals.Throwables that didn't make into the composite will be sent (individually) to the global error handler viaRxJavaPlugins.onError(Throwable) method asUndeliverableException errors. Similarly,Throwables signaled by source(s) after the returnedObservable has been disposed or terminated with a (composite) error will be sent to the same global error handler. UsemergeArrayDelayError(int, int, ObservableSource...) to merge sources and terminate only when all sourceObservableSources have completed or failed with an error.

    Type Parameters:

    T - the common element base type

    Parameters:

    sources - the array of ObservableSources

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

    bufferSize - the number of items to prefetch from each inner ObservableSource

    Returns:

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

    Throws:

    IllegalArgumentException - ifmaxConcurrent is less than or equal to 0

    See Also:

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

  • merge

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

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

    

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

    Scheduler:

    merge does not operate by default on a particularScheduler.

    Error handling:

    If any of the sourceObservableSources signal aThrowable viaonError, the resultingObservable terminates with thatThrowable and all other sourceObservableSources are disposed. If more than oneObservableSource signals an error, the resultingObservable may terminate with the first one's error or, depending on the concurrency of the sources, may terminate with aCompositeException containing two or more of the various error signals.Throwables that didn't make into the composite will be sent (individually) to the global error handler viaRxJavaPlugins.onError(Throwable) method asUndeliverableException errors. Similarly,Throwables signaled by source(s) after the returnedObservable has been disposed or terminated with a (composite) error will be sent to the same global error handler. UsemergeDelayError(Iterable) to merge sources and terminate only when all sourceObservableSources have completed or failed with an error.

    Type Parameters:

    T - the common element base type

    Parameters:

    sources - the Iterable of ObservableSources

    Returns:

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

    See Also:

    ReactiveX operators documentation: Merge,mergeDelayError(Iterable)

  • merge

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

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

    

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

    Scheduler:

    merge does not operate by default on a particularScheduler.

    Error handling:

    If any of the sourceObservableSources signal aThrowable viaonError, the resultingObservable terminates with thatThrowable and all other sourceObservableSources are disposed. If more than oneObservableSource signals an error, the resultingObservable may terminate with the first one's error or, depending on the concurrency of the sources, may terminate with aCompositeException containing two or more of the various error signals.Throwables that didn't make into the composite will be sent (individually) to the global error handler viaRxJavaPlugins.onError(Throwable) method asUndeliverableException errors. Similarly,Throwables signaled by source(s) after the returnedObservable has been disposed or terminated with a (composite) error will be sent to the same global error handler. UsemergeDelayError(Iterable, int) to merge sources and terminate only when all sourceObservableSources have completed or failed with an error.

    Type Parameters:

    T - the common element base type

    Parameters:

    sources - the Iterable of ObservableSources

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

    Returns:

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

    Throws:

    IllegalArgumentException - ifmaxConcurrent is less than or equal to 0

    See Also:

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

  • merge

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

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

    

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

    Scheduler:

    merge does not operate by default on a particularScheduler.

    Error handling:

    If any of the sourceObservableSources signal aThrowable viaonError, the resultingObservable terminates with thatThrowable and all other sourceObservableSources are disposed. If more than oneObservableSource signals an error, the resultingObservable may terminate with the first one's error or, depending on the concurrency of the sources, may terminate with aCompositeException containing two or more of the various error signals.Throwables that didn't make into the composite will be sent (individually) to the global error handler viaRxJavaPlugins.onError(Throwable) method asUndeliverableException errors. Similarly,Throwables signaled by source(s) after the returnedObservable has been disposed or terminated with a (composite) error will be sent to the same global error handler. UsemergeDelayError(ObservableSource) to merge sources and terminate only when all sourceObservableSources have completed or failed with an error.

    Type Parameters:

    T - the common element base type

    Parameters:

    sources - an ObservableSource that emits ObservableSources

    Returns:

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

    See Also:

    ReactiveX operators documentation: Merge,mergeDelayError(ObservableSource)

  • merge

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

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

    

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

    Scheduler:

    merge does not operate by default on a particularScheduler.

    Error handling:

    If any of the sourceObservableSources signal aThrowable viaonError, the resultingObservable terminates with thatThrowable and all other sourceObservableSources are disposed. If more than oneObservableSource signals an error, the resultingObservable may terminate with the first one's error or, depending on the concurrency of the sources, may terminate with aCompositeException containing two or more of the various error signals.Throwables that didn't make into the composite will be sent (individually) to the global error handler viaRxJavaPlugins.onError(Throwable) method asUndeliverableException errors. Similarly,Throwables signaled by source(s) after the returnedObservable has been disposed or terminated with a (composite) error will be sent to the same global error handler. UsemergeDelayError(ObservableSource, int) to merge sources and terminate only when all sourceObservableSources have completed or failed with an error.

    Type Parameters:

    T - the common element base type

    Parameters:

    sources - an ObservableSource that emits ObservableSources

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

    Returns:

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

    Throws:

    IllegalArgumentException - ifmaxConcurrent is less than or equal to 0

    Since:

    1.1.0

    See Also:

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

  • merge

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

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

    

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

    Scheduler:

    merge does not operate by default on a particularScheduler.

    Error handling:

    If any of the sourceObservableSources signal aThrowable viaonError, the resultingObservable terminates with thatThrowable and all other sourceObservableSources are disposed. If more than oneObservableSource signals an error, the resultingObservable may terminate with the first one's error or, depending on the concurrency of the sources, may terminate with aCompositeException containing two or more of the various error signals.Throwables that didn't make into the composite will be sent (individually) to the global error handler viaRxJavaPlugins.onError(Throwable) method asUndeliverableException errors. Similarly,Throwables signaled by source(s) after the returnedObservable has been disposed or terminated with a (composite) error will be sent to the same global error handler. UsemergeDelayError(ObservableSource, ObservableSource) to merge sources and terminate only when all sourceObservableSources have completed or failed with an error.

    Type Parameters:

    T - the common element base type

    Parameters:

    source1 - an ObservableSource to be merged

    source2 - an ObservableSource to be merged

    Returns:

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

    See Also:

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

  • merge

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

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

    

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

    Scheduler:

    merge does not operate by default on a particularScheduler.

    Error handling:

    If any of the sourceObservableSources signal aThrowable viaonError, the resultingObservable terminates with thatThrowable and all other sourceObservableSources are disposed. If more than oneObservableSource signals an error, the resultingObservable may terminate with the first one's error or, depending on the concurrency of the sources, may terminate with aCompositeException containing two or more of the various error signals.Throwables that didn't make into the composite will be sent (individually) to the global error handler viaRxJavaPlugins.onError(Throwable) method asUndeliverableException errors. Similarly,Throwables signaled by source(s) after the returnedObservable has been disposed or terminated with a (composite) error will be sent to the same global error handler. UsemergeDelayError(ObservableSource, ObservableSource, ObservableSource) to merge sources and terminate only when all sourceObservableSources have completed or failed with an error.

    Type Parameters:

    T - the common element base type

    Parameters:

    source1 - an ObservableSource to be merged

    source2 - an ObservableSource to be merged

    source3 - an ObservableSource to be merged

    Returns:

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

    See Also:

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

  • merge

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

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

    

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

    Scheduler:

    merge does not operate by default on a particularScheduler.

    Error handling:

    If any of the sourceObservableSources signal aThrowable viaonError, the resultingObservable terminates with thatThrowable and all other sourceObservableSources are disposed. If more than oneObservableSource signals an error, the resultingObservable may terminate with the first one's error or, depending on the concurrency of the sources, may terminate with aCompositeException containing two or more of the various error signals.Throwables that didn't make into the composite will be sent (individually) to the global error handler viaRxJavaPlugins.onError(Throwable) method asUndeliverableException errors. Similarly,Throwables signaled by source(s) after the returnedObservable has been disposed or terminated with a (composite) error will be sent to the same global error handler. UsemergeDelayError(ObservableSource, ObservableSource, ObservableSource, ObservableSource) to merge sources and terminate only when all sourceObservableSources have completed or failed with an error.

    Type Parameters:

    T - the common element base type

    Parameters:

    source1 - an ObservableSource to be merged

    source2 - an ObservableSource to be merged

    source3 - an ObservableSource to be merged

    source4 - an ObservableSource to be merged

    Returns:

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

    See Also:

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

  • mergeArray

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

    Flattens an Array of ObservableSources into one ObservableSource, without any transformation.

    

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

    Scheduler:

    mergeArray does not operate by default on a particularScheduler.

    Error handling:

    If any of the sourceObservableSources signal aThrowable viaonError, the resultingObservable terminates with thatThrowable and all other sourceObservableSources are disposed. If more than oneObservableSource signals an error, the resultingObservable may terminate with the first one's error or, depending on the concurrency of the sources, may terminate with aCompositeException containing two or more of the various error signals.Throwables that didn't make into the composite will be sent (individually) to the global error handler viaRxJavaPlugins.onError(Throwable) method asUndeliverableException errors. Similarly,Throwables signaled by source(s) after the returnedObservable has been disposed or terminated with a (composite) error will be sent to the same global error handler. UsemergeArrayDelayError(ObservableSource...) to merge sources and terminate only when all sourceObservableSources have completed or failed with an error.

    Type Parameters:

    T - the common element base type

    Parameters:

    sources - the array of ObservableSources

    Returns:

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

    See Also:

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

  • mergeDelayError

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

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

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

    

    Even if multiple merged ObservableSources sendonError notifications,mergeDelayError will only invoke theonError method of its Observers once.

    Scheduler:

    mergeDelayError does not operate by default on a particularScheduler.

    Type Parameters:

    T - the common element base type

    Parameters:

    sources - the Iterable of ObservableSources

    Returns:

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

    See Also:

    ReactiveX operators documentation: Merge

  • mergeDelayError

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

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

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

    

    Even if multiple merged ObservableSources sendonError notifications,mergeDelayError will only invoke theonError method of its Observers once.

    Scheduler:

    mergeDelayError does not operate by default on a particularScheduler.

    Type Parameters:

    T - the common element base type

    Parameters:

    sources - the Iterable of ObservableSources

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

    bufferSize - the number of items to prefetch from each inner ObservableSource

    Returns:

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

    See Also:

    ReactiveX operators documentation: Merge

  • mergeArrayDelayError

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

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

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

    

    Even if multiple merged ObservableSources sendonError notifications,mergeDelayError will only invoke theonError method of its Observers once.

    Scheduler:

    mergeArrayDelayError does not operate by default on a particularScheduler.

    Type Parameters:

    T - the common element base type

    Parameters:

    sources - the array of ObservableSources

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

    bufferSize - the number of items to prefetch from each inner ObservableSource

    Returns:

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

    See Also:

    ReactiveX operators documentation: Merge

  • mergeDelayError

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

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

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

    

    Even if multiple merged ObservableSources sendonError notifications,mergeDelayError will only invoke theonError method of its Observers once.

    Scheduler:

    mergeDelayError does not operate by default on a particularScheduler.

    Type Parameters:

    T - the common element base type

    Parameters:

    sources - the Iterable of ObservableSources

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

    Returns:

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

    See Also:

    ReactiveX operators documentation: Merge

  • mergeDelayError

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

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

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

    

    Even if multiple merged ObservableSources sendonError notifications,mergeDelayError will only invoke theonError method of its Observers once.

    Scheduler:

    mergeDelayError does not operate by default on a particularScheduler.

    Type Parameters:

    T - the common element base type

    Parameters:

    sources - an ObservableSource that emits ObservableSources

    Returns:

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

    See Also:

    ReactiveX operators documentation: Merge

  • mergeDelayError

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

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

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

    

    Even if multiple merged ObservableSources sendonError notifications,mergeDelayError will only invoke theonError method of its Observers once.

    Scheduler:

    mergeDelayError does not operate by default on a particularScheduler.

    Type Parameters:

    T - the common element base type

    Parameters:

    sources - an ObservableSource that emits ObservableSources

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

    Returns:

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

    Since:

    2.0

    See Also:

    ReactiveX operators documentation: Merge

  • mergeDelayError

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

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

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

    

    Even if both merged ObservableSources sendonError notifications,mergeDelayError will only invoke theonError method of its Observers once.

    Scheduler:

    mergeDelayError does not operate by default on a particularScheduler.

    Type Parameters:

    T - the common element base type

    Parameters:

    source1 - an ObservableSource to be merged

    source2 - an ObservableSource to be merged

    Returns:

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

    See Also:

    ReactiveX operators documentation: Merge

  • mergeDelayError

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

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

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

    

    Even if multiple merged ObservableSources sendonError notifications,mergeDelayError will only invoke theonError method of its Observers once.

    Scheduler:

    mergeDelayError does not operate by default on a particularScheduler.

    Type Parameters:

    T - the common element base type

    Parameters:

    source1 - an ObservableSource to be merged

    source2 - an ObservableSource to be merged

    source3 - an ObservableSource to be merged

    Returns:

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

    See Also:

    ReactiveX operators documentation: Merge

  • mergeDelayError

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

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

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

    

    Even if multiple merged ObservableSources sendonError notifications,mergeDelayError will only invoke theonError method of its Observers once.

    Scheduler:

    mergeDelayError does not operate by default on a particularScheduler.

    Type Parameters:

    T - the common element base type

    Parameters:

    source1 - an ObservableSource to be merged

    source2 - an ObservableSource to be merged

    source3 - an ObservableSource to be merged

    source4 - an ObservableSource to be merged

    Returns:

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

    See Also:

    ReactiveX operators documentation: Merge

  • mergeArrayDelayError

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

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

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

    

    Even if multiple merged ObservableSources sendonError notifications,mergeDelayError will only invoke theonError method of its Observers once.

    Scheduler:

    mergeArrayDelayError does not operate by default on a particularScheduler.

    Type Parameters:

    T - the common element base type

    Parameters:

    sources - the Iterable of ObservableSources

    Returns:

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

    See Also:

    ReactiveX operators documentation: Merge

  • never

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

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

    

    This ObservableSource is useful primarily for testing purposes.

    Scheduler:

    never does not operate by default on a particularScheduler.

    Type Parameters:

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

    Returns:

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

    See Also:

    ReactiveX operators documentation: Never

  • range

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

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

    

    Scheduler:

    range does not operate by default on a particularScheduler.

    Parameters:

    start - the value of the first Integer in the sequence

    count - the number of sequential Integers to generate

    Returns:

    an Observable that emits a range of sequential Integers

    Throws:

    IllegalArgumentException - ifcount is less than zero, or ifstart +count − 1 exceedsInteger.MAX_VALUE

    See Also:

    ReactiveX operators documentation: Range

  • rangeLong

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

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

    

    Scheduler:

    rangeLong does not operate by default on a particularScheduler.

    Parameters:

    start - the value of the first Long in the sequence

    count - the number of sequential Longs to generate

    Returns:

    an Observable that emits a range of sequential Longs

    Throws:

    IllegalArgumentException - ifcount is less than zero, or ifstart +count − 1 exceedsLong.MAX_VALUE

    See Also:

    ReactiveX operators documentation: Range

  • sequenceEqual

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

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

    

    Scheduler:

    sequenceEqual does not operate by default on a particularScheduler.

    Type Parameters:

    T - the type of items emitted by each ObservableSource

    Parameters:

    source1 - the first ObservableSource to compare

    source2 - the second ObservableSource to compare

    Returns:

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

    See Also:

    ReactiveX operators documentation: SequenceEqual

  • sequenceEqual

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

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

    

    Scheduler:

    sequenceEqual does not operate by default on a particularScheduler.

    Type Parameters:

    T - the type of items emitted by each ObservableSource

    Parameters:

    source1 - the first ObservableSource to compare

    source2 - the second ObservableSource to compare

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

    Returns:

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

    See Also:

    ReactiveX operators documentation: SequenceEqual

  • sequenceEqual

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

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

    

    Scheduler:

    sequenceEqual does not operate by default on a particularScheduler.

    Type Parameters:

    T - the type of items emitted by each ObservableSource

    Parameters:

    source1 - the first ObservableSource to compare

    source2 - the second ObservableSource to compare

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

    bufferSize - the number of items to prefetch from the first and second source ObservableSource

    Returns:

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

    See Also:

    ReactiveX operators documentation: SequenceEqual

  • sequenceEqual

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

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

    

    Scheduler:

    sequenceEqual does not operate by default on a particularScheduler.

    Type Parameters:

    T - the type of items emitted by each ObservableSource

    Parameters:

    source1 - the first ObservableSource to compare

    source2 - the second ObservableSource to compare

    bufferSize - the number of items to prefetch from the first and second source ObservableSource

    Returns:

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

    See Also:

    ReactiveX operators documentation: SequenceEqual

  • switchOnNext

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

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

    

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

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

    Scheduler:

    switchOnNext does not operate by default on a particularScheduler.

    Type Parameters:

    T - the item type

    Parameters:

    sources - the source ObservableSource that emits ObservableSources

    bufferSize - the number of items to prefetch from the inner ObservableSources

    Returns:

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

    See Also:

    ReactiveX operators documentation: Switch

  • switchOnNext

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

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

    

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

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

    Scheduler:

    switchOnNext does not operate by default on a particularScheduler.

    Type Parameters:

    T - the item type

    Parameters:

    sources - the source ObservableSource that emits ObservableSources

    Returns:

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

    See Also:

    ReactiveX operators documentation: Switch

  • switchOnNextDelayError

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

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

    

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

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

    Scheduler:

    switchOnNextDelayError does not operate by default on a particularScheduler.

    Type Parameters:

    T - the item type

    Parameters:

    sources - the source ObservableSource that emits ObservableSources

    Returns:

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

    Since:

    2.0

    See Also:

    ReactiveX operators documentation: Switch

  • switchOnNextDelayError

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

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

    

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

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

    Scheduler:

    switchOnNextDelayError does not operate by default on a particularScheduler.

    Type Parameters:

    T - the item type

    Parameters:

    sources - the source ObservableSource that emits ObservableSources

    prefetch - the number of items to prefetch from the inner ObservableSources

    Returns:

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

    Since:

    2.0

    See Also:

    ReactiveX operators documentation: Switch

  • timer

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

    Returns an Observable that emits0L after a specified delay, and then completes.

    

    Scheduler:

    timer operates by default on thecomputationScheduler.

    Parameters:

    delay - the initial delay before emitting a single0L

    unit - time units to use fordelay

    Returns:

    an Observable that0L after a specified delay, and then completes

    See Also:

    ReactiveX operators documentation: Timer

  • timer

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

    Returns an Observable that emits0L after a specified delay, on a specified Scheduler, and then completes.

    

    Scheduler:

    You specify whichScheduler this operator will use.

    Parameters:

    delay - the initial delay before emitting a single 0L

    unit - time units to use fordelay

    scheduler - theScheduler to use for scheduling the item

    Returns:

    an Observable that emits0L after a specified delay, on a specified Scheduler, and then completes

    Throws:

    NullPointerException - ifunit is null, or ifscheduler is null

    See Also:

    ReactiveX operators documentation: Timer

  • unsafeCreate

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

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

    Scheduler:

    unsafeCreate by default doesn't operate on any particularScheduler.

    Type Parameters:

    T - the value type emitted

    Parameters:

    onSubscribe - the ObservableSource instance to wrap

    Returns:

    the new Observable instance

  • using

    @CheckReturnValue@SchedulerSupport(value="none")public static <T,D> Observable<T> using(Callable<? extends D> resourceSupplier,Function<? super D,? extendsObservableSource<? extends T>> sourceSupplier,Consumer<? super D> disposer)

    Constructs an ObservableSource that creates a dependent resource object which is disposed of when the downstream calls dispose().

    

    Scheduler:

    using does not operate by default on a particularScheduler.

    Type Parameters:

    T - the element type of the generated ObservableSource

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

    Parameters:

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

    sourceSupplier - the factory function to create an ObservableSource

    disposer - the function that will dispose of the resource

    Returns:

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

    See Also:

    ReactiveX operators documentation: Using

  • using

    @CheckReturnValue@SchedulerSupport(value="none")public static <T,D> Observable<T> using(Callable<? extends D> resourceSupplier,Function<? super D,? extendsObservableSource<? extends T>> sourceSupplier,Consumer<? super D> disposer,        boolean eager)

    Constructs an ObservableSource that creates a dependent resource object which is disposed of just before termination if you have setdisposeEagerly totrue and a dispose() call does not occur before termination. Otherwise resource disposal will occur on a dispose() call. Eager disposal is particularly appropriate for a synchronous ObservableSource that reuses resources.disposeAction will only be called once per subscription.

    

    Scheduler:

    using does not operate by default on a particularScheduler.

    Type Parameters:

    T - the element type of the generated ObservableSource

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

    Parameters:

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

    sourceSupplier - the factory function to create an ObservableSource

    disposer - the function that will dispose of the resource

    eager - iftrue then disposal will happen either on a dispose() call or just before emission of a terminal event (onComplete oronError).

    Returns:

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

    Since:

    2.0

    See Also:

    ReactiveX operators documentation: Using

  • wrap

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

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

    Scheduler:

    wrap does not operate by default on a particularScheduler.

    Type Parameters:

    T - the value type

    Parameters:

    source - the source ObservableSource instance

    Returns:

    the new Observable instance or the same as the source

    Throws:

    NullPointerException - if source is null

  • zip

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

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

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

    The resultingObservableSource<R> returned fromzip will invokeonNext as many times as the number ofonNext invocations of the source ObservableSource that emits the fewest items.

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

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

    action1 will be called butaction2 won't.
    To work around this termination property, usedoOnDispose(Action) as well or useusing() to do cleanup in case of completion or a dispose() call.

    Note on method signature: since Java doesn't allow creating a generic array withnew T[], the implementation of this operator has to create anObject[] instead. Unfortunately, aFunction<Integer[], R> passed to the method would trigger aClassCastException.

    

    Scheduler:

    zip does not operate by default on a particularScheduler.

    Type Parameters:

    T - the common value type

    R - the zipped result type

    Parameters:

    sources - an Iterable of source ObservableSources

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

    Returns:

    an Observable that emits the zipped results

    See Also:

    ReactiveX operators documentation: Zip

  • zip

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

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

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

    The resultingObservableSource<R> returned fromzip will invokeonNext as many times as the number ofonNext invocations of the source ObservableSource that emits the fewest items.

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

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

    action1 will be called butaction2 won't.
    To work around this termination property, usedoOnDispose(Action) as well or useusing() to do cleanup in case of completion or a dispose() call.

    Note on method signature: since Java doesn't allow creating a generic array withnew T[], the implementation of this operator has to create anObject[] instead. Unfortunately, aFunction<Integer[], R> passed to the method would trigger aClassCastException.

    

    Scheduler:

    zip does not operate by default on a particularScheduler.

    Type Parameters:

    T - the value type of the inner ObservableSources

    R - the zipped result type

    Parameters:

    sources - an ObservableSource of source ObservableSources

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

    Returns:

    an Observable that emits the zipped results

    See Also:

    ReactiveX operators documentation: Zip

  • zip

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

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

    

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

    The resultingObservableSource<R> returned fromzip will invokeonNext as many times as the number ofonNext invocations of the source ObservableSource that emits the fewest items.

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

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

    action1 will be called butaction2 won't.
    To work around this termination property, usedoOnDispose(Action) as well or useusing() to do cleanup in case of completion or a dispose() call.

    Scheduler:

    zip does not operate by default on a particularScheduler.

    Type Parameters:

    T1 - the value type of the first source

    T2 - the value type of the second source

    R - the zipped result type

    Parameters:

    source1 - the first source ObservableSource

    source2 - a second source ObservableSource

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

    Returns:

    an Observable that emits the zipped results

    See Also:

    ReactiveX operators documentation: Zip

  • zip

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

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

    

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

    The resultingObservableSource<R> returned fromzip will invokeonNext as many times as the number ofonNext invocations of the source ObservableSource that emits the fewest items.

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

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

    action1 will be called butaction2 won't.
    To work around this termination property, usedoOnDispose(Action) as well or useusing() to do cleanup in case of completion or a dispose() call.

    Scheduler:

    zip does not operate by default on a particularScheduler.

    Type Parameters:

    T1 - the value type of the first source

    T2 - the value type of the second source

    R - the zipped result type

    Parameters:

    source1 - the first source ObservableSource

    source2 - a second source ObservableSource

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

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

    Returns:

    an Observable that emits the zipped results

    See Also:

    ReactiveX operators documentation: Zip

  • zip

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

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

    

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

    The resultingObservableSource<R> returned fromzip will invokeonNext as many times as the number ofonNext invocations of the source ObservableSource that emits the fewest items.

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

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

    action1 will be called butaction2 won't.
    To work around this termination property, usedoOnDispose(Action) as well or useusing() to do cleanup in case of completion or a dispose() call.

    Scheduler:

    zip does not operate by default on a particularScheduler.

    Type Parameters:

    T1 - the value type of the first source

    T2 - the value type of the second source

    R - the zipped result type

    Parameters:

    source1 - the first source ObservableSource

    source2 - a second source ObservableSource

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

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

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

    Returns:

    an Observable that emits the zipped results

    See Also:

    ReactiveX operators documentation: Zip

  • zip

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

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

    

    zip applies this function in strict sequence, so the first item emitted by the new ObservableSource will be the result of the function applied to the first item emitted byo1, the first item emitted byo2, and the first item emitted byo3; the second item emitted by the new ObservableSource will be the result of the function applied to the second item emitted byo1, the second item emitted byo2, and the second item emitted byo3; and so forth.

    The resultingObservableSource<R> returned fromzip will invokeonNext as many times as the number ofonNext invocations of the source ObservableSource that emits the fewest items.

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

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

    action1 will be called butaction2 won't.
    To work around this termination property, usedoOnDispose(Action) as well or useusing() to do cleanup in case of completion or a dispose() call.

    Scheduler:

    zip does not operate by default on a particularScheduler.

    Type Parameters:

    T1 - the value type of the first source

    T2 - the value type of the second source

    T3 - the value type of the third source

    R - the zipped result type

    Parameters:

    source1 - the first source ObservableSource

    source2 - a second source ObservableSource

    source3 - a third source ObservableSource

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

    Returns:

    an Observable that emits the zipped results

    See Also:

    ReactiveX operators documentation: Zip

  • zip

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

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

    

    zip applies this function in strict sequence, so the first item emitted by the new ObservableSource will be the result of the function applied to the first item emitted byo1, the first item emitted byo2, the first item emitted byo3, and the first item emitted by04; the second item emitted by the new ObservableSource will be the result of the function applied to the second item emitted by each of those ObservableSources; and so forth.

    The resultingObservableSource<R> returned fromzip will invokeonNext as many times as the number ofonNext invocations of the source ObservableSource that emits the fewest items.

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

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

    action1 will be called butaction2 won't.
    To work around this termination property, usedoOnDispose(Action) as well or useusing() to do cleanup in case of completion or a dispose() call.

    Scheduler:

    zip does not operate by default on a particularScheduler.

    Type Parameters:

    T1 - the value type of the first source

    T2 - the value type of the second source

    T3 - the value type of the third source

    T4 - the value type of the fourth source

    R - the zipped result type

    Parameters:

    source1 - the first source ObservableSource

    source2 - a second source ObservableSource

    source3 - a third source ObservableSource

    source4 - a fourth source ObservableSource

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

    Returns:

    an Observable that emits the zipped results

    See Also:

    ReactiveX operators documentation: Zip

  • zip

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

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

    

    zip applies this function in strict sequence, so the first item emitted by the new ObservableSource will be the result of the function applied to the first item emitted byo1, the first item emitted byo2, the first item emitted byo3, the first item emitted byo4, and the first item emitted byo5; the second item emitted by the new ObservableSource will be the result of the function applied to the second item emitted by each of those ObservableSources; and so forth.

    The resultingObservableSource<R> returned fromzip will invokeonNext as many times as the number ofonNext invocations of the source ObservableSource that emits the fewest items.

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

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

    action1 will be called butaction2 won't.
    To work around this termination property, usedoOnDispose(Action) as well or useusing() to do cleanup in case of completion or a dispose() call.

    Scheduler:

    zip does not operate by default on a particularScheduler.

    Type Parameters:

    T1 - the value type of the first source

    T2 - the value type of the second source

    T3 - the value type of the third source

    T4 - the value type of the fourth source

    T5 - the value type of the fifth source

    R - the zipped result type

    Parameters:

    source1 - the first source ObservableSource

    source2 - a second source ObservableSource

    source3 - a third source ObservableSource

    source4 - a fourth source ObservableSource

    source5 - a fifth source ObservableSource

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

    Returns:

    an Observable that emits the zipped results

    See Also:

    ReactiveX operators documentation: Zip

  • zip

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

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

    

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

    The resultingObservableSource<R> returned fromzip will invokeonNext as many times as the number ofonNext invocations of the source ObservableSource that emits the fewest items.

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

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

    action1 will be called butaction2 won't.
    To work around this termination property, usedoOnDispose(Action) as well or useusing() to do cleanup in case of completion or a dispose() call.

    Scheduler:

    zip does not operate by default on a particularScheduler.

    Type Parameters:

    T1 - the value type of the first source

    T2 - the value type of the second source

    T3 - the value type of the third source

    T4 - the value type of the fourth source

    T5 - the value type of the fifth source

    T6 - the value type of the sixth source

    R - the zipped result type

    Parameters:

    source1 - the first source ObservableSource

    source2 - a second source ObservableSource

    source3 - a third source ObservableSource

    source4 - a fourth source ObservableSource

    source5 - a fifth source ObservableSource

    source6 - a sixth source ObservableSource

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

    Returns:

    an Observable that emits the zipped results

    See Also:

    ReactiveX operators documentation: Zip

  • zip

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

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

    

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

    The resultingObservableSource<R> returned fromzip will invokeonNext as many times as the number ofonNext invocations of the source ObservableSource that emits the fewest items.

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

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

    action1 will be called butaction2 won't.
    To work around this termination property, usedoOnDispose(Action) as well or useusing() to do cleanup in case of completion or a dispose() call.

    Scheduler:

    zip does not operate by default on a particularScheduler.

    Type Parameters:

    T1 - the value type of the first source

    T2 - the value type of the second source

    T3 - the value type of the third source

    T4 - the value type of the fourth source

    T5 - the value type of the fifth source

    T6 - the value type of the sixth source

    T7 - the value type of the seventh source

    R - the zipped result type

    Parameters:

    source1 - the first source ObservableSource

    source2 - a second source ObservableSource

    source3 - a third source ObservableSource

    source4 - a fourth source ObservableSource

    source5 - a fifth source ObservableSource

    source6 - a sixth source ObservableSource

    source7 - a seventh source ObservableSource

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

    Returns:

    an Observable that emits the zipped results

    See Also:

    ReactiveX operators documentation: Zip

  • zip

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

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

    

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

    The resultingObservableSource<R> returned fromzip will invokeonNext as many times as the number ofonNext invocations of the source ObservableSource that emits the fewest items.

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

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

    action1 will be called butaction2 won't.
    To work around this termination property, usedoOnDispose(Action) as well or useusing() to do cleanup in case of completion or a dispose() call.

    Scheduler:

    zip does not operate by default on a particularScheduler.

    Type Parameters:

    T1 - the value type of the first source

    T2 - the value type of the second source

    T3 - the value type of the third source

    T4 - the value type of the fourth source

    T5 - the value type of the fifth source

    T6 - the value type of the sixth source

    T7 - the value type of the seventh source

    T8 - the value type of the eighth source

    R - the zipped result type

    Parameters:

    source1 - the first source ObservableSource

    source2 - a second source ObservableSource

    source3 - a third source ObservableSource

    source4 - a fourth source ObservableSource

    source5 - a fifth source ObservableSource

    source6 - a sixth source ObservableSource

    source7 - a seventh source ObservableSource

    source8 - an eighth source ObservableSource

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

    Returns:

    an Observable that emits the zipped results

    See Also:

    ReactiveX operators documentation: Zip

  • zip

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

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

    

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

    The resultingObservableSource<R> returned fromzip will invokeonNext as many times as the number ofonNext invocations of the source ObservableSource that emits the fewest items.

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

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

    action1 will be called butaction2 won't.
    To work around this termination property, usedoOnDispose(Action) as well or useusing() to do cleanup in case of completion or a dispose() call.

    Scheduler:

    zip does not operate by default on a particularScheduler.

    Type Parameters:

    T1 - the value type of the first source

    T2 - the value type of the second source

    T3 - the value type of the third source

    T4 - the value type of the fourth source

    T5 - the value type of the fifth source

    T6 - the value type of the sixth source

    T7 - the value type of the seventh source

    T8 - the value type of the eighth source

    T9 - the value type of the ninth source

    R - the zipped result type

    Parameters:

    source1 - the first source ObservableSource

    source2 - a second source ObservableSource

    source3 - a third source ObservableSource

    source4 - a fourth source ObservableSource

    source5 - a fifth source ObservableSource

    source6 - a sixth source ObservableSource

    source7 - a seventh source ObservableSource

    source8 - an eighth source ObservableSource

    source9 - a ninth source ObservableSource

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

    Returns:

    an Observable that emits the zipped results

    See Also:

    ReactiveX operators documentation: Zip

  • zipArray

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

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

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

    The resultingObservableSource<R> returned fromzip will invokeonNext as many times as the number ofonNext invocations of the source ObservableSource that emits the fewest items.

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

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

    action1 will be called butaction2 won't.
    To work around this termination property, usedoOnDispose(Action) as well or useusing() to do cleanup in case of completion or a dispose() call.

    Note on method signature: since Java doesn't allow creating a generic array withnew T[], the implementation of this operator has to create anObject[] instead. Unfortunately, aFunction<Integer[], R> passed to the method would trigger aClassCastException.

    

    Scheduler:

    zipArray does not operate by default on a particularScheduler.

    Type Parameters:

    T - the common element type

    R - the result type

    Parameters:

    sources - an array of source ObservableSources

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

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

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

    Returns:

    an Observable that emits the zipped results

    See Also:

    ReactiveX operators documentation: Zip

  • zipIterable

    @CheckReturnValue@SchedulerSupport(value="none")public static <T,R> Observable<R> zipIterable(Iterable<? extendsObservableSource<? extends T>> sources,Function<? superObject[],? extends R> zipper,        boolean delayError,        int bufferSize)

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

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

    The resultingObservableSource<R> returned fromzip will invokeonNext as many times as the number ofonNext invocations of the source ObservableSource that emits the fewest items.

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

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

    action1 will be called butaction2 won't.
    To work around this termination property, usedoOnDispose(Action) as well or useusing() to do cleanup in case of completion or a dispose() call.

    Note on method signature: since Java doesn't allow creating a generic array withnew T[], the implementation of this operator has to create anObject[] instead. Unfortunately, aFunction<Integer[], R> passed to the method would trigger aClassCastException.

    

    Scheduler:

    zipIterable does not operate by default on a particularScheduler.

    Type Parameters:

    T - the common source value type

    R - the zipped result type

    Parameters:

    sources - an Iterable of source ObservableSources

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

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

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

    Returns:

    an Observable that emits the zipped results

    See Also:

    ReactiveX operators documentation: Zip

  • all

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

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

    

    Scheduler:

    all does not operate by default on a particularScheduler.

    Parameters:

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

    Returns:

    a Single that emitstrue if all items emitted by the source ObservableSource satisfy the predicate; otherwise,false

    See Also:

    ReactiveX operators documentation: All

  • ambWith

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

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

    

    Scheduler:

    ambWith does not operate by default on a particularScheduler.

    Parameters:

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

    Returns:

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

    See Also:

    ReactiveX operators documentation: Amb

  • any

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

    Returns a Single that emitstrue if any item emitted by the source ObservableSource satisfies a specified condition, otherwisefalse.Note: this always emitsfalse if the source ObservableSource is empty.

    

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

    Scheduler:

    any does not operate by default on a particularScheduler.

    Parameters:

    predicate - the condition to test items emitted by the source ObservableSource

    Returns:

    a Single that emits a Boolean that indicates whether any item emitted by the source ObservableSource satisfies thepredicate

    See Also:

    ReactiveX operators documentation: Contains

  • as

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

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

    This allows fluent conversion to any other type.

    Scheduler:

    as does not operate by default on a particularScheduler.

    History: 2.1.7 - experimental

    Type Parameters:

    R - the resulting object type

    Parameters:

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

    Returns:

    the converted value

    Throws:

    NullPointerException - if converter is null

    Since:

    2.2

  • blockingFirst

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

    Returns the first item emitted by thisObservable, or throwsNoSuchElementException if it emits no items.

    

    Scheduler:

    blockingFirst does not operate by default on a particularScheduler.

    Returns:

    the first item emitted by thisObservable

    Throws:

    NoSuchElementException - if thisObservable emits no items

    See Also:

    ReactiveX documentation: First

  • blockingFirst

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

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

    

    Scheduler:

    blockingFirst does not operate by default on a particularScheduler.

    Parameters:

    defaultItem - a default value to return if thisObservable emits no items

    Returns:

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

    See Also:

    ReactiveX documentation: First

  • blockingForEach

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

    Consumes the upstreamObservable in a blocking fashion and invokes the givenConsumer with each upstream item on thecurrent thread until the upstream terminates.

    

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

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

    Scheduler:

    blockingForEach does not operate by default on a particularScheduler.

    Error handling:

    If the source signals an error, the operator wraps a checkedException intoRuntimeException and throws that. Otherwise,RuntimeExceptions andErrors are rethrown as they are.

    Parameters:

    onNext - theConsumer to invoke for each item emitted by theObservable

    Throws:

    RuntimeException - if an error occurs

    See Also:

    ReactiveX documentation: Subscribe,subscribe(Consumer)

  • blockingIterable

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

    Converts thisObservable into anIterable.

    

    Scheduler:

    blockingIterable does not operate by default on a particularScheduler.

    Returns:

    anIterable version of thisObservable

    See Also:

    ReactiveX documentation: To

  • blockingIterable

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

    Converts thisObservable into anIterable.

    

    Scheduler:

    blockingIterable does not operate by default on a particularScheduler.

    Parameters:

    bufferSize - the number of items to prefetch from the current Observable

    Returns:

    anIterable version of thisObservable

    See Also:

    ReactiveX documentation: To

  • blockingLast

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

    Returns the last item emitted by thisObservable, or throwsNoSuchElementException if thisObservable emits no items.

    

    Scheduler:

    blockingLast does not operate by default on a particularScheduler.

    Error handling:

    If the source signals an error, the operator wraps a checkedException intoRuntimeException and throws that. Otherwise,RuntimeExceptions andErrors are rethrown as they are.

    Returns:

    the last item emitted by thisObservable

    Throws:

    NoSuchElementException - if thisObservable emits no items

    See Also:

    ReactiveX documentation: Last

  • blockingLast

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

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

    

    Scheduler:

    blockingLast does not operate by default on a particularScheduler.

    Error handling:

    If the source signals an error, the operator wraps a checkedException intoRuntimeException and throws that. Otherwise,RuntimeExceptions andErrors are rethrown as they are.

    Parameters:

    defaultItem - a default value to return if thisObservable emits no items

    Returns:

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

    See Also:

    ReactiveX documentation: Last

  • blockingLatest

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

    Returns anIterable that returns the latest item emitted by thisObservable, waiting if necessary for one to become available.

    

    If thisObservable produces items faster thanIterator.next takes them,onNext events might be skipped, butonError oronComplete events are not.

    Note also that anonNext directly followed byonComplete might hide theonNext event.

    Scheduler:

    blockingLatest does not operate by default on a particularScheduler.

    Returns:

    an Iterable that always returns the latest item emitted by thisObservable

    See Also:

    ReactiveX documentation: First

  • blockingMostRecent

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

    Returns anIterable that always returns the item most recently emitted by thisObservable.

    

    Scheduler:

    blockingMostRecent does not operate by default on a particularScheduler.

    Parameters:

    initialValue - the initial value that theIterable sequence will yield if thisObservable has not yet emitted an item

    Returns:

    anIterable that on each iteration returns the item that thisObservable has most recently emitted

    See Also:

    ReactiveX documentation: First

  • blockingNext

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

    Returns anIterable that blocks until thisObservable emits another item, then returns that item.

    

    Scheduler:

    blockingNext does not operate by default on a particularScheduler.

    Returns:

    anIterable that blocks upon each iteration until thisObservable emits a new item, whereupon the Iterable returns that item

    See Also:

    ReactiveX documentation: TakeLast

  • blockingSingle

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

    If thisObservable completes after emitting a single item, return that item, otherwise throw aNoSuchElementException.

    

    Scheduler:

    blockingSingle does not operate by default on a particularScheduler.

    Error handling:

    If the source signals an error, the operator wraps a checkedException intoRuntimeException and throws that. Otherwise,RuntimeExceptions andErrors are rethrown as they are.

    Returns:

    the single item emitted by thisObservable

    See Also:

    ReactiveX documentation: First

  • blockingSingle

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

    If thisObservable completes after emitting a single item, return that item; if it emits more than one item, throw anIllegalArgumentException; if it emits no items, return a default value.

    

    Scheduler:

    blockingSingle does not operate by default on a particularScheduler.

    Error handling:

    If the source signals an error, the operator wraps a checkedException intoRuntimeException and throws that. Otherwise,RuntimeExceptions andErrors are rethrown as they are.

    Parameters:

    defaultItem - a default value to return if thisObservable emits no items

    Returns:

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

    See Also:

    ReactiveX documentation: First

  • toFuture

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

    Returns aFuture representing the only value emitted by thisObservable.

    

    If theObservable emits more than one item,Future will receive anIndexOutOfBoundsException. If theObservable is empty,Future will receive anNoSuchElementException. TheObservable source has to terminate in order for the returnedFuture to terminate as well.

    If theObservable may emit more than one item, useObservable.toList().toFuture().

    Scheduler:

    toFuture does not operate by default on a particularScheduler.

    Returns:

    aFuture that expects a single item to be emitted by thisObservable

    See Also:

    ReactiveX documentation: To

  • blockingSubscribe

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

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

    

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

    Scheduler:

    blockingSubscribe does not operate by default on a particularScheduler.

    Since:

    2.0

    See Also:

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

  • blockingSubscribe

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

    Subscribes to the source and calls the given callbackson the current thread.

    

    If theObservable emits an error, it is wrapped into anOnErrorNotImplementedException and routed to the RxJavaPlugins.onError handler. Using the overloadsblockingSubscribe(Consumer, Consumer) orblockingSubscribe(Consumer, Consumer, Action) instead is recommended.

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

    Scheduler:

    blockingSubscribe does not operate by default on a particularScheduler.

    Parameters:

    onNext - the callback action for each source value

    Since:

    2.0

    See Also:

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

  • blockingSubscribe

    @SchedulerSupport(value="none")public final void blockingSubscribe(Consumer<? superT> onNext,Consumer<? superThrowable> onError)

    Subscribes to the source and calls the given callbackson the current thread.

    

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

    Scheduler:

    blockingSubscribe does not operate by default on a particularScheduler.

    Parameters:

    onNext - the callback action for each source value

    onError - the callback action for an error event

    Since:

    2.0

    See Also:

    blockingSubscribe(Consumer, Consumer, Action)

  • blockingSubscribe

    @SchedulerSupport(value="none")public final void blockingSubscribe(Consumer<? superT> onNext,Consumer<? superThrowable> onError,Action onComplete)

    Subscribes to the source and calls the given callbackson the current thread.

    

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

    Scheduler:

    blockingSubscribe does not operate by default on a particularScheduler.

    Parameters:

    onNext - the callback action for each source value

    onError - the callback action for an error event

    onComplete - the callback action for the completion event.

    Since:

    2.0

  • blockingSubscribe

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

    Subscribes to the source and calls theObserver methodson the current thread.

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

    Scheduler:

    blockingSubscribe does not operate by default on a particularScheduler.

    The a dispose() call is composed through.

    Parameters:

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

    Since:

    2.0

  • buffer

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

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

    

    Scheduler:

    This version ofbuffer does not operate by default on a particularScheduler.

    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 mostcount items from the source ObservableSource

    See Also:

    ReactiveX operators documentation: Buffer

  • buffer

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

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

    

    Scheduler:

    This version ofbuffer does not operate by default on a particularScheduler.

    Parameters:

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

    skip - how many items emitted by the source ObservableSource should be skipped before starting a new buffer. Note that whenskip andcount are equal, this is the same operation asbuffer(int).

    Returns:

    an Observable that emits buffers for everyskip item from the source ObservableSource and containing at mostcount items

    See Also:

    ReactiveX operators documentation: Buffer

  • buffer

    @CheckReturnValue@SchedulerSupport(value="none")public final <U extendsCollection<? superT>> Observable<U> buffer(int count,        int skip,Callable<U> bufferSupplier)

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

    

    Scheduler:

    This version ofbuffer does not operate by default on a particularScheduler.

    Type Parameters:

    U - the collection subclass type to buffer into

    Parameters:

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

    skip - how many items emitted by the source ObservableSource should be skipped before starting a new buffer. Note that whenskip andcount are equal, this is the same operation asbuffer(int).

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

    Returns:

    an Observable that emits buffers for everyskip item from the source ObservableSource and containing at mostcount items

    See Also:

    ReactiveX operators documentation: Buffer

  • buffer

    @CheckReturnValue@SchedulerSupport(value="none")public final <U extendsCollection<? superT>> Observable<U> buffer(int count,Callable<U> bufferSupplier)

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

    

    Scheduler:

    This version ofbuffer does not operate by default on a particularScheduler.

    Type Parameters:

    U - the collection subclass type to buffer into

    Parameters:

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

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

    Returns:

    an Observable that emits connected, non-overlapping buffers, each containing at mostcount items from the source ObservableSource

    See Also:

    ReactiveX operators documentation: Buffer

  • buffer

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

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

    

    Scheduler:

    This version ofbuffer operates by default on thecomputationScheduler.

    Parameters:

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

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

    unit - the unit of time that applies to thetimespan andtimeskip arguments

    Returns:

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

    See Also:

    ReactiveX operators documentation: Buffer

  • buffer

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

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

    

    Scheduler:

    You specify whichScheduler this operator will use.

    Parameters:

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

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

    unit - the unit of time that applies to thetimespan andtimeskip arguments

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

    Returns:

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

    See Also:

    ReactiveX operators documentation: Buffer

  • buffer

    @CheckReturnValue@SchedulerSupport(value="custom")public final <U extendsCollection<? superT>> Observable<U> buffer(long timespan,        long timeskip,TimeUnit unit,Scheduler scheduler,Callable<U> bufferSupplier)

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

    

    Scheduler:

    You specify whichScheduler this operator will use.

    Type Parameters:

    U - the collection subclass type to buffer into

    Parameters:

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

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

    unit - the unit of time that applies to thetimespan andtimeskip arguments

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

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

    Returns:

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

    See Also:

    ReactiveX operators documentation: Buffer

  • buffer

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

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

    

    Scheduler:

    This version ofbuffer operates by default on thecomputationScheduler.

    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 thetimespan argument

    Returns:

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

    See Also:

    ReactiveX operators documentation: Buffer

  • buffer

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

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

    

    Scheduler:

    This version ofbuffer operates by default on thecomputationScheduler.

    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 thetimespan argument

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

    Returns:

    an Observable that emits connected, non-overlapping buffers of items emitted by the source ObservableSource, after a fixed duration or when the buffer reaches maximum capacity (whichever occurs first)

    See Also:

    ReactiveX operators documentation: Buffer

  • buffer

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

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

    

    Scheduler:

    You specify whichScheduler 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 thetimespan argument

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

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

    Returns:

    an Observable that emits connected, non-overlapping buffers of items emitted by the source ObservableSource after a fixed duration or when the buffer reaches maximum capacity (whichever occurs first)

    See Also:

    ReactiveX operators documentation: Buffer

  • buffer

    @CheckReturnValue@SchedulerSupport(value="custom")public final <U extendsCollection<? superT>> Observable<U> buffer(long timespan,TimeUnit unit,Scheduler scheduler,        int count,Callable<U> bufferSupplier,        boolean restartTimerOnMaxSize)

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

    

    Scheduler:

    You specify whichScheduler this operator will use.

    Type Parameters:

    U - the collection subclass type to buffer into

    Parameters:

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

    unit - the unit of time which applies to thetimespan argument

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

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

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

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

    Returns:

    an Observable that emits connected, non-overlapping buffers of items emitted by the source ObservableSource after a fixed duration or when the buffer reaches maximum capacity (whichever occurs first)

    See Also:

    ReactiveX operators documentation: Buffer

  • buffer

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

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

    

    Scheduler:

    You specify whichScheduler 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 thetimespan argument

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

    Returns:

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

    See Also:

    ReactiveX operators documentation: Buffer

  • buffer

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

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

    

    Scheduler:

    This version ofbuffer does not operate by default on a particularScheduler.

    Type Parameters:

    TOpening - the element type of the buffer-opening ObservableSource

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

    Parameters:

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

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

    Returns:

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

    See Also:

    ReactiveX operators documentation: Buffer

  • buffer

    @CheckReturnValue@SchedulerSupport(value="none")public final <TOpening,TClosing,U extendsCollection<? superT>> Observable<U> buffer(ObservableSource<? extends TOpening> openingIndicator,Function<? super TOpening,? extendsObservableSource<? extends TClosing>> closingIndicator,Callable<U> bufferSupplier)

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

    

    Scheduler:

    This version ofbuffer does not operate by default on a particularScheduler.

    Type Parameters:

    U - the collection subclass type to buffer into

    TOpening - the element type of the buffer-opening ObservableSource

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

    Parameters:

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

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

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

    Returns:

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

    See Also:

    ReactiveX operators documentation: Buffer

  • buffer

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

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

    

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

    Scheduler:

    This version ofbuffer does not operate by default on a particularScheduler.

    Type Parameters:

    B - the boundary value type (ignored)

    Parameters:

    boundary - the boundary ObservableSource

    Returns:

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

    See Also:

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

  • buffer

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

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

    

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

    Scheduler:

    This version ofbuffer does not operate by default on a particularScheduler.

    Type Parameters:

    B - the boundary value type (ignored)

    Parameters:

    boundary - the boundary ObservableSource

    initialCapacity - the initial capacity of each buffer chunk

    Returns:

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

    See Also:

    ReactiveX operators documentation: Buffer,buffer(ObservableSource)

  • buffer

    @CheckReturnValue@SchedulerSupport(value="none")public final <B,U extendsCollection<? superT>> Observable<U> buffer(ObservableSource<B> boundary,Callable<U> bufferSupplier)

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

    

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

    Scheduler:

    This version ofbuffer does not operate by default on a particularScheduler.

    Type Parameters:

    U - the collection subclass type to buffer into

    B - the boundary value type (ignored)

    Parameters:

    boundary - the boundary ObservableSource

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

    Returns:

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

    See Also:

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

  • buffer

    @CheckReturnValue@SchedulerSupport(value="none")public final <B> Observable<List<T>> buffer(Callable<? extendsObservableSource<B>> boundarySupplier)

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

    

    If either the sourceObservableSource or the boundaryObservableSource issues anonError notification the event is passed on immediately without first emitting the buffer it is in the process of assembling.

    Scheduler:

    This version ofbuffer does not operate by default on a particularScheduler.

    Type Parameters:

    B - the value type of the boundary-providing ObservableSource

    Parameters:

    boundarySupplier - aCallable that produces an ObservableSource that governs the boundary between buffers. Whenever the suppliedObservableSource emits an item,buffer emits the current buffer and begins to fill a new one

    Returns:

    an Observable that emits a connected, non-overlapping buffer of items from the source ObservableSource each time the ObservableSource created with theclosingIndicator argument emits an item

    See Also:

    ReactiveX operators documentation: Buffer

  • buffer

    @CheckReturnValue@SchedulerSupport(value="none")public final <B,U extendsCollection<? superT>> Observable<U> buffer(Callable<? extendsObservableSource<B>> boundarySupplier,Callable<U> bufferSupplier)

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

    

    If either the sourceObservableSource or the boundaryObservableSource issues anonError notification the event is passed on immediately without first emitting the buffer it is in the process of assembling.

    Scheduler:

    This version ofbuffer does not operate by default on a particularScheduler.

    Type Parameters:

    U - the collection subclass type to buffer into

    B - the value type of the boundary-providing ObservableSource

    Parameters:

    boundarySupplier - aCallable that produces an ObservableSource that governs the boundary between buffers. Whenever the suppliedObservableSource emits an item,buffer emits the current buffer and begins to fill a new one

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

    Returns:

    an Observable that emits a connected, non-overlapping buffer of items from the source ObservableSource each time the ObservableSource created with theclosingIndicator argument emits an item

    See Also:

    ReactiveX operators documentation: Buffer

  • cache

    @CheckReturnValue@SchedulerSupport(value="none")public final Observable<T> cache()

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

    

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

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

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

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

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

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

    Scheduler:

    cache does not operate by default on a particularScheduler.

    Returns:

    an Observable that, when first subscribed to, caches all of its items and notifications for the benefit of subsequent subscribers

    See Also:

    ReactiveX operators documentation: Replay

  • cacheWithInitialCapacity

    @CheckReturnValue@SchedulerSupport(value="none")public final Observable<T> cacheWithInitialCapacity(int initialCapacity)

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

    

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

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

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

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

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

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

    Scheduler:

    cacheWithInitialCapacity does not operate by default on a particularScheduler.

    Note: The capacity hint is not an upper bound on cache size. For that, considerreplay(int) in combination withConnectableObservable.autoConnect() or similar.

    Parameters:

    initialCapacity - hint for number of items to cache (for optimizing underlying data structure)

    Returns:

    an Observable that, when first subscribed to, caches all of its items and notifications for the benefit of subsequent subscribers

    See Also:

    ReactiveX operators documentation: Replay

  • cast

    @CheckReturnValue@SchedulerSupport(value="none")public final <U> Observable<U> cast(Class<U> clazz)

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

    

    Scheduler:

    cast does not operate by default on a particularScheduler.

    Type Parameters:

    U - the output value type cast to

    Parameters:

    clazz - the target class type thatcast will cast the items emitted by the source ObservableSource into before emitting them from the resulting ObservableSource

    Returns:

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

    See Also:

    ReactiveX operators documentation: Map

  • collect

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

    Collects items emitted by the finite source ObservableSource into a single mutable data structure and returns a Single that emits this structure.

    

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

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

    Scheduler:

    collect does not operate by default on a particularScheduler.

    Type Parameters:

    U - the accumulator and output type

    Parameters:

    initialValueSupplier - the mutable data structure that will collect the items

    collector - a function that accepts thestate and an emitted item, and modifiesstate accordingly

    Returns:

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

    See Also:

    ReactiveX operators documentation: Reduce

  • collectInto

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

    Collects items emitted by the finite source ObservableSource into a single mutable data structure and returns a Single that emits this structure.

    

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

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

    Scheduler:

    collectInto does not operate by default on a particularScheduler.

    Type Parameters:

    U - the accumulator and output type

    Parameters:

    initialValue - the mutable data structure that will collect the items

    collector - a function that accepts thestate and an emitted item, and modifiesstate accordingly

    Returns:

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

    See Also:

    ReactiveX operators documentation: Reduce

  • compose

    @CheckReturnValue@SchedulerSupport(value="none")public final <R> Observable<R> compose(ObservableTransformer<? superT,? extends R> composer)

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

    This method operates on the ObservableSource itself whereaslift(io.reactivex.ObservableOperator<? extends R, ? super T>) operates on the ObservableSource's Observers.

    If the operator you are creating is designed to act on the individual items emitted by a source ObservableSource, uselift(io.reactivex.ObservableOperator<? extends R, ? super T>). If your operator is designed to transform the source ObservableSource as a whole (for instance, by applying a particular set of existing RxJava operators to it) usecompose.

    Scheduler:

    compose does not operate by default on a particularScheduler.

    Type Parameters:

    R - the value type of the output ObservableSource

    Parameters:

    composer - implements the function that transforms the source ObservableSource

    Returns:

    the source ObservableSource, transformed by the transformer function

    See Also:

    RxJava wiki: Implementing Your Own Operators

  • concatMap

    @CheckReturnValue@SchedulerSupport(value="none")public final <R> Observable<R> concatMap(Function<? superT,? extendsObservableSource<? extends R>> mapper)

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

    

    Scheduler:

    concatMap does not operate by default on a particularScheduler.

    Type Parameters:

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

    Parameters:

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

    Returns:

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

    See Also:

    ReactiveX operators documentation: FlatMap

  • concatMap

    @CheckReturnValue@SchedulerSupport(value="none")public final <R> Observable<R> concatMap(Function<? superT,? extendsObservableSource<? extends R>> mapper,        int prefetch)

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

    

    Scheduler:

    concatMap does not operate by default on a particularScheduler.

    Type Parameters:

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

    Parameters:

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

    prefetch - the number of elements to prefetch from the current Observable

    Returns:

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

    See Also:

    ReactiveX operators documentation: FlatMap

  • concatMapDelayError

    @CheckReturnValue@SchedulerSupport(value="none")public final <R> Observable<R> concatMapDelayError(Function<? superT,? extendsObservableSource<? extends R>> mapper)

    Maps each of the items into an ObservableSource, subscribes to them one after the other, one at a time and emits their values in order while delaying any error from either this or any of the inner ObservableSources till all of them terminate.

    

    Scheduler:

    concatMapDelayError does not operate by default on a particularScheduler.

    Type Parameters:

    R - the result value type

    Parameters:

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

    Returns:

    the new ObservableSource instance with the concatenation behavior

  • concatMapDelayError

    @CheckReturnValue@SchedulerSupport(value="none")public final <R> Observable<R> concatMapDelayError(Function<? superT,? extendsObservableSource<? extends R>> mapper,        int prefetch,        boolean tillTheEnd)

    Maps each of the items into an ObservableSource, subscribes to them one after the other, one at a time and emits their values in order while delaying any error from either this or any of the inner ObservableSources till all of them terminate.

    

    Scheduler:

    concatMapDelayError does not operate by default on a particularScheduler.

    Type Parameters:

    R - the result value type

    Parameters:

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

    prefetch - the number of elements to prefetch from the current Observable

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

    Returns:

    the new ObservableSource instance with the concatenation behavior

  • concatMapEager

    @CheckReturnValue@SchedulerSupport(value="none")public final <R> Observable<R> concatMapEager(Function<? superT,? extendsObservableSource<? extends R>> mapper)

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

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

    

    Scheduler:

    This method does not operate by default on a particularScheduler.

    Type Parameters:

    R - the value type

    Parameters:

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

    Returns:

    the new ObservableSource instance with the specified concatenation behavior

    Since:

    2.0

  • concatMapEager

    @CheckReturnValue@SchedulerSupport(value="none")public final <R> Observable<R> concatMapEager(Function<? superT,? extendsObservableSource<? extends R>> mapper,        int maxConcurrency,        int prefetch)

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

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

    

    Scheduler:

    This method does not operate by default on a particularScheduler.

    Type Parameters:

    R - the value type

    Parameters:

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

    maxConcurrency - the maximum number of concurrent subscribed ObservableSources

    prefetch - hints about the number of expected values from each inner ObservableSource, must be positive

    Returns:

    the new ObservableSource instance with the specified concatenation behavior

    Since:

    2.0

  • concatMapEagerDelayError

    @CheckReturnValue@SchedulerSupport(value="none")public final <R> Observable<R> concatMapEagerDelayError(Function<? superT,? extendsObservableSource<? extends R>> mapper,        boolean tillTheEnd)

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

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

    

    Scheduler:

    This method does not operate by default on a particularScheduler.

    Type Parameters:

    R - the value type

    Parameters:

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

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

    Returns:

    the new ObservableSource instance with the specified concatenation behavior

    Since:

    2.0

  • concatMapEagerDelayError

    @CheckReturnValue@SchedulerSupport(value="none")public final <R> Observable<R> concatMapEagerDelayError(Function<? superT,? extendsObservableSource<? extends R>> mapper,        int maxConcurrency,        int prefetch,        boolean tillTheEnd)

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

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

    

    Scheduler:

    This method does not operate by default on a particularScheduler.

    Type Parameters:

    R - the value type

    Parameters:

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

    maxConcurrency - the maximum number of concurrent subscribed ObservableSources

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

    tillTheEnd - if true, exceptions from the current Observable and all the inner ObservableSources are delayed until all of them terminate, if false, exception from the current Observable is delayed until the currently running ObservableSource terminates

    Returns:

    the new ObservableSource instance with the specified concatenation behavior

    Since:

    2.0

  • concatMapCompletable

    @CheckReturnValue@SchedulerSupport(value="none")public final Completable concatMapCompletable(Function<? superT,? extendsCompletableSource> mapper)

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

    

    Scheduler:

    concatMapCompletable does not operate by default on a particularScheduler.

    History: 2.1.6 - experimental

    Parameters:

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

    Returns:

    a Completable that signalsonComplete when the upstream and all CompletableSources complete

    Since:

    2.2

  • concatMapCompletable

    @CheckReturnValue@SchedulerSupport(value="none")public final Completable concatMapCompletable(Function<? superT,? extendsCompletableSource> mapper,        int capacityHint)

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

    

    Scheduler:

    concatMapCompletable does not operate by default on a particularScheduler.

    History: 2.1.6 - experimental

    Parameters:

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

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

    Returns:

    a Completable that signalsonComplete when the upstream and all CompletableSources complete

    Since:

    2.2

  • concatMapCompletableDelayError

    @CheckReturnValue@SchedulerSupport(value="none")public final Completable concatMapCompletableDelayError(Function<? superT,? extendsCompletableSource> mapper)

    Maps the upstream items intoCompletableSources and subscribes to them one after the other terminates, delaying all errors till both thisObservable and all innerCompletableSources terminate.

    

    Scheduler:

    concatMapCompletableDelayError does not operate by default on a particularScheduler.

    History: 2.1.11 - experimental

    Parameters:

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

    Returns:

    a new Completable instance

    Since:

    2.2

    See Also:

    concatMapCompletable(Function, int)

  • concatMapCompletableDelayError

    @CheckReturnValue@SchedulerSupport(value="none")public final Completable concatMapCompletableDelayError(Function<? superT,? extendsCompletableSource> mapper,        boolean tillTheEnd)

    Maps the upstream items intoCompletableSources and subscribes to them one after the other terminates, optionally delaying all errors till both thisObservable and all innerCompletableSources terminate.

    

    Scheduler:

    concatMapCompletableDelayError does not operate by default on a particularScheduler.

    History: 2.1.11 - experimental

    Parameters:

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

    tillTheEnd - Iftrue, errors from thisObservable or any of the innerCompletableSources are delayed until all of them terminate. Iffalse, an error from thisObservable is delayed until the current innerCompletableSource terminates and only then is it emitted to the downstream.

    Returns:

    a new Completable instance

    Since:

    2.2

    See Also:

    concatMapCompletable(Function)

  • concatMapCompletableDelayError

    @CheckReturnValue@SchedulerSupport(value="none")public final Completable concatMapCompletableDelayError(Function<? superT,? extendsCompletableSource> mapper,        boolean tillTheEnd,        int prefetch)

    Maps the upstream items intoCompletableSources and subscribes to them one after the other terminates, optionally delaying all errors till both thisObservable and all innerCompletableSources terminate.

    

    Scheduler:

    concatMapCompletableDelayError does not operate by default on a particularScheduler.

    History: 2.1.11 - experimental

    Parameters:

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

    tillTheEnd - Iftrue, errors from thisObservable or any of the innerCompletableSources are delayed until all of them terminate. Iffalse, an error from thisObservable is delayed until the current innerCompletableSource terminates and only then is it emitted to the downstream.

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

    Returns:

    a new Completable instance

    Since:

    2.2

    See Also:

    concatMapCompletable(Function, int)

  • concatMapIterable

    @CheckReturnValue@SchedulerSupport(value="none")public final <U> Observable<U> concatMapIterable(Function<? superT,? extendsIterable<? extends U>> mapper)

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

    

    Scheduler:

    concatMapIterable does not operate by default on a particularScheduler.

    Type Parameters:

    U - the type of item emitted by the resulting ObservableSource

    Parameters:

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

    Returns:

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

    See Also:

    ReactiveX operators documentation: FlatMap

  • concatMapIterable

    @CheckReturnValue@SchedulerSupport(value="none")public final <U> Observable<U> concatMapIterable(Function<? superT,? extendsIterable<? extends U>> mapper,        int prefetch)

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

    

    Scheduler:

    concatMapIterable does not operate by default on a particularScheduler.

    Type Parameters:

    U - the type of item emitted by the resulting ObservableSource

    Parameters:

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

    prefetch - the number of elements to prefetch from the current Observable

    Returns:

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

    See Also:

    ReactiveX operators documentation: FlatMap

  • concatMapMaybe

    @CheckReturnValue@SchedulerSupport(value="none")public final <R> Observable<R> concatMapMaybe(Function<? superT,? extendsMaybeSource<? extends R>> mapper)

    Maps the upstream items intoMaybeSources and subscribes to them one after the other succeeds or completes, emits their success value if available or terminates immediately if either thisObservable or the current innerMaybeSource fail.

    

    Scheduler:

    concatMapMaybe does not operate by default on a particularScheduler.

    History: 2.1.11 - experimental

    Type Parameters:

    R - the result type of the innerMaybeSources

    Parameters:

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

    Returns:

    a new Observable instance

    Since:

    2.2

    See Also:

    concatMapMaybeDelayError(Function),concatMapMaybe(Function, int)

  • concatMapMaybe

    @CheckReturnValue@SchedulerSupport(value="none")public final <R> Observable<R> concatMapMaybe(Function<? superT,? extendsMaybeSource<? extends R>> mapper,        int prefetch)

    Maps the upstream items intoMaybeSources and subscribes to them one after the other succeeds or completes, emits their success value if available or terminates immediately if either thisObservable or the current innerMaybeSource fail.

    

    Scheduler:

    concatMapMaybe does not operate by default on a particularScheduler.

    History: 2.1.11 - experimental

    Type Parameters:

    R - the result type of the innerMaybeSources

    Parameters:

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

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

    Returns:

    a new Observable instance

    Since:

    2.2

    See Also:

    concatMapMaybe(Function),concatMapMaybeDelayError(Function, boolean, int)

  • concatMapMaybeDelayError

    @CheckReturnValue@SchedulerSupport(value="none")public final <R> Observable<R> concatMapMaybeDelayError(Function<? superT,? extendsMaybeSource<? extends R>> mapper)

    Maps the upstream items intoMaybeSources and subscribes to them one after the other terminates, emits their success value if available and delaying all errors till both thisObservable and all innerMaybeSources terminate.

    

    Scheduler:

    concatMapMaybeDelayError does not operate by default on a particularScheduler.

    History: 2.1.11 - experimental

    Type Parameters:

    R - the result type of the innerMaybeSources

    Parameters:

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

    Returns:

    a new Observable instance

    Since:

    2.2

    See Also:

    concatMapMaybe(Function),concatMapMaybeDelayError(Function, boolean)

  • concatMapMaybeDelayError

    @CheckReturnValue@SchedulerSupport(value="none")public final <R> Observable<R> concatMapMaybeDelayError(Function<? superT,? extendsMaybeSource<? extends R>> mapper,        boolean tillTheEnd)

    Maps the upstream items intoMaybeSources and subscribes to them one after the other terminates, emits their success value if available and optionally delaying all errors till both thisObservable and all innerMaybeSources terminate.

    

    Scheduler:

    concatMapMaybeDelayError does not operate by default on a particularScheduler.

    History: 2.1.11 - experimental

    Type Parameters:

    R - the result type of the innerMaybeSources

    Parameters:

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

    tillTheEnd - Iftrue, errors from thisObservable or any of the innerMaybeSources are delayed until all of them terminate. Iffalse, an error from thisObservable is delayed until the current innerMaybeSource terminates and only then is it emitted to the downstream.

    Returns:

    a new Observable instance

    Since:

    2.2

    See Also:

    concatMapMaybe(Function, int),concatMapMaybeDelayError(Function, boolean, int)

  • concatMapMaybeDelayError

    @CheckReturnValue@SchedulerSupport(value="none")public final <R> Observable<R> concatMapMaybeDelayError(Function<? superT,? extendsMaybeSource<? extends R>> mapper,        boolean tillTheEnd,        int prefetch)

    Maps the upstream items intoMaybeSources and subscribes to them one after the other terminates, emits their success value if available and optionally delaying all errors till both thisObservable and all innerMaybeSources terminate.

    

    Scheduler:

    concatMapMaybeDelayError does not operate by default on a particularScheduler.

    History: 2.1.11 - experimental

    Type Parameters:

    R - the result type of the innerMaybeSources

    Parameters:

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

    tillTheEnd - Iftrue, errors from thisObservable or any of the innerMaybeSources are delayed until all of them terminate. Iffalse, an error from thisObservable is delayed until the current innerMaybeSource terminates and only then is it emitted to the downstream.

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

    Returns:

    a new Observable instance

    Since:

    2.2

    See Also:

    concatMapMaybe(Function, int)

  • concatMapSingle

    @CheckReturnValue@SchedulerSupport(value="none")public final <R> Observable<R> concatMapSingle(Function<? superT,? extendsSingleSource<? extends R>> mapper)

    Maps the upstream items intoSingleSources and subscribes to them one after the other succeeds, emits their success values or terminates immediately if either thisObservable or the current innerSingleSource fail.

    

    Scheduler:

    concatMapSingle does not operate by default on a particularScheduler.

    History: 2.1.11 - experimental

    Type Parameters:

    R - the result type of the innerSingleSources

    Parameters:

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

    Returns:

    a new Observable instance

    Since:

    2.2

    See Also:

    concatMapSingleDelayError(Function),concatMapSingle(Function, int)

  • concatMapSingle

    @CheckReturnValue@SchedulerSupport(value="none")public final <R> Observable<R> concatMapSingle(Function<? superT,? extendsSingleSource<? extends R>> mapper,        int prefetch)

    Maps the upstream items intoSingleSources and subscribes to them one after the other succeeds, emits their success values or terminates immediately if either thisObservable or the current innerSingleSource fail.

    

    Scheduler:

    concatMapSingle does not operate by default on a particularScheduler.

    History: 2.1.11 - experimental

    Type Parameters:

    R - the result type of the innerSingleSources

    Parameters:

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

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

    Returns:

    a new Observable instance

    Since:

    2.2

    See Also:

    concatMapSingle(Function),concatMapSingleDelayError(Function, boolean, int)

  • concatMapSingleDelayError

    @CheckReturnValue@SchedulerSupport(value="none")public final <R> Observable<R> concatMapSingleDelayError(Function<? superT,? extendsSingleSource<? extends R>> mapper)

    Maps the upstream items intoSingleSources and subscribes to them one after the other succeeds or fails, emits their success values and delays all errors till both thisObservable and all innerSingleSources terminate.

    

    Scheduler:

    concatMapSingleDelayError does not operate by default on a particularScheduler.

    History: 2.1.11 - experimental

    Type Parameters:

    R - the result type of the innerSingleSources

    Parameters:

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

    Returns:

    a new Observable instance

    Since:

    2.2

    See Also:

    concatMapSingle(Function),concatMapSingleDelayError(Function, boolean)

  • concatMapSingleDelayError

    @CheckReturnValue@SchedulerSupport(value="none")public final <R> Observable<R> concatMapSingleDelayError(Function<? superT,? extendsSingleSource<? extends R>> mapper,        boolean tillTheEnd)

    Maps the upstream items intoSingleSources and subscribes to them one after the other succeeds or fails, emits their success values and optionally delays all errors till both thisObservable and all innerSingleSources terminate.

    

    Scheduler:

    concatMapSingleDelayError does not operate by default on a particularScheduler.

    History: 2.1.11 - experimental

    Type Parameters:

    R - the result type of the innerSingleSources

    Parameters:

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

    tillTheEnd - Iftrue, errors from thisObservable or any of the innerSingleSources are delayed until all of them terminate. Iffalse, an error from thisObservable is delayed until the current innerSingleSource terminates and only then is it emitted to the downstream.

    Returns:

    a new Observable instance

    Since:

    2.2

    See Also:

    concatMapSingle(Function, int),concatMapSingleDelayError(Function, boolean, int)

  • concatMapSingleDelayError

    @CheckReturnValue@SchedulerSupport(value="none")public final <R> Observable<R> concatMapSingleDelayError(Function<? superT,? extendsSingleSource<? extends R>> mapper,        boolean tillTheEnd,        int prefetch)

    Maps the upstream items intoSingleSources and subscribes to them one after the other succeeds or fails, emits their success values and optionally delays errors till both thisObservable and all innerSingleSources terminate.

    

    Scheduler:

    concatMapSingleDelayError does not operate by default on a particularScheduler.

    History: 2.1.11 - experimental

    Type Parameters:

    R - the result type of the innerSingleSources

    Parameters:

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

    tillTheEnd - Iftrue, errors from thisObservable or any of the innerSingleSources are delayed until all of them terminate. Iffalse, an error from thisObservable is delayed until the current innerSingleSource terminates and only then is it emitted to the downstream.

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

    Returns:

    a new Observable instance

    Since:

    2.2

    See Also:

    concatMapSingle(Function, int)

  • concatWith

    @CheckReturnValue@SchedulerSupport(value="none")public final Observable<T> concatWith(ObservableSource<? extendsT> other)

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

    

    Scheduler:

    concatWith does not operate by default on a particularScheduler.

    Parameters:

    other - an ObservableSource to be concatenated after the current

    Returns:

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

    See Also:

    ReactiveX operators documentation: Concat

  • concatWith

    @CheckReturnValue@SchedulerSupport(value="none")public final Observable<T> concatWith(@NonNullSingleSource<? extendsT> other)

    Returns anObservable that emits the items from thisObservable followed by the success item or error event of the otherSingleSource.

    

    Scheduler:

    concatWith does not operate by default on a particularScheduler.

    History: 2.1.10 - experimental

    Parameters:

    other - the SingleSource whose signal should be emitted after thisObservable completes normally.

    Returns:

    the new Observable instance

    Since:

    2.2

  • concatWith

    @CheckReturnValue@SchedulerSupport(value="none")public final Observable<T> concatWith(@NonNullMaybeSource<? extendsT> other)

    Returns anObservable that emits the items from thisObservable followed by the success item or terminal events of the otherMaybeSource.

    

    Scheduler:

    concatWith does not operate by default on a particularScheduler.

    History: 2.1.10 - experimental

    Parameters:

    other - the MaybeSource whose signal should be emitted after this Observable completes normally.

    Returns:

    the new Observable instance

    Since:

    2.2

  • concatWith

    @CheckReturnValue@SchedulerSupport(value="none")public final Observable<T> concatWith(@NonNullCompletableSource other)

    Returns anObservable that emits items from thisObservable and when it completes normally, the otherCompletableSource is subscribed to and the returnedObservable emits its terminal events.

    

    Scheduler:

    concatWith does not operate by default on a particularScheduler.

    History: 2.1.10 - experimental

    Parameters:

    other - theCompletableSource to subscribe to once the currentObservable completes normally

    Returns:

    the new Observable instance

    Since:

    2.2

  • contains

    @CheckReturnValue@SchedulerSupport(value="none")public final Single<Boolean> contains(Object element)

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

    

    Scheduler:

    contains does not operate by default on a particularScheduler.

    Parameters:

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

    Returns:

    a Single that emitstrue if the specified item is emitted by the source ObservableSource, orfalse if the source ObservableSource completes without emitting that item

    See Also:

    ReactiveX operators documentation: Contains

  • count

    @CheckReturnValue@SchedulerSupport(value="none")public final Single<Long> count()

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

    

    Scheduler:

    count does not operate by default on a particularScheduler.

    Returns:

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

    See Also:

    ReactiveX operators documentation: Count

  • debounce

    @CheckReturnValue@SchedulerSupport(value="none")public final <U> Observable<T> debounce(Function<? superT,? extendsObservableSource<U>> debounceSelector)

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

    

    The delivery of the item happens on the thread of the firstonNext oronComplete signal of the generatedObservableSource sequence, which if takes too long, a newer item may arrive from the upstream, causing the generated sequence to get disposed, which may also interrupt any downstream blocking operation (yielding anInterruptedException). It is recommended processing items that may take long time to be moved to another thread viaobserveOn(io.reactivex.Scheduler) applied afterdebounce itself.

    Scheduler:

    This version ofdebounce does not operate by default on a particularScheduler.

    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 ObservableSource that are followed by another item within a computed debounce duration

    See Also:

    ReactiveX operators documentation: Debounce

  • debounce

    @CheckReturnValue@SchedulerSupport(value="io.reactivex:computation")public final Observable<T> debounce(long timeout,TimeUnit unit)

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

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

    

    Delivery of the item after the grace period happens on thecomputationScheduler'sWorker which if takes too long, a newer item may arrive from the upstream, causing theWorker's task to get disposed, which may also interrupt any downstream blocking operation (yielding anInterruptedException). It is recommended processing items that may take long time to be moved to another thread viaobserveOn(io.reactivex.Scheduler) applied afterdebounce itself.

    Scheduler:

    debounce operates by default on thecomputationScheduler.

    Parameters:

    timeout - the length of the window of time that must pass after the emission of an item from the source ObservableSource in which that ObservableSource emits no items in order for the item to be emitted by the resulting ObservableSource

    unit - the unit of time for the specifiedtimeout

    Returns:

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

    See Also:

    ReactiveX operators documentation: Debounce,throttleWithTimeout(long, TimeUnit)

  • debounce

    @CheckReturnValue@SchedulerSupport(value="custom")public final Observable<T> debounce(long timeout,TimeUnit unit,Scheduler scheduler)

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

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

    

    Delivery of the item after the grace period happens on the givenScheduler'sWorker which if takes too long, a newer item may arrive from the upstream, causing theWorker's task to get disposed, which may also interrupt any downstream blocking operation (yielding anInterruptedException). It is recommended processing items that may take long time to be moved to another thread viaobserveOn(io.reactivex.Scheduler) applied afterdebounce itself.

    Scheduler:

    You specify whichScheduler this operator will use.

    Parameters:

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

    unit - the unit of time for the specifiedtimeout

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

    Returns:

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

    See Also:

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

  • defaultIfEmpty

    @CheckReturnValue@SchedulerSupport(value="none")public final Observable<T> defaultIfEmpty(T defaultItem)

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

    

    Scheduler:

    defaultIfEmpty does not operate by default on a particularScheduler.

    Parameters:

    defaultItem - the item to emit if the source ObservableSource emits no items

    Returns:

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

    See Also:

    ReactiveX operators documentation: DefaultIfEmpty

  • delay

    @CheckReturnValue@SchedulerSupport(value="none")public final <U> Observable<T> delay(Function<? superT,? extendsObservableSource<U>> itemDelay)

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

    

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

    Scheduler:

    This version ofdelay does not operate by default on a particularScheduler.

    Type Parameters:

    U - the item delay value type (ignored)

    Parameters:

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

    Returns:

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

    See Also:

    ReactiveX operators documentation: Delay

  • delay

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

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

    

    Scheduler:

    This version ofdelay operates by default on thecomputationScheduler.

    Parameters:

    delay - the delay to shift the source by

    unit - theTimeUnit in whichperiod is defined

    Returns:

    the source ObservableSource shifted in time by the specified delay

    See Also:

    ReactiveX operators documentation: Delay

  • delay

    @CheckReturnValue@SchedulerSupport(value="io.reactivex:computation")public final Observable<T> delay(long delay,TimeUnit unit,        boolean delayError)

    Returns an Observable that emits the items emitted by the source ObservableSource shifted forward in time by a specified delay. IfdelayError is true, error notifications will also be delayed.

    

    Scheduler:

    This version ofdelay operates by default on thecomputationScheduler.

    Parameters:

    delay - the delay to shift the source by

    unit - theTimeUnit in whichperiod is defined

    delayError - if true, the upstream exception is signalled with the given delay, after all preceding normal elements, if false, the upstream exception is signalled immediately

    Returns:

    the source ObservableSource shifted in time by the specified delay

    See Also:

    ReactiveX operators documentation: Delay

  • delay

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

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

    

    Scheduler:

    You specify whichScheduler this operator will use.

    Parameters:

    delay - the delay to shift the source by

    unit - the time unit ofdelay

    scheduler - theScheduler to use for delaying

    Returns:

    the source ObservableSource shifted in time by the specified delay

    See Also:

    ReactiveX operators documentation: Delay

  • delay

    @CheckReturnValue@SchedulerSupport(value="custom")public final Observable<T> delay(long delay,TimeUnit unit,Scheduler scheduler,        boolean delayError)

    Returns an Observable that emits the items emitted by the source ObservableSource shifted forward in time by a specified delay. IfdelayError is true, error notifications will also be delayed.

    

    Scheduler:

    You specify whichScheduler this operator will use.

    Parameters:

    delay - the delay to shift the source by

    unit - the time unit ofdelay

    scheduler - theScheduler to use for delaying

    delayError - if true, the upstream exception is signalled with the given delay, after all preceding normal elements, if false, the upstream exception is signalled immediately

    Returns:

    the source ObservableSource shifted in time by the specified delay

    See Also:

    ReactiveX operators documentation: Delay

  • delay

    @CheckReturnValue@SchedulerSupport(value="none")public final <U,V> Observable<T> delay(ObservableSource<U> subscriptionDelay,Function<? superT,? extendsObservableSource<V>> itemDelay)

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

    

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

    Scheduler:

    This version ofdelay does not operate by default on a particularScheduler.

    Type Parameters:

    U - the subscription delay value type (ignored)

    V - the item delay value type (ignored)

    Parameters:

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

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

    Returns:

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

    See Also:

    ReactiveX operators documentation: Delay

  • delaySubscription

    @CheckReturnValue@SchedulerSupport(value="none")public final <U> Observable<T> delaySubscription(ObservableSource<U> other)

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

    

    Scheduler:

    This method does not operate by default on a particularScheduler.

    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:

    2.0

  • delaySubscription

    @CheckReturnValue@SchedulerSupport(value="io.reactivex:computation")public final Observable<T> delaySubscription(long delay,TimeUnit unit)

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

    

    Scheduler:

    This version ofdelaySubscription operates by default on thecomputationScheduler.

    Parameters:

    delay - the time to delay the subscription

    unit - the time unit ofdelay

    Returns:

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

    See Also:

    ReactiveX operators documentation: Delay

  • delaySubscription

    @CheckReturnValue@SchedulerSupport(value="custom")public final Observable<T> delaySubscription(long delay,TimeUnit unit,Scheduler scheduler)

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

    

    Scheduler:

    You specify whichScheduler this operator will use.

    Parameters:

    delay - the time to delay the subscription

    unit - the time unit ofdelay

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

    Returns:

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

    See Also:

    ReactiveX operators documentation: Delay

  • dematerialize

    @CheckReturnValue@SchedulerSupport(value="none")@Deprecatedpublic final <T2> Observable<T2> dematerialize()

    Deprecated. in 2.2.4; inherently type-unsafe as it overrides the output generic type. Usedematerialize(Function) instead.
    Returns an Observable that reverses the effect ofmaterialize by transforming theNotification objects emitted by the source ObservableSource into the items or notifications they represent.

    

    When the upstream signals anonError oronComplete item, the returned Observable disposes of the flow and terminates with that type of terminal event:

     Observable.just(createOnNext(1), createOnComplete(), createOnNext(2)) .doOnDispose(() -> System.out.println("Disposed!")); .dematerialize() .test() .assertResult(1);

    If the upstream signalsonError oronComplete directly, the flow is terminated with the same event.

     Observable.just(createOnNext(1), createOnNext(2)) .dematerialize() .test() .assertResult(1, 2);

    If this behavior is not desired, the completion can be suppressed by applyingconcatWith(ObservableSource) with anever() source.

    Scheduler:

    dematerialize does not operate by default on a particularScheduler.

    Type Parameters:

    T2 - the output value type

    Returns:

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

    See Also:

    ReactiveX operators documentation: Dematerialize,dematerialize(Function)

  • dematerialize

    @CheckReturnValue@SchedulerSupport(value="none")public final <R> Observable<R> dematerialize(Function<? superT,Notification<R>> selector)

    Returns an Observable that reverses the effect ofmaterialize by transforming theNotification objects extracted from the source items via a selector function into their respectiveObserver signal types.

    

    The intended use of theselector function is to perform a type-safe identity mapping (see example) on a source that is already of typeNotification<T>. The Java language doesn't allow limiting instance methods to a certain generic argument shape, therefore, a function is used to ensure the conversion remains type safe.

    When the upstream signals anonError oronComplete item, the returned Observable disposes of the flow and terminates with that type of terminal event:

     Observable.just(createOnNext(1), createOnComplete(), createOnNext(2)) .doOnDispose(() -> System.out.println("Disposed!")); .dematerialize(notification -> notification) .test() .assertResult(1);

    If the upstream signalsonError oronComplete directly, the flow is terminated with the same event.

     Observable.just(createOnNext(1), createOnNext(2)) .dematerialize(notification -> notification) .test() .assertResult(1, 2);

    If this behavior is not desired, the completion can be suppressed by applyingconcatWith(ObservableSource) with anever() source.

    Scheduler:

    dematerialize does not operate by default on a particularScheduler.

    Type Parameters:

    R - the output value type

    Parameters:

    selector - function that returns the upstream item and should return a Notification to signal the correspondingObserver event to the downstream.

    Returns:

    an Observable that emits the items and notifications embedded in theNotification objects selected from the items emitted by the source ObservableSource

    Since:

    2.2.4 - experimental

    See Also:

    ReactiveX operators documentation: Dematerialize

  • distinct

    @CheckReturnValue@SchedulerSupport(value="none")public final Observable<T> distinct()

    Returns an Observable that emits all items emitted by the source ObservableSource that are distinct based onObject.equals(Object) comparison.

    

    It is recommended the elements' classT in the flow overrides the defaultObject.equals() andObject.hashCode() to provide meaningful comparison between items as the default Java implementation only considers reference equivalence.

    By default,distinct() uses an internalHashSet per Observer to remember previously seen items and usesSet.add(Object) returningfalse as the indicator for duplicates.

    Note that this internalHashSet may grow unbounded as items won't be removed from it by the operator. Therefore, using very long or infinite upstream (with very distinct elements) may lead toOutOfMemoryError.

    Customizing the retention policy can happen only by providing a customCollection implementation to thedistinct(Function, Callable) overload.

    Scheduler:

    distinct does not operate by default on a particularScheduler.

    Returns:

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

    See Also:

    ReactiveX operators documentation: Distinct,distinct(Function),distinct(Function, Callable)

  • distinct

    @CheckReturnValue@SchedulerSupport(value="none")public final <K> Observable<T> distinct(Function<? superT,K> keySelector)

    Returns an Observable that emits all items emitted by the source ObservableSource that are distinct according to a key selector function and based onObject.equals(Object) comparison of the objects returned by the key selector function.

    

    It is recommended the keys' classK overrides the defaultObject.equals() andObject.hashCode() to provide meaningful comparison between the key objects as the default Java implementation only considers reference equivalence.

    By default,distinct() uses an internalHashSet per Observer to remember previously seen keys and usesSet.add(Object) returningfalse as the indicator for duplicates.

    Note that this internalHashSet may grow unbounded as keys won't be removed from it by the operator. Therefore, using very long or infinite upstream (with very distinct keys) may lead toOutOfMemoryError.

    Customizing the retention policy can happen only by providing a customCollection implementation to thedistinct(Function, Callable) overload.

    Scheduler:

    distinct does not operate by default on a particularScheduler.

    Type Parameters:

    K - the key type

    Parameters:

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

    Returns:

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

    See Also:

    ReactiveX operators documentation: Distinct,distinct(Function, Callable)

  • distinct

    @CheckReturnValue@SchedulerSupport(value="none")public final <K> Observable<T> distinct(Function<? superT,K> keySelector,Callable<? extendsCollection<? super K>> collectionSupplier)

    Returns an Observable that emits all items emitted by the source ObservableSource that are distinct according to a key selector function and based onObject.equals(Object) comparison of the objects returned by the key selector function.

    

    It is recommended the keys' classK overrides the defaultObject.equals() andObject.hashCode() to provide meaningful comparison between the key objects as the default Java implementation only considers reference equivalence.

    Scheduler:

    distinct does not operate by default on a particularScheduler.

    Type Parameters:

    K - the key type

    Parameters:

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

    collectionSupplier - function called for each individual Observer to return a Collection subtype for holding the extracted keys and whose add() method's return indicates uniqueness.

    Returns:

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

    See Also:

    ReactiveX operators documentation: Distinct

  • distinctUntilChanged

    @CheckReturnValue@SchedulerSupport(value="none")public final Observable<T> distinctUntilChanged()

    Returns an Observable that emits all items emitted by the source ObservableSource that are distinct from their immediate predecessors based onObject.equals(Object) comparison.

    

    It is recommended the elements' classT in the flow overrides the defaultObject.equals() to provide meaningful comparison between items as the default Java implementation only considers reference equivalence. Alternatively, use thedistinctUntilChanged(BiPredicate) overload and provide a comparison function in case the classT can't be overridden with customequals() or the comparison itself should happen on different terms or properties of the classT.

    Note that the operator always retains the latest item from upstream regardless of the comparison result and uses it in the next comparison with the next upstream item.

    Note that if element typeT in the flow is mutable, the comparison of the previous and current item may yield unexpected results if the items are mutated externally. Common cases are mutableCharSequences orLists where the objects will actually have the same references when they are modified anddistinctUntilChanged will evaluate subsequent items as same. To avoid such situation, it is recommended that mutable data is converted to an immutable one, for example usingmap(CharSequence::toString) ormap(list -> Collections.unmodifiableList(new ArrayList<>(list))).

    Scheduler:

    distinctUntilChanged does not operate by default on a particularScheduler.

    Returns:

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

    See Also:

    ReactiveX operators documentation: Distinct,distinctUntilChanged(BiPredicate)

  • distinctUntilChanged

    @CheckReturnValue@SchedulerSupport(value="none")public final <K> Observable<T> distinctUntilChanged(Function<? superT,K> keySelector)

    Returns an Observable that emits all items emitted by the source ObservableSource that are distinct from their immediate predecessors, according to a key selector function and based onObject.equals(Object) comparison of those objects returned by the key selector function.

    

    It is recommended the keys' classK overrides the defaultObject.equals() to provide meaningful comparison between the key objects as the default Java implementation only considers reference equivalence. Alternatively, use thedistinctUntilChanged(BiPredicate) overload and provide a comparison function in case the classK can't be overridden with customequals() or the comparison itself should happen on different terms or properties of the item classT (for which the keys can be derived via a similar selector).

    Note that the operator always retains the latest key from upstream regardless of the comparison result and uses it in the next comparison with the next key derived from the next upstream item.

    Note that if element typeT in the flow is mutable, the comparison of the previous and current item may yield unexpected results if the items are mutated externally. Common cases are mutableCharSequences orLists where the objects will actually have the same references when they are modified anddistinctUntilChanged will evaluate subsequent items as same. To avoid such situation, it is recommended that mutable data is converted to an immutable one, for example usingmap(CharSequence::toString) ormap(list -> Collections.unmodifiableList(new ArrayList<>(list))).

    Scheduler:

    distinctUntilChanged does not operate by default on a particularScheduler.

    Type Parameters:

    K - the key type

    Parameters:

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

    Returns:

    an Observable that emits those items from the source ObservableSource whose keys are distinct from those of their immediate predecessors

    See Also:

    ReactiveX operators documentation: Distinct

  • distinctUntilChanged

    @CheckReturnValue@SchedulerSupport(value="none")public final Observable<T> distinctUntilChanged(BiPredicate<? superT,? superT> comparer)

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

    

    Note that the operator always retains the latest item from upstream regardless of the comparison result and uses it in the next comparison with the next upstream item.

    Note that if element typeT in the flow is mutable, the comparison of the previous and current item may yield unexpected results if the items are mutated externally. Common cases are mutableCharSequences orLists where the objects will actually have the same references when they are modified anddistinctUntilChanged will evaluate subsequent items as same. To avoid such situation, it is recommended that mutable data is converted to an immutable one, for example usingmap(CharSequence::toString) ormap(list -> Collections.unmodifiableList(new ArrayList<>(list))).

    Scheduler:

    distinctUntilChanged does not operate by default on a particularScheduler.

    Parameters:

    comparer - the function that receives the previous item and the current item and is expected to return true if the two are equal, thus skipping the current value.

    Returns:

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

    Since:

    2.0

    See Also:

    ReactiveX operators documentation: Distinct

  • doAfterNext

    @CheckReturnValue@SchedulerSupport(value="none")public final Observable<T> doAfterNext(Consumer<? superT> onAfterNext)

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

    Note that theonAfterNext action is shared between subscriptions and as such should be thread-safe.

    

    Scheduler:

    doAfterNext does not operate by default on a particularScheduler.

    Operator-fusion:

    This operator supports boundary-limited synchronous or asynchronous queue-fusion.

    History: 2.0.1 - experimental

    Parameters:

    onAfterNext - the Consumer that will be called after emitting an item from upstream to the downstream

    Returns:

    the new Observable instance

    Since:

    2.1

  • doAfterTerminate

    @CheckReturnValue@SchedulerSupport(value="none")public final Observable<T> doAfterTerminate(Action onFinally)

    Registers anAction to be called when this ObservableSource invokes eitheronComplete oronError.

    

    Scheduler:

    doAfterTerminate does not operate by default on a particularScheduler.

    Parameters:

    onFinally - anAction to be invoked when the source ObservableSource finishes

    Returns:

    an Observable that emits the same items as the source ObservableSource, then invokes theAction

    See Also:

    ReactiveX operators documentation: Do,doOnTerminate(Action)

  • doFinally

    @CheckReturnValue@SchedulerSupport(value="none")public final Observable<T> doFinally(Action onFinally)

    Calls the specified action after this Observable signals onError or onCompleted or gets disposed by the downstream.

    In case of a race between a terminal event and a dispose call, the providedonFinally action is executed once per subscription.

    Note that theonFinally action is shared between subscriptions and as such should be thread-safe.

    

    Scheduler:

    doFinally does not operate by default on a particularScheduler.

    Operator-fusion:

    This operator supports boundary-limited synchronous or asynchronous queue-fusion.

    History: 2.0.1 - experimental

    Parameters:

    onFinally - the action called when this Observable terminates or gets disposed

    Returns:

    the new Observable instance

    Since:

    2.1

  • doOnDispose

    @CheckReturnValue@SchedulerSupport(value="none")public final Observable<T> doOnDispose(Action onDispose)

    Calls the disposeAction if the downstream disposes the sequence.

    The action is shared between subscriptions and thus may be called concurrently from multiple threads; the action must be thread safe.

    If the action throws a runtime exception, that exception is rethrown by thedispose() call, sometimes as aCompositeException if there were multiple exceptions along the way.

    

    Scheduler:

    doOnDispose does not operate by default on a particularScheduler.

    Parameters:

    onDispose - the action that gets called when the sourceObservableSource's Disposable is disposed

    Returns:

    the sourceObservableSource modified so as to call this Action when appropriate

    Throws:

    NullPointerException - if onDispose is null

    See Also:

    ReactiveX operators documentation: Do

  • doOnComplete

    @CheckReturnValue@SchedulerSupport(value="none")public final Observable<T> doOnComplete(Action onComplete)

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

    

    Scheduler:

    doOnComplete does not operate by default on a particularScheduler.

    Parameters:

    onComplete - the action to invoke when the source ObservableSource callsonComplete

    Returns:

    the source ObservableSource with the side-effecting behavior applied

    See Also:

    ReactiveX operators documentation: Do

  • doOnEach

    @CheckReturnValue@SchedulerSupport(value="none")public final Observable<T> doOnEach(Consumer<? superNotification<T>> onNotification)

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

    

    Scheduler:

    doOnEach does not operate by default on a particularScheduler.

    Parameters:

    onNotification - the action to invoke for each item emitted by the source ObservableSource

    Returns:

    the source ObservableSource with the side-effecting behavior applied

    See Also:

    ReactiveX operators documentation: Do

  • doOnEach

    @CheckReturnValue@SchedulerSupport(value="none")public final Observable<T> doOnEach(Observer<? superT> observer)

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

    In case theonError of the supplied observer throws, the downstream will receive a composite exception containing the original exception and the exception thrown byonError. If either theonNext or theonComplete method of the supplied observer throws, the downstream will be terminated and will receive this thrown exception.

    

    Scheduler:

    doOnEach does not operate by default on a particularScheduler.

    Parameters:

    observer - the observer to be notified about onNext, onError and onComplete events on its respective methods before the actual downstream Observer gets notified.

    Returns:

    the source ObservableSource with the side-effecting behavior applied

    See Also:

    ReactiveX operators documentation: Do

  • doOnError

    @CheckReturnValue@SchedulerSupport(value="none")public final Observable<T> doOnError(Consumer<? superThrowable> onError)

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

    In case theonError action throws, the downstream will receive a composite exception containing the original exception and the exception thrown byonError.

    

    Scheduler:

    doOnError does not operate by default on a particularScheduler.

    Parameters:

    onError - the action to invoke if the source ObservableSource callsonError

    Returns:

    the source ObservableSource with the side-effecting behavior applied

    See Also:

    ReactiveX operators documentation: Do

  • doOnLifecycle

    @CheckReturnValue@SchedulerSupport(value="none")public final Observable<T> doOnLifecycle(Consumer<? superDisposable> onSubscribe,Action onDispose)

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

    

    Scheduler:

    doOnLifecycle does not operate by default on a particularScheduler.

    Parameters:

    onSubscribe - a Consumer called with the Disposable sent via Observer.onSubscribe()

    onDispose - called when the downstream disposes the Disposable via dispose()

    Returns:

    the source ObservableSource with the side-effecting behavior applied

    See Also:

    ReactiveX operators documentation: Do

  • doOnNext

    @CheckReturnValue@SchedulerSupport(value="none")public final Observable<T> doOnNext(Consumer<? superT> onNext)

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

    

    Scheduler:

    doOnNext does not operate by default on a particularScheduler.

    Parameters:

    onNext - the action to invoke when the source ObservableSource callsonNext

    Returns:

    the source ObservableSource with the side-effecting behavior applied

    See Also:

    ReactiveX operators documentation: Do

  • doOnSubscribe

    @CheckReturnValue@SchedulerSupport(value="none")public final Observable<T> doOnSubscribe(Consumer<? superDisposable> onSubscribe)

    Modifies the sourceObservableSource 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 sourceObservableSource is reference counted, in which case the sourceObservableSource will invoke the given action for the first subscription.

    

    Scheduler:

    doOnSubscribe does not operate by default on a particularScheduler.

    Parameters:

    onSubscribe - the Consumer that gets called when an Observer subscribes to the currentObservable

    Returns:

    the sourceObservableSource modified so as to call this Consumer when appropriate

    See Also:

    ReactiveX operators documentation: Do

  • doOnTerminate

    @CheckReturnValue@SchedulerSupport(value="none")public final Observable<T> doOnTerminate(Action onTerminate)

    Modifies the source ObservableSource so that it invokes an action when it callsonComplete oronError.

    

    This differs fromdoAfterTerminate in that this happensbefore theonComplete oronError notification.

    Scheduler:

    doOnTerminate does not operate by default on a particularScheduler.

    Parameters:

    onTerminate - the action to invoke when the source ObservableSource callsonComplete oronError

    Returns:

    the source ObservableSource with the side-effecting behavior applied

    See Also:

    ReactiveX operators documentation: Do,doAfterTerminate(Action)

  • elementAt

    @CheckReturnValue@SchedulerSupport(value="none")public final Maybe<T> elementAt(long index)

    Returns a Maybe that emits the single item at a specified index in a sequence of emissions from this Observable or completes if this Observable signals fewer elements than index.

    

    Scheduler:

    elementAt does not operate by default on a particularScheduler.

    Parameters:

    index - the zero-based index of the item to retrieve

    Returns:

    a Maybe that emits a single item: the item at the specified position in the sequence of those emitted by the source ObservableSource

    Throws:

    IndexOutOfBoundsException - ifindex is less than 0

    See Also:

    ReactiveX operators documentation: ElementAt

  • elementAt

    @CheckReturnValue@SchedulerSupport(value="none")public final Single<T> elementAt(long index,T defaultItem)

    Returns a Single that emits the item found at a specified index in a sequence of emissions from this Observable, or a default item if that index is out of range.

    

    Scheduler:

    elementAt does not operate by default on a particularScheduler.

    Parameters:

    index - the zero-based index of the item to retrieve

    defaultItem - the default item

    Returns:

    a Single that emits the item at the specified position in the sequence emitted by the source ObservableSource, or the default item if that index is outside the bounds of the source sequence

    Throws:

    IndexOutOfBoundsException - ifindex is less than 0

    See Also:

    ReactiveX operators documentation: ElementAt

  • elementAtOrError

    @CheckReturnValue@SchedulerSupport(value="none")public final Single<T> elementAtOrError(long index)

    Returns a Single that emits the item found at a specified index in a sequence of emissions from this Observable or signals aNoSuchElementException if this Observable signals fewer elements than index.

    

    Scheduler:

    elementAtOrError does not operate by default on a particularScheduler.

    Parameters:

    index - the zero-based index of the item to retrieve

    Returns:

    a Single that emits the item at the specified position in the sequence emitted by the source ObservableSource, or the default item if that index is outside the bounds of the source sequence

    Throws:

    IndexOutOfBoundsException - ifindex is less than 0

    See Also:

    ReactiveX operators documentation: ElementAt

  • filter

    @CheckReturnValue@SchedulerSupport(value="none")public final Observable<T> filter(Predicate<? superT> predicate)

    Filters items emitted by an ObservableSource by only emitting those that satisfy a specified predicate.

    

    Scheduler:

    filter does not operate by default on a particularScheduler.

    Parameters:

    predicate - a function that evaluates each item emitted by the source ObservableSource, returningtrue if it passes the filter

    Returns:

    an Observable that emits only those items emitted by the source ObservableSource that the filter evaluates astrue

    See Also:

    ReactiveX operators documentation: Filter

  • firstElement

    @CheckReturnValue@SchedulerSupport(value="none")public final Maybe<T> firstElement()

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

    

    Scheduler:

    firstElement does not operate by default on a particularScheduler.

    Returns:

    the new Maybe instance

    See Also:

    ReactiveX operators documentation: First

  • first

    @CheckReturnValue@SchedulerSupport(value="none")public final Single<T> first(T defaultItem)

    Returns a Single that emits only the very first item emitted by the source ObservableSource, or a default item if the source ObservableSource completes without emitting any items.

    

    Scheduler:

    first does not operate by default on a particularScheduler.

    Parameters:

    defaultItem - the default item to emit if the source ObservableSource doesn't emit anything

    Returns:

    the new Single instance

    See Also:

    ReactiveX operators documentation: First

  • firstOrError

    @CheckReturnValue@SchedulerSupport(value="none")public final Single<T> firstOrError()

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

    

    Scheduler:

    firstOrError does not operate by default on a particularScheduler.

    Returns:

    the new Single instance

    See Also:

    ReactiveX operators documentation: First

  • flatMap

    @CheckReturnValue@SchedulerSupport(value="none")public final <R> Observable<R> flatMap(Function<? superT,? extendsObservableSource<? extends R>> mapper)

    Returns an Observable that emits items based on applying a function that you supply to each item emitted by the source ObservableSource, where that function returns an ObservableSource, and then merging those resulting ObservableSources and emitting the results of this merger.

    

    Scheduler:

    flatMap does not operate by default on a particularScheduler.

    Type Parameters:

    R - the value type of the inner ObservableSources and the output type

    Parameters:

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

    Returns:

    an Observable that emits the result of applying the transformation function to each item emitted by the source ObservableSource and merging the results of the ObservableSources obtained from this transformation

    See Also:

    ReactiveX operators documentation: FlatMap

  • flatMap

    @CheckReturnValue@SchedulerSupport(value="none")public final <R> Observable<R> flatMap(Function<? superT,? extendsObservableSource<? extends R>> mapper,        boolean delayErrors)

    Returns an Observable that emits items based on applying a function that you supply to each item emitted by the source ObservableSource, where that function returns an ObservableSource, and then merging those resulting ObservableSources and emitting the results of this merger.

    

    Scheduler:

    flatMap does not operate by default on a particularScheduler.

    Type Parameters:

    R - the value type of the inner ObservableSources and the output type

    Parameters:

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

    delayErrors - if true, exceptions from the current Observable and all inner ObservableSources are delayed until all of them terminate if false, the first one signalling an exception will terminate the whole sequence immediately

    Returns:

    an Observable that emits the result of applying the transformation function to each item emitted by the source ObservableSource and merging the results of the ObservableSources obtained from this transformation

    See Also:

    ReactiveX operators documentation: FlatMap

  • flatMap

    @CheckReturnValue@SchedulerSupport(value="none")public final <R> Observable<R> flatMap(Function<? superT,? extendsObservableSource<? extends R>> mapper,        boolean delayErrors,        int maxConcurrency)

    Returns an Observable that emits items based on applying a function that you supply to each item emitted by the source ObservableSource, where that function returns an ObservableSource, and then merging those resulting ObservableSources and emitting the results of this merger, while limiting the maximum number of concurrent subscriptions to these ObservableSources.

    

    Scheduler:

    flatMap does not operate by default on a particularScheduler.

    Type Parameters:

    R - the value type of the inner ObservableSources and the output type

    Parameters:

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

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

    delayErrors - if true, exceptions from the current Observable and all inner ObservableSources are delayed until all of them terminate if false, the first one signalling an exception will terminate the whole sequence immediately

    Returns:

    an Observable that emits the result of applying the transformation function to each item emitted by the source ObservableSource and merging the results of the ObservableSources obtained from this transformation

    Since:

    2.0

    See Also:

    ReactiveX operators documentation: FlatMap

  • flatMap

    @CheckReturnValue@SchedulerSupport(value="none")public final <R> Observable<R> flatMap(Function<? superT,? extendsObservableSource<? extends R>> mapper,        boolean delayErrors,        int maxConcurrency,        int bufferSize)

    Returns an Observable that emits items based on applying a function that you supply to each item emitted by the source ObservableSource, where that function returns an ObservableSource, and then merging those resulting ObservableSources and emitting the results of this merger, while limiting the maximum number of concurrent subscriptions to these ObservableSources.

    

    Scheduler:

    flatMap does not operate by default on a particularScheduler.

    Type Parameters:

    R - the value type of the inner ObservableSources and the output type

    Parameters:

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

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

    delayErrors - if true, exceptions from the current Observable and all inner ObservableSources are delayed until all of them terminate if false, the first one signalling an exception will terminate the whole sequence immediately

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

    Returns:

    an Observable that emits the result of applying the transformation function to each item emitted by the source ObservableSource and merging the results of the ObservableSources obtained from this transformation

    Since:

    2.0

    See Also:

    ReactiveX operators documentation: FlatMap

  • flatMap

    @CheckReturnValue@SchedulerSupport(value="none")public final <R> Observable<R> flatMap(Function<? superT,? extendsObservableSource<? extends R>> onNextMapper,Function<? superThrowable,? extendsObservableSource<? extends R>> onErrorMapper,Callable<? extendsObservableSource<? extends R>> onCompleteSupplier)

    Returns an Observable that applies a function to each item emitted or notification raised by the source ObservableSource and then flattens the ObservableSources returned from these functions and emits the resulting items.

    

    Scheduler:

    flatMap does not operate by default on a particularScheduler.

    Type Parameters:

    R - the result type

    Parameters:

    onNextMapper - a function that returns an ObservableSource to merge for each item emitted by the source ObservableSource

    onErrorMapper - a function that returns an ObservableSource to merge for an onError notification from the source ObservableSource

    onCompleteSupplier - a function that returns an ObservableSource to merge for an onComplete notification from the source ObservableSource

    Returns:

    an Observable that emits the results of merging the ObservableSources returned from applying the specified functions to the emissions and notifications of the source ObservableSource

    See Also:

    ReactiveX operators documentation: FlatMap

  • flatMap

    @CheckReturnValue@SchedulerSupport(value="none")public final <R> Observable<R> flatMap(Function<? superT,? extendsObservableSource<? extends R>> onNextMapper,Function<Throwable,? extendsObservableSource<? extends R>> onErrorMapper,Callable<? extendsObservableSource<? extends R>> onCompleteSupplier,        int maxConcurrency)

    Returns an Observable that applies a function to each item emitted or notification raised by the source ObservableSource and then flattens the ObservableSources returned from these functions and emits the resulting items, while limiting the maximum number of concurrent subscriptions to these ObservableSources.

    

    Scheduler:

    flatMap does not operate by default on a particularScheduler.

    Type Parameters:

    R - the result type

    Parameters:

    onNextMapper - a function that returns an ObservableSource to merge for each item emitted by the source ObservableSource

    onErrorMapper - a function that returns an ObservableSource to merge for an onError notification from the source ObservableSource

    onCompleteSupplier - a function that returns an ObservableSource to merge for an onComplete notification from the source ObservableSource

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

    Returns:

    an Observable that emits the results of merging the ObservableSources returned from applying the specified functions to the emissions and notifications of the source ObservableSource

    Since:

    2.0

    See Also:

    ReactiveX operators documentation: FlatMap

  • flatMap

    @CheckReturnValue@SchedulerSupport(value="none")public final <R> Observable<R> flatMap(Function<? superT,? extendsObservableSource<? extends R>> mapper,        int maxConcurrency)

    Returns an Observable that emits items based on applying a function that you supply to each item emitted by the source ObservableSource, where that function returns an ObservableSource, and then merging those resulting ObservableSources and emitting the results of this merger, while limiting the maximum number of concurrent subscriptions to these ObservableSources.

    

    Scheduler:

    flatMap does not operate by default on a particularScheduler.

    Type Parameters:

    R - the value type of the inner ObservableSources and the output type

    Parameters:

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

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

    Returns:

    an Observable that emits the result of applying the transformation function to each item emitted by the source ObservableSource and merging the results of the ObservableSources obtained from this transformation

    Since:

    2.0

    See Also:

    ReactiveX operators documentation: FlatMap

  • flatMap

    @CheckReturnValue@SchedulerSupport(value="none")public final <U,R> Observable<R> flatMap(Function<? superT,? extendsObservableSource<? extends U>> mapper,BiFunction<? superT,? super U,? extends R> resultSelector)

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

    

    Scheduler:

    flatMap does not operate by default on a particularScheduler.

    Type Parameters:

    U - the type of items emitted by the collection ObservableSource

    R - the type of items emitted by the resulting ObservableSource

    Parameters:

    mapper - a function that returns an ObservableSource for each item emitted by the source ObservableSource

    resultSelector - a function that combines one item emitted by each of the source and collection ObservableSources and returns an item to be emitted by the resulting ObservableSource

    Returns:

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

    See Also:

    ReactiveX operators documentation: FlatMap

  • flatMap

    @CheckReturnValue@SchedulerSupport(value="none")public final <U,R> Observable<R> flatMap(Function<? superT,? extendsObservableSource<? extends U>> mapper,BiFunction<? superT,? super U,? extends R> combiner,        boolean delayErrors)

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

    

    Scheduler:

    flatMap does not operate by default on a particularScheduler.

    Type Parameters:

    U - the type of items emitted by the collection ObservableSource

    R - the type of items emitted by the resulting ObservableSource

    Parameters:

    mapper - a function that returns an ObservableSource for each item emitted by the source ObservableSource

    combiner - a function that combines one item emitted by each of the source and collection ObservableSources and returns an item to be emitted by the resulting ObservableSource

    delayErrors - if true, exceptions from the current Observable and all inner ObservableSources are delayed until all of them terminate if false, the first one signalling an exception will terminate the whole sequence immediately

    Returns:

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

    See Also:

    ReactiveX operators documentation: FlatMap

  • flatMap

    @CheckReturnValue@SchedulerSupport(value="none")public final <U,R> Observable<R> flatMap(Function<? superT,? extendsObservableSource<? extends U>> mapper,BiFunction<? superT,? super U,? extends R> combiner,        boolean delayErrors,        int maxConcurrency)

    Returns an Observable that emits the results of a specified function to the pair of values emitted by the source ObservableSource and a specified collection ObservableSource, while limiting the maximum number of concurrent subscriptions to these ObservableSources.

    

    Scheduler:

    flatMap does not operate by default on a particularScheduler.

    Type Parameters:

    U - the type of items emitted by the collection ObservableSource

    R - the type of items emitted by the resulting ObservableSource

    Parameters:

    mapper - a function that returns an ObservableSource for each item emitted by the source ObservableSource

    combiner - a function that combines one item emitted by each of the source and collection ObservableSources and returns an item to be emitted by the resulting ObservableSource

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

    delayErrors - if true, exceptions from the current Observable and all inner ObservableSources are delayed until all of them terminate if false, the first one signalling an exception will terminate the whole sequence immediately

    Returns:

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

    Since:

    2.0

    See Also:

    ReactiveX operators documentation: FlatMap

  • flatMap

    @CheckReturnValue@SchedulerSupport(value="none")public final <U,R> Observable<R> flatMap(Function<? superT,? extendsObservableSource<? extends U>> mapper,BiFunction<? superT,? super U,? extends R> combiner,        boolean delayErrors,        int maxConcurrency,        int bufferSize)

    Returns an Observable that emits the results of a specified function to the pair of values emitted by the source ObservableSource and a specified collection ObservableSource, while limiting the maximum number of concurrent subscriptions to these ObservableSources.

    

    Scheduler:

    flatMap does not operate by default on a particularScheduler.

    Type Parameters:

    U - the type of items emitted by the collection ObservableSource

    R - the type of items emitted by the resulting ObservableSource

    Parameters:

    mapper - a function that returns an ObservableSource for each item emitted by the source ObservableSource

    combiner - a function that combines one item emitted by each of the source and collection ObservableSources and returns an item to be emitted by the resulting ObservableSource

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

    delayErrors - if true, exceptions from the current Observable and all inner ObservableSources are delayed until all of them terminate if false, the first one signalling an exception will terminate the whole sequence immediately

    bufferSize - the number of elements to prefetch from the inner ObservableSources.

    Returns:

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

    Since:

    2.0

    See Also:

    ReactiveX operators documentation: FlatMap

  • flatMap

    @CheckReturnValue@SchedulerSupport(value="none")public final <U,R> Observable<R> flatMap(Function<? superT,? extendsObservableSource<? extends U>> mapper,BiFunction<? superT,? super U,? extends R> combiner,        int maxConcurrency)

    Returns an Observable that emits the results of a specified function to the pair of values emitted by the source ObservableSource and a specified collection ObservableSource, while limiting the maximum number of concurrent subscriptions to these ObservableSources.

    

    Scheduler:

    flatMap does not operate by default on a particularScheduler.

    Type Parameters:

    U - the type of items emitted by the collection ObservableSource

    R - the type of items emitted by the resulting ObservableSource

    Parameters:

    mapper - a function that returns an ObservableSource for each item emitted by the source ObservableSource

    combiner - a function that combines one item emitted by each of the source and collection ObservableSources and returns an item to be emitted by the resulting ObservableSource

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

    Returns:

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

    Since:

    2.0

    See Also:

    ReactiveX operators documentation: FlatMap

  • flatMapCompletable

    @CheckReturnValue@SchedulerSupport(value="none")public final Completable flatMapCompletable(Function<? superT,? extendsCompletableSource> mapper)

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

    

    Scheduler:

    flatMapCompletable does not operate by default on a particularScheduler.

    Parameters:

    mapper - the function that received each source value and transforms them into CompletableSources.

    Returns:

    the new Completable instance

  • flatMapCompletable

    @CheckReturnValue@SchedulerSupport(value="none")public final Completable flatMapCompletable(Function<? superT,? extendsCompletableSource> mapper,        boolean delayErrors)

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

    

    Scheduler:

    flatMapCompletable does not operate by default on a particularScheduler.

    Parameters:

    mapper - the function that received each source value and transforms them into CompletableSources.

    delayErrors - if true errors from the upstream and inner CompletableSources are delayed until each of them terminates.

    Returns:

    the new Completable instance

  • flatMapIterable

    @CheckReturnValue@SchedulerSupport(value="none")public final <U> Observable<U> flatMapIterable(Function<? superT,? extendsIterable<? extends U>> mapper)

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

    

    Scheduler:

    flatMapIterable does not operate by default on a particularScheduler.

    Type Parameters:

    U - the type of item emitted by the resulting Iterable

    Parameters:

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

    Returns:

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

    See Also:

    ReactiveX operators documentation: FlatMap

  • flatMapIterable

    @CheckReturnValue@SchedulerSupport(value="none")public final <U,V> Observable<V> flatMapIterable(Function<? superT,? extendsIterable<? extends U>> mapper,BiFunction<? superT,? super U,? extends V> resultSelector)

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

    

    Scheduler:

    flatMapIterable does not operate by default on a particularScheduler.

    Type Parameters:

    U - the collection element type

    V - the type of item emitted by the resulting Iterable

    Parameters:

    mapper - a function that returns an Iterable sequence of values for each item emitted by the source ObservableSource

    resultSelector - a function that returns an item based on the item emitted by the source ObservableSource and the Iterable returned for that item by thecollectionSelector

    Returns:

    an Observable that emits the items returned byresultSelector for each item in the source ObservableSource

    See Also:

    ReactiveX operators documentation: FlatMap

  • flatMapMaybe

    @CheckReturnValue@SchedulerSupport(value="none")public final <R> Observable<R> flatMapMaybe(Function<? superT,? extendsMaybeSource<? extends R>> mapper)

    Maps each element of the upstream Observable into MaybeSources, subscribes to all of them and merges their onSuccess values, in no particular order, into a single Observable sequence.

    

    Scheduler:

    flatMapMaybe does not operate by default on a particularScheduler.

    Type Parameters:

    R - the result value type

    Parameters:

    mapper - the function that received each source value and transforms them into MaybeSources.

    Returns:

    the new Observable instance

  • flatMapMaybe

    @CheckReturnValue@SchedulerSupport(value="none")public final <R> Observable<R> flatMapMaybe(Function<? superT,? extendsMaybeSource<? extends R>> mapper,        boolean delayErrors)

    Maps each element of the upstream Observable into MaybeSources, subscribes to them and merges their onSuccess values, in no particular order, into a single Observable sequence, optionally delaying all errors.

    

    Scheduler:

    flatMapMaybe does not operate by default on a particularScheduler.

    Type Parameters:

    R - the result value type

    Parameters:

    mapper - the function that received each source value and transforms them into MaybeSources.

    delayErrors - if true errors from the upstream and inner MaybeSources are delayed until each of them terminates.

    Returns:

    the new Observable instance

  • flatMapSingle

    @CheckReturnValue@SchedulerSupport(value="none")public final <R> Observable<R> flatMapSingle(Function<? superT,? extendsSingleSource<? extends R>> mapper)

    Maps each element of the upstream Observable into SingleSources, subscribes to all of them and merges their onSuccess values, in no particular order, into a single Observable sequence.

    

    Scheduler:

    flatMapSingle does not operate by default on a particularScheduler.

    Type Parameters:

    R - the result value type

    Parameters:

    mapper - the function that received each source value and transforms them into SingleSources.

    Returns:

    the new Observable instance

  • flatMapSingle

    @CheckReturnValue@SchedulerSupport(value="none")public final <R> Observable<R> flatMapSingle(Function<? superT,? extendsSingleSource<? extends R>> mapper,        boolean delayErrors)

    Maps each element of the upstream Observable into SingleSources, subscribes to them and merges their onSuccess values, in no particular order, into a single Observable sequence, optionally delaying all errors.

    

    Scheduler:

    flatMapSingle does not operate by default on a particularScheduler.

    Type Parameters:

    R - the result value type

    Parameters:

    mapper - the function that received each source value and transforms them into SingleSources.

    delayErrors - if true errors from the upstream and inner SingleSources are delayed until each of them terminates.

    Returns:

    the new Observable instance

  • forEach

    @CheckReturnValue@SchedulerSupport(value="none")public final Disposable forEach(Consumer<? superT> onNext)

    Subscribes to theObservableSource and receives notifications for each element.

    

    Alias tosubscribe(Consumer)

    Scheduler:

    forEach does not operate by default on a particularScheduler.

    Parameters:

    onNext -Consumer to execute for each item.

    Returns:

    a Disposable that allows disposing of an asynchronous sequence

    Throws:

    NullPointerException - ifonNext is null

    See Also:

    ReactiveX operators documentation: Subscribe

  • forEachWhile

    @CheckReturnValue@SchedulerSupport(value="none")public final Disposable forEachWhile(Predicate<? superT> onNext)

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

    

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

    Scheduler:

    forEachWhile does not operate by default on a particularScheduler.

    Parameters:

    onNext -Predicate to execute for each item.

    Returns:

    a Disposable that allows disposing of an asynchronous sequence

    Throws:

    NullPointerException - ifonNext is null

    See Also:

    ReactiveX operators documentation: Subscribe

  • forEachWhile

    @CheckReturnValue@SchedulerSupport(value="none")public final Disposable forEachWhile(Predicate<? superT> onNext,Consumer<? superThrowable> onError)

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

    Scheduler:

    forEachWhile does not operate by default on a particularScheduler.

    Parameters:

    onNext -Predicate to execute for each item.

    onError -Consumer to execute when an error is emitted.

    Returns:

    a Disposable that allows disposing of an asynchronous sequence

    Throws:

    NullPointerException - ifonNext is null, or ifonError is null

    See Also:

    ReactiveX operators documentation: Subscribe

  • forEachWhile

    @CheckReturnValue@SchedulerSupport(value="none")public final Disposable forEachWhile(Predicate<? superT> onNext,Consumer<? superThrowable> onError,Action onComplete)

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

    Scheduler:

    forEachWhile does not operate by default on a particularScheduler.

    Parameters:

    onNext -Predicate to execute for each item.

    onError -Consumer to execute when an error is emitted.

    onComplete -Action to execute when completion is signalled.

    Returns:

    a Disposable that allows disposing of an asynchronous sequence

    Throws:

    NullPointerException - ifonNext is null, or ifonError is null, or ifonComplete is null

    See Also:

    ReactiveX operators documentation: Subscribe

  • groupBy

    @CheckReturnValue@SchedulerSupport(value="none")public final <K> Observable<GroupedObservable<K,T>> groupBy(Function<? superT,? extends K> keySelector)

    Groups the items emitted by anObservableSource according to a specified criterion, and emits these grouped items asGroupedObservables. The emittedGroupedObservableSource allows only a singleObserver during its lifetime and if thisObserver calls dispose() before the source terminates, the next emission by the source having the same key will trigger a newGroupedObservableSource emission.

    

    Note: AGroupedObservable 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 thoseGroupedObservableSources that do not concern you. Instead, you can signal to them that they may discard their buffers by applying an operator likeignoreElements() to them.

    Scheduler:

    groupBy does not operate by default on a particularScheduler.

    Type Parameters:

    K - the key type

    Parameters:

    keySelector - a function that extracts the key for each item

    Returns:

    anObservableSource that emitsGroupedObservables, each of which corresponds to a unique key value and each of which emits those items from the source ObservableSource that share that key value

    See Also:

    ReactiveX operators documentation: GroupBy

  • groupBy

    @CheckReturnValue@SchedulerSupport(value="none")public final <K> Observable<GroupedObservable<K,T>> groupBy(Function<? superT,? extends K> keySelector,        boolean delayError)

    Groups the items emitted by anObservableSource according to a specified criterion, and emits these grouped items asGroupedObservables. The emittedGroupedObservableSource allows only a singleObserver during its lifetime and if thisObserver calls dispose() before the source terminates, the next emission by the source having the same key will trigger a newGroupedObservableSource emission.

    

    Note: AGroupedObservable 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 thoseGroupedObservableSources that do not concern you. Instead, you can signal to them that they may discard their buffers by applying an operator likeignoreElements() to them.

    Scheduler:

    groupBy does not operate by default on a particularScheduler.

    Type Parameters:

    K - the key type

    Parameters:

    keySelector - a function that extracts the key for each item

    delayError - if true, the exception from the current Observable is delayed in each group until that specific group emitted the normal values; if false, the exception bypasses values in the groups and is reported immediately.

    Returns:

    anObservableSource that emitsGroupedObservables, each of which corresponds to a unique key value and each of which emits those items from the source ObservableSource that share that key value

    See Also:

    ReactiveX operators documentation: GroupBy

  • groupBy

    @CheckReturnValue@SchedulerSupport(value="none")public final <K,V> Observable<GroupedObservable<K,V>> groupBy(Function<? superT,? extends K> keySelector,Function<? superT,? extends V> valueSelector)

    Groups the items emitted by anObservableSource according to a specified criterion, and emits these grouped items asGroupedObservables. The emittedGroupedObservableSource allows only a singleObserver during its lifetime and if thisObserver calls dispose() before the source terminates, the next emission by the source having the same key will trigger a newGroupedObservableSource emission.

    

    Note: AGroupedObservable 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 thoseGroupedObservableSources that do not concern you. Instead, you can signal to them that they may discard their buffers by applying an operator likeignoreElements() to them.

    Scheduler:

    groupBy does not operate by default on a particularScheduler.

    Type Parameters:

    K - the key type

    V - the element type

    Parameters:

    keySelector - a function that extracts the key for each item

    valueSelector - a function that extracts the return element for each item

    Returns:

    anObservableSource that emitsGroupedObservables, each of which corresponds to a unique key value and each of which emits those items from the source ObservableSource that share that key value

    See Also:

    ReactiveX operators documentation: GroupBy

  • groupBy

    @CheckReturnValue@SchedulerSupport(value="none")public final <K,V> Observable<GroupedObservable<K,V>> groupBy(Function<? superT,? extends K> keySelector,Function<? superT,? extends V> valueSelector,        boolean delayError)

    Groups the items emitted by anObservableSource according to a specified criterion, and emits these grouped items asGroupedObservables. The emittedGroupedObservableSource allows only a singleObserver during its lifetime and if thisObserver calls dispose() before the source terminates, the next emission by the source having the same key will trigger a newGroupedObservableSource emission.

    

    Note: AGroupedObservable 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 thoseGroupedObservableSources that do not concern you. Instead, you can signal to them that they may discard their buffers by applying an operator likeignoreElements() to them.

    Scheduler:

    groupBy does not operate by default on a particularScheduler.

    Type Parameters:

    K - the key type

    V - the element type

    Parameters:

    keySelector - a function that extracts the key for each item

    valueSelector - a function that extracts the return element for each item

    delayError - if true, the exception from the current Observable is delayed in each group until that specific group emitted the normal values; if false, the exception bypasses values in the groups and is reported immediately.

    Returns:

    anObservableSource that emitsGroupedObservables, each of which corresponds to a unique key value and each of which emits those items from the source ObservableSource that share that key value

    See Also:

    ReactiveX operators documentation: GroupBy

  • groupBy

    @CheckReturnValue@SchedulerSupport(value="none")public final <K,V> Observable<GroupedObservable<K,V>> groupBy(Function<? superT,? extends K> keySelector,Function<? superT,? extends V> valueSelector,        boolean delayError,        int bufferSize)

    Groups the items emitted by anObservableSource according to a specified criterion, and emits these grouped items asGroupedObservables. The emittedGroupedObservableSource allows only a singleObserver during its lifetime and if thisObserver calls dispose() before the source terminates, the next emission by the source having the same key will trigger a newGroupedObservableSource emission.

    

    Note: AGroupedObservable 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 thoseGroupedObservableSources that do not concern you. Instead, you can signal to them that they may discard their buffers by applying an operator likeignoreElements() to them.

    Scheduler:

    groupBy does not operate by default on a particularScheduler.

    Type Parameters:

    K - the key type

    V - the element type

    Parameters:

    keySelector - a function that extracts the key for each item

    valueSelector - a function that extracts the return element for each item

    delayError - if true, the exception from the current Observable is delayed in each group until that specific group emitted the normal values; if false, the exception bypasses values in the groups and is reported immediately.

    bufferSize - the hint for how manyGroupedObservables and element in eachGroupedObservable should be buffered

    Returns:

    anObservableSource that emitsGroupedObservables, each of which corresponds to a unique key value and each of which emits those items from the source ObservableSource that share that key value

    See Also:

    ReactiveX operators documentation: GroupBy

  • groupJoin

    @CheckReturnValue@SchedulerSupport(value="none")public final <TRight,TLeftEnd,TRightEnd,R> Observable<R> groupJoin(ObservableSource<? extends TRight> other,Function<? superT,? extendsObservableSource<TLeftEnd>> leftEnd,Function<? super TRight,? extendsObservableSource<TRightEnd>> rightEnd,BiFunction<? superT,? superObservable<TRight>,? extends R> resultSelector)

    Returns an Observable that correlates two ObservableSources when they overlap in time and groups the results.

    There are no guarantees in what order the items get combined when multiple items from one or both source ObservableSources overlap.

    

    Scheduler:

    groupJoin does not operate by default on a particularScheduler.

    Type Parameters:

    TRight - the value type of the right ObservableSource source

    TLeftEnd - the element type of the left duration ObservableSources

    TRightEnd - the element type of the right duration ObservableSources

    R - the result type

    Parameters:

    other - the other ObservableSource to correlate items from the source ObservableSource with

    leftEnd - a function that returns an ObservableSource whose emissions indicate the duration of the values of the source ObservableSource

    rightEnd - a function that returns an ObservableSource whose emissions indicate the duration of the values of theright ObservableSource

    resultSelector - a function that takes an item emitted by each ObservableSource and returns the value to be emitted by the resulting ObservableSource

    Returns:

    an Observable that emits items based on combining those items emitted by the source ObservableSources whose durations overlap

    See Also:

    ReactiveX operators documentation: Join

  • hide

    @CheckReturnValue@SchedulerSupport(value="none")public final Observable<T> hide()

    Hides the identity of this Observable and its Disposable.

    Allows hiding extra features such asSubject'sObserver methods or preventing certain identity-based optimizations (fusion).

    

    Scheduler:

    hide does not operate by default on a particularScheduler.

    Returns:

    the new Observable instance

    Since:

    2.0

  • ignoreElements

    @CheckReturnValue@SchedulerSupport(value="none")public final Completable ignoreElements()

    Ignores all items emitted by the source ObservableSource and only callsonComplete oronError.

    

    Scheduler:

    ignoreElements does not operate by default on a particularScheduler.

    Returns:

    the new Completable instance

    See Also:

    ReactiveX operators documentation: IgnoreElements

  • isEmpty

    @CheckReturnValue@SchedulerSupport(value="none")public final Single<Boolean> isEmpty()

    Returns a Single that emitstrue if the source ObservableSource is empty, otherwisefalse.

    In Rx.Net this is negated as theany Observer but we renamed this in RxJava to better match Java naming idioms.

    

    Scheduler:

    isEmpty does not operate by default on a particularScheduler.

    Returns:

    a Single that emits a Boolean

    See Also:

    ReactiveX operators documentation: Contains

  • join

    @CheckReturnValue@SchedulerSupport(value="none")public final <TRight,TLeftEnd,TRightEnd,R> Observable<R> join(ObservableSource<? extends TRight> other,Function<? superT,? extendsObservableSource<TLeftEnd>> leftEnd,Function<? super TRight,? extendsObservableSource<TRightEnd>> rightEnd,BiFunction<? superT,? super TRight,? extends R> resultSelector)

    Correlates the items emitted by two ObservableSources based on overlapping durations.

    There are no guarantees in what order the items get combined when multiple items from one or both source ObservableSources overlap.

    

    Scheduler:

    join does not operate by default on a particularScheduler.

    Type Parameters:

    TRight - the value type of the right ObservableSource source

    TLeftEnd - the element type of the left duration ObservableSources

    TRightEnd - the element type of the right duration ObservableSources

    R - the result type

    Parameters:

    other - the second ObservableSource to join items from

    leftEnd - a function to select a duration for each item emitted by the source ObservableSource, used to determine overlap

    rightEnd - a function to select a duration for each item emitted by theright ObservableSource, used to determine overlap

    resultSelector - a function that computes an item to be emitted by the resulting ObservableSource for any two overlapping items emitted by the two ObservableSources

    Returns:

    an Observable that emits items correlating to items emitted by the source ObservableSources that have overlapping durations

    See Also:

    ReactiveX operators documentation: Join

  • lastElement

    @CheckReturnValue@SchedulerSupport(value="none")public final Maybe<T> lastElement()

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

    

    Scheduler:

    lastElement does not operate by default on a particularScheduler.

    Returns:

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

    See Also:

    ReactiveX operators documentation: Last

  • last

    @CheckReturnValue@SchedulerSupport(value="none")public final Single<T> last(T defaultItem)

    Returns a Single that emits only the last item emitted by this Observable, or a default item if this Observable completes without emitting any items.

    

    Scheduler:

    last does not operate by default on a particularScheduler.

    Parameters:

    defaultItem - the default item to emit if the source ObservableSource is empty

    Returns:

    a Single that emits only the last item emitted by the source ObservableSource, or a default item if the source ObservableSource is empty

    See Also:

    ReactiveX operators documentation: Last

  • lastOrError

    @CheckReturnValue@SchedulerSupport(value="none")public final Single<T> lastOrError()

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

    

    Scheduler:

    lastOrError does not operate by default on a particularScheduler.

    Returns:

    a Single that emits only the last item emitted by the source ObservableSource. If the source ObservableSource completes without emitting any items aNoSuchElementException will be thrown.

    See Also:

    ReactiveX operators documentation: Last

  • lift

    @CheckReturnValue@SchedulerSupport(value="none")public final <R> Observable<R> lift(ObservableOperator<? extends R,? superT> lifter)

    This method requires advanced knowledge about building operators, please consider other standard composition methods first; Returns anObservable which, when subscribed to, invokes theapply(Observer) method of the providedObservableOperator for each individual downstreamObserver and allows the insertion of a custom operator by accessing the downstream'sObserver during this subscription phase and providing a newObserver, containing the custom operator's intended business logic, that will be used in the subscription process going further upstream.

    Generally, such a newObserver will wrap the downstream'sObserver and forwards theonNext,onError andonComplete events from the upstream directly or according to the emission pattern the custom operator's business logic requires. In addition, such operator can intercept the flow control calls ofdispose andisDisposed that would have traveled upstream and perform additional actions depending on the same business logic requirements.

    Example:

     // Step 1: Create the consumer type that will be returned by the ObservableOperator.apply(): public final class CustomObserver<T> implements Observer<T>, Disposable {     // The downstream's Observer that will receive the onXXX events     final Observer<? super String> downstream;     // The connection to the upstream source that will call this class' onXXX methods     Disposable upstream;     // The constructor takes the downstream subscriber and usually any other parameters     public CustomObserver(Observer<? super String> downstream) {         this.downstream = downstream;     }     // In the subscription phase, the upstream sends a Disposable to this class     // and subsequently this class has to send a Disposable to the downstream.     // Note that relaying the upstream's Disposable directly is not allowed in RxJava     @Override     public void onSubscribe(Disposable d) {         if (upstream != null) {             d.dispose();         } else {             upstream = d;             downstream.onSubscribe(this);         }     }     // The upstream calls this with the next item and the implementation's     // responsibility is to emit an item to the downstream based on the intended     // business logic, or if it can't do so for the particular item,        // request more from the upstream     @Override     public void onNext(T item) {         String str = item.toString();         if (str.length() < 2) {             downstream.onNext(str);         }         // Observable doesn't support backpressure, therefore, there is no         // need or opportunity to call upstream.request(1) if an item         // is not produced to the downstream     }     // Some operators may handle the upstream's error while others     // could just forward it to the downstream.     @Override     public void onError(Throwable throwable) {         downstream.onError(throwable);     }     // When the upstream completes, usually the downstream should complete as well.     @Override     public void onComplete() {         downstream.onComplete();     }     // Some operators may use their own resources which should be cleaned up if     // the downstream disposes the flow before it completed. Operators without     // resources can simply forward the dispose to the upstream.     // In some cases, a disposed flag may be set by this method so that other parts     // of this class may detect the dispose and stop sending events     // to the downstream.     @Override     public void dispose() {         upstream.dispose();     }     // Some operators may simply forward the call to the upstream while others     // can return the disposed flag set in dispose().     @Override     public boolean isDisposed() {         return upstream.isDisposed();     } } // Step 2: Create a class that implements the ObservableOperator interface and //         returns the custom consumer type from above in its apply() method. //         Such class may define additional parameters to be submitted to //         the custom consumer type. final class CustomOperator<T> implements ObservableOperator<String, T> {     @Override     public Observer<T> apply(Observer<? super String> downstream) {         return new CustomObserver<T>(downstream);     } } // Step 3: Apply the custom operator via lift() in a flow by creating an instance of it //         or reusing an existing one. Observable.range(5, 10) .lift(new CustomOperator<Integer>()) .test() .assertResult("5", "6", "7", "8", "9");

    Creating custom operators can be complicated and it is recommended one consults theRxJava wiki: Writing operators page about the tools, requirements, rules, considerations and pitfalls of implementing them.

    Note that implementing custom operators via thislift() method adds slightly more overhead by requiring an additional allocation and indirection per assembled flows. Instead, extending the abstractObservable class and creating anObservableTransformer with it is recommended.

    Note also that it is not possible to stop the subscription phase inlift() as theapply() method requires a non-nullObserver instance to be returned, which is then unconditionally subscribed to the upstreamObservable. For example, if the operator decided there is no reason to subscribe to the upstream source because of some optimization possibility or a failure to prepare the operator, it still has to return anObserver that should immediately dispose the upstream'sDisposable in itsonSubscribe method. Again, using anObservableTransformer and extending theObservable is a better option assubscribeActual(io.reactivex.Observer<? super T>) can decide to not subscribe to its upstream after all.

    Scheduler:

    lift does not operate by default on a particularScheduler, however, theObservableOperator may use aScheduler to support its own asynchronous behavior.

    Type Parameters:

    R - the output value type

    Parameters:

    lifter - theObservableOperator that receives the downstream'sObserver and should return anObserver with custom behavior to be used as the consumer for the currentObservable.

    Returns:

    the new Observable instance

    See Also:

    RxJava wiki: Writing operators,compose(ObservableTransformer)

  • map

    @CheckReturnValue@SchedulerSupport(value="none")public final <R> Observable<R> map(Function<? superT,? extends R> mapper)

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

    

    Scheduler:

    map does not operate by default on a particularScheduler.

    Type Parameters:

    R - the output type

    Parameters:

    mapper - a function to apply to each item emitted by the ObservableSource

    Returns:

    an Observable that emits the items from the source ObservableSource, transformed by the specified function

    See Also:

    ReactiveX operators documentation: Map

  • materialize

    @CheckReturnValue@SchedulerSupport(value="none")public final Observable<Notification<T>> materialize()

    Returns an Observable that represents all of the emissionsand notifications from the source ObservableSource into emissions marked with their original types withinNotification objects.

    

    Scheduler:

    materialize does not operate by default on a particularScheduler.

    Returns:

    an Observable that emits items that are the result of materializing the items and notifications of the source ObservableSource

    See Also:

    ReactiveX operators documentation: Materialize,dematerialize(Function)

  • mergeWith

    @CheckReturnValue@SchedulerSupport(value="none")public final Observable<T> mergeWith(ObservableSource<? extendsT> other)

    Flattens this and another ObservableSource into a single ObservableSource, without any transformation.

    

    You can combine items emitted by multiple ObservableSources so that they appear as a single ObservableSource, by using themergeWith method.

    Scheduler:

    mergeWith does not operate by default on a particularScheduler.

    Parameters:

    other - an ObservableSource to be merged

    Returns:

    an Observable that emits all of the items emitted by the source ObservableSources

    See Also:

    ReactiveX operators documentation: Merge

  • mergeWith

    @CheckReturnValue@SchedulerSupport(value="none")public final Observable<T> mergeWith(@NonNullSingleSource<? extendsT> other)

    Merges the sequence of items of this Observable with the success value of the other SingleSource.

    

    The success value of the otherSingleSource can get interleaved at any point of thisObservable sequence.

    Scheduler:

    mergeWith does not operate by default on a particularScheduler.

    History: 2.1.10 - experimental

    Parameters:

    other - theSingleSource whose success value to merge with

    Returns:

    the new Observable instance

    Since:

    2.2

  • mergeWith

    @CheckReturnValue@SchedulerSupport(value="none")public final Observable<T> mergeWith(@NonNullMaybeSource<? extendsT> other)

    Merges the sequence of items of this Observable with the success value of the other MaybeSource or waits both to complete normally if the MaybeSource is empty.

    

    The success value of the otherMaybeSource can get interleaved at any point of thisObservable sequence.

    Scheduler:

    mergeWith does not operate by default on a particularScheduler.

    History: 2.1.10 - experimental

    Parameters:

    other - theMaybeSource which provides a success value to merge with or completes

    Returns:

    the new Observable instance

    Since:

    2.2

  • mergeWith

    @CheckReturnValue@SchedulerSupport(value="none")public final Observable<T> mergeWith(@NonNullCompletableSource other)

    Relays the items of this Observable and completes only when the other CompletableSource completes as well.

    

    Scheduler:

    mergeWith does not operate by default on a particularScheduler.

    History: 2.1.10 - experimental

    Parameters:

    other - theCompletableSource to await for completion

    Returns:

    the new Observable instance

    Since:

    2.2

  • observeOn

    @CheckReturnValue@SchedulerSupport(value="custom")public final Observable<T> observeOn(Scheduler scheduler)

    Modifies an ObservableSource to perform its emissions and notifications on a specifiedScheduler, asynchronously with an unbounded buffer withFlowable.bufferSize() "island size".

    Note that onError notifications will cut ahead of onNext notifications on the emission thread if Scheduler is truly asynchronous. If strict event ordering is required, consider using theobserveOn(Scheduler, boolean) overload.

    

    This operator keeps emitting as many signals as it can on the given Scheduler's Worker thread, which may result in a longer than expected occupation of this thread. In other terms, it does not allow per-signal fairness in case the worker runs on a shared underlying thread. If such fairness and signal/work interleaving is preferred, use the delay operator with zero time instead.

    Scheduler:

    You specify whichScheduler this operator will use.

    "Island size" indicates how large chunks the unbounded buffer allocates to store the excess elements waiting to be consumed on the other side of the asynchronous boundary.

    Parameters:

    scheduler - theScheduler to notifyObservers on

    Returns:

    the source ObservableSource modified so that itsObservers are notified on the specifiedScheduler

    See Also:

    ReactiveX operators documentation: ObserveOn,RxJava Threading Examples,subscribeOn(io.reactivex.Scheduler),observeOn(Scheduler, boolean),observeOn(Scheduler, boolean, int),delay(long, TimeUnit, Scheduler)

  • observeOn

    @CheckReturnValue@SchedulerSupport(value="custom")public final Observable<T> observeOn(Scheduler scheduler,        boolean delayError)

    Modifies an ObservableSource to perform its emissions and notifications on a specifiedScheduler, asynchronously with an unbounded buffer withFlowable.bufferSize() "island size" and optionally delays onError notifications.

    

    This operator keeps emitting as many signals as it can on the given Scheduler's Worker thread, which may result in a longer than expected occupation of this thread. In other terms, it does not allow per-signal fairness in case the worker runs on a shared underlying thread. If such fairness and signal/work interleaving is preferred, use the delay operator with zero time instead.

    Scheduler:

    You specify whichScheduler this operator will use.

    "Island size" indicates how large chunks the unbounded buffer allocates to store the excess elements waiting to be consumed on the other side of the asynchronous boundary.

    Parameters:

    scheduler - theScheduler to notifyObservers on

    delayError - indicates if the onError notification may not cut ahead of onNext notification on the other side of the scheduling boundary. If true a sequence ending in onError will be replayed in the same order as was received from upstream

    Returns:

    the source ObservableSource modified so that itsObservers are notified on the specifiedScheduler

    See Also:

    ReactiveX operators documentation: ObserveOn,RxJava Threading Examples,subscribeOn(io.reactivex.Scheduler),observeOn(Scheduler),observeOn(Scheduler, boolean, int),delay(long, TimeUnit, Scheduler, boolean)

  • observeOn

    @CheckReturnValue@SchedulerSupport(value="custom")public final Observable<T> observeOn(Scheduler scheduler,        boolean delayError,        int bufferSize)

    Modifies an ObservableSource to perform its emissions and notifications on a specifiedScheduler, asynchronously with an unbounded buffer of configurable "island size" and optionally delays onError notifications.

    

    This operator keeps emitting as many signals as it can on the given Scheduler's Worker thread, which may result in a longer than expected occupation of this thread. In other terms, it does not allow per-signal fairness in case the worker runs on a shared underlying thread. If such fairness and signal/work interleaving is preferred, use the delay operator with zero time instead.

    Scheduler:

    You specify whichScheduler this operator will use.

    "Island size" indicates how large chunks the unbounded buffer allocates to store the excess elements waiting to be consumed on the other side of the asynchronous boundary. Values below 16 are not recommended in performance sensitive scenarios.

    Parameters:

    scheduler - theScheduler to notifyObservers on

    delayError - indicates if the onError notification may not cut ahead of onNext notification on the other side of the scheduling boundary. If true a sequence ending in onError will be replayed in the same order as was received from upstream

    bufferSize - the size of the buffer.

    Returns:

    the source ObservableSource modified so that itsObservers are notified on the specifiedScheduler

    See Also:

    ReactiveX operators documentation: ObserveOn,RxJava Threading Examples,subscribeOn(io.reactivex.Scheduler),observeOn(Scheduler),observeOn(Scheduler, boolean),delay(long, TimeUnit, Scheduler, boolean)

  • ofType

    @CheckReturnValue@SchedulerSupport(value="none")public final <U> Observable<U> ofType(Class<U> clazz)

    Filters the items emitted by an ObservableSource, only emitting those of the specified type.

    

    Scheduler:

    ofType does not operate by default on a particularScheduler.

    Type Parameters:

    U - the output type

    Parameters:

    clazz - the class type to filter the items emitted by the source ObservableSource

    Returns:

    an Observable that emits items from the source ObservableSource of typeclazz

    See Also:

    ReactiveX operators documentation: Filter

  • onErrorResumeNext

    @CheckReturnValue@SchedulerSupport(value="none")public final Observable<T> onErrorResumeNext(Function<? superThrowable,? extendsObservableSource<? extendsT>> resumeFunction)

    Instructs an ObservableSource to pass control to another ObservableSource rather than invokingonError if it encounters an error.

    

    By default, when an ObservableSource encounters an error that prevents it from emitting the expected item to itsObserver, the ObservableSource invokes its Observer'sonError method, and then quits without invoking any more of its Observer's methods. TheonErrorResumeNext method changes this behavior. If you pass a function that returns an ObservableSource (resumeFunction) toonErrorResumeNext, if the original ObservableSource encounters an error, instead of invoking its Observer'sonError method, it will instead relinquish control to the ObservableSource returned fromresumeFunction, which will invoke the Observer'sonNext method if it is able to do so. In such a case, because no ObservableSource necessarily invokesonError, the Observer may never know that an error happened.

    You can use this to prevent errors from propagating or to supply fallback data should errors be encountered.

    Scheduler:

    onErrorResumeNext does not operate by default on a particularScheduler.

    Parameters:

    resumeFunction - a function that returns an ObservableSource that will take over if the source ObservableSource encounters an error

    Returns:

    the original ObservableSource, with appropriately modified behavior

    See Also:

    ReactiveX operators documentation: Catch

  • onErrorResumeNext

    @CheckReturnValue@SchedulerSupport(value="none")public final Observable<T> onErrorResumeNext(ObservableSource<? extendsT> next)

    Instructs an ObservableSource to pass control to another ObservableSource rather than invokingonError if it encounters an error.

    

    By default, when an ObservableSource encounters an error that prevents it from emitting the expected item to itsObserver, the ObservableSource invokes its Observer'sonError method, and then quits without invoking any more of its Observer's methods. TheonErrorResumeNext method changes this behavior. If you pass another ObservableSource (resumeSequence) to an ObservableSource'sonErrorResumeNext method, if the original ObservableSource encounters an error, instead of invoking its Observer'sonError method, it will instead relinquish control toresumeSequence which will invoke the Observer'sonNext method if it is able to do so. In such a case, because no ObservableSource necessarily invokesonError, the Observer may never know that an error happened.

    You can use this to prevent errors from propagating or to supply fallback data should errors be encountered.

    Scheduler:

    onErrorResumeNext does not operate by default on a particularScheduler.

    Parameters:

    next - the next ObservableSource source that will take over if the source ObservableSource encounters an error

    Returns:

    the original ObservableSource, with appropriately modified behavior

    See Also:

    ReactiveX operators documentation: Catch

  • onErrorReturn

    @CheckReturnValue@SchedulerSupport(value="none")public final Observable<T> onErrorReturn(Function<? superThrowable,? extendsT> valueSupplier)

    Instructs an ObservableSource to emit an item (returned by a specified function) rather than invokingonError if it encounters an error.

    

    By default, when an ObservableSource encounters an error that prevents it from emitting the expected item to itsObserver, the ObservableSource invokes its Observer'sonError method, and then quits without invoking any more of its Observer's methods. TheonErrorReturn method changes this behavior. If you pass a function (resumeFunction) to an ObservableSource'sonErrorReturn method, if the original ObservableSource encounters an error, instead of invoking its Observer'sonError method, it will instead emit the return value ofresumeFunction.

    You can use this to prevent errors from propagating or to supply fallback data should errors be encountered.

    Scheduler:

    onErrorReturn does not operate by default on a particularScheduler.

    Parameters:

    valueSupplier - a function that returns a single value that will be emitted along with a regular onComplete in case the current Observable signals an onError event

    Returns:

    the original ObservableSource with appropriately modified behavior

    See Also:

    ReactiveX operators documentation: Catch

  • onErrorReturnItem

    @CheckReturnValue@SchedulerSupport(value="none")public final Observable<T> onErrorReturnItem(T item)

    Instructs an ObservableSource to emit an item (returned by a specified function) rather than invokingonError if it encounters an error.

    

    By default, when an ObservableSource encounters an error that prevents it from emitting the expected item to itsObserver, the ObservableSource invokes its Observer'sonError method, and then quits without invoking any more of its Observer's methods. TheonErrorReturn method changes this behavior. If you pass a function (resumeFunction) to an ObservableSource'sonErrorReturn method, if the original ObservableSource encounters an error, instead of invoking its Observer'sonError method, it will instead emit the return value ofresumeFunction.

    You can use this to prevent errors from propagating or to supply fallback data should errors be encountered.

    Scheduler:

    onErrorReturnItem does not operate by default on a particularScheduler.

    Parameters:

    item - the value that is emitted along with a regular onComplete in case the current Observable signals an exception

    Returns:

    the original ObservableSource with appropriately modified behavior

    See Also:

    ReactiveX operators documentation: Catch

  • onExceptionResumeNext

    @CheckReturnValue@SchedulerSupport(value="none")public final Observable<T> onExceptionResumeNext(ObservableSource<? extendsT> next)

    Instructs an ObservableSource to pass control to another ObservableSource rather than invokingonError if it encounters anException.

    This differs fromonErrorResumeNext(io.reactivex.functions.Function<? super java.lang.Throwable, ? extends io.reactivex.ObservableSource<? extends T>>) in that this one does not handleThrowable orError but lets those continue through.

    

    By default, when an ObservableSource encounters an exception that prevents it from emitting the expected item to itsObserver, the ObservableSource invokes its Observer'sonError method, and then quits without invoking any more of its Observer's methods. TheonExceptionResumeNext method changes this behavior. If you pass another ObservableSource (resumeSequence) to an ObservableSource'sonExceptionResumeNext method, if the original ObservableSource encounters an exception, instead of invoking its Observer'sonError method, it will instead relinquish control toresumeSequence which will invoke the Observer'sonNext method if it is able to do so. In such a case, because no ObservableSource necessarily invokesonError, the Observer may never know that an exception happened.

    You can use this to prevent exceptions from propagating or to supply fallback data should exceptions be encountered.

    Scheduler:

    onExceptionResumeNext does not operate by default on a particularScheduler.

    Parameters:

    next - the next ObservableSource that will take over if the source ObservableSource encounters an exception

    Returns:

    the original ObservableSource, with appropriately modified behavior

    See Also:

    ReactiveX operators documentation: Catch

  • onTerminateDetach

    @CheckReturnValue@SchedulerSupport(value="none")public final Observable<T> onTerminateDetach()

    Nulls out references to the upstream producer and downstream Observer if the sequence is terminated or downstream calls dispose().

    

    Scheduler:

    onTerminateDetach does not operate by default on a particularScheduler.

    Returns:

    an Observable which nulls out references to the upstream producer and downstream Observer if the sequence is terminated or downstream calls dispose()

    Since:

    2.0

  • publish

    @CheckReturnValue@SchedulerSupport(value="none")public final ConnectableObservable<T> publish()

    Returns aConnectableObservable, which is a variety of ObservableSource that waits until itsconnect method is called before it begins emitting items to thoseObservers that have subscribed to it.

    

    Scheduler:

    publish does not operate by default on a particularScheduler.

    Returns:

    aConnectableObservable that upon connection causes the source ObservableSource to emit items to itsObservers

    See Also:

    ReactiveX operators documentation: Publish

  • publish

    @CheckReturnValue@SchedulerSupport(value="none")public final <R> Observable<R> publish(Function<? superObservable<T>,? extendsObservableSource<R>> selector)

    Returns an Observable that emits the results of invoking a specified selector on items emitted by aConnectableObservable that shares a single subscription to the underlying sequence.

    

    Scheduler:

    publish does not operate by default on a particularScheduler.

    Type Parameters:

    R - the type of items emitted by the resulting ObservableSource

    Parameters:

    selector - a function that can use the multicasted source sequence as many times as needed, without causing multiple subscriptions to the source sequence. Observers to the given source will receive all notifications of the source from the time of the subscription forward.

    Returns:

    an Observable that emits the results of invoking the selector on the items emitted by aConnectableObservable that shares a single subscription to the underlying sequence

    See Also:

    ReactiveX operators documentation: Publish

  • reduce

    @CheckReturnValue@SchedulerSupport(value="none")public final Maybe<T> reduce(BiFunction<T,T,T> reducer)

    Returns a Maybe that applies a specified accumulator function to the first item emitted by a source ObservableSource, then feeds the result of that function along with the second item emitted by the source ObservableSource into the same function, and so on until all items have been emitted by the finite source ObservableSource, and emits the final result from the final call to your function as its sole item.

    

    This technique, which is called "reduce" here, is sometimes called "aggregate," "fold," "accumulate," "compress," or "inject" in other programming contexts. Groovy, for instance, has aninject method that does a similar operation on lists.

    Note that this operator requires the upstream to signalonComplete for the accumulator object to be emitted. Sources that are infinite and never complete will never emit anything through this operator and an infinite source may lead to a fatalOutOfMemoryError.

    Scheduler:

    reduce does not operate by default on a particularScheduler.

    Parameters:

    reducer - an accumulator function to be invoked on each item emitted by the source ObservableSource, whose result will be used in the next accumulator call

    Returns:

    a Maybe that emits a single item that is the result of accumulating the items emitted by the source ObservableSource

    See Also:

    ReactiveX operators documentation: Reduce,Wikipedia: Fold (higher-order function)

  • reduce

    @CheckReturnValue@SchedulerSupport(value="none")public final <R> Single<R> reduce(R seed,BiFunction<R,? superT,R> reducer)

    Returns a Single that applies a specified accumulator function to the first item emitted by a source ObservableSource and a specified seed value, then feeds the result of that function along with the second item emitted by an ObservableSource into the same function, and so on until all items have been emitted by the finite source ObservableSource, emitting the final result from the final call to your function as its sole item.

    

    This technique, which is called "reduce" here, is sometimes called "aggregate," "fold," "accumulate," "compress," or "inject" in other programming contexts. Groovy, for instance, has aninject method that does a similar operation on lists.

    Note that theseed is shared among all subscribers to the resulting ObservableSource and may cause problems if it is mutable. To make sure each subscriber gets its own value, defer the application of this operator viadefer(Callable):

     ObservableSource<T> source = ... Single.defer(() -> source.reduce(new ArrayList<>(), (list, item) -> list.add(item))); // alternatively, by using compose to stay fluent source.compose(o ->     Observable.defer(() -> o.reduce(new ArrayList<>(), (list, item) -> list.add(item)).toObservable()) ).firstOrError(); // or, by using reduceWith instead of reduce source.reduceWith(() -> new ArrayList<>(), (list, item) -> list.add(item)));

    Note that this operator requires the upstream to signalonComplete for the accumulator object to be emitted. Sources that are infinite and never complete will never emit anything through this operator and an infinite source may lead to a fatalOutOfMemoryError.

    Scheduler:

    reduce does not operate by default on a particularScheduler.

    Type Parameters:

    R - the accumulator and output value type

    Parameters:

    seed - the initial (seed) accumulator value

    reducer - an accumulator function to be invoked on each item emitted by the source ObservableSource, the result of which will be used in the next accumulator call

    Returns:

    a Single that emits a single item that is the result of accumulating the output from the items emitted by the source ObservableSource

    See Also:

    ReactiveX operators documentation: Reduce,Wikipedia: Fold (higher-order function),reduceWith(Callable, BiFunction)

  • reduceWith

    @CheckReturnValue@SchedulerSupport(value="none")public final <R> Single<R> reduceWith(Callable<R> seedSupplier,BiFunction<R,? superT,R> reducer)

    Returns a Single that applies a specified accumulator function to the first item emitted by a source ObservableSource and a seed value derived from calling a specified seedSupplier, then feeds the result of that function along with the second item emitted by an ObservableSource into the same function, and so on until all items have been emitted by the finite source ObservableSource, emitting the final result from the final call to your function as its sole item.

    

    This technique, which is called "reduce" here, is sometimes called "aggregate," "fold," "accumulate," "compress," or "inject" in other programming contexts. Groovy, for instance, has aninject method that does a similar operation on lists.

    Note that this operator requires the upstream to signalonComplete for the accumulator object to be emitted. Sources that are infinite and never complete will never emit anything through this operator and an infinite source may lead to a fatalOutOfMemoryError.

    Scheduler:

    reduceWith does not operate by default on a particularScheduler.

    Type Parameters:

    R - the accumulator and output value type

    Parameters:

    seedSupplier - the Callable that provides the initial (seed) accumulator value for each individual Observer

    reducer - an accumulator function to be invoked on each item emitted by the source ObservableSource, the result of which will be used in the next accumulator call

    Returns:

    a Single that emits a single item that is the result of accumulating the output from the items emitted by the source ObservableSource

    See Also:

    ReactiveX operators documentation: Reduce,Wikipedia: Fold (higher-order function)

  • repeat

    @CheckReturnValue@SchedulerSupport(value="none")public final Observable<T> repeat()

    Returns an Observable that repeats the sequence of items emitted by the source ObservableSource indefinitely.

    

    Scheduler:

    repeat does not operate by default on a particularScheduler.

    Returns:

    an Observable that emits the items emitted by the source ObservableSource repeatedly and in sequence

    See Also:

    ReactiveX operators documentation: Repeat

  • repeat

    @CheckReturnValue@SchedulerSupport(value="none")public final Observable<T> repeat(long times)

    Returns an Observable that repeats the sequence of items emitted by the source ObservableSource at mostcount times.

    

    Scheduler:

    repeat does not operate by default on a particularScheduler.

    Parameters:

    times - the number of times the source ObservableSource items are repeated, a count of 0 will yield an empty sequence

    Returns:

    an Observable that repeats the sequence of items emitted by the source ObservableSource at mostcount times

    Throws:

    IllegalArgumentException - ifcount is less than zero

    See Also:

    ReactiveX operators documentation: Repeat

  • repeatUntil

    @CheckReturnValue@SchedulerSupport(value="none")public final Observable<T> repeatUntil(BooleanSupplier stop)

    Returns an Observable that repeats the sequence of items emitted by the source ObservableSource until the provided stop function returns true.

    

    Scheduler:

    repeatUntil does not operate by default on a particularScheduler.

    Parameters:

    stop - a boolean supplier that is called when the current Observable completes; if it returns true, the returned Observable completes; if it returns false, the upstream Observable is resubscribed.

    Returns:

    the new Observable instance

    Throws:

    NullPointerException - ifstop is null

    See Also:

    ReactiveX operators documentation: Repeat

  • repeatWhen

    @CheckReturnValue@SchedulerSupport(value="none")public final Observable<T> repeatWhen(Function<? superObservable<Object>,? extendsObservableSource<?>> handler)

    Returns an Observable that emits the same values as the source ObservableSource with the exception of anonComplete. AnonComplete notification from the source will result in the emission of avoid item to the ObservableSource provided as an argument to thenotificationHandler function. If that ObservableSource callsonComplete oronError thenrepeatWhen will callonComplete oronError on the child subscription. Otherwise, this ObservableSource will resubscribe to the source ObservableSource.

    

    Scheduler:

    repeatWhen does not operate by default on a particularScheduler.

    Parameters:

    handler - receives an ObservableSource of notifications with which a user can complete or error, aborting the repeat.

    Returns:

    the source ObservableSource modified with repeat logic

    See Also:

    ReactiveX operators documentation: Repeat

  • replay

    @CheckReturnValue@SchedulerSupport(value="none")public final ConnectableObservable<T> replay()

    Returns aConnectableObservable that shares a single subscription to the underlying ObservableSource that will replay all of its items and notifications to any futureObserver. A Connectable ObservableSource resembles an ordinary ObservableSource, except that it does not begin emitting items when it is subscribed to, but only when itsconnect method is called.

    

    Scheduler:

    This version ofreplay does not operate by default on a particularScheduler.

    Returns:

    aConnectableObservable that upon connection causes the source ObservableSource to emit its items to itsObservers

    See Also:

    ReactiveX operators documentation: Replay

  • replay

    @CheckReturnValue@SchedulerSupport(value="none")public final <R> Observable<R> replay(Function<? superObservable<T>,? extendsObservableSource<R>> selector)

    Returns an Observable that emits items that are the results of invoking a specified selector on the items emitted by aConnectableObservable that shares a single subscription to the source ObservableSource.

    

    Scheduler:

    This version ofreplay does not operate by default on a particularScheduler.

    Type Parameters:

    R - the type of items emitted by the resulting ObservableSource

    Parameters:

    selector - the selector function, which can use the multicasted sequence as many times as needed, without causing multiple subscriptions to the ObservableSource

    Returns:

    an Observable that emits items that are the results of invoking the selector on aConnectableObservable that shares a single subscription to the source ObservableSource

    See Also:

    ReactiveX operators documentation: Replay

  • replay

    @CheckReturnValue@SchedulerSupport(value="none")public final <R> Observable<R> replay(Function<? superObservable<T>,? extendsObservableSource<R>> selector,        int bufferSize)

    Returns an Observable that emits items that are the results of invoking a specified selector on items emitted by aConnectableObservable that shares a single subscription to the source ObservableSource, replayingbufferSize notifications.

    Note that due to concurrency requirements,replay(bufferSize) may hold strong references to more thanbufferSize source emissions.

    

    Scheduler:

    This version ofreplay does not operate by default on a particularScheduler.

    Type Parameters:

    R - the type of items emitted by the resulting ObservableSource

    Parameters:

    selector - the selector function, which can use the multicasted sequence as many times as needed, without causing multiple subscriptions to the ObservableSource

    bufferSize - the buffer size that limits the number of items the connectable ObservableSource can replay

    Returns:

    an Observable that emits items that are the results of invoking the selector on items emitted by aConnectableObservable that shares a single subscription to the source ObservableSource replaying no more thanbufferSize items

    See Also:

    ReactiveX operators documentation: Replay

  • replay

    @CheckReturnValue@SchedulerSupport(value="io.reactivex:computation")public final <R> Observable<R> replay(Function<? superObservable<T>,? extendsObservableSource<R>> selector,        int bufferSize,        long time,TimeUnit unit)

    Returns an Observable that emits items that are the results of invoking a specified selector on items emitted by aConnectableObservable that shares a single subscription to the source ObservableSource, replaying no more thanbufferSize items that were emitted within a specified time window.

    Note that due to concurrency requirements,replay(bufferSize) may hold strong references to more thanbufferSize source emissions.

    

    Scheduler:

    This version ofreplay operates by default on thecomputationScheduler.

    Type Parameters:

    R - the type of items emitted by the resulting ObservableSource

    Parameters:

    selector - a selector function, which can use the multicasted sequence as many times as needed, without causing multiple subscriptions to the ObservableSource

    bufferSize - the buffer size that limits the number of items the connectable ObservableSource can replay

    time - the duration of the window in which the replayed items must have been emitted

    unit - the time unit oftime

    Returns:

    an Observable that emits items that are the results of invoking the selector on items emitted by aConnectableObservable that shares a single subscription to the source ObservableSource, and replays no more thanbufferSize items that were emitted within the window defined bytime

    See Also:

    ReactiveX operators documentation: Replay

  • replay

    @CheckReturnValue@SchedulerSupport(value="custom")public final <R> Observable<R> replay(Function<? superObservable<T>,? extendsObservableSource<R>> selector,        int bufferSize,        long time,TimeUnit unit,Scheduler scheduler)

    Returns an Observable that emits items that are the results of invoking a specified selector on items emitted by aConnectableObservable that shares a single subscription to the source ObservableSource, replaying no more thanbufferSize items that were emitted within a specified time window.

    Note that due to concurrency requirements,replay(bufferSize) may hold strong references to more thanbufferSize source emissions.

    

    Scheduler:

    You specify whichScheduler this operator will use.

    Type Parameters:

    R - the type of items emitted by the resulting ObservableSource

    Parameters:

    selector - a selector function, which can use the multicasted sequence as many times as needed, without causing multiple subscriptions to the ObservableSource

    bufferSize - the buffer size that limits the number of items the connectable ObservableSource can replay

    time - the duration of the window in which the replayed items must have been emitted

    unit - the time unit oftime

    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 aConnectableObservable that shares a single subscription to the source ObservableSource, and replays no more thanbufferSize items that were emitted within the window defined bytime

    Throws:

    IllegalArgumentException - ifbufferSize is less than zero

    See Also:

    ReactiveX operators documentation: Replay

  • replay

    @CheckReturnValue@SchedulerSupport(value="custom")public final <R> Observable<R> replay(Function<? superObservable<T>,? extendsObservableSource<R>> selector,        int bufferSize,Scheduler scheduler)

    Returns an Observable that emits items that are the results of invoking a specified selector on items emitted by aConnectableObservable that shares a single subscription to the source ObservableSource, replaying a maximum ofbufferSize items.

    Note that due to concurrency requirements,replay(bufferSize) may hold strong references to more thanbufferSize source emissions.

    

    Scheduler:

    You specify whichScheduler this operator will use.

    Type Parameters:

    R - the type of items emitted by the resulting ObservableSource

    Parameters:

    selector - a selector function, which can use the multicasted sequence as many times as needed, without causing multiple subscriptions to the ObservableSource

    bufferSize - the buffer size that limits the number of items the connectable ObservableSource can replay

    scheduler - the Scheduler on which the replay is observed

    Returns:

    an Observable that emits items that are the results of invoking the selector on items emitted by aConnectableObservable that shares a single subscription to the source ObservableSource, replaying no more thanbufferSize notifications

    See Also:

    ReactiveX operators documentation: Replay

  • replay

    @CheckReturnValue@SchedulerSupport(value="io.reactivex:computation")public final <R> Observable<R> replay(Function<? superObservable<T>,? extendsObservableSource<R>> selector,        long time,TimeUnit unit)

    Returns an Observable that emits items that are the results of invoking a specified selector on items emitted by aConnectableObservable that shares a single subscription to the source ObservableSource, replaying all items that were emitted within a specified time window.

    

    Scheduler:

    This version ofreplay operates by default on thecomputationScheduler.

    Type Parameters:

    R - the type of items emitted by the resulting ObservableSource

    Parameters:

    selector - a selector function, which can use the multicasted sequence as many times as needed, without causing multiple subscriptions to the ObservableSource

    time - the duration of the window in which the replayed items must have been emitted

    unit - the time unit oftime

    Returns:

    an Observable that emits items that are the results of invoking the selector on items emitted by aConnectableObservable that shares a single subscription to the source ObservableSource, replaying all items that were emitted within the window defined bytime

    See Also:

    ReactiveX operators documentation: Replay

  • replay

    @CheckReturnValue@SchedulerSupport(value="custom")public final <R> Observable<R> replay(Function<? superObservable<T>,? extendsObservableSource<R>> selector,        long time,TimeUnit unit,Scheduler scheduler)

    Returns an Observable that emits items that are the results of invoking a specified selector on items emitted by aConnectableObservable that shares a single subscription to the source ObservableSource, replaying all items that were emitted within a specified time window.

    

    Scheduler:

    You specify whichScheduler this operator will use.

    Type Parameters:

    R - the type of items emitted by the resulting ObservableSource

    Parameters:

    selector - a selector function, which can use the multicasted sequence as many times as needed, without causing multiple subscriptions to the ObservableSource

    time - the duration of the window in which the replayed items must have been emitted

    unit - the time unit oftime

    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 aConnectableObservable that shares a single subscription to the source ObservableSource, replaying all items that were emitted within the window defined bytime

    See Also:

    ReactiveX operators documentation: Replay

  • replay

    @CheckReturnValue@SchedulerSupport(value="custom")public final <R> Observable<R> replay(Function<? superObservable<T>,? extendsObservableSource<R>> selector,Scheduler scheduler)

    Returns an Observable that emits items that are the results of invoking a specified selector on items emitted by aConnectableObservable that shares a single subscription to the source ObservableSource.

    

    Scheduler:

    You specify whichScheduler this operator will use.

    Type Parameters:

    R - the type of items emitted by the resulting ObservableSource

    Parameters:

    selector - a selector function, which can use the multicasted sequence as many times as needed, without causing multiple subscriptions to the ObservableSource

    scheduler - the Scheduler where the replay is observed

    Returns:

    an Observable that emits items that are the results of invoking the selector on items emitted by aConnectableObservable that shares a single subscription to the source ObservableSource, replaying all items

    See Also:

    ReactiveX operators documentation: Replay

  • replay

    @CheckReturnValue@SchedulerSupport(value="none")public final ConnectableObservable<T> replay(int bufferSize)

    Returns aConnectableObservable that shares a single subscription to the source ObservableSource that replays at mostbufferSize items emitted by that ObservableSource. A Connectable ObservableSource resembles an ordinary ObservableSource, except that it does not begin emitting items when it is subscribed to, but only when itsconnect method is called.

    Note that due to concurrency requirements,replay(bufferSize) may hold strong references to more thanbufferSize source emissions.

    

    Scheduler:

    This version ofreplay does not operate by default on a particularScheduler.

    Parameters:

    bufferSize - the buffer size that limits the number of items that can be replayed

    Returns:

    aConnectableObservable that shares a single subscription to the source ObservableSource and replays at mostbufferSize items emitted by that ObservableSource

    See Also:

    ReactiveX operators documentation: Replay

  • replay

    @CheckReturnValue@SchedulerSupport(value="io.reactivex:computation")public final ConnectableObservable<T> replay(int bufferSize,        long time,TimeUnit unit)

    Returns aConnectableObservable that shares a single subscription to the source ObservableSource and replays at mostbufferSize items that were emitted during a specified time window. A Connectable ObservableSource resembles an ordinary ObservableSource, except that it does not begin emitting items when it is subscribed to, but only when itsconnect method is called.

    Note that due to concurrency requirements,replay(bufferSize) may hold strong references to more thanbufferSize source emissions.

    

    Scheduler:

    This version ofreplay operates by default on thecomputationScheduler.

    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 oftime

    Returns:

    aConnectableObservable that shares a single subscription to the source ObservableSource and replays at mostbufferSize items that were emitted during the window defined bytime

    See Also:

    ReactiveX operators documentation: Replay

  • replay

    @CheckReturnValue@SchedulerSupport(value="custom")public final ConnectableObservable<T> replay(int bufferSize,        long time,TimeUnit unit,Scheduler scheduler)

    Returns aConnectableObservable that shares a single subscription to the source ObservableSource and that replays a maximum ofbufferSize items that are emitted within a specified time window. A Connectable ObservableSource resembles an ordinary ObservableSource, except that it does not begin emitting items when it is subscribed to, but only when itsconnect method is called.

    Note that due to concurrency requirements,replay(bufferSize) may hold strong references to more thanbufferSize source emissions.

    

    Scheduler:

    You specify whichScheduler 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 oftime

    scheduler - the scheduler that is used as a time source for the window

    Returns:

    aConnectableObservable that shares a single subscription to the source ObservableSource and replays at mostbufferSize items that were emitted during the window defined bytime

    Throws:

    IllegalArgumentException - ifbufferSize is less than zero

    See Also:

    ReactiveX operators documentation: Replay

  • replay

    @CheckReturnValue@SchedulerSupport(value="custom")public final ConnectableObservable<T> replay(int bufferSize,Scheduler scheduler)

    Returns aConnectableObservable that shares a single subscription to the source ObservableSource and replays at mostbufferSize items emitted by that ObservableSource. A Connectable ObservableSource resembles an ordinary ObservableSource, except that it does not begin emitting items when it is subscribed to, but only when itsconnect method is called.

    Note that due to concurrency requirements,replay(bufferSize) may hold strong references to more thanbufferSize source emissions.

    

    Scheduler:

    You specify whichScheduler 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:

    aConnectableObservable that shares a single subscription to the source ObservableSource and replays at mostbufferSize items that were emitted by the ObservableSource

    See Also:

    ReactiveX operators documentation: Replay

  • replay

    @CheckReturnValue@SchedulerSupport(value="io.reactivex:computation")public final ConnectableObservable<T> replay(long time,TimeUnit unit)

    Returns aConnectableObservable that shares a single subscription to the source ObservableSource and replays all items emitted by that ObservableSource within a specified time window. A Connectable ObservableSource resembles an ordinary ObservableSource, except that it does not begin emitting items when it is subscribed to, but only when itsconnect method is called.

    

    Scheduler:

    This version ofreplay operates by default on thecomputationScheduler.

    Parameters:

    time - the duration of the window in which the replayed items must have been emitted

    unit - the time unit oftime

    Returns:

    aConnectableObservable that shares a single subscription to the source ObservableSource and replays the items that were emitted during the window defined bytime

    See Also:

    ReactiveX operators documentation: Replay

  • replay

    @CheckReturnValue@SchedulerSupport(value="custom")public final ConnectableObservable<T> replay(long time,TimeUnit unit,Scheduler scheduler)

    Returns aConnectableObservable that shares a single subscription to the source ObservableSource and replays all items emitted by that ObservableSource within a specified time window. A Connectable ObservableSource resembles an ordinary ObservableSource, except that it does not begin emitting items when it is subscribed to, but only when itsconnect method is called.

    

    Scheduler:

    You specify whichScheduler this operator will use.

    Parameters:

    time - the duration of the window in which the replayed items must have been emitted

    unit - the time unit oftime

    scheduler - the Scheduler that is the time source for the window

    Returns:

    aConnectableObservable that shares a single subscription to the source ObservableSource and replays the items that were emitted during the window defined bytime

    See Also:

    ReactiveX operators documentation: Replay

  • replay

    @CheckReturnValue@SchedulerSupport(value="custom")public final ConnectableObservable<T> replay(Scheduler scheduler)

    Returns aConnectableObservable that shares a single subscription to the source ObservableSource that will replay all of its items and notifications to any futureObserver on the givenScheduler. A Connectable ObservableSource resembles an ordinary ObservableSource, except that it does not begin emitting items when it is subscribed to, but only when itsconnect method is called.

    

    Scheduler:

    You specify whichScheduler this operator will use.

    Parameters:

    scheduler - the Scheduler on which the Observers will observe the emitted items

    Returns:

    aConnectableObservable that shares a single subscription to the source ObservableSource that will replay all of its items and notifications to any futureObserver on the givenScheduler

    See Also:

    ReactiveX operators documentation: Replay

  • retry

    @CheckReturnValue@SchedulerSupport(value="none")public final Observable<T> retry()

    Returns an Observable that mirrors the source ObservableSource, resubscribing to it if it callsonError (infinite retry count).

    

    If the source ObservableSource callsObserver.onError(java.lang.Throwable), this method will resubscribe to the source ObservableSource rather than propagating theonError call.

    Any and all items emitted by the source ObservableSource will be emitted by the resulting ObservableSource, even those emitted during failed subscriptions. For example, if an ObservableSource fails at first but emits[1, 2] then succeeds the second time and emits[1, 2, 3, 4, 5] then the complete sequence of emissions and notifications would be[1, 2, 1, 2, 3, 4, 5, onComplete].

    Scheduler:

    retry does not operate by default on a particularScheduler.

    Returns:

    the source ObservableSource modified with retry logic

    See Also:

    ReactiveX operators documentation: Retry

  • retry

    @CheckReturnValue@SchedulerSupport(value="none")public final Observable<T> retry(BiPredicate<? superInteger,? superThrowable> predicate)

    Returns an Observable that mirrors the source ObservableSource, resubscribing to it if it callsonError and the predicate returns true for that specific exception and retry count.

    

    Scheduler:

    retry does not operate by default on a particularScheduler.

    Parameters:

    predicate - the predicate that determines if a resubscription may happen in case of a specific exception and retry count

    Returns:

    the source ObservableSource modified with retry logic

    See Also:

    retry(),ReactiveX operators documentation: Retry

  • retry

    @CheckReturnValue@SchedulerSupport(value="none")public final Observable<T> retry(long times)

    Returns an Observable that mirrors the source ObservableSource, resubscribing to it if it callsonError up to a specified number of retries.

    

    If the source ObservableSource callsObserver.onError(java.lang.Throwable), this method will resubscribe to the source ObservableSource for a maximum ofcount resubscriptions rather than propagating theonError call.

    Any and all items emitted by the source ObservableSource will be emitted by the resulting ObservableSource, even those emitted during failed subscriptions. For example, if an ObservableSource fails at first but emits[1, 2] then succeeds the second time and emits[1, 2, 3, 4, 5] then the complete sequence of emissions and notifications would be[1, 2, 1, 2, 3, 4, 5, onComplete].

    Scheduler:

    retry does not operate by default on a particularScheduler.

    Parameters:

    times - the number of times to resubscribe if the current Observable fails

    Returns:

    the source ObservableSource modified with retry logic

    See Also:

    ReactiveX operators documentation: Retry

  • retry

    @CheckReturnValue@SchedulerSupport(value="none")public final Observable<T> retry(long times,Predicate<? superThrowable> predicate)

    Retries at most times or until the predicate returns false, whichever happens first.

    

    Scheduler:

    retry does not operate by default on a particularScheduler.

    Parameters:

    times - the number of times to resubscribe if the current Observable fails

    predicate - the predicate called with the failure Throwable and should return true to trigger a retry.

    Returns:

    the new Observable instance

  • retry

    @CheckReturnValue@SchedulerSupport(value="none")public final Observable<T> retry(Predicate<? superThrowable> predicate)

    Retries the current Observable if the predicate returns true.

    

    Scheduler:

    retry does not operate by default on a particularScheduler.

    Parameters:

    predicate - the predicate that receives the failure Throwable and should return true to trigger a retry.

    Returns:

    the new Observable instance

  • retryUntil

    @CheckReturnValue@SchedulerSupport(value="none")public final Observable<T> retryUntil(BooleanSupplier stop)

    Retries until the given stop function returns true.

    

    Scheduler:

    retryUntil does not operate by default on a particularScheduler.

    Parameters:

    stop - the function that should return true to stop retrying

    Returns:

    the new Observable instance

  • retryWhen

    @CheckReturnValue@SchedulerSupport(value="none")public final Observable<T> retryWhen(Function<? superObservable<Throwable>,? extendsObservableSource<?>> handler)

    Returns an Observable that emits the same values as the source ObservableSource with the exception of anonError. AnonError notification from the source will result in the emission of aThrowable item to the ObservableSource provided as an argument to thenotificationHandler function. If that ObservableSource callsonComplete oronError thenretry will callonComplete oronError on the child subscription. Otherwise, this ObservableSource will resubscribe to the source ObservableSource.

    

    Example: This retries 3 times, each time incrementing the number of seconds it waits.

      Observable.create((ObservableEmitter<? super String> s) -> {      System.out.println("subscribing");      s.onError(new RuntimeException("always fails"));  }).retryWhen(attempts -> {      return attempts.zipWith(Observable.range(1, 3), (n, i) -> i).flatMap(i -> {          System.out.println("delay retry by " + i + " second(s)");          return Observable.timer(i, TimeUnit.SECONDS);      });  }).blockingForEach(System.out::println);

    Output is:

     subscribing delay retry by 1 second(s) subscribing delay retry by 2 second(s) subscribing delay retry by 3 second(s) subscribing

    Note that the innerObservableSource returned by the handler function should signal eitheronNext,onError oronComplete in response to the receivedThrowable to indicate the operator should retry or terminate. If the upstream to the operator is asynchronous, signalling onNext followed by onComplete immediately may result in the sequence to be completed immediately. Similarly, if this innerObservableSource signalsonError oronComplete while the upstream is active, the sequence is terminated with the same signal immediately.

    The following example demonstrates how to retry an asynchronous source with a delay:

     Observable.timer(1, TimeUnit.SECONDS)     .doOnSubscribe(s -> System.out.println("subscribing"))     .map(v -> { throw new RuntimeException(); })     .retryWhen(errors -> {         AtomicInteger counter = new AtomicInteger();         return errors                   .takeWhile(e -> counter.getAndIncrement() != 3)                   .flatMap(e -> {                       System.out.println("delay retry by " + counter.get() + " second(s)");                       return Observable.timer(counter.get(), TimeUnit.SECONDS);                   });     })     .blockingSubscribe(System.out::println, System.out::println);

    Scheduler:

    retryWhen does not operate by default on a particularScheduler.

    Parameters:

    handler - receives an ObservableSource of notifications with which a user can complete or error, aborting the retry

    Returns:

    the source ObservableSource modified with retry logic

    See Also:

    ReactiveX operators documentation: Retry

  • safeSubscribe

    @SchedulerSupport(value="none")public final void safeSubscribe(Observer<? superT> observer)

    Subscribes to the current Observable and wraps the given Observer into a SafeObserver (if not already a SafeObserver) that deals with exceptions thrown by a misbehaving Observer (that doesn't follow the Reactive Streams specification).

    Scheduler:

    safeSubscribe does not operate by default on a particularScheduler.

    Parameters:

    observer - the incoming Observer instance

    Throws:

    NullPointerException - if s is null

  • sample

    @CheckReturnValue@SchedulerSupport(value="io.reactivex:computation")public final Observable<T> sample(long period,TimeUnit unit)

    Returns an Observable that emits the most recently emitted item (if any) emitted by the source ObservableSource within periodic time intervals.

    

    Scheduler:

    sample operates by default on thecomputationScheduler.

    Parameters:

    period - the sampling rate

    unit - theTimeUnit in whichperiod is defined

    Returns:

    an Observable that emits the results of sampling the items emitted by the source ObservableSource at the specified time interval

    See Also:

    ReactiveX operators documentation: Sample,throttleLast(long, TimeUnit)

  • sample

    @CheckReturnValue@SchedulerSupport(value="io.reactivex:computation")public final Observable<T> sample(long period,TimeUnit unit,        boolean emitLast)

    Returns an Observable that emits the most recently emitted item (if any) emitted by the source ObservableSource within periodic time intervals and optionally emit the very last upstream item when the upstream completes.

    

    Scheduler:

    sample operates by default on thecomputationScheduler.

    History: 2.0.5 - experimental

    Parameters:

    period - the sampling rate

    unit - theTimeUnit in whichperiod is defined

    emitLast - if true and the upstream completes while there is still an unsampled item available, that item is emitted to downstream before completion if false, an unsampled last item is ignored.

    Returns:

    an Observable that emits the results of sampling the items emitted by the source ObservableSource at the specified time interval

    Since:

    2.1

    See Also:

    ReactiveX operators documentation: Sample,throttleLast(long, TimeUnit)

  • sample

    @CheckReturnValue@SchedulerSupport(value="custom")public final Observable<T> sample(long period,TimeUnit unit,Scheduler scheduler)

    Returns an Observable that emits the most recently emitted item (if any) emitted by the source ObservableSource within periodic time intervals, where the intervals are defined on a particular Scheduler.

    

    Scheduler:

    You specify whichScheduler this operator will use.

    Parameters:

    period - the sampling rate

    unit - theTimeUnit in whichperiod is defined

    scheduler - theScheduler to use when sampling

    Returns:

    an Observable that emits the results of sampling the items emitted by the source ObservableSource at the specified time interval

    See Also:

    ReactiveX operators documentation: Sample,throttleLast(long, TimeUnit, Scheduler)

  • sample

    @CheckReturnValue@SchedulerSupport(value="custom")public final Observable<T> sample(long period,TimeUnit unit,Scheduler scheduler,        boolean emitLast)

    Returns an Observable that emits the most recently emitted item (if any) emitted by the source ObservableSource within periodic time intervals, where the intervals are defined on a particular Scheduler and optionally emit the very last upstream item when the upstream completes.

    

    Scheduler:

    You specify whichScheduler this operator will use.

    History: 2.0.5 - experimental

    Parameters:

    period - the sampling rate

    unit - theTimeUnit in whichperiod is defined

    scheduler - theScheduler to use when sampling

    emitLast - if true and the upstream completes while there is still an unsampled item available, that item is emitted to downstream before completion if false, an unsampled last item is ignored.

    Returns:

    an Observable that emits the results of sampling the items emitted by the source ObservableSource at the specified time interval

    Since:

    2.1

    See Also:

    ReactiveX operators documentation: Sample,throttleLast(long, TimeUnit, Scheduler)

  • sample

    @CheckReturnValue@SchedulerSupport(value="none")public final <U> Observable<T> sample(ObservableSource<U> sampler)

    Returns an Observable that, when the specifiedsampler ObservableSource emits an item or completes, emits the most recently emitted item (if any) emitted by the source ObservableSource since the previous emission from thesampler ObservableSource.

    

    Scheduler:

    This version ofsample does not operate by default on a particularScheduler.

    Type Parameters:

    U - the element type of the sampler ObservableSource

    Parameters:

    sampler - the ObservableSource to use for sampling the source ObservableSource

    Returns:

    an Observable that emits the results of sampling the items emitted by this ObservableSource whenever thesampler ObservableSource emits an item or completes

    See Also:

    ReactiveX operators documentation: Sample

  • sample

    @CheckReturnValue@SchedulerSupport(value="none")public final <U> Observable<T> sample(ObservableSource<U> sampler,        boolean emitLast)

    Returns an Observable that, when the specifiedsampler ObservableSource emits an item or completes, emits the most recently emitted item (if any) emitted by the source ObservableSource since the previous emission from thesampler ObservableSource and optionally emit the very last upstream item when the upstream or other ObservableSource complete.

    

    Scheduler:

    This version ofsample does not operate by default on a particularScheduler.

    History: 2.0.5 - experimental

    Type Parameters:

    U - the element type of the sampler ObservableSource

    Parameters:

    sampler - the ObservableSource to use for sampling the source ObservableSource

    emitLast - if true and the upstream completes while there is still an unsampled item available, that item is emitted to downstream before completion if false, an unsampled last item is ignored.

    Returns:

    an Observable that emits the results of sampling the items emitted by this ObservableSource whenever thesampler ObservableSource emits an item or completes

    Since:

    2.1

    See Also:

    ReactiveX operators documentation: Sample

  • scan

    @CheckReturnValue@SchedulerSupport(value="none")public final Observable<T> scan(BiFunction<T,T,T> accumulator)

    Returns an Observable that applies a specified accumulator function to the first item emitted by a source ObservableSource, then feeds the result of that function along with the second item emitted by the source ObservableSource into the same function, and so on until all items have been emitted by the source ObservableSource, emitting the result of each of these iterations.

    

    This sort of function is sometimes called an accumulator.

    Scheduler:

    scan does not operate by default on a particularScheduler.

    Parameters:

    accumulator - an accumulator function to be invoked on each item emitted by the source ObservableSource, whose result will be emitted toObservers viaonNext 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

    @CheckReturnValue@SchedulerSupport(value="none")public final <R> Observable<R> scan(R initialValue,BiFunction<R,? superT,R> accumulator)

    Returns an Observable that applies a specified accumulator function to the first item emitted by a source ObservableSource and a seed value, then feeds the result of that function along with the second item emitted by the source ObservableSource into the same function, and so on until all items have been emitted by the source ObservableSource, emitting the result of each of these iterations.

    

    This sort of function is sometimes called an accumulator.

    Note that the ObservableSource that results from this method will emitinitialValue as its first emitted item.

    Note that theinitialValue is shared among all subscribers to the resulting ObservableSource and may cause problems if it is mutable. To make sure each subscriber gets its own value, defer the application of this operator viadefer(Callable):

     ObservableSource<T> source = ... Observable.defer(() -> source.scan(new ArrayList<>(), (list, item) -> list.add(item))); // alternatively, by using compose to stay fluent source.compose(o ->     Observable.defer(() -> o.scan(new ArrayList<>(), (list, item) -> list.add(item))) );

    Scheduler:

    scan does not operate by default on a particularScheduler.

    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 ObservableSource, whose result will be emitted toObservers viaonNext and used in the next accumulator call

    Returns:

    an Observable that emitsinitialValue followed by the results of each call to the accumulator function

    See Also:

    ReactiveX operators documentation: Scan

  • scanWith

    @CheckReturnValue@SchedulerSupport(value="none")public final <R> Observable<R> scanWith(Callable<R> seedSupplier,BiFunction<R,? superT,R> accumulator)

    Returns an Observable that applies a specified accumulator function to the first item emitted by a source ObservableSource and a seed value, then feeds the result of that function along with the second item emitted by the source ObservableSource into the same function, and so on until all items have been emitted by the source ObservableSource, emitting the result of each of these iterations.

    

    This sort of function is sometimes called an accumulator.

    Note that the ObservableSource that results from this method will emit the value returned by theseedSupplier as its first item.

    Scheduler:

    scanWith does not operate by default on a particularScheduler.

    Type Parameters:

    R - the initial, accumulator and result type

    Parameters:

    seedSupplier - a Callable that returns the initial (seed) accumulator item for each individual Observer

    accumulator - an accumulator function to be invoked on each item emitted by the source ObservableSource, whose result will be emitted toObservers viaonNext and used in the next accumulator call

    Returns:

    an Observable that emitsinitialValue followed by the results of each call to the accumulator function

    See Also:

    ReactiveX operators documentation: Scan

  • serialize

    @CheckReturnValue@SchedulerSupport(value="none")public final Observable<T> serialize()

    Forces an ObservableSource's emissions and notifications to be serialized and for it to obeythe ObservableSource contract in other ways.

    It is possible for an ObservableSource to invoke its Observers' methods asynchronously, perhaps from different threads. This could make such an ObservableSource poorly-behaved, in that it might try to invokeonComplete oronError before one of itsonNext invocations, or it might callonNext from two different threads concurrently. You can force such an ObservableSource to be well-behaved and sequential by applying theserialize method to it.

    

    Scheduler:

    serialize does not operate by default on a particularScheduler.

    Returns:

    anObservableSource that is guaranteed to be well-behaved and to make only serialized calls to its observers

    See Also:

    ReactiveX operators documentation: Serialize

  • share

    @CheckReturnValue@SchedulerSupport(value="none")public final Observable<T> share()

    Returns a newObservableSource that multicasts (and shares a single subscription to) the originalObservableSource. As long as there is at least oneObserver thisObservableSource will be subscribed and emitting data. When all subscribers have disposed it will dispose the sourceObservableSource.

    This is an alias forpublish().refCount().

    

    Scheduler:

    share does not operate by default on a particularScheduler.

    Returns:

    anObservableSource that upon connection causes the sourceObservableSource to emit items to itsObservers

    See Also:

    ReactiveX operators documentation: RefCount

  • singleElement

    @CheckReturnValue@SchedulerSupport(value="none")public final Maybe<T> singleElement()

    Returns a Maybe that completes if this Observable is empty or emits the single item emitted by this Observable, or signals anIllegalArgumentException if this Observable emits more than one item.

    

    Scheduler:

    singleElement does not operate by default on a particularScheduler.

    Returns:

    aMaybe that emits the single item emitted by the source ObservableSource

    See Also:

    ReactiveX operators documentation: First

  • single

    @CheckReturnValue@SchedulerSupport(value="none")public final Single<T> single(T defaultItem)

    Returns a Single that emits the single item emitted by this Observable, if this Observable emits only a single item, or a default item if the source ObservableSource emits no items. If the source ObservableSource emits more than one item, anIllegalArgumentException is signalled instead.

    

    Scheduler:

    single does not operate by default on a particularScheduler.

    Parameters:

    defaultItem - a default value to emit if the source ObservableSource emits no item

    Returns:

    the new Single instance

    See Also:

    ReactiveX operators documentation: First

  • singleOrError

    @CheckReturnValue@SchedulerSupport(value="none")public final Single<T> singleOrError()

    Returns a Single that emits the single item emitted by this Observable if this Observable emits only a single item, otherwise if this Observable completes without emitting any items or emits more than one item aNoSuchElementException orIllegalArgumentException will be signalled respectively.

    

    Scheduler:

    singleOrError does not operate by default on a particularScheduler.

    Returns:

    the new Single instance

    See Also:

    ReactiveX operators documentation: First

  • skip

    @CheckReturnValue@SchedulerSupport(value="none")public final Observable<T> skip(long count)

    Returns an Observable that skips the firstcount items emitted by the source ObservableSource and emits the remainder.

    

    Scheduler:

    This version ofskip does not operate by default on a particularScheduler.

    Parameters:

    count - the number of items to skip

    Returns:

    an Observable that is identical to the source ObservableSource except that it does not emit the firstcount items that the source ObservableSource emits

    See Also:

    ReactiveX operators documentation: Skip

  • skip

    @CheckReturnValue@SchedulerSupport(value="io.reactivex:computation")public final Observable<T> skip(long time,TimeUnit unit)

    Returns an Observable that skips values emitted by the source ObservableSource before a specified time window elapses.

    

    Scheduler:

    skip does not operate on any particular scheduler but uses the current time from thecomputationScheduler.

    Parameters:

    time - the length of the time window to skip

    unit - the time unit oftime

    Returns:

    an Observable that skips values emitted by the source ObservableSource before the time window defined bytime elapses and the emits the remainder

    See Also:

    ReactiveX operators documentation: Skip

  • skip

    @CheckReturnValue@SchedulerSupport(value="custom")public final Observable<T> skip(long time,TimeUnit unit,Scheduler scheduler)

    Returns an Observable that skips values emitted by the source ObservableSource before a specified time window on a specifiedScheduler elapses.

    

    Scheduler:

    You specify whichScheduler this operator will use for the timed skipping

    Parameters:

    time - the length of the time window to skip

    unit - the time unit oftime

    scheduler - theScheduler on which the timed wait happens

    Returns:

    an Observable that skips values emitted by the source ObservableSource before the time window defined bytime andscheduler elapses, and then emits the remainder

    See Also:

    ReactiveX operators documentation: Skip

  • skipLast

    @CheckReturnValue@SchedulerSupport(value="none")public final Observable<T> skipLast(int count)

    Returns an Observable that drops a specified number of items from the end of the sequence emitted by the source ObservableSource.

    

    This Observer accumulates a queue long enough to store the firstcount items. As more items are received, items are taken from the front of the queue and emitted by the returned ObservableSource. This causes such items to be delayed.

    Scheduler:

    This version ofskipLast does not operate by default on a particularScheduler.

    Parameters:

    count - number of items to drop from the end of the source sequence

    Returns:

    an Observable that emits the items emitted by the source ObservableSource except for the dropped ones at the end

    Throws:

    IndexOutOfBoundsException - ifcount is less than zero

    See Also:

    ReactiveX operators documentation: SkipLast

  • skipLast

    @CheckReturnValue@SchedulerSupport(value="io.reactivex:trampoline")public final Observable<T> skipLast(long time,TimeUnit unit)

    Returns an Observable that drops items emitted by the source ObservableSource during a specified time window before the source completes.

    

    Note: this action will cache the latest items arriving in the specified time window.

    Scheduler:

    skipLast does not operate on any particular scheduler but uses the current time from thecomputationScheduler.

    Parameters:

    time - the length of the time window

    unit - the time unit oftime

    Returns:

    an Observable that drops those items emitted by the source ObservableSource in a time window before the source completes defined bytime

    See Also:

    ReactiveX operators documentation: SkipLast

  • skipLast

    @CheckReturnValue@SchedulerSupport(value="io.reactivex:trampoline")public final Observable<T> skipLast(long time,TimeUnit unit,        boolean delayError)

    Returns an Observable that drops items emitted by the source ObservableSource during a specified time window before the source completes.

    

    Note: this action will cache the latest items arriving in the specified time window.

    Scheduler:

    skipLast does not operate on any particular scheduler but uses the current time from thecomputationScheduler.

    Parameters:

    time - the length of the time window

    unit - the time unit oftime

    delayError - if true, an exception signalled by the current Observable is delayed until the regular elements are consumed by the downstream; if false, an exception is immediately signalled and all regular elements dropped

    Returns:

    an Observable that drops those items emitted by the source ObservableSource in a time window before the source completes defined bytime

    See Also:

    ReactiveX operators documentation: SkipLast

  • skipLast

    @CheckReturnValue@SchedulerSupport(value="custom")public final Observable<T> skipLast(long time,TimeUnit unit,Scheduler scheduler)

    Returns an Observable that drops items emitted by the source ObservableSource during a specified time window (defined on a specified scheduler) before the source completes.

    

    Note: this action will cache the latest items arriving in the specified time window.

    Scheduler:

    You specify whichScheduler this operator will use for tracking the current time

    Parameters:

    time - the length of the time window

    unit - the time unit oftime

    scheduler - the scheduler used as the time source

    Returns:

    an Observable that drops those items emitted by the source ObservableSource in a time window before the source completes defined bytime andscheduler

    See Also:

    ReactiveX operators documentation: SkipLast

  • skipLast

    @CheckReturnValue@SchedulerSupport(value="custom")public final Observable<T> skipLast(long time,TimeUnit unit,Scheduler scheduler,        boolean delayError)

    Returns an Observable that drops items emitted by the source ObservableSource during a specified time window (defined on a specified scheduler) before the source completes.

    

    Note: this action will cache the latest items arriving in the specified time window.

    Scheduler:

    You specify whichScheduler this operator will use to track the current time

    Parameters:

    time - the length of the time window

    unit - the time unit oftime

    scheduler - the scheduler used as the time source

    delayError - if true, an exception signalled by the current Observable is delayed until the regular elements are consumed by the downstream; if false, an exception is immediately signalled and all regular elements dropped

    Returns:

    an Observable that drops those items emitted by the source ObservableSource in a time window before the source completes defined bytime andscheduler

    See Also:

    ReactiveX operators documentation: SkipLast

  • skipLast

    @CheckReturnValue@SchedulerSupport(value="custom")public final Observable<T> skipLast(long time,TimeUnit unit,Scheduler scheduler,        boolean delayError,        int bufferSize)

    Returns an Observable that drops items emitted by the source ObservableSource during a specified time window (defined on a specified scheduler) before the source completes.

    

    Note: this action will cache the latest items arriving in the specified time window.

    Scheduler:

    You specify whichScheduler this operator will use.

    Parameters:

    time - the length of the time window

    unit - the time unit oftime

    scheduler - the scheduler used as the time source

    delayError - if true, an exception signalled by the current Observable is delayed until the regular elements are consumed by the downstream; if false, an exception is immediately signalled and all regular elements dropped

    bufferSize - the hint about how many elements to expect to be skipped

    Returns:

    an Observable that drops those items emitted by the source ObservableSource in a time window before the source completes defined bytime andscheduler

    See Also:

    ReactiveX operators documentation: SkipLast

  • skipUntil

    @CheckReturnValue@SchedulerSupport(value="none")public final <U> Observable<T> skipUntil(ObservableSource<U> other)

    Returns an Observable that skips items emitted by the source ObservableSource until a second ObservableSource emits an item.

    

    Scheduler:

    skipUntil does not operate by default on a particularScheduler.

    Type Parameters:

    U - the element type of the other ObservableSource

    Parameters:

    other - the second ObservableSource that has to emit an item before the source ObservableSource's elements begin to be mirrored by the resulting ObservableSource

    Returns:

    an Observable that skips items from the source ObservableSource until the second ObservableSource emits an item, then emits the remaining items

    See Also:

    ReactiveX operators documentation: SkipUntil

  • skipWhile

    @CheckReturnValue@SchedulerSupport(value="none")public final Observable<T> skipWhile(Predicate<? superT> predicate)

    Returns an Observable that skips all items emitted by the source ObservableSource as long as a specified condition holds true, but emits all further source items as soon as the condition becomes false.

    

    Scheduler:

    skipWhile does not operate by default on a particularScheduler.

    Parameters:

    predicate - a function to test each item emitted from the source ObservableSource

    Returns:

    an Observable that begins emitting items emitted by the source ObservableSource when the specified predicate becomes false

    See Also:

    ReactiveX operators documentation: SkipWhile

  • sorted

    @CheckReturnValue@SchedulerSupport(value="none")public final Observable<T> sorted()

    Returns an Observable that emits the events emitted by source ObservableSource, in a sorted order. Each item emitted by the ObservableSource must implementComparable with respect to all other items in the sequence.

    

    If any item emitted by this Observable does not implementComparable with respect to all other items emitted by this Observable, no items will be emitted and the sequence is terminated with aClassCastException.

    Note that callingsorted with long, non-terminating or infinite sources might causeOutOfMemoryError

    Scheduler:

    sorted does not operate by default on a particularScheduler.

    Returns:

    an Observable that emits the items emitted by the source ObservableSource in sorted order

  • sorted

    @CheckReturnValue@SchedulerSupport(value="none")public final Observable<T> sorted(Comparator<? superT> sortFunction)

    Returns an Observable that emits the events emitted by source ObservableSource, in a sorted order based on a specified comparison function.

    Note that callingsorted with long, non-terminating or infinite sources might causeOutOfMemoryError

    Scheduler:

    sorted does not operate by default on a particularScheduler.

    Parameters:

    sortFunction - a function that compares two items emitted by the source ObservableSource and returns an Integer that indicates their sort order

    Returns:

    an Observable that emits the items emitted by the source ObservableSource in sorted order

  • startWith

    @CheckReturnValue@SchedulerSupport(value="none")public final Observable<T> startWith(Iterable<? extendsT> items)

    Returns an Observable that emits the items in a specifiedIterable before it begins to emit items emitted by the source ObservableSource.

    

    Scheduler:

    startWith does not operate by default on a particularScheduler.

    Parameters:

    items - an Iterable that contains the items you want the modified ObservableSource to emit first

    Returns:

    an Observable that emits the items in the specifiedIterable and then emits the items emitted by the source ObservableSource

    See Also:

    ReactiveX operators documentation: StartWith

  • startWith

    @CheckReturnValue@SchedulerSupport(value="none")public final Observable<T> startWith(ObservableSource<? extendsT> other)

    Returns an Observable that emits the items in a specifiedObservableSource before it begins to emit items emitted by the source ObservableSource.

    

    Scheduler:

    startWith does not operate by default on a particularScheduler.

    Parameters:

    other - an ObservableSource that contains the items you want the modified ObservableSource to emit first

    Returns:

    an Observable that emits the items in the specifiedObservableSource and then emits the items emitted by the source ObservableSource

    See Also:

    ReactiveX operators documentation: StartWith

  • startWith

    @CheckReturnValue@SchedulerSupport(value="none")public final Observable<T> startWith(T item)

    Returns an Observable that emits a specified item before it begins to emit items emitted by the source ObservableSource.

    

    Scheduler:

    startWith does not operate by default on a particularScheduler.

    Parameters:

    item - the item to emit first

    Returns:

    an Observable that emits the specified item before it begins to emit items emitted by the source ObservableSource

    See Also:

    ReactiveX operators documentation: StartWith

  • startWithArray

    @CheckReturnValue@SchedulerSupport(value="none")public final Observable<T> startWithArray(T... items)

    Returns an Observable that emits the specified items before it begins to emit items emitted by the source ObservableSource.

    

    Scheduler:

    startWithArray does not operate by default on a particularScheduler.

    Parameters:

    items - the array of values to emit first

    Returns:

    an Observable that emits the specified items before it begins to emit items emitted by the source ObservableSource

    See Also:

    ReactiveX operators documentation: StartWith

  • subscribe

    @SchedulerSupport(value="none")public final Disposable subscribe()

    Subscribes to an ObservableSource and ignoresonNext andonComplete emissions.

    If the Observable emits an error, it is wrapped into anOnErrorNotImplementedException and routed to the RxJavaPlugins.onError handler.

    Scheduler:

    subscribe does not operate by default on a particularScheduler.

    Returns:

    aDisposable reference with which the caller can stop receiving items before the ObservableSource has finished sending them

    See Also:

    ReactiveX operators documentation: Subscribe

  • subscribe

    @CheckReturnValue@SchedulerSupport(value="none")public final Disposable subscribe(Consumer<? superT> onNext)

    Subscribes to an ObservableSource and provides a callback to handle the items it emits.

    If the Observable emits an error, it is wrapped into anOnErrorNotImplementedException and routed to the RxJavaPlugins.onError handler.

    Scheduler:

    subscribe does not operate by default on a particularScheduler.

    Parameters:

    onNext - theConsumer<T> you have designed to accept emissions from the ObservableSource

    Returns:

    aDisposable reference with which the caller can stop receiving items before the ObservableSource has finished sending them

    Throws:

    NullPointerException - ifonNext is null

    See Also:

    ReactiveX operators documentation: Subscribe

  • subscribe

    @CheckReturnValue@SchedulerSupport(value="none")public final Disposable subscribe(Consumer<? superT> onNext,Consumer<? superThrowable> onError)

    Subscribes to an ObservableSource and provides callbacks to handle the items it emits and any error notification it issues.

    Scheduler:

    subscribe does not operate by default on a particularScheduler.

    Parameters:

    onNext - theConsumer<T> you have designed to accept emissions from the ObservableSource

    onError - theConsumer<Throwable> you have designed to accept any error notification from the ObservableSource

    Returns:

    aDisposable reference with which the caller can stop receiving items before the ObservableSource has finished sending them

    Throws:

    NullPointerException - ifonNext is null, or ifonError is null

    See Also:

    ReactiveX operators documentation: Subscribe

  • subscribe

    @CheckReturnValue@SchedulerSupport(value="none")public final Disposable subscribe(Consumer<? superT> onNext,Consumer<? superThrowable> onError,Action onComplete)

    Subscribes to an ObservableSource and provides callbacks to handle the items it emits and any error or completion notification it issues.

    Scheduler:

    subscribe does not operate by default on a particularScheduler.

    Parameters:

    onNext - theConsumer<T> you have designed to accept emissions from the ObservableSource

    onError - theConsumer<Throwable> you have designed to accept any error notification from the ObservableSource

    onComplete - theAction you have designed to accept a completion notification from the ObservableSource

    Returns:

    aDisposable reference with which the caller can stop receiving items before the ObservableSource has finished sending them

    Throws:

    NullPointerException - ifonNext is null, or ifonError is null, or ifonComplete is null

    See Also:

    ReactiveX operators documentation: Subscribe

  • subscribe

    @CheckReturnValue@SchedulerSupport(value="none")public final Disposable subscribe(Consumer<? superT> onNext,Consumer<? superThrowable> onError,Action onComplete,Consumer<? superDisposable> onSubscribe)

    Subscribes to an ObservableSource and provides callbacks to handle the items it emits and any error or completion notification it issues.

    Scheduler:

    subscribe does not operate by default on a particularScheduler.

    Parameters:

    onNext - theConsumer<T> you have designed to accept emissions from the ObservableSource

    onError - theConsumer<Throwable> you have designed to accept any error notification from the ObservableSource

    onComplete - theAction you have designed to accept a completion notification from the ObservableSource

    onSubscribe - theConsumer that receives the upstream's Disposable

    Returns:

    aDisposable reference with which the caller can stop receiving items before the ObservableSource has finished sending them

    Throws:

    NullPointerException - ifonNext is null, or ifonError is null, or ifonComplete is null, or ifonSubscribe is null

    See Also:

    ReactiveX operators documentation: Subscribe

  • subscribe

    @SchedulerSupport(value="none")public final void subscribe(Observer<? superT> observer)

    Description copied from interface: ObservableSource
    Subscribes the given Observer to this ObservableSource instance.

    Specified by:

    subscribe in interface ObservableSource<T>

    Parameters:

    observer - the Observer, not null

  • subscribeActual

    protected abstract void subscribeActual(Observer<? superT> observer)

    Operator implementations (both source and intermediate) should implement this method that performs the necessary business logic and handles the incomingObservers.

    There is no need to call any of the plugin hooks on the currentObservable instance or theObserver; all hooks and basic safeguards have been applied bysubscribe(Observer) before this method gets called.

    Parameters:

    observer - the incoming Observer, never null

  • subscribeWith

    @CheckReturnValue@SchedulerSupport(value="none")public final <E extendsObserver<? superT>> E subscribeWith(E observer)

    Subscribes a given Observer (subclass) to this Observable and returns the given Observer as is.

    Usage example:

     Observable<Integer> source = Observable.range(1, 10); CompositeDisposable composite = new CompositeDisposable(); DisposableObserver<Integer> ds = new DisposableObserver<>() {     // ... }; composite.add(source.subscribeWith(ds));

    Scheduler:

    subscribeWith does not operate by default on a particularScheduler.

    Type Parameters:

    E - the type of the Observer to use and return

    Parameters:

    observer - the Observer (subclass) to use and return, not null

    Returns:

    the inputobserver

    Throws:

    NullPointerException - ifobserver is null

    Since:

    2.0

  • subscribeOn

    @CheckReturnValue@SchedulerSupport(value="custom")public final Observable<T> subscribeOn(Scheduler scheduler)

    Asynchronously subscribes Observers to this ObservableSource on the specifiedScheduler.

    

    Scheduler:

    You specify whichScheduler this operator will use.

    Parameters:

    scheduler - theScheduler to perform subscription actions on

    Returns:

    the source ObservableSource modified so that its subscriptions happen on the specifiedScheduler

    See Also:

    ReactiveX operators documentation: SubscribeOn,RxJava Threading Examples,observeOn(io.reactivex.Scheduler)

  • switchIfEmpty

    @CheckReturnValue@SchedulerSupport(value="none")public final Observable<T> switchIfEmpty(ObservableSource<? extendsT> other)

    Returns an Observable that emits the items emitted by the source ObservableSource or the items of an alternate ObservableSource if the source ObservableSource is empty.

    

    Scheduler:

    switchIfEmpty does not operate by default on a particularScheduler.

    Parameters:

    other - the alternate ObservableSource to subscribe to if the source does not emit any items

    Returns:

    an ObservableSource that emits the items emitted by the source ObservableSource or the items of an alternate ObservableSource if the source ObservableSource is empty.

    Since:

    1.1.0

  • switchMap

    @CheckReturnValue@SchedulerSupport(value="none")public final <R> Observable<R> switchMap(Function<? superT,? extendsObservableSource<? extends R>> mapper)

    Returns a new ObservableSource by applying a function that you supply to each item emitted by the source ObservableSource that returns an ObservableSource, and then emitting the items emitted by the most recently emitted of these ObservableSources.

    The resulting ObservableSource completes if both the upstream ObservableSource and the last inner ObservableSource, if any, complete. If the upstream ObservableSource signals an onError, the inner ObservableSource is disposed and the error delivered in-sequence.

    

    Scheduler:

    switchMap does not operate by default on a particularScheduler.

    Type Parameters:

    R - the element type of the inner ObservableSources and the output

    Parameters:

    mapper - a function that, when applied to an item emitted by the source ObservableSource, returns an ObservableSource

    Returns:

    an Observable that emits the items emitted by the ObservableSource returned from applyingfunc to the most recently emitted item emitted by the source ObservableSource

    See Also:

    ReactiveX operators documentation: FlatMap,switchMapDelayError(Function)

  • switchMap

    @CheckReturnValue@SchedulerSupport(value="none")public final <R> Observable<R> switchMap(Function<? superT,? extendsObservableSource<? extends R>> mapper,        int bufferSize)

    Returns a new ObservableSource by applying a function that you supply to each item emitted by the source ObservableSource that returns an ObservableSource, and then emitting the items emitted by the most recently emitted of these ObservableSources.

    The resulting ObservableSource completes if both the upstream ObservableSource and the last inner ObservableSource, if any, complete. If the upstream ObservableSource signals an onError, the inner ObservableSource is disposed and the error delivered in-sequence.

    

    Scheduler:

    switchMap does not operate by default on a particularScheduler.

    Type Parameters:

    R - the element type of the inner ObservableSources and the output

    Parameters:

    mapper - a function that, when applied to an item emitted by the source ObservableSource, returns an ObservableSource

    bufferSize - the number of elements to prefetch from the current active inner ObservableSource

    Returns:

    an Observable that emits the items emitted by the ObservableSource returned from applyingfunc to the most recently emitted item emitted by the source ObservableSource

    See Also:

    ReactiveX operators documentation: FlatMap,switchMapDelayError(Function, int)

  • switchMapCompletable

    @CheckReturnValue@SchedulerSupport(value="none")public final Completable switchMapCompletable(@NonNullFunction<? superT,? extendsCompletableSource> mapper)

    Maps the upstream values intoCompletableSources, subscribes to the newer one while disposing the subscription to the previousCompletableSource, thus keeping at most one activeCompletableSource running.

    

    Since aCompletableSource doesn't produce any items, the resulting reactive type of this operator is aCompletable that can only indicate successful completion or a failure in any of the innerCompletableSources or the failure of the currentObservable.

    Scheduler:

    switchMapCompletable does not operate by default on a particularScheduler.

    Error handling:

    If either thisObservable or the activeCompletableSource signals anonError, the resultingCompletable is terminated immediately with thatThrowable. Use theswitchMapCompletableDelayError(Function) to delay such inner failures until every innerCompletableSources and the mainObservable terminates in some fashion. If they fail concurrently, the operator may combine theThrowables into aCompositeException and signal it to the downstream instead. If any inactivated (switched out)CompletableSource signals anonError late, theThrowables will be signalled to the global error handler viaRxJavaPlugins.onError(Throwable) method asUndeliverableException errors.

    History: 2.1.11 - experimental

    Parameters:

    mapper - the function called with each upstream item and should return aCompletableSource to be subscribed to and awaited for (non blockingly) for its terminal event

    Returns:

    the new Completable instance

    Since:

    2.2

    See Also:

    switchMapCompletableDelayError(Function)

  • switchMapCompletableDelayError

    @CheckReturnValue@SchedulerSupport(value="none")public final Completable switchMapCompletableDelayError(@NonNullFunction<? superT,? extendsCompletableSource> mapper)

    Maps the upstream values intoCompletableSources, subscribes to the newer one while disposing the subscription to the previousCompletableSource, thus keeping at most one activeCompletableSource running and delaying any main or inner errors until all of them terminate.

    

    Since aCompletableSource doesn't produce any items, the resulting reactive type of this operator is aCompletable that can only indicate successful completion or a failure in any of the innerCompletableSources or the failure of the currentObservable.

    Scheduler:

    switchMapCompletableDelayError does not operate by default on a particularScheduler.

    Error handling:

    Errors of thisObservable and all theCompletableSources, who had the chance to run to their completion, are delayed until all of them terminate in some fashion. At this point, if there was only one failure, the respectiveThrowable is emitted to the downstream. It there were more than one failures, the operator combines allThrowables into aCompositeException and signals that to the downstream. If any inactivated (switched out)CompletableSource signals anonError late, theThrowables will be signalled to the global error handler viaRxJavaPlugins.onError(Throwable) method asUndeliverableException errors.

    History: 2.1.11 - experimental

    Parameters:

    mapper - the function called with each upstream item and should return aCompletableSource to be subscribed to and awaited for (non blockingly) for its terminal event

    Returns:

    the new Completable instance

    Since:

    2.2

    See Also:

    switchMapCompletable(Function)

  • switchMapMaybe

    @CheckReturnValue@SchedulerSupport(value="none")public final <R> Observable<R> switchMapMaybe(@NonNullFunction<? superT,? extendsMaybeSource<? extends R>> mapper)

    Maps the upstream items intoMaybeSources and switches (subscribes) to the newer ones while disposing the older ones (and ignoring their signals) and emits the latest success value of the current one if available while failing immediately if thisObservable or any of the active innerMaybeSources fail.

    

    Scheduler:

    switchMapMaybe does not operate by default on a particularScheduler.

    Error handling:

    This operator terminates with anonError if thisObservable or any of the innerMaybeSources fail while they are active. When this happens concurrently, their individualThrowable errors may get combined and emitted as a singleCompositeException. Otherwise, a late (i.e., inactive or switched out)onError from thisObservable or from any of the innerMaybeSources will be forwarded to the global error handler viaRxJavaPlugins.onError(Throwable) asUndeliverableException

    History: 2.1.11 - experimental

    Type Parameters:

    R - the output value type

    Parameters:

    mapper - the function called with the current upstream event and should return aMaybeSource to replace the current active inner source and get subscribed to.

    Returns:

    the new Observable instance

    Since:

    2.2

    See Also:

    switchMapMaybeDelayError(Function)

  • switchMapMaybeDelayError

    @CheckReturnValue@SchedulerSupport(value="none")public final <R> Observable<R> switchMapMaybeDelayError(@NonNullFunction<? superT,? extendsMaybeSource<? extends R>> mapper)

    Maps the upstream items intoMaybeSources and switches (subscribes) to the newer ones while disposing the older ones (and ignoring their signals) and emits the latest success value of the current one if available, delaying errors from thisObservable or the innerMaybeSources until all terminate.

    

    Scheduler:

    switchMapMaybeDelayError does not operate by default on a particularScheduler.

    History: 2.1.11 - experimental

    Type Parameters:

    R - the output value type

    Parameters:

    mapper - the function called with the current upstream event and should return aMaybeSource to replace the current active inner source and get subscribed to.

    Returns:

    the new Observable instance

    Since:

    2.2

    See Also:

    switchMapMaybe(Function)

  • switchMapSingle

    @CheckReturnValue@SchedulerSupport(value="none")@NonNullpublic final <R> Observable<R> switchMapSingle(@NonNullFunction<? superT,? extendsSingleSource<? extends R>> mapper)

    Returns a new ObservableSource by applying a function that you supply to each item emitted by the source ObservableSource that returns a SingleSource, and then emitting the item emitted by the most recently emitted of these SingleSources.

    The resulting ObservableSource completes if both the upstream ObservableSource and the last inner SingleSource, if any, complete. If the upstream ObservableSource signals an onError, the inner SingleSource is disposed and the error delivered in-sequence.

    

    Scheduler:

    switchMapSingle does not operate by default on a particularScheduler.

    History: 2.0.8 - experimental

    Type Parameters:

    R - the element type of the inner SingleSources and the output

    Parameters:

    mapper - a function that, when applied to an item emitted by the source ObservableSource, returns a SingleSource

    Returns:

    an Observable that emits the item emitted by the SingleSource returned from applyingfunc to the most recently emitted item emitted by the source ObservableSource

    Since:

    2.2

    See Also:

    ReactiveX operators documentation: FlatMap,switchMapSingleDelayError(Function)

  • switchMapSingleDelayError

    @CheckReturnValue@SchedulerSupport(value="none")@NonNullpublic final <R> Observable<R> switchMapSingleDelayError(@NonNullFunction<? superT,? extendsSingleSource<? extends R>> mapper)

    Returns a new ObservableSource by applying a function that you supply to each item emitted by the source ObservableSource that returns a SingleSource, and then emitting the item emitted by the most recently emitted of these SingleSources and delays any error until all SingleSources terminate.

    The resulting ObservableSource completes if both the upstream ObservableSource and the last inner SingleSource, if any, complete. If the upstream ObservableSource signals an onError, the termination of the last inner SingleSource will emit that error as is or wrapped into a CompositeException along with the other possible errors the former inner SingleSources signalled.

    

    Scheduler:

    switchMapSingleDelayError does not operate by default on a particularScheduler.

    History: 2.0.8 - experimental

    Type Parameters:

    R - the element type of the inner SingleSources and the output

    Parameters:

    mapper - a function that, when applied to an item emitted by the source ObservableSource, returns a SingleSource

    Returns:

    an Observable that emits the item emitted by the SingleSource returned from applyingfunc to the most recently emitted item emitted by the source ObservableSource

    Since:

    2.2

    See Also:

    ReactiveX operators documentation: FlatMap,switchMapSingle(Function)

  • switchMapDelayError

    @CheckReturnValue@SchedulerSupport(value="none")public final <R> Observable<R> switchMapDelayError(Function<? superT,? extendsObservableSource<? extends R>> mapper)

    Returns a new ObservableSource by applying a function that you supply to each item emitted by the source ObservableSource that returns an ObservableSource, and then emitting the items emitted by the most recently emitted of these ObservableSources and delays any error until all ObservableSources terminate.

    The resulting ObservableSource completes if both the upstream ObservableSource and the last inner ObservableSource, if any, complete. If the upstream ObservableSource signals an onError, the termination of the last inner ObservableSource will emit that error as is or wrapped into a CompositeException along with the other possible errors the former inner ObservableSources signalled.

    

    Scheduler:

    switchMapDelayError does not operate by default on a particularScheduler.

    Type Parameters:

    R - the element type of the inner ObservableSources and the output

    Parameters:

    mapper - a function that, when applied to an item emitted by the source ObservableSource, returns an ObservableSource

    Returns:

    an Observable that emits the items emitted by the ObservableSource returned from applyingfunc to the most recently emitted item emitted by the source ObservableSource

    Since:

    2.0

    See Also:

    ReactiveX operators documentation: FlatMap,switchMap(Function)

  • switchMapDelayError

    @CheckReturnValue@SchedulerSupport(value="none")public final <R> Observable<R> switchMapDelayError(Function<? superT,? extendsObservableSource<? extends R>> mapper,        int bufferSize)

    Returns a new ObservableSource by applying a function that you supply to each item emitted by the source ObservableSource that returns an ObservableSource, and then emitting the items emitted by the most recently emitted of these ObservableSources and delays any error until all ObservableSources terminate.

    The resulting ObservableSource completes if both the upstream ObservableSource and the last inner ObservableSource, if any, complete. If the upstream ObservableSource signals an onError, the termination of the last inner ObservableSource will emit that error as is or wrapped into a CompositeException along with the other possible errors the former inner ObservableSources signalled.

    

    Scheduler:

    switchMapDelayError does not operate by default on a particularScheduler.

    Type Parameters:

    R - the element type of the inner ObservableSources and the output

    Parameters:

    mapper - a function that, when applied to an item emitted by the source ObservableSource, returns an ObservableSource

    bufferSize - the number of elements to prefetch from the current active inner ObservableSource

    Returns:

    an Observable that emits the items emitted by the ObservableSource returned from applyingfunc to the most recently emitted item emitted by the source ObservableSource

    Since:

    2.0

    See Also:

    ReactiveX operators documentation: FlatMap,switchMap(Function, int)

  • take

    @CheckReturnValue@SchedulerSupport(value="none")public final Observable<T> take(long count)

    Returns an Observable that emits only the firstcount items emitted by the source ObservableSource. If the source emits fewer thancount items then all of its items are emitted.

    

    This method returns an ObservableSource that will invoke a subscribingObserver'sonNext function a maximum ofcount times before invokingonComplete.

    Scheduler:

    This version oftake does not operate by default on a particularScheduler.

    Parameters:

    count - the maximum number of items to emit

    Returns:

    an Observable that emits only the firstcount items emitted by the source ObservableSource, or all of the items from the source ObservableSource if that ObservableSource emits fewer thancount items

    See Also:

    ReactiveX operators documentation: Take

  • take

    @CheckReturnValue@SchedulerSupport(value="none")public final Observable<T> take(long time,TimeUnit unit)

    Returns an Observable that emits those items emitted by source ObservableSource before a specified time runs out.

    If time runs out before theObservable completes normally, theonComplete event will be signaled on the defaultcomputationScheduler.

    

    Scheduler:

    This version oftake operates by default on thecomputationScheduler.

    Parameters:

    time - the length of the time window

    unit - the time unit oftime

    Returns:

    an Observable that emits those items emitted by the source ObservableSource before the time runs out

    See Also:

    ReactiveX operators documentation: Take

  • take

    @CheckReturnValue@SchedulerSupport(value="custom")public final Observable<T> take(long time,TimeUnit unit,Scheduler scheduler)

    Returns an Observable that emits those items emitted by source ObservableSource before a specified time (on a specified Scheduler) runs out.

    If time runs out before theObservable completes normally, theonComplete event will be signaled on the providedScheduler.

    

    Scheduler:

    You specify whichScheduler this operator will use.

    Parameters:

    time - the length of the time window

    unit - the time unit oftime

    scheduler - the Scheduler used for time source

    Returns:

    an Observable that emits those items emitted by the source ObservableSource before the time runs out, according to the specified Scheduler

    See Also:

    ReactiveX operators documentation: Take

  • takeLast

    @CheckReturnValue@SchedulerSupport(value="none")public final Observable<T> takeLast(int count)

    Returns an Observable that emits at most the lastcount items emitted by the source ObservableSource. If the source emits fewer thancount items then all of its items are emitted.

    

    Scheduler:

    This version oftakeLast does not operate by default on a particularScheduler.

    Parameters:

    count - the maximum number of items to emit from the end of the sequence of items emitted by the source ObservableSource

    Returns:

    an Observable that emits at most the lastcount items emitted by the source ObservableSource

    Throws:

    IndexOutOfBoundsException - ifcount is less than zero

    See Also:

    ReactiveX operators documentation: TakeLast

  • takeLast

    @CheckReturnValue@SchedulerSupport(value="io.reactivex:trampoline")public final Observable<T> takeLast(long count,        long time,TimeUnit unit)

    Returns an Observable that emits at most a specified number of items from the source ObservableSource that were emitted in a specified window of time before the ObservableSource completed.

    

    Scheduler:

    takeLast does not operate on any particular scheduler but uses the current time from thecomputationScheduler.

    Parameters:

    count - the maximum number of items to emit

    time - the length of the time window

    unit - the time unit oftime

    Returns:

    an Observable that emits at mostcount items from the source ObservableSource that were emitted in a specified window of time before the ObservableSource completed

    See Also:

    ReactiveX operators documentation: TakeLast

  • takeLast

    @CheckReturnValue@SchedulerSupport(value="custom")public final Observable<T> takeLast(long count,        long time,TimeUnit unit,Scheduler scheduler)

    Returns an Observable that emits at most a specified number of items from the source ObservableSource that were emitted in a specified window of time before the ObservableSource completed, where the timing information is provided by a given Scheduler.

    

    Scheduler:

    You specify whichScheduler this operator will use for tracking the current time

    Parameters:

    count - the maximum number of items to emit

    time - the length of the time window

    unit - the time unit oftime

    scheduler - theScheduler that provides the timestamps for the observed items

    Returns:

    an Observable that emits at mostcount items from the source ObservableSource that were emitted in a specified window of time before the ObservableSource completed, where the timing information is provided by the givenscheduler

    Throws:

    IndexOutOfBoundsException - ifcount is less than zero

    See Also:

    ReactiveX operators documentation: TakeLast

  • takeLast

    @CheckReturnValue@SchedulerSupport(value="custom")public final Observable<T> takeLast(long count,        long time,TimeUnit unit,Scheduler scheduler,        boolean delayError,        int bufferSize)

    Returns an Observable that emits at most a specified number of items from the source ObservableSource that were emitted in a specified window of time before the ObservableSource completed, where the timing information is provided by a given Scheduler.

    

    Scheduler:

    You specify whichScheduler this operator will use for tracking the current time

    Parameters:

    count - the maximum number of items to emit

    time - the length of the time window

    unit - the time unit oftime

    scheduler - theScheduler that provides the timestamps for the observed items

    delayError - if true, an exception signalled by the current Observable is delayed until the regular elements are consumed by the downstream; if false, an exception is immediately signalled and all regular elements dropped

    bufferSize - the hint about how many elements to expect to be last

    Returns:

    an Observable that emits at mostcount items from the source ObservableSource that were emitted in a specified window of time before the ObservableSource completed, where the timing information is provided by the givenscheduler

    Throws:

    IndexOutOfBoundsException - ifcount is less than zero

    See Also:

    ReactiveX operators documentation: TakeLast

  • takeLast

    @CheckReturnValue@SchedulerSupport(value="io.reactivex:trampoline")public final Observable<T> takeLast(long time,TimeUnit unit)

    Returns an Observable that emits the items from the source ObservableSource that were emitted in a specified window of time before the ObservableSource completed.

    

    Scheduler:

    This version oftakeLast operates by default on thecomputationScheduler.

    Parameters:

    time - the length of the time window

    unit - the time unit oftime

    Returns:

    an Observable that emits the items from the source ObservableSource that were emitted in the window of time before the ObservableSource completed specified bytime

    See Also:

    ReactiveX operators documentation: TakeLast

  • takeLast

    @CheckReturnValue@SchedulerSupport(value="io.reactivex:trampoline")public final Observable<T> takeLast(long time,TimeUnit unit,        boolean delayError)

    Returns an Observable that emits the items from the source ObservableSource that were emitted in a specified window of time before the ObservableSource completed.

    

    Scheduler:

    This version oftakeLast operates by default on thecomputationScheduler.

    Parameters:

    time - the length of the time window

    unit - the time unit oftime

    delayError - if true, an exception signalled by the current Observable is delayed until the regular elements are consumed by the downstream; if false, an exception is immediately signalled and all regular elements dropped

    Returns:

    an Observable that emits the items from the source ObservableSource that were emitted in the window of time before the ObservableSource completed specified bytime

    See Also:

    ReactiveX operators documentation: TakeLast

  • takeLast

    @CheckReturnValue@SchedulerSupport(value="custom")public final Observable<T> takeLast(long time,TimeUnit unit,Scheduler scheduler)

    Returns an Observable that emits the items from the source ObservableSource that were emitted in a specified window of time before the ObservableSource completed, where the timing information is provided by a specified Scheduler.

    

    Scheduler:

    You specify whichScheduler this operator will use.

    Parameters:

    time - the length of the time window

    unit - the time unit oftime

    scheduler - the Scheduler that provides the timestamps for the Observed items

    Returns:

    an Observable that emits the items from the source ObservableSource that were emitted in the window of time before the ObservableSource completed specified bytime, where the timing information is provided byscheduler

    See Also:

    ReactiveX operators documentation: TakeLast

  • takeLast

    @CheckReturnValue@SchedulerSupport(value="custom")public final Observable<T> takeLast(long time,TimeUnit unit,Scheduler scheduler,        boolean delayError)

    Returns an Observable that emits the items from the source ObservableSource that were emitted in a specified window of time before the ObservableSource completed, where the timing information is provided by a specified Scheduler.

    

    Scheduler:

    You specify whichScheduler this operator will use.

    Parameters:

    time - the length of the time window

    unit - the time unit oftime

    scheduler - the Scheduler that provides the timestamps for the Observed items

    delayError - if true, an exception signalled by the current Observable is delayed until the regular elements are consumed by the downstream; if false, an exception is immediately signalled and all regular elements dropped

    Returns:

    an Observable that emits the items from the source ObservableSource that were emitted in the window of time before the ObservableSource completed specified bytime, where the timing information is provided byscheduler

    See Also:

    ReactiveX operators documentation: TakeLast

  • takeLast

    @CheckReturnValue@SchedulerSupport(value="custom")public final Observable<T> takeLast(long time,TimeUnit unit,Scheduler scheduler,        boolean delayError,        int bufferSize)

    Returns an Observable that emits the items from the source ObservableSource that were emitted in a specified window of time before the ObservableSource completed, where the timing information is provided by a specified Scheduler.

    

    Scheduler:

    You specify whichScheduler this operator will use.

    Parameters:

    time - the length of the time window

    unit - the time unit oftime

    scheduler - the Scheduler that provides the timestamps for the Observed items

    delayError - if true, an exception signalled by the current Observable is delayed until the regular elements are consumed by the downstream; if false, an exception is immediately signalled and all regular elements dropped

    bufferSize - the hint about how many elements to expect to be last

    Returns:

    an Observable that emits the items from the source ObservableSource that were emitted in the window of time before the ObservableSource completed specified bytime, where the timing information is provided byscheduler

    See Also:

    ReactiveX operators documentation: TakeLast

  • takeUntil

    @CheckReturnValue@SchedulerSupport(value="none")public final <U> Observable<T> takeUntil(ObservableSource<U> other)

    Returns an Observable that emits the items emitted by the source Observable until a second ObservableSource emits an item.

    

    Scheduler:

    takeUntil does not operate by default on a particularScheduler.

    Type Parameters:

    U - the type of items emitted byother

    Parameters:

    other - the ObservableSource whose first emitted item will causetakeUntil to stop emitting items from the source Observable

    Returns:

    an Observable that emits the items emitted by the source Observable until such time asother emits its first item

    See Also:

    ReactiveX operators documentation: TakeUntil

  • takeUntil

    @CheckReturnValue@SchedulerSupport(value="none")public final Observable<T> takeUntil(Predicate<? superT> 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 andtakeWhile(Predicate) is that here, the condition is evaluatedafter the item is emitted.

    Scheduler:

    takeUntil does not operate by default on a particularScheduler.

    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(Predicate)

  • takeWhile

    @CheckReturnValue@SchedulerSupport(value="none")public final Observable<T> takeWhile(Predicate<? superT> predicate)

    Returns an Observable that emits items emitted by the source ObservableSource so long as each item satisfied a specified condition, and then completes as soon as this condition is not satisfied.

    

    Scheduler:

    takeWhile does not operate by default on a particularScheduler.

    Parameters:

    predicate - a function that evaluates an item emitted by the source ObservableSource and returns a Boolean

    Returns:

    an Observable that emits the items from the source ObservableSource so long as each item satisfies the condition defined bypredicate, then completes

    See Also:

    ReactiveX operators documentation: TakeWhile,takeUntil(Predicate)

  • throttleFirst

    @CheckReturnValue@SchedulerSupport(value="io.reactivex:computation")public final Observable<T> throttleFirst(long windowDuration,TimeUnit unit)

    Returns an Observable that emits only the first item emitted by the source ObservableSource during sequential time windows of a specified duration.

    This differs fromthrottleLast(long, java.util.concurrent.TimeUnit) in that this only tracks passage of time whereasthrottleLast(long, java.util.concurrent.TimeUnit) ticks at scheduled intervals.

    

    Scheduler:

    throttleFirst operates by default on thecomputationScheduler.

    Parameters:

    windowDuration - time to wait before emitting another item after emitting the last item

    unit - the unit of time ofwindowDuration

    Returns:

    an Observable that performs the throttle operation

    See Also:

    ReactiveX operators documentation: Sample

  • throttleFirst

    @CheckReturnValue@SchedulerSupport(value="custom")public final Observable<T> throttleFirst(long skipDuration,TimeUnit unit,Scheduler scheduler)

    Returns an Observable that emits only the first item emitted by the source ObservableSource during sequential time windows of a specified duration, where the windows are managed by a specified Scheduler.

    This differs fromthrottleLast(long, java.util.concurrent.TimeUnit) in that this only tracks passage of time whereasthrottleLast(long, java.util.concurrent.TimeUnit) ticks at scheduled intervals.

    

    Scheduler:

    You specify whichScheduler this operator will use.

    Parameters:

    skipDuration - time to wait before emitting another item after emitting the last item

    unit - the unit of time ofskipDuration

    scheduler - theScheduler 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

  • throttleLast

    @CheckReturnValue@SchedulerSupport(value="io.reactivex:computation")public final Observable<T> throttleLast(long intervalDuration,TimeUnit unit)

    Returns an Observable that emits only the last item emitted by the source ObservableSource during sequential time windows of a specified duration.

    This differs fromthrottleFirst(long, java.util.concurrent.TimeUnit) in that this ticks along at a scheduled interval whereasthrottleFirst(long, java.util.concurrent.TimeUnit) does not tick, it just tracks passage of time.

    

    Scheduler:

    throttleLast operates by default on thecomputationScheduler.

    Parameters:

    intervalDuration - duration of windows within which the last item emitted by the source ObservableSource will be emitted

    unit - the unit of time ofintervalDuration

    Returns:

    an Observable that performs the throttle operation

    See Also:

    ReactiveX operators documentation: Sample,sample(long, TimeUnit)

  • throttleLast

    @CheckReturnValue@SchedulerSupport(value="custom")public final Observable<T> throttleLast(long intervalDuration,TimeUnit unit,Scheduler scheduler)

    Returns an Observable that emits only the last item emitted by the source ObservableSource during sequential time windows of a specified duration, where the duration is governed by a specified Scheduler.

    This differs fromthrottleFirst(long, java.util.concurrent.TimeUnit) in that this ticks along at a scheduled interval whereasthrottleFirst(long, java.util.concurrent.TimeUnit) does not tick, it just tracks passage of time.

    

    Scheduler:

    You specify whichScheduler this operator will use.

    Parameters:

    intervalDuration - duration of windows within which the last item emitted by the source ObservableSource will be emitted

    unit - the unit of time ofintervalDuration

    scheduler - theScheduler 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,sample(long, TimeUnit, Scheduler)

  • throttleLatest

    @CheckReturnValue@SchedulerSupport(value="io.reactivex:computation")public final Observable<T> throttleLatest(long timeout,TimeUnit unit)

    Throttles items from the upstreamObservable by first emitting the next item from upstream, then periodically emitting the latest item (if any) when the specified timeout elapses between them.

    

    Unlike the option withthrottleLatest(long, TimeUnit, boolean), the very last item being held back (if any) is not emitted when the upstream completes.

    If no items were emitted from the upstream during this timeout phase, the next upstream item is emitted immediately and the timeout window starts from then.

    Scheduler:

    throttleLatest operates by default on thecomputationScheduler.

    History: 2.1.14 - experimental

    Parameters:

    timeout - the time to wait after an item emission towards the downstream before trying to emit the latest item from upstream again

    unit - the time unit

    Returns:

    the new Observable instance

    Since:

    2.2

    See Also:

    throttleLatest(long, TimeUnit, boolean),throttleLatest(long, TimeUnit, Scheduler)

  • throttleLatest

    @CheckReturnValue@SchedulerSupport(value="io.reactivex:computation")public final Observable<T> throttleLatest(long timeout,TimeUnit unit,        boolean emitLast)

    Throttles items from the upstreamObservable by first emitting the next item from upstream, then periodically emitting the latest item (if any) when the specified timeout elapses between them.

    

    If no items were emitted from the upstream during this timeout phase, the next upstream item is emitted immediately and the timeout window starts from then.

    Scheduler:

    throttleLatest operates by default on thecomputationScheduler.

    History: 2.1.14 - experimental

    Parameters:

    timeout - the time to wait after an item emission towards the downstream before trying to emit the latest item from upstream again

    unit - the time unit

    emitLast - Iftrue, the very last item from the upstream will be emitted immediately when the upstream completes, regardless if there is a timeout window active or not. Iffalse, the very last upstream item is ignored and the flow terminates.

    Returns:

    the new Observable instance

    Since:

    2.2

    See Also:

    throttleLatest(long, TimeUnit, Scheduler, boolean)

  • throttleLatest

    @CheckReturnValue@SchedulerSupport(value="custom")public final Observable<T> throttleLatest(long timeout,TimeUnit unit,Scheduler scheduler)

    Throttles items from the upstreamObservable by first emitting the next item from upstream, then periodically emitting the latest item (if any) when the specified timeout elapses between them.

    

    Unlike the option withthrottleLatest(long, TimeUnit, Scheduler, boolean), the very last item being held back (if any) is not emitted when the upstream completes.

    If no items were emitted from the upstream during this timeout phase, the next upstream item is emitted immediately and the timeout window starts from then.

    Scheduler:

    You specify whichScheduler this operator will use.

    History: 2.1.14 - experimental

    Parameters:

    timeout - the time to wait after an item emission towards the downstream before trying to emit the latest item from upstream again

    unit - the time unit

    scheduler - theScheduler where the timed wait and latest item emission will be performed

    Returns:

    the new Observable instance

    Since:

    2.2

    See Also:

    throttleLatest(long, TimeUnit, Scheduler, boolean)

  • throttleLatest

    @CheckReturnValue@SchedulerSupport(value="custom")public final Observable<T> throttleLatest(long timeout,TimeUnit unit,Scheduler scheduler,        boolean emitLast)

    Throttles items from the upstreamObservable by first emitting the next item from upstream, then periodically emitting the latest item (if any) when the specified timeout elapses between them.

    

    If no items were emitted from the upstream during this timeout phase, the next upstream item is emitted immediately and the timeout window starts from then.

    Scheduler:

    You specify whichScheduler this operator will use.

    History: 2.1.14 - experimental

    Parameters:

    timeout - the time to wait after an item emission towards the downstream before trying to emit the latest item from upstream again

    unit - the time unit

    scheduler - theScheduler where the timed wait and latest item emission will be performed

    emitLast - Iftrue, the very last item from the upstream will be emitted immediately when the upstream completes, regardless if there is a timeout window active or not. Iffalse, the very last upstream item is ignored and the flow terminates.

    Returns:

    the new Observable instance

    Since:

    2.2

  • throttleWithTimeout

    @CheckReturnValue@SchedulerSupport(value="io.reactivex:computation")public final Observable<T> throttleWithTimeout(long timeout,TimeUnit unit)

    Returns an Observable that mirrors the source ObservableSource, except that it drops items emitted by the source ObservableSource that are followed by newer items before a timeout value expires. The timer resets on each emission (alias todebounce(long, TimeUnit, Scheduler)).

    Note: If items keep being emitted by the source ObservableSource faster than the timeout then no items will be emitted by the resulting ObservableSource.

    

    Scheduler:

    throttleWithTimeout operates by default on thecomputationScheduler.

    Parameters:

    timeout - the length of the window of time that must pass after the emission of an item from the source ObservableSource in which that ObservableSource emits no items in order for the item to be emitted by the resulting ObservableSource

    unit - the unit of time for the specifiedtimeout

    Returns:

    an Observable that filters out items from the source ObservableSource that are too quickly followed by newer items

    See Also:

    ReactiveX operators documentation: Debounce,debounce(long, TimeUnit)

  • throttleWithTimeout

    @CheckReturnValue@SchedulerSupport(value="custom")public final Observable<T> throttleWithTimeout(long timeout,TimeUnit unit,Scheduler scheduler)

    Returns an Observable that mirrors the source ObservableSource, except that it drops items emitted by the source ObservableSource that are followed by newer items before a timeout value expires on a specified Scheduler. The timer resets on each emission (Alias todebounce(long, TimeUnit, Scheduler)).

    Note: If items keep being emitted by the source ObservableSource faster than the timeout then no items will be emitted by the resulting ObservableSource.

    

    Scheduler:

    You specify whichScheduler this operator will use.

    Parameters:

    timeout - the length of the window of time that must pass after the emission of an item from the source ObservableSource in which that ObservableSource emits no items in order for the item to be emitted by the resulting ObservableSource

    unit - the unit of time for the specifiedtimeout

    scheduler - theScheduler to use internally to manage the timers that handle the timeout for each item

    Returns:

    an Observable that filters out items from the source ObservableSource that are too quickly followed by newer items

    See Also:

    ReactiveX operators documentation: Debounce,debounce(long, TimeUnit, Scheduler)

  • timeInterval

    @CheckReturnValue@SchedulerSupport(value="none")public final Observable<Timed<T>> timeInterval()

    Returns an Observable that emits records of the time interval between consecutive items emitted by the source ObservableSource.

    

    Scheduler:

    timeInterval does not operate on any particular scheduler but uses the current time from thecomputationScheduler.

    Returns:

    an Observable that emits time interval information items

    See Also:

    ReactiveX operators documentation: TimeInterval

  • timeInterval

    @CheckReturnValue@SchedulerSupport(value="none")public final Observable<Timed<T>> timeInterval(Scheduler scheduler)

    Returns an Observable that emits records of the time interval between consecutive items emitted by the source ObservableSource, where this interval is computed on a specified Scheduler.

    

    Scheduler:

    The operator does not operate on any particular scheduler but uses the current time from the specifiedScheduler.

    Parameters:

    scheduler - theScheduler used to compute time intervals

    Returns:

    an Observable that emits time interval information items

    See Also:

    ReactiveX operators documentation: TimeInterval

  • timeInterval

    @CheckReturnValue@SchedulerSupport(value="none")public final Observable<Timed<T>> timeInterval(TimeUnit unit)

    Returns an Observable that emits records of the time interval between consecutive items emitted by the source ObservableSource.

    

    Scheduler:

    timeInterval does not operate on any particular scheduler but uses the current time from thecomputationScheduler.

    Parameters:

    unit - the time unit for the current time

    Returns:

    an Observable that emits time interval information items

    See Also:

    ReactiveX operators documentation: TimeInterval

  • timeInterval

    @CheckReturnValue@SchedulerSupport(value="none")public final Observable<Timed<T>> timeInterval(TimeUnit unit,Scheduler scheduler)

    Returns an Observable that emits records of the time interval between consecutive items emitted by the source ObservableSource, where this interval is computed on a specified Scheduler.

    

    Scheduler:

    The operator does not operate on any particular scheduler but uses the current time from the specifiedScheduler.

    Parameters:

    unit - the time unit for the current time

    scheduler - theScheduler used to compute time intervals

    Returns:

    an Observable that emits time interval information items

    See Also:

    ReactiveX operators documentation: TimeInterval

  • timeout

    @CheckReturnValue@SchedulerSupport(value="none")public final <V> Observable<T> timeout(Function<? superT,? extendsObservableSource<V>> itemTimeoutIndicator)

    Returns an Observable that mirrors the source ObservableSource, but notifies observers of aTimeoutException if an item emitted by the source ObservableSource doesn't arrive within a window of time after the emission of the previous item, where that period of time is measured by an ObservableSource that is a function of the previous item.

    

    Note: The arrival of the first source item is never timed out.

    Scheduler:

    This version oftimeout operates by default on theimmediateScheduler.

    Type Parameters:

    V - the timeout value type (ignored)

    Parameters:

    itemTimeoutIndicator - a function that returns an ObservableSource for each item emitted by the source ObservableSource and that determines the timeout window for the subsequent item

    Returns:

    an Observable that mirrors the source ObservableSource, but notifies observers of aTimeoutException if an item emitted by the source ObservableSource takes longer to arrive than the time window defined by the selector for the previously emitted item

    See Also:

    ReactiveX operators documentation: Timeout

  • timeout

    @CheckReturnValue@SchedulerSupport(value="none")public final <V> Observable<T> timeout(Function<? superT,? extendsObservableSource<V>> itemTimeoutIndicator,ObservableSource<? extendsT> other)

    Returns an Observable that mirrors the source ObservableSource, but that switches to a fallback ObservableSource if an item emitted by the source ObservableSource doesn't arrive within a window of time after the emission of the previous item, where that period of time is measured by an ObservableSource that is a function of the previous item.

    

    Note: The arrival of the first source item is never timed out.

    Scheduler:

    This version oftimeout operates by default on theimmediateScheduler.

    Type Parameters:

    V - the timeout value type (ignored)

    Parameters:

    itemTimeoutIndicator - a function that returns an ObservableSource, for each item emitted by the source ObservableSource, that determines the timeout window for the subsequent item

    other - the fallback ObservableSource to switch to if the source ObservableSource times out

    Returns:

    an Observable that mirrors the source ObservableSource, but switches to mirroring a fallback ObservableSource if an item emitted by the source ObservableSource takes longer to arrive than the time window defined by the selector for the previously emitted item

    See Also:

    ReactiveX operators documentation: Timeout

  • timeout

    @CheckReturnValue@SchedulerSupport(value="io.reactivex:computation")public final Observable<T> timeout(long timeout,TimeUnit timeUnit)

    Returns an Observable that mirrors the source ObservableSource but applies a timeout policy for each emitted item. If the next item isn't emitted within the specified timeout duration starting from its predecessor, the resulting ObservableSource terminates and notifies observers of aTimeoutException.

    

    Scheduler:

    This version oftimeout operates by default on thecomputationScheduler.

    Parameters:

    timeout - maximum duration between emitted items before a timeout occurs

    timeUnit - the unit of time that applies to thetimeout argument.

    Returns:

    the source ObservableSource modified to notify observers of aTimeoutException in case of a timeout

    See Also:

    ReactiveX operators documentation: Timeout

  • timeout

    @CheckReturnValue@SchedulerSupport(value="io.reactivex:computation")public final Observable<T> timeout(long timeout,TimeUnit timeUnit,ObservableSource<? extendsT> other)

    Returns an Observable that mirrors the source ObservableSource but applies a timeout policy for each emitted item. If the next item isn't emitted within the specified timeout duration starting from its predecessor, the source ObservableSource is disposed and resulting ObservableSource begins instead to mirror a fallback ObservableSource.

    

    Scheduler:

    This version oftimeout operates by default on thecomputationScheduler.

    Parameters:

    timeout - maximum duration between items before a timeout occurs

    timeUnit - the unit of time that applies to thetimeout argument

    other - the fallback ObservableSource to use in case of a timeout

    Returns:

    the source ObservableSource modified to switch to the fallback ObservableSource in case of a timeout

    See Also:

    ReactiveX operators documentation: Timeout

  • timeout

    @CheckReturnValue@SchedulerSupport(value="custom")public final Observable<T> timeout(long timeout,TimeUnit timeUnit,Scheduler scheduler,ObservableSource<? extendsT> other)

    Returns an Observable that mirrors the source ObservableSource but applies a timeout policy for each emitted item using a specified Scheduler. If the next item isn't emitted within the specified timeout duration starting from its predecessor, the source ObservableSource is disposed and resulting ObservableSource begins instead to mirror a fallback ObservableSource.

    

    Scheduler:

    You specify whichScheduler this operator will use.

    Parameters:

    timeout - maximum duration between items before a timeout occurs

    timeUnit - the unit of time that applies to thetimeout argument

    scheduler - theScheduler to run the timeout timers on

    other - the ObservableSource to use as the fallback in case of a timeout

    Returns:

    the source ObservableSource modified so that it will switch to the fallback ObservableSource in case of a timeout

    See Also:

    ReactiveX operators documentation: Timeout

  • timeout

    @CheckReturnValue@SchedulerSupport(value="custom")public final Observable<T> timeout(long timeout,TimeUnit timeUnit,Scheduler scheduler)

    Returns an Observable that mirrors the source ObservableSource but applies a timeout policy for each emitted item, where this policy is governed on a specified Scheduler. If the next item isn't emitted within the specified timeout duration starting from its predecessor, the resulting ObservableSource terminates and notifies observers of aTimeoutException.

    

    Scheduler:

    You specify whichScheduler this operator will use.

    Parameters:

    timeout - maximum duration between items before a timeout occurs

    timeUnit - the unit of time that applies to thetimeout argument

    scheduler - the Scheduler to run the timeout timers on

    Returns:

    the source ObservableSource modified to notify observers of aTimeoutException in case of a timeout

    See Also:

    ReactiveX operators documentation: Timeout

  • timeout

    @CheckReturnValue@SchedulerSupport(value="none")public final <U,V> Observable<T> timeout(ObservableSource<U> firstTimeoutIndicator,Function<? superT,? extendsObservableSource<V>> itemTimeoutIndicator)

    Returns an Observable that mirrors the source ObservableSource, but notifies observers of aTimeoutException if either the first item emitted by the source ObservableSource or any subsequent item doesn't arrive within time windows defined by other ObservableSources.

    

    Scheduler:

    This version oftimeout operates by default on theimmediateScheduler.

    Type Parameters:

    U - the first timeout value type (ignored)

    V - the subsequent timeout value type (ignored)

    Parameters:

    firstTimeoutIndicator - a function that returns an ObservableSource that determines the timeout window for the first source item

    itemTimeoutIndicator - a function that returns an ObservableSource for each item emitted by the source ObservableSource and that determines the timeout window in which the subsequent source item must arrive in order to continue the sequence

    Returns:

    an Observable that mirrors the source ObservableSource, but notifies observers of aTimeoutException 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

    @CheckReturnValue@SchedulerSupport(value="none")public final <U,V> Observable<T> timeout(ObservableSource<U> firstTimeoutIndicator,Function<? superT,? extendsObservableSource<V>> itemTimeoutIndicator,ObservableSource<? extendsT> other)

    Returns an Observable that mirrors the source ObservableSource, but switches to a fallback ObservableSource if either the first item emitted by the source ObservableSource or any subsequent item doesn't arrive within time windows defined by other ObservableSources.

    

    Scheduler:

    This version oftimeout operates by default on theimmediateScheduler.

    Type Parameters:

    U - the first timeout value type (ignored)

    V - the subsequent timeout value type (ignored)

    Parameters:

    firstTimeoutIndicator - a function that returns an ObservableSource which determines the timeout window for the first source item

    itemTimeoutIndicator - a function that returns an ObservableSource for each item emitted by the source ObservableSource and that determines the timeout window in which the subsequent source item must arrive in order to continue the sequence

    other - the fallback ObservableSource to switch to if the source ObservableSource times out

    Returns:

    an Observable that mirrors the source ObservableSource, but switches to theother ObservableSource if either the first item emitted by the source ObservableSource or any subsequent item doesn't arrive within time windows defined by the timeout selectors

    Throws:

    NullPointerException - ifitemTimeoutIndicator is null, or ifother is null

    See Also:

    ReactiveX operators documentation: Timeout

  • timestamp

    @CheckReturnValue@SchedulerSupport(value="none")public final Observable<Timed<T>> timestamp()

    Returns an Observable that emits each item emitted by the source ObservableSource, wrapped in aTimed object.

    

    Scheduler:

    timestamp does not operate on any particular scheduler but uses the current time from thecomputationScheduler.

    Returns:

    an Observable that emits timestamped items from the source ObservableSource

    See Also:

    ReactiveX operators documentation: Timestamp

  • timestamp

    @CheckReturnValue@SchedulerSupport(value="none")public final Observable<Timed<T>> timestamp(Scheduler scheduler)

    Returns an Observable that emits each item emitted by the source ObservableSource, wrapped in aTimed object whose timestamps are provided by a specified Scheduler.

    

    Scheduler:

    This operator does not operate on any particular scheduler but uses the current time from the specifiedScheduler.

    Parameters:

    scheduler - theScheduler to use as a time source

    Returns:

    an Observable that emits timestamped items from the source ObservableSource with timestamps provided by thescheduler

    See Also:

    ReactiveX operators documentation: Timestamp

  • timestamp

    @CheckReturnValue@SchedulerSupport(value="none")public final Observable<Timed<T>> timestamp(TimeUnit unit)

    Returns an Observable that emits each item emitted by the source ObservableSource, wrapped in aTimed object.

    

    Scheduler:

    timestamp does not operate on any particular scheduler but uses the current time from thecomputationScheduler.

    Parameters:

    unit - the time unit for the current time

    Returns:

    an Observable that emits timestamped items from the source ObservableSource

    See Also:

    ReactiveX operators documentation: Timestamp

  • timestamp

    @CheckReturnValue@SchedulerSupport(value="none")public final Observable<Timed<T>> timestamp(TimeUnit unit,Scheduler scheduler)

    Returns an Observable that emits each item emitted by the source ObservableSource, wrapped in aTimed object whose timestamps are provided by a specified Scheduler.

    

    Scheduler:

    This operator does not operate on any particular scheduler but uses the current time from the specifiedScheduler.

    Parameters:

    unit - the time unit for the current time

    scheduler - theScheduler to use as a time source

    Returns:

    an Observable that emits timestamped items from the source ObservableSource with timestamps provided by thescheduler

    See Also:

    ReactiveX operators documentation: Timestamp

  • to

    @CheckReturnValue@SchedulerSupport(value="none")public final <R> R to(Function<? superObservable<T>,R> converter)

    Calls the specified converter function during assembly time and returns its resulting value.

    This allows fluent conversion to any other type.

    Scheduler:

    to does not operate by default on a particularScheduler.

    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

  • toList

    @CheckReturnValue@SchedulerSupport(value="none")public final Single<List<T>> toList()

    Returns a Single that emits a single item, a list composed of all the items emitted by the finite source ObservableSource.

    

    Normally, an ObservableSource that returns multiple items will do so by invoking itsObserver'sonNext method for each such item. You can change this behavior, instructing the ObservableSource to compose a list of all of these items and then to invoke the Observer'sonNext function once, passing it the entire list, by calling the ObservableSource'stoList method prior to calling itssubscribe() method.

    Note that this operator requires the upstream to signalonComplete for the accumulated list to be emitted. Sources that are infinite and never complete will never emit anything through this operator and an infinite source may lead to a fatalOutOfMemoryError.

    Scheduler:

    toList does not operate by default on a particularScheduler.

    Returns:

    a Single that emits a single item: a List containing all of the items emitted by the source ObservableSource

    See Also:

    ReactiveX operators documentation: To

  • toList

    @CheckReturnValue@SchedulerSupport(value="none")public final Single<List<T>> toList(int capacityHint)

    Returns a Single that emits a single item, a list composed of all the items emitted by the finite source ObservableSource.

    

    Normally, an ObservableSource that returns multiple items will do so by invoking itsObserver'sonNext method for each such item. You can change this behavior, instructing the ObservableSource to compose a list of all of these items and then to invoke the Observer'sonNext function once, passing it the entire list, by calling the ObservableSource'stoList method prior to calling itssubscribe() method.

    Note that this operator requires the upstream to signalonComplete for the accumulated list to be emitted. Sources that are infinite and never complete will never emit anything through this operator and an infinite source may lead to a fatalOutOfMemoryError.

    Scheduler:

    toList does not operate by default on a particularScheduler.

    Parameters:

    capacityHint - the number of elements expected from the current Observable

    Returns:

    a Single that emits a single item: a List containing all of the items emitted by the source ObservableSource

    See Also:

    ReactiveX operators documentation: To

  • toList

    @CheckReturnValue@SchedulerSupport(value="none")public final <U extendsCollection<? superT>> Single<U> toList(Callable<U> collectionSupplier)

    Returns a Single that emits a single item, a list composed of all the items emitted by the finite source ObservableSource.

    

    Normally, an ObservableSource that returns multiple items will do so by invoking itsObserver'sonNext method for each such item. You can change this behavior, instructing the ObservableSource to compose a list of all of these items and then to invoke the Observer'sonNext function once, passing it the entire list, by calling the ObservableSource'stoList method prior to calling itssubscribe() method.

    Note that this operator requires the upstream to signalonComplete for the accumulated collection to be emitted. Sources that are infinite and never complete will never emit anything through this operator and an infinite source may lead to a fatalOutOfMemoryError.

    Scheduler:

    toList does not operate by default on a particularScheduler.

    Type Parameters:

    U - the subclass of a collection of Ts

    Parameters:

    collectionSupplier - the Callable returning the collection (for each individual Observer) to be filled in

    Returns:

    a Single that emits a single item: a List containing all of the items emitted by the source ObservableSource

    See Also:

    ReactiveX operators documentation: To

  • toMap

    @CheckReturnValue@SchedulerSupport(value="none")public final <K> Single<Map<K,T>> toMap(Function<? superT,? extends K> keySelector)

    Returns a Single that emits a single HashMap containing all items emitted by the finite source ObservableSource, mapped by the keys returned by a specifiedkeySelector function.

    

    If more than one source item maps to the same key, the HashMap will contain the latest of those items.

    Note that this operator requires the upstream to signalonComplete for the accumulated map to be emitted. Sources that are infinite and never complete will never emit anything through this operator and an infinite source may lead to a fatalOutOfMemoryError.

    Scheduler:

    toMap does not operate by default on a particularScheduler.

    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:

    a Single that emits a single item: a HashMap containing the mapped items from the source ObservableSource

    See Also:

    ReactiveX operators documentation: To

  • toMap

    @CheckReturnValue@SchedulerSupport(value="none")public final <K,V> Single<Map<K,V>> toMap(Function<? superT,? extends K> keySelector,Function<? superT,? extends V> valueSelector)

    Returns a Single that emits a single HashMap containing values corresponding to items emitted by the finite source ObservableSource, mapped by the keys returned by a specifiedkeySelector 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.

    Note that this operator requires the upstream to signalonComplete for the accumulated map to be emitted. Sources that are infinite and never complete will never emit anything through this operator and an infinite source may lead to a fatalOutOfMemoryError.

    Scheduler:

    toMap does not operate by default on a particularScheduler.

    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:

    a Single that emits a single item: a HashMap containing the mapped items from the source ObservableSource

    See Also:

    ReactiveX operators documentation: To

  • toMap

    @CheckReturnValue@SchedulerSupport(value="none")public final <K,V> Single<Map<K,V>> toMap(Function<? superT,? extends K> keySelector,Function<? superT,? extends V> valueSelector,Callable<? extendsMap<K,V>> mapSupplier)

    Returns a Single that emits a single Map, returned by a specifiedmapFactory function, that contains keys and values extracted from the items emitted by the finite source ObservableSource.

    

    Note that this operator requires the upstream to signalonComplete for the accumulated map to be emitted. Sources that are infinite and never complete will never emit anything through this operator and an infinite source may lead to a fatalOutOfMemoryError.

    Scheduler:

    toMap does not operate by default on a particularScheduler.

    Type Parameters:

    K - the key type of the Map

    V - the value type of the Map

    Parameters:

    keySelector - the function that extracts the key from a source item to be used in the Map

    valueSelector - the function that extracts the value from the source items to be used as value in the Map

    mapSupplier - the function that returns a Map instance to be used

    Returns:

    a Single that emits a single item: a Map that contains the mapped items emitted by the source ObservableSource

    See Also:

    ReactiveX operators documentation: To

  • toMultimap

    @CheckReturnValue@SchedulerSupport(value="none")public final <K> Single<Map<K,Collection<T>>> toMultimap(Function<? superT,? extends K> keySelector)

    Returns a Single that emits a single HashMap that contains an ArrayList of items emitted by the finite source ObservableSource keyed by a specifiedkeySelector function.

    

    Note that this operator requires the upstream to signalonComplete for the accumulated map to be emitted. Sources that are infinite and never complete will never emit anything through this operator and an infinite source may lead to a fatalOutOfMemoryError.

    Scheduler:

    toMultimap does not operate by default on a particularScheduler.

    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:

    a Single that emits a single item: a HashMap that contains an ArrayList of items mapped from the source ObservableSource

    See Also:

    ReactiveX operators documentation: To

  • toMultimap

    @CheckReturnValue@SchedulerSupport(value="none")public final <K,V> Single<Map<K,Collection<V>>> toMultimap(Function<? superT,? extends K> keySelector,Function<? superT,? extends V> valueSelector)

    Returns a Single that emits a single HashMap that contains an ArrayList of values extracted by a specifiedvalueSelector function from items emitted by the finite source ObservableSource, keyed by a specifiedkeySelector function.

    

    Note that this operator requires the upstream to signalonComplete for the accumulated map to be emitted. Sources that are infinite and never complete will never emit anything through this operator and an infinite source may lead to a fatalOutOfMemoryError.

    Scheduler:

    toMultimap does not operate by default on a particularScheduler.

    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:

    a Single that emits a single item: a HashMap that contains an ArrayList of items mapped from the source ObservableSource

    See Also:

    ReactiveX operators documentation: To

  • toMultimap

    @CheckReturnValue@SchedulerSupport(value="none")public final <K,V> Single<Map<K,Collection<V>>> toMultimap(Function<? superT,? extends K> keySelector,Function<? superT,? extends V> valueSelector,Callable<? extendsMap<K,Collection<V>>> mapSupplier,Function<? super K,? extendsCollection<? super V>> collectionFactory)

    Returns a Single that emits a single Map, returned by a specifiedmapFactory function, that contains a custom collection of values, extracted by a specifiedvalueSelector function from items emitted by the source ObservableSource, and keyed by thekeySelector function.

    

    Scheduler:

    toMultimap does not operate by default on a particularScheduler.

    Type Parameters:

    K - the key type of the Map

    V - the value type of the Map

    Parameters:

    keySelector - the function that extracts a key from the source items to be used as the key in the Map

    valueSelector - the function that extracts a value from the source items to be used as the value in the Map

    mapSupplier - the function that returns a Map instance to be used

    collectionFactory - the function that returns a Collection instance for a particular key to be used in the Map

    Returns:

    a Single that emits a single item: a Map that contains the collection of mapped items from the source ObservableSource

    See Also:

    ReactiveX operators documentation: To

  • toMultimap

    @CheckReturnValue@SchedulerSupport(value="none")public final <K,V> Single<Map<K,Collection<V>>> toMultimap(Function<? superT,? extends K> keySelector,Function<? superT,? extends V> valueSelector,Callable<Map<K,Collection<V>>> mapSupplier)

    Returns a Single that emits a single Map, returned by a specifiedmapFactory function, that contains an ArrayList of values, extracted by a specifiedvalueSelector function from items emitted by the finite source ObservableSource and keyed by thekeySelector function.

    

    Note that this operator requires the upstream to signalonComplete for the accumulated map to be emitted. Sources that are infinite and never complete will never emit anything through this operator and an infinite source may lead to a fatalOutOfMemoryError.

    Scheduler:

    toMultimap does not operate by default on a particularScheduler.

    Type Parameters:

    K - the key type of the Map

    V - the value type of the Map

    Parameters:

    keySelector - the function that extracts a key from the source items to be used as the key in the Map

    valueSelector - the function that extracts a value from the source items to be used as the value in the Map

    mapSupplier - the function that returns a Map instance to be used

    Returns:

    a Single that emits a single item: a Map that contains a list items mapped from the source ObservableSource

    See Also:

    ReactiveX operators documentation: To

  • toFlowable

    @BackpressureSupport(value=SPECIAL)@CheckReturnValue@SchedulerSupport(value="none")public final Flowable<T> toFlowable(BackpressureStrategy strategy)

    Converts the current Observable into a Flowable by applying the specified backpressure strategy.

    Marble diagrams for the various backpressure strategies are as follows:

    • BackpressureStrategy.BUFFER

      

    • BackpressureStrategy.DROP

      

    • BackpressureStrategy.LATEST

      

    • BackpressureStrategy.ERROR

      

    • BackpressureStrategy.MISSING

      

    Backpressure:

    The operator applies the chosen backpressure strategy ofBackpressureStrategy enum.

    Scheduler:

    toFlowable does not operate by default on a particularScheduler.

    Parameters:

    strategy - the backpressure strategy to apply

    Returns:

    the new Flowable instance

  • toSortedList

    @CheckReturnValue@SchedulerSupport(value="none")public final Single<List<T>> toSortedList()

    Returns a Single that emits a list that contains the items emitted by the finite source ObservableSource, in a sorted order. Each item emitted by the ObservableSource must implementComparable with respect to all other items in the sequence.

    If any item emitted by this Observable does not implementComparable with respect to all other items emitted by this Observable, no items will be emitted and the sequence is terminated with aClassCastException.

    

    Note that this operator requires the upstream to signalonComplete for the accumulated list to be emitted. Sources that are infinite and never complete will never emit anything through this operator and an infinite source may lead to a fatalOutOfMemoryError.

    Scheduler:

    toSortedList does not operate by default on a particularScheduler.

    Returns:

    a Single that emits a list that contains the items emitted by the source ObservableSource in sorted order

    See Also:

    ReactiveX operators documentation: To

  • toSortedList

    @CheckReturnValue@SchedulerSupport(value="none")public final Single<List<T>> toSortedList(Comparator<? superT> comparator)

    Returns a Single that emits a list that contains the items emitted by the finite source ObservableSource, in a sorted order based on a specified comparison function.

    

    Note that this operator requires the upstream to signalonComplete for the accumulated list to be emitted. Sources that are infinite and never complete will never emit anything through this operator and an infinite source may lead to a fatalOutOfMemoryError.

    Scheduler:

    toSortedList does not operate by default on a particularScheduler.

    Parameters:

    comparator - a function that compares two items emitted by the source ObservableSource and returns an Integer that indicates their sort order

    Returns:

    a Single that emits a list that contains the items emitted by the source ObservableSource in sorted order

    See Also:

    ReactiveX operators documentation: To

  • toSortedList

    @CheckReturnValue@SchedulerSupport(value="none")public final Single<List<T>> toSortedList(Comparator<? superT> comparator,        int capacityHint)

    Returns a Single that emits a list that contains the items emitted by the finite source ObservableSource, in a sorted order based on a specified comparison function.

    

    Note that this operator requires the upstream to signalonComplete for the accumulated list to be emitted. Sources that are infinite and never complete will never emit anything through this operator and an infinite source may lead to a fatalOutOfMemoryError.

    Scheduler:

    toSortedList does not operate by default on a particularScheduler.

    Parameters:

    comparator - a function that compares two items emitted by the source ObservableSource and returns an Integer that indicates their sort order

    capacityHint - the initial capacity of the ArrayList used to accumulate items before sorting

    Returns:

    a Single that emits a list that contains the items emitted by the source ObservableSource in sorted order

    Since:

    2.0

    See Also:

    ReactiveX operators documentation: To

  • toSortedList

    @CheckReturnValue@SchedulerSupport(value="none")public final Single<List<T>> toSortedList(int capacityHint)

    Returns a Single that emits a list that contains the items emitted by the finite source ObservableSource, in a sorted order. Each item emitted by the ObservableSource must implementComparable with respect to all other items in the sequence.

    If any item emitted by this Observable does not implementComparable with respect to all other items emitted by this Observable, no items will be emitted and the sequence is terminated with aClassCastException.

    

    Note that this operator requires the upstream to signalonComplete for the accumulated list to be emitted. Sources that are infinite and never complete will never emit anything through this operator and an infinite source may lead to a fatalOutOfMemoryError.

    Scheduler:

    toSortedList does not operate by default on a particularScheduler.

    Parameters:

    capacityHint - the initial capacity of the ArrayList used to accumulate items before sorting

    Returns:

    a Single that emits a list that contains the items emitted by the source ObservableSource in sorted order

    Since:

    2.0

    See Also:

    ReactiveX operators documentation: To

  • unsubscribeOn

    @CheckReturnValue@SchedulerSupport(value="custom")public final Observable<T> unsubscribeOn(Scheduler scheduler)

    Modifies the source ObservableSource so that subscribers will dispose it on a specifiedScheduler.

    

    Scheduler:

    You specify whichScheduler this operator will use.

    Parameters:

    scheduler - theScheduler to perform the call to dispose() of the upstream Disposable

    Returns:

    the source ObservableSource modified so that its dispose() calls happen on the specifiedScheduler

    See Also:

    ReactiveX operators documentation: SubscribeOn

  • window

    @CheckReturnValue@SchedulerSupport(value="none")public final Observable<Observable<T>> window(long count)

    Returns an Observable that emits windows of items it collects from the source ObservableSource. The resulting ObservableSource emits connected, non-overlapping windows, each containingcount items. When the source ObservableSource completes or encounters an error, the resulting ObservableSource emits the current window and propagates the notification from the source ObservableSource.

    

    Scheduler:

    This version ofwindow does not operate by default on a particularScheduler.

    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 mostcount items from the source ObservableSource

    Throws:

    IllegalArgumentException - if either count is non-positive

    See Also:

    ReactiveX operators documentation: Window

  • window

    @CheckReturnValue@SchedulerSupport(value="none")public final Observable<Observable<T>> window(long count,        long skip)

    Returns an Observable that emits windows of items it collects from the source ObservableSource. The resulting ObservableSource emits windows everyskip items, each containing no more thancount items. When the source ObservableSource completes or encounters an error, the resulting ObservableSource emits the current window and propagates the notification from the source ObservableSource.

    

    Scheduler:

    This version ofwindow does not operate by default on a particularScheduler.

    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 ifskip andcount are equal this is the same operation aswindow(long).

    Returns:

    an Observable that emits windows everyskip items containing at mostcount items from the source ObservableSource

    Throws:

    IllegalArgumentException - if either count or skip is non-positive

    See Also:

    ReactiveX operators documentation: Window

  • window

    @CheckReturnValue@SchedulerSupport(value="none")public final Observable<Observable<T>> window(long count,        long skip,        int bufferSize)

    Returns an Observable that emits windows of items it collects from the source ObservableSource. The resulting ObservableSource emits windows everyskip items, each containing no more thancount items. When the source ObservableSource completes or encounters an error, the resulting ObservableSource emits the current window and propagates the notification from the source ObservableSource.

    

    Scheduler:

    This version ofwindow does not operate by default on a particularScheduler.

    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 ifskip andcount are equal this is the same operation aswindow(long).

    bufferSize - the capacity hint for the buffer in the inner windows

    Returns:

    an Observable that emits windows everyskip items containing at mostcount items from the source ObservableSource

    Throws:

    IllegalArgumentException - if either count or skip is non-positive

    See Also:

    ReactiveX operators documentation: Window

  • window

    @CheckReturnValue@SchedulerSupport(value="io.reactivex:computation")public final Observable<Observable<T>> window(long timespan,        long timeskip,TimeUnit unit)

    Returns an Observable that emits windows of items it collects from the source ObservableSource. The resulting ObservableSource starts a new window periodically, as determined by thetimeskip argument. It emits each window after a fixed timespan, specified by thetimespan argument. When the source ObservableSource completes or ObservableSource completes or encounters an error, the resulting ObservableSource emits the current window and propagates the notification from the source ObservableSource.

    

    Scheduler:

    This version ofwindow operates by default on thecomputationScheduler.

    Parameters:

    timespan - the period of time each window collects items before it should be emitted

    timeskip - the period of time after which a new window will be created

    unit - the unit of time that applies to thetimespan andtimeskip arguments

    Returns:

    an Observable that emits new windows periodically as a fixed timespan elapses

    See Also:

    ReactiveX operators documentation: Window

  • window

    @CheckReturnValue@SchedulerSupport(value="custom")public final Observable<Observable<T>> window(long timespan,        long timeskip,TimeUnit unit,Scheduler scheduler)

    Returns an Observable that emits windows of items it collects from the source ObservableSource. The resulting ObservableSource starts a new window periodically, as determined by thetimeskip argument. It emits each window after a fixed timespan, specified by thetimespan argument. When the source ObservableSource completes or ObservableSource completes or encounters an error, the resulting ObservableSource emits the current window and propagates the notification from the source ObservableSource.

    

    Scheduler:

    You specify whichScheduler this operator will use.

    Parameters:

    timespan - the period of time each window collects items before it should be emitted

    timeskip - the period of time after which a new window will be created

    unit - the unit of time that applies to thetimespan andtimeskip arguments

    scheduler - theScheduler 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

    @CheckReturnValue@SchedulerSupport(value="custom")public final Observable<Observable<T>> window(long timespan,        long timeskip,TimeUnit unit,Scheduler scheduler,        int bufferSize)

    Returns an Observable that emits windows of items it collects from the source ObservableSource. The resulting ObservableSource starts a new window periodically, as determined by thetimeskip argument. It emits each window after a fixed timespan, specified by thetimespan argument. When the source ObservableSource completes or ObservableSource completes or encounters an error, the resulting ObservableSource emits the current window and propagates the notification from the source ObservableSource.

    

    Scheduler:

    You specify whichScheduler this operator will use.

    Parameters:

    timespan - the period of time each window collects items before it should be emitted

    timeskip - the period of time after which a new window will be created

    unit - the unit of time that applies to thetimespan andtimeskip arguments

    scheduler - theScheduler to use when determining the end and start of a window

    bufferSize - the capacity hint for the buffer in the inner windows

    Returns:

    an Observable that emits new windows periodically as a fixed timespan elapses

    See Also:

    ReactiveX operators documentation: Window

  • window

    @CheckReturnValue@SchedulerSupport(value="io.reactivex:computation")public final Observable<Observable<T>> window(long timespan,TimeUnit unit)

    Returns an Observable that emits windows of items it collects from the source ObservableSource. The resulting ObservableSource emits connected, non-overlapping windows, each of a fixed duration specified by thetimespan argument. When the source ObservableSource completes or encounters an error, the resulting ObservableSource emits the current window and propagates the notification from the source ObservableSource.

    

    Scheduler:

    This version ofwindow operates by default on thecomputationScheduler.

    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 thetimespan argument

    Returns:

    an Observable that emits connected, non-overlapping windows representing items emitted by the source ObservableSource during fixed, consecutive durations

    See Also:

    ReactiveX operators documentation: Window

  • window

    @CheckReturnValue@SchedulerSupport(value="io.reactivex:computation")public final Observable<Observable<T>> window(long timespan,TimeUnit unit,        long count)

    Returns an Observable that emits windows of items it collects from the source ObservableSource. The resulting ObservableSource emits connected, non-overlapping windows, each of a fixed duration as specified by thetimespan argument or a maximum size as specified by thecount argument (whichever is reached first). When the source ObservableSource completes or encounters an error, the resulting ObservableSource emits the current window and propagates the notification from the source ObservableSource.

    

    Scheduler:

    This version ofwindow operates by default on thecomputationScheduler.

    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 thetimespan argument

    count - the maximum size of each window before it should be emitted

    Returns:

    an Observable that emits connected, non-overlapping windows of items from the source ObservableSource that were emitted during a fixed duration of time or when the window has reached maximum capacity (whichever occurs first)

    See Also:

    ReactiveX operators documentation: Window

  • window

    @CheckReturnValue@SchedulerSupport(value="io.reactivex:computation")public final Observable<Observable<T>> window(long timespan,TimeUnit unit,        long count,        boolean restart)

    Returns an Observable that emits windows of items it collects from the source ObservableSource. The resulting ObservableSource emits connected, non-overlapping windows, each of a fixed duration as specified by thetimespan argument or a maximum size as specified by thecount argument (whichever is reached first). When the source ObservableSource completes or encounters an error, the resulting ObservableSource emits the current window and propagates the notification from the source ObservableSource.

    

    Scheduler:

    This version ofwindow operates by default on thecomputationScheduler.

    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 thetimespan argument

    count - the maximum size of each window before it should be emitted

    restart - if true, when a window reaches the capacity limit, the timer is restarted as well

    Returns:

    an Observable that emits connected, non-overlapping windows of items from the source ObservableSource that were emitted during a fixed duration of time or when the window has reached maximum capacity (whichever occurs first)

    See Also:

    ReactiveX operators documentation: Window

  • window

    @CheckReturnValue@SchedulerSupport(value="custom")public final Observable<Observable<T>> window(long timespan,TimeUnit unit,Scheduler scheduler)

    Returns an Observable that emits windows of items it collects from the source ObservableSource. The resulting ObservableSource emits connected, non-overlapping windows, each of a fixed duration as specified by thetimespan argument. When the source ObservableSource completes or encounters an error, the resulting ObservableSource emits the current window and propagates the notification from the source ObservableSource.

    

    Scheduler:

    You specify whichScheduler 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 thetimespan argument

    scheduler - theScheduler to use when determining the end and start of a window

    Returns:

    an Observable that emits connected, non-overlapping windows containing items emitted by the source ObservableSource within a fixed duration

    See Also:

    ReactiveX operators documentation: Window

  • window

    @CheckReturnValue@SchedulerSupport(value="custom")public final Observable<Observable<T>> window(long timespan,TimeUnit unit,Scheduler scheduler,        long count)

    Returns an Observable that emits windows of items it collects from the source ObservableSource. The resulting ObservableSource emits connected, non-overlapping windows, each of a fixed duration specified by thetimespan argument or a maximum size specified by thecount argument (whichever is reached first). When the source ObservableSource completes or encounters an error, the resulting ObservableSource emits the current window and propagates the notification from the source ObservableSource.

    

    Scheduler:

    You specify whichScheduler 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 thetimespan argument

    count - the maximum size of each window before it should be emitted

    scheduler - theScheduler 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 ObservableSource 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

    @CheckReturnValue@SchedulerSupport(value="custom")public final Observable<Observable<T>> window(long timespan,TimeUnit unit,Scheduler scheduler,        long count,        boolean restart)

    Returns an Observable that emits windows of items it collects from the source ObservableSource. The resulting ObservableSource emits connected, non-overlapping windows, each of a fixed duration specified by thetimespan argument or a maximum size specified by thecount argument (whichever is reached first). When the source ObservableSource completes or encounters an error, the resulting ObservableSource emits the current window and propagates the notification from the source ObservableSource.

    

    Scheduler:

    You specify whichScheduler 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 thetimespan argument

    count - the maximum size of each window before it should be emitted

    scheduler - theScheduler to use when determining the end and start of a window

    restart - if true, when a window reaches the capacity limit, the timer is restarted as well

    Returns:

    an Observable that emits connected, non-overlapping windows of items from the source ObservableSource that were emitted during a fixed duration of time or when the window has reached maximum capacity (whichever occurs first)

    See Also:

    ReactiveX operators documentation: Window

  • window

    @CheckReturnValue@SchedulerSupport(value="custom")public final Observable<Observable<T>> window(long timespan,TimeUnit unit,Scheduler scheduler,        long count,        boolean restart,        int bufferSize)

    Returns an Observable that emits windows of items it collects from the source ObservableSource. The resulting ObservableSource emits connected, non-overlapping windows, each of a fixed duration specified by thetimespan argument or a maximum size specified by thecount argument (whichever is reached first). When the source ObservableSource completes or encounters an error, the resulting ObservableSource emits the current window and propagates the notification from the source ObservableSource.

    

    Scheduler:

    You specify whichScheduler 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 thetimespan argument

    count - the maximum size of each window before it should be emitted

    scheduler - theScheduler to use when determining the end and start of a window

    restart - if true, when a window reaches the capacity limit, the timer is restarted as well

    bufferSize - the capacity hint for the buffer in the inner windows

    Returns:

    an Observable that emits connected, non-overlapping windows of items from the source ObservableSource that were emitted during a fixed duration of time or when the window has reached maximum capacity (whichever occurs first)

    See Also:

    ReactiveX operators documentation: Window

  • window

    @CheckReturnValue@SchedulerSupport(value="none")public final <B> Observable<Observable<T>> window(ObservableSource<B> boundary)

    Returns an Observable that emits non-overlapping windows of items it collects from the source ObservableSource where the boundary of each window is determined by the items emitted from a specified boundary-governing ObservableSource.

    

    Scheduler:

    This version ofwindow does not operate by default on a particularScheduler.

    Type Parameters:

    B - the window element type (ignored)

    Parameters:

    boundary - an ObservableSource whose emitted items close and open windows

    Returns:

    an Observable that emits non-overlapping windows of items it collects from the source ObservableSource where the boundary of each window is determined by the items emitted from theboundary ObservableSource

    See Also:

    ReactiveX operators documentation: Window

  • window

    @CheckReturnValue@SchedulerSupport(value="none")public final <B> Observable<Observable<T>> window(ObservableSource<B> boundary,        int bufferSize)

    Returns an Observable that emits non-overlapping windows of items it collects from the source ObservableSource where the boundary of each window is determined by the items emitted from a specified boundary-governing ObservableSource.

    

    Scheduler:

    This version ofwindow does not operate by default on a particularScheduler.

    Type Parameters:

    B - the window element type (ignored)

    Parameters:

    boundary - an ObservableSource whose emitted items close and open windows

    bufferSize - the capacity hint for the buffer in the inner windows

    Returns:

    an Observable that emits non-overlapping windows of items it collects from the source ObservableSource where the boundary of each window is determined by the items emitted from theboundary ObservableSource

    See Also:

    ReactiveX operators documentation: Window

  • window

    @CheckReturnValue@SchedulerSupport(value="none")public final <U,V> Observable<Observable<T>> window(ObservableSource<U> openingIndicator,Function<? super U,? extendsObservableSource<V>> closingIndicator)

    Returns an Observable that emits windows of items it collects from the source ObservableSource. The resulting ObservableSource emits windows that contain those items emitted by the source ObservableSource between the time when theopeningIndicator ObservableSource emits an item and when the ObservableSource returned byclosingIndicator emits an item.

    

    Scheduler:

    This version ofwindow does not operate by default on a particularScheduler.

    Type Parameters:

    U - the element type of the window-opening ObservableSource

    V - the element type of the window-closing ObservableSources

    Parameters:

    openingIndicator - an ObservableSource that, when it emits an item, causes another window to be created

    closingIndicator - aFunction that produces an ObservableSource for every window created. When this ObservableSource emits an item, the associated window is closed and emitted

    Returns:

    an Observable that emits windows of items emitted by the source ObservableSource that are governed by the specified window-governing ObservableSources

    See Also:

    ReactiveX operators documentation: Window

  • window

    @CheckReturnValue@SchedulerSupport(value="none")public final <U,V> Observable<Observable<T>> window(ObservableSource<U> openingIndicator,Function<? super U,? extendsObservableSource<V>> closingIndicator,        int bufferSize)

    Returns an Observable that emits windows of items it collects from the source ObservableSource. The resulting ObservableSource emits windows that contain those items emitted by the source ObservableSource between the time when theopeningIndicator ObservableSource emits an item and when the ObservableSource returned byclosingIndicator emits an item.

    

    Scheduler:

    This version ofwindow does not operate by default on a particularScheduler.

    Type Parameters:

    U - the element type of the window-opening ObservableSource

    V - the element type of the window-closing ObservableSources

    Parameters:

    openingIndicator - an ObservableSource that, when it emits an item, causes another window to be created

    closingIndicator - aFunction that produces an ObservableSource for every window created. When this ObservableSource emits an item, the associated window is closed and emitted

    bufferSize - the capacity hint for the buffer in the inner windows

    Returns:

    an Observable that emits windows of items emitted by the source ObservableSource that are governed by the specified window-governing ObservableSources

    See Also:

    ReactiveX operators documentation: Window

  • window

    @CheckReturnValue@SchedulerSupport(value="none")public final <B> Observable<Observable<T>> window(Callable<? extendsObservableSource<B>> boundary)

    Returns an Observable that emits windows of items it collects from the source ObservableSource. The resulting ObservableSource emits connected, non-overlapping windows. It emits the current window and opens a new one whenever the ObservableSource produced by the specifiedclosingIndicator emits an item.

    

    Scheduler:

    This version ofwindow does not operate by default on a particularScheduler.

    Type Parameters:

    B - the element type of the boundary ObservableSource

    Parameters:

    boundary - aCallable that returns anObservableSource that governs the boundary between windows. When the sourceObservableSource emits an item,window emits the current window and begins a new one.

    Returns:

    an Observable that emits connected, non-overlapping windows of items from the source ObservableSource wheneverclosingIndicator emits an item

    See Also:

    ReactiveX operators documentation: Window

  • window

    @CheckReturnValue@SchedulerSupport(value="none")public final <B> Observable<Observable<T>> window(Callable<? extendsObservableSource<B>> boundary,        int bufferSize)

    Returns an Observable that emits windows of items it collects from the source ObservableSource. The resulting ObservableSource emits connected, non-overlapping windows. It emits the current window and opens a new one whenever the ObservableSource produced by the specifiedclosingIndicator emits an item.

    

    Scheduler:

    This version ofwindow does not operate by default on a particularScheduler.

    Type Parameters:

    B - the element type of the boundary ObservableSource

    Parameters:

    boundary - aCallable that returns anObservableSource that governs the boundary between windows. When the sourceObservableSource emits an item,window emits the current window and begins a new one.

    bufferSize - the capacity hint for the buffer in the inner windows

    Returns:

    an Observable that emits connected, non-overlapping windows of items from the source ObservableSource wheneverclosingIndicator emits an item

    See Also:

    ReactiveX operators documentation: Window

  • withLatestFrom

    @CheckReturnValue@SchedulerSupport(value="none")public final <U,R> Observable<R> withLatestFrom(ObservableSource<? extends U> other,BiFunction<? superT,? super U,? extends R> combiner)

    Merges the specified ObservableSource into this ObservableSource sequence by using theresultSelector function only when the source ObservableSource (this instance) emits an item.

    

    Scheduler:

    This operator, by default, doesn't run any particularScheduler.

    Type Parameters:

    U - the element type of the other ObservableSource

    R - the result type of the combination

    Parameters:

    other - the other ObservableSource

    combiner - the function to call when this ObservableSource emits an item and the other ObservableSource has already emitted an item, to generate the item to be emitted by the resulting ObservableSource

    Returns:

    an Observable that merges the specified ObservableSource into this ObservableSource by using theresultSelector function only when the source ObservableSource sequence (this instance) emits an item

    Since:

    2.0

    See Also:

    ReactiveX operators documentation: CombineLatest

  • withLatestFrom

    @CheckReturnValue@SchedulerSupport(value="none")public final <T1,T2,R> Observable<R> withLatestFrom(ObservableSource<T1> o1,ObservableSource<T2> o2,Function3<? superT,? super T1,? super T2,R> combiner)

    Combines the value emission from this ObservableSource with the latest emissions from the other ObservableSources via a function to produce the output item.

    Note that this operator doesn't emit anything until all other sources have produced at least one value. The resulting emission only happens when this ObservableSource emits (and not when any of the other sources emit, unlike combineLatest). If a source doesn't produce any value and just completes, the sequence is completed immediately.

    

    Scheduler:

    This operator does not operate by default on a particularScheduler.

    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 ObservableSource

    o2 - the second other ObservableSource

    combiner - the function called with an array of values from each participating ObservableSource

    Returns:

    the new ObservableSource instance

    Since:

    2.0

  • withLatestFrom

    @CheckReturnValue@SchedulerSupport(value="none")public final <T1,T2,T3,R> Observable<R> withLatestFrom(ObservableSource<T1> o1,ObservableSource<T2> o2,ObservableSource<T3> o3,Function4<? superT,? super T1,? super T2,? super T3,R> combiner)

    Combines the value emission from this ObservableSource with the latest emissions from the other ObservableSources via a function to produce the output item.

    Note that this operator doesn't emit anything until all other sources have produced at least one value. The resulting emission only happens when this ObservableSource emits (and not when any of the other sources emit, unlike combineLatest). If a source doesn't produce any value and just completes, the sequence is completed immediately.

    

    Scheduler:

    This operator does not operate by default on a particularScheduler.

    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 ObservableSource

    o2 - the second other ObservableSource

    o3 - the third other ObservableSource

    combiner - the function called with an array of values from each participating ObservableSource

    Returns:

    the new ObservableSource instance

    Since:

    2.0

  • withLatestFrom

    @CheckReturnValue@SchedulerSupport(value="none")public final <T1,T2,T3,T4,R> Observable<R> withLatestFrom(ObservableSource<T1> o1,ObservableSource<T2> o2,ObservableSource<T3> o3,ObservableSource<T4> o4,Function5<? superT,? super T1,? super T2,? super T3,? super T4,R> combiner)

    Combines the value emission from this ObservableSource with the latest emissions from the other ObservableSources via a function to produce the output item.

    Note that this operator doesn't emit anything until all other sources have produced at least one value. The resulting emission only happens when this ObservableSource emits (and not when any of the other sources emit, unlike combineLatest). If a source doesn't produce any value and just completes, the sequence is completed immediately.

    

    Scheduler:

    This operator does not operate by default on a particularScheduler.

    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 ObservableSource

    o2 - the second other ObservableSource

    o3 - the third other ObservableSource

    o4 - the fourth other ObservableSource

    combiner - the function called with an array of values from each participating ObservableSource

    Returns:

    the new ObservableSource instance

    Since:

    2.0

  • withLatestFrom

    @CheckReturnValue@SchedulerSupport(value="none")public final <R> Observable<R> withLatestFrom(ObservableSource<?>[] others,Function<? superObject[],R> combiner)

    Combines the value emission from this ObservableSource with the latest emissions from the other ObservableSources via a function to produce the output item.

    Note that this operator doesn't emit anything until all other sources have produced at least one value. The resulting emission only happens when this ObservableSource emits (and not when any of the other sources emit, unlike combineLatest). If a source doesn't produce any value and just completes, the sequence is completed immediately.

    

    Scheduler:

    This operator does not operate by default on a particularScheduler.

    Type Parameters:

    R - the result value type

    Parameters:

    others - the array of other sources

    combiner - the function called with an array of values from each participating ObservableSource

    Returns:

    the new ObservableSource instance

    Since:

    2.0

  • withLatestFrom

    @CheckReturnValue@SchedulerSupport(value="none")public final <R> Observable<R> withLatestFrom(Iterable<? extendsObservableSource<?>> others,Function<? superObject[],R> combiner)

    Combines the value emission from this ObservableSource with the latest emissions from the other ObservableSources via a function to produce the output item.

    Note that this operator doesn't emit anything until all other sources have produced at least one value. The resulting emission only happens when this ObservableSource emits (and not when any of the other sources emit, unlike combineLatest). If a source doesn't produce any value and just completes, the sequence is completed immediately.

    

    Scheduler:

    This operator does not operate by default on a particularScheduler.

    Type Parameters:

    R - the result value type

    Parameters:

    others - the iterable of other sources

    combiner - the function called with an array of values from each participating ObservableSource

    Returns:

    the new ObservableSource instance

    Since:

    2.0

  • zipWith

    @CheckReturnValue@SchedulerSupport(value="none")public final <U,R> Observable<R> zipWith(Iterable<U> other,BiFunction<? superT,? super U,? extends R> zipper)

    Returns an Observable that emits items that are the result of applying a specified function to pairs of values, one each from the source ObservableSource and a specified Iterable sequence.

    

    Note that theother Iterable is evaluated as items are observed from the source ObservableSource; it is not pre-consumed. This allows you to zip infinite streams on either side.

    Scheduler:

    zipWith does not operate by default on a particularScheduler.

    Type Parameters:

    U - the type of items in theother Iterable

    R - the type of items emitted by the resulting ObservableSource

    Parameters:

    other - the Iterable sequence

    zipper - a function that combines the pairs of items from the ObservableSource and the Iterable to generate the items to be emitted by the resulting ObservableSource

    Returns:

    an Observable that pairs up values from the source ObservableSource and theother Iterable sequence and emits the results ofzipFunction applied to these pairs

    See Also:

    ReactiveX operators documentation: Zip

  • zipWith

    @CheckReturnValue@SchedulerSupport(value="none")public final <U,R> Observable<R> zipWith(ObservableSource<? extends U> other,BiFunction<? superT,? super U,? extends R> zipper)

    Returns an Observable that emits items that are the result of applying a specified function to pairs of values, one each from the source ObservableSource and another specified ObservableSource.

    

    The operator subscribes to its sources in order they are specified and completes eagerly if one of the sources is shorter than the rest while disposing the other sources. Therefore, it is possible those other sources will never be able to run to completion (and thus not callingdoOnComplete()). This can also happen if the sources are exactly the same length; if source A completes and B has been consumed and is about to complete, the operator detects A won't be sending further values and it will dispose B immediately. For example:

    range(1, 5).doOnComplete(action1).zipWith(range(6, 5).doOnComplete(action2), (a, b) -> a + b)

    action1 will be called butaction2 won't.
    To work around this termination property, usedoOnDispose(Action) as well or useusing() to do cleanup in case of completion or a dispose() call.

    Scheduler:

    zipWith does not operate by default on a particularScheduler.

    Type Parameters:

    U - the type of items emitted by theother ObservableSource

    R - the type of items emitted by the resulting ObservableSource

    Parameters:

    other - the other ObservableSource

    zipper - a function that combines the pairs of items from the two ObservableSources to generate the items to be emitted by the resulting ObservableSource

    Returns:

    an Observable that pairs up values from the source ObservableSource and theother ObservableSource and emits the results ofzipFunction applied to these pairs

    See Also:

    ReactiveX operators documentation: Zip

  • zipWith

    @CheckReturnValue@SchedulerSupport(value="none")public final <U,R> Observable<R> zipWith(ObservableSource<? extends U> other,BiFunction<? superT,? super U,? extends R> zipper,        boolean delayError)

    Returns an Observable that emits items that are the result of applying a specified function to pairs of values, one each from the source ObservableSource and another specified ObservableSource.

    

    The operator subscribes to its sources in order they are specified and completes eagerly if one of the sources is shorter than the rest while disposing the other sources. Therefore, it is possible those other sources will never be able to run to completion (and thus not callingdoOnComplete()). This can also happen if the sources are exactly the same length; if source A completes and B has been consumed and is about to complete, the operator detects A won't be sending further values and it will dispose B immediately. For example:

    range(1, 5).doOnComplete(action1).zipWith(range(6, 5).doOnComplete(action2), (a, b) -> a + b)

    action1 will be called butaction2 won't.
    To work around this termination property, usedoOnDispose(Action) as well or useusing() to do cleanup in case of completion or a dispose() call.

    Scheduler:

    zipWith does not operate by default on a particularScheduler.

    Type Parameters:

    U - the type of items emitted by theother ObservableSource

    R - the type of items emitted by the resulting ObservableSource

    Parameters:

    other - the other ObservableSource

    zipper - a function that combines the pairs of items from the two ObservableSources to generate the items to be emitted by the resulting ObservableSource

    delayError - if true, errors from the current Observable or the other ObservableSource is delayed until both terminate

    Returns:

    an Observable that pairs up values from the source ObservableSource and theother ObservableSource and emits the results ofzipFunction applied to these pairs

    Since:

    2.0

    See Also:

    ReactiveX operators documentation: Zip

  • zipWith

    @CheckReturnValue@SchedulerSupport(value="none")public final <U,R> Observable<R> zipWith(ObservableSource<? extends U> other,BiFunction<? superT,? super U,? extends R> zipper,        boolean delayError,        int bufferSize)

    Returns an Observable that emits items that are the result of applying a specified function to pairs of values, one each from the source ObservableSource and another specified ObservableSource.

    

    The operator subscribes to its sources in order they are specified and completes eagerly if one of the sources is shorter than the rest while disposing the other sources. Therefore, it is possible those other sources will never be able to run to completion (and thus not callingdoOnComplete()). This can also happen if the sources are exactly the same length; if source A completes and B has been consumed and is about to complete, the operator detects A won't be sending further values and it will dispose B immediately. For example:

    range(1, 5).doOnComplete(action1).zipWith(range(6, 5).doOnComplete(action2), (a, b) -> a + b)

    action1 will be called butaction2 won't.
    To work around this termination property, usedoOnDispose(Action) as well or useusing() to do cleanup in case of completion or a dispose() call.

    Scheduler:

    zipWith does not operate by default on a particularScheduler.

    Type Parameters:

    U - the type of items emitted by theother ObservableSource

    R - the type of items emitted by the resulting ObservableSource

    Parameters:

    other - the other ObservableSource

    zipper - a function that combines the pairs of items from the two ObservableSources to generate the items to be emitted by the resulting ObservableSource

    bufferSize - the capacity hint for the buffer in the inner windows

    delayError - if true, errors from the current Observable or the other ObservableSource is delayed until both terminate

    Returns:

    an Observable that pairs up values from the source ObservableSource and theother ObservableSource and emits the results ofzipFunction applied to these pairs

    Since:

    2.0

    See Also:

    ReactiveX operators documentation: Zip

  • test

    @CheckReturnValue@SchedulerSupport(value="none")public final TestObserver<T> test()

    Creates a TestObserver and subscribes it to this Observable.

    Scheduler:

    test does not operate by default on a particularScheduler.

    Returns:

    the new TestObserver instance

    Since:

    2.0

  • test

    @CheckReturnValue@SchedulerSupport(value="none")public final TestObserver<T> test(boolean dispose)

    Creates a TestObserver, optionally disposes it and then subscribes it to this Observable.

    Scheduler:

    test does not operate by default on a particularScheduler.

    Parameters:

    dispose - dispose the TestObserver before it is subscribed to this Observable?

    Returns:

    the new TestObserver instance

    Since:

    2.0