Rxjava——变换操作符

当你有一个需要订阅的Observable，并且希望转换结果的时候（切记，响应式编程中一切皆流）。即将涉及到observable转换的时候，从队列中取出将要消费的事件，不可能一直是我们需要的格式或者形状，可能每个值都需要扩展成更丰富的对象或者化作更多的值。为了达到目的，我们可以为每一个observable的返回值使用一个这样的方法函数，使用它可以将所有已发送的事件转换成各种Observable，并最终合并结果。

1. map

map操作符的作用就是将一个事件转换成另一个事件,通过使用map中的方法对Observable中发射出来的所有数据进行变换,map可以进行多次变化，例如.map() .map()........

static List studentList = new ArrayList() {
        {
            add(new Student("科比", 24));
            add(new Student("姚明", 11));
        }

    };
    static Map courseMap = new HashMap<>();

    static {
        courseMap.put("科比", new Course("湖人", 1996));
        courseMap.put("姚明", new Course("火箭", 1996));

    }

 //map
    private static void testMap() {
        final List nameList = new ArrayList<>();
        Observable.from(studentList).map(new Func1() {
            @Override
            public String call(Student student) {
                return student.name;
            }
        }).subscribe(new Subscriber() {
            @Override
            public void onCompleted() {
                System.out.println("onCompleted nameList.size() = " + nameList.size());
            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onNext(String value) {
                System.out.println("onSuccess value = " + value);
                nameList.add(value);
            }
        });
    }
运行结果: 得到多个Student对象中的name，保存到nameList中

2.Flatmap

flatMap()究竟是用来干嘛的？简单的说，flatmap把一个Observable变成多个Observable，然后把得到的多个Obervable的元素一个个的发射出去。

flatmap.jpg

在这里引用大神的例子进行理解：
首先假设这么一种需求：假设有一个数据结构『学生』，现在需要打印出一组学生的名字。实现方式很简单：

Student[] students = ...;
Subscriber subscriber = new Subscriber() {
    @Override
    public void onNext(String name) {
        Log.d(tag, name);
    }
    ...
};
Observable.from(students)
    .map(new Func1() {
        @Override
        public String call(Student student) {
            return student.getName();
        }
    })
    .subscribe(subscriber);

那么再假设：如果要打印出每个学生所需要修的所有课程的名称呢？（需求的区别在于，每个学生只有一个名字，但却有多个课程。）首先可以这样实现：

Student[] students = ...;
Subscriber subscriber = new Subscriber() {
    @Override
    public void onNext(Student student) {
        List courses = student.getCourses();
        for (int i = 0; i < courses.size(); i++) {
            Course course = courses.get(i);
            Log.d(tag, course.getName());
        }
    }
    ...
};
Observable.from(students)
    .subscribe(subscriber);

flatmap登场

Student[] students = ...;
Subscriber subscriber = new Subscriber() {
    @Override
    public void onNext(Course course) {
        Log.d(tag, course.getName());
    }
    ...
};
Observable.from(students)
    .flatMap(new Func1>() {
        @Override
        public Observable call(Student student) {
            return Observable.from(student.getCourses());
        }
    })
    .subscribe(subscriber);

    从上面的代码可以看出， flatMap() 和 map() 有一个相同点：它也是把传入的参数转化之后返回另一个对象。但需要注意，和 map() 不同的是， flatMap() 中返回的是个 Observable 对象，并且这个 Observable 对象并不是被直接发送到了 Subscriber 的回调方法中。 flatMap() 的原理是这样的：1. 使用传入的事件对象创建一个 Observable 对象；2. 并不发送这个 Observable, 而是将它激活，于是它开始发送事件；3. 每一个创建出来的 Observable 发送的事件，都被汇入同一个 Observable ，而这个 Observable 负责将这些事件统一交给 Subscriber 的回调方法。

3.ConcatMap操作符
类似于最简单版本的flatMap，但是它按次序连接而不是合并那些生成的Observables，然后产生自己的数据序列。
区别：无序：FlatMap对这些Observables发射的数据做的是合并(merge)操作，因此它们可能是交错的。
有序：ConcatMap不会让变换后的Observables发射的数据交错，它按照严格的顺序发射这些数据。
说明：在同步线程中，FlatMap和ConcactMap的执行结果是一样的（结果是有序的）
只有在异步线程中，FlatMap结果可能是无序的，而ConcactMap始终能保持有序的结果。

 public static void test() {
        List integers = Arrays.asList(2, 3, 4, 5, 6, 7, 8, 9);
        Observable.from(integers).flatMap(new Func1>() {
            @Override
            public Observable call(Integer integer) {
                return Observable.just(integer).subscribeOn(Schedulers.from(Executors.newCachedThreadPool()));
            }
        }).subscribe(new Subscriber() {
            @Override
            public void onCompleted() {

            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onNext(Integer integer) {
                System.out.println("flatMap onSuccess value = " + integer);
            }
        });
        System.out.println("----------------------------");

        Observable.from(integers)
                .concatMap(new Func1>() {
                    @Override
                    public Observable call(Integer integer) {
                        return Observable.just(integer).subscribeOn(Schedulers.from(Executors.newCachedThreadPool()));
                    }
                })
                .subscribe(new Subscriber() {
                    @Override
                    public void onCompleted() {

                    }

                    @Override
                    public void onError(Throwable e) {

                    }

                    @Override
                    public void onNext(Integer integer) {
                        System.out.println("concatMap onNext value = " + integer);
                    }
                });

    }

----------------------------
flatMap onSuccess value = 2
flatMap onSuccess value = 4
flatMap onSuccess value = 6
flatMap onSuccess value = 7
flatMap onSuccess value = 3
flatMap onSuccess value = 9
flatMap onSuccess value = 8
flatMap onSuccess value = 5
以上是乱序的
concatMap onNext value = 2
concatMap onNext value = 3
concatMap onNext value = 4
concatMap onNext value = 5
concatMap onNext value = 6
concatMap onNext value = 7
concatMap onNext value = 8
concatMap onNext value = 9

4.switchMap
解释：将Observable发射的数据集合变换为Observables集合，然后只发射这些Observables最近发射的数据
用法与FlatMap几乎一样，区别是SwitchMap操作符只会发射最近的Observables。当原Observable发射一个新的数据项时，如果旧数据项订阅还未完成，就取消旧订阅数据和停止监视那个数据项产生的Observable,开始监视新的数据项.

 private static void test7() {
        Observable.just("A", "B", "C", "D", "E")
                .switchMap(new Func1>() {
                    @Override
                    public Observable call(String s) {
                        return Observable.just(s + "1").subscribeOn(Schedulers.newThread()); //并发
                        //return Observable.just(s+"1");
                    }
                })
                .subscribe(new Observer() {
                    @Override
                    public void onCompleted() {
                        System.out.println("switchMap onCompleted");
                    }

                    @Override
                    public void onError(Throwable e) {
                        System.out.println("switchMap onError :" + e);
                    }

                    @Override
                    public void onNext(String s) {
                        System.out.println("switchMap Next :" + s);
                    }
                });

        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
逻辑推演：
     * A --> 取消空的，没有可以取消的
     * B-->  A1被取消
     * C-->  B1被取消
     * D-->  C1被取消
     * E-->  D1被取消
     * 最终输出E1
这里说明一点：在同步线程中，switchmap发射所有的Observables
                          在异步中，switchmap发射最近的Observables