Class UnicastSubject<T>

java.lang.Object

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

io.reactivex.rxjava4.subjects.Subject<T>

io.reactivex.rxjava4.subjects.UnicastSubject<T>

Type Parameters:

T - the value type received and emitted by this Subject subclass

All Implemented Interfaces:

ObservableSource<T>, Observer<T>

public final class UnicastSubject<T>
extends Subject<T>

A Subject that queues up events until a single Observer subscribes to it, replays those events to it until the Observer catches up and then switches to relaying events live to this single Observer until this UnicastSubject terminates or the Observer disposes.

Note that UnicastSubject holds an unbounded internal buffer.

This subject does not have a public constructor by design; a new empty instance of this UnicastSubject can be created via the following create methods that allow specifying the retention policy for items:

• create() - creates an empty, unbounded UnicastSubject that caches all items and the terminal event it receives.
• create(int) - creates an empty, unbounded UnicastSubject with a hint about how many total items one expects to retain.
• create(boolean) - creates an empty, unbounded UnicastSubject that optionally delays an error it receives and replays it after the regular items have been emitted.
• create(int, Runnable) - creates an empty, unbounded UnicastSubject with a hint about how many total items one expects to retain and a callback that will be called exactly once when the UnicastSubject gets terminated or the single Observer disposes.
• create(int, Runnable, boolean) - creates an empty, unbounded UnicastSubject with a hint about how many total items one expects to retain and a callback that will be called exactly once when the UnicastSubject gets terminated or the single Observer disposes and optionally delays an error it receives and replays it after the regular items have been emitted.

If more than one Observer attempts to subscribe to this UnicastSubject, they will receive an IllegalStateException indicating the single-use-only nature of this UnicastSubject, even if the UnicastSubject already terminated with an error.

Since a Subject is conceptionally derived from the Processor type in the Reactive Streams specification, nulls are not allowed (Rule 2.13) as parameters to onNext(Object) and onError(Throwable). Such calls will result in a NullPointerException being thrown and the subject's state is not changed.

Since a UnicastSubject is an Observable, it does not support backpressure.

When this UnicastSubject is terminated via onError(Throwable) the current or late single Observer may receive the Throwable before any available items could be emitted. To make sure an onError event is delivered to the Observer after the normal items, create a UnicastSubject with the create(boolean) or create(int, Runnable, boolean) factory methods.

Even though UnicastSubject implements the Observer interface, calling onSubscribe is not required (Rule 2.12) if the subject is used as a standalone source. However, calling onSubscribe after the UnicastSubject reached its terminal state will result in the given Disposable being disposed immediately.

Calling onNext(Object), onError(Throwable) and onComplete() is required to be serialized (called from the same thread or called non-overlappingly from different threads through external means of serialization). The Subject.toSerialized() method available to all Subjects provides such serialization and also protects against reentrance (i.e., when a downstream Observer consuming this subject also wants to call onNext(Object) on this subject recursively).

This UnicastSubject supports the standard state-peeking methods hasComplete(), hasThrowable(), getThrowable() and hasObservers().

Scheduler:

UnicastSubject does not operate by default on a particular Scheduler and the single Observer gets notified on the thread the respective onXXX methods were invoked.

Error handling:

When the onError(Throwable) is called, the UnicastSubject enters into a terminal state and emits the same Throwable instance to the current single Observer. During this emission, if the single Observers disposes its respective Disposable, the Throwable is delivered to the global error handler via RxJavaPlugins.onError(Throwable). If there were no Observers subscribed to this UnicastSubject when the onError() was called, the global error handler is not invoked.

Example usage:

UnicastSubject<Integer> subject = UnicastSubject.create();

TestObserver<Integer> to1 = subject.test();

// fresh UnicastSubjects are empty
to1.assertEmpty();

TestObserver<Integer> to2 = subject.test();

// A UnicastSubject only allows one Observer during its lifetime
to2.assertFailure(IllegalStateException.class);

subject.onNext(1);
to1.assertValue(1);

subject.onNext(2);
to1.assertValues(1, 2);

subject.onComplete();
to1.assertResult(1, 2);

// ----------------------------------------------------

UnicastSubject<Integer> subject2 = UnicastSubject.create();

// a UnicastSubject caches events until its single Observer subscribes
subject2.onNext(1);
subject2.onNext(2);
subject2.onComplete();

TestObserver<Integer> to3 = subject2.test();

// the cached events are emitted in order
to3.assertResult(1, 2);

Since:

2.0

Method Summary

Modifier and Type	Method	Description
static <T> @NonNull UnicastSubject<T>	create()	Creates an UnicastSubject with an internal buffer capacity hint 16.
static <T> @NonNull UnicastSubject<T>	create(boolean delayError)	Creates an UnicastSubject with an internal buffer capacity hint 16 and given delay error flag.
static <T> @NonNull UnicastSubject<T>	create(int capacityHint)	Creates an UnicastSubject with the given internal buffer capacity hint.
static <T> @NonNull UnicastSubject<T>	create(int capacityHint, @NonNull Runnable onTerminate)	Creates an UnicastSubject with the given internal buffer capacity hint and a callback for the case when the single Subscriber cancels its subscription or the subject is terminated.
static <T> @NonNull UnicastSubject<T>	create(int capacityHint, @NonNull Runnable onTerminate, boolean delayError)	Creates an UnicastSubject with the given internal buffer capacity hint, delay error flag and a callback for the case when the single Observer disposes its Disposable or the subject is terminated.
@Nullable Throwable	getThrowable()	Returns the error that caused the Subject to terminate or null if the Subject hasn't terminated yet.
boolean	hasComplete()	Returns true if the subject has reached a terminal state through a complete event.
boolean	hasObservers()	Returns true if the subject has any Observers.
boolean	hasThrowable()	Returns true if the subject has reached a terminal state through an error event.
void	onComplete()	Notifies the Observer that the Observable has finished sending push-based notifications.
void	onError(Throwable t)	Notifies the Observer that the Observable has experienced an error condition.
void	onNext(T t)	Provides the Observer with a new item to observe.
void	onSubscribe(Disposable d)	Provides the Observer with the means of cancelling (disposing) the connection (channel) with the Observable in both synchronous (from within Observer.onNext(Object)) and asynchronous manner.
protected void	subscribeActual(Observer<? super T> observer)	Operator implementations (both source and intermediate) should implement this method that performs the necessary business logic and handles the incoming Observers.

Methods inherited from class Subject

toSerialized

Modifier and Type	Method	Description
final @NonNull Subject<T>	toSerialized()	Wraps this Subject and serializes the calls to the onSubscribe, onNext, onError and onComplete methods, making them thread-safe.

Methods inherited from class Observable

all, amb, ambArray, ambWith, any, blockingFirst, blockingFirst, blockingForEach, blockingForEach, blockingIterable, blockingIterable, blockingLast, blockingLast, blockingLatest, blockingMostRecent, blockingNext, blockingSingle, blockingSingle, blockingStream, blockingStream, blockingSubscribe, blockingSubscribe, blockingSubscribe, blockingSubscribe, blockingSubscribe, buffer, buffer, buffer, buffer, buffer, buffer, buffer, buffer, buffer, buffer, buffer, buffer, buffer, buffer, buffer, buffer, buffer, bufferSize, cache, cacheWithInitialCapacity, cast, collect, collect, collectInto, combineLatest, combineLatest, combineLatest, combineLatest, combineLatest, combineLatest, combineLatest, combineLatest, combineLatest, combineLatest, combineLatestArray, combineLatestArray, combineLatestArrayDelayError, combineLatestArrayDelayError, combineLatestDelayError, combineLatestDelayError, compose, concat, concat, concat, concat, concat, concat, concatArray, concatArrayDelayError, concatArrayEager, concatArrayEager, concatArrayEagerDelayError, concatArrayEagerDelayError, concatDelayError, concatDelayError, concatDelayError, concatEager, concatEager, concatEager, concatEager, concatEagerDelayError, concatEagerDelayError, concatEagerDelayError, concatEagerDelayError, concatMap, concatMap, concatMap, concatMapCompletable, concatMapCompletable, concatMapCompletableDelayError, concatMapCompletableDelayError, concatMapCompletableDelayError, concatMapDelayError, concatMapDelayError, concatMapDelayError, concatMapEager, concatMapEager, concatMapEagerDelayError, concatMapEagerDelayError, concatMapIterable, concatMapMaybe, concatMapMaybe, concatMapMaybeDelayError, concatMapMaybeDelayError, concatMapMaybeDelayError, concatMapSingle, concatMapSingle, concatMapSingleDelayError, concatMapSingleDelayError, concatMapSingleDelayError, concatMapStream, concatWith, concatWith, concatWith, concatWith, contains, count, create, debounce, debounce, debounce, debounce, defaultIfEmpty, defer, delay, delay, delay, delay, delay, delay, delaySubscription, delaySubscription, delaySubscription, dematerialize, distinct, distinct, distinct, distinctUntilChanged, distinctUntilChanged, distinctUntilChanged, doAfterNext, doAfterTerminate, doFinally, doOnComplete, doOnDispose, doOnEach, doOnEach, doOnError, doOnLifecycle, doOnNext, doOnSubscribe, doOnTerminate, elementAt, elementAt, elementAtOrError, empty, error, error, filter, first, firstElement, firstOrError, firstOrErrorStage, firstStage, flatMap, flatMap, flatMap, flatMap, flatMap, flatMap, flatMap, flatMap, flatMap, flatMap, flatMap, flatMap, flatMapCompletable, flatMapCompletable, flatMapIterable, flatMapIterable, flatMapMaybe, flatMapMaybe, flatMapSingle, flatMapSingle, flatMapStream, forEach, forEachWhile, forEachWhile, forEachWhile, fromAction, fromArray, fromCallable, fromCompletable, fromCompletionStage, fromFuture, fromFuture, fromIterable, fromMaybe, fromOptional, fromPublisher, fromRunnable, fromSingle, fromStream, fromSupplier, generate, generate, generate, generate, generate, groupBy, groupBy, groupBy, groupBy, groupBy, groupJoin, hide, ignoreElements, interval, interval, interval, interval, intervalRange, intervalRange, isEmpty, join, just, just, just, just, just, just, just, just, just, just, last, lastElement, lastOrError, lastOrErrorStage, lastStage, lift, map, mapOptional, materialize, merge, merge, merge, merge, merge, merge, merge, merge, mergeArray, mergeArray, mergeArrayDelayError, mergeArrayDelayError, mergeDelayError, mergeDelayError, mergeDelayError, mergeDelayError, mergeDelayError, mergeDelayError, mergeDelayError, mergeDelayError, mergeWith, mergeWith, mergeWith, mergeWith, never, observeOn, observeOn, observeOn, ofType, onErrorComplete, onErrorComplete, onErrorResumeNext, onErrorResumeWith, onErrorReturn, onErrorReturnItem, onTerminateDetach, publish, publish, range, rangeLong, reduce, reduce, reduceWith, repeat, repeat, repeatUntil, repeatWhen, replay, replay, replay, replay, replay, replay, replay, replay, replay, replay, replay, replay, replay, replay, replay, replay, replay, replay, retry, retry, retry, retry, retry, retryUntil, retryWhen, safeSubscribe, sample, sample, sample, sample, sample, sample, sample, scan, scan, scanWith, sequenceEqual, sequenceEqual, sequenceEqual, sequenceEqual, serialize, share, single, singleElement, singleOrError, singleOrErrorStage, singleStage, skip, skip, skip, skipLast, skipLast, skipLast, skipLast, skipLast, skipLast, skipUntil, skipWhile, sorted, sorted, startWith, startWith, startWith, startWith, startWithArray, startWithItem, startWithIterable, subscribe, subscribe, subscribe, subscribe, subscribe, subscribe, subscribeOn, subscribeWith, switchIfEmpty, switchMap, switchMap, switchMapCompletable, switchMapCompletableDelayError, switchMapDelayError, switchMapDelayError, switchMapMaybe, switchMapMaybeDelayError, switchMapSingle, switchMapSingleDelayError, switchOnNext, switchOnNext, switchOnNextDelayError, switchOnNextDelayError, take, take, take, takeLast, takeLast, takeLast, takeLast, takeLast, takeLast, takeLast, takeLast, takeLast, takeUntil, takeUntil, takeWhile, test, test, throttleFirst, throttleFirst, throttleFirst, throttleLast, throttleLast, throttleLast, throttleLatest, throttleLatest, throttleLatest, throttleLatest, throttleLatest, throttleWithTimeout, throttleWithTimeout, throttleWithTimeout, timeInterval, timeInterval, timeInterval, timeInterval, timeout, timeout, timeout, timeout, timeout, timeout, timeout, timeout, timer, timer, timestamp, timestamp, timestamp, timestamp, to, toFlowable, toFuture, toList, toList, toList, toMap, toMap, toMap, toMultimap, toMultimap, toMultimap, toMultimap, toSortedList, toSortedList, toSortedList, toSortedList, unsafeCreate, unsubscribeOn, using, using, window, window, window, window, window, window, window, window, window, window, window, window, window, window, window, window, window, withLatestFrom, withLatestFrom, withLatestFrom, withLatestFrom, withLatestFrom, withLatestFrom, wrap, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zipArray, zipWith, zipWith, zipWith, zipWith

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

Methods inherited from class Object

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

Method Details

create

@CheckReturnValue
@NonNull
public static <T> @NonNull UnicastSubject<T> create()

Creates an UnicastSubject with an internal buffer capacity hint 16.

Type Parameters:

T - the value type

Returns:

an UnicastSubject instance

create

@CheckReturnValue
@NonNull
public static <T> @NonNull UnicastSubject<T> create(int capacityHint)

Creates an UnicastSubject with the given internal buffer capacity hint.

Type Parameters:

T - the value type

Parameters:

capacityHint - the hint to size the internal unbounded buffer

Returns:

an UnicastSubject instance

Throws:

IllegalArgumentException - if capacityHint is non-positive

create

@CheckReturnValue
@NonNull
public static <T> @NonNull UnicastSubject<T> create(int capacityHint,
 @NonNull
 @NonNull Runnable onTerminate)

Creates an UnicastSubject with the given internal buffer capacity hint and a callback for the case when the single Subscriber cancels its subscription or the subject is terminated.

The callback, if not null, is called exactly once and non-overlapped with any active replay.

Type Parameters:

T - the value type

Parameters:

capacityHint - the hint to size the internal unbounded buffer

onTerminate - the callback to run when the Subject is terminated or cancelled, null not allowed

Returns:

an UnicastSubject instance

Throws:

NullPointerException - if onTerminate is null

IllegalArgumentException - if capacityHint is non-positive

create

@CheckReturnValue
@NonNull
public static <T> @NonNull UnicastSubject<T> create(int capacityHint,
 @NonNull
 @NonNull Runnable onTerminate,
 boolean delayError)

Creates an UnicastSubject with the given internal buffer capacity hint, delay error flag and a callback for the case when the single Observer disposes its Disposable or the subject is terminated.

The callback, if not null, is called exactly once and non-overlapped with any active replay.

History: 2.0.8 - experimental

Type Parameters:

T - the value type

Parameters:

capacityHint - the hint to size the internal unbounded buffer

onTerminate - the callback to run when the Subject is terminated or cancelled, null not allowed

delayError - deliver pending onNext events before onError

Returns:

an UnicastSubject instance

Throws:

NullPointerException - if onTerminate is null

IllegalArgumentException - if capacityHint is non-positive

Since:

2.2

create

@CheckReturnValue
@NonNull
public static <T> @NonNull UnicastSubject<T> create(boolean delayError)

Creates an UnicastSubject with an internal buffer capacity hint 16 and given delay error flag.

The callback, if not null, is called exactly once and non-overlapped with any active replay.

History: 2.0.8 - experimental

Type Parameters:

T - the value type

Parameters:

delayError - deliver pending onNext events before onError

Returns:

an UnicastSubject instance

Since:

2.2

subscribeActual

protected void subscribeActual(Observer<? super T> observer)

Description copied from class: Observable

Operator implementations (both source and intermediate) should implement this method that performs the necessary business logic and handles the incoming Observers.

There is no need to call any of the plugin hooks on the current Observable instance or the Observer; all hooks and basic safeguards have been applied by Observable.subscribe(Observer) before this method gets called.

Specified by:

subscribeActual in class Observable<T>

Parameters:

observer - the incoming Observer, never null

onSubscribe

public void onSubscribe(Disposable d)

Description copied from interface: Observer

Provides the Observer with the means of cancelling (disposing) the connection (channel) with the Observable in both synchronous (from within Observer.onNext(Object)) and asynchronous manner.

Parameters:

d - the Disposable instance whose Disposable.dispose() can be called anytime to cancel the connection

onNext

public void onNext(T t)

Description copied from interface: Observer

Provides the Observer with a new item to observe.

The Observable may call this method 0 or more times.

The Observable will not call this method again after it calls either Observer.onComplete() or Observer.onError(Throwable).

Parameters:

t - the item emitted by the Observable

onError

public void onError(Throwable t)

Description copied from interface: Observer

Notifies the Observer that the Observable has experienced an error condition.

If the Observable calls this method, it will not thereafter call Observer.onNext(T) or Observer.onComplete().

Parameters:

t - the exception encountered by the Observable

onComplete

public void onComplete()

Description copied from interface: Observer

Notifies the Observer that the Observable has finished sending push-based notifications.

The Observable will not call this method if it calls Observer.onError(Throwable).

hasObservers

@CheckReturnValue
public boolean hasObservers()

Description copied from class: Subject

Returns true if the subject has any Observers.

The method is thread-safe.

Specified by:

hasObservers in class Subject<T>

Returns:

true if the subject has any Observers

getThrowable

@Nullable
@CheckReturnValue
public @Nullable Throwable getThrowable()

Description copied from class: Subject

Returns the error that caused the Subject to terminate or null if the Subject hasn't terminated yet.

The method is thread-safe.

Specified by:

getThrowable in class Subject<T>

Returns:

the error that caused the Subject to terminate or null if the Subject hasn't terminated yet

hasThrowable

@CheckReturnValue
public boolean hasThrowable()

Description copied from class: Subject

Returns true if the subject has reached a terminal state through an error event.

The method is thread-safe.

Specified by:

hasThrowable in class Subject<T>

Returns:

true if the subject has reached a terminal state through an error event

See Also:

• Subject.getThrowable()
• Subject.hasComplete()

hasComplete

@CheckReturnValue
public boolean hasComplete()

Description copied from class: Subject

Returns true if the subject has reached a terminal state through a complete event.

The method is thread-safe.

Specified by:

hasComplete in class Subject<T>

Returns:

true if the subject has reached a terminal state through a complete event

See Also:

• Subject.hasThrowable()