RxJava 学习笔记总结(一)

1、合并操作符
zip

操作符是把多个可观察的管道来合并消息到一条管道来处理，并可以对合并的消息进行格式处理，总的消息数量由最少的那一条管道决定。常见的运用场景比如一个消息页面需要用到两台服务器的查询请求，这样我们就需要通过查询两个接口来合并数据最后渲染UI。

Observable<Integer> observable1 = new Observable<Integer>() {
            @Override
            protected void subscribeActual(Observer<? super Integer> observer) {
                Log.e("observable1--->", "0");
                observer.onNext(0);
                Log.e("observable1--->", "1");
                observer.onNext(1);
                Log.e("observable1--->", "2");
                observer.onNext(2);
                Log.e("observable1--->", "3");
                observer.onNext(3);
                Log.e("observable1--->", "onComplete");
                observer.onComplete();
            }
        };
        Observable<String> observable2 = new Observable<String>() {
            @Override
            protected void subscribeActual(Observer<? super String> observer) {
                Log.e("observable2--->", "a");
                observer.onNext("a");
                Log.e("observable2--->", "b");
                observer.onNext("b");
                Log.e("observable2--->", "c");
                observer.onNext("c");
                Log.e("observable2--->", "d");
                observer.onNext("d");
                Log.e("observable2--->", "e");
                observer.onNext("e");
                Log.e("observable2--->", "f");
                observer.onNext("f");
                Log.e("observable2--->", "onComplete");
                observer.onComplete();
            }
        };
        Observable.zip(observable1, observable2, new BiFunction<Integer, String, String>() {
            @Override
            public String apply(Integer integer, String s) throws Exception {
                return "下标为：" + integer + "，内容为：" + s;
            }
        }).subscribe(new Consumer<String>() {
            @Override
            public void accept(String s) throws Exception {
                Log.e("subscribe--->", s);
            }
        });

输出控制台

E/observable1--->: 0
E/observable1--->: 1
E/observable1--->: 2
E/observable1--->: 3
E/observable1--->: onComplete
E/observable2--->: a
E/subscribe--->: 下标为：0，内容为：a
E/observable2--->: b
E/subscribe--->: 下标为：1，内容为：b
E/observable2--->: c
E/subscribe--->: 下标为：2，内容为：c
E/observable2--->: d
E/subscribe--->: 下标为：3，内容为：d
E/observable2--->: e
E/observable2--->: f
E/observable2--->: onComplete

concat

操作符是把多个可观察的管道串行合并，事件不为空，则结束，后续的事件不再处理，通常配合 firstElement 操作符一起出现，firstElement 的作用是按照顺序依次分发事件，常用的场景比如加载图片，先查缓存再查磁盘最后请求网络数据加载，即三个判断三个 Observable 通过 concat 去合并，当其中一个不为空就立即采用，下面的不再分发处理。

String memoryCache = null;
        String diskCache = "123";
        String netCache = null;
        Observable ob1 = Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(ObservableEmitter<String> emitter) throws Exception {
                if (TextUtils.isEmpty(memoryCache)) {
                    Log.e(TAG, "没有内存缓存");
                    emitter.onComplete();
                } else {
                    emitter.onNext("内存缓存");
                }
            }
        });
        Observable ob2 = Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(ObservableEmitter<String> emitter) throws Exception {
                if (TextUtils.isEmpty(diskCache)) {
                    Log.e(TAG, "没有磁盘缓存");
                    emitter.onComplete();
                } else {
                    emitter.onNext("磁盘缓存");
                }
            }
        });
        Observable ob3 = Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(ObservableEmitter<String> emitter) throws Exception {
                if (TextUtils.isEmpty(netCache)) {
                    Log.e(TAG, "网络缓存");
                    emitter.onComplete();
                } else {
                    emitter.onNext("网络缓存");
                }
            }
        });
        Observable.concat(ob1, ob2, ob3)
                .firstElement()
                .subscribe(new Consumer<String>() {
                    @Override
                    public void accept(String o) throws Exception {
                        toast(o);
                    }
                });

控制台输出

E/RxJavaActivity: 没有内存缓存

merge

操作符是把两个管道的事件合并到一条管道串行分发，执行分发顺序和参数摆放顺序有关。说实话这个操作符它能用在什么地方我没有具体的运用场景，可以试想一下，假设一个页面的数据需要请求多个接口然后再统一渲染，如果他们的返回值不同，那么我们在 merge 里处理的返回值必须为 Object 再去判断其类型，而且这样做还有一个严重的Bug，那就是假设返回了 null，我们无法判断是哪个接口返回空，假设需求返回的数据类型是一致的，然后我们需要在一个页面请求两个接口来合并处理它，感觉这个操作符能够运用的场景比较极端，适合那种一个整体的数据需要从两个接口去请求并且还要保证顺序。

Observable netOb = Observable.just(123);
        Observable cacheOb = Observable.just(456);
        Observable.merge(cacheOb, netOb).subscribe(new Consumer<Integer>() {
            @Override
            public void accept(Integer o) throws Exception {
                Log.e(TAG, String.valueOf(o));
            }
        });

控制台输出

E/RxJavaActivity: 456
E/RxJavaActivity: 123

combineLatest

操作符把多个管道的事件合并到一条管道来分发，看起来和上面的 zip 操作符差不多，其实差别在于它分发的事件数量取决于最后一条管道事件的数据且只会合并前面管道的最后一个事件，所有管道最少有一个事件才能分发，描述比较晦涩难懂，直接看例子。

Observable ob1 = Observable.just(1, 2, 3, 4, 5, 6, 7, 8, 9);
        Observable ob2 = Observable.just("a", "b", "c", "d");
        Observable ob3 = Observable.just("一", "二", "三", "四", "五");
        Observable.combineLatest(ob3, ob2, ob1, new Function3<String, String, Integer, String>() {
            @Override
            public String apply(String s, String s2, Integer integer) throws Exception {
                return "s=" + s + " s2=" + s2 + " integer=" + integer;
            }
        }).subscribe(new Consumer<String>() {
            @Override
            public void accept(String result) throws Exception {
                Log.e(TAG, result);
            }
        });

控制台输出

E/RxJavaActivity: s=五 s2=d integer=1
E/RxJavaActivity: s=五 s2=d integer=2
E/RxJavaActivity: s=五 s2=d integer=3
E/RxJavaActivity: s=五 s2=d integer=4
E/RxJavaActivity: s=五 s2=d integer=5
E/RxJavaActivity: s=五 s2=d integer=6
E/RxJavaActivity: s=五 s2=d integer=7
E/RxJavaActivity: s=五 s2=d integer=8
E/RxJavaActivity: s=五 s2=d integer=9