RxJava.zip

# RxJava: Reactive Extensions for the JVM <a href='https://github.com/ReactiveX/RxJava/actions?query=workflow%3ASnapshot'><img src='https://github.com/ReactiveX/RxJava/workflows/Snapshot/badge.svg'></a> [](https://codecov.io/gh/ReactiveX/RxJava/branch/3.x) [](https://maven-badges.herokuapp.com/maven-central/io.reactivex.rxjava3/rxjava) [](https://gitpod.io/#https://github.com/ReactiveX/RxJava) RxJava is a Java VM implementation of [Reactive Extensions](http://reactivex.io): a library for composing asynchronous and event-based programs by using observable sequences. It extends the [observer pattern](http://en.wikipedia.org/wiki/Observer_pattern) to support sequences of data/events and adds operators that allow you to compose sequences together declaratively while abstracting away concerns about things like low-level threading, synchronization, thread-safety and concurrent data structures. #### Version 3.x ([Javadoc](http://reactivex.io/RxJava/3.x/javadoc/)) - Single dependency: [Reactive-Streams](https://github.com/reactive-streams/reactive-streams-jvm). - Java 8+ or Android API 21+ required. - Java 8 lambda-friendly API. - [Android](https://github.com/ReactiveX/RxAndroid) desugar friendly. - Fixed API mistakes and many limits of RxJava 2. - Intended to be a replacement for RxJava 2 with relatively few binary incompatible changes. - Non-opinionated about the source of concurrency (threads, pools, event loops, fibers, actors, etc.). - Async or synchronous execution. - Virtual time and schedulers for parameterized concurrency. - Test and diagnostic support via test schedulers, test consumers and plugin hooks. - Interop with newer JDK versions via 3rd party libraries, such as - [Java 9 Flow API](https://github.com/akarnokd/RxJavaJdk9Interop#rxjavajdk9interop) - [Java 21 Virtual Threads](https://github.com/akarnokd/RxJavaFiberInterop#rxjavafiberinterop) Learn more about RxJava in general on the <a href="https://github.com/ReactiveX/RxJava/wiki">Wiki Home</a>. :information_source: Please read the [What's different in 3.0](https://github.com/ReactiveX/RxJava/wiki/What's-different-in-3.0) for details on the changes and migration information when upgrading from 2.x. #### Version 2.x The [2.x version](https://github.com/ReactiveX/RxJava/tree/2.x) is end-of-life as of **February 28, 2021**. No further development, support, maintenance, PRs and updates will happen. The [Javadoc]([Javadoc](http://reactivex.io/RxJava/2.x/javadoc/)) of the very last version, **2.2.21**, will remain accessible. #### Version 1.x The [1.x version](https://github.com/ReactiveX/RxJava/tree/1.x) is end-of-life as of **March 31, 2018**. No further development, support, maintenance, PRs and updates will happen. The [Javadoc]([Javadoc](http://reactivex.io/RxJava/1.x/javadoc/)) of the very last version, **1.3.8**, will remain accessible. ## Getting started ### Setting up the dependency The first step is to include RxJava 3 into your project, for example, as a Gradle compile dependency: ```groovy implementation "io.reactivex.rxjava3:rxjava:3.x.y" ``` (Please replace `x` and `y` with the latest version numbers: [](https://maven-badges.herokuapp.com/maven-central/io.reactivex.rxjava3/rxjava) ) ### Hello World The second is to write the **Hello World** program: ```java package rxjava.examples; import io.reactivex.rxjava3.core.*; public class HelloWorld { public static void main(String[] args) { Flowable.just("Hello world").subscribe(System.out::println); } } ``` Note that RxJava 3 components now live under `io.reactivex.rxjava3` and the base classes and interfaces live under `io.reactivex.rxjava3.core`. ### Base classes RxJava 3 features several base classes you can discover operators on: - [`io.reactivex.rxjava3.core.Flowable`](http://reactivex.io/RxJava/3.x/javadoc/io/reactivex/rxjava3/core/Flowable.html): 0..N flows, supporting Reactive-Streams and backpressure - [`io.reactivex.rxjava3.core.Observable`](http://reactivex.io/RxJava/3.x/javadoc/io/reactivex/rxjava3/core/Observable.html): 0..N flows, no backpressure, - [`io.reactivex.rxjava3.core.Single`](http://reactivex.io/RxJava/3.x/javadoc/io/reactivex/rxjava3/core/Single.html): a flow of exactly 1 item or an error, - [`io.reactivex.rxjava3.core.Completable`](http://reactivex.io/RxJava/3.x/javadoc/io/reactivex/rxjava3/core/Completable.html): a flow without items but only a completion or error signal, - [`io.reactivex.rxjava3.core.Maybe`](http://reactivex.io/RxJava/3.x/javadoc/io/reactivex/rxjava3/core/Maybe.html): a flow with no items, exactly one item or an error. ### Some terminology #### Upstream, downstream The dataflows in RxJava consist of a source, zero or more intermediate steps followed by a data consumer or combinator step (where the step is responsible to consume the dataflow by some means): ```java source.operator1().operator2().operator3().subscribe(consumer); source.flatMap(value -> source.operator1().operator2().operator3()); ``` Here, if we imagine ourselves on `operator2`, looking to the left towards the source is called the **upstream**. Looking to the right towards the subscriber/consumer is called the **downstream**. This is often more apparent when each element is written on a separate line: ```java source .operator1() .operator2() .operator3() .subscribe(consumer) ``` #### Objects in motion In RxJava's documentation, **emission**, **emits**, **item**, **event**, **signal**, **data** and **message** are considered synonyms and represent the object traveling along the dataflow. #### Backpressure When the dataflow runs through asynchronous steps, each step may perform different things with different speed. To avoid overwhelming such steps, which usually would manifest itself as increased memory usage due to temporary buffering or the need for skipping/dropping data, so-called backpressure is applied, which is a form of flow control where the steps can express how many items are they ready to process. This allows constraining the memory usage of the dataflows in situations where there is generally no way for a step to know how many items the upstream will send to it. In RxJava, the dedicated `Flowable` class is designated to support backpressure and `Observable` is dedicated to the non-backpressured operations (short sequences, GUI interactions, etc.). The other types, `Single`, `Maybe` and `Completable` don't support backpressure nor should they; there is always room to store one item temporarily. #### Assembly time The preparation of dataflows by applying various intermediate operators happens in the so-called **assembly time**: ```java Flowable<Integer> flow = Flowable.range(1, 5) .map(v -> v * v) .filter(v -> v % 3 == 0) ; ``` At this point, the data is not flowing yet and no side-effects are happening. #### Subscription time This is a temporary state when `subscribe()` is called on a flow that establishes the chain of processing steps internally: ```java flow.subscribe(System.out::println) ```` This is when the **subscription side-effects** are triggered (see `doOnSubscribe`). Some sources block or start emitting items right away in this state. #### Runtime This is the state when the flows are actively emitting items, errors or completion signals: ```java Observable.create(emitter -> { while (!emitter.isDisposed()) { long time = System.currentTimeMillis(); emitter.onNext(time); if (time % 2 != 0) { emitter.onError(new IllegalStateException("Odd millisecond!")); break; } } }) .subscri