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适用于一对多，多对多的场景