RxJava2最全面、最详细的讲解（二）

前言：九牛一毫莫自夸，骄傲自满必翻车，历览古今多少事，成由谦逊败由奢。

一、概述

RxJava2在第一篇文章中基本用法作了详细的介绍，是一个基于事件流的异步操作库。相信大家对RxJava有了一定的理解，由于篇幅过长所以重新写了一篇，如果不了解Rxjava2可以参考下RxJava2最全面、最详细的讲解(一)。下面开始继续讲解RxJava2的其他用法。(源码和其他链接在文章最后给出)

在使用前记得在build.gradle文件中添加依赖：

    implementation 'io.reactivex.rxjava2:rxjava:2.0.4'
    implementation 'io.reactivex.rxjava2:rxandroid:2.0.1'

注意：RxJava1与RxJava2依赖不能共存。不能同时添加RxJava1与RxJava2的依赖，只能添加其中一个。

RxJava的操作符就是java中的用法，详尽的操作符请看官网ReactiveX的官方网站，这里列举了一部分：

Creating Observables(Observable的创建操作符)，比如：Observable.create()、Observable.just()、Observable.from()等等；
Transforming Observables(Observable的转换操作符)，比如：observable.map()、observable.flatMap()、observable.buffer()等等；
Filtering Observables(Observable的过滤操作符)，比如：observable.filter()、observable.sample()、observable.take()等等；
Combining Observables(Observable的组合操作符)，比如：observable.join()、observable.merge()、observable.combineLatest()等等；
Error Handling Operators(Observable的错误处理操作符)，比如:observable.onErrorResumeNext()、observable.retry()等等；
Observable Utility Operators(Observable的功能性操作符)，比如：observable.subscribeOn()、observable.observeOn()、observable.delay()等等；
Conditional and Boolean Operators(Observable的条件操作符)，比如：observable.amb()、observable.contains()、observable.skipUntil()等等；
Mathematical and Aggregate Operators(Observable数学运算及聚合操作符)，比如：observable.count()、observable.reduce()、observable.concat()等等；
其他如observable.toList()、observable.connect()、observable.publish()等等；

二、变换操作符

变换操作符的主要是对事件序列中的事件进行处理变换，使其转变成不同的事件，再加以处理。这里列举几种常用的操作符

1.Map()

map操作符把被观察者Observable产生的结果通过映射规则转换成另一种结果集，并交给订阅者处理。简单来说就是对被观察者发送的每个事件都通过指定函数的处理，从而转变成另一种事件。

//链式编程
Observable.just(1, 2, 3, 4, 5)
           //使用Map操作符中的Function函数对被观察者发送的事件统一作出处理
           .map(new Function() {
        @Override
        public Integer apply(Integer integer) throws Exception {
            //对被观察者just发送的结果，都全部乘以10处理
            return integer * 10;
        }
    }).subscribe(new Consumer() {//订阅
        @Override
        public void accept(Integer integer) throws Exception {//接受事件结果，是处理后的结果
            Log.e(TAG, "map：accept == " + integer);
        }
    });

上面的例子中我们使用just()操作符连续发送1,2,3,4,5等5个事件，通过Map操作符中的Function函数对被观察者发送的事件统一作出乘以10处理，订阅后输出最终结果：

2.flatMap()

flatMap()操作符是将Observable(被观察者)产生的结果拆分和单独转换变成多个Observable，然后把多个Observable“扁平化”整合成新的一个Observable，并依次提交产生的结果给订阅者。

大意为：flatMap()通过传入一个函数作为参数转换源Observable(被观察者)，在这个函数中你可以自定义转换规则，最后在这个函数中返回一个新的Observable，然后flatMap函数回调方法通过合并这些Observable成一个新的Observable，发送给Observer(观察者)。（理论比较抽象，我们来看例子）

 Observable.create(new ObservableOnSubscribe() {
        @Override
        public void subscribe(ObservableEmitter e) {
            e.onNext("A");
            e.onNext("B");
            e.onComplete();
        }
    }).flatMap(new Function>() {
        @Override//通过flatMap将被观察者生产的事件进行拆分，再将新的事件转换成一个新的Observable发送
        public ObservableSource apply(String s) {
            List list = new ArrayList<>();
            Log.e(TAG, "flatMap：apply == 事件" + s);
            //将一个事件拆分成两个子事件，例如将A事件拆分成A0,A1两个事件，然后再整个合成一个Observable通过fromIterable发送给订阅者
            for (int j = 0; j < 2; j++) {
                list.add("拆分后的子事件" + s + j);
            }
            return Observable.fromIterable(list);
        }
    }).subscribe(new Consumer() {
        @Override
        public void accept(String s) {
            Log.e(TAG, "flatMap：accept == " + s);
        }
    });

上面我们发送了A、B两个事件，在flatMap中接收到A事件后，将A事件拆分成A0，A1两个事件，再通过fromIterable(list)整合成一个Observable发送给订阅者。打印log如下：

注意：flatMap在合并Observable结果时，可能存在交叉的情况出现，即新合并生成的序列可能是无序的。（上面的例子我演示多次并没有出现乱序）

3.concatMap()

concatMap()和flatMap()方法类似，都是把Observable(被观察者)产生的事件转换成多个Observable(被观察者)，然后把Observable整合成一个Observable，并依次提交生产的结果给订阅者。

与flatMap()不同的是，concatMap()在处理产生的Observable时，采用的是“连接concat”的方式，而不是“marge合并”的方式，这样就保证了产生事件的顺序性，也就是说提交给订阅者的结果是按照顺序提交的，不会存在交叉的可能性。

Observable.create(new ObservableOnSubscribe() {
        @Override
        public void subscribe(ObservableEmitter e) {
            e.onNext("A");
            e.onNext("B");
            e.onComplete();
        }
    }).concatMap(new Function>() {
        @Override//通过concatMap（有序）将被观察者生产的事件进行拆分，再将新的事件转换成一个新的Observable发送
        public ObservableSource apply(String s) {
            List strings = new ArrayList<>();
            Log.e(TAG, "concatMap：apply == 事件" + s);
            for (int j = 0; j < 2; j++) {
                strings.add("拆分后的子事件" + s + j);
            }
            return Observable.fromIterable(strings);
        }
    }).subscribe(new Consumer() {
        @Override
        public void accept(String s) {
            Log.e(TAG, "concatMap：accept == " + s);
        }
    });

打印的log如下：

4.buffer()

buffer()操作符将Observable(被观察者)需要发送的事件周期性收集到列表中，并把这列表提交给Observer(观察者)，观察者处理后，清空buffer列表，同时接收下一次的结果交给订阅者，周而复始。

需要注意的是：一但初始的Observable在产生事件中出现异常，即使buffer()收集到已经存在的结果，订阅者也会马上收到这个异常，并结束整个过程。

 Observable.just("A", "B", "C", "D", "E")//这里演示发送5个事件
         .buffer(3, 2)//缓存列表数量为3个，步长为2
                .subscribe(new Observer>() {
        @Override
        public void onSubscribe(Disposable d) {
            Log.e(TAG, "buffer：onSubscribe == 订阅");
        }

        @Override
        public void onNext(List strings) {
            Log.e(TAG, "buffer：onNext == 缓存事件数：" + strings.size());
            for (int j = 0; j < strings.size(); j++) {
                Log.e(TAG, "buffer：子事件==" + strings.get(j));
            }
        }

        @Override
        public void onError(Throwable e) {
            Log.e(TAG, "buffer：onError == " + e.getMessage());
        }

        @Override
        public void onComplete() {
            Log.e(TAG, "buffer：onComplete == ");
        }
    });

上述例子设置了"ABCDE"5个事件，缓存事件数为3个，步长为2。在被观察者的事件中，第一次获取3个事件数放到缓存区域，即"A"，"B"，"C"，发送给订阅者；第二次获取时，因为步长=2，所以事件往后移动2个，即指针往后移动2位，从"C"开始取三个事件，即"C"，"D"，"E"发送给订阅者；第三次获取时，事件再在第二次的基础上往后移动2个，即到了"E"，取3个事件，事件不足3个，只能够取"E"发送给订阅者。看图比较好理解，我们来看看buffer()的原理图：

打印结果如下：

这里先对变换操作符做出表格总结：

创建类型		作用	使用场景
变换操作符	map()	对Observable发送的每一个事件进行转换	数据类型、事件等需要转换
	flatMap()	对Observable发送的整个个事件进行转换（无序）
	concatMap()	对Observable发送的整个个事件进行转换（有序）
	buffer()	从Observable的事件中获取事件放到缓存区再发送事件

三、组合操作符

1.concat()与concatArray()

concat()与concatArray()都是组合多个被观察者的一起发送数据，合并后安先后顺序执行。

二者的区别是：concat()的观察者数量最多是4个，而concatArray()的个数没有限制

//concat的构造方法
concat(source1)；
concat(source1, source2)；
concat(source1, source2, source3)；
concat(source1, source2, source3, source4)；

//concatArray的构造方法
concatArray(ObservableSource... sources)；

我们来看看简单的运用：

  Observable.concat(Observable.just(1, 2), Observable.just(3, 4), Observable.just(5, 6), Observable.just(7, 8))
            .subscribe(new Observer() {
        @Override
        public void onSubscribe(Disposable d) {
            Log.e(TAG, "concat：onSubscribe == 订阅");
        }

        @Override
        public void onNext(Integer integer) {
            Log.e(TAG, "concat：onNext ==" + integer);
        }

        @Override
        public void onError(Throwable e) {
            Log.e(TAG, "concat：onError == " + e.getMessage());
        }

        @Override
        public void onComplete() {
            Log.e(TAG, "concat：onComplete == ");
        }
    });

  Observable.concatArray(Observable.just("一", "二"), Observable.just("三", "四"),
                Observable.just("五", "六"), Observable.just("七", "八"), Observable.just("九", "十"))
                .subscribe(new Observer() {
        @Override
        public void onSubscribe(Disposable d) {
            Log.e(TAG, "concatArray：onSubscribe == 订阅");
        }

        @Override
        public void onNext(String s) {
            Log.e(TAG, "concatArray：onNext ==" + s);
        }

        @Override
        public void onError(Throwable e) {
            Log.e(TAG, "concatArray：onError == " + e.getMessage());
        }

        @Override
        public void onComplete() {
            Log.e(TAG, "concatArray：onComplete == ");
        }
    });

上面concat()创建了四个被观察者，发送1,2,3,4,5,6,7,8个事件，concatArray()创建了五个被观察者，发送一,二,三,四,五,六,七,八,九,十，打印log如下：

2.Merge()与MergeArray()

Merge()与MergeArray()组合多个被观察者发送数据，按照时间先后顺序来执行。与concat()与concatArray()组合类似

Merge()与MergeArray()的区别：Merge()只能发送最多4个Observable(被观察者)，MergeArray()的数量没有限制。MergeArray()这里就不演示例子了。

Megre()的构造方法：

merge(source1)；
merge(source1, source2)；
merge(source1, source2,  source3)；
merge(source1, source2,  source3,  source4)；

MergeArray()的构造方法：

mergeArray(ObservableSource... sources)；

    //起始值为1，发送3个事件，第一个事件延迟1秒发送，事件间隔为1秒
    Observable observable1 = Observable.intervalRange(1, 3, 1, 1, TimeUnit.SECONDS);
    //起始值为10，发送3个事件，第一个事件延迟1秒发送，事件间隔为1秒
    Observable observable2 = Observable.intervalRange(10, 3, 1, 1, TimeUnit.SECONDS);

        Observable.merge(observable1, observable2)
            .subscribe(new Observer() {
        @Override
        public void onSubscribe(Disposable d) {
            Log.e(TAG, "concatArray：onSubscribe == 订阅");
        }

        @Override
        public void onNext(Long aLong) {
            Log.e(TAG, "concatArray：onNext ==" + aLong);
        }

        @Override
        public void onError(Throwable e) {
            Log.e(TAG, "concatArray：onError == " + e.getMessage());
        }

        @Override
        public void onComplete() {
            Log.e(TAG, "concatArray：onComplete == ");
        }
    });

这里我们创建了两个被观察者，一个起始值为1，延迟1秒发送3个事件，另一个为起始值为10，延迟1秒发送3个事件，按照Observable提交结果的时间顺序来执行，对Observable进行合并，Observable1每隔1秒产生数据为：1,2,3，Observable2每隔1秒产生的数据为：10,11,12，都延迟1秒产生，最后合并的结果为：1,10,2,11,3,12，MergeArray()同理，打印log如下：

可以看出都是按照时间的先后顺序来执行被观察者发送事件。

3.concatDelayError()

concat()与concatArray()组合中，如果某一个Observable(被观察者)发出onError()事件，则会马上停止其他事件的发送。如果需要onError()事件推迟到其他事件发送完成才出发的话则需要用到concatDelayError()方法；

我们来看看concat()方法中途抛出异常的例子：

   Observable observable1 = Observable.create(new ObservableOnSubscribe() {
        @Override
        public void subscribe(ObservableEmitter e) throws Exception {
            e.onNext("第一个事件");
            e.onNext("第二个事件");
            e.onError(new Exception("中途抛出异常"));
            e.onComplete();
        }
    });
    Observable observable2 = Observable.just("第三个事件");

    //中途抛出异常列子：
    Observable.concat(observable1, observable2).subscribe(new Observer() {
        @Override
        public void onSubscribe(Disposable d) {
            Log.e(TAG, "concatDelayError：onSubscribe == 订阅");
        }

        @Override
        public void onNext(String s) {
            Log.e(TAG, "concatDelayError：onNext ==" + s);
        }

        @Override
        public void onError(Throwable e) {
            Log.e(TAG, "concatDelayError：onError == " + e.getMessage());
        }

        @Override
        public void onComplete() {
            Log.e(TAG, "concatDelayError：onComplete == ");
        }
    });

这里我们依次发送第一个事件，第二个事件，中途抛出异常，调用onComplete()，第三个事件，打印log如下：

可以看到，调用onError()方法以后，其他事件概不执行了，那么我们来看看解决办法，改用concatDelayError()：

    Observable observable1 = Observable.create(new ObservableOnSubscribe() {
        @Override
        public void subscribe(ObservableEmitter e) throws Exception {
            e.onNext("第一个事件");
            e.onNext("第二个事件");
            e.onError(new Exception("中途抛出异常"));
            e.onComplete();
        }
    });
    Observable observable2 = Observable.just("第三个事件");

    //中途抛出异常列子：
    Observable.concatArrayDelayError(observable1, observable2).subscribe(new Observer() {
        @Override
        public void onSubscribe(Disposable d) {
            Log.e(TAG, "concatDelayError：onSubscribe == 订阅");
        }

        @Override
        public void onNext(String s) {
            Log.e(TAG, "concatDelayError：onNext ==" + s);
        }

        @Override
        public void onError(Throwable e) {
            Log.e(TAG, "concatDelayError：onError == " + e.getMessage());
        }

        @Override
        public void onComplete() {
            Log.e(TAG, "concatDelayError：onComplete == ");
        }
    });

会把错误在所有结果合并完后才执行，打印的数据如下：

4.megreDelayError()

megreDelayError()方法同上，meger()合并的某个Observable(被观察者)出现异常，会马上停止合并，并对订阅者回到onError()方法，而megreDelayError()会把错误在所有结果合并完后才执行：

   //创建被观察者-异常
    Observable