Movatterモバイル変換

java.lang.Object
- io.reactivex.Single<T>

Type Parameters:
T - the type of the item emitted by the Single
All Implemented Interfaces:
SingleSource<T>
Direct Known Subclasses:
SingleSubject
```
public abstract classSingle<T>extendsObjectimplementsSingleSource<T>
```
TheSingle class implements the Reactive Pattern for a single value response.
Single behaves similarly toObservable except that it can only emit either a single successful value or an error (there is no "onComplete" notification as there is for anObservable).
TheSingle class implements theSingleSource base interface and the default consumer type it interacts with is theSingleObserver via thesubscribe(SingleObserver) method.
TheSingle operates with the following sequential protocol:
```
onSubscribe (onSuccess | onError)?
```
Note thatonSuccess andonError are mutually exclusive events; unlikeObservable,onSuccess is never followed byonError.
LikeObservable, a runningSingle can be stopped through theDisposable instance provided to consumers throughSingleObserver.onSubscribe(io.reactivex.disposables.Disposable).
Like anObservable, aSingle is lazy, can be either "hot" or "cold", synchronous or asynchronous.Single instances returned by the methods of this class arecold and there is a standardhot implementation in the form of a subject:SingleSubject.
The documentation for this class makes use of marble diagrams. The following legend explains these diagrams:
SeeFlowable orObservable for the implementation of the Reactive Pattern for a stream or vector of values.
For more information see theReactiveX documentation.
Example:
```
 Disposable d = Single.just("Hello World") .delay(10, TimeUnit.SECONDS, Schedulers.io()) .subscribeWith(new DisposableSingleObserver<String>() { @Override public void onStart() { System.out.println("Started"); } @Override public void onSuccess(String value) { System.out.println("Success: " + value); } @Override public void onError(Throwable error) { error.printStackTrace(); } }); Thread.sleep(5000); d.dispose();
```
Note that by design, subscriptions viasubscribe(SingleObserver) can't be disposed from the outside (hence thevoid return of thesubscribe(SingleObserver) method) and it is the responsibility of the implementor of theSingleObserver to allow this to happen. RxJava supports such usage with the standardDisposableSingleObserver instance. For convenience, thesubscribeWith(SingleObserver) method is provided as well to allow working with aSingleObserver (or subclass) instance to be applied with in a fluent manner (such as in the example above).
Since:
2.0
See Also:
DisposableSingleObserver

Constructor Summary
Constructors
Constructor and Description
Single()

Constructors
Constructor and Description
`Single()`

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`static <T> Single<T>`	`amb(Iterable<? extendsSingleSource<? extends T>> sources)` Runs multiple SingleSources and signals the events of the first one that signals (disposing the rest).
`static <T> Single<T>`	`ambArray(SingleSource<? extends T>... sources)` Runs multiple SingleSources and signals the events of the first one that signals (disposing the rest).
`Single<T>`	`ambWith(SingleSource<? extendsT> other)` Signals the event of this or the other SingleSource whichever signals first.
`<R> R`	`as(SingleConverter<T,? extends R> converter)` Calls the specified converter function during assembly time and returns its resulting value.
`T`	`blockingGet()` Waits in a blocking fashion until the current Single signals a success value (which is returned) or an exception (which is propagated).
`Single<T>`	`cache()` Stores the success value or exception from the current Single and replays it to late SingleObservers.
`<U> Single<U>`	`cast(Class<? extends U> clazz)` Casts the success value of the current Single into the target type or signals a ClassCastException if not compatible.
`<R> Single<R>`	`compose(SingleTransformer<? superT,? extends R> transformer)` Transform a Single by applying a particular Transformer function to it.
`static <T> Flowable<T>`	`concat(Iterable<? extendsSingleSource<? extends T>> sources)` Concatenate the single values, in a non-overlapping fashion, of the SingleSources provided by an Iterable sequence.
`static <T> Observable<T>`	`concat(ObservableSource<? extendsSingleSource<? extends T>> sources)` Concatenate the single values, in a non-overlapping fashion, of the SingleSources provided by an Observable sequence.
`static <T> Flowable<T>`	`concat(Publisher<? extendsSingleSource<? extends T>> sources)` Concatenate the single values, in a non-overlapping fashion, of the SingleSources provided by a Publisher sequence.
`static <T> Flowable<T>`	`concat(Publisher<? extendsSingleSource<? extends T>> sources, int prefetch)` Concatenate the single values, in a non-overlapping fashion, of the SingleSources provided by a Publisher sequence and prefetched by the specified amount.
`static <T> Flowable<T>`	`concat(SingleSource<? extends T> source1,SingleSource<? extends T> source2)` Returns a Flowable that emits the items emitted by two Singles, one after the other.
`static <T> Flowable<T>`	`concat(SingleSource<? extends T> source1,SingleSource<? extends T> source2,SingleSource<? extends T> source3)` Returns a Flowable that emits the items emitted by three Singles, one after the other.
`static <T> Flowable<T>`	`concat(SingleSource<? extends T> source1,SingleSource<? extends T> source2,SingleSource<? extends T> source3,SingleSource<? extends T> source4)` Returns a Flowable that emits the items emitted by four Singles, one after the other.
`static <T> Flowable<T>`	`concatArray(SingleSource<? extends T>... sources)` Concatenate the single values, in a non-overlapping fashion, of the SingleSources provided in an array.
`static <T> Flowable<T>`	`concatArrayEager(SingleSource<? extends T>... sources)` Concatenates a sequence of SingleSource eagerly into a single stream of values.
`static <T> Flowable<T>`	`concatEager(Iterable<? extendsSingleSource<? extends T>> sources)` Concatenates a sequence of SingleSources eagerly into a single stream of values.
`static <T> Flowable<T>`	`concatEager(Publisher<? extendsSingleSource<? extends T>> sources)` Concatenates a Publisher sequence of SingleSources eagerly into a single stream of values.
`Flowable<T>`	`concatWith(SingleSource<? extendsT> other)` Returns a Flowable that emits the item emitted by the source Single, then the item emitted by the specified Single.
`Single<Boolean>`	`contains(Object value)` Signals true if the current Single signals a success value that is Object-equals with the value provided.
`Single<Boolean>`	`contains(Object value,BiPredicate<Object,Object> comparer)` Signals true if the current Single signals a success value that is equal with the value provided by calling a bi-predicate.
`static <T> Single<T>`	`create(SingleOnSubscribe<T> source)` Provides an API (via a cold Single) that bridges the reactive world with the callback-style world.
`static <T> Single<T>`	`defer(Callable<? extendsSingleSource<? extends T>> singleSupplier)` Calls a`Callable` for each individual`SingleObserver` to return the actual`SingleSource` to be subscribed to.
`Single<T>`	`delay(long time,TimeUnit unit)` Delays the emission of the success signal from the current Single by the specified amount.
`Single<T>`	`delay(long time,TimeUnit unit, boolean delayError)` Delays the emission of the success or error signal from the current Single by the specified amount.
`Single<T>`	`delay(long time,TimeUnit unit,Scheduler scheduler)` Delays the emission of the success signal from the current Single by the specified amount.
`Single<T>`	`delay(long time,TimeUnit unit,Scheduler scheduler, boolean delayError)` Delays the emission of the success or error signal from the current Single by the specified amount.
`Single<T>`	`delaySubscription(CompletableSource other)` Delays the actual subscription to the current Single until the given other CompletableSource completes.
`Single<T>`	`delaySubscription(long time,TimeUnit unit)` Delays the actual subscription to the current Single until the given time delay elapsed.
`Single<T>`	`delaySubscription(long time,TimeUnit unit,Scheduler scheduler)` Delays the actual subscription to the current Single until the given time delay elapsed.
`<U> Single<T>`	`delaySubscription(ObservableSource<U> other)` Delays the actual subscription to the current Single until the given other ObservableSource signals its first value or completes.
`<U> Single<T>`	`delaySubscription(Publisher<U> other)` Delays the actual subscription to the current Single until the given other Publisher signals its first value or completes.
`<U> Single<T>`	`delaySubscription(SingleSource<U> other)` Delays the actual subscription to the current Single until the given other SingleSource signals success.
`<R> Maybe<R>`	`dematerialize(Function<? superT,Notification<R>> selector)` Maps the`Notification` success value of this Single back into normal`onSuccess`,`onError` or`onComplete` signals as a`Maybe` source.
`Single<T>`	`doAfterSuccess(Consumer<? superT> onAfterSuccess)` Calls the specified consumer with the success item after this item has been emitted to the downstream.
`Single<T>`	`doAfterTerminate(Action onAfterTerminate)` Registers an`Action` to be called after this Single invokes either onSuccess or onError.
`Single<T>`	`doFinally(Action onFinally)` Calls the specified action after this Single signals onSuccess or onError or gets disposed by the downstream.
`Single<T>`	`doOnDispose(Action onDispose)` Calls the shared`Action` if a SingleObserver subscribed to the current Single disposes the common Disposable it received via onSubscribe.
`Single<T>`	`doOnError(Consumer<? superThrowable> onError)` Calls the shared consumer with the error sent via onError for each SingleObserver that subscribes to the current Single.
`Single<T>`	`doOnEvent(BiConsumer<? superT,? superThrowable> onEvent)` Calls the shared consumer with the error sent via onError or the value via onSuccess for each SingleObserver that subscribes to the current Single.
`Single<T>`	`doOnSubscribe(Consumer<? superDisposable> onSubscribe)` Calls the shared consumer with the Disposable sent through the onSubscribe for each SingleObserver that subscribes to the current Single.
`Single<T>`	`doOnSuccess(Consumer<? superT> onSuccess)` Calls the shared consumer with the success value sent via onSuccess for each SingleObserver that subscribes to the current Single.
`Single<T>`	`doOnTerminate(Action onTerminate)` Returns a Single instance that calls the given onTerminate callback just before this Single completes normally or with an exception.
`static <T> Single<Boolean>`	`equals(SingleSource<? extends T> first,SingleSource<? extends T> second)` Compares two SingleSources and emits true if they emit the same value (compared via Object.equals).
`static <T> Single<T>`	`error(Callable<? extendsThrowable> errorSupplier)` Signals a Throwable returned by the callback function for each individual SingleObserver.
`static <T> Single<T>`	`error(Throwable exception)` Returns a Single that invokes a subscriber's`onError` method when the subscriber subscribes to it.
`Maybe<T>`	`filter(Predicate<? superT> predicate)` Filters the success item of the Single via a predicate function and emitting it if the predicate returns true, completing otherwise.
`<R> Single<R>`	`flatMap(Function<? superT,? extendsSingleSource<? extends R>> mapper)` Returns a Single that is based on applying a specified function to the item emitted by the source Single, where that function returns a SingleSource.
`Completable`	`flatMapCompletable(Function<? superT,? extendsCompletableSource> mapper)` Returns a`Completable` that completes based on applying a specified function to the item emitted by the source`Single`, where that function returns a`Completable`.
`<R> Maybe<R>`	`flatMapMaybe(Function<? superT,? extendsMaybeSource<? extends R>> mapper)` Returns a Maybe that is based on applying a specified function to the item emitted by the source Single, where that function returns a MaybeSource.
`<R> Observable<R>`	`flatMapObservable(Function<? superT,? extendsObservableSource<? extends R>> mapper)` Returns an Observable that is based on applying a specified function to the item emitted by the source Single, where that function returns an ObservableSource.
`<R> Flowable<R>`	`flatMapPublisher(Function<? superT,? extendsPublisher<? extends R>> mapper)` Returns a Flowable that emits items based on applying a specified function to the item emitted by the source Single, where that function returns a Publisher.
`<U> Flowable<U>`	`flattenAsFlowable(Function<? superT,? extendsIterable<? extends U>> mapper)` Maps the success value of the upstream`Single` into an`Iterable` and emits its items as a`Flowable` sequence.
`<U> Observable<U>`	`flattenAsObservable(Function<? superT,? extendsIterable<? extends U>> mapper)` Maps the success value of the upstream`Single` into an`Iterable` and emits its items as an`Observable` sequence.
`static <T> Single<T>`	`fromCallable(Callable<? extends T> callable)` Returns a`Single` that invokes passed function and emits its result for each new SingleObserver that subscribes.
`static <T> Single<T>`	`fromFuture(Future<? extends T> future)` Converts a`Future` into a`Single`.
`static <T> Single<T>`	`fromFuture(Future<? extends T> future, long timeout,TimeUnit unit)` Converts a`Future` into a`Single`, with a timeout on the Future.
`static <T> Single<T>`	`fromFuture(Future<? extends T> future, long timeout,TimeUnit unit,Scheduler scheduler)` Converts a`Future` into a`Single`, with a timeout on the Future.
`static <T> Single<T>`	`fromFuture(Future<? extends T> future,Scheduler scheduler)` Converts a`Future`, operating on a specified`Scheduler`, into a`Single`.
`static <T> Single<T>`	`fromObservable(ObservableSource<? extends T> observableSource)` Wraps a specific ObservableSource into a Single and signals its single element or error.
`static <T> Single<T>`	`fromPublisher(Publisher<? extends T> publisher)` Wraps a specific Publisher into a Single and signals its single element or error.
`Single<T>`	`hide()` Hides the identity of the current Single, including the Disposable that is sent to the downstream via`onSubscribe()`.
`Completable`	`ignoreElement()` Returns a`Completable` that ignores the success value of this`Single` and calls`onComplete` instead on the returned`Completable`.
`static <T> Single<T>`	`just(T item)` Returns a`Single` that emits a specified item.
`<R> Single<R>`	`lift(SingleOperator<? extends R,? superT> lift)` This method requires advanced knowledge about building operators, please consider other standard composition methods first; Returns a`Single` which, when subscribed to, invokes the`apply(SingleObserver)` method of the provided`SingleOperator` for each individual downstream`Single` and allows the insertion of a custom operator by accessing the downstream's`SingleObserver` during this subscription phase and providing a new`SingleObserver`, containing the custom operator's intended business logic, that will be used in the subscription process going further upstream.
`<R> Single<R>`	`map(Function<? superT,? extends R> mapper)` Returns a Single that applies a specified function to the item emitted by the source Single and emits the result of this function application.
`Single<Notification<T>>`	`materialize()` Maps the signal types of this Single into a`Notification` of the same kind and emits it as a single success value to downstream.
`static <T> Flowable<T>`	`merge(Iterable<? extendsSingleSource<? extends T>> sources)` Merges an Iterable sequence of SingleSource instances into a single Flowable sequence, running all SingleSources at once.
`static <T> Flowable<T>`	`merge(Publisher<? extendsSingleSource<? extends T>> sources)` Merges a Flowable sequence of SingleSource instances into a single Flowable sequence, running all SingleSources at once.
`static <T> Single<T>`	`merge(SingleSource<? extendsSingleSource<? extends T>> source)` Flattens a`Single` that emits a`Single` into a single`Single` that emits the item emitted by the nested`Single`, without any transformation.
`static <T> Flowable<T>`	`merge(SingleSource<? extends T> source1,SingleSource<? extends T> source2)` Flattens two Singles into a single Flowable, without any transformation.
`static <T> Flowable<T>`	`merge(SingleSource<? extends T> source1,SingleSource<? extends T> source2,SingleSource<? extends T> source3)` Flattens three Singles into a single Flowable, without any transformation.
`static <T> Flowable<T>`	`merge(SingleSource<? extends T> source1,SingleSource<? extends T> source2,SingleSource<? extends T> source3,SingleSource<? extends T> source4)` Flattens four Singles into a single Flowable, without any transformation.
`static <T> Flowable<T>`	`mergeDelayError(Iterable<? extendsSingleSource<? extends T>> sources)` Merges an Iterable sequence of SingleSource instances into a single Flowable sequence, running all SingleSources at once and delaying any error(s) until all sources succeed or fail.
`static <T> Flowable<T>`	`mergeDelayError(Publisher<? extendsSingleSource<? extends T>> sources)` Merges a Flowable sequence of SingleSource instances into a single Flowable sequence, running all SingleSources at once and delaying any error(s) until all sources succeed or fail.
`static <T> Flowable<T>`	`mergeDelayError(SingleSource<? extends T> source1,SingleSource<? extends T> source2)` Flattens two Singles into a single Flowable, without any transformation, delaying any error(s) until all sources succeed or fail.
`static <T> Flowable<T>`	`mergeDelayError(SingleSource<? extends T> source1,SingleSource<? extends T> source2,SingleSource<? extends T> source3)` Flattens three Singles into a single Flowable, without any transformation, delaying any error(s) until all sources succeed or fail.
`static <T> Flowable<T>`	`mergeDelayError(SingleSource<? extends T> source1,SingleSource<? extends T> source2,SingleSource<? extends T> source3,SingleSource<? extends T> source4)` Flattens four Singles into a single Flowable, without any transformation, delaying any error(s) until all sources succeed or fail.
`Flowable<T>`	`mergeWith(SingleSource<? extendsT> other)` Flattens this and another Single into a single Flowable, without any transformation.
`static <T> Single<T>`	`never()` Returns a singleton instance of a never-signalling Single (only calls onSubscribe).
`Single<T>`	`observeOn(Scheduler scheduler)` Modifies a Single to emit its item (or notify of its error) on a specified`Scheduler`, asynchronously.
`Single<T>`	`onErrorResumeNext(Function<? superThrowable,? extendsSingleSource<? extendsT>> resumeFunctionInCaseOfError)` Instructs a Single to pass control to another Single rather than invoking`SingleObserver.onError(Throwable)` if it encounters an error.
`Single<T>`	`onErrorResumeNext(Single<? extendsT> resumeSingleInCaseOfError)` Instructs a Single to pass control to another Single rather than invoking`SingleObserver.onError(Throwable)` if it encounters an error.
`Single<T>`	`onErrorReturn(Function<Throwable,? extendsT> resumeFunction)` Instructs a Single to emit an item (returned by a specified function) rather than invoking`onError` if it encounters an error.
`Single<T>`	`onErrorReturnItem(T value)` Signals the specified value as success in case the current Single signals an error.
`Single<T>`	`onTerminateDetach()` Nulls out references to the upstream producer and downstream SingleObserver if the sequence is terminated or downstream calls dispose().
`Flowable<T>`	`repeat()` Repeatedly re-subscribes to the current Single and emits each success value.
`Flowable<T>`	`repeat(long times)` Re-subscribes to the current Single at most the given number of times and emits each success value.
`Flowable<T>`	`repeatUntil(BooleanSupplier stop)` Re-subscribes to the current Single until the given BooleanSupplier returns true.
`Flowable<T>`	`repeatWhen(Function<? superFlowable<Object>,? extendsPublisher<?>> handler)` Re-subscribes to the current Single if the Publisher returned by the handler function signals a value in response to a value signalled through the Flowable the handle receives.
`Single<T>`	`retry()` Repeatedly re-subscribes to the current Single indefinitely if it fails with an onError.
`Single<T>`	`retry(BiPredicate<? superInteger,? superThrowable> predicate)` Re-subscribe to the current Single if the given predicate returns true when the Single fails with an onError.
`Single<T>`	`retry(long times)` Repeatedly re-subscribe at most the specified times to the current Single if it fails with an onError.
`Single<T>`	`retry(long times,Predicate<? superThrowable> predicate)` Repeatedly re-subscribe at most times or until the predicate returns false, whichever happens first if it fails with an onError.
`Single<T>`	`retry(Predicate<? superThrowable> predicate)` Re-subscribe to the current Single if the given predicate returns true when the Single fails with an onError.
`Single<T>`	`retryWhen(Function<? superFlowable<Throwable>,? extendsPublisher<?>> handler)` Re-subscribes to the current Single if and when the Publisher returned by the handler function signals a value.
`Disposable`	`subscribe()` Subscribes to a Single but ignore its emission or notification.
`Disposable`	`subscribe(BiConsumer<? superT,? superThrowable> onCallback)` Subscribes to a Single and provides a composite callback to handle the item it emits or any error notification it issues.
`Disposable`	`subscribe(Consumer<? superT> onSuccess)` Subscribes to a Single and provides a callback to handle the item it emits.
`Disposable`	`subscribe(Consumer<? superT> onSuccess,Consumer<? superThrowable> onError)` Subscribes to a Single and provides callbacks to handle the item it emits or any error notification it issues.
`void`	`subscribe(SingleObserver<? superT> observer)` Subscribes the given SingleObserver to this SingleSource instance.
`protected abstract void`	`subscribeActual(SingleObserver<? superT> observer)` Implement this method in subclasses to handle the incoming`SingleObserver`s.
`Single<T>`	`subscribeOn(Scheduler scheduler)` Asynchronously subscribes subscribers to this Single on the specified`Scheduler`.
`<E extendsSingleObserver<? superT>> E`	`subscribeWith(E observer)` Subscribes a given SingleObserver (subclass) to this Single and returns the given SingleObserver as is.
`Single<T>`	`takeUntil(CompletableSource other)` Returns a Single that emits the item emitted by the source Single until a Completable terminates.
`<E> Single<T>`	`takeUntil(Publisher<E> other)` Returns a Single that emits the item emitted by the source Single until a Publisher emits an item.
`<E> Single<T>`	`takeUntil(SingleSource<? extends E> other)` Returns a Single that emits the item emitted by the source Single until a second Single emits an item.
`TestObserver<T>`	`test()` Creates a TestObserver and subscribes it to this Single.
`TestObserver<T>`	`test(boolean cancelled)` Creates a TestObserver optionally in cancelled state, then subscribes it to this Single.
`Single<T>`	`timeout(long timeout,TimeUnit unit)` Signals a TimeoutException if the current Single doesn't signal a success value within the specified timeout window.
`Single<T>`	`timeout(long timeout,TimeUnit unit,Scheduler scheduler)` Signals a TimeoutException if the current Single doesn't signal a success value within the specified timeout window.
`Single<T>`	`timeout(long timeout,TimeUnit unit,Scheduler scheduler,SingleSource<? extendsT> other)` Runs the current Single and if it doesn't signal within the specified timeout window, it is disposed and the other SingleSource subscribed to.
`Single<T>`	`timeout(long timeout,TimeUnit unit,SingleSource<? extendsT> other)` Runs the current Single and if it doesn't signal within the specified timeout window, it is disposed and the other SingleSource subscribed to.
`staticSingle<Long>`	`timer(long delay,TimeUnit unit)` Signals success with 0L value after the given delay for each SingleObserver.
`staticSingle<Long>`	`timer(long delay,TimeUnit unit,Scheduler scheduler)` Signals success with 0L value after the given delay for each SingleObserver.
`<R> R`	`to(Function<? superSingle<T>,R> convert)` Calls the specified converter function with the current Single instance during assembly time and returns its result.
`Completable`	`toCompletable()` Deprecated. see`ignoreElement()` instead, will be removed in 3.0
`Flowable<T>`	`toFlowable()` Converts this Single into a`Flowable`.
`Future<T>`	`toFuture()` Returns a`Future` representing the single value emitted by this`Single`.
`Maybe<T>`	`toMaybe()` Converts this Single into a`Maybe`.
`Observable<T>`	`toObservable()` Converts this Single into an`Observable`.
`static <T> Single<T>`	`unsafeCreate(SingleSource<T> onSubscribe)` Advanced use only: creates a Single instance without any safeguards by using a callback that is called with a SingleObserver.
`Single<T>`	`unsubscribeOn(Scheduler scheduler)` Returns a Single which makes sure when a SingleObserver disposes the Disposable, that call is propagated up on the specified scheduler.
`static <T,U> Single<T>`	`using(Callable<U> resourceSupplier,Function<? super U,? extendsSingleSource<? extends T>> singleFunction,Consumer<? super U> disposer)` Allows using and disposing a resource while running a SingleSource instance generated from that resource (similar to a try-with-resources).
`static <T,U> Single<T>`	`using(Callable<U> resourceSupplier,Function<? super U,? extendsSingleSource<? extends T>> singleFunction,Consumer<? super U> disposer, boolean eager)` Allows using and disposing a resource while running a SingleSource instance generated from that resource (similar to a try-with-resources).
`static <T> Single<T>`	`wrap(SingleSource<T> source)` Wraps a SingleSource instance into a new Single instance if not already a Single instance.
`static <T,R> Single<R>`	`zip(Iterable<? extendsSingleSource<? extends T>> sources,Function<? superObject[],? extends R> zipper)` Waits until all SingleSource sources provided by the Iterable sequence signal a success value and calls a zipper function with an array of these values to return a result to be emitted to downstream.
`static <T1,T2,R> Single<R>`	`zip(SingleSource<? extends T1> source1,SingleSource<? extends T2> source2,BiFunction<? super T1,? super T2,? extends R> zipper)` Returns a Single that emits the results of a specified combiner function applied to two items emitted by two other Singles.
`static <T1,T2,T3,R> Single<R>`	`zip(SingleSource<? extends T1> source1,SingleSource<? extends T2> source2,SingleSource<? extends T3> source3,Function3<? super T1,? super T2,? super T3,? extends R> zipper)` Returns a Single that emits the results of a specified combiner function applied to three items emitted by three other Singles.
`static <T1,T2,T3,T4,R> Single<R>`	`zip(SingleSource<? extends T1> source1,SingleSource<? extends T2> source2,SingleSource<? extends T3> source3,SingleSource<? extends T4> source4,Function4<? super T1,? super T2,? super T3,? super T4,? extends R> zipper)` Returns a Single that emits the results of a specified combiner function applied to four items emitted by four other Singles.
`static <T1,T2,T3,T4,T5,R> Single<R>`	`zip(SingleSource<? extends T1> source1,SingleSource<? extends T2> source2,SingleSource<? extends T3> source3,SingleSource<? extends T4> source4,SingleSource<? extends T5> source5,Function5<? super T1,? super T2,? super T3,? super T4,? super T5,? extends R> zipper)` Returns a Single that emits the results of a specified combiner function applied to five items emitted by five other Singles.
`static <T1,T2,T3,T4,T5,T6,R> Single<R>`	`zip(SingleSource<? extends T1> source1,SingleSource<? extends T2> source2,SingleSource<? extends T3> source3,SingleSource<? extends T4> source4,SingleSource<? extends T5> source5,SingleSource<? extends T6> source6,Function6<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? extends R> zipper)` Returns a Single that emits the results of a specified combiner function applied to six items emitted by six other Singles.
`static <T1,T2,T3,T4,T5,T6,T7,R> Single<R>`	`zip(SingleSource<? extends T1> source1,SingleSource<? extends T2> source2,SingleSource<? extends T3> source3,SingleSource<? extends T4> source4,SingleSource<? extends T5> source5,SingleSource<? extends T6> source6,SingleSource<? extends T7> source7,Function7<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? extends R> zipper)` Returns a Single that emits the results of a specified combiner function applied to seven items emitted by seven other Singles.
`static <T1,T2,T3,T4,T5,T6,T7,T8,R> Single<R>`	`zip(SingleSource<? extends T1> source1,SingleSource<? extends T2> source2,SingleSource<? extends T3> source3,SingleSource<? extends T4> source4,SingleSource<? extends T5> source5,SingleSource<? extends T6> source6,SingleSource<? extends T7> source7,SingleSource<? extends T8> source8,Function8<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? extends R> zipper)` Returns a Single that emits the results of a specified combiner function applied to eight items emitted by eight other Singles.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,R> Single<R>`	`zip(SingleSource<? extends T1> source1,SingleSource<? extends T2> source2,SingleSource<? extends T3> source3,SingleSource<? extends T4> source4,SingleSource<? extends T5> source5,SingleSource<? extends T6> source6,SingleSource<? extends T7> source7,SingleSource<? extends T8> source8,SingleSource<? extends T9> source9,Function9<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? super T9,? extends R> zipper)` Returns a Single that emits the results of a specified combiner function applied to nine items emitted by nine other Singles.
`static <T,R> Single<R>`	`zipArray(Function<? superObject[],? extends R> zipper,SingleSource<? extends T>... sources)` Waits until all SingleSource sources provided via an array signal a success value and calls a zipper function with an array of these values to return a result to be emitted to downstream.
`<U,R> Single<R>`	`zipWith(SingleSource<U> other,BiFunction<? superT,? super U,? extends R> zipper)` Returns a Single that emits the result of applying a specified function to the pair of items emitted by the source Single and another specified Single.

Methods inherited from class java.lang.Object
clone,equals,finalize,getClass,hashCode,notify,notifyAll,toString,wait,wait,wait

- Constructor Detail
 - Single
```
public Single()
```
- Method Detail
 - amb
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public static <T> Single<T> amb(Iterable<? extendsSingleSource<? extends T>> sources)
```
 Runs multiple SingleSources and signals the events of the first one that signals (disposing the rest).
 Scheduler:
 amb does not operate by default on a particularScheduler.
 Type Parameters:
 T - the value type
 Parameters:
 sources - the Iterable sequence of sources. A subscription to each source will occur in the same order as in this Iterable.
 Returns:
 the new Single instance
 Since:
 2.0
 - ambArray
```
@CheckReturnValue@SchedulerSupport(value="none")public static <T> Single<T> ambArray(SingleSource<? extends T>... sources)
```
 Runs multiple SingleSources and signals the events of the first one that signals (disposing the rest).
 Scheduler:
 ambArray does not operate by default on a particularScheduler.
 Type Parameters:
 T - the value type
 Parameters:
 sources - the array of sources. A subscription to each source will occur in the same order as in this array.
 Returns:
 the new Single instance
 Since:
 2.0
 - concat
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")@BackpressureSupport(value=FULL)public static <T> Flowable<T> concat(Iterable<? extendsSingleSource<? extends T>> sources)
```
 Concatenate the single values, in a non-overlapping fashion, of the SingleSources provided by an Iterable sequence.
 Backpressure:
 The returnedFlowable honors the backpressure of the downstream consumer.
 Scheduler:
 concat does not operate by default on a particularScheduler.
 Type Parameters:
 T - the value type
 Parameters:
 sources - the Iterable sequence of SingleSource instances
 Returns:
 the new Flowable instance
 Since:
 2.0
 - concat
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public static <T> Observable<T> concat(ObservableSource<? extendsSingleSource<? extends T>> sources)
```
 Concatenate the single values, in a non-overlapping fashion, of the SingleSources provided by an Observable sequence.
 Scheduler:
 concat does not operate by default on a particularScheduler.
 Type Parameters:
 T - the value type
 Parameters:
 sources - the ObservableSource of SingleSource instances
 Returns:
 the new Observable instance
 Since:
 2.0
 - concat
```
@CheckReturnValue@NonNull@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public static <T> Flowable<T> concat(Publisher<? extendsSingleSource<? extends T>> sources)
```
 Concatenate the single values, in a non-overlapping fashion, of the SingleSources provided by a Publisher sequence.
 Backpressure:
 The returnedFlowable honors the backpressure of the downstream consumer and the sourcesPublisher is expected to honor it as well.
 Scheduler:
 concat does not operate by default on a particularScheduler.
 Type Parameters:
 T - the value type
 Parameters:
 sources - the Publisher of SingleSource instances
 Returns:
 the new Flowable instance
 Since:
 2.0
 - concat
```
@CheckReturnValue@NonNull@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public static <T> Flowable<T> concat(Publisher<? extendsSingleSource<? extends T>> sources, int prefetch)
```
 Concatenate the single values, in a non-overlapping fashion, of the SingleSources provided by a Publisher sequence and prefetched by the specified amount.
 Backpressure:
 The returnedFlowable honors the backpressure of the downstream consumer and the sourcesPublisher is expected to honor it as well.
 Scheduler:
 concat does not operate by default on a particularScheduler.
 Type Parameters:
 T - the value type
 Parameters:
 sources - the Publisher of SingleSource instances
 prefetch - the number of SingleSources to prefetch from the Publisher
 Returns:
 the new Flowable instance
 Since:
 2.0
 - concat
```
@CheckReturnValue@NonNull@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public static <T> Flowable<T> concat(SingleSource<? extends T> source1,SingleSource<? extends T> source2)
```
 Returns a Flowable that emits the items emitted by two Singles, one after the other.
 Backpressure:
 The returnedFlowable honors the backpressure of the downstream consumer.
 Scheduler:
 concat does not operate by default on a particularScheduler.
 Type Parameters:
 T - the common value type
 Parameters:
 source1 - a Single to be concatenated
 source2 - a Single to be concatenated
 Returns:
 a Flowable that emits items emitted by the two source Singles, one after the other.
 See Also:
 ReactiveX operators documentation: Concat
 - concat
```
@CheckReturnValue@NonNull@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public static <T> Flowable<T> concat(SingleSource<? extends T> source1,SingleSource<? extends T> source2,SingleSource<? extends T> source3)
```
 Returns a Flowable that emits the items emitted by three Singles, one after the other.
 Backpressure:
 The returnedFlowable honors the backpressure of the downstream consumer.
 Scheduler:
 concat does not operate by default on a particularScheduler.
 Type Parameters:
 T - the common value type
 Parameters:
 source1 - a Single to be concatenated
 source2 - a Single to be concatenated
 source3 - a Single to be concatenated
 Returns:
 a Flowable that emits items emitted by the three source Singles, one after the other.
 See Also:
 ReactiveX operators documentation: Concat
 - concat
```
@CheckReturnValue@NonNull@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public static <T> Flowable<T> concat(SingleSource<? extends T> source1,SingleSource<? extends T> source2,SingleSource<? extends T> source3,SingleSource<? extends T> source4)
```
 Returns a Flowable that emits the items emitted by four Singles, one after the other.
 Backpressure:
 The returnedFlowable honors the backpressure of the downstream consumer.
 Scheduler:
 concat does not operate by default on a particularScheduler.
 Type Parameters:
 T - the common value type
 Parameters:
 source1 - a Single to be concatenated
 source2 - a Single to be concatenated
 source3 - a Single to be concatenated
 source4 - a Single to be concatenated
 Returns:
 a Flowable that emits items emitted by the four source Singles, one after the other.
 See Also:
 ReactiveX operators documentation: Concat
 - concatArray
```
@CheckReturnValue@NonNull@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public static <T> Flowable<T> concatArray(SingleSource<? extends T>... sources)
```
 Concatenate the single values, in a non-overlapping fashion, of the SingleSources provided in an array.
 Backpressure:
 The returnedFlowable honors the backpressure of the downstream consumer.
 Scheduler:
 concatArray does not operate by default on a particularScheduler.
 Type Parameters:
 T - the value type
 Parameters:
 sources - the array of SingleSource instances
 Returns:
 the new Flowable instance
 Since:
 2.0
 - concatArrayEager
```
@BackpressureSupport(value=FULL)@CheckReturnValue@NonNull@SchedulerSupport(value="none")public static <T> Flowable<T> concatArrayEager(SingleSource<? extends T>... sources)
```
 Concatenates a sequence of SingleSource eagerly into a single stream of values.
 Eager concatenation means that once a subscriber subscribes, this operator subscribes to all of the source SingleSources. The operator buffers the value emitted by these SingleSources and then drains them in order, each one after the previous one completes.
 Backpressure:
 The operator honors backpressure from downstream.
 Scheduler:
 This method does not operate by default on a particularScheduler.
 Type Parameters:
 T - the value type
 Parameters:
 sources - a sequence of Single that need to be eagerly concatenated
 Returns:
 the new Flowable instance with the specified concatenation behavior
 - concatEager
```
@BackpressureSupport(value=FULL)@CheckReturnValue@NonNull@SchedulerSupport(value="none")public static <T> Flowable<T> concatEager(Publisher<? extendsSingleSource<? extends T>> sources)
```
 Concatenates a Publisher sequence of SingleSources eagerly into a single stream of values.
 Eager concatenation means that once a subscriber subscribes, this operator subscribes to all of the emitted source Publishers as they are observed. The operator buffers the values emitted by these Publishers and then drains them in order, each one after the previous one completes.
 Backpressure:
 Backpressure is honored towards the downstream and the outer Publisher is expected to support backpressure. Violating this assumption, the operator will signalMissingBackpressureException.
 Scheduler:
 This method does not operate by default on a particularScheduler.
 Type Parameters:
 T - the value type
 Parameters:
 sources - a sequence of Publishers that need to be eagerly concatenated
 Returns:
 the new Publisher instance with the specified concatenation behavior
 - concatEager
```
@BackpressureSupport(value=FULL)@CheckReturnValue@NonNull@SchedulerSupport(value="none")public static <T> Flowable<T> concatEager(Iterable<? extendsSingleSource<? extends T>> sources)
```
 Concatenates a sequence of SingleSources eagerly into a single stream of values.
 Eager concatenation means that once a subscriber subscribes, this operator subscribes to all of the source SingleSources. The operator buffers the values emitted by these SingleSources and then drains them in order, each one after the previous one completes.
 Backpressure:
 Backpressure is honored towards the downstream.
 Scheduler:
 This method does not operate by default on a particularScheduler.
 Type Parameters:
 T - the value type
 Parameters:
 sources - a sequence of SingleSource that need to be eagerly concatenated
 Returns:
 the new Flowable instance with the specified concatenation behavior
 - create
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public static <T> Single<T> create(SingleOnSubscribe<T> source)
```
 Provides an API (via a cold Single) that bridges the reactive world with the callback-style world.
 Example:
```
 Single.<Event>create(emitter -> { Callback listener = new Callback() { @Override public void onEvent(Event e) { emitter.onSuccess(e); } @Override public void onFailure(Exception e) { emitter.onError(e); } }; AutoCloseable c = api.someMethod(listener); emitter.setCancellable(c::close); });
```
 Scheduler:
 create does not operate by default on a particularScheduler.
 Type Parameters:
 T - the value type
 Parameters:
 source - the emitter that is called when a SingleObserver subscribes to the returnedSingle
 Returns:
 the new Single instance
 See Also:
 SingleOnSubscribe,Cancellable
 - defer
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public static <T> Single<T> defer(Callable<? extendsSingleSource<? extends T>> singleSupplier)
```
 Calls aCallable for each individualSingleObserver to return the actualSingleSource to be subscribed to.
 Scheduler:
 defer does not operate by default on a particularScheduler.
 Type Parameters:
 T - the value type
 Parameters:
 singleSupplier - theCallable that is called for each individualSingleObserver and returns a SingleSource instance to subscribe to
 Returns:
 the new Single instance
 - error
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public static <T> Single<T> error(Callable<? extendsThrowable> errorSupplier)
```
 Signals a Throwable returned by the callback function for each individual SingleObserver.
 Scheduler:
 error does not operate by default on a particularScheduler.
 Type Parameters:
 T - the value type
 Parameters:
 errorSupplier - the callable that is called for each individual SingleObserver and returns a Throwable instance to be emitted.
 Returns:
 the new Single instance
 - error
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public static <T> Single<T> error(Throwable exception)
```
 Returns a Single that invokes a subscriber'sonError method when the subscriber subscribes to it.
 Scheduler:
 error does not operate by default on a particularScheduler.
 Type Parameters:
 T - the type of the item (ostensibly) emitted by the Single
 Parameters:
 exception - the particular Throwable to pass toonError
 Returns:
 a Single that invokes the subscriber'sonError method when the subscriber subscribes to it
 See Also:
 ReactiveX operators documentation: Throw
 - fromCallable
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public static <T> Single<T> fromCallable(Callable<? extends T> callable)
```
 Returns aSingle that invokes passed function and emits its result for each new SingleObserver that subscribes.
 Allows you to defer execution of passed function until SingleObserver subscribes to theSingle. It makes passed function "lazy". Result of the function invocation will be emitted by theSingle.
 Scheduler:
 fromCallable does not operate by default on a particularScheduler.
 Error handling:
 If theCallable throws an exception, the respectiveThrowable is delivered to the downstream viaSingleObserver.onError(Throwable), except when the downstream has disposed thisSingle source. In this latter case, theThrowable is delivered to the global error handler viaRxJavaPlugins.onError(Throwable) as anUndeliverableException.
 Type Parameters:
 T - the type of the item emitted by theSingle.
 Parameters:
 callable - function which execution should be deferred, it will be invoked when SingleObserver will subscribe to theSingle.
 Returns:
 aSingle whoseSingleObservers' subscriptions trigger an invocation of the given function.
 - fromFuture
```
@CheckReturnValue@SchedulerSupport(value="none")public static <T> Single<T> fromFuture(Future<? extends T> future)
```
 Converts aFuture into aSingle.
 You can convert any object that supports theFuture interface into a Single that emits the return value of theFuture.get() method of that object, by passing the object into thefrom method.
 Important note: This Single is blocking; you cannot dispose it.
 Scheduler:
 fromFuture does not operate by default on a particularScheduler.
 Type Parameters:
 T - the type of object that theFuture returns, and also the type of item to be emitted by the resultingSingle
 Parameters:
 future - the sourceFuture
 Returns:
 aSingle that emits the item from the sourceFuture
 See Also:
 ReactiveX operators documentation: From
 - fromFuture
```
@CheckReturnValue@SchedulerSupport(value="none")public static <T> Single<T> fromFuture(Future<? extends T> future, long timeout,TimeUnit unit)
```
 Converts aFuture into aSingle, with a timeout on the Future.
 You can convert any object that supports theFuture interface into aSingle that emits the return value of theFuture.get() method of that object, by passing the object into thefrom method.
 Important note: ThisSingle is blocking; you cannot dispose it.
 Scheduler:
 fromFuture does not operate by default on a particularScheduler.
 Type Parameters:
 T - the type of object that theFuture returns, and also the type of item to be emitted by the resultingSingle
 Parameters:
 future - the sourceFuture
 timeout - the maximum time to wait before callingget
 unit - theTimeUnit of thetimeout argument
 Returns:
 aSingle that emits the item from the sourceFuture
 See Also:
 ReactiveX operators documentation: From
 - fromFuture
```
@CheckReturnValue@SchedulerSupport(value="custom")public static <T> Single<T> fromFuture(Future<? extends T> future, long timeout,TimeUnit unit,Scheduler scheduler)
```
 Converts aFuture into aSingle, with a timeout on the Future.
 You can convert any object that supports theFuture interface into aSingle that emits the return value of theFuture.get() method of that object, by passing the object into thefrom method.
 Important note: ThisSingle is blocking; you cannot dispose it.
 Scheduler:
 You specify theScheduler where the blocking wait will happen.
 Type Parameters:
 T - the type of object that theFuture returns, and also the type of item to be emitted by the resultingSingle
 Parameters:
 future - the sourceFuture
 timeout - the maximum time to wait before callingget
 unit - theTimeUnit of thetimeout argument
 scheduler - the Scheduler to use for the blocking wait
 Returns:
 aSingle that emits the item from the sourceFuture
 See Also:
 ReactiveX operators documentation: From
 - fromFuture
```
@CheckReturnValue@SchedulerSupport(value="custom")public static <T> Single<T> fromFuture(Future<? extends T> future,Scheduler scheduler)
```
 Converts aFuture, operating on a specifiedScheduler, into aSingle.
 You can convert any object that supports theFuture interface into aSingle that emits the return value of theFuture.get() method of that object, by passing the object into thefrom method.
 Scheduler:
 You specify whichScheduler this operator will use.
 Type Parameters:
 T - the type of object that theFuture returns, and also the type of item to be emitted by the resultingSingle
 Parameters:
 future - the sourceFuture
 scheduler - theScheduler to wait for the Future on. Use a Scheduler such asSchedulers.io() that can block and wait on the Future
 Returns:
 aSingle that emits the item from the sourceFuture
 See Also:
 ReactiveX operators documentation: From
 - fromPublisher
```
@BackpressureSupport(value=UNBOUNDED_IN)@CheckReturnValue@NonNull@SchedulerSupport(value="none")public static <T> Single<T> fromPublisher(Publisher<? extends T> publisher)
```
 Wraps a specific Publisher into a Single and signals its single element or error.
 If the source Publisher is empty, a NoSuchElementException is signalled. If the source has more than one element, an IndexOutOfBoundsException is signalled.
 ThePublisher must follow theReactive Streams specification. Violating the specification may result in undefined behavior.
 If possible, usecreate(SingleOnSubscribe) to create a source-likeSingle instead.
 Note that even thoughPublisher appears to be a functional interface, it is not recommended to implement it through a lambda as the specification requires state management that is not achievable with a stateless lambda.
 Backpressure:
 Thepublisher is consumed in an unbounded fashion but will be cancelled if it produced more than one item.
 Scheduler:
 fromPublisher does not operate by default on a particularScheduler.
 Type Parameters:
 T - the value type
 Parameters:
 publisher - the source Publisher instance, not null
 Returns:
 the new Single instance
 See Also:
 create(SingleOnSubscribe)
 - fromObservable
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public static <T> Single<T> fromObservable(ObservableSource<? extends T> observableSource)
```
 Wraps a specific ObservableSource into a Single and signals its single element or error.
 If the ObservableSource is empty, a NoSuchElementException is signalled. If the source has more than one element, an IndexOutOfBoundsException is signalled.
 Scheduler:
 fromObservable does not operate by default on a particularScheduler.
 Type Parameters:
 T - the type of the item emitted by theSingle.
 Parameters:
 observableSource - the source Observable, not null
 Returns:
 the new Single instance
 - just
```
@CheckReturnValue@SchedulerSupport(value="none")@NonNullpublic static <T> Single<T> just(T item)
```
 Returns aSingle that emits a specified item.
 To convert any object into aSingle that emits that object, pass that object into thejust method.
 Scheduler:
 just does not operate by default on a particularScheduler.
 Type Parameters:
 T - the type of that item
 Parameters:
 item - the item to emit
 Returns:
 aSingle that emitsitem
 See Also:
 ReactiveX operators documentation: Just
 - merge
```
@CheckReturnValue@NonNull@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public static <T> Flowable<T> merge(Iterable<? extendsSingleSource<? extends T>> sources)
```
 Merges an Iterable sequence of SingleSource instances into a single Flowable sequence, running all SingleSources at once.
 Backpressure:
 The returnedFlowable honors the backpressure of the downstream consumer.
 Scheduler:
 merge does not operate by default on a particularScheduler.
 Error handling:
 If any of the sourceSingleSources signal aThrowable viaonError, the resultingFlowable terminates with thatThrowable and all other sourceSingleSources are disposed. If more than oneSingleSource signals an error, the resultingFlowable may terminate with the first one's error or, depending on the concurrency of the sources, may terminate with aCompositeException containing two or more of the various error signals.Throwables that didn't make into the composite will be sent (individually) to the global error handler viaRxJavaPlugins.onError(Throwable) method asUndeliverableException errors. Similarly,Throwables signaled by source(s) after the returnedFlowable has been cancelled or terminated with a (composite) error will be sent to the same global error handler. UsemergeDelayError(Iterable) to merge sources and terminate only when all sourceSingleSources have completed or failed with an error.
 Type Parameters:
 T - the common and resulting value type
 Parameters:
 sources - the Iterable sequence of SingleSource sources
 Returns:
 the new Flowable instance
 Since:
 2.0
 See Also:
 mergeDelayError(Iterable)
 - merge
```
@CheckReturnValue@NonNull@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public static <T> Flowable<T> merge(Publisher<? extendsSingleSource<? extends T>> sources)
```
 Merges a Flowable sequence of SingleSource instances into a single Flowable sequence, running all SingleSources at once.
 Backpressure:
 The returnedFlowable honors the backpressure of the downstream consumer.
 Scheduler:
 merge does not operate by default on a particularScheduler.
 Error handling:
 If any of the sourceSingleSources signal aThrowable viaonError, the resultingFlowable terminates with thatThrowable and all other sourceSingleSources are disposed. If more than oneSingleSource signals an error, the resultingFlowable may terminate with the first one's error or, depending on the concurrency of the sources, may terminate with aCompositeException containing two or more of the various error signals.Throwables that didn't make into the composite will be sent (individually) to the global error handler viaRxJavaPlugins.onError(Throwable) method asUndeliverableException errors. Similarly,Throwables signaled by source(s) after the returnedFlowable has been cancelled or terminated with a (composite) error will be sent to the same global error handler. UsemergeDelayError(Publisher) to merge sources and terminate only when all sourceSingleSources have completed or failed with an error.
 Type Parameters:
 T - the common and resulting value type
 Parameters:
 sources - the Flowable sequence of SingleSource sources
 Returns:
 the new Flowable instance
 Since:
 2.0
 See Also:
 mergeDelayError(Publisher)
 - merge
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public static <T> Single<T> merge(SingleSource<? extendsSingleSource<? extends T>> source)
```
 Flattens aSingle that emits aSingle into a singleSingle that emits the item emitted by the nestedSingle, without any transformation.
 Scheduler:
 merge does not operate by default on a particularScheduler.
 The resultingSingle emits the outer source's or the innerSingleSource'sThrowable as is. Unlike the othermerge() operators, this operator won't and can't produce aCompositeException because there is only one possibility for the outer or the innerSingleSource to emit anonError signal. Therefore, there is no need for amergeDelayError(SingleSource<SingleSource<T>>) operator.
 Type Parameters:
 T - the value type of the sources and the output
 Parameters:
 source - aSingle that emits aSingle
 Returns:
 aSingle that emits the item that is the result of flattening theSingle emitted bysource
 See Also:
 ReactiveX operators documentation: Merge
 - merge
```
@CheckReturnValue@NonNull@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public static <T> Flowable<T> merge(SingleSource<? extends T> source1,SingleSource<? extends T> source2)
```
 Flattens two Singles into a single Flowable, without any transformation.
 You can combine items emitted by multiple Singles so that they appear as a single Flowable, by using themerge method.
 Backpressure:
 The returnedFlowable honors the backpressure of the downstream consumer.
 Scheduler:
 merge does not operate by default on a particularScheduler.
 Error handling:
 If any of the sourceSingleSources signal aThrowable viaonError, the resultingFlowable terminates with thatThrowable and all other sourceSingleSources are disposed. If more than oneSingleSource signals an error, the resultingFlowable may terminate with the first one's error or, depending on the concurrency of the sources, may terminate with aCompositeException containing two or more of the various error signals.Throwables that didn't make into the composite will be sent (individually) to the global error handler viaRxJavaPlugins.onError(Throwable) method asUndeliverableException errors. Similarly,Throwables signaled by source(s) after the returnedFlowable has been cancelled or terminated with a (composite) error will be sent to the same global error handler. UsemergeDelayError(SingleSource, SingleSource) to merge sources and terminate only when all sourceSingleSources have completed or failed with an error.
 Type Parameters:
 T - the common value type
 Parameters:
 source1 - a SingleSource to be merged
 source2 - a SingleSource to be merged
 Returns:
 a Flowable that emits all of the items emitted by the source Singles
 See Also:
 ReactiveX operators documentation: Merge,mergeDelayError(SingleSource, SingleSource)
 - merge
```
@CheckReturnValue@NonNull@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public static <T> Flowable<T> merge(SingleSource<? extends T> source1,SingleSource<? extends T> source2,SingleSource<? extends T> source3)
```
 Flattens three Singles into a single Flowable, without any transformation.
 You can combine items emitted by multiple Singles so that they appear as a single Flowable, by using themerge method.
 Backpressure:
 The returnedFlowable honors the backpressure of the downstream consumer.
 Scheduler:
 merge does not operate by default on a particularScheduler.
 Error handling:
 If any of the sourceSingleSources signal aThrowable viaonError, the resultingFlowable terminates with thatThrowable and all other sourceSingleSources are disposed. If more than oneSingleSource signals an error, the resultingFlowable may terminate with the first one's error or, depending on the concurrency of the sources, may terminate with aCompositeException containing two or more of the various error signals.Throwables that didn't make into the composite will be sent (individually) to the global error handler viaRxJavaPlugins.onError(Throwable) method asUndeliverableException errors. Similarly,Throwables signaled by source(s) after the returnedFlowable has been cancelled or terminated with a (composite) error will be sent to the same global error handler. UsemergeDelayError(SingleSource, SingleSource, SingleSource) to merge sources and terminate only when all sourceSingleSources have completed or failed with an error.
 Type Parameters:
 T - the common value type
 Parameters:
 source1 - a SingleSource to be merged
 source2 - a SingleSource to be merged
 source3 - a SingleSource to be merged
 Returns:
 a Flowable that emits all of the items emitted by the source Singles
 See Also:
 ReactiveX operators documentation: Merge,mergeDelayError(SingleSource, SingleSource, SingleSource)
 - merge
```
@CheckReturnValue@NonNull@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public static <T> Flowable<T> merge(SingleSource<? extends T> source1,SingleSource<? extends T> source2,SingleSource<? extends T> source3,SingleSource<? extends T> source4)
```
 Flattens four Singles into a single Flowable, without any transformation.
 You can combine items emitted by multiple Singles so that they appear as a single Flowable, by using themerge method.
 Backpressure:
 The returnedFlowable honors the backpressure of the downstream consumer.
 Scheduler:
 merge does not operate by default on a particularScheduler.
 Error handling:
 If any of the sourceSingleSources signal aThrowable viaonError, the resultingFlowable terminates with thatThrowable and all other sourceSingleSources are disposed. If more than oneSingleSource signals an error, the resultingFlowable may terminate with the first one's error or, depending on the concurrency of the sources, may terminate with aCompositeException containing two or more of the various error signals.Throwables that didn't make into the composite will be sent (individually) to the global error handler viaRxJavaPlugins.onError(Throwable) method asUndeliverableException errors. Similarly,Throwables signaled by source(s) after the returnedFlowable has been cancelled or terminated with a (composite) error will be sent to the same global error handler. UsemergeDelayError(SingleSource, SingleSource, SingleSource, SingleSource) to merge sources and terminate only when all sourceSingleSources have completed or failed with an error.
 Type Parameters:
 T - the common value type
 Parameters:
 source1 - a SingleSource to be merged
 source2 - a SingleSource to be merged
 source3 - a SingleSource to be merged
 source4 - a SingleSource to be merged
 Returns:
 a Flowable that emits all of the items emitted by the source Singles
 See Also:
 ReactiveX operators documentation: Merge,mergeDelayError(SingleSource, SingleSource, SingleSource, SingleSource)
 - mergeDelayError
```
@CheckReturnValue@NonNull@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public static <T> Flowable<T> mergeDelayError(Iterable<? extendsSingleSource<? extends T>> sources)
```
 Merges an Iterable sequence of SingleSource instances into a single Flowable sequence, running all SingleSources at once and delaying any error(s) until all sources succeed or fail.
 Backpressure:
 The returnedFlowable honors the backpressure of the downstream consumer.
 Scheduler:
 mergeDelayError does not operate by default on a particularScheduler.
 History: 2.1.9 - experimental
 Type Parameters:
 T - the common and resulting value type
 Parameters:
 sources - the Iterable sequence of SingleSource sources
 Returns:
 the new Flowable instance
 Since:
 2.2
 See Also:
 merge(Iterable)
 - mergeDelayError
```
@CheckReturnValue@NonNull@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public static <T> Flowable<T> mergeDelayError(Publisher<? extendsSingleSource<? extends T>> sources)
```
 Merges a Flowable sequence of SingleSource instances into a single Flowable sequence, running all SingleSources at once and delaying any error(s) until all sources succeed or fail.
 Backpressure:
 The returnedFlowable honors the backpressure of the downstream consumer.
 Scheduler:
 mergeDelayError does not operate by default on a particularScheduler.
 History: 2.1.9 - experimental
 Type Parameters:
 T - the common and resulting value type
 Parameters:
 sources - the Flowable sequence of SingleSource sources
 Returns:
 the new Flowable instance
 Since:
 2.2
 See Also:
 merge(Publisher)
 - mergeDelayError
```
@CheckReturnValue@NonNull@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public static <T> Flowable<T> mergeDelayError(SingleSource<? extends T> source1,SingleSource<? extends T> source2)
```
 Flattens two Singles into a single Flowable, without any transformation, delaying any error(s) until all sources succeed or fail.
 You can combine items emitted by multiple Singles so that they appear as a single Flowable, by using themergeDelayError method.
 Backpressure:
 The returnedFlowable honors the backpressure of the downstream consumer.
 Scheduler:
 mergeDelayError does not operate by default on a particularScheduler.
 History: 2.1.9 - experimental
 Type Parameters:
 T - the common value type
 Parameters:
 source1 - a SingleSource to be merged
 source2 - a SingleSource to be merged
 Returns:
 a Flowable that emits all of the items emitted by the source Singles
 Since:
 2.2
 See Also:
 ReactiveX operators documentation: Merge,merge(SingleSource, SingleSource)
 - mergeDelayError
```
@CheckReturnValue@NonNull@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public static <T> Flowable<T> mergeDelayError(SingleSource<? extends T> source1,SingleSource<? extends T> source2,SingleSource<? extends T> source3)
```
 Flattens three Singles into a single Flowable, without any transformation, delaying any error(s) until all sources succeed or fail.
 You can combine items emitted by multiple Singles so that they appear as a single Flowable, by using themergeDelayError method.
 Backpressure:
 The returnedFlowable honors the backpressure of the downstream consumer.
 Scheduler:
 mergeDelayError does not operate by default on a particularScheduler.
 History: 2.1.9 - experimental
 Type Parameters:
 T - the common value type
 Parameters:
 source1 - a SingleSource to be merged
 source2 - a SingleSource to be merged
 source3 - a SingleSource to be merged
 Returns:
 a Flowable that emits all of the items emitted by the source Singles
 Since:
 2.2
 See Also:
 ReactiveX operators documentation: Merge,merge(SingleSource, SingleSource, SingleSource)
 - mergeDelayError
```
@CheckReturnValue@NonNull@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public static <T> Flowable<T> mergeDelayError(SingleSource<? extends T> source1,SingleSource<? extends T> source2,SingleSource<? extends T> source3,SingleSource<? extends T> source4)
```
 Flattens four Singles into a single Flowable, without any transformation, delaying any error(s) until all sources succeed or fail.
 You can combine items emitted by multiple Singles so that they appear as a single Flowable, by using themergeDelayError method.
 Backpressure:
 The returnedFlowable honors the backpressure of the downstream consumer.
 Scheduler:
 mergeDelayError does not operate by default on a particularScheduler.
 History: 2.1.9 - experimental
 Type Parameters:
 T - the common value type
 Parameters:
 source1 - a SingleSource to be merged
 source2 - a SingleSource to be merged
 source3 - a SingleSource to be merged
 source4 - a SingleSource to be merged
 Returns:
 a Flowable that emits all of the items emitted by the source Singles
 Since:
 2.2
 See Also:
 ReactiveX operators documentation: Merge,merge(SingleSource, SingleSource, SingleSource, SingleSource)
 - never
```
@CheckReturnValue@SchedulerSupport(value="none")public static <T> Single<T> never()
```
 Returns a singleton instance of a never-signalling Single (only calls onSubscribe).
 Scheduler:
 never does not operate by default on a particularScheduler.
 Type Parameters:
 T - the target value type
 Returns:
 the singleton never instance
 Since:
 2.0
 - timer
```
@CheckReturnValue@SchedulerSupport(value="io.reactivex:computation")public static Single<Long> timer(long delay,TimeUnit unit)
```
 Signals success with 0L value after the given delay for each SingleObserver.
 Scheduler:
 timer operates by default on thecomputationScheduler.
 Parameters:
 delay - the delay amount
 unit - the time unit of the delay
 Returns:
 the new Single instance
 Since:
 2.0
 - timer
```
@CheckReturnValue@NonNull@SchedulerSupport(value="custom")public static Single<Long> timer(long delay,TimeUnit unit,Scheduler scheduler)
```
 Signals success with 0L value after the given delay for each SingleObserver.
 Scheduler:
 you specify theScheduler to signal on.
 Parameters:
 delay - the delay amount
 unit - the time unit of the delay
 scheduler - the scheduler where the single 0L will be emitted
 Returns:
 the new Single instance
 Throws:
 NullPointerException - if unit is null, or if scheduler is null
 Since:
 2.0
 - equals
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public static <T> Single<Boolean> equals(SingleSource<? extends T> first,SingleSource<? extends T> second)
```
 Compares two SingleSources and emits true if they emit the same value (compared via Object.equals).
 Scheduler:
 equals does not operate by default on a particularScheduler.
 Type Parameters:
 T - the common value type
 Parameters:
 first - the first SingleSource instance
 second - the second SingleSource instance
 Returns:
 the new Single instance
 Since:
 2.0
 - unsafeCreate
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public static <T> Single<T> unsafeCreate(SingleSource<T> onSubscribe)
```
 Advanced use only: creates a Single instance without any safeguards by using a callback that is called with a SingleObserver.
 Scheduler:
 unsafeCreate does not operate by default on a particularScheduler.
 Type Parameters:
 T - the value type
 Parameters:
 onSubscribe - the function that is called with the subscribing SingleObserver
 Returns:
 the new Single instance
 Throws:
 IllegalArgumentException - ifsource is a subclass ofSingle; such instances don't need conversion and is possibly a port remnant from 1.x or one should usehide() instead.
 Since:
 2.0
 - using
```
@CheckReturnValue@SchedulerSupport(value="none")public static <T,U> Single<T> using(Callable resourceSupplier,Function<? super U,? extendsSingleSource<? extends T>> singleFunction,Consumer<? super U> disposer)
```
 Allows using and disposing a resource while running a SingleSource instance generated from that resource (similar to a try-with-resources).
 Scheduler:
 using does not operate by default on a particularScheduler.
 Type Parameters:
 T - the value type of the SingleSource generated
 U - the resource type
 Parameters:
 resourceSupplier - the Callable called for each SingleObserver to generate a resource Object
 singleFunction - the function called with the returned resource Object fromresourceSupplier and should return a SingleSource instance to be run by the operator
 disposer - the consumer of the generated resource that is called exactly once for that particular resource when the generated SingleSource terminates (successfully or with an error) or gets disposed.
 Returns:
 the new Single instance
 Since:
 2.0
 - using
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public static <T,U> Single<T> using(Callable resourceSupplier,Function<? super U,? extendsSingleSource<? extends T>> singleFunction,Consumer<? super U> disposer, boolean eager)
```
 Allows using and disposing a resource while running a SingleSource instance generated from that resource (similar to a try-with-resources).
 Scheduler:
 using does not operate by default on a particularScheduler.
 Type Parameters:
 T - the value type of the SingleSource generated
 U - the resource type
 Parameters:
 resourceSupplier - the Callable called for each SingleObserver to generate a resource Object
 singleFunction - the function called with the returned resource Object fromresourceSupplier and should return a SingleSource instance to be run by the operator
 disposer - the consumer of the generated resource that is called exactly once for that particular resource when the generated SingleSource terminates (successfully or with an error) or gets disposed.
 eager - if true, the disposer is called before the terminal event is signalled if false, the disposer is called after the terminal event is delivered to downstream
 Returns:
 the new Single instance
 Since:
 2.0
 - wrap
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public static <T> Single<T> wrap(SingleSource<T> source)
```
 Wraps a SingleSource instance into a new Single instance if not already a Single instance.
 Scheduler:
 wrap does not operate by default on a particularScheduler.
 Type Parameters:
 T - the value type
 Parameters:
 source - the source to wrap
 Returns:
 the Single wrapper or the source cast to Single (if possible)
 - zip
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public static <T,R> Single<R> zip(Iterable<? extendsSingleSource<? extends T>> sources,Function<? superObject[],? extends R> zipper)
```
 Waits until all SingleSource sources provided by the Iterable sequence signal a success value and calls a zipper function with an array of these values to return a result to be emitted to downstream.
 If theIterable ofSingleSources is empty aNoSuchElementException error is signalled after subscription.
 Note on method signature: since Java doesn't allow creating a generic array withnew T[], the implementation of this operator has to create anObject[] instead. Unfortunately, aFunction<Integer[], R> passed to the method would trigger aClassCastException.
 If any of the SingleSources signal an error, all other SingleSources get disposed and the error emitted to downstream immediately.
 Scheduler:
 zip does not operate by default on a particularScheduler.
 Type Parameters:
 T - the common value type
 R - the result value type
 Parameters:
 sources - the Iterable sequence of SingleSource instances. An empty sequence will result in anonError signal ofNoSuchElementException.
 zipper - the function that receives an array with values from each SingleSource and should return a value to be emitted to downstream
 Returns:
 the new Single instance
 Since:
 2.0
 - zip
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public static <T1,T2,R> Single<R> zip(SingleSource<? extends T1> source1,SingleSource<? extends T2> source2,BiFunction<? super T1,? super T2,? extends R> zipper)
```
 Returns a Single that emits the results of a specified combiner function applied to two items emitted by two other Singles.
 Scheduler:
 zip does not operate by default on a particularScheduler.
 Type Parameters:
 T1 - the first source Single's value type
 T2 - the second source Single's value type
 R - the result value type
 Parameters:
 source1 - the first source Single
 source2 - a second source Single
 zipper - a function that, when applied to the item emitted by each of the source Singles, results in an item that will be emitted by the resulting Single
 Returns:
 a Single that emits the zipped results
 See Also:
 ReactiveX operators documentation: Zip
 - zip
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public static <T1,T2,T3,R> Single<R> zip(SingleSource<? extends T1> source1,SingleSource<? extends T2> source2,SingleSource<? extends T3> source3,Function3<? super T1,? super T2,? super T3,? extends R> zipper)
```
 Returns a Single that emits the results of a specified combiner function applied to three items emitted by three other Singles.
 Scheduler:
 zip does not operate by default on a particularScheduler.
 Type Parameters:
 T1 - the first source Single's value type
 T2 - the second source Single's value type
 T3 - the third source Single's value type
 R - the result value type
 Parameters:
 source1 - the first source Single
 source2 - a second source Single
 source3 - a third source Single
 zipper - a function that, when applied to the item emitted by each of the source Singles, results in an item that will be emitted by the resulting Single
 Returns:
 a Single that emits the zipped results
 See Also:
 ReactiveX operators documentation: Zip
 - zip
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public static <T1,T2,T3,T4,R> Single<R> zip(SingleSource<? extends T1> source1,SingleSource<? extends T2> source2,SingleSource<? extends T3> source3,SingleSource<? extends T4> source4,Function4<? super T1,? super T2,? super T3,? super T4,? extends R> zipper)
```
 Returns a Single that emits the results of a specified combiner function applied to four items emitted by four other Singles.
 Scheduler:
 zip does not operate by default on a particularScheduler.
 Type Parameters:
 T1 - the first source Single's value type
 T2 - the second source Single's value type
 T3 - the third source Single's value type
 T4 - the fourth source Single's value type
 R - the result value type
 Parameters:
 source1 - the first source Single
 source2 - a second source Single
 source3 - a third source Single
 source4 - a fourth source Single
 zipper - a function that, when applied to the item emitted by each of the source Singles, results in an item that will be emitted by the resulting Single
 Returns:
 a Single that emits the zipped results
 See Also:
 ReactiveX operators documentation: Zip
 - zip
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public static <T1,T2,T3,T4,T5,R> Single<R> zip(SingleSource<? extends T1> source1,SingleSource<? extends T2> source2,SingleSource<? extends T3> source3,SingleSource<? extends T4> source4,SingleSource<? extends T5> source5,Function5<? super T1,? super T2,? super T3,? super T4,? super T5,? extends R> zipper)
```
 Returns a Single that emits the results of a specified combiner function applied to five items emitted by five other Singles.
 Scheduler:
 zip does not operate by default on a particularScheduler.
 Type Parameters:
 T1 - the first source Single's value type
 T2 - the second source Single's value type
 T3 - the third source Single's value type
 T4 - the fourth source Single's value type
 T5 - the fifth source Single's value type
 R - the result value type
 Parameters:
 source1 - the first source Single
 source2 - a second source Single
 source3 - a third source Single
 source4 - a fourth source Single
 source5 - a fifth source Single
 zipper - a function that, when applied to the item emitted by each of the source Singles, results in an item that will be emitted by the resulting Single
 Returns:
 a Single that emits the zipped results
 See Also:
 ReactiveX operators documentation: Zip
 - zip
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public static <T1,T2,T3,T4,T5,T6,R> Single<R> zip(SingleSource<? extends T1> source1,SingleSource<? extends T2> source2,SingleSource<? extends T3> source3,SingleSource<? extends T4> source4,SingleSource<? extends T5> source5,SingleSource<? extends T6> source6,Function6<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? extends R> zipper)
```
 Returns a Single that emits the results of a specified combiner function applied to six items emitted by six other Singles.
 Scheduler:
 zip does not operate by default on a particularScheduler.
 Type Parameters:
 T1 - the first source Single's value type
 T2 - the second source Single's value type
 T3 - the third source Single's value type
 T4 - the fourth source Single's value type
 T5 - the fifth source Single's value type
 T6 - the sixth source Single's value type
 R - the result value type
 Parameters:
 source1 - the first source Single
 source2 - a second source Single
 source3 - a third source Single
 source4 - a fourth source Single
 source5 - a fifth source Single
 source6 - a sixth source Single
 zipper - a function that, when applied to the item emitted by each of the source Singles, results in an item that will be emitted by the resulting Single
 Returns:
 a Single that emits the zipped results
 See Also:
 ReactiveX operators documentation: Zip
 - zip
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public static <T1,T2,T3,T4,T5,T6,T7,R> Single<R> zip(SingleSource<? extends T1> source1,SingleSource<? extends T2> source2,SingleSource<? extends T3> source3,SingleSource<? extends T4> source4,SingleSource<? extends T5> source5,SingleSource<? extends T6> source6,SingleSource<? extends T7> source7,Function7<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? extends R> zipper)
```
 Returns a Single that emits the results of a specified combiner function applied to seven items emitted by seven other Singles.
 Scheduler:
 zip does not operate by default on a particularScheduler.
 Type Parameters:
 T1 - the first source Single's value type
 T2 - the second source Single's value type
 T3 - the third source Single's value type
 T4 - the fourth source Single's value type
 T5 - the fifth source Single's value type
 T6 - the sixth source Single's value type
 T7 - the seventh source Single's value type
 R - the result value type
 Parameters:
 source1 - the first source Single
 source2 - a second source Single
 source3 - a third source Single
 source4 - a fourth source Single
 source5 - a fifth source Single
 source6 - a sixth source Single
 source7 - a seventh source Single
 zipper - a function that, when applied to the item emitted by each of the source Singles, results in an item that will be emitted by the resulting Single
 Returns:
 a Single that emits the zipped results
 See Also:
 ReactiveX operators documentation: Zip
 - zip
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public static <T1,T2,T3,T4,T5,T6,T7,T8,R> Single<R> zip(SingleSource<? extends T1> source1,SingleSource<? extends T2> source2,SingleSource<? extends T3> source3,SingleSource<? extends T4> source4,SingleSource<? extends T5> source5,SingleSource<? extends T6> source6,SingleSource<? extends T7> source7,SingleSource<? extends T8> source8,Function8<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? extends R> zipper)
```
 Returns a Single that emits the results of a specified combiner function applied to eight items emitted by eight other Singles.
 Scheduler:
 zip does not operate by default on a particularScheduler.
 Type Parameters:
 T1 - the first source Single's value type
 T2 - the second source Single's value type
 T3 - the third source Single's value type
 T4 - the fourth source Single's value type
 T5 - the fifth source Single's value type
 T6 - the sixth source Single's value type
 T7 - the seventh source Single's value type
 T8 - the eighth source Single's value type
 R - the result value type
 Parameters:
 source1 - the first source Single
 source2 - a second source Single
 source3 - a third source Single
 source4 - a fourth source Single
 source5 - a fifth source Single
 source6 - a sixth source Single
 source7 - a seventh source Single
 source8 - an eighth source Single
 zipper - a function that, when applied to the item emitted by each of the source Singles, results in an item that will be emitted by the resulting Single
 Returns:
 a Single that emits the zipped results
 See Also:
 ReactiveX operators documentation: Zip
 - zip
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public static <T1,T2,T3,T4,T5,T6,T7,T8,T9,R> Single<R> zip(SingleSource<? extends T1> source1,SingleSource<? extends T2> source2,SingleSource<? extends T3> source3,SingleSource<? extends T4> source4,SingleSource<? extends T5> source5,SingleSource<? extends T6> source6,SingleSource<? extends T7> source7,SingleSource<? extends T8> source8,SingleSource<? extends T9> source9,Function9<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? super T9,? extends R> zipper)
```
 Returns a Single that emits the results of a specified combiner function applied to nine items emitted by nine other Singles.
 Scheduler:
 zip does not operate by default on a particularScheduler.
 Type Parameters:
 T1 - the first source Single's value type
 T2 - the second source Single's value type
 T3 - the third source Single's value type
 T4 - the fourth source Single's value type
 T5 - the fifth source Single's value type
 T6 - the sixth source Single's value type
 T7 - the seventh source Single's value type
 T8 - the eighth source Single's value type
 T9 - the ninth source Single's value type
 R - the result value type
 Parameters:
 source1 - the first source Single
 source2 - a second source Single
 source3 - a third source Single
 source4 - a fourth source Single
 source5 - a fifth source Single
 source6 - a sixth source Single
 source7 - a seventh source Single
 source8 - an eighth source Single
 source9 - a ninth source Single
 zipper - a function that, when applied to the item emitted by each of the source Singles, results in an item that will be emitted by the resulting Single
 Returns:
 a Single that emits the zipped results
 See Also:
 ReactiveX operators documentation: Zip
 - zipArray
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public static <T,R> Single<R> zipArray(Function<? superObject[],? extends R> zipper,SingleSource<? extends T>... sources)
```
 Waits until all SingleSource sources provided via an array signal a success value and calls a zipper function with an array of these values to return a result to be emitted to downstream.
 If the array ofSingleSources is empty aNoSuchElementException error is signalled immediately.
 Note on method signature: since Java doesn't allow creating a generic array withnew T[], the implementation of this operator has to create anObject[] instead. Unfortunately, aFunction<Integer[], R> passed to the method would trigger aClassCastException.
 If any of the SingleSources signal an error, all other SingleSources get disposed and the error emitted to downstream immediately.
 Scheduler:
 zipArray does not operate by default on a particularScheduler.
 Type Parameters:
 T - the common value type
 R - the result value type
 Parameters:
 sources - the array of SingleSource instances. An empty sequence will result in anonError signal ofNoSuchElementException.
 zipper - the function that receives an array with values from each SingleSource and should return a value to be emitted to downstream
 Returns:
 the new Single instance
 Since:
 2.0
 - ambWith
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final Single<T> ambWith(SingleSource<? extendsT> other)
```
 Signals the event of this or the other SingleSource whichever signals first.
 Scheduler:
 ambWith does not operate by default on a particularScheduler.
 Parameters:
 other - the other SingleSource to race for the first emission of success or error
 Returns:
 the new Single instance. A subscription to this provided source will occur after subscribing to the current source.
 Since:
 2.0
 - as
```
@CheckReturnValue@SchedulerSupport(value="none")public final <R> R as(@NonNullSingleConverter<T,? extends R> converter)
```
 Calls the specified converter function during assembly time and returns its resulting value.
 This allows fluent conversion to any other type.
 Scheduler:
 as does not operate by default on a particularScheduler.
 History: 2.1.7 - experimental
 Type Parameters:
 R - the resulting object type
 Parameters:
 converter - the function that receives the current Single instance and returns a value
 Returns:
 the converted value
 Throws:
 NullPointerException - if converter is null
 Since:
 2.2
 - hide
```
@CheckReturnValue@SchedulerSupport(value="none")public final Single<T> hide()
```
 Hides the identity of the current Single, including the Disposable that is sent to the downstream viaonSubscribe().
 Scheduler:
 hide does not operate by default on a particularScheduler.
 Returns:
 the new Single instance
 Since:
 2.0
 - compose
```
@CheckReturnValue@SchedulerSupport(value="none")public final <R> Single<R> compose(SingleTransformer<? superT,? extends R> transformer)
```
 Transform a Single by applying a particular Transformer function to it.
 This method operates on the Single itself whereaslift(io.reactivex.SingleOperator<? extends R, ? super T>) operates on the Single's SingleObservers.
 If the operator you are creating is designed to act on the individual item emitted by a Single, uselift(io.reactivex.SingleOperator<? extends R, ? super T>). If your operator is designed to transform the source Single as a whole (for instance, by applying a particular set of existing RxJava operators to it) usecompose.
 Scheduler:
 compose does not operate by default on a particularScheduler.
 Type Parameters:
 R - the value type of the single returned by the transformer function
 Parameters:
 transformer - the transformer function, not null
 Returns:
 the source Single, transformed by the transformer function
 See Also:
 RxJava wiki: Implementing Your Own Operators
 - cache
```
@CheckReturnValue@SchedulerSupport(value="none")public final Single<T> cache()
```
 Stores the success value or exception from the current Single and replays it to late SingleObservers.
 The returned Single subscribes to the current Single when the first SingleObserver subscribes.
 Scheduler:
 cache does not operate by default on a particularScheduler.
 Returns:
 the new Single instance
 Since:
 2.0
 - cast
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final  Single cast(Class<? extends U> clazz)
```
 Casts the success value of the current Single into the target type or signals a ClassCastException if not compatible.
 Scheduler:
 cast does not operate by default on a particularScheduler.
 Type Parameters:
 U - the target type
 Parameters:
 clazz - the type token to use for casting the success result from the current Single
 Returns:
 the new Single instance
 Since:
 2.0
 - concatWith
```
@BackpressureSupport(value=FULL)@CheckReturnValue@SchedulerSupport(value="none")public final Flowable<T> concatWith(SingleSource<? extendsT> other)
```
 Returns a Flowable that emits the item emitted by the source Single, then the item emitted by the specified Single.
 Backpressure:
 The returnedFlowable honors the backpressure of the downstream consumer.
 Scheduler:
 concatWith does not operate by default on a particularScheduler.
 Parameters:
 other - a Single to be concatenated after the current
 Returns:
 a Flowable that emits the item emitted by the source Single, followed by the item emitted byt1
 See Also:
 ReactiveX operators documentation: Concat
 - delay
```
@CheckReturnValue@SchedulerSupport(value="io.reactivex:computation")public final Single<T> delay(long time,TimeUnit unit)
```
 Delays the emission of the success signal from the current Single by the specified amount. An error signal will not be delayed.
 Scheduler:
 delay operates by default on thecomputationScheduler.
 Parameters:
 time - the amount of time the success signal should be delayed for
 unit - the time unit
 Returns:
 the new Single instance
 Since:
 2.0
 - delay
```
@CheckReturnValue@SchedulerSupport(value="io.reactivex:computation")public final Single<T> delay(long time,TimeUnit unit, boolean delayError)
```
 Delays the emission of the success or error signal from the current Single by the specified amount.
 Scheduler:
 delay operates by default on thecomputationScheduler.
 History: 2.1.5 - experimental
 Parameters:
 time - the amount of time the success or error signal should be delayed for
 unit - the time unit
 delayError - if true, both success and error signals are delayed. if false, only success signals are delayed.
 Returns:
 the new Single instance
 Since:
 2.2
 - delay
```
@CheckReturnValue@SchedulerSupport(value="custom")public final Single<T> delay(long time,TimeUnit unit,Scheduler scheduler)
```
 Delays the emission of the success signal from the current Single by the specified amount. An error signal will not be delayed.
 Scheduler:
 you specify theScheduler where the non-blocking wait and emission happens
 Parameters:
 time - the amount of time the success signal should be delayed for
 unit - the time unit
 scheduler - the target scheduler to use for the non-blocking wait and emission
 Returns:
 the new Single instance
 Throws:
 NullPointerException - if unit is null, or if scheduler is null
 Since:
 2.0
 - delay
```
@CheckReturnValue@NonNull@SchedulerSupport(value="custom")public final Single<T> delay(long time,TimeUnit unit,Scheduler scheduler, boolean delayError)
```
 Delays the emission of the success or error signal from the current Single by the specified amount.
 Scheduler:
 you specify theScheduler where the non-blocking wait and emission happens
 History: 2.1.5 - experimental
 Parameters:
 time - the amount of time the success or error signal should be delayed for
 unit - the time unit
 scheduler - the target scheduler to use for the non-blocking wait and emission
 delayError - if true, both success and error signals are delayed. if false, only success signals are delayed.
 Returns:
 the new Single instance
 Throws:
 NullPointerException - if unit is null, or if scheduler is null
 Since:
 2.2
 - delaySubscription
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final Single<T> delaySubscription(CompletableSource other)
```
 Delays the actual subscription to the current Single until the given other CompletableSource completes.
 If the delaying source signals an error, that error is re-emitted and no subscription to the current Single happens.
 Scheduler:
 delaySubscription does not operate by default on a particularScheduler.
 Parameters:
 other - the CompletableSource that has to complete before the subscription to the current Single happens
 Returns:
 the new Single instance
 Since:
 2.0
 - delaySubscription
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final  Single<T> delaySubscription(SingleSource other)
```
 Delays the actual subscription to the current Single until the given other SingleSource signals success.
 If the delaying source signals an error, that error is re-emitted and no subscription to the current Single happens.
 Scheduler:
 delaySubscription does not operate by default on a particularScheduler.
 Type Parameters:
 U - the element type of the other source
 Parameters:
 other - the SingleSource that has to complete before the subscription to the current Single happens
 Returns:
 the new Single instance
 Since:
 2.0
 - delaySubscription
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final  Single<T> delaySubscription(ObservableSource other)
```
 Delays the actual subscription to the current Single until the given other ObservableSource signals its first value or completes.
 If the delaying source signals an error, that error is re-emitted and no subscription to the current Single happens.
 Scheduler:
 delaySubscription does not operate by default on a particularScheduler.
 Type Parameters:
 U - the element type of the other source
 Parameters:
 other - the ObservableSource that has to signal a value or complete before the subscription to the current Single happens
 Returns:
 the new Single instance
 Since:
 2.0
 - delaySubscription
```
@BackpressureSupport(value=FULL)@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final  Single<T> delaySubscription(Publisher other)
```
 Delays the actual subscription to the current Single until the given other Publisher signals its first value or completes.
 If the delaying source signals an error, that error is re-emitted and no subscription to the current Single happens.
 The other source is consumed in an unbounded manner (requesting Long.MAX_VALUE from it).
 Backpressure:
 Theother publisher is consumed in an unbounded fashion but will be cancelled after the first item it produced.
 Scheduler:
 delaySubscription does not operate by default on a particularScheduler.
 Type Parameters:
 U - the element type of the other source
 Parameters:
 other - the Publisher that has to signal a value or complete before the subscription to the current Single happens
 Returns:
 the new Single instance
 Since:
 2.0
 - delaySubscription
```
@CheckReturnValue@SchedulerSupport(value="io.reactivex:computation")public final Single<T> delaySubscription(long time,TimeUnit unit)
```
 Delays the actual subscription to the current Single until the given time delay elapsed.
 Scheduler:
 delaySubscription does by default subscribe to the current Single on thecomputationScheduler after the delay.
 Parameters:
 time - the time amount to wait with the subscription
 unit - the time unit of the waiting
 Returns:
 the new Single instance
 Since:
 2.0
 - delaySubscription
```
@CheckReturnValue@SchedulerSupport(value="custom")public final Single<T> delaySubscription(long time,TimeUnit unit,Scheduler scheduler)
```
 Delays the actual subscription to the current Single until the given time delay elapsed.
 Scheduler:
 delaySubscription does by default subscribe to the current Single on theScheduler you provided, after the delay.
 Parameters:
 time - the time amount to wait with the subscription
 unit - the time unit of the waiting
 scheduler - the scheduler to wait on and subscribe on to the current Single
 Returns:
 the new Single instance
 Since:
 2.0
 - dematerialize
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final <R> Maybe<R> dematerialize(Function<? superT,Notification<R>> selector)
```
 Maps theNotification success value of this Single back into normalonSuccess,onError oronComplete signals as aMaybe source.
 The intended use of theselector function is to perform a type-safe identity mapping (see example) on a source that is already of typeNotification<T>. The Java language doesn't allow limiting instance methods to a certain generic argument shape, therefore, a function is used to ensure the conversion remains type safe.
 Scheduler:
 dematerialize does not operate by default on a particularScheduler.
 Example:
```
 Single.just(Notification.createOnNext(1)) .dematerialize(notification -> notification) .test() .assertResult(1);
```
 Type Parameters:
 R - the result type
 Parameters:
 selector - the function called with the success item and should return aNotification instance.
 Returns:
 the new Maybe instance
 Since:
 2.2.4 - experimental
 See Also:
 materialize()
 - doAfterSuccess
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final Single<T> doAfterSuccess(Consumer<? superT> onAfterSuccess)
```
 Calls the specified consumer with the success item after this item has been emitted to the downstream.
 Note that thedoAfterSuccess action is shared between subscriptions and as such should be thread-safe.
 Scheduler:
 doAfterSuccess does not operate by default on a particularScheduler.
 History: 2.0.1 - experimental
 Parameters:
 onAfterSuccess - the Consumer that will be called after emitting an item from upstream to the downstream
 Returns:
 the new Single instance
 Since:
 2.1
 - doAfterTerminate
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final Single<T> doAfterTerminate(Action onAfterTerminate)
```
 Registers anAction to be called after this Single invokes either onSuccess or onError.
 Note that thedoAfterTerminate action is shared between subscriptions and as such should be thread-safe.
 Scheduler:
 doAfterTerminate does not operate by default on a particularScheduler.
 History: 2.0.6 - experimental
 Parameters:
 onAfterTerminate - anAction to be invoked when the source Single finishes
 Returns:
 a Single that emits the same items as the source Single, then invokes theAction
 Since:
 2.1
 See Also:
 ReactiveX operators documentation: Do
 - doFinally
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final Single<T> doFinally(Action onFinally)
```
 Calls the specified action after this Single signals onSuccess or onError or gets disposed by the downstream.
 In case of a race between a terminal event and a dispose call, the providedonFinally action is executed once per subscription.
 Note that theonFinally action is shared between subscriptions and as such should be thread-safe.
 Scheduler:
 doFinally does not operate by default on a particularScheduler.
 History: 2.0.1 - experimental
 Parameters:
 onFinally - the action called when this Single terminates or gets disposed
 Returns:
 the new Single instance
 Since:
 2.1
 - doOnSubscribe
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final Single<T> doOnSubscribe(Consumer<? superDisposable> onSubscribe)
```
 Calls the shared consumer with the Disposable sent through the onSubscribe for each SingleObserver that subscribes to the current Single.
 Scheduler:
 doOnSubscribe does not operate by default on a particularScheduler.
 Parameters:
 onSubscribe - the consumer called with the Disposable sent via onSubscribe
 Returns:
 the new Single instance
 Since:
 2.0
 - doOnTerminate
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final Single<T> doOnTerminate(Action onTerminate)
```
 Returns a Single instance that calls the given onTerminate callback just before this Single completes normally or with an exception.
 This differs fromdoAfterTerminate in that this happensbefore theonSuccess oronError notification.
 Scheduler:
 doOnTerminate does not operate by default on a particularScheduler.
 Parameters:
 onTerminate - the action to invoke when the consumer callsonSuccess oronError
 Returns:
 the new Single instance
 Since:
 2.2.7 - experimental
 See Also:
 ReactiveX operators documentation: Do,doOnTerminate(Action)
 - doOnSuccess
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final Single<T> doOnSuccess(Consumer<? superT> onSuccess)
```
 Calls the shared consumer with the success value sent via onSuccess for each SingleObserver that subscribes to the current Single.
 Scheduler:
 doOnSuccess does not operate by default on a particularScheduler.
 Parameters:
 onSuccess - the consumer called with the success value of onSuccess
 Returns:
 the new Single instance
 Since:
 2.0
 - doOnEvent
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final Single<T> doOnEvent(BiConsumer<? superT,? superThrowable> onEvent)
```
 Calls the shared consumer with the error sent via onError or the value via onSuccess for each SingleObserver that subscribes to the current Single.
 Scheduler:
 doOnEvent does not operate by default on a particularScheduler.
 Parameters:
 onEvent - the consumer called with the success value of onEvent
 Returns:
 the new Single instance
 Since:
 2.0
 - doOnError
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final Single<T> doOnError(Consumer<? superThrowable> onError)
```
 Calls the shared consumer with the error sent via onError for each SingleObserver that subscribes to the current Single.
 Scheduler:
 doOnError does not operate by default on a particularScheduler.
 Parameters:
 onError - the consumer called with the success value of onError
 Returns:
 the new Single instance
 Since:
 2.0
 - doOnDispose
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final Single<T> doOnDispose(Action onDispose)
```
 Calls the sharedAction if a SingleObserver subscribed to the current Single disposes the common Disposable it received via onSubscribe.
 Scheduler:
 doOnDispose does not operate by default on a particularScheduler.
 Parameters:
 onDispose - the action called when the subscription is disposed
 Returns:
 the new Single instance
 Throws:
 NullPointerException - if onDispose is null
 Since:
 2.0
 - filter
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final Maybe<T> filter(Predicate<? superT> predicate)
```
 Filters the success item of the Single via a predicate function and emitting it if the predicate returns true, completing otherwise.
 Scheduler:
 filter does not operate by default on a particularScheduler.
 Parameters:
 predicate - a function that evaluates the item emitted by the source Maybe, returningtrue if it passes the filter
 Returns:
 a Maybe that emit the item emitted by the source Maybe that the filter evaluates astrue
 See Also:
 ReactiveX operators documentation: Filter
 - flatMap
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final <R> Single<R> flatMap(Function<? superT,? extendsSingleSource<? extends R>> mapper)
```
 Returns a Single that is based on applying a specified function to the item emitted by the source Single, where that function returns a SingleSource.
 Scheduler:
 flatMap does not operate by default on a particularScheduler.
 Type Parameters:
 R - the result value type
 Parameters:
 mapper - a function that, when applied to the item emitted by the source Single, returns a SingleSource
 Returns:
 the Single returned frommapper when applied to the item emitted by the source Single
 See Also:
 ReactiveX operators documentation: FlatMap
 - flatMapMaybe
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final <R> Maybe<R> flatMapMaybe(Function<? superT,? extendsMaybeSource<? extends R>> mapper)
```
 Returns a Maybe that is based on applying a specified function to the item emitted by the source Single, where that function returns a MaybeSource.
 Scheduler:
 flatMapMaybe does not operate by default on a particularScheduler.
 Type Parameters:
 R - the result value type
 Parameters:
 mapper - a function that, when applied to the item emitted by the source Single, returns a MaybeSource
 Returns:
 the Maybe returned frommapper when applied to the item emitted by the source Single
 See Also:
 ReactiveX operators documentation: FlatMap
 - flatMapPublisher
```
@BackpressureSupport(value=FULL)@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final <R> Flowable<R> flatMapPublisher(Function<? superT,? extendsPublisher<? extends R>> mapper)
```
 Returns a Flowable that emits items based on applying a specified function to the item emitted by the source Single, where that function returns a Publisher.
 Backpressure:
 The returnedFlowable honors the backpressure of the downstream consumer and thePublisher returned by the mapper function is expected to honor it as well.
 Scheduler:
 flatMapPublisher does not operate by default on a particularScheduler.
 Type Parameters:
 R - the result value type
 Parameters:
 mapper - a function that, when applied to the item emitted by the source Single, returns a Flowable
 Returns:
 the Flowable returned fromfunc when applied to the item emitted by the source Single
 See Also:
 ReactiveX operators documentation: FlatMap
 - flattenAsFlowable
```
@BackpressureSupport(value=FULL)@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final  Flowable flattenAsFlowable(Function<? superT,? extendsIterable<? extends U>> mapper)
```
 Maps the success value of the upstreamSingle into anIterable and emits its items as aFlowable sequence.
 Backpressure:
 The operator honors backpressure from downstream.
 Scheduler:
 flattenAsFlowable does not operate by default on a particularScheduler.
 Type Parameters:
 U - the type of item emitted by the resulting Iterable
 Parameters:
 mapper - a function that returns an Iterable sequence of values for when given an item emitted by the source Single
 Returns:
 the new Flowable instance
 See Also:
 ReactiveX operators documentation: FlatMap
 - flattenAsObservable
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final  Observable flattenAsObservable(Function<? superT,? extendsIterable<? extends U>> mapper)
```
 Maps the success value of the upstreamSingle into anIterable and emits its items as anObservable sequence.
 Scheduler:
 flattenAsObservable does not operate by default on a particularScheduler.
 Type Parameters:
 U - the type of item emitted by the resulting Iterable
 Parameters:
 mapper - a function that returns an Iterable sequence of values for when given an item emitted by the source Single
 Returns:
 the new Observable instance
 See Also:
 ReactiveX operators documentation: FlatMap
 - flatMapObservable
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final <R> Observable<R> flatMapObservable(Function<? superT,? extendsObservableSource<? extends R>> mapper)
```
 Returns an Observable that is based on applying a specified function to the item emitted by the source Single, where that function returns an ObservableSource.
 Scheduler:
 flatMapObservable does not operate by default on a particularScheduler.
 Type Parameters:
 R - the result value type
 Parameters:
 mapper - a function that, when applied to the item emitted by the source Single, returns an ObservableSource
 Returns:
 the Observable returned fromfunc when applied to the item emitted by the source Single
 See Also:
 ReactiveX operators documentation: FlatMap
 - flatMapCompletable
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final Completable flatMapCompletable(Function<? superT,? extendsCompletableSource> mapper)
```
 Returns aCompletable that completes based on applying a specified function to the item emitted by the sourceSingle, where that function returns aCompletable.
 Scheduler:
 flatMapCompletable does not operate by default on a particularScheduler.
 Parameters:
 mapper - a function that, when applied to the item emitted by the source Single, returns a Completable
 Returns:
 the Completable returned fromfunc when applied to the item emitted by the source Single
 Since:
 2.0
 See Also:
 ReactiveX operators documentation: FlatMap
 - blockingGet
```
@CheckReturnValue@SchedulerSupport(value="none")public final T blockingGet()
```
 Waits in a blocking fashion until the current Single signals a success value (which is returned) or an exception (which is propagated).
 Scheduler:
 blockingGet does not operate by default on a particularScheduler.
 Error handling:
 If the source signals an error, the operator wraps a checkedException intoRuntimeException and throws that. Otherwise,RuntimeExceptions andErrors are rethrown as they are.
 Returns:
 the success value
 - lift
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final <R> Single<R> lift(SingleOperator<? extends R,? superT> lift)
```
 This method requires advanced knowledge about building operators, please consider other standard composition methods first; Returns aSingle which, when subscribed to, invokes theapply(SingleObserver) method of the providedSingleOperator for each individual downstreamSingle and allows the insertion of a custom operator by accessing the downstream'sSingleObserver during this subscription phase and providing a newSingleObserver, containing the custom operator's intended business logic, that will be used in the subscription process going further upstream.
 Generally, such a newSingleObserver will wrap the downstream'sSingleObserver and forwards theonSuccess andonError events from the upstream directly or according to the emission pattern the custom operator's business logic requires. In addition, such operator can intercept the flow control calls ofdispose andisDisposed that would have traveled upstream and perform additional actions depending on the same business logic requirements.
 Example:
```
 // Step 1: Create the consumer type that will be returned by the SingleOperator.apply(): public final class CustomSingleObserver<T> implements SingleObserver<T>, Disposable { // The downstream's SingleObserver that will receive the onXXX events final SingleObserver<? super String> downstream; // The connection to the upstream source that will call this class' onXXX methods Disposable upstream; // The constructor takes the downstream subscriber and usually any other parameters public CustomSingleObserver(SingleObserver<? super String> downstream) { this.downstream = downstream; } // In the subscription phase, the upstream sends a Disposable to this class // and subsequently this class has to send a Disposable to the downstream. // Note that relaying the upstream's Disposable directly is not allowed in RxJava @Override public void onSubscribe(Disposable d) { if (upstream != null) { d.dispose(); } else { upstream = d; downstream.onSubscribe(this); } } // The upstream calls this with the next item and the implementation's // responsibility is to emit an item to the downstream based on the intended // business logic, or if it can't do so for the particular item, // request more from the upstream @Override public void onSuccess(T item) { String str = item.toString(); if (str.length() < 2) { downstream.onSuccess(str); } else { // Single is usually expected to produce one of the onXXX events downstream.onError(new NoSuchElementException()); } } // Some operators may handle the upstream's error while others // could just forward it to the downstream. @Override public void onError(Throwable throwable) { downstream.onError(throwable); } // Some operators may use their own resources which should be cleaned up if // the downstream disposes the flow before it completed. Operators without // resources can simply forward the dispose to the upstream. // In some cases, a disposed flag may be set by this method so that other parts // of this class may detect the dispose and stop sending events // to the downstream. @Override public void dispose() { upstream.dispose(); } // Some operators may simply forward the call to the upstream while others // can return the disposed flag set in dispose(). @Override public boolean isDisposed() { return upstream.isDisposed(); } } // Step 2: Create a class that implements the SingleOperator interface and // returns the custom consumer type from above in its apply() method. // Such class may define additional parameters to be submitted to // the custom consumer type. final class CustomSingleOperator<T> implements SingleOperator<String> { @Override public SingleObserver<? super String> apply(SingleObserver<? super T> upstream) { return new CustomSingleObserver<T>(upstream); } } // Step 3: Apply the custom operator via lift() in a flow by creating an instance of it // or reusing an existing one. Single.just(5) .lift(new CustomSingleOperator<Integer>()) .test() .assertResult("5"); Single.just(15) .lift(new CustomSingleOperator<Integer>()) .test() .assertFailure(NoSuchElementException.class);
```
 Creating custom operators can be complicated and it is recommended one consults theRxJava wiki: Writing operators page about the tools, requirements, rules, considerations and pitfalls of implementing them.
 Note that implementing custom operators via thislift() method adds slightly more overhead by requiring an additional allocation and indirection per assembled flows. Instead, extending the abstractSingle class and creating aSingleTransformer with it is recommended.
 Note also that it is not possible to stop the subscription phase inlift() as theapply() method requires a non-nullSingleObserver instance to be returned, which is then unconditionally subscribed to the upstreamSingle. For example, if the operator decided there is no reason to subscribe to the upstream source because of some optimization possibility or a failure to prepare the operator, it still has to return aSingleObserver that should immediately dispose the upstream'sDisposable in itsonSubscribe method. Again, using aSingleTransformer and extending theSingle is a better option assubscribeActual(io.reactivex.SingleObserver<? super T>) can decide to not subscribe to its upstream after all.
 Scheduler:
 lift does not operate by default on a particularScheduler, however, theSingleOperator may use aScheduler to support its own asynchronous behavior.
 Type Parameters:
 R - the output value type
 Parameters:
 lift - theSingleOperator that receives the downstream'sSingleObserver and should return aSingleObserver with custom behavior to be used as the consumer for the currentSingle.
 Returns:
 the new Single instance
 See Also:
 RxJava wiki: Writing operators,compose(SingleTransformer)
 - map
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final <R> Single<R> map(Function<? superT,? extends R> mapper)
```
 Returns a Single that applies a specified function to the item emitted by the source Single and emits the result of this function application.
 Scheduler:
 map does not operate by default on a particularScheduler.
 Type Parameters:
 R - the result value type
 Parameters:
 mapper - a function to apply to the item emitted by the Single
 Returns:
 a Single that emits the item from the source Single, transformed by the specified function
 See Also:
 ReactiveX operators documentation: Map
 - materialize
```
@CheckReturnValue@SchedulerSupport(value="none")public final Single<Notification<T>> materialize()
```
 Maps the signal types of this Single into aNotification of the same kind and emits it as a single success value to downstream.
 Scheduler:
 materialize does not operate by default on a particularScheduler.
 Returns:
 the new Single instance
 Since:
 2.2.4 - experimental
 See Also:
 dematerialize(Function)
 - contains
```
@CheckReturnValue@SchedulerSupport(value="none")public final Single<Boolean> contains(Object value)
```
 Signals true if the current Single signals a success value that is Object-equals with the value provided.
 Scheduler:
 contains does not operate by default on a particularScheduler.
 Parameters:
 value - the value to compare against the success value of this Single
 Returns:
 the new Single instance
 Since:
 2.0
 - contains
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final Single<Boolean> contains(Object value,BiPredicate<Object,Object> comparer)
```
 Signals true if the current Single signals a success value that is equal with the value provided by calling a bi-predicate.
 Scheduler:
 contains does not operate by default on a particularScheduler.
 Parameters:
 value - the value to compare against the success value of this Single
 comparer - the function that receives the success value of this Single, the value provided and should return true if they are considered equal
 Returns:
 the new Single instance
 Since:
 2.0
 - mergeWith
```
@BackpressureSupport(value=FULL)@CheckReturnValue@SchedulerSupport(value="none")public final Flowable<T> mergeWith(SingleSource<? extendsT> other)
```
 Flattens this and another Single into a single Flowable, without any transformation.
 You can combine items emitted by multiple Singles so that they appear as a single Flowable, by using themergeWith method.
 Backpressure:
 The returnedFlowable honors the backpressure of the downstream consumer.
 Scheduler:
 mergeWith does not operate by default on a particularScheduler.
 Parameters:
 other - a SingleSource to be merged
 Returns:
 that emits all of the items emitted by the source Singles
 See Also:
 ReactiveX operators documentation: Merge
 - observeOn
```
@CheckReturnValue@NonNull@SchedulerSupport(value="custom")public final Single<T> observeOn(Scheduler scheduler)
```
 Modifies a Single to emit its item (or notify of its error) on a specifiedScheduler, asynchronously.
 Scheduler:
 you specify whichScheduler this operator will use.
 Parameters:
 scheduler - theScheduler to notify subscribers on
 Returns:
 the source Single modified so that its subscribers are notified on the specifiedScheduler
 Throws:
 NullPointerException - if scheduler is null
 See Also:
 ReactiveX operators documentation: ObserveOn,RxJava Threading Examples,subscribeOn(io.reactivex.Scheduler)
 - onErrorReturn
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final Single<T> onErrorReturn(Function<Throwable,? extendsT> resumeFunction)
```
 Instructs a Single to emit an item (returned by a specified function) rather than invokingonError if it encounters an error.
 By default, when a Single encounters an error that prevents it from emitting the expected item to its subscriber, the Single invokes its subscriber'sSingleObserver.onError(java.lang.Throwable) method, and then quits without invoking any more of its subscriber's methods. TheonErrorReturn method changes this behavior. If you pass a function (resumeFunction) to a Single'sonErrorReturn method, if the original Single encounters an error, instead of invoking its subscriber'sSingleObserver.onError(java.lang.Throwable) method, it will instead emit the return value ofresumeFunction.
 You can use this to prevent errors from propagating or to supply fallback data should errors be encountered.
 Scheduler:
 onErrorReturn does not operate by default on a particularScheduler.
 Parameters:
 resumeFunction - a function that returns an item that the new Single will emit if the source Single encounters an error
 Returns:
 the original Single with appropriately modified behavior
 See Also:
 ReactiveX operators documentation: Catch
 - onErrorReturnItem
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final Single<T> onErrorReturnItem(T value)
```
 Signals the specified value as success in case the current Single signals an error.
 Scheduler:
 onErrorReturnItem does not operate by default on a particularScheduler.
 Parameters:
 value - the value to signal if the current Single fails
 Returns:
 the new Single instance
 Since:
 2.0
 - onErrorResumeNext
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final Single<T> onErrorResumeNext(Single<? extendsT> resumeSingleInCaseOfError)
```
 Instructs a Single to pass control to another Single rather than invokingSingleObserver.onError(Throwable) if it encounters an error.
 By default, when a Single encounters an error that prevents it from emitting the expected item to itsSingleObserver, the Single invokes its SingleObserver'sonError method, and then quits without invoking any more of its SingleObserver's methods. TheonErrorResumeNext method changes this behavior. If you pass another Single (resumeSingleInCaseOfError) to a Single'sonErrorResumeNext method, if the original Single encounters an error, instead of invoking its SingleObserver'sonError method, it will instead relinquish control toresumeSingleInCaseOfError which will invoke the SingleObserver'sonSuccess method if it is able to do so. In such a case, because no Single necessarily invokesonError, the SingleObserver may never know that an error happened.
 You can use this to prevent errors from propagating or to supply fallback data should errors be encountered.
 Scheduler:
 onErrorResumeNext does not operate by default on a particularScheduler.
 Parameters:
 resumeSingleInCaseOfError - a Single that will take control if source Single encounters an error.
 Returns:
 the original Single, with appropriately modified behavior.
 See Also:
 ReactiveX operators documentation: Catch
 - onErrorResumeNext
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final Single<T> onErrorResumeNext(Function<? superThrowable,? extendsSingleSource<? extendsT>> resumeFunctionInCaseOfError)
```
 Instructs a Single to pass control to another Single rather than invokingSingleObserver.onError(Throwable) if it encounters an error.
 By default, when a Single encounters an error that prevents it from emitting the expected item to itsSingleObserver, the Single invokes its SingleObserver'sonError method, and then quits without invoking any more of its SingleObserver's methods. TheonErrorResumeNext method changes this behavior. If you pass a function that will return another Single (resumeFunctionInCaseOfError) to a Single'sonErrorResumeNext method, if the original Single encounters an error, instead of invoking its SingleObserver'sonError method, it will instead relinquish control toresumeSingleInCaseOfError which will invoke the SingleObserver'sonSuccess method if it is able to do so. In such a case, because no Single necessarily invokesonError, the SingleObserver may never know that an error happened.
 You can use this to prevent errors from propagating or to supply fallback data should errors be encountered.
 Scheduler:
 onErrorResumeNext does not operate by default on a particularScheduler.
 Parameters:
 resumeFunctionInCaseOfError - a function that returns a Single that will take control if source Single encounters an error.
 Returns:
 the original Single, with appropriately modified behavior.
 Since:
 .20
 See Also:
 ReactiveX operators documentation: Catch
 - onTerminateDetach
```
@CheckReturnValue@SchedulerSupport(value="none")public final Single<T> onTerminateDetach()
```
 Nulls out references to the upstream producer and downstream SingleObserver if the sequence is terminated or downstream calls dispose().
 Scheduler:
 onTerminateDetach does not operate by default on a particularScheduler.
 History: 2.1.5 - experimental
 Returns:
 a Single which nulls out references to the upstream producer and downstream SingleObserver if the sequence is terminated or downstream calls dispose()
 Since:
 2.2
 - repeat
```
@BackpressureSupport(value=FULL)@CheckReturnValue@SchedulerSupport(value="none")public final Flowable<T> repeat()
```
 Repeatedly re-subscribes to the current Single and emits each success value.
 Backpressure:
 The returnedFlowable honors the backpressure of the downstream consumer.
 Scheduler:
 repeat does not operate by default on a particularScheduler.
 Returns:
 the new Flowable instance
 Since:
 2.0
 - repeat
```
@BackpressureSupport(value=FULL)@CheckReturnValue@SchedulerSupport(value="none")public final Flowable<T> repeat(long times)
```
 Re-subscribes to the current Single at most the given number of times and emits each success value.
 Backpressure:
 The returnedFlowable honors the backpressure of the downstream consumer.
 Scheduler:
 repeat does not operate by default on a particularScheduler.
 Parameters:
 times - the number of times to re-subscribe to the current Single
 Returns:
 the new Flowable instance
 Since:
 2.0
 - repeatWhen
```
@BackpressureSupport(value=FULL)@CheckReturnValue@SchedulerSupport(value="none")public final Flowable<T> repeatWhen(Function<? superFlowable<Object>,? extendsPublisher<?>> handler)
```
 Re-subscribes to the current Single if the Publisher returned by the handler function signals a value in response to a value signalled through the Flowable the handle receives.
 Backpressure:
 The returnedFlowable honors the backpressure of the downstream consumer. ThePublisher returned by the handler function is expected to honor backpressure as well.
 Scheduler:
 repeatWhen does not operate by default on a particularScheduler.
 Parameters:
 handler - the function that is called with a Flowable that signals a value when the Single signalled a success value and returns a Publisher that has to signal a value to trigger a resubscription to the current Single, otherwise the terminal signal of the Publisher will be the terminal signal of the sequence as well.
 Returns:
 the new Flowable instance
 Since:
 2.0
 - repeatUntil
```
@BackpressureSupport(value=FULL)@CheckReturnValue@SchedulerSupport(value="none")public final Flowable<T> repeatUntil(BooleanSupplier stop)
```
 Re-subscribes to the current Single until the given BooleanSupplier returns true.
 Backpressure:
 The returnedFlowable honors the backpressure of the downstream consumer.
 Scheduler:
 repeatUntil does not operate by default on a particularScheduler.
 Parameters:
 stop - the BooleanSupplier called after the current Single succeeds and if returns false, the Single is re-subscribed; otherwise the sequence completes.
 Returns:
 the new Flowable instance
 Since:
 2.0
 - retry
```
@CheckReturnValue@SchedulerSupport(value="none")public final Single<T> retry()
```
 Repeatedly re-subscribes to the current Single indefinitely if it fails with an onError.
 Scheduler:
 retry does not operate by default on a particularScheduler.
 Returns:
 the new Single instance
 Since:
 2.0
 - retry
```
@CheckReturnValue@SchedulerSupport(value="none")public final Single<T> retry(long times)
```
 Repeatedly re-subscribe at most the specified times to the current Single if it fails with an onError.
 Scheduler:
 retry does not operate by default on a particularScheduler.
 Parameters:
 times - the number of times to resubscribe if the current Single fails
 Returns:
 the new Single instance
 Since:
 2.0
 - retry
```
@CheckReturnValue@SchedulerSupport(value="none")public final Single<T> retry(BiPredicate<? superInteger,? superThrowable> predicate)
```
 Re-subscribe to the current Single if the given predicate returns true when the Single fails with an onError.
 Scheduler:
 retry does not operate by default on a particularScheduler.
 Parameters:
 predicate - the predicate called with the resubscription count and the failure Throwable and should return true if a resubscription should happen
 Returns:
 the new Single instance
 Since:
 2.0
 - retry
```
@CheckReturnValue@SchedulerSupport(value="none")public final Single<T> retry(long times,Predicate<? superThrowable> predicate)
```
 Repeatedly re-subscribe at most times or until the predicate returns false, whichever happens first if it fails with an onError.
 Scheduler:
 retry does not operate by default on a particularScheduler.
 History: 2.1.8 - experimental
 Parameters:
 times - the number of times to resubscribe if the current Single fails
 predicate - the predicate called with the failure Throwable and should return true if a resubscription should happen
 Returns:
 the new Single instance
 Since:
 2.2
 - retry
```
@CheckReturnValue@SchedulerSupport(value="none")public final Single<T> retry(Predicate<? superThrowable> predicate)
```
 Re-subscribe to the current Single if the given predicate returns true when the Single fails with an onError.
 Scheduler:
 retry does not operate by default on a particularScheduler.
 Parameters:
 predicate - the predicate called with the failure Throwable and should return true if a resubscription should happen
 Returns:
 the new Single instance
 Since:
 2.0
 - retryWhen
```
@CheckReturnValue@SchedulerSupport(value="none")public final Single<T> retryWhen(Function<? superFlowable<Throwable>,? extendsPublisher<?>> handler)
```
 Re-subscribes to the current Single if and when the Publisher returned by the handler function signals a value.
 If the Publisher signals an onComplete, the resulting Single will signal a NoSuchElementException.
 Note that the innerPublisher returned by the handler function should signal eitheronNext,onError oronComplete in response to the receivedThrowable to indicate the operator should retry or terminate. If the upstream to the operator is asynchronous, signalling onNext followed by onComplete immediately may result in the sequence to be completed immediately. Similarly, if this innerPublisher signalsonError oronComplete while the upstream is active, the sequence is terminated with the same signal immediately.
 The following example demonstrates how to retry an asynchronous source with a delay:
```
 Single.timer(1, TimeUnit.SECONDS) .doOnSubscribe(s -> System.out.println("subscribing")) .map(v -> { throw new RuntimeException(); }) .retryWhen(errors -> { AtomicInteger counter = new AtomicInteger(); return errors .takeWhile(e -> counter.getAndIncrement() != 3) .flatMap(e -> { System.out.println("delay retry by " + counter.get() + " second(s)"); return Flowable.timer(counter.get(), TimeUnit.SECONDS); }); }) .blockingGet();
```
 Scheduler:
 retryWhen does not operate by default on a particularScheduler.
 Parameters:
 handler - the function that receives a Flowable of the error the Single emits and should return a Publisher that should signal a normal value (in response to the throwable the Flowable emits) to trigger a resubscription or signal an error to be the output of the resulting Single
 Returns:
 the new Single instance
 - subscribe
```
@SchedulerSupport(value="none")public final Disposable subscribe()
```
 Subscribes to a Single but ignore its emission or notification.
 If the Single emits an error, it is wrapped into anOnErrorNotImplementedException and routed to the RxJavaPlugins.onError handler.
 Scheduler:
 subscribe does not operate by default on a particularScheduler.
 Returns:
 aDisposable reference can request theSingle stop work.
 See Also:
 ReactiveX operators documentation: Subscribe
 - subscribe
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final Disposable subscribe(BiConsumer<? superT,? superThrowable> onCallback)
```
 Subscribes to a Single and provides a composite callback to handle the item it emits or any error notification it issues.
 Scheduler:
 subscribe does not operate by default on a particularScheduler.
 Parameters:
 onCallback - the callback that receives either the success value or the failure Throwable (whichever is not null)
 Returns:
 aDisposable reference can request theSingle stop work.
 Throws:
 NullPointerException - ifonCallback is null
 See Also:
 ReactiveX operators documentation: Subscribe
 - subscribe
```
@CheckReturnValue@SchedulerSupport(value="none")public final Disposable subscribe(Consumer<? superT> onSuccess)
```
 Subscribes to a Single and provides a callback to handle the item it emits.
 If the Single emits an error, it is wrapped into anOnErrorNotImplementedException and routed to the RxJavaPlugins.onError handler.
 Scheduler:
 subscribe does not operate by default on a particularScheduler.
 Parameters:
 onSuccess - theConsumer<T> you have designed to accept the emission from the Single
 Returns:
 aDisposable reference can request theSingle stop work.
 Throws:
 NullPointerException - ifonSuccess is null
 See Also:
 ReactiveX operators documentation: Subscribe
 - subscribe
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final Disposable subscribe(Consumer<? superT> onSuccess,Consumer<? superThrowable> onError)
```
 Subscribes to a Single and provides callbacks to handle the item it emits or any error notification it issues.
 Scheduler:
 subscribe does not operate by default on a particularScheduler.
 Parameters:
 onSuccess - theConsumer<T> you have designed to accept the emission from the Single
 onError - theConsumer<Throwable> you have designed to accept any error notification from the Single
 Returns:
 aDisposable reference can request theSingle stop work.
 Throws:
 NullPointerException - ifonSuccess is null, or ifonError is null
 See Also:
 ReactiveX operators documentation: Subscribe
 - subscribe
```
@SchedulerSupport(value="none")public final void subscribe(SingleObserver<? superT> observer)
```
 Description copied from interface: SingleSource
 Subscribes the given SingleObserver to this SingleSource instance.
 Specified by:
 subscribe in interface SingleSource<T>
 Parameters:
 observer - the SingleObserver, not null
 - subscribeActual
```
protected abstract void subscribeActual(@NonNullSingleObserver<? superT> observer)
```
 Implement this method in subclasses to handle the incomingSingleObservers.
 There is no need to call any of the plugin hooks on the currentSingle instance or theSingleObserver; all hooks and basic safeguards have been applied bysubscribe(SingleObserver) before this method gets called.
 Parameters:
 observer - the SingleObserver to handle, not null
 - subscribeWith
```
@CheckReturnValue@SchedulerSupport(value="none")public final <E extendsSingleObserver<? superT>> E subscribeWith(E observer)
```
 Subscribes a given SingleObserver (subclass) to this Single and returns the given SingleObserver as is.
 Usage example:
```
 Single<Integer> source = Single.just(1); CompositeDisposable composite = new CompositeDisposable(); DisposableSingleObserver<Integer> ds = new DisposableSingleObserver<>() { // ... }; composite.add(source.subscribeWith(ds));
```
 Scheduler:
 subscribeWith does not operate by default on a particularScheduler.
 Type Parameters:
 E - the type of the SingleObserver to use and return
 Parameters:
 observer - the SingleObserver (subclass) to use and return, not null
 Returns:
 the inputobserver
 Throws:
 NullPointerException - ifobserver is null
 Since:
 2.0
 - subscribeOn
```
@CheckReturnValue@NonNull@SchedulerSupport(value="custom")public final Single<T> subscribeOn(Scheduler scheduler)
```
 Asynchronously subscribes subscribers to this Single on the specifiedScheduler.
 Scheduler:
 You specify whichScheduler this operator will use.
 Parameters:
 scheduler - theScheduler to perform subscription actions on
 Returns:
 the source Single modified so that its subscriptions happen on the specifiedScheduler
 See Also:
 ReactiveX operators documentation: SubscribeOn,RxJava Threading Examples,observeOn(io.reactivex.Scheduler)
 - takeUntil
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final Single<T> takeUntil(CompletableSource other)
```
 Returns a Single that emits the item emitted by the source Single until a Completable terminates. Upon termination ofother, this will emit aCancellationException rather than go toSingleObserver.onSuccess(Object).
 Scheduler:
 takeUntil does not operate by default on a particularScheduler.
 Parameters:
 other - the Completable whose termination will causetakeUntil to emit the item from the source Single
 Returns:
 a Single that emits the item emitted by the source Single until such time asother terminates.
 See Also:
 ReactiveX operators documentation: TakeUntil
 - takeUntil
```
@BackpressureSupport(value=FULL)@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final <E> Single<T> takeUntil(Publisher<E> other)
```
 Returns a Single that emits the item emitted by the source Single until a Publisher emits an item. Upon emission of an item fromother, this will emit aCancellationException rather than go toSingleObserver.onSuccess(Object).
 Backpressure:
 Theother publisher is consumed in an unbounded fashion but will be cancelled after the first item it produced.
 Scheduler:
 takeUntil does not operate by default on a particularScheduler.
 Type Parameters:
 E - the type of items emitted byother
 Parameters:
 other - the Publisher whose first emitted item will causetakeUntil to emit the item from the source Single
 Returns:
 a Single that emits the item emitted by the source Single until such time asother emits its first item
 See Also:
 ReactiveX operators documentation: TakeUntil
 - takeUntil
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final <E> Single<T> takeUntil(SingleSource<? extends E> other)
```
 Returns a Single that emits the item emitted by the source Single until a second Single emits an item. Upon emission of an item fromother, this will emit aCancellationException rather than go toSingleObserver.onSuccess(Object).
 Scheduler:
 takeUntil does not operate by default on a particularScheduler.
 Type Parameters:
 E - the type of item emitted byother
 Parameters:
 other - the Single whose emitted item will causetakeUntil to emit the item from the source Single
 Returns:
 a Single that emits the item emitted by the source Single until such time asother emits its item
 See Also:
 ReactiveX operators documentation: TakeUntil
 - timeout
```
@CheckReturnValue@SchedulerSupport(value="io.reactivex:computation")public final Single<T> timeout(long timeout,TimeUnit unit)
```
 Signals a TimeoutException if the current Single doesn't signal a success value within the specified timeout window.
 Scheduler:
 timeout signals the TimeoutException on thecomputationScheduler.
 Parameters:
 timeout - the timeout amount
 unit - the time unit
 Returns:
 the new Single instance
 Since:
 2.0
 - timeout
```
@CheckReturnValue@SchedulerSupport(value="custom")public final Single<T> timeout(long timeout,TimeUnit unit,Scheduler scheduler)
```
 Signals a TimeoutException if the current Single doesn't signal a success value within the specified timeout window.
 Scheduler:
 timeout signals the TimeoutException on theScheduler you specify.
 Parameters:
 timeout - the timeout amount
 unit - the time unit
 scheduler - the target scheduler where the timeout is awaited and the TimeoutException signalled
 Returns:
 the new Single instance
 Since:
 2.0
 - timeout
```
@CheckReturnValue@NonNull@SchedulerSupport(value="custom")public final Single<T> timeout(long timeout,TimeUnit unit,Scheduler scheduler,SingleSource<? extendsT> other)
```
 Runs the current Single and if it doesn't signal within the specified timeout window, it is disposed and the other SingleSource subscribed to.
 Scheduler:
 timeout subscribes to the other SingleSource on theScheduler you specify.
 Parameters:
 timeout - the timeout amount
 unit - the time unit
 scheduler - the scheduler where the timeout is awaited and the subscription to other happens
 other - the other SingleSource that gets subscribed to if the current Single times out
 Returns:
 the new Single instance
 Since:
 2.0
 - timeout
```
@CheckReturnValue@NonNull@SchedulerSupport(value="io.reactivex:computation")public final Single<T> timeout(long timeout,TimeUnit unit,SingleSource<? extendsT> other)
```
 Runs the current Single and if it doesn't signal within the specified timeout window, it is disposed and the other SingleSource subscribed to.
 Scheduler:
 timeout subscribes to the other SingleSource on thecomputationScheduler.
 Parameters:
 timeout - the timeout amount
 unit - the time unit
 other - the other SingleSource that gets subscribed to if the current Single times out
 Returns:
 the new Single instance
 Throws:
 NullPointerException - if other is null, or if unit is null, or if scheduler is null
 Since:
 2.0
 - to
```
@CheckReturnValue@SchedulerSupport(value="none")public final <R> R to(Function<? superSingle<T>,R> convert)
```
 Calls the specified converter function with the current Single instance during assembly time and returns its result.
 Scheduler:
 to does not operate by default on a particularScheduler.
 Type Parameters:
 R - the result type
 Parameters:
 convert - the function that is called with the current Single instance during assembly time that should return some value to be the result
 Returns:
 the value returned by the convert function
 - toCompletable
```
@CheckReturnValue@SchedulerSupport(value="none")@Deprecatedpublic final Completable toCompletable()
```
 Deprecated. seeignoreElement() instead, will be removed in 3.0
 Returns aCompletable that discards result of theSingle and callsonComplete when this sourceSingle callsonSuccess. Error terminal event is propagated.
 Scheduler:
 toCompletable does not operate by default on a particularScheduler.
 Returns:
 aCompletable that callsonComplete on it's subscriber when the sourceSingle callsonSuccess.
 Since:
 2.0
 - ignoreElement
```
@CheckReturnValue@SchedulerSupport(value="none")public final Completable ignoreElement()
```
 Returns aCompletable that ignores the success value of thisSingle and callsonComplete instead on the returnedCompletable.
 Scheduler:
 ignoreElement does not operate by default on a particularScheduler.
 Returns:
 aCompletable that callsonComplete on it's observer when the sourceSingle callsonSuccess.
 Since:
 2.1.13
 - toFlowable
```
@BackpressureSupport(value=FULL)@CheckReturnValue@SchedulerSupport(value="none")public final Flowable<T> toFlowable()
```
 Converts this Single into aFlowable.
 Backpressure:
 The returnedFlowable honors the backpressure of the downstream consumer.
 Scheduler:
 toFlowable does not operate by default on a particularScheduler.
 Returns:
 aFlowable that emits a single item T or an error.
 - toFuture
```
@CheckReturnValue@SchedulerSupport(value="none")public final Future<T> toFuture()
```
 Returns aFuture representing the single value emitted by thisSingle.
 Scheduler:
 toFuture does not operate by default on a particularScheduler.
 Returns:
 aFuture that expects a single item to be emitted by thisSingle
 See Also:
 ReactiveX documentation: To
 - toMaybe
```
@CheckReturnValue@SchedulerSupport(value="none")public final Maybe<T> toMaybe()
```
 Converts this Single into aMaybe.
 Scheduler:
 toMaybe does not operate by default on a particularScheduler.
 Returns:
 aMaybe that emits a single item T or an error.
 - toObservable
```
@CheckReturnValue@SchedulerSupport(value="none")public final Observable<T> toObservable()
```
 Converts this Single into anObservable.
 Scheduler:
 toObservable does not operate by default on a particularScheduler.
 Returns:
 anObservable that emits a single item T or an error.
 - unsubscribeOn
```
@CheckReturnValue@NonNull@SchedulerSupport(value="custom")public final Single<T> unsubscribeOn(Scheduler scheduler)
```
 Returns a Single which makes sure when a SingleObserver disposes the Disposable, that call is propagated up on the specified scheduler.
 Scheduler:
 unsubscribeOn calls dispose() of the upstream on theScheduler you specify.
 History: 2.0.9 - experimental
 Parameters:
 scheduler - the target scheduler where to execute the disposal
 Returns:
 the new Single instance
 Throws:
 NullPointerException - if scheduler is null
 Since:
 2.2
 - zipWith
```
@CheckReturnValue@SchedulerSupport(value="none")public final <U,R> Single<R> zipWith(SingleSource other,BiFunction<? superT,? super U,? extends R> zipper)
```
 Returns a Single that emits the result of applying a specified function to the pair of items emitted by the source Single and another specified Single.
 Scheduler:
 zipWith does not operate by default on a particularScheduler.
 Type Parameters:
 U - the type of items emitted by theother Single
 R - the type of items emitted by the resulting Single
 Parameters:
 other - the other SingleSource
 zipper - a function that combines the pairs of items from the two SingleSources to generate the items to be emitted by the resulting Single
 Returns:
 a Single that pairs up values from the source Single and theother SingleSource and emits the results ofzipFunction applied to these pairs
 See Also:
 ReactiveX operators documentation: Zip
 - test
```
@CheckReturnValue@SchedulerSupport(value="none")public final TestObserver<T> test()
```
 Creates a TestObserver and subscribes it to this Single.
 Scheduler:
 test does not operate by default on a particularScheduler.
 Returns:
 the new TestObserver instance
 Since:
 2.0
 - test
```
@CheckReturnValue@SchedulerSupport(value="none")public final TestObserver<T> test(boolean cancelled)
```
 Creates a TestObserver optionally in cancelled state, then subscribes it to this Single.
 Scheduler:
 test does not operate by default on a particularScheduler.
 Parameters:
 cancelled - if true, the TestObserver will be cancelled before subscribing to this Single.
 Returns:
 the new TestObserver instance
 Since:
 2.0

Movatterモバイル変換

Class Single<T>

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

Single

Method Detail

amb

ambArray

concat

concat

concat

concat

concat

concat

concat

concatArray

concatArrayEager

concatEager

concatEager

create

defer

error

error

fromCallable

fromFuture

fromFuture

fromFuture

fromFuture

fromPublisher

fromObservable

just

merge

merge

merge

merge

merge

merge

mergeDelayError

mergeDelayError

mergeDelayError

mergeDelayError

mergeDelayError

never

timer

timer

equals

unsafeCreate

using

using

wrap

zip

zip

zip

zip

zip

zip

zip

zip

zip

zipArray

ambWith

as

hide

compose

cache

cast

concatWith

delay

delay

delay

delay

delaySubscription

delaySubscription

delaySubscription

delaySubscription

delaySubscription

delaySubscription

dematerialize