RxJava学习笔记操作符学习（4）

作者: 西红柿的眼泪 | 来源:发表于2018-08-22 16:41 被阅读0次

组合 / 合并操作符

作用

组合多个被观察者（Observable） & 合并需要发送的事件

常见类型

常见类型.png

.应用场景 & 对应操作符介绍

concat（） / concatArray（）
作用
组合多个被观察者一起发送数据，合并后按发送顺序串行执行。
二者区别：组合被观察者的数量，即concat（）组合被观察者数量≤4个，而concatArray（）则可＞4个。
事例：

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

                    }

                    @Override
                    public void onNext(String s) {
                        Log.e("sss", "接收到了事件"+ s);
                    }

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

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

2.merge（） / mergeArray（）
作用
组合多个被观察者一起发送数据，合并后按时间线并行执行。
二者区别：组合被观察者的数量，即merge（）组合被观察者数量≤4个，而mergeArray（）则可＞4个。
区别上述的concat（） / concatArray（）操作符：同样是组合多个被观察者一起发送数据，但concat（） / concatArray（）操作符合并后是按发送顺序串行执行。
事例

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

                    }

                    @Override
                    public void onNext(Long aLong) {
                        Log.e("sss", "接收到了事件"+ aLong);
                    }

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

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

concatDelayError（） / mergeDelayError（）
作用

示意图.png

事例

 Observable.concatArrayDelayError(Observable.create(new ObservableOnSubscribe<Integer>() {
                    @Override
                    public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
                        emitter.onNext(1);
                        emitter.onNext(2);
                        emitter.onNext(3);
                        emitter.onError(new Throwable());
                    }
                }),
                Observable.just(4,5,6))
                .subscribe(new Observer<Integer>() {
                    @Override
                    public void onSubscribe(Disposable d) {

                    }

                    @Override
                    public void onNext(Integer integer) {
                        Log.e("sss", "接收到了事件"+ integer);
                    }

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

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

4.Zip（）
作用
合并多个被观察者（Observable）发送的事件，生成一个新的事件序列（即组合过后的事件序列），并最终发送。
事件组合方式 = 严格按照原先事件序列进行对位合并；最终合并的事件数量 = 多个被观察者（Observable）中数量最少的数量。

image.png

事例

 public void ZipOperators(View view) {
        Observable<Integer> observable1 = Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
                Log.e("sss", "被观察者1发送了事件1");
                emitter.onNext(1);
                Thread.sleep(1000);
                Log.e("sss", "被观察者1发送了事件2");
                emitter.onNext(2);
                Thread.sleep(1000);
                Log.e("sss", "被观察者1发送了事件3");
                emitter.onNext(3);
                Thread.sleep(1000);
                emitter.onComplete();
            }
        }).subscribeOn(Schedulers.io());
        Observable<String> observable2 = Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(ObservableEmitter<String> emitter) throws Exception {
                Log.e("sss", "被观察者2发送了事件1");
                emitter.onNext("A");
                Thread.sleep(3000);
                Log.e("sss", "被观察者2发送了事件2");
                emitter.onNext("B");
                Thread.sleep(3000);
                Log.e("sss", "被观察者2发送了事件3");
                emitter.onNext("C");
                Thread.sleep(3000);
                emitter.onComplete();
            }
        }).subscribeOn(Schedulers.io());

        Observable.zip(observable1, observable2, new BiFunction<Integer, String, String>() {

            @Override
            public String apply(Integer integer, String s) throws Exception {
                return integer + s;
            }
        }).subscribe(new Observer<String>() {
            @Override
            public void onSubscribe(Disposable d) {

            }

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

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

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

5.combineLatest（）
作用
当两个Observables中的任何一个发送了数据后，将先发送了数据的Observables 的最新（最后）一个数据与另外一个Observable发送的每个数据结合，最终基于该函数的结果发送数据。
与Zip（）的区别：Zip（） = 按个数合并，即1对1合并；CombineLatest（） = 按时间合并，即在同一个时间点上合并。
事例

 public void combineLatestOperators(View view){
        
        Observable.combineLatest(Observable.just(1L, 2L, 3L),
                Observable.intervalRange(0, 3, 1, 1, TimeUnit.SECONDS),
                new BiFunction<Long, Long, Long>() {
                    @Override
                    public Long apply(Long aLong, Long aLong2) throws Exception {
                        // aLong = 第1个Observable发送的最新（最后）1个数据
                        // aLong2 = 第2个Observable发送的每1个数据
                        Log.e("sss", "合并的数据是： "+ aLong + " "+ aLong2);
                        return aLong+aLong2;
                    }
                }).subscribe(new Consumer<Long>() {
            @Override
            public void accept(Long aLong) throws Exception {
                Log.e("sss", "合并的结果是： "+aLong);
            }
        });
    }

6.combineLatestDelayError（）
作用
类似于concatDelayError（） / mergeDelayError（），即错误处理，此处不作过多描述。
7.reduce（）
作用
把被观察者需要发送的事件聚合成1个事件 & 发送，聚合的逻辑根据需求撰写，但本质都是前2个数据聚合，然后与后1个数据继续进行聚合，依次类推。
事例

public void reduceOperators(View view){
        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("sss", "最终计算的结果是： "+integer);
            }
        });
    }

8.collect（）
作用
将被观察者Observable发送的数据事件收集到一个数据结构里。
事例

public void collectOperators(View view){
        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> integers, Integer integer) throws Exception {
                        integers.add(integer);
                    }
                }).subscribe(new Consumer<ArrayList<Integer>>() {
            @Override
            public void accept(ArrayList<Integer> integers) throws Exception {
                Log.e("sss","本次发送的数据是： "+integers);
            }
        });
    }

9.startWith（） / startWithArray（）
作用
在一个被观察者发送事件前，追加发送一些数据 / 一个新的被观察者。
事例

public void startOperators(View view){
        Observable.just(7,8,9)
                .startWith(6)
                .startWithArray(1,2,3)
                .subscribe(new Observer<Integer>() {
                    @Override
                    public void onSubscribe(Disposable d) {

                    }

                    @Override
                    public void onNext(Integer integer) {
                        Log.e("sss", "接收到了事件"+ integer );
                    }

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

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

count（）
作用
统计被观察者发送事件的数量。
事例

public void countOperators(View view){
        Observable.just(1,2,3,4)
                .count()
                .subscribe(new Consumer<Long>() {
                    @Override
                    public void accept(Long aLong) throws Exception {
                      Log.e("sss","接受的数量为"+aLong);
                    }
                });
    }

11总结

i总结.png

实际开发中的应用

1.合并数据源展示
merge的使用

String result = "数据源来自 = " ;
    public void combineDataOperators(View view){


        Observable<String> observable1=Observable.just("网络");

        Observable<String> observable2=Observable.just("本地");

        Observable.merge(observable1,observable2)
                .subscribe(new Observer<String>() {
                    @Override
                    public void onSubscribe(Disposable d) {

                    }

                    @Override
                    public void onNext(String s) {
                        Log.e("sss", "数据源有： "+ s  );
                        result += s + "+";
                    }

                    @Override
                    public void onError(Throwable e) {

                    }

                    @Override
                    public void onComplete() {
                        Log.e("sss", "获取数据完成");
                        Log.e("sss",  result  );
                    }
                });
    }

zip的使用

public void togetherOperators(View view){
        Retrofit retrofit=new Retrofit.Builder()
                .baseUrl("http://fy.iciba.com/")
                .addConverterFactory(GsonConverterFactory.create())
                .addCallAdapterFactory(RxJava2CallAdapterFactory.create())
                .build();

        GetRequest_Interface getRequest_interface=retrofit.create(GetRequest_Interface.class);

        Observable<Translation> observable1=getRequest_interface.getCall_1().subscribeOn(Schedulers.io());
        Observable<Translation> observable2=getRequest_interface.getCall_2().subscribeOn(Schedulers.io());


        Observable.zip(observable1, observable2, new BiFunction<Translation, Translation, String>() {
            @Override
            public String apply(Translation translation, Translation translation2) throws Exception {
                return translation.getContent().getOut()+translation2.getContent().getOut();
            }
        }).observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Consumer<String>() {
                    @Override
                    public void accept(String s) throws Exception {
                        Log.e("sss","接受到的数据"+s);
                    }
                }, new Consumer<Throwable>() {
                    @Override
                    public void accept(Throwable throwable) throws Exception {

                    }
                });

    }

2.从磁盘 / 内存缓存中获取缓存数据

 public void CacheOperators(View view){
        final String memoryCache=null;
        final String diskCache="从磁盘中获取上数据";
        Observable<String> memory=Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(ObservableEmitter<String> emitter) throws Exception {
                if (memoryCache!=null){
                    emitter.onNext(memoryCache);
                }else {
                    emitter.onComplete();
                }
            }
        });
        Observable<String> disk=Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(ObservableEmitter<String> emitter) throws Exception {
                if (diskCache!=null){
                    emitter.onNext(diskCache);
                }else {
                    emitter.onComplete();
                }
            }
        });
        Observable<String> netWork=Observable.just("从网络获取");
        Observable.concat(memory,disk,netWork)
                // 通过firstElement()，从串联队列中取出并发送第1个有效事件（Next事件），即依次判断检查memory、disk、network
                // a. firstElement()取出第1个事件 = memory，即先判断内存缓存中有无数据缓存；由于memoryCache = null，即内存缓存中无数据，所以发送结束事件（视为无效事件）
                // b. firstElement()继续取出第2个事件 = disk，即判断磁盘缓存中有无数据缓存：由于diskCache ≠ null，即磁盘缓存中有数据，所以发送Next事件（有效事件）
                // c. 即firstElement()已发出第1个有效事件（disk事件），所以停止判断。
                .firstElement()
                .subscribe(new Consumer<String>() {
                    @Override
                    public void accept(String s) throws Exception {
                        Log.e("sss","最终获取的数据来源 =  "+ s);
                    }
                });
        
    }

3.联合判断多个事件
与RxBinding联合使用


        final EditText name,pwd,verification ;
        final Button list;

        name=findViewById(R.id.name);
        pwd=findViewById(R.id.pwd);
        verification=findViewById(R.id.verification);

        list=findViewById(R.id.list);

        Observable<CharSequence> nameObservable= RxTextView.textChanges(name).skip(1);
        Observable<CharSequence> pwdObservable= RxTextView.textChanges(pwd).skip(1);
        Observable<CharSequence> verificationObservable= RxTextView.textChanges(verification).skip(1);

        Observable.combineLatest(nameObservable, pwdObservable, verificationObservable, new Function3<CharSequence, CharSequence, CharSequence, Boolean>() {
            @Override
            public Boolean apply(CharSequence charSequence, CharSequence charSequence2, CharSequence charSequence3) throws Exception {


                boolean isUserNameValid = !TextUtils.isEmpty(name.getText()) ;
                // 除了设置为空，也可设置长度限制
                // boolean isUserNameValid = !TextUtils.isEmpty(name.getText()) && (name.getText().toString().length() > 2 && name.getText().toString().length() < 9);

                boolean isUserPwdValid = !TextUtils.isEmpty(pwd.getText());
                boolean isUserVerValid = !TextUtils.isEmpty(verification.getText()) ;
                return isUserNameValid&isUserPwdValid&isUserVerValid;
            }
        }).subscribe(new Consumer<Boolean>() {
            @Override
            public void accept(Boolean aBoolean) throws Exception {
                list.setEnabled(aBoolean);
            }
        });

RxJava学习笔记操作符学习（4）

组合 / 合并操作符

作用

常见类型

.应用场景 & 对应操作符介绍

实际开发中的应用

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读