川峰

RxJava操作符

文章目录

RxJava创建型操作符

create()操作符
just()操作符
fromArray()操作符
fromIterable()操作符
differ()操作符
timer()操作符
interval()操作符
intervalRange()操作符
range()操作符
rangeLong()操作符
其他

RxJava变换操作符

map()操作符
flatMap()操作符
concatMap()操作符
buffer()操作符

RxJava组合/合并操作符

concat()操作符
concatArray()操作符
merge()操作符
mergeArray()操作符
concatDelayError()操作符
mergeDelayError()操作符
zip()操作符
combineLatest()操作符
combineLatestDelayError()操作符
reduce()操作符
collect()操作符
startWith()操作符
count()操作符

RxJava功能型操作符

subscribe()操作符
subscribeOn() & observeOn()操作符
delay()操作符
do操作符
onErrorReturn()操作符
onErrorResumeNext()
onExceptionResumeNext()操作符
retry()操作符
retryUntil()操作符
retryWhen()操作符
repeat()操作符
repeatWhen()操作符
debounce()操作符

RxJava过滤操作符

filter()操作符
ofType()操作符
skip() / skipLast()操作符
distinct() / distinctUntilChanged()操作符
take() & takeLast()操作符
throttleFirst() / throttleLast()操作符
sample()操作符
throttleWithTimeout()操作符
firstElement() / lastElement()操作符
elementAt()操作符
elementAtOrError()操作符
ignoreElements() 操作符

RxJava条件/布尔操作符

all()操作符
takeWhile()操作符
skipWhile()操作符
takeUntil()操作符
skipUntil()操作符
sequenceEqual()操作符
contains()操作符
isEmpty()操作符
amb()操作符
defaultIfEmpty()操作符

RxJava添加依赖：

dependencies {
    implementation 'io.reactivex.rxjava2:rxandroid:2.1.1'
    implementation "io.reactivex.rxjava2:rxjava:2.2.8"
}

其中rxandroid是在android系统上针对对rxjava做的扩展，如果你是android开发，那么可以使用rxandroid即可。但是rxandroid官方说最好也同时依赖rxjava的最新版本，以便修复未知bug和使用最新的特性。

RxJava创建型操作符

create()操作符

作用：完整创建1个被观察者对象（Observable）
示例代码：

	  //通过Observable.create() 创建一个被观察者 Observable 对象
      Observable.create(new ObservableOnSubscribe<Integer>() {
            /** 在subscribe（）里定义需要发送的事件 */
            @Override
            public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
                // 通过 ObservableEmitter类对象产生 & 发送事件
                // ObservableEmitter类负责定义事件发射器 & 向观察者发送事件
                emitter.onNext(1);
                emitter.onNext(2);
                emitter.onNext(3);
                emitter.onComplete();
            }
        }).subscribe(new Observer<Integer>() {//订阅一个观察者对象

 			// 默认最先调用复写的 onSubscribe（）
           @Override
           public void onSubscribe(Disposable d) {
               Log.d(TAG, "开始采用subscribe连接");
           }
          

           @Override
           public void onNext(Integer value) {
               Log.d(TAG, "接收到了事件"+ value  );
           }

           @Override
           public void onError(Throwable e) {
               Log.d(TAG, "对Error事件作出响应");
           }

           @Override
           public void onComplete() {
               Log.d(TAG, "对Complete事件作出响应");
           }

       });

输出：

从第一个例子分析RxJava的调用机制：

既然说RxJava是基于观察者模式的，那我们就从第一个例子开刀来分析一下它是如何实现观察者模式的。

首先， Observable.create() 在创建一个被观察者 Observable 对象时，传入参数是一个ObservableOnSubscribe接口的实现，而这个方法返回的实际是一个ObservableCreate类的对象：

create()传入的接口被这个ObservableCreate对象持有，当 Observable 对象被订阅时，Observable.subscribe()方法内部会调用它自己的subscribeActual()方法：

这个方法其实是Observable类的一个抽象方法：

它的实现有很多类，而ObservableCreate就是它的实现类之一，在ObservableCreate类的subscribeActual()方法中则会调用ObservableOnSubscribe接口的subscribe()方法：

这个source就是 Observable.create() 在创建被观察者对象时传入的接口实现对象，而调用subscribe()方法时传入的参数parent，在内部的实现类实际是CreateEmitter(ObservableCreate类的静态内部类)，在CreateEmitter创建时持有了Observer对象：

在CreateEmitter类的onNext、onError、onComplete方法中分别调用了它持有的Observer对象的onNext、onError、onComplete方法：

这样就会触发观察者依次调用对应事件的onNext实现方法从而响应事件，即事件序列会依照设定依次被触发，从而完成了被观察者向观察者发送事件的过程。（被观察者调用了观察者的回调方法，即观察者模式）

好了，第一个创建操作符的过程搞清楚了，其他创建型的操作符基本大同小异了。

just()操作符

作用：快速创建1个被观察者对象，直接发送传入的事件
只能发送10个以下的事件
示例代码：

public void just() {
        // 1. 创建时传入整型1、2、3、4, 快速创建被观察者对象（Observable）最多只能发送10个以下事件
        // 在创建后就会发送这些对象，相当于执行了onNext(1)、onNext(2)、onNext(3)、onNext(4)
        Observable.just(1, 2, 3, 4).subscribe(new Observer<Integer>() {

            @Override
            public void onSubscribe(Disposable d) {
                Log.d(TAG, "开始采用subscribe连接");
            }
            // 默认最先调用复写的 onSubscribe（）

            @Override
            public void onNext(Integer value) {
                Log.d(TAG, "接收到了事件" + value);
            }

            @Override
            public void onError(Throwable e) {
                Log.d(TAG, "对Error事件作出响应");
            }

            @Override
            public void onComplete() {
                Log.d(TAG, "对Complete事件作出响应");
            }

        });
    }

输出：

fromArray()操作符

作用：快速创建1个被观察者对象，直接发送传入的数组数据，可以发送10个以上事件，可用于数组遍历
示例代码：

    public void fromArray() {
        // 1. 设置需要传入的数组, 快速创建被观察者对象（Observable） & 可发送10个以上事件（数组形式）
        // 可用于对数组进行遍历
        // 注：若直接传递一个list集合进去，否则会直接把list当做一个数据元素发送
        Integer[] items = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
        Observable.fromArray(items).subscribe(new Observer<Integer>() {
            @Override
            public void onSubscribe(Disposable d) {
                Log.d(TAG, "开始采用subscribe连接");
            }

            @Override
            public void onNext(Integer value) {
                Log.d(TAG, "接收到了事件" + value);
            }

            @Override
            public void onError(Throwable e) {
                Log.d(TAG, "对Error事件作出响应");
            }

            @Override
            public void onComplete() {
                Log.d(TAG, "对Complete事件作出响应");
            }
        });
    }

输出：

fromIterable()操作符

作用：快速创建1个被观察者对象，直接发送传入的集合List数据，可发送10个以上事件，可用于集合元素遍历
示例代码：

   public void fromIterable() {
        // 1. 设置一个集合
        List<Integer> list = new ArrayList<>();
        for (int i = 0; i < 20; i++) {
            list.add(i+1);
        }
        // 2. 通过fromIterable()将集合中的对象 / 数据发送出去
        Observable.fromIterable(list)
                .subscribe(new Observer<Integer>() {
                    @Override
                    public void onSubscribe(Disposable d) {
                        Log.d(TAG, "开始采用subscribe连接");
                    }

                    @Override
                    public void onNext(Integer value) {
                        Log.d(TAG, "接收到了事件"+ value  );
                    }

                    @Override
                    public void onError(Throwable e) {
                        Log.d(TAG, "对Error事件作出响应");
                    }

                    @Override
                    public void onComplete() {
                        Log.d(TAG, "对Complete事件作出响应");
                    }
                });
    }

输出：

differ()操作符

作用：动态创建（或延迟创建）被观察者对象，直到有观察者（Observer ）订阅时，才动态创建被观察者对象（Observable） & 发送事件。

通过 Observable工厂方法创建被观察者对象（Observable），每次订阅后，都会得到一个刚创建的最新的Observable对象，这可以确保Observable对象里的数据是最新的。

示例代码：

    public void differ() {
        // 通过defer 定义被观察者对象 注：此时被观察者对象还没创建
        Observable<Long> observable = Observable.defer(new Callable<ObservableSource<? extends Long>>() {
            @Override
            public ObservableSource<? extends Long> call() throws Exception {
                Log.d(TAG, "Observable创建的时间戳: "+System.currentTimeMillis());
                return Observable.just(System.currentTimeMillis());
            }
        });

        Log.d(TAG, "observable.subscribe的时间戳: "+System.currentTimeMillis());
        //观察者开始订阅 注：此时，才会调用defer() 创建被观察者对象(Observable)
        observable.subscribe(new Observer<Long>() {

            @Override
            public void onSubscribe(Disposable d) {
                Log.d(TAG, "开始采用subscribe连接");
            }

            @Override
            public void onNext(Long value) {
                Log.d(TAG, "接收到的时间戳是" + value);
            }

            @Override
            public void onError(Throwable e) {
                Log.d(TAG, "对Error事件作出响应");
            }

            @Override
            public void onComplete() {
                Log.d(TAG, "对Complete事件作出响应");
            }
        });
    }

输出：

可见，observable的创建时间是在observable.subscribe之后。

timer()操作符

作用：快速创建1个被观察者对象, 延时指定时间发送一个事件（发送1个Long型的数值0）
示例代码：

    public void timer() {
        //延时2s发送一个事件, 会发送一个long类型数值0，等同于延时2s后调用一次onNext(0)触发事件
        Observable.timer(2, TimeUnit.SECONDS)
                .subscribe(new Observer<Long>() {
                    @Override
                    public void onSubscribe(Disposable d) {
                        Log.d(TAG, "开始采用subscribe连接");
                    }

                    @Override
                    public void onNext(Long value) {
                        Log.d(TAG, "接收到了事件" + value);
                    }

                    @Override
                    public void onError(Throwable e) {
                        Log.d(TAG, "对Error事件作出响应");
                    }

                    @Override
                    public void onComplete() {
                        Log.d(TAG, "对Complete事件作出响应");
                    }
                });
    }

输出：

interval()操作符

作用：快速创建1个被观察者对象，每隔指定时间发送1个事件（从0开始无限递增1的整数序列）
示例代码：

   public void interval() {
        // 延迟3s后，每隔1秒发送1个事件, 产生1个数字（从0开始递增1，无限个）
        Observable.interval(3, 1, TimeUnit.SECONDS)
        		//.interval(300, TimeUnit.MILLISECONDS) //每个0.3秒发送一个事件
                .subscribe(new Observer<Long>() {
                    @Override
                    public void onSubscribe(Disposable d) {
                        Log.d(TAG, "开始采用subscribe连接");
                    }

                    @Override
                    public void onNext(Long value) {
                        Log.d(TAG, "接收到了事件"+ value);
                    }

                    @Override
                    public void onError(Throwable e) {
                        Log.d(TAG, "对Error事件作出响应");
                    }

                    @Override
                    public void onComplete() {
                        Log.d(TAG, "对Complete事件作出响应");
                    }

                });
    }

输出：

intervalRange()操作符

作用：快速创建1个被观察者对象，每隔指定时间发送1个事件，可指定发送数据的起始值和数量
示例代码：

   public void intervalRange() {
        //延时3s后，每隔2s发送一个事件，事件序列：从5开始递增，总共发送10个事件
        //前四个参数含义为：long start, long count, long initialDelay, long period
        Observable.intervalRange(5, 10, 3, 2, TimeUnit.SECONDS)
                .subscribe(new Observer<Long>() {
                    @Override
                    public void onSubscribe(Disposable d) {
                        Log.d(TAG, "开始采用subscribe连接");
                    }

                    @Override
                    public void onNext(Long value) {
                        Log.d(TAG, "接收到了事件"+ value);
                    }

                    @Override
                    public void onError(Throwable e) {
                        Log.d(TAG, "对Error事件作出响应");
                    }

                    @Override
                    public void onComplete() {
                        Log.d(TAG, "对Complete事件作出响应");
                    }
                });
    }

输出：

range()操作符

作用：快速创建1个被观察者对象, 连续发送 1个指定范围的事件序列（无延时）
示例代码：

    public void range() {
        // 从2开始发送10个事件, 每次发送的事件递增1
        // final int start, final int count
        // 注意：参数是int型的，count必须大于0，且满足start + (count - 1) <= Integer.MAX_VALUE
        Observable.range(2, 10)
                .subscribe(new Observer<Integer>() {
                    @Override
                    public void onSubscribe(Disposable d) {
                        Log.d(TAG, "开始采用subscribe连接");
                    }

                    @Override
                    public void onNext(Integer value) {
                        Log.d(TAG, "接收到了事件" + value);
                    }

                    @Override
                    public void onError(Throwable e) {
                        Log.d(TAG, "对Error事件作出响应");
                    }

                    @Override
                    public void onComplete() {
                        Log.d(TAG, "对Complete事件作出响应");
                    }

                });
    }

输出：

rangeLong()操作符

作用：快速创建1个被观察者对象, 连续发送 1个指定范围的事件序列（无延时）
与range操作符的不同是：range发送的是int型数据，rangeLong()发送的是long型的数据
示例代码：

   public void rangeLong() {
        // 从2开始发送10个事件, 每次发送的事件递增1
        // long start, long count
        // 注意：参数是long型的，count必须大于0，且满足start + (count - 1) <= Long.MAX_VALUE
        Observable.rangeLong(2, 10)
                .subscribe(new Observer<Long>() {
                    @Override
                    public void onSubscribe(Disposable d) {
                        Log.d(TAG, "开始采用subscribe连接");
                    }

                    @Override
                    public void onNext(Long value) {
                        Log.d(TAG, "接收到了事件" + value);
                    }

                    @Override
                    public void onError(Throwable e) {
                        Log.d(TAG, "对Error事件作出响应");
                    }

                    @Override
                    public void onComplete() {
                        Log.d(TAG, "对Complete事件作出响应");
                    }

                });
    }

输出：

其他

下列方法一般用于测试使用

    public void other() {
        // 该方法创建的被观察者对象发送事件的特点：仅发送Complete事件，直接通知完成,
        // 即观察者接收后会直接调用onCompleted（）不会调用onNext
        Observable observable1 = Observable.empty();
        observable1.subscribe(observer);

        // 该方法创建的被观察者对象发送事件的特点：仅发送Error事件，直接通知异常,
        // 即观察者接收后会直接调用onError（）
        Observable observable2 = Observable.error(new RuntimeException());
        observable2.subscribe(observer);

        // 该方法创建的被观察者对象发送事件的特点：不发送任何事件, 即观察者接收后不会调用onComplete onNext
        Observable observable3 = Observable.never();
        observable3.subscribe(observer);
    }

RxJava变换操作符

map()操作符

作用：对被观察者发送的每1个事件都通过指定的函数处理，从而变换成另外一种事件, 可用于数据类型转换
示例代码：

    public void map() {
        Observable.create(new ObservableOnSubscribe<Integer>() {

            @Override
            public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
                // 被观察者发送事件, 参数为整型1、2、3
                emitter.onNext(1);
                emitter.onNext(2);
                emitter.onNext(3);
            }
            //使用Map变换操作符中的Function函数对被观察者发送的事件进行统一变换：整型变换成字符串类型
        }).map(new Function<Integer, String>() {
            @Override
            public String apply(Integer integer) throws Exception {
                return "使用 Map变换操作符 将事件" + integer + "的参数从 整型" + integer + " 变换成 字符串类型" + integer;
            }
        }).subscribe(new Consumer<String>() {

            //观察者接收到是变换后的事件: 字符串类型
            @Override
            public void accept(String s) throws Exception {
                Log.d(TAG, s);
            }
        });
    }

输出：

flatMap()操作符

作用：将被观察者发送的事件序列进行拆分 & 单独转换，再合并成一个新的事件序列，最后再进行发送.
将Observable每一次发射的事件都转换成一个新的Observable，最好将这些Observable合并成一个新的Observable发送给观察者，但不能保证观察者是按照原始序列的顺序收到事件的。
无序的将被观察者发送的整个事件序列进行变换。
示例代码：

    public void flatMap() {
        Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
                emitter.onNext(1);
                emitter.onNext(2);
                emitter.onNext(3);
            }
            // 采用flatMap（）变换操作符
        }).flatMap(new Function<Integer, ObservableSource<String>>() {
            @Override
            public ObservableSource<String> apply(Integer integer) throws Exception {
                // 通过flatMap中将被观察者生产的事件序列先进行拆分，
                // 将每个事件转换为一个新的发送三个String的事件，最终合并，再发送给被观察者
                final List<String> list = new ArrayList<>();
                for (int i = 0; i < 3; i++) {
                    list.add("我是事件 " + integer + "拆分后的子事件" + i);
                }
                return Observable.fromIterable(list);
            }
        }).subscribe(new Consumer<String>() {
            @Override
            public void accept(String s) throws Exception {
                Log.d(TAG, s);
            }
        });
    }

输出：

map操作符的详细介绍和实例可以看这篇：https://www.jianshu.com/p/128e662906af

concatMap()操作符

作用：类似于flatMap()，但是保证观察者收到的事件顺序是严格按照原始事件序列发送的顺序。
有序的将被观察者发送的整个事件序列进行变换
示例代码：

    public void concatMap() {
        Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
                emitter.onNext(1);
                emitter.onNext(2);
                emitter.onNext(3);
            }
            //采用concatMap（）变换操作符
        }).concatMap(new Function<Integer, ObservableSource<String>>() {
            @Override
            public ObservableSource<String> apply(Integer integer) throws Exception {
                // 通过concatMap中将被观察者生产的事件序列先进行拆分，
                // 将每个事件转换为一个新的发送三个String的事件，最终合并，再发送给被观察者
                final List<String> list = new ArrayList<>();
                for (int i = 0; i < 3; i++) {
                    list.add("我是事件 " + integer + "拆分后的子事件" + i);
                }
                return Observable.fromIterable(list);
            }
        }).subscribe(new Consumer<String>() {
            @Override
            public void accept(String s) throws Exception {
                Log.d(TAG, s);
            }
        });
    }

buffer()操作符

作用：每次从被观察者（Obervable）需要发送的事件中获取一定数量的事件进行发送。

示例代码：

    public void buffer() {
    	//每次从1, 2, 3, 4, 5发送3个数据，每次发送往后移动一个数量的位置
        Observable.just(1, 2, 3, 4, 5)
                .buffer(3, 1) // 设置缓存区大小 & 步长,
                // 缓存区大小: 每次从被观察者中获取的事件数量
                // 步长: 每次需要发送新事件时需要往后移动的位置
                .subscribe(new Observer<List<Integer>>() {
                    @Override
                    public void onSubscribe(Disposable d) {
                    }

                    @Override
                    public void onNext(List<Integer> stringList) {
                        Log.d(TAG, " 缓存区里的事件数量 = " + stringList.size());
                        for (Integer value : stringList) {
                            Log.d(TAG, " 事件 = " + value);
                        }
                    }

                    @Override
                    public void onError(Throwable e) {
                        Log.d(TAG, "对Error事件作出响应");
                    }

                    @Override
                    public void onComplete() {
                        Log.d(TAG, "对Complete事件作出响应");
                    }
                });
    }

输出：

RxJava组合/合并操作符

concat()操作符

作用：组合多个被观察者一起发送数据，合并后按发送顺序串行执行
示例代码：

    public void concat() {
        // concat（）：组合多个被观察者（≤4个）一起发送数据
        // 注：串行执行
        Observable.concat(Observable.just(1, 2),
                Observable.just(3, 4),
                Observable.just(5, 6),
                Observable.just(7, 8))
                .subscribe(new Observer<Integer>() {
                    @Override
                    public void onSubscribe(Disposable d) {

                    }

                    @Override
                    public void onNext(Integer value) {
                        Log.d(TAG, "接收到了事件"+ value  );
                    }

                    @Override
                    public void onError(Throwable e) {
                        Log.d(TAG, "对Error事件作出响应");
                    }

                    @Override
                    public void onComplete() {
                        Log.d(TAG, "对Complete事件作出响应");
                    }
                });
    }

输出：

concatArray()操作符

作用：同contact, 组合多个被观察者一起发送数据，合并后按发送顺序串行执行（可超过4个参数）
示例代码：

    public void concatArray() {
        // concatArray（）：组合多个被观察者一起发送数据（可＞4个）
        // 注：串行执行
        Observable.concatArray(Observable.just(1, 2),
                Observable.just(3, 4),
                Observable.just(5, 6),
                Observable.just(7, 8),
                Observable.just(9, 10))
                .subscribe(new Observer<Integer>() {
                    @Override
                    public void onSubscribe(Disposable d) {

                    }

                    @Override
                    public void onNext(Integer value) {
                        Log.d(TAG, "接收到了事件"+ value  );
                    }

                    @Override
                    public void onError(Throwable e) {
                        Log.d(TAG, "对Error事件作出响应");
                    }

                    @Override
                    public void onComplete() {
                        Log.d(TAG, "对Complete事件作出响应");
                    }
                });
    }

输出：

注：使用concat(Iterable> sources)也可以发送一个Observable的List集合（超过4个）。

merge()操作符

作用：组合多个被观察者一起发送数据，合并后按时间线并行执行
示例代码：

    public void merge() {
        // merge（）：组合多个被观察者（≤4个）一起发送数据
        // 注：合并后按照时间线并行执行
        Observable.merge(
                Observable.intervalRange(0, 3, 1, 1, TimeUnit.SECONDS), // 从0开始发送、共发送3个数据、第1次事件延迟发送时间 = 1s、间隔时间 = 1s
                Observable.intervalRange(2, 3, 1, 1, TimeUnit.SECONDS)) // 从2开始发送、共发送3个数据、第1次事件延迟发送时间 = 1s、间隔时间 = 1s
                .subscribe(new Observer<Long>() {
                    @Override
                    public void onSubscribe(Disposable d) {

                    }

                    @Override
                    public void onNext(Long value) {
                        Log.d(TAG, "接收到了事件"+ value  );
                    }

                    @Override
                    public void onError(Throwable e) {
                        Log.d(TAG, "对Error事件作出响应");
                    }

                    @Override
                    public void onComplete() {
                        Log.d(TAG, "对Complete事件作出响应");
                    }
                });

    }

输出：

mergeArray()操作符

作用：组合多个被观察者一起发送数据，合并后按时间线并行执行（可merge超过 4个）
示例代码：

    public void mergeArray() {
        // mergeArray（）：组合多个被观察者一起发送数据（可>4个）
        // 注：合并后按照时间线并行执行
        Observable.mergeArray(
                Observable.intervalRange(0, 3, 1, 1, TimeUnit.SECONDS),
                Observable.intervalRange(3, 3, 1, 1, TimeUnit.SECONDS),
                Observable.intervalRange(6, 3, 1, 1, TimeUnit.SECONDS),
                Observable.intervalRange(9, 3, 1, 1, TimeUnit.SECONDS),
                Observable.intervalRange(13, 3, 1, 1, TimeUnit.SECONDS))
                .subscribe(new Observer<Long>() {
                    @Override
                    public void onSubscribe(Disposable d) {

                    }

                    @Override
                    public void onNext(Long value) {
                        Log.d(TAG, "接收到了事件"+ value  );
                    }

                    @Override
                    public void onError(Throwable e) {
                        Log.d(TAG, "对Error事件作出响应");
                    }

                    @Override
                    public void onComplete() {
                        Log.d(TAG, "对Complete事件作出响应");
                    }
                });

    }

输出：

注：使用merge(Iterable> sources)也可以发送一个Observable的List集合（超过4个）。

concatDelayError()操作符

作用：使用concat()操作符时，若其中一个被观察者发出onError事件，则会马上终止其他被观察者继续发送事件，使用concatDelayError()操作符可以避免这种情况，使得onError事件推迟到其他被观察者发送事件完成以后才触发。
示例代码：

    public void concatDelayError() {
        Observable<Integer> observable1 = Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
                emitter.onNext(1);
                emitter.onNext(2);
                // 发送Error事件，因为使用了concatDelayError，所以第2个Observable将会发送事件，等发送完毕后，再发送错误事件
                emitter.onError(new NullPointerException());
                emitter.onComplete();
            }
        });
        Observable<Integer> observable2 = Observable.just(3, 4);
        List<Observable<Integer>> list = new ArrayList<>();
        list.add(observable1);
        list.add(observable2);
        Observable.concatDelayError(list)
        //concatArrayDelayError针对concatArray
//        Observable.concatArrayDelayError(observable1, observable2)
                .subscribe(new Observer<Integer>() {
                    @Override
                    public void onSubscribe(Disposable d) {

                    }
                    @Override
                    public void onNext(Integer value) {
                        Log.d(TAG, "接收到了事件"+ value  );
                    }

                    @Override
                    public void onError(Throwable e) {
                        Log.d(TAG, "对Error事件作出响应");
                    }

                    @Override
                    public void onComplete() {
                        Log.d(TAG, "对Complete事件作出响应");
                    }
                });
    }

如果不使用concatDelayError的输出：

使用concatDelayError的输出：

mergeDelayError()操作符

作用：类似于concatDelayError()操作符，专门针对merge()操作的。

zip()操作符

作用：合并多个被观察者（Observable）发送的事件，生成一个新的事件序列（即组合过后的事件序列）进行发送
新的事件序列的长度由长度较短的那个Observable决定
示例代码：

    public void zip() {
        Observable<Integer> observable1 = Observable.just(1, 2, 3, 4);
        Observable<String> observable2 = Observable.just("A", "B", "C");
        Observable.zip(observable1, observable2, new BiFunction<Integer, String, String>() {
                    @Override
                    public String apply(Integer integer, String s) throws Exception {
                        return s + integer;
                    }
                }).subscribe(new Observer<String>() {
                    @Override
                    public void onSubscribe(Disposable d) {
                        Log.d(TAG, "onSubscribe");
                    }

                    @Override
                    public void onNext(String value) {
                        Log.d(TAG, "最终接收到的事件 =  " + value);
                    }

                    @Override
                    public void onError(Throwable e) {
                        Log.d(TAG, "onError");
                    }

                    @Override
                    public void onComplete() {
                        Log.d(TAG, "onComplete");
                    }
                });
    }

输出：

关于zip操作符比较详细的解释看这篇文章：https://www.jianshu.com/p/bb58571cdb64

combineLatest()操作符

作用：当多个Observables中的任何一个发送了数据后，将先发送了数据的Observables 的最新（最后）一个数据与其他Observable发送的每个数据结合，结合的规则由combineLatest()传入的函数决定，最终基于该函数的结果发送数据。

与Zip()的区别：Zip() = 按个数合并，即1对1合并；CombineLatest() = 按时间合并，即在同一个时间点上合并。

示例代码：

    public void combineLatest() {
        Observable.combineLatest(
                Observable.just(1L, 2L, 3L), // 第1个发送数据事件的Observable
                Observable.intervalRange(0, 3, 1, 1, TimeUnit.SECONDS), // 第2个发送数据事件的Observable：从0开始发送、共发送3个数据、第1次事件延迟发送时间 = 1s、间隔时间 = 1s
                new BiFunction<Long, Long, Long>() {
                    @Override
                    public Long apply(Long o1, Long o2) throws Exception {
                        // o1 = 第1个Observable发送的最新（最后）1个数据
                        // o2 = 第2个Observable发送的每1个数据
                        // 合并的逻辑 = 相加
                        // 即第1个Observable发送的最后1个数据 与 第2个Observable发送的每1个数据进行相加
                        Log.e(TAG, "合并的数据是： " + o1 + " " + o2);
                        return o1 + o2;
                    }
                }).subscribe(new Consumer<Long>() {
                    @Override
                    public void accept(Long s) throws Exception {
                        Log.e(TAG, "合并的结果是： " + s);
                    }
                });
    }

输出：

50.686 7870-7973/com.fly.rx.simple D/RxJavaCombineConcat: 合并的数据是： 3 0
50.686 7870-7973/com.fly.rx.simple D/RxJavaCombineConcat: 合并的结果是： 3
51.686 7870-7973/com.fly.rx.simple D/RxJavaCombineConcat: 合并的数据是： 3 1
51.687 7870-7973/com.fly.rx.simple D/RxJavaCombineConcat: 合并的结果是： 4
52.686 7870-7973/com.fly.rx.simple D/RxJavaCombineConcat: 合并的数据是： 3 2
52.686 7870-7973/com.fly.rx.simple D/RxJavaCombineConcat: 合并的结果是： 5

combineLatestDelayError()操作符

作用：作用类似于concatDelayError()

reduce()操作符

作用：把被观察者需要发送的事件按照指定规则聚合成一个新事件发送
示例代码：

    public void reduce() {
        Observable.just(1,2,3,4)
                .reduce(new BiFunction<Integer, Integer, Integer>() {
                    // 在该复写方法中复写聚合的逻辑
                    @Override
                    public Integer apply(@NonNull Integer s1, @NonNull Integer s2) throws Exception {
                        // 本次聚合的逻辑是：全部数据相乘起来，每次将前两个数据相乘作为下一次的开始计算第一个数据
                        Log.e(TAG, "本次计算的数据是： "+s1 +" 乘 "+ s2);
                        return s1 * s2;
                    }
                }).subscribe(new Consumer<Integer>() {
                    @Override
                    public void accept(@NonNull Integer s) throws Exception {
                        Log.e(TAG, "最终计算的结果是： "+s);

                    }
                });
    }

输出：

collect()操作符

作用：将被观察者Observable发送的数据事件收集到一个数据结构里
示例代码：

    public void collect() {
        Observable.just(1, 2, 3 ,4, 5, 6)
                .collect(new Callable<ArrayList<Integer>>() {
                            @Override
                            public ArrayList<Integer> call() throws Exception {
                                // 创建数据结构（容器），用于收集被观察者发送的数据
                                return new ArrayList<>();
                            }
                        }, new BiConsumer<ArrayList<Integer>, Integer>() {
                            @Override
                            public void accept(ArrayList<Integer> list, Integer integer) throws Exception {
                                //对发送的数据进行收集 参数说明：list = 容器，integer = 后者数据
                                list.add(integer);
                            }
                }).subscribe(new Consumer<ArrayList<Integer>>() {
                    @Override
                    public void accept(@NonNull ArrayList<Integer> s) throws Exception {
                        Log.e(TAG, "本次发送的数据是： "+s);

                    }
                });
    }

输出：

startWith()操作符

作用：在一个被观察者发送事件前，追加发送一些数据或追加一个新的被观察者
示例代码：

    public void startWith() {
        Observable.just(7, 8)
                .startWith(6)  // 追加单个数据
                .startWithArray(4, 5) // 追加多个数据
                .startWith(Observable.just(1, 2, 3))//追加一个被观察者
                .subscribe(new Observer<Integer>() {
                    @Override
                    public void onSubscribe(Disposable d) {
                    }

                    @Override
                    public void onNext(Integer value) {
                        Log.d(TAG, "接收到了事件"+ value  );
                    }

                    @Override
                    public void onError(Throwable e) {
                        Log.d(TAG, "对Error事件作出响应");
                    }

                    @Override
                    public void onComplete() {
                        Log.d(TAG, "对Complete事件作出响应");
                    }
                });
    }

输出：

count()操作符

作用：统计被观察者发送事件的数量
示例代码：

    public void count() {
        Observable.just(1, 2, 3, 4)
                .count()
                .subscribe(new Consumer<Long>() {
                    @Override
                    public void accept(Long aLong) throws Exception {
                        Log.e(TAG, "发送的事件数量 =  "+aLong);

                    }
                });
    }

输出：

RxJava功能型操作符

subscribe()操作符

作用：被观察者订阅观察者，即连接观察者和被观察者形成订阅关系
示例代码：

  public void subscribe() {
        Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
                emitter.onNext(1);
                emitter.onComplete();
            }
        }).subscribe(new Observer<Integer>() {
            @Override
            public void onSubscribe(Disposable d) {
                Log.d(TAG, "开始采用subscribe连接");
            }

            @Override
            public void onNext(Integer value) {
                Log.d(TAG, "对Next事件"+ value +"作出响应"  );
            }

            @Override
            public void onError(Throwable e) {
                Log.d(TAG, "对Error事件作出响应");
            }

            @Override
            public void onComplete() {
                Log.d(TAG, "对Complete事件作出响应");
            }
        });
    }

subscribeOn() & observeOn()操作符

作用：线程调度，subscribeOn()指定被观察者发送事件的工作线程，observeOn()指定观察者响应事件的工作线程。

在 RxJava模型中，被观察者（Observable） / 观察者（Observer）的工作线程 = 创建自身的线程，即，若被观察者（Observable） / 观察者（Observer）在主线程被创建，那么他们的工作（生产事件 / 接收& 响应事件）就会发生在主线程。所以在在Android中默认被观察者和观察者是运行在相同的工作线程（即定义他们的线程，也就是默认的UI主线程中）。

在Android中，要实现在子线程中实现耗时的网络操作等，然后回到主线程实现 UI操作，那么对应的RxJava中，可理解为：

被观察者（Observable）在子线程中生产事件（如实现耗时操作等等）
观察者（Observer）在主线程接收 & 响应事件（即实现UI操作）

在 RxJava中，内置了多种用于调度的线程类型

类型	含义	应用场景
Schedulers.immediate()	当前线程 = 不指定线程	默认
AndroidSchedulers.mainThread()	Android主线程	操作UI
Schedulers.newThread()	常规新线程	耗时等操作
Schedulers.io()	io操作线程	网络请求、文件读写等io密集型操作
Schedulers.computation()	CPU计算操作线程	大量计算操作
Schedulers.single()	共享单线程实例	在单线程中排队按顺序执行任务
Schedulers.trampoline()	以FIFO的队列执行	暂停当前任务，执行新插入进来的任务完之后，再将未完成的任务接着执行

注：RxJava内部使用线程池来维护这些线程，所以线程的调度效率非常高。

示例代码：

    public void subscribOn() {
        Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
                Log.d(TAG, "被观察者 Observer的工作线程是: " + Thread.currentThread().getName());
                emitter.onNext(1);
                emitter.onComplete();
            }
        }).subscribeOn(Schedulers.io())
          //.subscribeOn(Schedulers.newThread())
          //.subscribeOn(Schedulers.computation())
          //.subscribeOn(Schedulers.single())
          .observeOn(AndroidSchedulers.mainThread())
          .subscribe(new Observer<Integer>() {
                @Override
                public void onSubscribe(Disposable d) {
                    Log.d(TAG, "开始采用subscribe连接");
                }

                @Override
                public void onNext(Integer value) {
                    Log.d(TAG, "观察者 Observer的工作线程是: " + Thread.currentThread().getName());
                }

                @Override
                public void onError(Throwable e) {
                }

                @Override
                public void onComplete() {
                }
            });
    }

输出：

注意的地方：

若Observable.subscribeOn()多次调用，则只有第一次指定有效，其余的指定线程无效

 observable.subscribeOn(Schedulers.newThread()) // 第一次指定被观察者线程 = 新线程
          .subscribeOn(AndroidSchedulers.mainThread()) // 第二次指定无效
          .observeOn(AndroidSchedulers.mainThread())
          .subscribe(observer);

若Observable.observeOn()多次调用，则每次指定均有效，即每指定一次，就会进行一次线程的切换

Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
                Log.d(TAG, "被观察者Observable的工作线程是: " + Thread.currentThread().getName());
                emitter.onNext(1);
                emitter.onComplete();
            }
        }).subscribeOn(Schedulers.newThread())
          .observeOn(AndroidSchedulers.mainThread())// 第一次指定观察者为主线程
          .doOnNext(new Consumer<Integer>() { // 生产事件
                @Override
                public void accept(Integer integer) throws Exception {
                    Log.d(TAG, "第一次观察者Observer的工作线程是： " + Thread.currentThread().getName());
                }
            })
          .observeOn(Schedulers.newThread()) // 第二次指定观察者为新的工作线程 有效
          .subscribe(new Observer<Integer>() {
                @Override
                public void onSubscribe(Disposable d) {
                    Log.d(TAG, "开始采用subscribe连接");
                }

                @Override
                public void onNext(Integer value) {
                    Log.d(TAG, "第二次观察者Observer的工作线程是: " + Thread.currentThread().getName());
                }

                @Override
                public void onError(Throwable e) {
                    Log.d(TAG, "对Error事件作出响应");
                }

                @Override
                public void onComplete() {
                    Log.d(TAG, "对Complete事件作出响应");
                }
            });

3. 在发送网络请求时退出当前Activity，此时如果回到主线程更新 UI，App会崩溃
解决方案：当 Activity退出时，调用 Disposable.dispose()切断观察者和被观察者的连接，使得观察者无法收到事件 & 响应事件。
当出现多个Disposable时，可采用RxJava内置容器CompositeDisposable进行统一管理

// 添加Disposable到CompositeDisposable容器
CompositeDisposable.add()
// 清空CompositeDisposable容器
CompositeDisposable.clear()

实例可以看这篇：https://www.jianshu.com/p/8818b98c44e2

delay()操作符

作用：使得被观察者延迟一段时间再发送事件
示例代码：

    public void delay() {
        Observable.just(1, 2, 3).delay(3, TimeUnit.SECONDS) // 延迟3s再发送
                .subscribe(new Observer<Integer>() {
                    @Override
                    public void onSubscribe(Disposable d) {

                    }

                    @Override
                    public void onNext(Integer value) {
                        Log.d(TAG, "接收到了事件" + value);
                    }

                    @Override
                    public void onError(Throwable e) {
                        Log.d(TAG, "对Error事件作出响应");
                    }

                    @Override
                    public void onComplete() {
                        Log.d(TAG, "对Complete事件作出响应");
                    }
                });
    }

delay()有多个重载函数：

其中有的可以指定线程调度器和错误延迟

do操作符

作用：在某个事件的生命周期中调用
do操作符有一系列：

方法	含义
doOnEach()	Observable每次发送事件前调用1次（包括完成和错误的事件）
doOnNext()	执行Next事件前调用
doAfterNext()	执行Next事件后调用
doOnError()	发送错误事件前调用
doOnCompleted()	正常发送事件完毕调用
doOnTerminate()	执行终止前调用(包括正常和异常终止的情况)
doAfterTerminate()	执行终止后调用
doFinally()	最后执行
doOnSubscribe	观察者订阅时调用

示例代码：

    public void doOn() {
        Observable.create(new ObservableOnSubscribe<Integer>() {
                @Override
                public void subscribe(ObservableEmitter<Integer> e) throws Exception {
                    e.onNext(1);
                    e.onNext(2);
                    e.onError(new Throwable("发生错误了"));
                    e.onComplete();
                }
            }).doOnEach(new Consumer<Notification<Integer>>() {
                @Override
                public void accept(Notification<Integer> integerNotification) throws Exception {
                    Log.d(TAG, "doOnEach: " + integerNotification.getValue());
                }
            }).doOnNext(new Consumer<Integer>() {
                @Override
                public void accept(Integer integer) throws Exception {
                    Log.d(TAG, "doOnNext: " + integer);
                }
            }).doAfterNext(new Consumer<Integer>() {
                @Override
                public void accept(Integer integer) throws Exception {
                    Log.d(TAG, "doAfterNext: " + integer);
                }
            }).doOnComplete(new Action() {
                @Override
                public void run() throws Exception {
                    Log.e(TAG, "doOnComplete: ");
                }
            }).doOnError(new Consumer<Throwable>() {
                @Override
                public void accept(Throwable throwable) throws Exception {
                    Log.d(TAG, "doOnError: " + throwable.getMessage());
                }
            }).doOnSubscribe(new Consumer<Disposable>() {
                @Override
                public void accept(@NonNull Disposable disposable) throws Exception {
                    Log.e(TAG, "doOnSubscribe: ");
                }
            }).doOnTerminate(new Action() {
                @Override
                public void run() throws Exception {
                    Log.e(TAG, "doOnTerminate: ");
                }
            }).doAfterTerminate(new Action() {
                @Override
                public void run() throws Exception {
                    Log.e(TAG, "doAfterTerminate: ");
                }
            }).doFinally(new Action() {
                @Override
                public void run() throws Exception {
                    Log.e(TAG, "doFinally: ");
                }
            }).subscribe(new Observer<Integer>() {
                @Override
                public void onSubscribe(Disposable d) {
                    Log.d(TAG, "onSubscribe");
                }
                @Override
                public void onNext(Integer value) {
                    Log.d(TAG, "接收到了事件"+ value  );
                }

                @Override
                public void onError(Throwable e) {
                    Log.d(TAG, "对Error事件作出响应");
                }

                @Override
                public void onComplete() {
                    Log.d(TAG, "对Complete事件作出响应");
                }
            });
    }

输出：

onErrorReturn()操作符

作用：可以捕获错误。遇到错误时，发送一个特殊事件，并且正常终止。
注意后面的事件不会再发送
示例代码：

    public void onErrorReturn() {
        Observable.create(new ObservableOnSubscribe<Integer>() {
                    @Override
                    public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
                        emitter.onNext(1);
                        emitter.onNext(2);
                        emitter.onError(new Throwable("错误异常"));
                        emitter.onNext(3);

                    }
                }).onErrorReturn(new Function<Throwable, Integer>() {
                    @Override
                    public Integer apply(Throwable throwable) throws Exception {
                        Log.e(TAG, "发生了错误：  " + throwable.getMessage());
                        //捕获错误 返回一个特殊事件正常终止
                        return 404;
                    }
                }).subscribe(new Observer<Integer>() {
                    @Override
                    public void onSubscribe(Disposable d) {

                    }

                    @Override
                    public void onNext(Integer integer) {
                        Log.d(TAG, String.valueOf(integer));
                    }

                    @Override
                    public void onError(Throwable e) {
                        Log.d(TAG, e.getMessage());
                    }

                    @Override
                    public void onComplete() {
                        Log.d(TAG, "onComplete");
                    }
                });

    }

输出：

onErrorResumeNext()

作用：发生错误的时候，发送1个新的Observable正常终止
示例代码：

   public void onErrorResumeNext() {
        Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> e) throws Exception {
                e.onNext(1);
                e.onNext(2);
                e.onError(new Throwable("发生错误了"));
                e.onNext(3);
            }
        }).onErrorResumeNext(new Function<Throwable, ObservableSource<? extends Integer>>() {
            @Override
            public ObservableSource<? extends Integer> apply(@NonNull Throwable throwable) throws Exception {
                Log.e(TAG, "在onErrorReturn处理了错误: " + throwable.toString());
                // 发生错误事件后，发送一个新的被观察者Observable
                return Observable.just(11, 22);

            }
        }).subscribe(new Observer<Integer>() {
            @Override
            public void onSubscribe(Disposable d) {
            }

            @Override
            public void onNext(Integer value) {
                Log.d(TAG, "接收到了事件" + value);
            }

            @Override
            public void onError(Throwable e) {
                Log.d(TAG, "对Error事件作出响应");
            }

            @Override
            public void onComplete() {
                Log.d(TAG, "对Complete事件作出响应");
            }
        });
    }

输出：

onExceptionResumeNext()操作符

作用：发生异常时，发送1个新的Observable正常终止

注意onExceptionResumeNext()拦截的类型是Exception， onErrorResumeNext() 拦截的类型是Throwable，若用onExceptionResumeNext()拦截 Throwable，则会将错误传递给观察者的onError方法。

示例代码：

    public void onExceptionResumeNext() {
        Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> e) throws Exception {
                e.onNext(1);
                e.onNext(2);
                e.onError(new Exception("发生错误了"));
                e.onNext(3);
            }
        }).onExceptionResumeNext(new Observable<Integer>() {
            @Override
            protected void subscribeActual(Observer<? super Integer> observer) {
                observer.onNext(55);
                observer.onNext(66);
                observer.onComplete();
            }
        }).subscribe(new Observer<Integer>() {
            @Override
            public void onSubscribe(Disposable d) {

            }

            @Override
            public void onNext(Integer value) {
                Log.d(TAG, "接收到了事件" + value);
            }

            @Override
            public void onError(Throwable e) {
                Log.d(TAG, "对Error事件作出响应");
            }

            @Override
            public void onComplete() {
                Log.d(TAG, "对Complete事件作出响应");
            }
        });
    }

输出：

retry()操作符

作用：重试，即当出现错误时（出现onError），让被观察者重新发射数据

与onExceptionResumeNext()和onErrorResumeNext() 的区别是retry()可以对Throwable 和 Exception都可拦截，并且retry()完毕之后观察者还是会收到onError事件的，前两者则不会。

retry有一些重载方法：

方法	说明
retry()	出现错误时，让被观察者重新发送数据。若错误一直发生，则一直重新发送
retry(long time)	与retry不同的书，若错误一直发生，被观察者则一直重新发送数据，但这持续重新发送有次数限制
retry(Predicate predicate)	出现错误时，根据指定逻辑(可以捕获到发生的错误)决定是否让被观察者重新发送数据
retry(new BiPredicate)	出现错误时，根据指定逻辑(可以捕获重发的次数和发生的错误)决定是否让被观察者重新发送数据
retry（long time,Predicate predicate）	出现错误时，根据指定逻辑(可以捕获到发生的错误)决定是否让被观察者重新发送数据。并且可设置重发次数

示例代码：

    public void retry() {
        Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> e) throws Exception {
                e.onNext(1);
                e.onNext(2);
                e.onError(new Exception("发生错误了"));
                e.onNext(3);
            }
        })//.retry() //一直重新发送(但这样就死循环了)
          //.retry(3)//重发最多3次
          .retry(new BiPredicate<Integer, Throwable>() {
              // 拦截错误后，根据逻辑判断是否需要重新发送请求
             @Override
             public boolean test(Integer integer, Throwable throwable) throws Exception {
                // 捕获异常
                 Log.e(TAG, "异常错误 =  "+throwable.toString());
                // 获取当前重试次数
                Log.e(TAG, "当前重试次数 =  "+integer);
                //返回false = 不重新重新发送数据 & 调用观察者的onError结束
                //返回true = 重新发送请求（若持续遇到错误，就持续重新发送）
                  if (integer > 3) {
                      return false;
                  }
                return true;
             }
          })
//          .retry(3, new Predicate() {// 拦截错误后，根据逻辑判断是否需要重新发送请求, 最多重新发送3次
//              @Override
//              public boolean test(@NonNull Throwable throwable) throws Exception {
//                  // 捕获异常
//                  Log.e(TAG, "retry错误: "+throwable.toString());
//                  //返回false = 不重新重新发送数据 & 调用观察者的onError（）结束
//                  //返回true = 重新发送请求
//                  return true;
//              }
//          })
           .subscribe(new Observer<Integer>() {
            @Override
            public void onSubscribe(Disposable d) {
            }

            @Override
            public void onNext(Integer value) {
                Log.d(TAG, "接收到了事件" + value);
            }

            @Override
            public void onError(Throwable e) {
                Log.d(TAG, "对Error事件作出响应");
            }

            @Override
            public void onComplete() {
                Log.d(TAG, "对Complete事件作出响应");
            }
        });
    }

输出：

retryUntil()操作符

作用：出现错误后，满足判断条件之前持续重新发送数据
类似于retry（Predicate predicate），唯一区别：返回 true 则不重新发送数据事件。
示例代码：

    public void retryUntil() {
        Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> e) throws Exception {
                e.onNext(1);
                e.onNext(2);
                e.onError(new Exception("发生错误了"));
                e.onNext(3);
            }
        }).retryUntil(new BooleanSupplier() {
            @Override
            public boolean getAsBoolean() throws Exception {

                //return true ： 不重新发送请求，并且调用观察者的onError()方法结束
                // return false ： 重新发送数据(若持续遇到错误，就持续重新发送)
                return false;
            }
        }).subscribe(new Observer<Integer>() {
            @Override
            public void onSubscribe(Disposable d) {
            }

            @Override
            public void onNext(Integer value) {
                Log.d(TAG, "接收到了事件" + value);
            }

            @Override
            public void onError(Throwable e) {
                Log.d(TAG, "对Error事件作出响应");
            }

            @Override
            public void onComplete() {
                Log.d(TAG, "对Complete事件作出响应");
            }
        });
    }

retryWhen()操作符

作用：遇到错误时，将发生的错误传递给一个新的被观察者，并决定是否需要重新订阅原始被观察者
示例代码：

    public void retryWhen() {
        Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> e) throws Exception {
                e.onNext(1);
                e.onNext(2);
                e.onError(new Exception("发生错误了"));
                e.onNext(3);
            }
            // 遇到error事件才会回调
        }).retryWhen(new Function<Observable<Throwable>, ObservableSource<?>>() {

            @Override
            public ObservableSource<?> apply(@NonNull Observable<Throwable> throwableObservable) throws Exception {
                // 参数Observable中的泛型 = 上游操作符抛出的异常，可通过该条件来判断异常的类型
                // 返回Observable = 新的被观察者 Observable（任意类型）
                return throwableObservable.flatMap(new Function<Throwable, ObservableSource<?>>() {
                    // 此处有两种情况：
                    // 1. 若 新的被观察者 Observable发送的事件 = Error事件，那么 原始Observable则不重新发送事件：
                    // 2. 若 新的被观察者 Observable发送的事件 = Next事件 ，那么原始的Observable则重新发送事件：
                    @Override
                    public ObservableSource<?> apply(@NonNull Throwable throwable) throws Exception {

                        // 1. 若返回的Observable发送的事件 = Error事件，则原始的Observable不重新发送事件
                        // 该异常错误信息可在观察者中的onError（）中获得
                        return Observable.error(new Throwable("retryWhen终止啦"));

                        //2、若返回的Observable发送的事件= Next事件(和next的内容无关)，则原始的Observable重新发送事件(若持续遇到错误，则持续发送)
                        // 仅仅是作为一个触发重新订阅原被观察者的通知，什么数据并不重要，只要不是onComplete/onError事件
                        //return Observable.just(5);
                    }
                });

            }
        }).subscribe(new Observer<Integer>() {
            @Override
            public void onSubscribe(Disposable d) {

            }
            @Override
            public void onNext(Integer value) {
                Log.d(TAG, "接收到了事件"+ value  );
            }

            @Override
            public void onError(Throwable e) {
                Log.d(TAG, "对Error事件作出响应" + e.toString());
                // 获取异常错误信息
            }

            @Override
            public void onComplete() {
                Log.d(TAG, "对Complete事件作出响应");
            }
        });
    }

输出：

repeat()操作符

作用：无条件地、重复发送被观察者事件
接收到onCompleted()事件后，触发重新订阅，默认运行在一个新的线程上
示例代码：

    public void repeat() {
        Observable.just(1, 2)
                .repeat(3) // 重复发送3次被观察者事件
                //.repeat()//无限重复
                .subscribe(new Observer<Integer>() {
                    @Override
                    public void onSubscribe(Disposable d) {
                        Log.d(TAG, "开始采用subscribe连接");
                    }

                    @Override
                    public void onNext(Integer value) {
                        Log.d(TAG, "接收到了事件" + value);
                    }

                    @Override
                    public void onError(Throwable e) {
                        Log.d(TAG, "对Error事件作出响应");
                    }

                    @Override
                    public void onComplete() {
                        Log.d(TAG, "对Complete事件作出响应");
                    }

                });

    }

输出：

repeatWhen()操作符

作用：有条件地、重复发送被观察者事件

将原始 Observable 停止发送事件的标识（Complete（） / Error（））转换成1个 Object 类型数据传递给1个新被观察者（Observable），以此决定是否重新订阅 & 发送原来的 Observable:

若新被观察者（Observable）返回1个Complete / Error事件，则不重新订阅 & 发送原来的 Observable
若新被观察者（Observable）返回其余事件时，则重新订阅 & 发送原来的 Observable

示例代码：

    public void repeatWhen() {
        Observable.just(1,2,3).repeatWhen(new Function<Observable<Object>, ObservableSource<?>>() {

            @Override
            public ObservableSource<?> apply(@NonNull Observable<Object> objectObservable) throws Exception {
                // 在Function函数中，必须对输入的 Observable