Android-學習筆記-RxJava操作符(二)

5 錯誤處理
  • onErrorResumeNext( ) — 指示Observable在遇到錯誤時發射一個數據序列

  • onErrorReturn( ) — 指示Observable在遇到錯誤時發射一個特定的數據

  • onExceptionResumeNext( ) — 指示Observable遇到錯誤時繼續發射數據

  • retry( ) — 指示Observable遇到錯誤時重試。Retry操作符不會將原始Observable的onError通知傳遞給觀察者,Retry總是傳遞onNext通知給觀察者,由於重新訂閱,可能會造成數據項重複。

  • retryWhen() - 指示Observable遇到錯誤時,將錯誤傳遞給另一個Observable ,用另一個Observable來決定是否要重新訂閱這個Observable。

6 輔助操作
  • materialize( ) — 將Observable轉換成一個通知列表

  • dematerialize( ) — 將上面通知列表 逆轉回一個Observable

  • timestamp( ) — 給Observable發射的每個數據項添加一個時間戳

  • serialize( ) — 強制Observable按次序發射數據並且要求功能是完好的

  • cache( ) — 記住Observable發射的數據序列併發射相同的數據序列給後續的訂閱者

  • subscribeOn( ) — 指定Observable執行任務的調度器

  • observeOn( ) — 指定觀察者觀察Observable的調度器

  • Do — 註冊一個動作 作爲原始Observable生命週期事件中的一種佔位符
    doOnSubscribe( ) — 註冊一個動作,在觀察者訂閱時使用,
    使用場景:可以在事件發出之前做一些初始化的工作,比如彈出進度條等等
    注意:doOnSubscribe( ) 默認運行在事件產生的線程裏面,如果事件產生的線程是 io 線程,
    則需要在 doOnSubscribe( )後面 subscribeOn(AndroidSchedulers.mainThread()) 指定線程。

    doOnEach( ) — 註冊一個動作,對Observable發射的每個數據項使用
    doOnNext() — 註冊一個動作,在每次OnNext()方法被調用前執行,
    使用場景:從網絡請求數據,在數據被展示前,緩存到本地

    doOnCompleted( ) — 註冊一個動作,對正常完成的Observable使用
    doOnError( ) — 註冊一個動作,對發生錯誤的Observable使用
    doOnTerminate( ) — 註冊一個動作,對完成的Observable使用,無論是否發生錯誤

  • delay( ) — 延時發射Observable的結果 。

  • delaySubscription( ) — 延時處理訂閱請求。

  • timeInterval( ) — 定期發射數據

  • Timeout() — 如果過了指定的一段時間沒有發射數據,則發射錯誤通知 。(超時)

  • using( ) — 創建一個只在Observable生命週期存在的資源

  • singleElement() — 強制返回單個數據,否則拋出異常
    single(defaultItem) — 如果Observable完成時返回了單個數據,就返回它,否則返回默認數據
    singleOrError

  • To — 將Observable轉換爲其它對象或數據結構
    toFuture( ), toIterable( ), toList( ) ,toSortedList(),toMap(),toMultiMap(),nest()

6.1 舉例

         Observable<String> observable = Observable.just("1", "2", "3", "4", "5", "6");
         observable
//                 //.delay( 3 , TimeUnit.SECONDS )        //延遲發射
//                 //.delaySubscription(3 , TimeUnit.SECONDS) //延時訂閱

                .doOnSubscribe(new Consumer<Disposable>() {
                    @Override
                    public void accept(Disposable disposable) throws Exception {
                        System.out.println("doOnSubscribe");
                    }
                })

                .doOnEach(new Consumer<Notification<String>>() {
                    @Override
                    public void accept(Notification<String> stringNotification) throws Exception {
                        System.out.println("doOnEach ---" + stringNotification.toString());
                    }
                })

                .doOnNext(new Consumer<String>() {
                    @Override
                    public void accept(String s) throws Exception {
                        System.out.println("doOnNext ====" + s);
                    }
                })
                
                .doOnComplete(new Action() {
                    @Override
                    public void run() throws Exception {
                        System.out.println("doOnComplete");

                    }
                })
                .doOnError(new Consumer<Throwable>() {
                    @Override
                    public void accept(Throwable throwable) throws Exception {
                        System.out.println("doOnError");
                    }
                })
                .doOnTerminate(new Action() {
                    @Override
                    public void run() throws Exception {
                        System.out.println("doOnTerminate");
                    }
                })

                .subscribe(x -> System.out.println("next = " + x),
                        error -> System.out.println("error =" + error),
                        () -> System.out.println("complete")
                );

7 條件操作符
  • amb() — 給定多個Observable,只讓第一個發射數據的Observable發射全部數據

  • defaultIfEmpty() — 發射來自原始Observable的數據,如果原始Observable沒有發射數據,就發射一個默認數據

  • takeUntil() — 1 takeUntil(Observable)) 發射來自原始Observable的數據,直到第二個Observable發射了一個數據或一個通知。(原始Observable剩餘的數據就不在發射)。2 takeUntil(Func1)),使用一個謂詞函數來判定是否需要終止發射數據,直到指定的條件成立 ,剩餘的就不再發射。

  • takeWhile() — 根據指定條件,發射Observable數據,直到指定的條件不成立。
    指定條件爲ture,就發射,一旦爲false,就不再發射

  • skipUntil() — 丟棄原始Observable發射的數據,直到第二個Observable發射了一個數據,然後發射原始Observable 所有剩餘的數據

  • skipWhile() — 根據指定條件,丟棄Observable發射的數據,直到指定的條件不成立,它開始發射剩下原始數據。
    指定條件爲ture,就丟棄,一旦爲false,就發射

7.1 舉例
takeUntil,skipUntil 還有點蒙

        Observable.range(1, 9)
//                .takeWhile(new Predicate<Integer>() {
//                    @Override
//                    public boolean test(Integer integer) throws Exception {
//                        System.out.println("takeWhile = " + integer.toString());
//                        return integer.intValue() < 5;
//                    }
//                })
//                .takeUntil(new Predicate<Integer>() {
//                    @Override
//                    public boolean test(Integer integer) throws Exception {
//                        System.out.println("takeUntil = " + integer.toString());
//                        System.out.println("takeUntil = " + (integer.intValue() > 5));
//                        return integer.intValue() > 5;
//                    }
//                })

//                .skipWhile(new Predicate<Integer>() {
//                    @Override
//                    public boolean test(Integer integer) throws Exception {
//                        System.out.println("skipWhile = "+integer.toString());
//                        System.out.println("skipWhile = "+(integer.intValue() < 5));
//                       // 5<5  false
//                        return integer.intValue() < 5;
//                    }
//                })
             
                .subscribe(x -> System.out.println("next = " + x),
                        error -> System.out.println("error =" + error),
                        () -> System.out.println("complete")
                );
       Observable observable1 = Observable.create(emitter ->
                {
                    //產生結果的間隔時間分別爲300毫秒
                    for (int i = 61; i < 71; i++) {
                        Thread.sleep(300);
                        System.out.println(" ---->發射: " + i);
                        emitter.onNext(i);

                    }
                    emitter.onComplete();
                }
        );

        Observable observable2 =   Observable.create(new ObservableOnSubscribe<String>() {

            @Override
            public void subscribe(ObservableEmitter<String> emitter) throws Exception {
                for (int i = 1; i < 31; i++) {

                    Thread.sleep(100L);
                    System.out.println("---->發射: " + i);
                    emitter.onNext("===>" + i);
                }
                emitter.onComplete();
            }
        });

        observable1
                  .takeUntil(observable2)
                //.skipUntil(observable2)
		          .subscribe(x -> System.out.println("next = " + x),
		                        error -> System.out.println("error =" + error),
		                        () -> System.out.println("complete")
		                );


8 布爾操作符
  • all( ) — 判斷是否所有的數據項都滿足某個條件
  • contains( ) — 判斷Observable是否會發射一個指定的值
  • isEmpty( ) — 判斷Observable是否發射了一個值
  • sequenceEqual( ) — 判斷兩個Observables發射的序列是否相等
9 算術和聚合操作
  • average()(平均值) — 計算Observable發射的數據序列的平均值,然後發射這個結果

  • sum() — 計算併發射數據序列的和

  • max() — 計算併發射數據序列的最大值

  • min() — 計算併發射數據序列的最小值

  • count() — 計算Observable發射的數據個數,並只發送此值

  • concat() — 不交錯的連接多個Observable的數據

10 連接操作
  • connect()(連接) — 指示可連接的Observable開始發送數據給訂閱者

  • publish() — 將普通(Cold)的Observable轉換爲可連接(Hot)的Observable

  • refCount() — 使一個可連接的Observable表現得像一個普通的Observable

  • replay() — 確保所有的觀察者收到同樣的數據序列,即使他們在Observable開始發射數據之後才訂閱

發表評論
所有評論
還沒有人評論,想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章