【Android】RxJava的使用（三）转换——map、flatMap

前两篇Android RxJava的使用（一）基本用法、Android RxJava的使用（二）Action介绍了RxJava的基本用法，对Rxjava还不了解的请先看以上两篇。这篇为你们讲解RxJava中map和flatMap的使用。

参考： 给 Android 开发者的 RxJava 详解
（本文部份内容引用自该博客）

回顾

前两篇为你们介绍了使用RxJava打印多个字符串的方法

Observable.just("Hellow", "Wrold").subscribe(new Action1<String>() {
          @Override
          public void call(String s) {
              Log.i(TAG, s);
          }
      });

这样的例子基本没有实际用处，只是为你们演示如何使用Rxjava。今天就抛开这个例子。

map

在使用map以前要先说道一个接口：Func1，Func1和上一篇提到的Action1类似。Func1 和 Action的区别在于， Func1 包装的是有返回值的方法。
接下来就是map的用法，看代码更直观点；
例：获得多个Student对象中的name，保存到nameList中

Observable.just(student1, student2, student2)
                //使用map进行转换，参数1：转换前的类型，参数2：转换后的类型
                .map(new Func1<Student, String>() {
                    @Override
                    public String call(Student i) {
                        String name = i.getName();//获取Student对象中的name
                        return name;//返回name
                    }
                })
                .subscribe(new Action1<String>() {
                    @Override
                    public void call(String s) {
                        nameList.add(s);
                    }
                });

能够看到Observable中原来的参数是Student对象，而最后咱们须要的是name，这里使用了map来实现这一转换的过程。固然，map能够屡次使用。

//屡次使用map，想用几个用几个
        Observable.just("Hello", "World")
                .map(new Func1<String, Integer>() {//将String类型的转化为Integer类型的哈希码
                    @Override
                    public Integer call(String s) {
                        return s.hashCode();
                    }
                })
                .map(new Func1<Integer, String>() {//将转化后获得的Integer类型的哈希码再转化为String类型
                    @Override
                    public String call(Integer integer) {
                        return integer.intValue() + "";
                    }
                })
                .subscribe(new Action1<String>() {
                    @Override
                    public void call(String s) {
                        Log.i(TAG, s);
                    }
                });

flatMap

flatMap是一个比教难理解的一个转换，在这里先假设一个需求，须要打印多个Student所学的课程。这跟以前获取Student的name又不一样了，这里先肯定一下关系，一个Student类中只有一个name，而一个Student却有多门课程（Course），Student咱们能够理解成这样：

/**
     * 学生类
     */
    class Student {
        private String name;//姓名
        private List<Course> coursesList;//所修的课程
        ...
    }
    /**
     * 课程类
     */
    class  Course {
        private String name;//课程名
        private String id;
        ...
    }

若是使用map来实现打印全部学生所修个课程名，实现的代码是这样的：

List<Student> students = new ArrayList<Student>();
        students.add...
        ...

        Action1<List<Course>> action1 = new Action1<List<Course>>() {
            @Override
            public void call(List<Course> 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<Student, List<Course>>() {
                    @Override
                    public List<Course> call(Student student) {
                        //返回coursesList
                        return student.getCoursesList();
                    }
                })
                .subscribe(action1);

能够看到，在Action1中出现了for来循环打印课程名，使用RxJava就是为了剔除这样的嵌套结构，使得总体的逻辑性更强。这时候就可使用flatMap了，使用flatMap实现的代码是这样的：

List<Student> students = new ArrayList<Student>();
        students.add...
        ...

        Observable.from(students)
                .flatMap(new Func1<Student, Observable<Course>>() {
                    @Override
                    public Observable<Course> call(Student student) {
                        return Observable.from(student.getCoursesList());
                    }
                })
                .subscribe(new Action1<Course>() {
                    @Override
                    public void call(Course course) {
                        Log.i(TAG, course.getName());
                    }
                });

这样就实现了跟上面代码同样的效果，看起来有点懵？确实，flatMap理解起来有点绕，刚接触flatMap的时候我也是懵逼一个。下面我将flatMap的示意图，但愿能帮助理解：

由上图能够看出Student一、Student2通过flatMap后，按顺序依次经历了Observable一、Observable2，分别转化为Course。最后按顺序获得Course一、Course二、Course三、Course四、Course五、Course6，其中1-3由Student1获得，4-6由Student2获得。
结合代码和示意图，是否是对flatMap有了必定的理解。

注意：FlatMap对这些Observables发射的数据作的是合并(merge)操做，所以它们多是交错的。也就说，传入的顺序可能跟出来的顺序不同。
若是要保证顺的的话，可使用concatMap。

其余操做符

除了map和flatMap以外，还有其余操做符以供使用。这里就不一一列举他们的用法了，其余经常使用的操做符以下：

filter：集合进行过滤
each：遍历集合
take：取出集合中的前几个
skip：跳过前几个元素

更多操做符

小结

看完map、flatMap后，慢慢能看到RxJava的实际用处了。不过只是这点功能的RxJava是远远不能知足咱们的需求，更多的用法我只能在后面更新了。今天就到这里吧！！！

以上有错误之处感谢指出

更多：
Android RxJava的使用（四）线程控制 —— Scheduler

参考：给 Android 开发者的 RxJava 详解（本文部份内容引用自该博客）