RxJava的基本使用和操作符

一.基本使用

1.链式调用

首先在build.gradle中添加依赖：

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

RxJava的使用步骤包括：

• 创建被观察者进行事件发送
• 创建观察者进行事件响应
• 通过订阅方法连接观察者和被观察者

Observable.create(new ObservableOnSubscribe<Integer>() {
        @Override
        public void subscribe(ObservableEmitter<Integer> e) throws Exception {
        e.onNext(2);
        e.onNext(3);

            }
        }).subscribe(new Observer<Integer>() {
            @Override
            public void onSubscribe(Disposable d) {
                Log.e(TAG, "onSubscribe: ");
            }

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

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

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

被观察者通过ObservableEmitter的onNext进行事件发送，在观察者的onNext方法中进行事件接收。

2.onComplete

被观察者可以调用ObservableEmitter的onComplete方法通知观察者发送完成，此时观察者的onComplete方法中会收到该通知。之后，被观察者可以继续发送事件，但观察者不会再接收。

	Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> e) throws Exception {
                e.onNext(2);
                e.onComplete();
                e.onNext(3);
                Log.e(TAG, "被观察者-Emitter：3 已发送" );
            }
        }).subscribe(new Observer<Integer>() {
            @Override
            public void onSubscribe(Disposable d) {
                Log.e(TAG, "观察者-onSubscribe: ");
            }

            @Override
            public void onNext(Integer integer) {
                Log.e(TAG, "观察者-onNext: " + integer);
            }

            @Override
            public void onError(Throwable e) {
                Log.e(TAG, "观察者-onError: "+e.getMessage() );
            }

            @Override
            public void onComplete() {
                Log.e(TAG, "观察者-onComplete: ");
            }
        });

输出：

2019-11-03 16:46:09.098 24226-24226/com.example.rxjava_learn E/MainActivity: 观察者-onSubscribe: 
    2019-11-03 16:46:09.099 24226-24226/com.example.rxjava_learn E/MainActivity: 观察者-onNext: 2
    2019-11-03 16:46:09.099 24226-24226/com.example.rxjava_learn E/MainActivity: 观察者-onComplete: 
    2019-11-03 16:46:09.099 24226-24226/com.example.rxjava_learn E/MainActivity: 被观察者-Emitter：3 已发送

3.onError

被观察者可以调用ObservableEmitter的onError方法发送异常，此时观察者的onError方法中会收到该异常。被观察者在发送异常之后再使用onNext发送事件，观察者不会收到事件。如果被观察者在发送完onComplete之后发送onError会导致程序崩溃。

4.Disposable

当被观察者执行subscribe方法连接观察者时，在观察者的onSubscribe方法中可以得到Disposable对象，通过调用该对象的dispose方法可以断开被观察者和观察者之间的连接，断开之后，被观察者可以继续发送事件，但观察者无法接受。

Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> e) throws Exception {
                for (int i=0;i<3;i++){
                    e.onNext(i);
                    Log.e(TAG, "被观察者发送：" + i );
                }
            }
        }).subscribe(new Observer<Integer>() {
            @Override
            public void onSubscribe(Disposable d) {
                Log.e(TAG, "观察者-onSubscribe: ");
                disposable = d;
            }

            @Override
            public void onNext(Integer integer) {
                Log.e(TAG, "观察者-onNext: " + integer);
                disposable.dispose();
            }

            @Override
            public void onError(Throwable e) {
                Log.e(TAG, "观察者-onError: "+e.getMessage() );
            }

            @Override
            public void onComplete() {
                Log.e(TAG, "观察者-onComplete: ");
            }
        });

输出：

2019-11-03 16:54:15.341 24927-24927/com.example.rxjava_learn E/MainActivity: 观察者-onSubscribe: 
    2019-11-03 16:54:15.343 24927-24927/com.example.rxjava_learn E/MainActivity: 观察者-onNext: 0
    2019-11-03 16:54:15.343 24927-24927/com.example.rxjava_learn E/MainActivity: 被观察者发送：0
    2019-11-03 16:54:15.343 24927-24927/com.example.rxjava_learn E/MainActivity: 被观察者发送：1
    2019-11-03 16:54:15.343 24927-24927/com.example.rxjava_learn E/MainActivity: 被观察者发送：2

dispose方法可以放在Activity的onDestroy中，在应用退出时执行。

@Override
    protected void onDestroy() {
        super.onDestroy();
        if (disposable != null){
            disposable.dispose();
        }
    }

二.操作符

RxJava中，主要用到的操作符有创建型操作符、过滤型操作符、合并型操作符、变换型操作符、条件型操作符以及异常处理操作符。

（一）创建型操作符

创建型操作符用于创建被观察者，向观察者发送事件，主要有以下几种：

1.just

just方法中可以输入任意数量的参数（最多10个），被观察者会依次将这些参数发送给观察者。

Observable.just(1,"3",1.0f)
                .subscribe(new Observer<Object>() {
                    @Override
                    public void onSubscribe(Disposable d) {
                        Log.e(TAG, "onSubscribe: ");
                    }

                    @Override
                    public void onNext(Object o) {
                        Log.e(TAG, "onNext: " + o );
                    }

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

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

输出：

2019-11-03 21:19:33.481 31925-31925/com.example.rxjava_learn E/MainActivity: onSubscribe: 
    2019-11-03 21:19:33.481 31925-31925/com.example.rxjava_learn E/MainActivity: onNext: 1
    2019-11-03 21:19:33.482 31925-31925/com.example.rxjava_learn E/MainActivity: onNext: 3
    2019-11-03 21:19:33.483 31925-31925/com.example.rxjava_learn E/MainActivity: onNext: 1.0
    2019-11-03 21:19:33.484 31925-31925/com.example.rxjava_learn E/MainActivity: onComplete:

2.fromArray

fromArray接收一个数组，并把数组元素依次进行发送。

Integer[] arr = new Integer[]{1,2,3};
        Observable.fromArray(arr)
                .subscribe(new Observer<Integer>() {
                    @Override
                    public void onSubscribe(Disposable d) {
                        Log.e(TAG, "onSubscribe: " );
                    }

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

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

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

输出：

2019-11-03 21:21:24.796 31925-31925/com.example.rxjava_learn E/MainActivity: onSubscribe: 
    2019-11-03 21:21:24.796 31925-31925/com.example.rxjava_learn E/MainActivity: onNext: 1
    2019-11-03 21:21:24.796 31925-31925/com.example.rxjava_learn E/MainActivity: onNext: 2
    2019-11-03 21:21:24.797 31925-31925/com.example.rxjava_learn E/MainActivity: onNext: 3
    2019-11-03 21:21:24.797 31925-31925/com.example.rxjava_learn E/MainActivity: onComplete:

3.empty

empty会发送只会发送onComplete事件，观察者的泛型只能是Object。

Observable.empty()
                .subscribe(new Observer<Object>() {

                    @Override
                    public void onSubscribe(Disposable d) {
                        Log.e(TAG, "onSubscribe: " );
                    }

                    @Override
                    public void onNext(Object o) {
                        Log.e(TAG, "onNext: " );
                    }

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

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

输出：

2019-11-03 21:21:49.201 31925-31925/com.example.rxjava_learn E/MainActivity: onSubscribe: 
    2019-11-03 21:21:49.201 31925-31925/com.example.rxjava_learn E/MainActivity: onComplete: 

4.range

range接收两个int型参数，第一个参数是起始值，第二个参数是数量。

Observable.range(1,3)
                .subscribe(new Observer<Integer>() {
                    @Override
                    public void onSubscribe(Disposable d) {
                        Log.e(TAG, "onSubscribe: " );
                    }

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

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

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

输出：

2019-11-03 21:25:28.565 31925-31925/com.example.rxjava_learn E/MainActivity: onSubscribe: 
    2019-11-03 21:25:28.566 31925-31925/com.example.rxjava_learn E/MainActivity: onNext: 1
    2019-11-03 21:25:28.566 31925-31925/com.example.rxjava_learn E/MainActivity: onNext: 2
    2019-11-03 21:25:28.566 31925-31925/com.example.rxjava_learn E/MainActivity: onNext: 3
    2019-11-03 21:25:28.566 31925-31925/com.example.rxjava_learn E/MainActivity: onComplete: 

5.defer

defer用于动态创建被观察者，只有观察者订阅时，被观察者才会被创建。

i = 1;
        Observable<Object> observable = Observable.defer(new Callable<ObservableSource<?>>() {
            @Override
            public ObservableSource<?> call() throws Exception {
                return Observable.range(i, 3);
            }
        });
        i = 10;
        observable.subscribe(new Observer<Object>() {

            @Override
            public void onSubscribe(Disposable d) {
                Log.e(TAG, "onSubscribe: " );
            }

            @Override
            public void onNext(Object o) {
                Log.e(TAG, "onNext: " + o);
            }

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

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

输出：

2019-11-03 21:27:44.967 31925-31925/com.example.rxjava_learn E/MainActivity: onSubscribe: 
    2019-11-03 21:27:44.967 31925-31925/com.example.rxjava_learn E/MainActivity: onNext: 10
    2019-11-03 21:27:44.967 31925-31925/com.example.rxjava_learn E/MainActivity: onNext: 11
    2019-11-03 21:27:44.967 31925-31925/com.example.rxjava_learn E/MainActivity: onNext: 12
    2019-11-03 21:27:44.967 31925-31925/com.example.rxjava_learn E/MainActivity: onComplete: 

6.timer

timer可以设置延时时间，延时时间过后，发送一个0.

Observable.timer(2, TimeUnit.SECONDS)
                .subscribe(new Observer<Long>() {
                    @Override
                    public void onSubscribe(Disposable d) {
                        Log.e(TAG, "onSubscribe: " );
                    }

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

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

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

输出：

7.interval

interval用于每隔指定时间发送事件，事件是从0开始递增1的序列。第一个参数是第一次延迟时间，第二个参数是时间间隔，第三个参数是时间单位。

Observable.interval(3,1,TimeUnit.SECONDS)
                .subscribe(new Observer<Long>() {
                    @Override
                    public void onSubscribe(Disposable d) {
                        Log.e(TAG, "onSubscribe: " );
                    }

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

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

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

输出：

8.intervalRange

intervalRange在interval基础上增加了两个参数，第一个参数表示发送整数序列的起始值，第二个参数表示整数序列的数量。

Observable.intervalRange(10,5,3,1,TimeUnit.SECONDS)
                .subscribe(new Observer<Long>() {
                    @Override
                    public void onSubscribe(Disposable d) {
                        Log.e(TAG, "onSubscribe: " );
                    }

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

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

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

输出：

（二）变换型操作符

变换型操作符用在被观察者发送事件之后、观察者接收事件之前，对发送的事件进行变换操作。

1.map

map对发送的事件进行处理，变换成另一种事件。

Observable.just(1,2,3)
                .map(new Function<Integer, String>() {
                    @Override
                    public String apply(Integer integer) throws Exception {
                        return "map变换之后：" + integer;
                    }
                })
                .subscribe(new Consumer<String>() {
                    @Override
                    public void accept(String s) throws Exception {
                        Log.e(TAG, "accept: " + s );
                    }
                });

输出：

2019-11-05 23:28:58.075 8343-8343/com.example.rxjava_learn E/TransActivity: accept: map变换之后：1
    2019-11-05 23:28:58.075 8343-8343/com.example.rxjava_learn E/TransActivity: accept: map变换之后：2
    2019-11-05 23:28:58.075 8343-8343/com.example.rxjava_learn E/TransActivity: accept: map变换之后：3

2.flatMap

flatMap接收观察者发送的事件，返回值类型为ObservableSource（被观察者），即把接收到的事件进行了第二次发送。flatMap进行二次发送时是没有顺序的。

Observable.just("A","B","C")
                .flatMap(new Function<String, ObservableSource<String>>() {
                    @Override
                    public ObservableSource<String> apply(String s) throws Exception {
                        List<String> list = new ArrayList<>();
                        for (int i=1;i<=3;i++){
                            list.add("事件" + s + "的子事件" + i);
                        }
                        return Observable.fromIterable(list).delay(5, TimeUnit.SECONDS);
                    }
                }).subscribe(new Consumer<String>() {
            @Override
            public void accept(String o) throws Exception {
                Log.e(TAG, "accept: " + o );
            }
        });

输出：

3.concatMap

concatMap与flatMap功能类似，区别是concatMap进行二次发送的事件是有序的。

Observable.just("A","B","C")
                .concatMap(new Function<String, ObservableSource<String>>() {
                    @Override
                    public ObservableSource<String> apply(String s) throws Exception {
                        List<String> list = new ArrayList<>();
                        for (int i=1;i<=3;i++){
                            list.add("事件" + s + "的子事件" + i);
                        }
                        return Observable.fromIterable(list).delay(5, TimeUnit.SECONDS);
                    }
                }).subscribe(new Consumer<String>() {
            @Override
            public void accept(String o) throws Exception {
                Log.e(TAG, "accept: " + o );
            }
        });

输出：

4.groupBy

groupBy用于对发送的事件进行分组，groupBy为分组的逻辑，在观察者中的groupedObservable对象中，groupedObservable的getKey方法可以得到组名称。

Observable.just(81,92,63,94,73,99,90)
                .groupBy(new Function<Integer, String>() {
                    @Override
                    public String apply(Integer integer) throws Exception {
                        return integer >= 90 ? "优" : "良";
                    }
                }).subscribe(new Consumer<GroupedObservable<String, Integer>>() {
            @Override
            public void accept(GroupedObservable<String, Integer> groupedObservable) throws Exception {
                groupedObservable.subscribe(new Consumer<Integer>() {
                    @Override
                    public void accept(Integer integer) throws Exception {
                        Log.e(TAG, groupedObservable.getKey() + ": " + integer );
                    }
                });
            }
        });

输出：

5.buffer

buffer从被观察者中获取一定数量的事件放入缓冲区，然后发送给观察者，第一个参数为缓冲区大小，第二个参数为每次获取新事件的数量。

Observable.just(1,2,3,4,5,6,7,8,9,10)
                .buffer(3,2)
                .subscribe(new Consumer<List<Integer>>() {
                    @Override
                    public void accept(List<Integer> integers) throws Exception {
                        Log.e(TAG, "accept: " + integers );
                        Log.e(TAG, "---------------" );
                    }
                });

输出：

（三）过滤型操作符

过滤型操作符可以设置过滤条件，对发送的事件进行过滤。

1.filter

filter中可以指定过滤条件，filter内返回值为true代表不过滤事件，返回false代表过滤事件。

Observable.just(1,2,3,4,5)
                .filter(new Predicate<Integer>() {
                    @Override
                    public boolean test(Integer integer) throws Exception {
                        return integer > 3 ? true : false;
                    }
                }).subscribe(new Consumer<Integer>() {
            @Override
            public void accept(Integer integer) throws Exception {
                Log.e(TAG, "accept: " + integer );
            }
        });

输出：

2019-11-05 23:57:13.977 9482-9482/com.example.rxjava_learn E/FilterActivity: accept: 4
    2019-11-05 23:57:13.978 9482-9482/com.example.rxjava_learn E/FilterActivity: accept: 5

2.take

take用在定时器中，参数为整数，表示取一定数量的事件，超过该数量的事件过滤掉。

Observable.interval(1, TimeUnit.SECONDS)
                .take(5)
                .subscribe(new Consumer<Long>() {
                    @Override
                    public void accept(Long aLong) throws Exception {
                        Log.e(TAG, "accept: " + aLong );
                    }
                });

输出：

3.distinct

distinct用于过滤掉重复事件。

Observable.just(1,1,1,2,2,3,3)
                .distinct()
                .subscribe(new Consumer<Integer>() {
                    @Override
                    public void accept(Integer integer) throws Exception {
                        Log.e(TAG, "accept: " + integer );
                    }
                });

输出：

2019-11-06 00:01:31.338 9482-9482/com.example.rxjava_learn E/FilterActivity: accept: 1
    2019-11-06 00:01:31.338 9482-9482/com.example.rxjava_learn E/FilterActivity: accept: 2
    2019-11-06 00:01:31.338 9482-9482/com.example.rxjava_learn E/FilterActivity: accept: 3

4.elementAt

elementAt指定获取某个事件，如果获取不到，则获取默认事件。

Observable.just("A","B","C")
                .elementAt(1,"D")
                .subscribe(new Consumer<String>() {
                    @Override
                    public void accept(String s) throws Exception {
                        Log.e(TAG, "accept: " + s );
                    }
                });

输出：

2019-11-06 00:03:27.354 9482-9482/com.example.rxjava_learn E/FilterActivity: accept: B

（四）条件型操作符

条件型操作符主要用于判断发送的事件是否满足设定的条件。

1.all

all用来判断发送的所有事件是否同时满足某条件，如果满足，返回true。

Observable.just(1,2,3,4)
                .all(new Predicate<Integer>() {
                    @Override
                    public boolean test(Integer integer) throws Exception {
                        return integer > 0;
                    }
                })
                .subscribe(new Consumer<Boolean>() {
                    @Override
                    public void accept(Boolean aBoolean) throws Exception {
                        Log.e(TAG, "accept: " + aBoolean);
                    }
                });

输出：

2019-11-06 19:54:16.950 10315-10315/com.example.rxjava_learn E/ConditionActivity: accept: true

2.contains

contains用来判断发送的事件中是否包含某个事件。

Observable.just("A","B","C")
                .contains("D")
                .subscribe(new Consumer<Boolean>() {
                    @Override
                    public void accept(Boolean aBoolean) throws Exception {
                        Log.e(TAG, "accept: " + aBoolean);
                    }
                });

输出：

2019-11-06 19:55:18.179 10315-10315/com.example.rxjava_learn E/ConditionActivity: accept: false

3.isEmpty

isEmpty用来判断发送的事件是否为empty。

Observable.empty()
                .isEmpty()
                .subscribe(new Consumer<Boolean>() {
                    @Override
                    public void accept(Boolean aBoolean) throws Exception {
                        Log.e(TAG, "accept: " + aBoolean );
                    }
                });

输出：

2019-11-06 19:56:50.480 10315-10315/com.example.rxjava_learn E/ConditionActivity: accept: true

4.any

any用来判断发送的所有事件中是否至少有一个事件满足条件。

Observable.just(1,2,3,4)
                .any(new Predicate<Integer>() {
                    @Override
                    public boolean test(Integer integer) throws Exception {
                        return integer > 3;
                    }
                })
                .subscribe(new Consumer<Boolean>() {
                    @Override
                    public void accept(Boolean aBoolean) throws Exception {
                        Log.e(TAG, "accept: " + aBoolean);
                    }
                });

输出：

2019-11-06 19:58:00.370 10315-10315/com.example.rxjava_learn E/ConditionActivity: accept: true

（五）合并型操作符

合并型操作符用于合并多个被观察者发送的事件。

1.concat/concatArray

concat用于将多个被观察者组合在一起发送事件，组合后按照发送事件的顺序串行发送事件。concat最多组合4个被观察者，concatArray可以组合4个以上观察者。

Observable.concat(Observable.just(1,2),
                Observable.just(3,4),
                Observable.just(5,6))
                .subscribe(new Consumer<Integer>() {
                    @Override
                    public void accept(Integer integer) throws Exception {
                        Log.e(TAG, "accept: " + integer );
                    }
                });

输出：

2019-11-06 20:13:47.051 11365-11365/com.example.rxjava_learn E/CombineActivity: accept: 1
2019-11-06 20:13:47.052 11365-11365/com.example.rxjava_learn E/CombineActivity: accept: 2
2019-11-06 20:13:47.052 11365-11365/com.example.rxjava_learn E/CombineActivity: accept: 3
2019-11-06 20:13:47.052 11365-11365/com.example.rxjava_learn E/CombineActivity: accept: 4
2019-11-06 20:13:47.052 11365-11365/com.example.rxjava_learn E/CombineActivity: accept: 5
2019-11-06 20:13:47.052 11365-11365/com.example.rxjava_learn E/CombineActivity: accept: 6

2.merge/mergeArray

concat用于将多个被观察者组合在一起发送事件，与concat的区别是merge组合后按照发送时间顺序发送事件。merge最多组合4个被观察者，mergeArray可以组合4个以上观察者。

Observable.merge(Observable.intervalRange(1,3,1,1, TimeUnit.SECONDS),
            Observable.intervalRange(5,3,1,1, TimeUnit.SECONDS))
            .subscribe(new Consumer<Long>() {
                @Override
                public void accept(Long aLong) throws Exception {
                    Log.e(TAG, "accept: " + aLong );
                }
            });

输出：

3.zip

zip按照多个被观察者的事件序列进行合并，即所有被观察者的第一个事件合并在一起，第二个事件合并在一起，最终合并得到的事件数量是事件最少的被观察者发送的事件数量。

Observable.zip(Observable.intervalRange(1, 6,1 ,1,TimeUnit.SECONDS),
            Observable.just("A", "B", "C"), new BiFunction<Long, String, String>() {
                @Override
                public String apply(Long integer, String s) throws Exception {
                    return integer + "-" + s;
                }
            })
            .subscribe(new Consumer<String>() {
                @Override
                public void accept(String s) throws Exception {
                    Log.e(TAG, "accept: " + s );
                }
            });

输出：

4.combineLatest

combineLatest将处在同一时间点上的事件进行合并。

Observable.combineLatest(Observable.intervalRange(1, 6,1 ,1,TimeUnit.SECONDS),
            Observable.just("A", "B", "C"), new BiFunction<Long, String, String>() {
                @Override
                public String apply(Long integer, String s) throws Exception {
                    return integer + "-" + s;
                }
            })
            .subscribe(new Consumer<String>() {
                @Override
                public void accept(String s) throws Exception {
                    Log.e(TAG, "accept: " + s );
                }
            });

输出：

5.reduce

reduce把被观察者发送的多个事件合并成一个事件发送。

Observable.just(1,2,3,4)
            .reduce(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 {
            Log.e(TAG, "accept: " + integer );
        }
    });

输出：

2019-11-06 20:39:03.764 12906-12906/com.example.rxjava_learn E/CombineActivity: accept: 10

6.collect

collect用于将发送的多个事件收集到集合中。

Observable.just(1,2,3,4)
            .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> integers, Integer integer) throws Exception {
                    integers.add(integer);
                }
            }).subscribe(new Consumer<ArrayList<Integer>>() {
        @Override
        public void accept(ArrayList<Integer> integers) throws Exception {
            Log.e(TAG, "accept: " + integers );
        }
    });

输出：

2019-11-06 20:42:47.150 13113-13113/com.example.rxjava_learn E/CombineActivity: accept: [1, 2, 3, 4]

7.startWith/startWithArray

startWith用于在被观察者发送事件之前在开头添加一些事件，startWith每次添加一个事件，startWithArray可以一次添加多个事件。

Observable.just(4,5,6)
            .startWith(3)
            .startWithArray(1,2)
            .subscribe(new Consumer<Integer>() {
                @Override
                public void accept(Integer integer) throws Exception {
                    Log.e(TAG, "accept: " + integer );
                }
            });

输出：

2019-11-06 20:45:36.801 13293-13293/com.example.rxjava_learn E/CombineActivity: accept: 1
2019-11-06 20:45:36.801 13293-13293/com.example.rxjava_learn E/CombineActivity: accept: 2
2019-11-06 20:45:36.802 13293-13293/com.example.rxjava_learn E/CombineActivity: accept: 3
2019-11-06 20:45:36.802 13293-13293/com.example.rxjava_learn E/CombineActivity: accept: 4
2019-11-06 20:45:36.802 13293-13293/com.example.rxjava_learn E/CombineActivity: accept: 5
2019-11-06 20:45:36.802 13293-13293/com.example.rxjava_learn E/CombineActivity: accept: 6

（六）异常处理操作符

异常处理操作符用于对异常进行处理。

1.onErrorReturn

onErrorReturn对被观察者发送到onError事件进行处理，观察者会在onNext只能够接收到处理结果。onErrorReturn接收到异常后，会中断被观察者的事件发送。

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

            @Override
            public void subscribe(ObservableEmitter<Integer> e) throws Exception {
                for (int i=0;i<5;i++){
                    if (i == 3){
                        e.onError(new IllegalArgumentException("发送异常!"));
                    }
                    e.onNext(i);
                }
            }
        }).onErrorReturn(new Function<Throwable, Integer>() {
            @Override
            public Integer apply(Throwable throwable) throws Exception {
                Log.e(TAG, "onErrorReturn: " + "处理异常");
                return 404;
            }
        })
                .subscribe(new Observer<Integer>() {
            @Override
            public void onSubscribe(Disposable d) {

            }

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

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

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

输出：

 2019-11-06 22:32:28.917 17394-17394/com.example.rxjava_learn E/ExceptionActivity: onNext: 0
    2019-11-06 22:32:28.917 17394-17394/com.example.rxjava_learn E/ExceptionActivity: onNext: 1
    2019-11-06 22:32:28.917 17394-17394/com.example.rxjava_learn E/ExceptionActivity: onNext: 2
    2019-11-06 22:32:28.917 17394-17394/com.example.rxjava_learn E/ExceptionActivity: onErrorReturn: 处理异常
    2019-11-06 22:32:28.918 17394-17394/com.example.rxjava_learn E/ExceptionActivity: onNext: 404
    2019-11-06 22:32:28.918 17394-17394/com.example.rxjava_learn E/ExceptionActivity: onComplete: 

2.onErrorResumeNext

onErrorResumeNext返回值为被观察者，在返回的被观察者中可以再次发送多个事件。

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

            @Override
            public void subscribe(ObservableEmitter<Integer> e) throws Exception {
                for (int i=0;i<5;i++){
                    if (i == 3){
                        e.onError(new IllegalArgumentException("发送异常!"));
                    }
                    e.onNext(i);
                }
            }
        }).onErrorResumeNext(new Function<Throwable, ObservableSource<? extends Integer>>() {
            @Override
            public ObservableSource<? extends Integer> apply(Throwable throwable) throws Exception {
                return Observable.just(404);
            }
        }).subscribe(new Observer<Integer>() {
                    @Override
                    public void onSubscribe(Disposable d) {

                    }

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

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

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

输出：

2019-11-06 22:35:43.686 17593-17593/com.example.rxjava_learn E/ExceptionActivity: onNext: 0
2019-11-06 22:35:43.686 17593-17593/com.example.rxjava_learn E/ExceptionActivity: onNext: 1
2019-11-06 22:35:43.686 17593-17593/com.example.rxjava_learn E/ExceptionActivity: onNext: 2
2019-11-06 22:35:43.687 17593-17593/com.example.rxjava_learn E/ExceptionActivity: onNext: 404
2019-11-06 22:35:43.687 17593-17593/com.example.rxjava_learn E/ExceptionActivity: onComplete: 

3.onExceptionResumeNext

onExceptionResumeNext可以处理通过throw抛出的异常，使程序不崩溃。

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

        @Override
        public void subscribe(ObservableEmitter<Integer> e) throws Exception {
            for (int i=0;i<5;i++){
                if (i == 3){
                    throw new IllegalArgumentException();
                }
                e.onNext(i);
            }
        }
    }).onExceptionResumeNext(new ObservableSource<Integer>() {
        @Override
        public void subscribe(Observer<? super Integer> observer) {
            observer.onNext(404);
        }
    }).subscribe(new Observer<Integer>() {
        @Override
        public void onSubscribe(Disposable d) {

        }

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

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

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

输出：

2019-11-06 22:51:02.833 18386-18386/com.example.rxjava_learn E/ExceptionActivity: onNext: 0
2019-11-06 22:51:02.833 18386-18386/com.example.rxjava_learn E/ExceptionActivity: onNext: 1
2019-11-06 22:51:02.833 18386-18386/com.example.rxjava_learn E/ExceptionActivity: onNext: 2
2019-11-06 22:51:02.833 18386-18386/com.example.rxjava_learn E/ExceptionActivity: onNext: 404

4.retry

被观察者发送onError事件后，retry可以进行重试操作。

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

        @Override
        public void subscribe(ObservableEmitter<Integer> e) throws Exception {
            for (int i=0;i<5;i++){
                if (i == 3){
                    e.onError(new IllegalArgumentException("发送异常!"));
                }
                e.onNext(i);
            }
        }
    }).retry(2).subscribe(new Observer<Integer>() {
        @Override
        public void onSubscribe(Disposable d) {

        }

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

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

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

输出：