Android打造自己的网络框架----RxJava的基础学习使用2（map、flatMap）

这篇为大家讲解RxJava中map和flatMap的使用。

map

在使用map之前要先说道一个接口：Func1，Func1和上一篇提到的Action1相似。Func1 和 Action的区别在于， Func1 包装的是有返回值的方法。

下面给大家介绍下这个用法

Observable.just(student1, student2, student3)
                //使用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);
                    }
                });

从上面可以看到FUNC1参数1：转换前的类型，参数2：转换后的类型

其实看到这里大家基本都明白了，map其实就是过滤下数据，吧转换后的返回数据传给subscribe里面。
当然也可以多个map

  //多次使用map，想用几个用几个
        Observable.just("Hello", "World")
                .map(new Func1<String, Integer>() {//将String类型的转化为Integer类型的哈希码
                    @Override
                    public Integer call(String s) {
                        return s.length();
                    }
                })
                .map(new Func1<Integer, String>() {//将转化后得到的Integer类型的哈希码再转化为String类型
                    @Override
                    public String call(Integer integer) {
                        Log.e("看看传的值",integer+"");
                        return "=="+integer.intValue();
                    }
                })
                .subscribe(new Action1<String>() {
                    @Override
                    public void call(String s) {
                        Log.i("===这是==", s);
                    }
                });

可以看到其实就是map按规则处理下，返回传给下面继续按规则处理知道传到subscribe

flatMap

flatMap是一个比教难理解的一个转换，在这里先假设一个需求，需要打印多个Student所学的课程。这跟之前获取Student的name又不同了，这里先确定一下关系，一个Student类中只有一个name，而一个Student却有多门课程（Course），
类如下

public class Student {
    private String name;//课程名
    private List<Course>list;



public class Course {
    private String name;//课程名
    private String id;

这里如果用map也能处理处理如下

  Observable.from(students)
                .map(new Func1<Student, List<Course>>() {
                    @Override
                    public List<Course> call(Student student) {
                        //返回coursesList
                        return student.getList();
                    }
                })
                .subscribe(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());
                        }
                    }
                });

但是你看到我们用了for循环，因为传来的是一个集合

这里用flatMap就很好处理了

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

大家可以看到这里flatmap将其转换的是Observable，也就是把内部把得到集合再处理成一块一块的

还有其他的操作符（不常用就先不说了）

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