RxJava2 操作符 map与 flatMap

(一) map就是变换需要操作的数据内容或者结构的意思

使用场景:

当原始数据不能满足我们的需求，但我们却需要依赖这一原始数据去获取满足我们需求的数据时，那么就用它

原理图如下:

举个栗子:

结果:

(二) flatmap

1.解决for循环嵌套

private static class Student{
    private int id;
    private String name;
    private String sex;
    private List<Course> courseList;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public List<Course> getCourseList() {
        return courseList;
    }

    public void setCourseList(List<Course> courseList) {
        this.courseList = courseList;
    }

    public static class Course{
        private int id;
        private String name;

        public int getId() {
            return id;
        }

        public void setId(int id) {
            this.id = id;
        }

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }
    }
}

  //构建数据
    final List<Student> list = new ArrayList<>();
    for(int i = 0 ; i < 3 ; ++i){
        Student stu = new Student();
        stu.id = i;
        stu.name ="学生"+i;
        List<Student.Course> courses = new ArrayList<>();
        for(int j = 0 ; j < 4 ; ++j){
            Student.Course course = new Student.Course();
            course.setName(stu.name+"的课程"+j);
            course.setId(j);
            courses.add(course);
        }

        stu.setCourseList(courses);
        list.add(stu);
    }

/*创建observable将所有学生发送*/

    Observable.fromIterable(list)
        /*筛选学生：这里是学生id为0或2*/
            .filter(new Predicate<Student>() {
                @Override
                public boolean test(Student student) throws Exception {
                    return student.id == 0 || student.id == 2;
                }
            })
       /*将学生的课程发送出去，从学生实例得到课程实例，再发射出去*/
            .flatMap(new Function<Student, ObservableSource<Student.Course>>() {
                @Override
                public ObservableSource<Student.Course> apply(Student student) throws Exception {
                    Log.d(TAG,"flatmap student name = "+student.name);
                    return Observable.fromIterable(student.getCourseList()).delay(10, TimeUnit.MILLISECONDS);
                }
            })
       /*得到课程再筛选id为1或3的课程*/
            .filter(new Predicate<Student.Course>() {
                @Override
                public boolean test(Student.Course course) throws Exception {
                    return course.getId() == 1||course.id == 3;
                }
            })
       /*接受到学生的课程*/
            .subscribe(new Consumer<Student.Course>() {
                @Override
                public void accept(Student.Course course) throws Exception {
                    Log.d(TAG,"Consumer accept course = "+course.getName());
                }
            });

flatmap解决网络请求嵌套问题