or run

npx @tessl/cli init

Version

Tile

Overview

Evals

Files

docs

completable.md disposables.md error-handling.md flowable.md index.md maybe.md observable.md schedulers.md single.md subjects.md

tile.json

tessl/maven-io-reactivex-rxjava2--rxjava

RxJava: Reactive Extensions for the JVM – a library for composing asynchronous and event-based programs using observable sequences for the Java VM.

Workspace: tessl
Visibility: Public
Created: 3 months ago
Last updated: 3 months ago
Describes: pkg:maven/io.reactivex.rxjava2/rxjava@2.2.x

To install, run

npx @tessl/cli install tessl/maven-io-reactivex-rxjava2--rxjava@2.2.0

RxJava

RxJava 2.x is a Java VM implementation of Reactive Extensions that provides a comprehensive library for composing asynchronous and event-based programs using observable sequences. It extends the observer pattern to support data/event sequences with operators for declarative composition while abstracting low-level threading, synchronization, and concurrent data structures.

Package Information

Package Name: rxjava
Package Type: maven
Language: Java

Installation:

<dependency>
  <groupId>io.reactivex.rxjava2</groupId>
  <artifactId>rxjava</artifactId>
  <version>2.2.21</version>
</dependency>

Gradle: implementation 'io.reactivex.rxjava2:rxjava:2.2.21'

Core Imports

import io.reactivex.Observable;
import io.reactivex.Flowable;
import io.reactivex.Single;
import io.reactivex.Maybe;
import io.reactivex.Completable;
import io.reactivex.Observer;
import io.reactivex.disposables.Disposable;
import io.reactivex.schedulers.Schedulers;

Basic Usage

import io.reactivex.Observable;
import io.reactivex.Observer;
import io.reactivex.disposables.Disposable;
import io.reactivex.schedulers.Schedulers;

// Create and subscribe to an Observable
Observable<String> observable = Observable.just("Hello", "World")
    .map(s -> s.toUpperCase())
    .subscribeOn(Schedulers.io())
    .observeOn(Schedulers.computation());

observable.subscribe(new Observer<String>() {
    @Override
    public void onSubscribe(Disposable d) {
        // Handle subscription
    }
    
    @Override
    public void onNext(String value) {
        System.out.println(value);
    }
    
    @Override
    public void onError(Throwable e) {
        e.printStackTrace();
    }
    
    @Override
    public void onComplete() {
        System.out.println("Completed");
    }
});

// Lambda-style subscription
Observable.fromArray(1, 2, 3, 4, 5)
    .filter(x -> x % 2 == 0)
    .map(x -> x * x)
    .subscribe(
        value -> System.out.println("Value: " + value),
        error -> error.printStackTrace(),
        () -> System.out.println("Complete")
    );

Architecture

RxJava is built around several key components:

Reactive Types: Five core types (Observable, Flowable, Single, Maybe, Completable) for different use cases
Observer Pattern: Push-based notifications with Observer interfaces for each reactive type
Operators: Rich set of operators for transformation, filtering, combining, and error handling
Schedulers: Abstraction for controlling threading and execution context
Backpressure: Flow control mechanism in Flowable to handle fast producers
Disposables: Resource management for subscription cleanup
Subjects/Processors: Hot observables that can multicast to multiple observers

Capabilities

Observable Streams

Cold observable sequences for 0-N items without backpressure support. Ideal for UI events, HTTP requests, and general reactive programming patterns.

public abstract class Observable<T> implements ObservableSource<T> {
    // Factory methods
    public static <T> Observable<T> just(T... items);
    public static <T> Observable<T> fromArray(T... array);
    public static <T> Observable<T> fromIterable(Iterable<? extends T> source);
    public static Observable<Long> interval(long period, TimeUnit unit);
    public static <T> Observable<T> create(ObservableOnSubscribe<T> source);
    
    // Transformation operators
    public final <R> Observable<R> map(Function<? super T, ? extends R> mapper);
    public final <R> Observable<R> flatMap(Function<? super T, ? extends ObservableSource<? extends R>> mapper);
    public final Observable<T> filter(Predicate<? super T> predicate);
    
    // Threading
    public final Observable<T> subscribeOn(Scheduler scheduler);
    public final Observable<T> observeOn(Scheduler scheduler);
    
    // Subscription
    public final Disposable subscribe(Consumer<? super T> onNext);
    public final void subscribe(Observer<? super T> observer);
}

Observable Streams

Flowable Streams

Reactive streams with backpressure support for 0-N items. Compatible with Reactive Streams specification for handling fast data producers.

public abstract class Flowable<T> implements Publisher<T> {
    // Factory methods with backpressure handling
    public static <T> Flowable<T> just(T... items);
    public static <T> Flowable<T> fromArray(T... array);
    public static <T> Flowable<T> create(FlowableOnSubscribe<T> source, BackpressureStrategy mode);
    
    // Backpressure operators
    public final Flowable<T> onBackpressureBuffer();
    public final Flowable<T> onBackpressureDrop();
    public final Flowable<T> onBackpressureLatest();
    
    // Standard operators
    public final <R> Flowable<R> map(Function<? super T, ? extends R> mapper);
    public final Flowable<T> filter(Predicate<? super T> predicate);
    
    // Subscription
    public final void subscribe(FlowableSubscriber<? super T> subscriber);
}

Flowable Streams

Single Values

Reactive type that emits exactly one value or an error. Perfect for async operations that return a single result like HTTP requests.

public abstract class Single<T> implements SingleSource<T> {
    // Factory methods
    public static <T> Single<T> just(T item);
    public static <T> Single<T> fromCallable(Callable<? extends T> callable);
    public static <T> Single<T> create(SingleOnSubscribe<T> source);
    
    // Transformation
    public final <R> Single<R> map(Function<? super T, ? extends R> mapper);
    public final <R> Single<R> flatMap(Function<? super T, ? extends SingleSource<? extends R>> mapper);
    
    // Error handling
    public final Single<T> onErrorReturn(Function<? super Throwable, ? extends T> valueSupplier);
    
    // Subscription
    public final Disposable subscribe(Consumer<? super T> onSuccess);
    public final void subscribe(SingleObserver<? super T> observer);
}

Single Values

Maybe Values

Reactive type that emits 0 or 1 item or an error. Useful for operations that may or may not return a value.

public abstract class Maybe<T> implements MaybeSource<T> {
    // Factory methods
    public static <T> Maybe<T> just(T item);
    public static <T> Maybe<T> empty();
    public static <T> Maybe<T> fromCallable(Callable<? extends T> callable);
    
    // Transformation
    public final <R> Maybe<R> map(Function<? super T, ? extends R> mapper);
    public final Maybe<T> filter(Predicate<? super T> predicate);
    public final Maybe<T> defaultIfEmpty(T defaultItem);
    
    // Subscription
    public final Disposable subscribe(Consumer<? super T> onSuccess);
    public final void subscribe(MaybeObserver<? super T> observer);
}

Maybe Values

Completable Operations

Reactive type that only signals completion or error without emitting items. Ideal for fire-and-forget operations.

public abstract class Completable implements CompletableSource {
    // Factory methods
    public static Completable complete();
    public static Completable fromAction(Action action);
    public static Completable fromRunnable(Runnable runnable);
    
    // Chaining
    public final <T> Observable<T> andThen(ObservableSource<T> next);
    public final Completable andThen(CompletableSource next);
    
    // Subscription
    public final Disposable subscribe(Action onComplete);
    public final void subscribe(CompletableObserver observer);
}

Completable Operations

Schedulers and Threading

Control execution context and threading for reactive streams.

public abstract class Scheduler {
    public abstract Worker createWorker();
    public Disposable scheduleDirect(Runnable run);
    public Disposable scheduleDirect(Runnable run, long delay, TimeUnit unit);
}

public final class Schedulers {
    public static Scheduler io();
    public static Scheduler computation();
    public static Scheduler newThread();
    public static Scheduler single();
    public static Scheduler trampoline();
    public static Scheduler from(Executor executor);
}

Schedulers and Threading

Subjects and Hot Observables

Hot observables that can multicast to multiple observers and emit items regardless of subscriptions.

public abstract class Subject<T> extends Observable<T> implements Observer<T> {
    public abstract boolean hasObservers();
    public abstract boolean hasThrowable();
    public abstract boolean hasComplete();
}

// Main subject types
public final class PublishSubject<T> extends Subject<T>;
public final class BehaviorSubject<T> extends Subject<T>;
public final class ReplaySubject<T> extends Subject<T>;
public final class AsyncSubject<T> extends Subject<T>;

Subjects and Hot Observables

Resource Management

Disposable pattern for managing subscriptions and preventing memory leaks.

public interface Disposable {
    void dispose();
    boolean isDisposed();
}

public final class CompositeDisposable implements Disposable {
    public boolean add(Disposable disposable);
    public boolean remove(Disposable disposable);
    public void clear();
}

Resource Management

Error Handling

Comprehensive error handling and recovery mechanisms.

// Error handling operators available on all reactive types
public final Observable<T> onErrorReturn(Function<? super Throwable, ? extends T> valueSupplier);
public final Observable<T> onErrorResumeNext(Function<? super Throwable, ? extends ObservableSource<? extends T>> resumeFunction);
public final Observable<T> retry();
public final Observable<T> retry(long times);
public final Observable<T> retryWhen(Function<? super Observable<Throwable>, ? extends ObservableSource<?>> handler);

Error Handling

Core Types

// Observer interfaces
public interface Observer<T> {
    void onSubscribe(Disposable d);
    void onNext(T t);
    void onError(Throwable e);
    void onComplete();
}

public interface SingleObserver<T> {
    void onSubscribe(Disposable d);
    void onSuccess(T t);
    void onError(Throwable e);
}

public interface MaybeObserver<T> {
    void onSubscribe(Disposable d);
    void onSuccess(T t);
    void onError(Throwable e);
    void onComplete();
}

public interface CompletableObserver {
    void onSubscribe(Disposable d);
    void onComplete();
    void onError(Throwable e);
}

// Functional interfaces
public interface Consumer<T> {
    void accept(T t) throws Exception;
}

public interface Function<T, R> {
    R apply(T t) throws Exception;
}

public interface Predicate<T> {
    boolean test(T t) throws Exception;
}

public interface Action {
    void run() throws Exception;
}

// Backpressure strategies
public enum BackpressureStrategy {
    MISSING, ERROR, BUFFER, DROP, LATEST
}

Version

Tile

Files

tessl/maven-io-reactivex-rxjava2--rxjava

To install, run

index.md.css-3qkkll{font-size:var(--chakra-font-sizes-sm);font-weight:var(--chakra-font-weights-normal);color:var(--chakra-colors-gray-300);}docs/

RxJava

Package Information

Core Imports

Basic Usage

Architecture

Capabilities

Observable Streams

Flowable Streams

Single Values

Maybe Values

Completable Operations

Schedulers and Threading

Subjects and Hot Observables

Resource Management

Error Handling

Core Types

index.mddocs/