Skip to content
Related Articles

Related Articles

Save Article
Improve Article
Save Article
Like Article

Understanding RxJava Create and fromCallable Operator

  • Last Updated : 17 Aug, 2021

In this article, we will learn about the RxJava Create and fromCallable Operators. We can choose between the required function based on what is required skillset is needed. We frequently make mistakes when utilizing RxJava Operators. Let’s get this straight so we don’t make a mistake.

With examples, we shall study the following operations.

Attention reader! Don’t stop learning now. Get hold of all the important Java Foundation and Collections concepts with the Fundamentals of Java and Java Collections Course at a student-friendly price and become industry ready. To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

  • Create
  • fromCallable

1. Create

RxJava Operator should be created.

Image 1. The RxJava Operator.

Build Operator: Use a function to create an Observable from scratch.



Using the Create Operator, we may do a job and keep emitting values one by one until the operation is completed. 

Let’s have a look at an example:

Java




Observable.create<String> { shooter ->
    // do something
    if (!shooter.isDisposed) {
        shooter.onNext("GeeksforGeeks")
    }
    // do and emit
    if (!shooter.isDisposed) {
        shooter.onNext("GfG")
    }
    // on finish
    if (!shooter.isDisposed) {
        shooter.onComplete()
    }
}
.subscribeOn(Schedulers.io())
.subscribe { item ->
    Log.d("Android", "item : $item")
}

Output:

"GeeksforGeeks" "GfG"

This operator creates an observable from zero but even after that, it can only shoot only 1 item at a time, hence it returns an item!

Image 2. The Callable.

Java




Observable.fromCallable<String> {
    // perform a task and then return
    return@fromCallable "Geeks for Geeks"
}

Output: 

Geeks for Geeks

This does not imply that fromCallable is equivalent to Single. We’ll see how it truly varies later. Both of them will continue to postpone the action until and unless they do some observation. This means that it renders the task “lazy.”

So, here are the key distinctions between the Create and fromCallable operators:

  1. Create can produce several things, whereas fromCallable can only produce one.
  2. There is no easy method to see if isDisposed in fromCallable is present as it is in Create. Hence if it shoots an item after they have been disposed of, then that throwable is handled to the global error handler. It implies that the application will be terminated.

Conclusion

We can here so use RxJava Create to solve this problem, hope this article clears out any doubts which would’ve arisen and removed the mist from knowledge.




My Personal Notes arrow_drop_up
Recommended Articles
Page :