When do you use map vs flatMap in RxJava

Question

When do you use map vs flatMap in RxJava   Say  for example  we want to map Files containing JSON into Strings that contain the JSON--  Using map  we have to deal with the Exception somehow  But how    Observable from jsonFile  map new Func1 lt File  String gt           Override public String call File file            try               return new Gson   toJson new FileReader file   Object class             catch  FileNotFoundException e                   So Exception  What to do                     return null     Not good                Using flatMap  it s much more verbose  but we can forward the problem down the chain of Observables and handle the error if we choose somewhere else and even retry   Observable from jsonFile  flatMap new Func1 lt File  Observable lt String gt  gt           Override public Observable lt String gt  call final File file            return Observable create new Observable OnSubscribe lt String gt                   Override public void call Subscriber lt   super String gt  subscriber                    try                       String json   new Gson   toJson new FileReader file   Object class                        subscriber onNext json                       subscriber onCompleted                      catch  FileNotFoundException e                        subscriber onError e                                                           I like the simplicity of the map  but the error handling of flatmap  not the verbosity   I haven t seen any best practices on this floating around and I m curious how this is being used in practice

User · Answer

Here is a simple thumb-rule that I use help me decide as when to use flatMap   over map   in Rx s Observable   Once you come to a decision that you re going to employ a map transformation  you d write your transformation code to return some Object right   If what you re returning as end result of your transformation is    a non-observable object then you d use just map    And map   wraps that object in an Observable and emits it  an Observable object  then you d use flatMap    And flatMap   unwraps the Observable  picks the returned object  wraps it with its own Observable and emits it    Say for example we ve a method titleCase String inputParam  that returns Titled Cased String object of the input param  The return type of this method can be String or Observable lt String gt     If the return type of titleCase     were to be mere String  then you d use map s - gt  titleCase s   If the return type of titleCase     were to be Observable lt String gt   then you d use flatMap s - gt  titleCase s     Hope that clarifies

User · Answer

I just wanted to add that with flatMap  you don t really need to use your own custom Observable inside the function and you can rely on standard factory methods operators   Observable from jsonFile  flatMap new Func1 lt File  Observable lt String gt  gt           Override public Observable lt String gt  call final File file            try               String json   new Gson   toJson new FileReader file   Object class               return Observable just json             catch  FileNotFoundException ex                return Observable  lt String gt error ex                         Generally  you should avoid throwing  Runtime-  exceptions from onXXX methods and callbacks if possible  even though we placed as many safeguards as we could in RxJava

User · Answer

The question is When do you use map vs flatMap in RxJava   And I think a simple demo is more specific   When you want to convert item emitted to another type   in your case converting file to String  map and flatMap can both work  But I prefer map operator because it s more clearly   However in some place  flatMap can do magic work but map can t  For example  I want to get a user s info but I have to first get his id when user login in  Obviously I need two requests and they are in order    Let s begin    Observable lt LoginResponse gt  login String email  String password    Observable lt UserInfo gt  fetchUserInfo String userId     Here are two methods  one for login returned Response  and another for fetching user info   login email  password           flatMap response - gt                  fetchUserInfo response id            subscribe userInfo - gt                   get user info and you update ui now               As you see  in function flatMap applies  at first I get user id from Response then fetch user info  When two requests are finished  we can do our job such as updating UI or save data into database    However if you use map you can t write such nice code  In a word  flatMap can help us serialize requests

User · Answer

map transform one event to another  flatMap transform one event to zero or more event   this is taken from IntroToRx   As you want to transform your json to an object  using map should be enough   Dealing with the FileNotFoundException is another problem  using map or flatmap wouldn t solve this issue    To solve your Exception problem  just throw it with a Non checked exception   RX will call the onError handler for you   Observable from jsonFile  map new Func1 lt File  String gt           Override public String call File file            try               return new Gson   toJson new FileReader file   Object class             catch  FileNotFoundException e                   this exception is a part of rx-java             throw OnErrorThrowable addValueAsLastCause e  file                         the exact same version with flatmap     Observable from jsonFile  flatMap new Func1 lt File  Observable lt String gt  gt           Override public Observable lt String gt  call File file            try               return Observable just new Gson   toJson new FileReader file   Object class              catch  FileNotFoundException e                   this static method is a part of rx-java  It will return an exception which is associated to the value              throw OnErrorThrowable addValueAsLastCause e  file                  alternatively  you can return Obersable empty    instead of throwing exception                       You can return too  in the flatMap version a new Observable that is just an error   Observable from jsonFile  flatMap new Func1 lt File  Observable lt String gt  gt           Override public Observable lt String gt  call File file            try               return Observable just new Gson   toJson new FileReader file   Object class              catch  FileNotFoundException e                return Observable error OnErrorThrowable addValueAsLastCause e  file

User · Answer

In your case you need map  since there is only 1 input and 1 output    map - supplied function simply accepts an item and returns an item which will be emitted further  only once  down   flatMap - supplied function accepts an item then returns an  Observable   meaning each item of the new  Observable  will be emitted separately further down    May be code will clear things up for you   Observable just  item1   map  str - gt        System out println  inside the map     str       return str     subscribe System out  println    Observable just  item2   flatMap  str - gt        System out println  inside the flatMap     str       return Observable just str        str          str              subscribe System out  println     Output   inside the map item1 item1 inside the flatMap item2 item2  item2   item2

User · Answer

Flatmap maps observables to observables   Map maps items to items    Flatmap is more flexible but Map is more lightweight and direct  so it kind of depends on your usecase   If you are doing ANYTHING async  including switching threads   you should be using Flatmap  as Map will not check if the consumer is disposed  part of the lightweight-ness

User · Answer

In that scenario use map  you don t need a new Observable for it   you should use Exceptions propagate  which is a wrapper so you can send those checked exceptions to the rx mechanism   Observable lt String gt  obs   Observable from jsonFile  map new Func1 lt File  String gt            Override public String call File file            try                return new Gson   toJson new FileReader file   Object class             catch  FileNotFoundException e                throw Exceptions propagate t    will propagate it as error                         You then should handle this error in the subscriber  obs subscribe new Subscriber lt String gt           Override      public void onNext String s      valid result         Override      public void onCompleted              Override      public void onError Throwable e      e might be the FileNotFoundException you got           There is an excellent post for it  http   blog danlew net 2015 12 08 error-handling-in-rxjava

User · Answer

FlatMap behaves very much like map  the difference is that the function it applies returns an observable itself  so it s perfectly suited to map over asynchronous operations    In the practical sense  the function Map applies just makes a transformation over the chained response  not returning an Observable   while the function FlatMap applies returns an Observable lt T gt   that is why FlatMap is recommended if you plan to make an asynchronous call inside the method   Summary    Map returns an object of type T FlatMap returns an Observable    A clear example can be seen here  http   blog couchbase com why-couchbase-chose-rxjava-new-java-sdk    Couchbase Java 2 X Client uses Rx to provide asynchronous calls in a convenient way  Since it uses Rx  it has the methods map and FlatMap  the explanation in their documentation might be helpful to understand the general concept    To handle errors  override onError on your susbcriber   Subscriber lt String gt  mySubscriber   new Subscriber lt String gt           Override     public void onNext String s    System out println s           Override     public void onCompleted             Override     public void onError Throwable e           It might help to look at this document  http   blog danlew net 2014 09 15 grokking-rxjava-part-1   A good source about how to manage errors with RX can be found at  https   gist github com daschl db9fcc9d2b932115b679

User · Answer

The way I think about it is that you use flatMap when the function you wanted to put inside of map   returns an Observable  In which case you might still try to use map   but it would be unpractical  Let me try to explain why   If in such case you decided to stick with map  you would get an Observable lt Observable lt Something gt  gt   For example in your case  if we used an imaginary RxGson library  that returned an Observable lt String gt  from it s toJson   method  instead of simply returning a String  it would look like this   Observable from jsonFile  map new Func1 lt File  Observable lt String gt  gt           Override public Observable lt String gt  gt  call File file            return new RxGson   toJson new FileReader file   Object class                you get Observable lt Observable lt String gt  gt  here   At this point it would be pretty tricky to subscribe   to such an observable  Inside of it you would get an Observable lt String gt  to which you would again need to subscribe   to get the value  Which is not practical or nice to look at   So to make it useful one idea is to  flatten  this observable of observables  you might start to see where the name  flat Map comes from   RxJava provides a few ways to flatten observables and for sake of simplicity lets assume merge is what we want  Merge basically takes a bunch of observables and emits whenever any of them emits   Lots of people would argue switch would be a better default  But if you re emitting just one value  it doesn t matter anyway    So amending our previous snippet we would get   Observable from jsonFile  map new Func1 lt File  Observable lt String gt  gt           Override public Observable lt String gt  gt  call File file            return new RxGson   toJson new FileReader file   Object class            merge       you get Observable lt String gt  here   This is a lot more useful  because subscribing to that  or mapping  or filtering  or     you just get the String value   Also  mind you  such variant of merge   does not exist in RxJava  but if you understand the idea of merge then I hope you also understand how that would work    So basically because such merge   should probably only ever be useful when it succeeds a map   returning an observable and so you don t have to type this over and over again  flatMap   was created as a shorthand  It applies the mapping function just as a normal map   would  but later instead of emitting the returned values it also  flattens   or merges  them   That s the general use case  It is most useful in a codebase that uses Rx allover the place and you ve got many methods returning observables  which you want to chain with other methods returning observables   In your use case it happens to be useful as well  because map   can only transform one value emitted in onNext   into another value emitted in onNext    But it cannot transform it into multiple values  no value at all or an error  And as akarnokd wrote in his answer  and mind you he s much smarter than me  probably in general  but at least when it comes to RxJava  you shouldn t throw exceptions from your map    So instead you can use flatMap   and  return Observable just value     when all goes well  but   return Observable error exception     when something fails  See his answer for a complete snippet  https   stackoverflow com a 30330772 1402641

User · Answer

In some cases you might end up having chain of observables  wherein your observable would return another observable   flatmap  kind of unwraps the second observable which is buried in the first one and let you directly access the data second observable is spitting out while subscribing

[java] When do you use map vs flatMap in RxJava?

Examples related to java

Examples related to mapping

Examples related to rx-java

Examples related to flatmap