RxJava2基础总结（二）

操作符

rxjava之所以强大原因就在这里了，操作符可对原始发射器发出的数据进行多种变换继而重新发送。

Map
它的作用是对发射时间发送的每一个事件应用一个函数，每一个事件都按照指定的函数去变化
这里写图片描述

Observable.create(new ObservableOnSubscribe<String>() {

            @Override
            public void subscribe(ObservableEmitter<String> emitter) throws Exception {
                emitter.onNext(1 + "");
                emitter.onNext(2 + "");
                emitter.onNext(3 + "");

            }
        }).map(new Function<String, Integer>() {

            @Override
            public Integer apply(String s) throws Exception {
                return new Integer(s) + 1;
            }
        }).subscribe(new Consumer<Integer>() {
            @Override
            public void accept(Integer integer) throws Exception {
                Logger.e(integer + "");
            }
        });

发送字符串1，2，3 通过map操作符转换成Integer类型值分别为2，3，4最后发射

│    2
E: └────────────────────────────────────────────────────────────────────────────────────────────────────────────────
E: ┌────────────────────────────────────────────────────────────────────────────────────────────────────────────────
E: ├┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄
E: 
E: ├┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄
E: │ 3
E: └────────────────────────────────────────────────────────────────────────────────────────────────────────────────
E: ┌────────────────────────────────────────────────────────────────────────────────────────────────────────────────
E: ├┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄
E: ├┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄
E: │ 4
E:

Zip
一一对应合并两种发射器的数据，当然合并后的数据类型是由我们自定义的。如果两种发射器数据量不同，那么多的数据就会被丢弃。

    Observable.zip(Observable.create(new ObservableOnSubscribe<Integer>() {

            @Override
            public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {

                emitter.onNext(1);
                emitter.onNext(2);
                emitter.onNext(3);

            }
        }), Observable.just(2, 3), new BiFunction<Integer, Integer, Integer>() {

            @Override
            public Integer apply(Integer integer, Integer integer2) throws Exception {
                return integer + integer2;
            }
        }).subscribe(new Consumer<Integer>() {
            @Override
            public void accept(Integer integer) throws Exception {
                Logger.e(integer + "");
            }
        });

前者发送了 1，2，3 后者只发送了2，3，那么合并后第一组数据的3会被丢弃。

├┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄
E: │ 3
E: └────────────────────────────────────────────────────────────────────────────────────────────────────────────────
E: ┌────────────────────────────────────────────────────────────────────────────────────────────────────────────────
E: │ Thread: main
E: ├┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄
E: │ MainActivity$1.accept  (MainActivity.java:70)
E: │    MainActivity$1.accept  (MainActivity.java:73)
E: ├┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄
E: │ 5
E: └────────────────────────────────────────────────────────────────────────────────────────────────────────────────

Concat

concat 操作符将两种发射器数据进行连接
这里写图片描述

   Observable.concat(Observable.just(1, 2, 3, 4), Observable.create(new ObservableOnSubscribe<Object>() {

            /**
             * Called for each Observer that subscribes.
             *
             * @param emitter the safe emitter instance, never null
             * @throws Exception on error
             */
            @Override
            public void subscribe(ObservableEmitter<Object> emitter) throws Exception {

                emitter.onNext(5);
                emitter.onNext(6);
                emitter.onNext(7);

            }

        })).subscribe(new Consumer<Object>() {

            /**
             * Consume the given value.
             *
             * @param o the value
             * @throws Exception on error
             */
            @Override
            public void accept(Object o) throws Exception {
                Logger.e(o.toString());
            }
        });

前者发送了1，2，3，4，后者为5，6，7。那么最后的结果是两者拼接起来且顺序相同。

E: │ 1
E: └────────────────────────────────────────────────────────────────────────────────────────────────────────────────
E: ┌────────────────────────────────────────────────────────────────────────────────────────────────────────────────
E: │ Thread: main
E: ├┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄
E: │ LambdaObserver.onNext  (LambdaObserver.java:63)
E: │    MainActivity$1.accept  (MainActivity.java:78)
E: ├┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄
E: │ 2
E: └────────────────────────────────────────────────────────────────────────────────────────────────────────────────
E: ┌────────────────────────────────────────────────────────────────────────────────────────────────────────────────
E: │ Thread: main
E: ├┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄
E: │ LambdaObserver.onNext  (LambdaObserver.java:63)
E: │    MainActivity$1.accept  (MainActivity.java:78)
E: ├┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄
E: │ 3
E: └────────────────────────────────────────────────────────────────────────────────────────────────────────────────
E: ┌────────────────────────────────────────────────────────────────────────────────────────────────────────────────
E: │ Thread: main
E: ├┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄
E: │ LambdaObserver.onNext  (LambdaObserver.java:63)
E: │    MainActivity$1.accept  (MainActivity.java:78)
E: ├┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄
E: │ 4
E: └────────────────────────────────────────────────────────────────────────────────────────────────────────────────
E: ┌────────────────────────────────────────────────────────────────────────────────────────────────────────────────
E: │ Thread: main
E: ├┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄
E: │ LambdaObserver.onNext  (LambdaObserver.java:63)
E: │    MainActivity$1.accept  (MainActivity.java:78)
E: ├┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄
E: │ 5
E: └────────────────────────────────────────────────────────────────────────────────────────────────────────────────
E: ┌────────────────────────────────────────────────────────────────────────────────────────────────────────────────
E: │ Thread: main
E: ├┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄
E: │ LambdaObserver.onNext  (LambdaObserver.java:63)
E: │    MainActivity$1.accept  (MainActivity.java:78)
E: ├┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄
E: │ 6
E: └────────────────────────────────────────────────────────────────────────────────────────────────────────────────
E: ┌────────────────────────────────────────────────────────────────────────────────────────────────────────────────
E: │ Thread: main
E: ├┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄
E: │ LambdaObserver.onNext  (LambdaObserver.java:63)
E: │    MainActivity$1.accept  (MainActivity.java:78)
E: ├┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄
E: │ 7
E:

这里要注意的是，如果要使用creat来创造默认发射器，那么必须要将其后置，否则第二个发射器数据不能正常发射。

FlatMap
分流发射器，就是将当前发射器发出每一组数据进行扩展。扩展成一个发射器(包含多组数据)，再将这些发射器的数据组合起来，组合后的数据并不能一定保证原始数据的顺序。


        Observable.just(1, 2).flatMap(new Function<Integer, ObservableSource<?>>() {
            @Override
            public ObservableSource<?> apply(Integer integer) throws Exception {
                if (integer == 1) {

                    List<Integer> list = new ArrayList<>();
                    for (int i = 0; i < 3; i++) {
                        list.add(integer);
                    }
                    return Observable.fromIterable(list).delay(5000, TimeUnit.MILLISECONDS);

                } else {

                    List<Integer> list = new ArrayList<>();

                    for (int i = 0; i < 3; i++) {
                        list.add(integer);
                    }
                    return Observable.fromIterable(list).delay(5000, TimeUnit.MILLISECONDS);
                }

            }
        }).subscribe(new Consumer<Object>() {

            /**
             * Consume the given value.
             *
             * @param o the value
             * @throws Exception on error
             */
            @Override
            public void accept(Object o) throws Exception {
                Logger.e(o.toString());
            }
        });

笔者将两组发射器都延迟5000毫秒后执行，如果是有序，那么按照顺序依次延迟后，前者的发射器也是应该先发出，那就是111，222.

├┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄
E: │ 1
E: └────────────────────────────────────────────────────────────────────────────────────────────────────────────────
E: ┌────────────────────────────────────────────────────────────────────────────────────────────────────────────────
E: │ Thread: RxComputationThreadPool-1
E: ├┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄
E: │ LambdaObserver.onNext  (LambdaObserver.java:63)
E: │    MainActivity$1.accept  (MainActivity.java:87)
E: ├┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄
E: │ 2
E: └────────────────────────────────────────────────────────────────────────────────────────────────────────────────
E: ┌────────────────────────────────────────────────────────────────────────────────────────────────────────────────
E: │ Thread: RxComputationThreadPool-1
E: ├┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄
E: │ LambdaObserver.onNext  (LambdaObserver.java:63)
E: │    MainActivity$1.accept  (MainActivity.java:87)
E: ├┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄
E: │ 2
E: └────────────────────────────────────────────────────────────────────────────────────────────────────────────────
E: ┌────────────────────────────────────────────────────────────────────────────────────────────────────────────────
E: │ Thread: RxComputationThreadPool-1
E: ├┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄
E: │ LambdaObserver.onNext  (LambdaObserver.java:63)
E: │    MainActivity$1.accept  (MainActivity.java:87)
E: ├┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄
E: │ 2
E: └────────────────────────────────────────────────────────────────────────────────────────────────────────────────
E: ┌────────────────────────────────────────────────────────────────────────────────────────────────────────────────
E: │ Thread: RxComputationThreadPool-1
E: ├┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄
E: │ LambdaObserver.onNext  (LambdaObserver.java:63)
E: │    MainActivity$1.accept  (MainActivity.java:87)
E: ├┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄
E: │ 1
E: └────────────────────────────────────────────────────────────────────────────────────────────────────────────────
E: ┌────────────────────────────────────────────────────────────────────────────────────────────────────────────────
E: │ Thread: RxComputationThreadPool-1
E: ├┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄
E: │ LambdaObserver.onNext  (LambdaObserver.java:63)
E: │    MainActivity$1.accept  (MainActivity.java:87)
E: ├┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄
E: │ 1
E: └────────────────────────────────────────────────────────────────────────────────────────────────────────────────

然而并不是这样，结果则是两组发射器同时发出，所以说flatMap没有控制数据的发送顺序，而是由新生成的Observable本身决定。

ConcatMap

concatMap就是与之对应的保证了顺序的分流发射器，

Observable.just(1, 2).concatMap(new Function<Integer, ObservableSource<?>>() {
            @Override
            public ObservableSource<?> apply(Integer integer) throws Exception {
                if (integer == 1) {

                    List<Integer> list = new ArrayList<>();
                    for (int i = 0; i < 3; i++) {
                        list.add(integer);
                    }
                    return Observable.fromIterable(list).delay(10000, TimeUnit.MILLISECONDS);

                } else {

                    List<Integer> list = new ArrayList<>();

                    for (int i = 0; i < 3; i++) {
                        list.add(integer);
                    }
                    return Observable.fromIterable(list).delay(5000, TimeUnit.MILLISECONDS);
                }

            }
        }).subscribe(new Consumer<Object>() {

            /**
             * Consume the given value.
             *
             * @param o the value
             * @throws Exception on error
             */
            @Override
            public void accept(Object o) throws Exception {

                Logger.e(String.valueOf(System.currentTimeMillis()));

                Logger.e(o.toString());

            }
        });

笔者将第一组发射器延迟10秒，第二组延迟5秒，如果ConcatMap不能保证顺序的话，那么首先执行的一定是第二组。

├┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄
E: │ 1533124963245
E: └────────────────────────────────────────────────────────────────────────────────────────────────────────────────
E: ┌────────────────────────────────────────────────────────────────────────────────────────────────────────────────
E: │ Thread: RxComputationThreadPool-1
E: ├┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄
E: │ LambdaObserver.onNext  (LambdaObserver.java:63)
E: │    MainActivity$1.accept  (MainActivity.java:88)
E: ├┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄
E: │ 1
E: └────────────────────────────────────────────────────────────────────────────────────────────────────────────────
E: ┌────────────────────────────────────────────────────────────────────────────────────────────────────────────────
E: │ Thread: RxComputationThreadPool-1
E: ├┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄
E: │ LambdaObserver.onNext  (LambdaObserver.java:63)
E: │    MainActivity$1.accept  (MainActivity.java:87)
E: ├┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄
E: │ 1533124963249
E: └────────────────────────────────────────────────────────────────────────────────────────────────────────────────
E: ┌────────────────────────────────────────────────────────────────────────────────────────────────────────────────
E: │ Thread: RxComputationThreadPool-1
E: ├┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄
E: │ LambdaObserver.onNext  (LambdaObserver.java:63)
E: │    MainActivity$1.accept  (MainActivity.java:88)
E: ├┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄
E: │ 1
E: └────────────────────────────────────────────────────────────────────────────────────────────────────────────────
E: ┌────────────────────────────────────────────────────────────────────────────────────────────────────────────────
E: │ Thread: RxComputationThreadPool-1
E: ├┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄
E: │ LambdaObserver.onNext  (LambdaObserver.java:63)
E: │    MainActivity$1.accept  (MainActivity.java:87)
E: ├┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄
E: │ 1533124963251
E: └────────────────────────────────────────────────────────────────────────────────────────────────────────────────
E: ┌────────────────────────────────────────────────────────────────────────────────────────────────────────────────
E: │ Thread: RxComputationThreadPool-1
E: ├┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄
E: │ LambdaObserver.onNext  (LambdaObserver.java:63)
E: │    MainActivity$1.accept  (MainActivity.java:88)
E: ├┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄
E: │ 1
E: └────────────────────────────────────────────────────────────────────────────────────────────────────────────────
E: ┌────────────────────────────────────────────────────────────────────────────────────────────────────────────────
E: │ Thread: RxComputationThreadPool-2
E: ├┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄
E: │ LambdaObserver.onNext  (LambdaObserver.java:63)
E: │    MainActivity$1.accept  (MainActivity.java:87)
E: ├┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄
E: │ 1533124968254
E: └────────────────────────────────────────────────────────────────────────────────────────────────────────────────
E: ┌────────────────────────────────────────────────────────────────────────────────────────────────────────────────
E: │ Thread: RxComputationThreadPool-2
E: ├┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄
E: │ LambdaObserver.onNext  (LambdaObserver.java:63)
E: │    MainActivity$1.accept  (MainActivity.java:88)
E: ├┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄
E: │ 2
E: └────────────────────────────────────────────────────────────────────────────────────────────────────────────────
E: ┌────────────────────────────────────────────────────────────────────────────────────────────────────────────────
E: │ Thread: RxComputationThreadPool-2
E: ├┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄
E: │ LambdaObserver.onNext  (LambdaObserver.java:63)
E: │    MainActivity$1.accept  (MainActivity.java:87)
E: ├┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄
E: │ 1533124968257
E: └────────────────────────────────────────────────────────────────────────────────────────────────────────────────
E: ┌────────────────────────────────────────────────────────────────────────────────────────────────────────────────
E: │ Thread: RxComputationThreadPool-2
E: ├┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄
E: │ LambdaObserver.onNext  (LambdaObserver.java:63)
E: │    MainActivity$1.accept  (MainActivity.java:88)
E: ├┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄
E: │ 2
E: └────────────────────────────────────────────────────────────────────────────────────────────────────────────────
E: ┌────────────────────────────────────────────────────────────────────────────────────────────────────────────────
E: │ Thread: RxComputationThreadPool-2
E: ├┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄
E: │ LambdaObserver.onNext  (LambdaObserver.java:63)
E: │    MainActivity$1.accept  (MainActivity.java:87)
E: ├┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄
E: │ 1533124968259
E: └────────────────────────────────────────────────────────────────────────────────────────────────────────────────
E: ┌────────────────────────────────────────────────────────────────────────────────────────────────────────────────
E: │ Thread: RxComputationThreadPool-2
E: ├┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄
E: │ LambdaObserver.onNext  (LambdaObserver.java:63)
E: │    MainActivity$1.accept  (MainActivity.java:88)
E: ├┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄
E: │ 2
E: └────────────────────────────────────────────────────────────────────────────────────────────────────────────────

然而仍是先执行第一组，然后再是第二组，观察时间差值，正是第二组的延迟时间，所以他的机制应该就是保证第一组数据发射完毕才会开始处理第二组数据然后执行发射。而flatMap则是先处理完所有原始数据再根据生成的Observable本身情况去发送。其实给apply方法里打个Log很容易就看出来区别。

。。。。。。。后续

RxJava2基础总结（二）

操作符

猜你喜欢