Introduction to RxJava

What is RxJava?

RxJava is a Java implementation of ReactiveX, a library for composing asynchronous and event-based programs using observable sequences. It extends the observer pattern to support sequences of data and/or events and adds operators that allow you to compose sequences together declaratively.

RxJava allows you to write clean, composable, and flexible code for asynchronous operations such as:

• Network calls and API responses
• UI events and user interactions
• Database queries and data processing
• Background processing and computation
• Event streams and messaging

Getting Started

Installation

To start using RxJava in your project, add the following dependency:

1// Maven
2<dependency>
3    <groupId>io.reactivex.rxjava3</groupId>
4    <artifactId>rxjava</artifactId>
5    <version>3.1.8</version>
6</dependency>
7
8// Gradle
9implementation 'io.reactivex.rxjava3:rxjava:3.1.8'

Core Concepts

Observable

The core type in RxJava is the Observable. An Observable represents a stream of data or events that can be observed. It can emit:

• Zero or more items (onNext)
• An error (onError)
• A completion signal (onComplete)

1import io.reactivex.rxjava3.core.Observable;
2
3// Creating an Observable that emits a sequence of integers
4Observable<Integer> observable = Observable.fromArray(1, 2, 3, 4, 5);
5
6// Subscribing to the Observable
7observable.subscribe(
8    item -> System.out.println("Received: " + item),  // onNext
9    error -> System.err.println("Error: " + error),   // onError
10    () -> System.out.println("Completed")             // onComplete
11);

Operators

Operators allow you to transform, combine, manipulate, and work with the sequences emitted by Observables. RxJava provides a vast array of operators to handle almost any scenario.

1import io.reactivex.rxjava3.core.Observable;
2
3Observable.fromArray(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
4    .filter(n -> n % 2 == 0)      // Keep only even numbers
5    .map(n -> n * n)              // Square each number
6    .take(3)                      // Take only the first 3 results
7    .subscribe(
8        result -> System.out.println("Result: " + result),
9        error -> System.err.println("Error: " + error),
10        () -> System.out.println("Processing completed")
11    );
12
13// Output:
14// Result: 4
15// Result: 16
16// Result: 36
17// Processing completed

Schedulers

Schedulers in RxJava manage the execution context (thread) on which operations run, allowing you to control concurrency. Some common schedulers include:

• Schedulers.io() - For IO-bound work (network, disk)
• Schedulers.computation() - For CPU-intensive work
• Schedulers.newThread() - Creates a new thread for each unit of work
• AndroidSchedulers.mainThread() - For Android UI thread operations (with RxAndroid)

Key Benefits of RxJava