Chapter 1, Building your First "Hello World" RxJava Application, will briefly cover an initial setup of RxJava, and we will use it to produce a first "Hello World" message in a reactive fashion even though it will be super simplistic. To do this, we will set up RxJava dependencies and Retrolambda to make our application support lambdas from Java 8.

Chapter 2, Understanding the Basics of RxJava, will explain the core aspects of RxJava. We will learn what Observables, Subscribers, Flowables, and others are. These basic building blocks will be used extensively through the book.

Chapter 3, Learning to use Retrofit by Fetching Financial Data, says that very few modern applications can get away without relying on internet connectivity. In this chapter, we will learn how to use the most popular Retrofit library to do HTTP requests and some basics of data processing. All this will be done while retrieving remote financial stock quote data and displaying it in the UI.

Chapter 4, Integrating RxJava 1.0 with RxJava 2.0, explains that RxJava 2.0 was introduced quite recently, so lots of libraries are still available only for RxJava 1.0. Here, we will learn how to connect different versions of RxJava.

Chapter 5, Writing Data to SQLite and Schedulers, asserts that one of the most popular options for data persistence is SQLite database. With RxJava, you can use libraries, such as StorIO, to make the interactions reactive. Additionally, Schedulers will be covered so that developers can change where the actual computations are being run.

Chapter 6, Error Handling and SQLite Data Reading, cover one of the most important aspects while writing code--error handling. We will learn various ways of doing that in RxJava. Furthermore, we will learn how StorIO can be used to read financial stock data that was saved in SQLite before.

Chapter 7, Integrating RxJava with Activity Lifecycle, will teach a very important aspect of Android and RxJava--resource leaks. Here, we will learn how to prevent memory and thread leaks by delving deep into the Activity Lifecycle and exploring a few different ways how the life cycle methods can be connected to RxJava.

Chapter 8, Writing Custom Observables, explores the creation of custom observables. We will do this by creating a custom observable to consume an endless stream of Twitter updates. These updates will be incorporated into the existing financial quote data flow and displayed in the UI.

Chapter 9, Advanced Observable Flows Explained, says that there are many different operations available in RxJava. We will learn how the .zip() and .flatMap() operators work and how they can be used. Also, we will explore advanced operators, such as .groupBy() and .switchMap().

Chapter 10, Higher Level Abstractions, explains that as the code can get messy really easy, it is extremely useful to be well versed in refactoring, which helps to simplify code and abstract away unnecessary details. Here, we will learn how method extraction, static method factories, and other approaches can help us achieve that.

Chapter 11, Basics of Subjects and Preference Persistence, covers subjects as a handy tool that behave as data producer and consumer. We will learn how they work, and we will cover a few different types of Subjects. After this chapter, we will know how different Subject types can be used and what use cases are appropriate for them.

Chapter 12, Learning to Read Marble Diagrams, explores and explains several examples of marble diagrams. Marble diagrams and the knowledge of how to read them will prove to be of extreme use when one wants to read the official RxJava documentation, as almost all operations are explained in marble diagrams.