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<File, String>() {

    @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<File, Observable<String>>() {

    @Override public Observable<String> call(final File file) {

        return Observable.create(new Observable.OnSubscribe<String>() {

            @Override public void call(Subscriber<? super String> 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 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.

Answer 1

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<String>.

• If the return type of titleCase(..) were to be mere String, then you'd use map(s -> titleCase(s))
• If the return type of titleCase(..) were to be Observable<String>, then you'd use flatMap(s -> titleCase(s))

Hope that clarifies.