Uses of Class
io.reactivex.rxjava3.core.Single

Packages that use Single

Package	Description
io.reactivex.rxjava3.core	Base reactive classes: Flowable, Observable, Single, Maybe and Completable; base reactive consumers; other common base interfaces.
io.reactivex.rxjava3.internal.jdk8
io.reactivex.rxjava3.internal.operators.completable
io.reactivex.rxjava3.internal.operators.flowable
io.reactivex.rxjava3.internal.operators.maybe
io.reactivex.rxjava3.internal.operators.observable
io.reactivex.rxjava3.internal.operators.single
io.reactivex.rxjava3.plugins	Contains the central plugin handler RxJavaPlugins class to hook into the lifecycle of the base reactive types and schedulers.
io.reactivex.rxjava3.subjects	Classes representing so-called hot sources, aka subjects, that implement a base reactive class and the respective consumer type at once to allow forms of multicasting events to multiple consumers as well as consuming another base reactive type of their kind.

Uses of Single in io.reactivex.rxjava3.core

Methods in io.reactivex.rxjava3.core that return Single

Modifier and Type	Method	Description
final @NonNull Single<Boolean>	Flowable.all(@NonNull Predicate<? super @NonNull T> predicate)	Returns a Single that emits a Boolean that indicates whether all of the items emitted by the current Flowable satisfy a condition.
final @NonNull Single<Boolean>	Observable.all(@NonNull Predicate<? super @NonNull T> predicate)	Returns a Single that emits a Boolean that indicates whether all of the items emitted by the current Observable satisfy a condition.
static <@NonNull T> @NonNull Single<T>	Single.amb(@NonNull Iterable<@NonNull ? extends SingleSource<? extends @NonNull T>> sources)	Runs multiple SingleSources and signals the events of the first one that signals (disposing the rest).
static <@NonNull T> @NonNull Single<T>	Single.ambArray(@NonNull SingleSource<? extends @NonNull T>... sources)	Runs multiple SingleSources and signals the events of the first one that signals (disposing the rest).
final @NonNull Single<T>	Single.ambWith(@NonNull SingleSource<? extends @NonNull T> other)	Signals the event of this or the other SingleSource whichever signals first.
final <@NonNull T> @NonNull Single<T>	Completable.andThen(@NonNull SingleSource<@NonNull T> next)	Returns a Single which will subscribe to this Completable and once that is completed then will subscribe to the next SingleSource.
final @NonNull Single<Boolean>	Flowable.any(@NonNull Predicate<? super @NonNull T> predicate)	Returns a Single that emits true if any item emitted by the current Flowable satisfies a specified condition, otherwise false.
final @NonNull Single<Boolean>	Observable.any(@NonNull Predicate<? super @NonNull T> predicate)	Returns a Single that emits true if any item emitted by the current Observable satisfies a specified condition, otherwise false.
final @NonNull Single<T>	Single.cache()	Stores the success value or exception from the current Single and replays it to late SingleObservers.
final <@NonNull U> @NonNull Single<U>	Single.cast(@NonNull Class<? extends @NonNull U> clazz)	Casts the success value of the current Single into the target type or signals a ClassCastException if not compatible.
final <@NonNull U> @NonNull Single<U>	Flowable.collect(@NonNull Supplier<? extends @NonNull U> initialItemSupplier, @NonNull BiConsumer<? super @NonNull U, ? super @NonNull T> collector)	Collects items emitted by the finite source Publisher into a single mutable data structure and returns a Single that emits this structure.
final <@NonNull R, @Nullable A> @NonNull Single<R>	Flowable.collect(@NonNull Collector<? super @NonNull T, @Nullable A, @NonNull R> collector)	Collects the finite upstream's values into a container via a Stream Collector callback set and emits it as the success result.
final <@NonNull U> @NonNull Single<U>	Observable.collect(@NonNull Supplier<? extends @NonNull U> initialItemSupplier, @NonNull BiConsumer<? super @NonNull U, ? super @NonNull T> collector)	Collects items emitted by the finite source Observable into a single mutable data structure and returns a Single that emits this structure.
final <@NonNull R, @Nullable A> @NonNull Single<R>	Observable.collect(@NonNull Collector<? super @NonNull T, @Nullable A, @NonNull R> collector)	Collects the finite upstream's values into a container via a Stream Collector callback set and emits it as the success result as a Single.
final <@NonNull U> @NonNull Single<U>	Flowable.collectInto(@NonNull U initialItem, @NonNull BiConsumer<? super @NonNull U, ? super @NonNull T> collector)	Collects items emitted by the finite source Publisher into a single mutable data structure and returns a Single that emits this structure.
final <@NonNull U> @NonNull Single<U>	Observable.collectInto(@NonNull U initialItem, @NonNull BiConsumer<? super @NonNull U, ? super @NonNull T> collector)	Collects items emitted by the finite source Observable into a single mutable data structure and returns a Single that emits this structure.
final <@NonNull R> @NonNull Single<R>	Single.compose(@NonNull SingleTransformer<? super @NonNull T, ? extends @NonNull R> transformer)	Transform a Single by applying a particular SingleTransformer function to it.
final <@NonNull R> @NonNull Single<R>	Single.concatMap(@NonNull Function<? super @NonNull T, ? extends SingleSource<? extends @NonNull R>> mapper)	Returns a Single that is based on applying a specified function to the item emitted by the current Single, where that function returns a SingleSource.
final @NonNull Single<Boolean>	Flowable.contains(@NonNull Object item)	Returns a Single that emits a Boolean that indicates whether the current Flowable emitted a specified item.
final @NonNull Single<Boolean>	Maybe.contains(@NonNull Object item)	Returns a Single that emits a Boolean that indicates whether the current Maybe emitted a specified item.
final @NonNull Single<Boolean>	Observable.contains(@NonNull Object item)	Returns a Single that emits a Boolean that indicates whether the current Observable emitted a specified item.
final @NonNull Single<Boolean>	Single.contains(@NonNull Object item)	Signals true if the current Single signals a success value that is Object.equals(Object) with the value provided.
final @NonNull Single<Boolean>	Single.contains(@NonNull Object item, @NonNull BiPredicate<Object,Object> comparer)	Signals true if the current Single signals a success value that is equal with the value provided by calling a BiPredicate.
final @NonNull Single<Long>	Flowable.count()	Returns a Single that counts the total number of items emitted by the current Flowable and emits this count as a 64-bit Long.
final @NonNull Single<Long>	Maybe.count()	Returns a Single that counts the total number of items emitted (0 or 1) by the current Maybe and emits this count as a 64-bit Long.
final @NonNull Single<Long>	Observable.count()	Returns a Single that counts the total number of items emitted by the current Observable and emits this count as a 64-bit Long.
static <@NonNull T> @NonNull Single<T>	Single.create(@NonNull SingleOnSubscribe<@NonNull T> source)	Provides an API (via a cold Single) that bridges the reactive world with the callback-style world.
final @NonNull Single<T>	Maybe.defaultIfEmpty(@NonNull T defaultItem)	Returns a Single that emits the item emitted by the current Maybe or a specified default item if the current Maybe is empty.
static <@NonNull T> @NonNull Single<T>	Single.defer(@NonNull Supplier<? extends @NonNull SingleSource<? extends @NonNull T>> supplier)	Calls a Supplier for each individual SingleObserver to return the actual SingleSource to be subscribed to.
final @NonNull Single<T>	Single.delay(long time, @NonNull TimeUnit unit)	Delays the emission of the success signal from the current Single by the specified amount.
final @NonNull Single<T>	Single.delay(long time, @NonNull TimeUnit unit, boolean delayError)	Delays the emission of the success or error signal from the current Single by the specified amount.
final @NonNull Single<T>	Single.delay(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)	Delays the emission of the success signal from the current Single by the specified amount.
final @NonNull Single<T>	Single.delay(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean delayError)	Delays the emission of the success or error signal from the current Single by the specified amount.
final @NonNull Single<T>	Single.delaySubscription(long time, @NonNull TimeUnit unit)	Delays the actual subscription to the current Single until the given time delay elapsed.
final @NonNull Single<T>	Single.delaySubscription(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)	Delays the actual subscription to the current Single until the given time delay elapsed.
final @NonNull Single<T>	Single.delaySubscription(@NonNull CompletableSource subscriptionIndicator)	Delays the actual subscription to the current Single until the given other CompletableSource completes.
final <@NonNull U> @NonNull Single<T>	Single.delaySubscription(@NonNull ObservableSource<@NonNull U> subscriptionIndicator)	Delays the actual subscription to the current Single until the given other ObservableSource signals its first value or completes.
final <@NonNull U> @NonNull Single<T>	Single.delaySubscription(@NonNull SingleSource<@NonNull U> subscriptionIndicator)	Delays the actual subscription to the current Single until the given other SingleSource signals success.
final <@NonNull U> @NonNull Single<T>	Single.delaySubscription(@NonNull org.reactivestreams.Publisher<@NonNull U> subscriptionIndicator)	Delays the actual subscription to the current Single until the given other Publisher signals its first value or completes.
final @NonNull Single<T>	Single.doAfterSuccess(@NonNull Consumer<? super @NonNull T> onAfterSuccess)	Calls the specified consumer with the success item after this item has been emitted to the downstream.
final @NonNull Single<T>	Single.doAfterTerminate(@NonNull Action onAfterTerminate)	Registers an Action to be called after this Single invokes either onSuccess or onError.
final @NonNull Single<T>	Single.doFinally(@NonNull Action onFinally)	Calls the specified action after this Single signals onSuccess or onError or gets disposed by the downstream.
final @NonNull Single<T>	Single.doOnDispose(@NonNull Action onDispose)	Calls the shared Action if a SingleObserver subscribed to the current Single disposes the common Disposable it received via onSubscribe.
final @NonNull Single<T>	Single.doOnError(@NonNull Consumer<? super Throwable> onError)	Calls the shared consumer with the error sent via onError for each SingleObserver that subscribes to the current Single.
final @NonNull Single<T>	Single.doOnEvent(@NonNull BiConsumer<@Nullable ? super @NonNull T, @Nullable ? super Throwable> 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.
final @NonNull Single<T>	Single.doOnLifecycle(@NonNull Consumer<? super Disposable> onSubscribe, @NonNull Action onDispose)	Calls the appropriate onXXX method (shared between all SingleObservers) for the lifecycle events of the sequence (subscription, disposal).
final @NonNull Single<T>	Single.doOnSubscribe(@NonNull Consumer<? super Disposable> onSubscribe)	Calls the shared consumer with the Disposable sent through the onSubscribe for each SingleObserver that subscribes to the current Single.
final @NonNull Single<T>	Single.doOnSuccess(@NonNull Consumer<? super @NonNull T> onSuccess)	Calls the shared consumer with the success value sent via onSuccess for each SingleObserver that subscribes to the current Single.
final @NonNull Single<T>	Single.doOnTerminate(@NonNull Action onTerminate)	Returns a Single instance that calls the given onTerminate callback just before this Single completes normally or with an exception.
final @NonNull Single<T>	Flowable.elementAt(long index, @NonNull T defaultItem)	Returns a Single that emits the item found at a specified index in a sequence of emissions from this Flowable, or a default item if that index is out of range.
final @NonNull Single<T>	Observable.elementAt(long index, @NonNull T defaultItem)	Returns a Single that emits the item found at a specified index in a sequence of emissions from the current Observable, or a default item if that index is out of range.
final @NonNull Single<T>	Flowable.elementAtOrError(long index)	Returns a Single that emits the item found at a specified index in a sequence of emissions from this Flowable or signals a NoSuchElementException if this Flowable has fewer elements than index.
final @NonNull Single<T>	Observable.elementAtOrError(long index)	Returns a Single that emits the item found at a specified index in a sequence of emissions from the current Observable or signals a NoSuchElementException if the current Observable signals fewer elements than index.
static <@NonNull T> @NonNull Single<T>	Single.error(@NonNull Supplier<? extends @NonNull Throwable> supplier)	Signals a Throwable returned by the callback function for each individual SingleObserver.
static <@NonNull T> @NonNull Single<T>	Single.error(@NonNull Throwable throwable)	Returns a Single that invokes a subscriber's onError method when the subscriber subscribes to it.
final @NonNull Single<T>	Flowable.first(@NonNull T defaultItem)	Returns a Single that emits only the very first item emitted by this Flowable, or a default item if this Flowable completes without emitting anything.
final @NonNull Single<T>	Observable.first(@NonNull T defaultItem)	Returns a Single that emits only the very first item emitted by the current Observable, or a default item if the current Observable completes without emitting any items.
final @NonNull Single<T>	Flowable.firstOrError()	Returns a Single that emits only the very first item emitted by this Flowable or signals a NoSuchElementException if this Flowable is empty.
final @NonNull Single<T>	Observable.firstOrError()	Returns a Single that emits only the very first item emitted by the current Observable or signals a NoSuchElementException if the current Observable is empty.
final <@NonNull R> @NonNull Single<R>	Single.flatMap(@NonNull Function<? super @NonNull T, ? extends SingleSource<? extends @NonNull R>> mapper)	Returns a Single that is based on applying a specified function to the item emitted by the current Single, where that function returns a SingleSource.
final <@NonNull R> @NonNull Single<R>	Single.flatMap(@NonNull Function<? super @NonNull T, ? extends SingleSource<? extends @NonNull R>> onSuccessMapper, @NonNull Function<? super Throwable, ? extends SingleSource<? extends @NonNull R>> onErrorMapper)	Maps the onSuccess or onError signals of the current Single into a SingleSource and emits that SingleSource's signals.
final <@NonNull U, @NonNull R> @NonNull Single<R>	Single.flatMap(@NonNull Function<? super @NonNull T, ? extends SingleSource<? extends @NonNull U>> mapper, @NonNull BiFunction<? super @NonNull T, ? super @NonNull U, ? extends @NonNull R> combiner)	Returns a Single that emits the results of a specified function to the pair of values emitted by the current Single and a specified mapped SingleSource.
static <@NonNull T> @NonNull Single<T>	Single.fromCallable(@NonNull Callable<? extends @NonNull T> callable)	Returns a Single that invokes the given Callable for each incoming SingleObserver and emits its value or exception to them.
static <@NonNull T> @NonNull Single<@NonNull T>	Single.fromCompletionStage(@NonNull CompletionStage<@NonNull T> stage)	Signals the completion value or error of the given (hot) CompletionStage-based asynchronous calculation.
static <@NonNull T> @NonNull Single<T>	Single.fromFuture(@NonNull Future<? extends @NonNull T> future)	Converts a Future into a Single and awaits its outcome in a blocking fashion.
static <@NonNull T> @NonNull Single<T>	Single.fromFuture(@NonNull Future<? extends @NonNull T> future, long timeout, @NonNull TimeUnit unit)	Converts a Future into a Single and awaits its outcome, or timeout, in a blocking fashion.
static <@NonNull T> @NonNull Single<T>	Single.fromMaybe(@NonNull MaybeSource<@NonNull T> maybe)	Returns a Single instance that when subscribed to, subscribes to the MaybeSource instance and emits onSuccess as a single item, turns an onComplete into NoSuchElementException error signal or forwards the onError signal.
static <@NonNull T> @NonNull Single<T>	Single.fromMaybe(@NonNull MaybeSource<@NonNull T> maybe, @NonNull T defaultItem)	Returns a Single instance that when subscribed to, subscribes to the MaybeSource instance and emits onSuccess as a single item, emits the defaultItem for an onComplete signal or forwards the onError signal.
static <@NonNull T> @NonNull Single<T>	Single.fromObservable(@NonNull ObservableSource<? extends @NonNull T> observable)	Wraps a specific ObservableSource into a Single and signals its single element or error.
static <@NonNull T> @NonNull Single<T>	Single.fromPublisher(@NonNull org.reactivestreams.Publisher<? extends @NonNull T> publisher)	Wraps a specific Publisher into a Single and signals its single element or error.
static <@NonNull T> @NonNull Single<T>	Single.fromSupplier(@NonNull Supplier<? extends @NonNull T> supplier)	Returns a Single that invokes passed supplier and emits its result for each individual SingleObserver that subscribes.
final @NonNull Single<T>	Single.hide()	Hides the identity of the current Single, including the Disposable that is sent to the downstream via onSubscribe().
final @NonNull Single<Boolean>	Flowable.isEmpty()	Returns a Single that emits true if the current Flowable is empty, otherwise false.
final @NonNull Single<Boolean>	Maybe.isEmpty()	Returns a Single that emits true if the current Maybe is empty, otherwise false.
final @NonNull Single<Boolean>	Observable.isEmpty()	Returns a Single that emits true if the current Observable is empty, otherwise false.
static <@NonNull T> @NonNull Single<T>	Single.just(@NonNull T item)	Returns a Single that emits a specified item.
final @NonNull Single<T>	Flowable.last(@NonNull T defaultItem)	Returns a Single that emits only the last item emitted by this Flowable, or a default item if this Flowable completes without emitting any items.
final @NonNull Single<T>	Observable.last(@NonNull T defaultItem)	Returns a Single that emits only the last item emitted by the current Observable, or a default item if the current Observable completes without emitting any items.
final @NonNull Single<T>	Flowable.lastOrError()	Returns a Single that emits only the last item emitted by this Flowable or signals a NoSuchElementException if this Flowable is empty.
final @NonNull Single<T>	Observable.lastOrError()	Returns a Single that emits only the last item emitted by the current Observable or signals a NoSuchElementException if the current Observable is empty.
final <@NonNull R> @NonNull Single<R>	Single.lift(@NonNull SingleOperator<? extends @NonNull R, ? super @NonNull T> 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.
final <@NonNull R> @NonNull Single<R>	Single.map(@NonNull Function<? super @NonNull T, ? extends @NonNull R> mapper)	Returns a Single that applies a specified function to the item emitted by the current Single and emits the result of this function application.
final <@NonNull T> @NonNull Single<Notification<T>>	Completable.materialize()	Maps the signal types of this Completable into a Notification of the same kind and emits it as a single success value to downstream.
final @NonNull Single<Notification<T>>	Maybe.materialize()	Maps the signal types of this Maybe into a Notification of the same kind and emits it as a Single's onSuccess value to downstream.
final @NonNull Single<Notification<T>>	Single.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 <@NonNull T> @NonNull Single<T>	Single.merge(@NonNull SingleSource<? extends SingleSource<? extends @NonNull T>> source)	Flattens a SingleSource that emits a SingleSingle into a single Single that emits the item emitted by the nested SingleSource, without any transformation.
static <@NonNull T> @NonNull Single<T>	Single.never()	Returns a singleton instance of a never-signaling Single (only calls onSubscribe).
final @NonNull Single<T>	Single.observeOn(@NonNull Scheduler scheduler)	Signals the success item or the terminal signals of the current Single on the specified Scheduler, asynchronously.
final @NonNull Single<T>	Single.onErrorResumeNext(@NonNull Function<? super Throwable, ? extends SingleSource<? extends @NonNull T>> fallbackSupplier)	Resumes the flow with a SingleSource returned for the failure Throwable of the current Single by a function instead of signaling the error via onError.
final @NonNull Single<T>	Single.onErrorResumeWith(@NonNull SingleSource<? extends @NonNull T> fallback)	Resumes the flow with the given SingleSource when the current Single fails instead of signaling the error via onError.
final @NonNull Single<T>	Single.onErrorReturn(@NonNull Function<Throwable, ? extends @NonNull T> itemSupplier)	Ends the flow with a success item returned by a function for the Throwable error signaled by the current Single instead of signaling the error via onError.
final @NonNull Single<T>	Single.onErrorReturnItem(@NonNull T item)	Signals the specified value as success in case the current Single signals an error.
final @NonNull Single<T>	Single.onTerminateDetach()	Nulls out references to the upstream producer and downstream SingleObserver if the sequence is terminated or downstream calls dispose().
final <@NonNull R> @NonNull Single<R>	Flowable.reduce(@NonNull R seed, @NonNull BiFunction<@NonNull R, ? super @NonNull T, @NonNull R> reducer)	Returns a Single that applies a specified accumulator function to the first item emitted by the current Flowable and a specified seed value, then feeds the result of that function along with the second item emitted by the current Flowable into the same function, and so on until all items have been emitted by the current and finite Flowable, emitting the final result from the final call to your function as its sole item.
final <@NonNull R> @NonNull Single<R>	Observable.reduce(@NonNull R seed, @NonNull BiFunction<@NonNull R, ? super @NonNull T, @NonNull R> reducer)	Returns a Single that applies a specified accumulator function to the first item emitted by the current Observable and a specified seed value, then feeds the result of that function along with the second item emitted by the current Observable into the same function, and so on until all items have been emitted by the current and finite Observable, emitting the final result from the final call to your function as its sole item.
final <@NonNull R> @NonNull Single<R>	Flowable.reduceWith(@NonNull Supplier<@NonNull R> seedSupplier, @NonNull BiFunction<@NonNull R, ? super @NonNull T, @NonNull R> reducer)	Returns a Single that applies a specified accumulator function to the first item emitted by the current Flowable and a seed value derived from calling a specified seedSupplier, then feeds the result of that function along with the second item emitted by the current Flowable into the same function, and so on until all items have been emitted by the current and finite Flowable, emitting the final result from the final call to your function as its sole item.
final <@NonNull R> @NonNull Single<R>	Observable.reduceWith(@NonNull Supplier<@NonNull R> seedSupplier, @NonNull BiFunction<@NonNull R, ? super @NonNull T, @NonNull R> reducer)	Returns a Single that applies a specified accumulator function to the first item emitted by the current Observable and a seed value derived from calling a specified seedSupplier, then feeds the result of that function along with the second item emitted by the current Observable into the same function, and so on until all items have been emitted by the current and finite Observable, emitting the final result from the final call to your function as its sole item.
final @NonNull Single<T>	Single.retry()	Repeatedly re-subscribes to the current Single indefinitely if it fails with an onError.
final @NonNull Single<T>	Single.retry(long times)	Repeatedly re-subscribe at most the specified times to the current Single if it fails with an onError.
final @NonNull Single<T>	Single.retry(long times, @NonNull Predicate<? super Throwable> predicate)	Repeatedly re-subscribe at most times or until the predicate returns false, whichever happens first if it fails with an onError.
final @NonNull Single<T>	Single.retry(@NonNull BiPredicate<? super Integer, ? super Throwable> predicate)	Re-subscribe to the current Single if the given predicate returns true when the Single fails with an onError.
final @NonNull Single<T>	Single.retry(@NonNull Predicate<? super Throwable> predicate)	Re-subscribe to the current Single if the given predicate returns true when the Single fails with an onError.
final @NonNull Single<T>	Single.retryUntil(@NonNull BooleanSupplier stop)	Retries until the given stop function returns true.
final @NonNull Single<T>	Single.retryWhen(@NonNull Function<? super Flowable<Throwable>, @NonNull ? extends org.reactivestreams.Publisher<@NonNull ?>> handler)	Re-subscribes to the current Single if and when the Publisher returned by the handler function signals a value.
static @NonNull Single<Boolean>	Completable.sequenceEqual(@NonNull CompletableSource source1, @NonNull CompletableSource source2)	Compares two CompletableSources and emits true via a Single if both complete.
static <@NonNull T> @NonNull Single<Boolean>	Flowable.sequenceEqual(@NonNull org.reactivestreams.Publisher<? extends @NonNull T> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T> source2)	Returns a Single that emits a Boolean value that indicates whether two Publisher sequences are the same by comparing the items emitted by each Publisher pairwise.
static <@NonNull T> @NonNull Single<Boolean>	Flowable.sequenceEqual(@NonNull org.reactivestreams.Publisher<? extends @NonNull T> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T> source2, int bufferSize)	Returns a Single that emits a Boolean value that indicates whether two Publisher sequences are the same by comparing the items emitted by each Publisher pairwise.
static <@NonNull T> @NonNull Single<Boolean>	Flowable.sequenceEqual(@NonNull org.reactivestreams.Publisher<? extends @NonNull T> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T> source2, @NonNull BiPredicate<? super @NonNull T, ? super @NonNull T> isEqual)	Returns a Single that emits a Boolean value that indicates whether two Publisher sequences are the same by comparing the items emitted by each Publisher pairwise based on the results of a specified equality function.
static <@NonNull T> @NonNull Single<Boolean>	Flowable.sequenceEqual(@NonNull org.reactivestreams.Publisher<? extends @NonNull T> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T> source2, @NonNull BiPredicate<? super @NonNull T, ? super @NonNull T> isEqual, int bufferSize)	Returns a Single that emits a Boolean value that indicates whether two Publisher sequences are the same by comparing the items emitted by each Publisher pairwise based on the results of a specified equality function.
static <@NonNull T> @NonNull Single<Boolean>	Maybe.sequenceEqual(@NonNull MaybeSource<? extends @NonNull T> source1, @NonNull MaybeSource<? extends @NonNull T> source2)	Returns a Single that emits a Boolean value that indicates whether two MaybeSource sequences are the same by comparing the items emitted by each MaybeSource pairwise.
static <@NonNull T> @NonNull Single<Boolean>	Maybe.sequenceEqual(@NonNull MaybeSource<? extends @NonNull T> source1, @NonNull MaybeSource<? extends @NonNull T> source2, @NonNull BiPredicate<? super @NonNull T, ? super @NonNull T> isEqual)	Returns a Single that emits a Boolean value that indicates whether two MaybeSources are the same by comparing the items emitted by each MaybeSource pairwise based on the results of a specified equality function.
static <@NonNull T> @NonNull Single<Boolean>	Observable.sequenceEqual(@NonNull ObservableSource<? extends @NonNull T> source1, @NonNull ObservableSource<? extends @NonNull T> source2)	Returns a Single that emits a Boolean value that indicates whether two ObservableSource sequences are the same by comparing the items emitted by each ObservableSource pairwise.
static <@NonNull T> @NonNull Single<Boolean>	Observable.sequenceEqual(@NonNull ObservableSource<? extends @NonNull T> source1, @NonNull ObservableSource<? extends @NonNull T> source2, int bufferSize)	Returns a Single that emits a Boolean value that indicates whether two ObservableSource sequences are the same by comparing the items emitted by each ObservableSource pairwise.
static <@NonNull T> @NonNull Single<Boolean>	Observable.sequenceEqual(@NonNull ObservableSource<? extends @NonNull T> source1, @NonNull ObservableSource<? extends @NonNull T> source2, @NonNull BiPredicate<? super @NonNull T, ? super @NonNull T> isEqual)	Returns a Single that emits a Boolean value that indicates whether two ObservableSource sequences are the same by comparing the items emitted by each ObservableSource pairwise based on the results of a specified equality function.
static <@NonNull T> @NonNull Single<Boolean>	Observable.sequenceEqual(@NonNull ObservableSource<? extends @NonNull T> source1, @NonNull ObservableSource<? extends @NonNull T> source2, @NonNull BiPredicate<? super @NonNull T, ? super @NonNull T> isEqual, int bufferSize)	Returns a Single that emits a Boolean value that indicates whether two ObservableSource sequences are the same by comparing the items emitted by each ObservableSource pairwise based on the results of a specified equality function.
static <@NonNull T> @NonNull Single<Boolean>	Single.sequenceEqual(@NonNull SingleSource<? extends @NonNull T> source1, @NonNull SingleSource<? extends @NonNull T> source2)	Compares two SingleSources and emits true if they emit the same value (compared via Object.equals(Object)).
final @NonNull Single<T>	Flowable.single(@NonNull T defaultItem)	Returns a Single that emits the single item emitted by the current Flowable if it emits only a single item, or a default item if the current Flowable emits no items.
final @NonNull Single<T>	Observable.single(@NonNull T defaultItem)	Returns a Single that emits the single item emitted by the current Observable, if the current Observable emits only a single item, or a default item if the current Observable emits no items.
final @NonNull Single<T>	Flowable.singleOrError()	Returns a Single that emits the single item emitted by this Flowable, if this Flowable emits only a single item, otherwise if this Flowable completes without emitting any items a NoSuchElementException will be signaled and if this Flowable emits more than one item, an IllegalArgumentException will be signaled.
final @NonNull Single<T>	Observable.singleOrError()	Returns a Single that emits the single item emitted by the current Observable if it emits only a single item, otherwise if the current Observable completes without emitting any items or emits more than one item a NoSuchElementException or IllegalArgumentException will be signaled respectively.
final @NonNull Single<T>	Single.subscribeOn(@NonNull Scheduler scheduler)	Asynchronously subscribes SingleObservers to this Single on the specified Scheduler.
final @NonNull Single<T>	Maybe.switchIfEmpty(@NonNull SingleSource<? extends @NonNull T> other)	Returns a Single that emits the items emitted by the current Maybe or the item of an alternate SingleSource if the current Maybe is empty.
final @NonNull Single<T>	Single.takeUntil(@NonNull CompletableSource other)	Returns a Single that emits the item emitted by the current Single until a CompletableSource terminates.
final <@NonNull E> @NonNull Single<T>	Single.takeUntil(@NonNull SingleSource<? extends @NonNull E> other)	Returns a Single that emits the item emitted by the current Single until a second Single emits an item.
final <@NonNull E> @NonNull Single<T>	Single.takeUntil(@NonNull org.reactivestreams.Publisher<@NonNull E> other)	Returns a Single that emits the item emitted by the current Single until a Publisher emits an item or completes.
final @NonNull Single<Timed<T>>	Single.timeInterval()	Measures the time (in milliseconds) between the subscription and success item emission of the current Single and signals it as a tuple (Timed) success value.
final @NonNull Single<Timed<T>>	Single.timeInterval(@NonNull Scheduler scheduler)	Measures the time (in milliseconds) between the subscription and success item emission of the current Single and signals it as a tuple (Timed) success value.
final @NonNull Single<Timed<T>>	Single.timeInterval(@NonNull TimeUnit unit)	Measures the time between the subscription and success item emission of the current Single and signals it as a tuple (Timed) success value.
final @NonNull Single<Timed<T>>	Single.timeInterval(@NonNull TimeUnit unit, @NonNull Scheduler scheduler)	Measures the time between the subscription and success item emission of the current Single and signals it as a tuple (Timed) success value.
final @NonNull Single<T>	Single.timeout(long timeout, @NonNull TimeUnit unit)	Signals a TimeoutException if the current Single doesn't signal a success value within the specified timeout window.
final @NonNull Single<T>	Single.timeout(long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)	Signals a TimeoutException if the current Single doesn't signal a success value within the specified timeout window.
final @NonNull Single<T>	Single.timeout(long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, @NonNull SingleSource<? extends @NonNull T> fallback)	Runs the current Single and if it doesn't signal within the specified timeout window, it is disposed and the other SingleSource subscribed to.
final @NonNull Single<T>	Single.timeout(long timeout, @NonNull TimeUnit unit, @NonNull SingleSource<? extends @NonNull T> fallback)	Runs the current Single and if it doesn't signal within the specified timeout window, it is disposed and the other SingleSource subscribed to.
private Single<T>	Single.timeout0(long timeout, TimeUnit unit, Scheduler scheduler, SingleSource<? extends @NonNull T> fallback)
static @NonNull Single<Long>	Single.timer(long delay, @NonNull TimeUnit unit)	Signals success with 0L value after the given delay when a SingleObserver subscribes.
static @NonNull Single<Long>	Single.timer(long delay, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)	Signals success with 0L value on the specified Scheduler after the given delay when a SingleObserver subscribes.
final @NonNull Single<Timed<T>>	Single.timestamp()	Combines the success value from the current Single with the current time (in milliseconds) of its reception, using the computation Scheduler as time source, then signals them as a Timed instance.
final @NonNull Single<Timed<T>>	Single.timestamp(@NonNull Scheduler scheduler)	Combines the success value from the current Single with the current time (in milliseconds) of its reception, using the given Scheduler as time source, then signals them as a Timed instance.
final @NonNull Single<Timed<T>>	Single.timestamp(@NonNull TimeUnit unit)	Combines the success value from the current Single with the current time of its reception, using the computation Scheduler as time source, then signals it as a Timed instance.
final @NonNull Single<Timed<T>>	Single.timestamp(@NonNull TimeUnit unit, @NonNull Scheduler scheduler)	Combines the success value from the current Single with the current time of its reception, using the given Scheduler as time source, then signals it as a Timed instance.
final @NonNull Single<List<T>>	Flowable.toList()	Returns a Single that emits a single item, a list composed of all the items emitted by the finite upstream source Publisher.
final @NonNull Single<List<T>>	Flowable.toList(int capacityHint)	Returns a Single that emits a single item, a list composed of all the items emitted by the finite source Publisher.
final <@NonNull U extends Collection<? super @NonNull T>> @NonNull Single<U>	Flowable.toList(@NonNull Supplier<@NonNull U> collectionSupplier)	Returns a Single that emits a single item, a list composed of all the items emitted by the finite source Publisher.
final @NonNull Single<@NonNull List<T>>	Observable.toList()	Returns a Single that emits a single item, a List composed of all the items emitted by the current and finite Observable.
final @NonNull Single<@NonNull List<T>>	Observable.toList(int capacityHint)	Returns a Single that emits a single item, a List composed of all the items emitted by the current and finite Observable.
final <@NonNull U extends Collection<? super @NonNull T>> @NonNull Single<U>	Observable.toList(@NonNull Supplier<@NonNull U> collectionSupplier)	Returns a Single that emits a single item, a Collection (subclass) composed of all the items emitted by the finite upstream Observable.
final <@NonNull K> @NonNull Single<Map<K,T>>	Flowable.toMap(@NonNull Function<? super @NonNull T, ? extends @NonNull K> keySelector)	Returns a Single that emits a single HashMap containing all items emitted by the finite source Publisher, mapped by the keys returned by a specified keySelector function.
final <@NonNull K, @NonNull V> @NonNull Single<Map<K,V>>	Flowable.toMap(@NonNull Function<? super @NonNull T, ? extends @NonNull K> keySelector, @NonNull Function<? super @NonNull T, ? extends @NonNull V> valueSelector)	Returns a Single that emits a single HashMap containing values corresponding to items emitted by the finite source Publisher, mapped by the keys returned by a specified keySelector function.
final <@NonNull K, @NonNull V> @NonNull Single<Map<K,V>>	Flowable.toMap(@NonNull Function<? super @NonNull T, ? extends @NonNull K> keySelector, @NonNull Function<? super @NonNull T, ? extends @NonNull V> valueSelector, @NonNull Supplier<? extends Map<@NonNull K, @NonNull V>> mapSupplier)	Returns a Single that emits a single Map, returned by a specified mapFactory function, that contains keys and values extracted from the items emitted by the finite source Publisher.
final <@NonNull K> @NonNull Single<@NonNull Map<K,T>>	Observable.toMap(@NonNull Function<? super @NonNull T, ? extends @NonNull K> keySelector)	Returns a Single that emits a single HashMap containing all items emitted by the current and finite Observable, mapped by the keys returned by a specified keySelector function.
final <@NonNull K, @NonNull V> @NonNull Single<Map<K,V>>	Observable.toMap(@NonNull Function<? super @NonNull T, ? extends @NonNull K> keySelector, @NonNull Function<? super @NonNull T, ? extends @NonNull V> valueSelector)	Returns a Single that emits a single HashMap containing values corresponding to items emitted by the current and finite Observable, mapped by the keys and values returned by the given selector functions.
final <@NonNull K, @NonNull V> @NonNull Single<Map<K,V>>	Observable.toMap(@NonNull Function<? super @NonNull T, ? extends @NonNull K> keySelector, @NonNull Function<? super @NonNull T, ? extends @NonNull V> valueSelector, @NonNull Supplier<? extends Map<@NonNull K, @NonNull V>> mapSupplier)	Returns a Single that emits a single Map (subclass), returned by a specified mapFactory function, that contains keys and values extracted from the items, via selector functions, emitted by the current and finite Observable.
final <@NonNull K> @NonNull Single<Map<K, Collection<T>>>	Flowable.toMultimap(@NonNull Function<? super @NonNull T, ? extends @NonNull K> keySelector)	Returns a Single that emits a single HashMap that contains an ArrayList of items emitted by the finite source Publisher keyed by a specified keySelector function.
final <@NonNull K, @NonNull V> @NonNull Single<Map<K, Collection<V>>>	Flowable.toMultimap(@NonNull Function<? super @NonNull T, ? extends @NonNull K> keySelector, @NonNull Function<? super @NonNull T, ? extends @NonNull V> valueSelector)	Returns a Single that emits a single HashMap that contains an ArrayList of values extracted by a specified valueSelector function from items emitted by the finite source Publisher, keyed by a specified keySelector function.
final <@NonNull K, @NonNull V> @NonNull Single<Map<K, Collection<V>>>	Flowable.toMultimap(@NonNull Function<? super @NonNull T, ? extends @NonNull K> keySelector, @NonNull Function<? super @NonNull T, ? extends @NonNull V> valueSelector, @NonNull Supplier<? extends Map<@NonNull K, Collection<@NonNull V>>> mapSupplier, @NonNull Function<? super @NonNull K, ? extends Collection<? super @NonNull V>> collectionFactory)	Returns a Single that emits a single Map, returned by a specified mapFactory function, that contains a custom collection of values, extracted by a specified valueSelector function from items emitted by the finite source Publisher, and keyed by the keySelector function.
final <@NonNull K, @NonNull V> @NonNull Single<Map<K, Collection<V>>>	Flowable.toMultimap(@NonNull Function<? super @NonNull T, ? extends @NonNull K> keySelector, @NonNull Function<? super @NonNull T, ? extends @NonNull V> valueSelector, @NonNull Supplier<Map<@NonNull K, Collection<@NonNull V>>> mapSupplier)	Returns a Single that emits a single Map, returned by a specified mapFactory function, that contains an ArrayList of values, extracted by a specified valueSelector function from items emitted by the finite source Publisher and keyed by the keySelector function.
final <@NonNull K> @NonNull Single<@NonNull Map<K, Collection<T>>>	Observable.toMultimap(@NonNull Function<? super @NonNull T, ? extends @NonNull K> keySelector)	Returns a Single that emits a single HashMap that contains an ArrayList of items emitted by the current and finite Observable keyed by a specified keySelector function.
final <@NonNull K, @NonNull V> @NonNull Single<@NonNull Map<K, Collection<V>>>	Observable.toMultimap(@NonNull Function<? super @NonNull T, ? extends @NonNull K> keySelector, @NonNull Function<? super @NonNull T, ? extends @NonNull V> valueSelector, @NonNull Supplier<? extends Map<@NonNull K, Collection<@NonNull V>>> mapSupplier, @NonNull Function<? super @NonNull K, ? extends Collection<? super @NonNull V>> collectionFactory)	Returns a Single that emits a single Map (subclass), returned by a specified mapFactory function, that contains a custom Collection of values, extracted by a specified valueSelector function from items emitted by the current and finite Observable, and keyed by the keySelector function.
final <@NonNull K, @NonNull V> @NonNull Single<@NonNull Map<K, Collection<V>>>	Observable.toMultimap(@NonNull Function<? super @NonNull T, ? extends @NonNull K> keySelector, @NonNull Function<? super @NonNull T, ? extends @NonNull V> valueSelector, @NonNull Supplier<Map<@NonNull K, Collection<@NonNull V>>> mapSupplier)	Returns a Single that emits a single Map (subclass), returned by a specified mapFactory function, that contains an ArrayList of values, extracted by a specified valueSelector function from items emitted by the current and finite Observable and keyed by the keySelector function.
final <@NonNull K, @NonNull V> @NonNull Single<@NonNull Map<K, Collection<V>>>	Observable.toMultimap(@NonNull Function<? super @NonNull T, ? extends @NonNull K> keySelector, Function<? super @NonNull T, ? extends @NonNull V> valueSelector)	Returns a Single that emits a single HashMap that contains an ArrayList of values extracted by a specified valueSelector function from items emitted by the current and finite Observable, keyed by a specified keySelector function.
final <@NonNull T> @NonNull Single<T>	Completable.toSingle(@NonNull Supplier<? extends @NonNull T> completionValueSupplier)	Converts this Completable into a Single which when this Completable completes normally, calls the given Supplier and emits its returned value through onSuccess.
final @NonNull Single<T>	Maybe.toSingle()	Converts this Maybe into a Single instance composing disposal through and turning an empty Maybe into a signal of NoSuchElementException.
private static <T> @NonNull Single<T>	Single.toSingle(@NonNull Flowable<T> source)
final <@NonNull T> @NonNull Single<T>	Completable.toSingleDefault(@NonNull T completionValue)	Converts this Completable into a Single which when this Completable completes normally, emits the given value through onSuccess.
final @NonNull Single<List<T>>	Flowable.toSortedList()	Returns a Single that emits a List that contains the items emitted by the finite source Publisher, in a sorted order.
final @NonNull Single<List<T>>	Flowable.toSortedList(int capacityHint)	Returns a Single that emits a List that contains the items emitted by the finite source Publisher, in a sorted order.
final @NonNull Single<List<T>>	Flowable.toSortedList(@NonNull Comparator<? super @NonNull T> comparator)	Returns a Single that emits a List that contains the items emitted by the finite source Publisher, in a sorted order based on a specified comparison function.
final @NonNull Single<List<T>>	Flowable.toSortedList(@NonNull Comparator<? super @NonNull T> comparator, int capacityHint)	Returns a Single that emits a List that contains the items emitted by the finite source Publisher, in a sorted order based on a specified comparison function.
final @NonNull Single<@NonNull List<T>>	Observable.toSortedList()	Returns a Single that emits a List that contains the items emitted by the current and finite Observable, in a sorted order.
final @NonNull Single<@NonNull List<T>>	Observable.toSortedList(int capacityHint)	Returns a Single that emits a List that contains the items emitted by the current and finite Observable, in a sorted order.
final @NonNull Single<@NonNull List<T>>	Observable.toSortedList(@NonNull Comparator<? super @NonNull T> comparator)	Returns a Single that emits a List that contains the items emitted by the current and finite Observable, in a sorted order based on a specified comparison function.
final @NonNull Single<@NonNull List<T>>	Observable.toSortedList(@NonNull Comparator<? super @NonNull T> comparator, int capacityHint)	Returns a Single that emits a List that contains the items emitted by the current and finite Observable, in a sorted order based on a specified comparison function.
static <@NonNull T> @NonNull Single<T>	Single.unsafeCreate(@NonNull SingleSource<@NonNull T> onSubscribe)	Advanced use only: creates a Single instance without any safeguards by using a callback that is called with a SingleObserver.
final @NonNull Single<T>	Single.unsubscribeOn(@NonNull Scheduler scheduler)	Returns a Single which makes sure when a SingleObserver disposes the Disposable, that call is propagated up on the specified Scheduler.
static <@NonNull T, @NonNull U> @NonNull Single<T>	Single.using(@NonNull Supplier<@NonNull U> resourceSupplier, @NonNull Function<? super @NonNull U, ? extends SingleSource<? extends @NonNull T>> sourceSupplier, @NonNull Consumer<? super @NonNull U> resourceCleanup)	Allows using and disposing a resource while running a SingleSource instance generated from that resource (similar to a try-with-resources).
static <@NonNull T, @NonNull U> @NonNull Single<T>	Single.using(@NonNull Supplier<@NonNull U> resourceSupplier, @NonNull Function<? super @NonNull U, ? extends SingleSource<? extends @NonNull T>> sourceSupplier, @NonNull Consumer<? super @NonNull U> resourceCleanup, boolean eager)	Allows using and disposing a resource while running a SingleSource instance generated from that resource (similar to a try-with-resources).
static <@NonNull T> @NonNull Single<T>	Single.wrap(@NonNull SingleSource<@NonNull T> source)	Wraps a SingleSource instance into a new Single instance if not already a Single instance.
static <@NonNull T1, @NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull T8, @NonNull T9, @NonNull R> @NonNull Single<R>	Single.zip(@NonNull SingleSource<? extends @NonNull T1> source1, @NonNull SingleSource<? extends @NonNull T2> source2, @NonNull SingleSource<? extends @NonNull T3> source3, @NonNull SingleSource<? extends @NonNull T4> source4, @NonNull SingleSource<? extends @NonNull T5> source5, @NonNull SingleSource<? extends @NonNull T6> source6, @NonNull SingleSource<? extends @NonNull T7> source7, @NonNull SingleSource<? extends @NonNull T8> source8, @NonNull SingleSource<? extends @NonNull T9> source9, @NonNull Function9<? super @NonNull T1, ? super @NonNull T2, ? super @NonNull T3, ? super @NonNull T4, ? super @NonNull T5, ? super @NonNull T6, ? super @NonNull T7, ? super @NonNull T8, ? super @NonNull T9, ? extends @NonNull R> zipper)	Returns a Single that emits the results of a specified combiner function applied to nine items emitted by nine other SingleSources.
static <@NonNull T1, @NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull T8, @NonNull R> @NonNull Single<R>	Single.zip(@NonNull SingleSource<? extends @NonNull T1> source1, @NonNull SingleSource<? extends @NonNull T2> source2, @NonNull SingleSource<? extends @NonNull T3> source3, @NonNull SingleSource<? extends @NonNull T4> source4, @NonNull SingleSource<? extends @NonNull T5> source5, @NonNull SingleSource<? extends @NonNull T6> source6, @NonNull SingleSource<? extends @NonNull T7> source7, @NonNull SingleSource<? extends @NonNull T8> source8, @NonNull Function8<? super @NonNull T1, ? super @NonNull T2, ? super @NonNull T3, ? super @NonNull T4, ? super @NonNull T5, ? super @NonNull T6, ? super @NonNull T7, ? super @NonNull T8, ? extends @NonNull R> zipper)	Returns a Single that emits the results of a specified combiner function applied to eight items emitted by eight other SingleSources.
static <@NonNull T1, @NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull R> @NonNull Single<R>	Single.zip(@NonNull SingleSource<? extends @NonNull T1> source1, @NonNull SingleSource<? extends @NonNull T2> source2, @NonNull SingleSource<? extends @NonNull T3> source3, @NonNull SingleSource<? extends @NonNull T4> source4, @NonNull SingleSource<? extends @NonNull T5> source5, @NonNull SingleSource<? extends @NonNull T6> source6, @NonNull SingleSource<? extends @NonNull T7> source7, @NonNull Function7<? super @NonNull T1, ? super @NonNull T2, ? super @NonNull T3, ? super @NonNull T4, ? super @NonNull T5, ? super @NonNull T6, ? super @NonNull T7, ? extends @NonNull R> zipper)	Returns a Single that emits the results of a specified combiner function applied to seven items emitted by seven other SingleSources.
static <@NonNull T1, @NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull R> @NonNull Single<R>	Single.zip(@NonNull SingleSource<? extends @NonNull T1> source1, @NonNull SingleSource<? extends @NonNull T2> source2, @NonNull SingleSource<? extends @NonNull T3> source3, @NonNull SingleSource<? extends @NonNull T4> source4, @NonNull SingleSource<? extends @NonNull T5> source5, @NonNull SingleSource<? extends @NonNull T6> source6, @NonNull Function6<? super @NonNull T1, ? super @NonNull T2, ? super @NonNull T3, ? super @NonNull T4, ? super @NonNull T5, ? super @NonNull T6, ? extends @NonNull R> zipper)	Returns a Single that emits the results of a specified combiner function applied to six items emitted by six other SingleSources.
static <@NonNull T1, @NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull R> @NonNull Single<R>	Single.zip(@NonNull SingleSource<? extends @NonNull T1> source1, @NonNull SingleSource<? extends @NonNull T2> source2, @NonNull SingleSource<? extends @NonNull T3> source3, @NonNull SingleSource<? extends @NonNull T4> source4, @NonNull SingleSource<? extends @NonNull T5> source5, @NonNull Function5<? super @NonNull T1, ? super @NonNull T2, ? super @NonNull T3, ? super @NonNull T4, ? super @NonNull T5, ? extends @NonNull R> zipper)	Returns a Single that emits the results of a specified combiner function applied to five items emitted by five other SingleSources.
static <@NonNull T1, @NonNull T2, @NonNull T3, @NonNull T4, @NonNull R> @NonNull Single<R>	Single.zip(@NonNull SingleSource<? extends @NonNull T1> source1, @NonNull SingleSource<? extends @NonNull T2> source2, @NonNull SingleSource<? extends @NonNull T3> source3, @NonNull SingleSource<? extends @NonNull T4> source4, @NonNull Function4<? super @NonNull T1, ? super @NonNull T2, ? super @NonNull T3, ? super @NonNull T4, ? extends @NonNull R> zipper)	Returns a Single that emits the results of a specified combiner function applied to four items emitted by four other SingleSources.
static <@NonNull T1, @NonNull T2, @NonNull T3, @NonNull R> @NonNull Single<R>	Single.zip(@NonNull SingleSource<? extends @NonNull T1> source1, @NonNull SingleSource<? extends @NonNull T2> source2, @NonNull SingleSource<? extends @NonNull T3> source3, @NonNull Function3<? super @NonNull T1, ? super @NonNull T2, ? super @NonNull T3, ? extends @NonNull R> zipper)	Returns a Single that emits the results of a specified combiner function applied to three items emitted by three other SingleSources.
static <@NonNull T1, @NonNull T2, @NonNull R> @NonNull Single<R>	Single.zip(@NonNull SingleSource<? extends @NonNull T1> source1, @NonNull SingleSource<? extends @NonNull T2> source2, @NonNull BiFunction<? super @NonNull T1, ? super @NonNull T2, ? extends @NonNull R> zipper)	Returns a Single that emits the results of a specified combiner function applied to two items emitted by two other SingleSources.
static <@NonNull T, @NonNull R> @NonNull Single<R>	Single.zip(@NonNull Iterable<@NonNull ? extends SingleSource<? extends @NonNull T>> sources, @NonNull Function<? super Object[], ? extends @NonNull 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 the downstream.
static <@NonNull T, @NonNull R> @NonNull Single<R>	Single.zipArray(@NonNull Function<? super Object[], ? extends @NonNull R> zipper, @NonNull SingleSource<? extends @NonNull 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.
final <@NonNull U, @NonNull R> @NonNull Single<R>	Single.zipWith(@NonNull SingleSource<@NonNull U> other, @NonNull BiFunction<? super @NonNull T, ? super @NonNull U, ? extends @NonNull R> zipper)	Returns a Single that emits the result of applying a specified function to the pair of items emitted by the current Single and another specified SingleSource.

Methods in io.reactivex.rxjava3.core with parameters of type Single

Modifier and Type	Method	Description
R	SingleConverter.apply(@NonNull Single<@NonNull T> upstream)	Applies a function to the upstream Single and returns a converted value of type R.
@NonNull SingleSource<Downstream>	SingleTransformer.apply(@NonNull Single<@NonNull Upstream> upstream)	Applies a function to the upstream Single and returns a SingleSource with optionally different element type.

Uses of Single in io.reactivex.rxjava3.internal.jdk8

Subclasses of Single in io.reactivex.rxjava3.internal.jdk8

Modifier and Type	Class	Description
final class	FlowableCollectWithCollectorSingle<T,A,R>	Collect items into a container defined by a Stream Collector callback set.
final class	ObservableCollectWithCollectorSingle<T,A,R>	Collect items into a container defined by a Stream Collector callback set.
final class	SingleFromCompletionStage<T>	Wrap a CompletionStage and signal its outcome.

Fields in io.reactivex.rxjava3.internal.jdk8 declared as Single

Modifier and Type	Field	Description
(package private) final Single<T>	SingleFlattenStreamAsFlowable.source
(package private) final Single<T>	SingleFlattenStreamAsObservable.source
(package private) final Single<T>	SingleMapOptional.source

Constructors in io.reactivex.rxjava3.internal.jdk8 with parameters of type Single

Modifier	Constructor	Description
	SingleFlattenStreamAsFlowable(Single<T> source, Function<? super T, ? extends Stream<? extends R>> mapper)
	SingleFlattenStreamAsObservable(Single<T> source, Function<? super T, ? extends Stream<? extends R>> mapper)
	SingleMapOptional(Single<T> source, Function<? super T, Optional<? extends R>> mapper)

Uses of Single in io.reactivex.rxjava3.internal.operators.completable

Subclasses of Single in io.reactivex.rxjava3.internal.operators.completable

Modifier and Type	Class	Description
final class	CompletableMaterialize<T>	Turn the signal types of a Completable source into a single Notification of equal kind.
final class	CompletableToSingle<T>

Uses of Single in io.reactivex.rxjava3.internal.operators.flowable

Subclasses of Single in io.reactivex.rxjava3.internal.operators.flowable

Modifier and Type	Class	Description
final class	FlowableAllSingle<T>
final class	FlowableAnySingle<T>
final class	FlowableCollectSingle<T,U>
final class	FlowableCountSingle<T>
final class	FlowableElementAtSingle<T>
final class	FlowableLastSingle<T>	Consumes the source Publisher and emits its last item or the defaultItem if empty.
final class	FlowableReduceSeedSingle<T,R>	Reduce a sequence of values, starting from a seed value and by using an accumulator function and return the last accumulated value.
final class	FlowableReduceWithSingle<T,R>	Reduce a sequence of values, starting from a generated seed value and by using an accumulator function and return the last accumulated value.
final class	FlowableSequenceEqualSingle<T>
final class	FlowableSingleSingle<T>
final class	FlowableToListSingle<T, U extends Collection<? super T>>

Uses of Single in io.reactivex.rxjava3.internal.operators.maybe

Subclasses of Single in io.reactivex.rxjava3.internal.operators.maybe

Modifier and Type	Class	Description
final class	MaybeContains<T>	Signals true if the source signals a value that is object-equals with the provided value, false otherwise or for empty sources.
final class	MaybeCount<T>	Signals 1L if the source signalled an item or 0L if the source is empty.
final class	MaybeEqualSingle<T>	Compares two MaybeSources to see if they are both empty or emit the same value compared via a BiPredicate.
final class	MaybeIsEmptySingle<T>	Signals true if the source Maybe signals onComplete, signals false if the source Maybe signals onSuccess.
final class	MaybeMaterialize<T>	Turn the signal types of a Maybe source into a single Notification of equal kind.
final class	MaybeSwitchIfEmptySingle<T>	Subscribes to the other source if the main source is empty.
final class	MaybeToSingle<T>	Wraps a MaybeSource and exposes its onSuccess and onError signals and signals NoSuchElementException for onComplete if defaultValue is null.

Uses of Single in io.reactivex.rxjava3.internal.operators.observable

Subclasses of Single in io.reactivex.rxjava3.internal.operators.observable

Modifier and Type	Class	Description
final class	ObservableAllSingle<T>
final class	ObservableAnySingle<T>
final class	ObservableCollectSingle<T,U>
final class	ObservableCountSingle<T>
final class	ObservableElementAtSingle<T>
final class	ObservableLastSingle<T>	Consumes the source ObservableSource and emits its last item, the defaultItem if empty or a NoSuchElementException if even the defaultItem is null.
final class	ObservableReduceSeedSingle<T,R>	Reduce a sequence of values, starting from a seed value and by using an accumulator function and return the last accumulated value.
final class	ObservableReduceWithSingle<T,R>	Reduce a sequence of values, starting from a generated seed value and by using an accumulator function and return the last accumulated value.
final class	ObservableSequenceEqualSingle<T>
final class	ObservableSingleSingle<T>
final class	ObservableToListSingle<T, U extends Collection<? super T>>

Uses of Single in io.reactivex.rxjava3.internal.operators.single

Subclasses of Single in io.reactivex.rxjava3.internal.operators.single

Modifier and Type	Class	Description
final class	SingleAmb<T>
final class	SingleCache<T>
final class	SingleContains<T>
final class	SingleCreate<T>
final class	SingleDefer<T>
final class	SingleDelay<T>
final class	SingleDelayWithCompletable<T>
final class	SingleDelayWithObservable<T,U>
final class	SingleDelayWithPublisher<T,U>
final class	SingleDelayWithSingle<T,U>
final class	SingleDetach<T>	Breaks the references between the upstream and downstream when the Maybe terminates.
final class	SingleDoAfterSuccess<T>	Calls a consumer after pushing the current item to the downstream.
final class	SingleDoAfterTerminate<T>	Calls an action after pushing the current item or an error to the downstream.
final class	SingleDoFinally<T>	Execute an action after an onSuccess, onError or a dispose event.
final class	SingleDoOnDispose<T>
final class	SingleDoOnError<T>
final class	SingleDoOnEvent<T>
final class	SingleDoOnLifecycle<T>	Invokes callbacks upon onSubscribe from upstream and dispose from downstream.
final class	SingleDoOnSubscribe<T>	Calls a callback when the upstream calls onSubscribe with a disposable.
final class	SingleDoOnSuccess<T>
final class	SingleDoOnTerminate<T>
final class	SingleEquals<T>
final class	SingleError<T>
final class	SingleFlatMap<T,R>
final class	SingleFlatMapBiSelector<T,U,R>	Maps a source item to another SingleSource then calls a BiFunction with the original item and the secondary item to generate the final result.
final class	SingleFlatMapNotification<T,R>	Maps a value into a SingleSource and relays its signal.
final class	SingleFromCallable<T>
final class	SingleFromPublisher<T>
final class	SingleFromSupplier<T>	Calls a supplier and emits its value or exception to the incoming SingleObserver.
final class	SingleFromUnsafeSource<T>
final class	SingleHide<T>
final class	SingleJust<T>
final class	SingleLift<T,R>
final class	SingleMap<T,R>
final class	SingleMaterialize<T>	Turn the signal types of a Single source into a single Notification of equal kind.
final class	SingleNever
final class	SingleObserveOn<T>
final class	SingleOnErrorReturn<T>
final class	SingleResumeNext<T>
final class	SingleSubscribeOn<T>
final class	SingleTakeUntil<T,U>	Signals the events of the source Single or signals a CancellationException if the other Publisher signalled first.
final class	SingleTimeInterval<T>	Measures the time between subscription and the success item emission from the upstream and emits this as a Timed success value.
final class	SingleTimeout<T>
final class	SingleTimer	Signals a 0L after the specified delay.
final class	SingleUnsubscribeOn<T>	Makes sure a dispose() call from downstream happens on the specified scheduler.
final class	SingleUsing<T,U>
final class	SingleZipArray<T,R>
final class	SingleZipIterable<T,R>

Fields in io.reactivex.rxjava3.internal.operators.single declared as Single

Modifier and Type	Field	Description
static final Single<Object>	SingleNever.INSTANCE
(package private) final Single<T>	SingleDematerialize.source
(package private) final Single<T>	SingleDoOnLifecycle.source
(package private) final Single<T>	SingleMaterialize.source
(package private) final Single<T>	SingleOnErrorComplete.source

Constructors in io.reactivex.rxjava3.internal.operators.single with parameters of type Single

Modifier	Constructor	Description
	SingleDematerialize(Single<T> source, Function<? super T, Notification<R>> selector)
	SingleDoOnLifecycle(Single<T> upstream, Consumer<? super Disposable> onSubscribe, Action onDispose)
	SingleMaterialize(Single<T> source)
	SingleOnErrorComplete(Single<T> source, Predicate<? super Throwable> predicate)

Uses of Single in io.reactivex.rxjava3.plugins

Fields in io.reactivex.rxjava3.plugins with type parameters of type Single

Modifier and Type	Field	Description
(package private) static @Nullable Function<? super Single, ? extends Single>	RxJavaPlugins.onSingleAssembly
(package private) static @Nullable Function<? super Single, ? extends Single>	RxJavaPlugins.onSingleAssembly
(package private) static @Nullable BiFunction<? super Single, @NonNull ? super SingleObserver, @NonNull ? extends SingleObserver>	RxJavaPlugins.onSingleSubscribe

Methods in io.reactivex.rxjava3.plugins that return Single

Modifier and Type	Method	Description
static <@NonNull T> @NonNull Single<T>	RxJavaPlugins.onAssembly(@NonNull Single<@NonNull T> source)	Calls the associated hook function.

Methods in io.reactivex.rxjava3.plugins that return types with arguments of type Single

Modifier and Type	Method	Description
static @Nullable Function<? super Single, ? extends Single>	RxJavaPlugins.getOnSingleAssembly()	Returns the current hook function.
static @Nullable Function<? super Single, ? extends Single>	RxJavaPlugins.getOnSingleAssembly()	Returns the current hook function.
static @Nullable BiFunction<? super Single, @NonNull ? super SingleObserver, @NonNull ? extends SingleObserver>	RxJavaPlugins.getOnSingleSubscribe()	Returns the current hook function.

Methods in io.reactivex.rxjava3.plugins with parameters of type Single

Modifier and Type	Method	Description
static <@NonNull T> @NonNull Single<T>	RxJavaPlugins.onAssembly(@NonNull Single<@NonNull T> source)	Calls the associated hook function.
static <@NonNull T> @NonNull SingleObserver<? super T>	RxJavaPlugins.onSubscribe(@NonNull Single<@NonNull T> source, @NonNull SingleObserver<? super @NonNull T> observer)	Calls the associated hook function.

Method parameters in io.reactivex.rxjava3.plugins with type arguments of type Single

Modifier and Type	Method	Description
static void	RxJavaPlugins.setOnSingleAssembly(@Nullable Function<? super Single, ? extends Single> onSingleAssembly)	Sets the specific hook function.
static void	RxJavaPlugins.setOnSingleAssembly(@Nullable Function<? super Single, ? extends Single> onSingleAssembly)	Sets the specific hook function.
static void	RxJavaPlugins.setOnSingleSubscribe(@Nullable BiFunction<? super Single, @NonNull ? super SingleObserver, @NonNull ? extends SingleObserver> onSingleSubscribe)	Sets the specific hook function.

Uses of Single in io.reactivex.rxjava3.subjects

Subclasses of Single in io.reactivex.rxjava3.subjects

Modifier and Type	Class	Description
final class	SingleSubject<T>	Represents a hot Single-like source and consumer of events similar to Subjects.