*map家族

Rxjava提供了mapping函数：map() , flatMap(), concatMap(), flatMapIterable(), switchMap()所有的这些函数都是作用于一个可观测序列，然后变换它发射的值，最后以一种新的形式返还给它们。

1：map()

    
 PRivate void testMap() {        List<String> lists = new ArrayList<>();        lists.add("aa");        lists.add("bb");        lists.add("cc");        Observable.from(lists)                .map(new Func1<String, Character>() {                    @Override                    public Character call(String s) {                        return s.charAt(0);                    }                })                .subscribe(new Subscriber<Character>() {                    @Override                    public void onCompleted() {                    }                    @Override                    public void onError(Throwable e) {                    }                    @Override                    public void onNext(Character c) {                        Log.e("TAG", c+"");                    }                });    }
2:flatmap();
根据原本的Observable发送的事件根据需求创建一个新的事件。比如：一个学生有多门成绩，我们现在有一个List<Student> 集合，其中每个Studnet对象有一个课程集合List<String>;想要打印最终的课程，可以通过如下：首先定义一个很简单的Student类
 class Student {        private List<String> courses;        public List<String> getCourses() {            return courses;        }        public void setCourses(List<String> courses) {            this.courses = courses;        }    }通过flatmap创建新的事件
    private void testFlatMap() {        List<Student> students = new ArrayList<>();        //对每一个Studnet对象的courses赋值，此步骤省略        Observable.from(students)                .flatMap(new Func1<Student, Observable<String>>() {                    @Override                    public Observable<String> call(Student student) {                        return Observable.from(student.getCourses());                    }                }).subscribe(new Action1<String>() {            @Override            public void call(String s) {                Log.e("TAG", "课程名="+s);            }        });    }
3：concatmap();
concatmap和flatmap的作用基本相同，都是根据事件创建一个新的事件。唯一不同的是flamap不能保证事件重组后的顺序，比如由事件1创建出a,b两个事件；由事件2创建出c,d两个事件，那么通过flatmap发出的事件可能是a->c->b->d。而通过concatmap重组的事件必须是a->b->c->d.
class Student {        private List<String> courses;        public List<String> getCourses() {            return courses;        }        public void setCourses(List<String> courses) {            this.courses = courses;        }    }    private void testFlatMap() {        List<Student> students = new ArrayList<>();        //对每一个Studnet对象的courses赋值，此步骤省略        Observable.from(students)                .concatMap(new Func1<Student, Observable<String>>() {                    @Override                    public Observable<String> call(Student student) {                        return Observable.from(student.getCourses());                    }                }).subscribe(new Action1<String>() {            @Override            public void call(String s) {                Log.e("TAG", "课程名=" + s);            }        });    }
4：flatmapIterable();
和flatmap()使用效果相似。区别是flatmap参数把每一个数据转换成一个新的Observable,而flatMapIterable的参数把每一个数据转换成一个Iterable对象
  class Student {        private List<String> courses;        public List<String> getCourses() {            return courses;        }        public void setCourses(List<String> courses) {            this.courses = courses;        }    }    private void testFlatMapIterable() {        List<Student> students = new ArrayList<>();        //对每一个Studnet对象的courses赋值，此步骤省略        Observable.from(students)                .flatMapIterable(new Func1<Student, Iterable<String>>() {                    @Override                    public Iterable<String> call(Student student) {                        return student.getCourses();                    }                }).subscribe(new Observer<String>() {            @Override            public void onCompleted() {            }            @Override            public void onError(Throwable e) {            }            @Override            public void onNext(String s) {                Log.e("TAG", "course=" + s);            }        });    }
5:switchMap();
和flatmap()作用相似。不同的是switchMap:每当源Observable发射一个新的数据项时，会停止订阅和监视上一个数据项产生的Observable,并开始监视当前发射的这一个。
 class Student {        private List<String> courses;        public List<String> getCourses() {            return courses;        }        public void setCourses(List<String> courses) {            this.courses = courses;        }    }        private void testSwitchMap() {        List<Student> students = new ArrayList<>();        //对每一个Studnet对象的courses赋值，此步骤省略        Observable.from(students)                .switchMap(new Func1<Student, Observable<String>>() {                    @Override                    public Observable<String> call(Student student) {                        return Observable.from(student.getCourses());                    }                }).subscribe(new Observer<String>() {            @Override            public void onCompleted() {            }            @Override            public void onError(Throwable e) {            }            @Override            public void onNext(String s) {                Log.e("TAG", "course=" + s);            }        });    }
6：sacn();
对于原始序列的每一个数据都应用于一个函数，函数计算的结果作为下一个数据的第一个参数来使用。
  private void testScan() {        Observable.just("a", "b", "c", "d")                .scan(new Func2<String, String, String>() {                    @Override                    public String call(String sum, String s) {                        return sum + s;                    }                }).subscribe(new Subscriber<String>() {            @Override            public void onCompleted() {            }            @Override            public void onError(Throwable e) {            }            @Override            public void onNext(String s) {                Log.e("TAG", s);            }        });    }以上通过每次把数据源累加，最后的结为：aababcabcd在此，map家族介绍完毕