天天日天天操,亚洲精品国产成人,瑜伽裤透明全毛露丁字裤

組合 / 合并操作符

作用

組合多個被觀察者（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）

RxJava學習筆記操作符學習（4）

組合 / 合并操作符

作用

常見類型

.應用場景 & 對應操作符介紹

實際開發中的應用

推薦閱讀更多精彩內容

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美 国产 综合 欧美 视频

RxJava學習筆記操作符學習（4）

組合 / 合并操作符

作用

常見類型

.應用場景 & 對應操作符介紹

實際開發中的應用

推薦閱讀更多精彩內容

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美国产综合欧美视频