Rxjava操作符之辩解map和flatmap的区别,以及应用场景

共同点:

  1. 都是依赖FuncX(入参,返回值)进行转换(将一个类型依据程序逻辑转换成另一种类型,根据入参和返回值)
  2. 都能在转换后直接被subscribe

区别:

  1. map返回的是结果集,flatmap返回的是包含结果集的Observable(返回结果不同)
  2. map被订阅时每传递一个事件执行一次onNext方法,flatmap多用于多对多,一对多,再被转化为多个时,一般利用from/just进行一一分发,被订阅时将所有数据传递完毕汇总到一个Observable然后一一执行onNext方法(执行顺序不同)>>>>(如单纯用于一对一转换则和map相同)
  3. map只能单一转换,单一只的是只能一对一进行转换,指一个对象可以转化为另一个对象但是不能转换成对象数组(map返回结果集不能直接使用from/just再次进行事件分发,一旦转换成对象数组的话,再处理集合/数组的结果时需要利用for一一遍历取出,而使用RxJava就是为了剔除这样的嵌套结构,使得整体的逻辑性更强。)
    flatmap既可以单一转换也可以一对多/多对多转换,flatmap要求返回Observable,因此可以再内部进行from/just的再次事件分发,一一取出单一对象(转换对象的能力不同)

eg.1-2:

```
  Observable.just("a", "b", "c")
            //使用map进行转换,参数1:转换前的类型,参数2:转换后的类型
            .map(new Func1() {
                @Override
                public String call(String i) {
                    String name = i;
                    Log.i("tag","map--1----"+i);
                    return name;
                }
            })
            .subscribe(new Action1() {
                @Override
                public void call(String s) {
                    Log.i("tag","map--2----"+s);
                   tv.setText(s);
                }
            });
    logcat信息
    11-23 10:24:31.350 12902-12902/com.example.seele.retrofit I/tag: map--1----a
    11-23 10:24:31.350 12902-12902/com.example.seele.retrofit I/tag: map--2----a
    11-23 10:24:31.350 12902-12902/com.example.seele.retrofit I/tag: map--1----b
    11-23 10:24:31.350 12902-12902/com.example.seele.retrofit I/tag: map--2----b
    11-23 10:24:31.350 12902-12902/com.example.seele.retrofit I/tag: map--1----c
    11-23 10:24:31.350 12902-12902/com.example.seele.retrofit I/tag: map--2----c

--------------------------------------------------------------------------------

 Observable.just("a", "b", "c")
            .flatMap(
                    new Func1>() {
                        @Override
                        public Observable call(String s) {
                            Log.i("tag", "map--1----" + s);
                            return Observable.just(s + "!!!");
                        }
                    })
            .subscribeOn(Schedulers.newThread())
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe(new Action1() {
                @Override
                public void call(String s) {
                    Log.i("tag", "map--2----" + s);
                    tv.setText(s);
                }
            });
logcat信息:
11-23 10:53:51.320 14442-14527/? I/tag: map--1----a
11-23 10:53:51.320 14442-14527/? I/tag: map--1----b
11-23 10:53:51.320 14442-14527/? I/tag: map--1----c
11-23 10:53:51.340 14442-14442/? I/tag: map--2----a!!!
11-23 10:53:51.340 14442-14442/? I/tag: map--2----b!!!
11-23 10:53:51.340 14442-14442/? I/tag: map--2----c!!!

eg.3:

打印所有学生所修的课程名(每个学生有多门课程)

如果使用map来实现的代码是这样的:

  Action1> action1 = new Action1>() {
        @Override
        public void call(List courses) {
            //遍历courses,输出cuouses的name
             for (int i = 0; i < courses.size(); i++){
                Log.i(TAG, courses.get(i).getName());
            }
        }
    };
    Observable.from(students)
            .map(new Func1>() {
                @Override
                public List call(Student student) {
                    //返回coursesList
                    return student.getCoursesList();
                }
            })
            .subscribe(action1);
//来这里在订阅之前如果继续用map处理则只能得到每个学生的一门所修的课程,只能循环遍历

flatMap实现的代码是这样的:

 Observable.from(students)
            .flatMap(new Func1>() {
                @Override
                public Observable call(Student student) {
                    return Observable.from(student.getCoursesList());
                }
            })
            .subscribe(new Action1() {
                @Override
                public void call(Course course) {
                    Log.i(TAG, course.getName());
                }
            });
//首先一旦订阅,通过flatmap根据from将所有传递过来的student包装到另一个observable中,然后一一发送事件(student)执行return Observable.from(student.getCoursesList());
//一旦事件发送完毕调用call,一一执行

使用场景:

map适用于一对一转换,当然也可以配合flatmap进行适用
flatmap适用于一对多,多对多的场景

你可能感兴趣的:(Rxjava操作符之辩解map和flatmap的区别,以及应用场景)