All Classes and Interfaces

Class	Description
Action	A functional interface similar to Runnable but allows throwing a checked exception.
AsyncProcessor<T>	Processor that emits the very last value followed by a completion event or the received error to Flow.Subscribers.
AsyncSubject<T>	A Subject that emits the very last value followed by a completion event or the received error to Observers.
BackpressureKind	Enumeration for various kinds of backpressure support.
BackpressureOverflowStrategy	Options to deal with buffer overflow when using onBackpressureBuffer.
BackpressureStrategy	Represents the options for applying backpressure to a source sequence.
BackpressureSupport	Indicates the backpressure support kind of the associated operator or class.
BaseTestConsumer<T,U>	Base class with shared infrastructure to support TestSubscriber and TestObserver.
BehaviorProcessor<T>	Processor that emits the most recent item it has observed and all subsequent observed items to each subscribed Flow.Subscriber.
BehaviorSubject<T>	Subject that emits the most recent item it has observed and all subsequent observed items to each subscribed Observer.
Beta	Indicates the feature is in beta state: it will be most likely stay but the signature may change between versions without warning.
BiConsumer<T1,T2>	A functional interface (callback) that accepts two values (of possibly different types).
BiFunction<T1,T2,R>	A functional interface (callback) that computes a value based on multiple input values.
BiPredicate<T1,T2>	A functional interface (callback) that returns true or false for the given input values.
BooleanSupplier	A functional interface (callback) that returns a boolean value.
Cancellable	A functional interface that has a single cancel method that can throw.
CheckReturnValue	Marks methods whose return values should be checked.
Completable	The Completable class represents a deferred computation without any value but only indication for completion or exception.
CompletableConverter<R>	Convenience interface and callback used by the Completable.to(CompletableConverter) operator to turn a Completable into another value fluently.
CompletableEmitter	Abstraction over an RxJava CompletableObserver that allows associating a resource with it.
CompletableObserver	Provides a mechanism for receiving push-based notification of a valueless completion or an error.
CompletableOnSubscribe	A functional interface that has a subscribe() method that receives a CompletableEmitter instance that allows pushing an event in a cancellation-safe manner.
CompletableOperator	Interface to map/wrap a downstream observer to an upstream observer.
CompletableSource	Represents a basic Completable source base interface, consumable via an CompletableObserver.
CompletableSubject	Represents a hot Completable-like source and consumer of events similar to Subjects.
CompletableTransformer	Convenience interface and callback used by the compose operator to turn a Completable into another Completable fluently.
CompositeDisposable	A disposable container that can hold onto multiple other Disposables and offers O(1) time complexity for CompositeDisposable.add(Disposable), CompositeDisposable.remove(Disposable) and CompositeDisposable.delete(Disposable) operations.
CompositeException	Represents an exception that is a composite of one or more other exceptions.
ConditionalSubscriber<T>	A FlowableSubscriber with an additional ConditionalSubscriber.tryOnNext(Object) method that tells the caller the specified value has been accepted or not.
ConnectableFlowable<T>	A ConnectableFlowable resembles an ordinary Flowable, except that it does not begin emitting items when it is subscribed to, but only when its ConnectableFlowable.connect(Consumer) method is called.
ConnectableObservable<T>	A ConnectableObservable resembles an ordinary Observable, except that it does not begin emitting items when it is subscribed to, but only when its ConnectableObservable.connect(Consumer) method is called.
Consumer<T>	A functional interface (callback) that accepts a single value.
DefaultObserver<T>	Abstract base implementation of an Observer with support for cancelling a subscription via DefaultObserver.cancel() (synchronously) and calls DefaultObserver.onStart() when the subscription happens.
DefaultSubscriber<T>	Abstract base implementation of a invalid reference Subscriber with support for requesting via DefaultSubscriber.request(long), cancelling via via DefaultSubscriber.cancel() (both synchronously) and calls DefaultSubscriber.onStart() when the subscription happens.
Disposable	Represents a disposable resource.
DisposableCompletableObserver	An abstract CompletableObserver that allows asynchronous cancellation by implementing Disposable.
DisposableContainer	Common interface to add and remove disposables from a container.
DisposableMaybeObserver<T>	An abstract MaybeObserver that allows asynchronous cancellation by implementing Disposable.
DisposableObserver<T>	An abstract Observer that allows asynchronous cancellation by implementing Disposable.
DisposableSingleObserver<T>	An abstract SingleObserver that allows asynchronous cancellation by implementing Disposable.
DisposableSubscriber<T>	An abstract Subscriber that allows asynchronous, external cancellation by implementing Disposable.
Emitter<T>	Base interface for emitting signals in a push-fashion in various generator-like source operators (create, generate).
Exceptions	Utility class to help propagate checked exceptions and rethrow exceptions designated as fatal.
Experimental	Indicates the feature is in experimental state: its existence, signature or behavior might change without warning from one release to the next.
Flowable<T>	The Flowable class that implements the Reactive Streams Flow.Publisher Pattern and offers factory methods, intermediate operators and the ability to consume reactive dataflows.
FlowableConverter<T,R>	Convenience interface and callback used by the Flowable.to(FlowableConverter) operator to turn a Flowable into another value fluently.
FlowableEmitter<T>	Abstraction over a Reactive Streams invalid reference org.reactivestreams.Subscriber that allows associating a resource with it and exposes the current number of downstream requested amount.
FlowableOnSubscribe<T>	A functional interface that has a subscribe() method that receives a FlowableEmitter instance that allows pushing events in a backpressure-safe and cancellation-safe manner.
FlowableOperator<Downstream, Upstream>	Interface to map/wrap a downstream Flow.Subscriber to an upstream Subscriber.
FlowableProcessor<T>	Represents a Subscriber and a Flowable (Publisher) at the same time, allowing multicasting events from a single source to multiple child Subscribers.
FlowableSubscriber<T>	Represents a Reactive-Streams inspired Flow.Subscriber that is RxJava 4 only and weakens the Reactive Streams rules §1.3 and §3.9 of the specification for gaining performance.
FlowableTransformer<Upstream, Downstream>	Interface to compose Flowables.
Function<T,R>	A functional interface that takes a value and returns another value, possibly with a different type and allows throwing a checked exception.
Function3<T1,T2,T3,R>	A functional interface (callback) that computes a value based on multiple input values.
Function4<T1,T2,T3,T4,R>	A functional interface (callback) that computes a value based on multiple input values.
Function5<T1,T2,T3,T4,T5,R>	A functional interface (callback) that computes a value based on multiple input values.
Function6<T1,T2,T3,T4,T5,T6,R>	A functional interface (callback) that computes a value based on multiple input values.
Function7<T1,T2,T3,T4,T5,T6,T7,R>	A functional interface (callback) that computes a value based on multiple input values.
Function8<T1,T2,T3,T4,T5,T6,T7,T8,R>	A functional interface (callback) that computes a value based on multiple input values.
Function9<T1,T2,T3,T4,T5,T6,T7,T8,T9,R>	A functional interface (callback) that computes a value based on multiple input values.
GroupedFlowable<K,T>	A Flowable that has been grouped by key, the value of which can be obtained with GroupedFlowable.getKey().
GroupedObservable<K,T>	An Observable that has been grouped by key, the value of which can be obtained with GroupedObservable.getKey().
IntFunction<T>	A functional interface (callback) that takes a primitive value and return value of type T.
LambdaConsumerIntrospection	An interface that indicates that the implementing type is composed of individual components and exposes information about their behavior.
LongConsumer	A functional interface (callback) that consumes a primitive long value.
Maybe<T>	The Maybe class represents a deferred computation and emission of a single value, no value at all or an exception.
MaybeConverter<T,R>	Convenience interface and callback used by the Maybe.to(MaybeConverter) operator to turn a Maybe into another value fluently.
MaybeEmitter<T>	Abstraction over an RxJava MaybeObserver that allows associating a resource with it.
MaybeObserver<T>	Provides a mechanism for receiving push-based notification of a single value, an error or completion without any value.
MaybeOnSubscribe<T>	A functional interface that has a subscribe() method that receives a MaybeEmitter instance that allows pushing an event in a cancellation-safe manner.
MaybeOperator<Downstream, Upstream>	Interface to map/wrap a downstream MaybeObserver to an upstream MaybeObserver.
MaybeSource<T>	Represents a basic Maybe source base interface, consumable via an MaybeObserver.
MaybeSubject<T>	Represents a hot Maybe-like source and consumer of events similar to Subjects.
MaybeTransformer<Upstream, Downstream>	Interface to compose Maybes.
MissingBackpressureException	Indicates that an operator attempted to emit a value but the downstream wasn't ready for it.
MulticastProcessor<T>	A FlowableProcessor implementation that coordinates downstream requests through a front-buffer and stable-prefetching, optionally canceling the upstream if all subscribers have cancelled.
NonNull	Indicates that a field/parameter/variable/type parameter/return type is never null.
Notification<T>	Represents the reactive signal types: onNext, onError and onComplete and holds their parameter values (a value, a Throwable, nothing).
Nullable	Indicates that a field/parameter/variable/type parameter/return type may be null.
Observable<T>	The Observable class is the non-backpressured, optionally multi-valued base reactive class that offers factory methods, intermediate operators and the ability to consume synchronous and/or asynchronous reactive dataflows.
ObservableConverter<T,R>	Convenience interface and callback used by the Observable.to(ObservableConverter) operator to turn an Observable into another value fluently.
ObservableEmitter<T>	Abstraction over an RxJava Observer that allows associating a resource with it.
ObservableOnSubscribe<T>	A functional interface that has a subscribe() method that receives an ObservableEmitter instance that allows pushing events in a cancellation-safe manner.
ObservableOperator<Downstream, Upstream>	Interface to map/wrap a downstream Observer to an upstream Observer.
ObservableSource<T>	Represents a basic, non-backpressured Observable source base interface, consumable via an Observer.
ObservableTransformer<Upstream, Downstream>	Interface to compose Observables.
Observer<T>	Provides a mechanism for receiving push-based notifications.
OnErrorNotImplementedException	Represents an exception used to signal to the RxJavaPlugins.onError() that a callback-based subscribe() method on a base reactive type didn't specify an onError handler.
ParallelFailureHandling	Enumerations for handling failure within a parallel operator.
ParallelFlowable<T>	Abstract base class for parallel publishing of events signaled to an array of Flow.Subscribers.
ParallelFlowableConverter<T,R>	Convenience interface and callback used by the ParallelFlowable.to(ParallelFlowableConverter) operator to turn a ParallelFlowable into another value fluently.
ParallelTransformer<Upstream, Downstream>	Interface to compose ParallelFlowable.
Predicate<T>	A functional interface (callback) that returns true or false for the given input value.
ProtocolViolationException	Explicitly named exception to indicate a Reactive-Streams protocol violation.
PublishProcessor<T>	Processor that multicasts all subsequently observed items to its current Flow.Subscribers.
PublishSubject<T>	A Subject that emits (multicasts) items to currently subscribed Observers and terminal events to current or late Observers.
QueueDisposable<T>	An interface extending SimpleQueue and Disposable and allows negotiating the fusion mode between subsequent operators of the Observable base reactive type.
QueueFuseable<T>	Represents a SimpleQueue plus the means and constants for requesting a fusion mode.
QueueOverflowException	Indicates an overflow happened because the upstream disregarded backpressure completely or invalid reference org.reactivestreams.Subscriber#onNext(Object) was called concurrently from multiple threads without synchronization.
QueueSubscription<T>	An interface extending SimpleQueue and Flow.Subscription and allows negotiating the fusion mode between subsequent operators of the Flowable base reactive type.
ReplayProcessor<T>	Replays events to Subscribers.
ReplaySubject<T>	Replays events (in a configurable bounded or unbounded manner) to current and late Observers.
ResourceCompletableObserver	An abstract CompletableObserver that allows asynchronous cancellation of its subscription and associated resources.
ResourceMaybeObserver<T>	An abstract MaybeObserver that allows asynchronous cancellation of its subscription and associated resources.
ResourceObserver<T>	An abstract Observer that allows asynchronous cancellation of its subscription and associated resources.
ResourceSingleObserver<T>	An abstract SingleObserver that allows asynchronous cancellation of its subscription and the associated resources.
ResourceSubscriber<T>	An abstract Subscriber that allows asynchronous cancellation of its subscription and associated resources.
RxJavaPlugins	Utility class to inject handlers to certain standard RxJava operations.
SafeObserver<T>	Wraps another Observer and ensures all onXXX methods conform the protocol (except the requirement for serialized access).
SafeSubscriber<T>	Wraps another Flow.Subscriber and ensures all onXXX methods conform the protocol (except the requirement for serialized access).
ScalarSupplier<T>	A marker interface indicating that a scalar, constant value is held by the implementing reactive type which can be safely extracted during assembly time can be used for optimization.
Scheduler	A Scheduler is an object that specifies an API for scheduling units of work provided in the form of Runnables to be executed without delay (effectively as soon as possible), after a specified time delay or periodically and represents an abstraction over an asynchronous boundary that ensures these units of work get executed by some underlying task-execution scheme (such as custom Threads, event loop, Executor or Actor system) with some uniform properties and guarantees regardless of the particular underlying scheme.
Scheduler.Worker	Represents an isolated, sequential worker of a parent Scheduler for executing Runnable tasks on an underlying task-execution scheme (such as custom Threads, event loop, Executor or Actor system).
SchedulerRunnableIntrospection	Interface to indicate the implementor class wraps a Runnable that can be accessed via SchedulerRunnableIntrospection.getWrappedRunnable().
Schedulers	Static factory methods for returning standard Scheduler instances.
SchedulerSupport	Indicates what kind of scheduler the class or method uses.
SerialDisposable	A Disposable container that allows atomically updating/replacing the contained Disposable with another Disposable, disposing the old one when updating plus handling the disposition when the container itself is disposed.
SerializedObserver<T>	Serializes access to the Observer.onNext(Object), Observer.onError(Throwable) and Observer.onComplete() methods of another Observer.
SerializedSubscriber<T>	Serializes access to the Flow.Subscriber.onNext(Object), Flow.Subscriber.onError(Throwable) and Flow.Subscriber.onComplete() methods of another Flow.Subscriber.
SimplePlainQueue<T>	Override of the SimpleQueue interface with no throws Throwable on poll().
SimpleQueue<T>	A simplified interface for offering, polling and clearing a queue.
Single<T>	The Single class implements the Reactive Pattern for a single value response.
SingleConverter<T,R>	Convenience interface and callback used by the Single.to(SingleConverter) operator to turn a Single into another value fluently.
SingleEmitter<T>	Abstraction over an RxJava SingleObserver that allows associating a resource with it.
SingleObserver<T>	Provides a mechanism for receiving push-based notification of a single value or an error.
SingleOnSubscribe<T>	A functional interface that has a subscribe() method that receives a SingleEmitter instance that allows pushing an event in a cancellation-safe manner.
SingleOperator<Downstream, Upstream>	Interface to map/wrap a downstream SingleObserver to an upstream SingleObserver.
SingleSource<T>	Represents a basic Single source base interface, consumable via an SingleObserver.
SingleSubject<T>	Represents a hot Single-like source and consumer of events similar to Subjects.
SingleTransformer<Upstream, Downstream>	Interface to compose Singles.
SpscArrayQueue<E>	A Single-Producer-Single-Consumer queue backed by a pre-allocated buffer.
SpscLinkedArrayQueue<T>	A single-producer single-consumer array-backed queue which can allocate new arrays in case the consumer is slower than the producer.
Subject<T>	Represents an Observer and an Observable at the same time, allowing multicasting events from a single source to multiple child Observers.
Supplier<T>	A functional interface (callback) that provides a single value or throws an exception.
TestObserver<T>	An Observer, MaybeObserver, SingleObserver and CompletableObserver composite that can record events from Observables, Maybes, Singles and Completables and allows making assertions about them.
TestScheduler	A special, non thread-safe scheduler for testing operators that require a scheduler without introducing real concurrency and allows manually advancing a virtual time.
TestSubscriber<T>	A Flow.Subscriber implementation that records events and allows making assertions about them.
Timed<T>	Holds onto a value along with time information.
UndeliverableException	Wrapper for Throwable errors that are sent to RxJavaPlugins.onError.
UnicastProcessor<T>	A FlowableProcessor variant that queues up events until a single Flow.Subscriber subscribes to it, replays those events to it until the Subscriber catches up and then switches to relaying events live to this single Subscriber until this UnicastProcessor terminates or the Subscriber cancels its subscription.
UnicastSubject<T>	A Subject that queues up events until a single Observer subscribes to it, replays those events to it until the Observer catches up and then switches to relaying events live to this single Observer until this UnicastSubject terminates or the Observer disposes.