Class Index

A B C D E F G I L M N O P R S T U

A

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 Subscribers.
AsyncSubject<T>	An Subject that emits the very last value followed by a completion event or the received error to Observers.

B

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 extends BaseTestConsumer<T, U>>	Base class with shared infrastructure to support TestSubscriber and TestObserver.
BaseTestConsumer.TestWaitStrategy	Enumeration of default wait strategies when waiting for a specific number of items in `awaitCount(int, Runnable)`.
BehaviorProcessor<T>	Processor that emits the most recent item it has observed and all subsequent observed items to each subscribed 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.

C

Cancellable	A functional interface that has a single cancel method that can throw.
CheckReturnValue	Marks methods whose return values should be checked.
Completable	Represents a deferred computation without any value but only indication for completion or exception.
CompletableEmitter	Abstraction over an RxJava `CompletableObserver` that allows associating a resource with it.
CompletableObserver	Represents the subscription API callbacks when subscribing to a Completable instance.
CompletableOnSubscribe	A functional interface that has a `subscribe()` method that receives an instance of 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) add and removal complexity.
CompositeException	Represents an exception that is a composite of one or more other exceptions.
ConnectableFlowable<T>	A `ConnectableObservable` resembles an ordinary `Flowable`, except that it does not begin emitting items when it is subscribed to, but only when its `connect()` 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 `connect()` method is called.
Consumer<T>	A functional interface (callback) that accepts a single value.

D

DefaultObserver<T>	Abstract base implementation of an `Observer` with support for cancelling a subscription via `cancel()` (synchronously) and calls `onStart()` when the subscription happens.
DefaultSubscriber<T>	Abstract base implementation of a org.reactivestreams.Subscriber Subscriber with support for requesting via `request(long)`, cancelling via via `cancel()` (both synchronously) and calls `onStart()` when the subscription happens.
Disposable	Represents a disposable resource.
DisposableCompletableObserver	An abstract `CompletableObserver` that allows asynchronous cancellation by implementing Disposable.
DisposableMaybeObserver<T>	An abstract `MaybeObserver` that allows asynchronous cancellation by implementing Disposable.
DisposableObserver<T>	An abstract `Observer` that allows asynchronous cancellation by implementing Disposable.
Disposables	Utility class to help create disposables by wrapping other types.
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.

E

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.

F

Flowable<T>	The Flowable class that implements the Reactive-Streams Pattern and offers factory methods, intermediate operators and the ability to consume reactive dataflows.
FlowableEmitter<T>	Abstraction over a Reactive Streams 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 an instance of a `FlowableEmitter` instance that allows pushing events in a backpressure-safe and cancellation-safe manner.
FlowableOperator<Downstream, Upstream>	Interface to map/wrap a downstream 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 Subscriber that is RxJava 2 only and weakens 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.

G

GroupedFlowable<K, T>	A `Flowable` that has been grouped by key, the value of which can be obtained with `getKey()`.
GroupedObservable<K, T>	An `Observable` that has been grouped by key, the value of which can be obtained with `getKey()`.

I

IntFunction<T> A functional interface (callback) that takes a primitive value and return value of type T.

L

LongConsumer A functional interface (callback) that consumes a primitive long value.

M

Maybe<T>	Represents a deferred computation and emission of a maybe value or exception.
MaybeEmitter<T>	Abstraction over an RxJava `MaybeObserver` that allows associating a resource with it.
MaybeObserver<T>	Provides a mechanism for receiving push-based notifications.
MaybeOnSubscribe<T>	A functional interface that has a `subscribe()` method that receives an instance of a `MaybeEmitter` instance that allows pushing an event in a cancellation-safe manner.
MaybeOperator<Downstream, Upstream>	Interface to map/wrap a downstream observer to an upstream observer.
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.

N

NonNull	Indicates that a field/parameter/variable/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/return type may be null.

O

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.
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 instance of 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.

P

ParallelFailureHandling	Enumerations for handling failure within a parallel operator.
ParallelFlowable<T>	Abstract base class for Parallel publishers that take an array of Subscribers.
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 Subscribers.
PublishSubject<T>	Subject that, once an `Observer` has subscribed, emits all subsequently observed items to the subscriber.

R

ReplayProcessor<T>	Replays events to Subscribers.
ReplaySubject<T>	Replays events to 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.

S

SafeObserver<T>	Wraps another Subscriber and ensures all onXXX methods conform the protocol (except the requirement for serialized access).
SafeSubscriber<T>	Wraps another Subscriber and ensures all onXXX methods conform the protocol (except the requirement for serialized access).
Scheduler	A `Scheduler` is an object that specifies an API for scheduling units of work with or without delays or periodically.
Scheduler.Worker	Sequential Scheduler for executing actions on a single thread or event loop.
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 onNext, onError and onComplete methods of another Observer.
SerializedSubscriber<T>	Serializes access to the onNext, onError and onComplete methods of another Subscriber.
Single<T>	The Single class implements the Reactive Pattern for a single value response.
SingleEmitter<T>	Abstraction over an RxJava `SingleObserver` that allows associating a resource with it.
SingleObserver<T>	Provides a mechanism for receiving push-based notifications.
SingleOnSubscribe<T>	A functional interface that has a `subscribe()` method that receives an instance of a `SingleEmitter` instance that allows pushing an event in a cancellation-safe manner.
SingleOperator<Downstream, Upstream>	Interface to map/wrap a downstream observer to an upstream observer.
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.
Subject<T>	Represents an Observer and an Observable at the same time, allowing multicasting events from a single source to multiple child Subscribers.

T

TestObserver<T>	An Observer that records events 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 subscriber that records events and allows making assertions about them.
Timed<T>	Holds onto a value along with time information.

U

UndeliverableException	Wrapper for Throwable errors that are sent to `RxJavaPlugins.onError`.
UnicastProcessor<T>	Processor that allows only a single Subscriber to subscribe to it during its lifetime.
UnicastSubject<T>	Subject that allows only a single Subscriber to subscribe to it during its lifetime.