Types of Observables in RxJava

In the model-view paradigm, this class represents an observable object, or "data." It can be subclassed in order to represent an object that the application wishes to watch. The issue is that you're creating software that will render data describing a three-dimensional scene in two dimensions. The application must be modular and allow for numerous, concurrent views of the same scene. 

One or more observers can be assigned to an observable object. An observer can be any object that implements the Observer interface. When an observable instance changes, an application that calls the Observable's notifyObservers() method notifies all of its observers of the change through a call to their update method.

👁 Image

In simple terms,  

• An Observable is analogous to a speaker that broadcasts the value. It does various tasks and generates some values.
• An Operator is similar to a translator in that it converts/modifies data from one form to another.
• An Observer is what fetches the value.

Observable Types in RxJava

The many types of Observables in RxJava are as follows:

• Observable
• Flowable
• Single
• Maybe
• Completable

Let's commence creating some Observables in RxJava to better understand this,  

Type #1: Creating a Basic Observable

Use Case: Assume you are downloading a file and need to push the current status of the download. You will have to emit more than one value in this case.

 
Type #2: Creating a Complex Obersever using Observable

Observer <> Flowable

When the Observable emits a large number of values that cannot be absorbed by the Observer, the Flowable comes into play. In this scenario, the Observable must skip some data based on a strategy, otherwise, it will throw an exception. A strategy is used by the Flowable Observable to handle the exception. BackPressureStrategy is the strategy, and MissingBackPressureException is the exception. 

Geek Tip: Just like type #1, you can create Flowable using Flowable.create() similarly.

Solitary<> SingleObserver

When an Observable must emit only one value, such as a response to a network request, Single is used.

Type #3: Creating Single Observable 

 
Then use it with a single observable in the following manner: 

 
The maybe <> Observer

When the Observable must emit a value or no value, maybe is used.

Type #4: Creating a maybe Observer 

 
Completable <> CompletableObserver

When the Observable must do some job without emitting a value, it is called a Completable.

Type #5: Creating a Completable Observer 

Using it now in the following manner: 

Conclusion

The class combines the properties of a view (it textually shows the value of the model's current state) with a controller (it allows the user to enter a new value for the state of the model). With help of this article, you would have now known how to create an Observable in any way you want and then use it as your procured use case.