part05_Rxjava操作符

weixin_34365417發表於2018-08-30

作者：IT魔幻師
部落格：www.huyingzi.top
轉載請註明出處：https://www.jianshu.com/p/afeba5aea533

一、建立型操作符

主要用於建立被觀察者

just
create的快捷建立操作,create操作符必須手動呼叫onNext才能觸發事件,just會自動觸發

@Test
 public void testjust() {
     //just是create的快捷建立操作
     Observable.just("我是你爸爸","我是你爸爸2").subscribe(new Observer<String>() {
         @Override
         public void onSubscribe(Disposable d) {
         }

         @Override
         public void onNext(String s) {
             //此處會依次收到just引數傳遞過來的值
         }

         @Override
         public void onError(Throwable e) {

         }

         @Override
         public void onComplete() {

         }
     });
 }

fromArray
相比於just,fromArray適用於多引數的情況.

  @Test
  public void testFromArray() {
      Observable.fromArray(new String[]{"我是你爸爸",
              "我是你爸爸2",
              "我是你爸爸3",
              "我是你爸爸4"}).subscribe(new Observer<String>() {
          @Override
          public void onSubscribe(Disposable d) {
          }

          @Override
          public void onNext(String s) {
              System.out.println("onNext  "+s);
          }

          @Override
          public void onError(Throwable e) {
          }

          @Override
          public void onComplete() {
          }
      });
  }

range
建立在一定範圍內的事件

@Test
  public void testRange() {
      //從5開始執行11次事件
      Observable.range(5,11).subscribe(new Observer<Integer>() {
          @Override
          public void onSubscribe(Disposable d) {
          }
          @Override
          public void onNext(Integer integer) {
              System.out.println(integer);
          }
          @Override
          public void onError(Throwable e) {
          }
          @Override
          public void onComplete() {
          }
      });
  }

empty
主要適用於呼叫後不需要返回引數只需要關心結果,如:發起網路請求後在onComplete()中處理結果即可他不會回撥onNext函式.


  @Test
  public void testempty() {
      Observable.empty().subscribe(new Observer<Object>() {
          @Override
          public void onSubscribe(Disposable d) {
          }

          @Override
          public void onNext(Object o) {
          }

          @Override
          public void onError(Throwable e) {
          }

          @Override
          public void onComplete() {
              System.out.println("執行結束");
          }
      });
  }

interval
定時器操作符,需要依賴Android的api不能在純java環境下使用

//每隔1單位秒的時間執行一次
Observable.interval(1, TimeUnit.SECONDS);

intervalRange
定時器操作符,需要依賴Android的api不能在純java環境下使用

 //從0開始每隔1000毫秒傳送50個事件  初始延時0
      Observable.intervalRange(0,50,0,1000, TimeUnit.MILLISECONDS).subscribe(new Consumer<Long>() {
          @Override
          public void accept(Long aLong) throws Exception {
              System.out.println(aLong);
          }
      });

timer
跟interval一樣.

二、轉換操作符

將事件型別轉換成我們想要的結果

map

 @Test
  public void testMap() {
      //場景:根據圖片地址最終轉換成bitmap
      Observable.just("icon01.png","icon02.png").map(new Function<String, Bitmap>() {
          @Override
          public Bitmap apply(String url) throws Exception {
              //在此次模擬執行網路請求等操作
              // ...  此處省略
              Bitmap mBitmap = Bitmap.createBitmap(200,200, Bitmap.Config.ARGB_8888);
              return mBitmap;
              
          }
      }).subscribe(new Observer<Bitmap>() {
          @Override
          public void onSubscribe(Disposable d) {
              
          }

          @Override
          public void onNext(Bitmap bitmap) {
              //在此次就可以 以此得到請求到的圖片 
              System.out.println("得到結果:"+bitmap);
          }

          @Override
          public void onError(Throwable e) {

          }

          @Override
          public void onComplete() {

          }
      });
  }

flatMap
在上一個事件完成後才能開始下一個事件的情況

@Test
  public void testFlatMap() {
      //比如:token過期了 必須先請求一個token 再進行登入請求
      Observable.just("getToken","login").flatMap(new Function<String, ObservableSource<?>>() {
          @Override
          public ObservableSource<?> apply(String s) throws Exception {
              System.out.println("執行事件:"+s);
              return createRespone(s);
          }
      }).subscribe(new Observer<Object>() {
          @Override
          public void onSubscribe(Disposable d) {
          }

          @Override
          public void onNext(Object o) {
              //依次回撥處理結果
              System.out.println(o);

          }

          @Override
          public void onError(Throwable e) {
          }

          @Override
          public void onComplete() {
          }
      });

  }

  private ObservableSource<?> createRespone(final String s) {
      //根據請求再建立一個被觀察者,觀察上一個請求是否成功了
      return Observable.create(new ObservableOnSubscribe<String>() {
          @Override
          public void subscribe(ObservableEmitter<String> emitter) throws Exception {
              System.out.println("上一個事件已經執行完成開始執行此事件:"+s);
              //此處是基於getToken完成之後才會執行
              emitter.onNext(s);
          }
      });
  }

groupBy
對傳入的事件進行分組,分組的條件可以自己指定

@Test
  public void testGroupBy() {
      Observable.just(1,2,3,4).groupBy(new Function<Integer, String>() {
          @Override
          public String apply(Integer integer) throws Exception {
              return integer>2?"A組":"B組";
          }
      }).subscribe(new Consumer<GroupedObservable<String, Integer>>() {
          @Override
          public void accept(final GroupedObservable<String, Integer> stringIntegerGroupedObservable)
                  throws Exception {
              //stringIntegerGroupedObservable 是一個分組後的被觀察者
              stringIntegerGroupedObservable.subscribe(new Consumer<Integer>() {
                  @Override
                  public void accept(Integer integer) throws Exception {
                      String key = stringIntegerGroupedObservable.getKey();
                      System.out.println("key="+key+" "+integer);
                  }
              });
          }
      });
  }

buffer
大批量資料需要處理的時候,對其進行分批次處理

 @Test
  public void testBuffer() {
      //將6條資料每2條分一個組執行
      Observable.just(1,2,3,4,5,6).buffer(2).subscribe(new Observer<List<Integer>>() {
          @Override
          public void onSubscribe(Disposable d) {

          }

          @Override
          public void onNext(List<Integer> integers) {
              //以此回撥每個組的資料
              System.out.println(integers);
          }

          @Override
          public void onError(Throwable e) {

          }

          @Override
          public void onComplete() {

          }
      });
  }

range
上一個結果作為下一個引數,所有的結果累加得到最終結果,檔案合併或者字串拼接等場景.

  @Test
  public void testScan() {
      Observable.range(1,5).scan(new BiFunction<Integer, Integer, Integer>() {
          @Override
          public Integer apply(Integer integer, Integer integer2) throws Exception {
              //第一個引數integer為之前所有結果的和  就是累加的形式
              //相當於 第一個檔案跟第二個檔案合併,合併後的結果跟第三個檔案合併...最終合併成一個大檔案
              return integer+integer2;
          }
      }).subscribe(new Observer<Integer>() {
          @Override
          public void onSubscribe(Disposable d) {

          }

          @Override
          public void onNext(Integer integer) {
              System.out.println(integer);
          }

          @Override
          public void onError(Throwable e) {

          }

          @Override
          public void onComplete() {

          }
      });
  }

三、過濾操作符

filter
對事件進行過濾或者不過濾的處理

@Test
  public void testFilter() {
      Observable.just(1,2,3,4,5,6).filter(new Predicate<Integer>() {
          @Override
          public boolean test(Integer integer) throws Exception {
              //此次決定是否過濾
              //true 不過濾
              //false 過濾掉不計入結果中
              return integer>2;
          }
      }).subscribe(new Observer<Integer>() {
          @Override
          public void onSubscribe(Disposable d) {

          }

          @Override
          public void onNext(Integer integer) {
              //接受過濾後的結果 
              System.out.println(integer);
          }

          @Override
          public void onError(Throwable e) {

          }

          @Override
          public void onComplete() {

          }
      });
  }

take
限制產生事件的數量

    @Test
  public void testTake() {
      //每隔1單位秒的時間執行一次 take限制只執行5次
      Observable.interval(1, TimeUnit.SECONDS).take(5).subscribe(new Observer<Long>() {
          @Override
          public void onSubscribe(Disposable d) {
          }

          @Override
          public void onNext(Long aLong) {
              System.out.println(aLong+"");
              
          }

          @Override
          public void onError(Throwable e) {
          }

          @Override
          public void onComplete() {
          }
      });
  }

distinct
過濾重複事件

    @Test
  public void testDistinct() {
      Observable.just(1,2,2,2,3,3,6,6,7).distinct().subscribe(new Observer<Integer>() {
          @Override
          public void onSubscribe(Disposable d) {
          }

          @Override
          public void onNext(Integer integer) {
              System.out.println(integer);
          }

          @Override
          public void onError(Throwable e) {
          }

          @Override
          public void onComplete() {
          }
      });
  }

elementAt
過濾指定的事件

      //指定過慮出第5個事件
      Observable.just(1,2,2,2,3,3,6,6,7).elementAt(5).subscribe(new Consumer<Integer>() {
          @Override
          public void accept(Integer integer) throws Exception {
              System.out.println(integer);
          }
      });

四、條件操作符

all
判斷所有事件是否滿足一個條件，如果全部滿足則為true

 Observable.just(1,2,3,4,5,6).all(new Predicate<Integer>() {
          @Override
          public boolean test(Integer integer) throws Exception {
              //所有的事件都大於2嗎
              return integer>2;
          }
      }).subscribe(new Consumer<Boolean>() {
          @Override
          public void accept(Boolean aBoolean) throws Exception {
              //此次返回時間結果
              System.out.println(aBoolean);
          }
      });

contains
判斷所有事件中是否包含某項事件

 Observable.just(1,2,3,4,5).contains(3).subscribe(new Consumer<Boolean>() {
         @Override
         public void accept(Boolean aBoolean) throws Exception {
             //此處返回是否包含3的結果
             System.out.println(aBoolean);
         }
     });

any
所有事件中只要有有一個符合條件即為true

Observable.just(1,2,3,4,5).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 {
              System.out.println(aBoolean);
          }
      });

isEmpty
判斷一個觀察者是否有事件

 Observable.just(1).isEmpty().subscribe(new Consumer<Boolean>() {
          @Override
          public void accept(Boolean aBoolean) throws Exception {
              //有事件返回true  空事件返回false
              System.out.println(aBoolean);
          }
      });

defaultIfEmpty
如果被觀察者不傳送任何事件，則會傳送預設事件
```
.defaultIfEmpty(0)
```

skipWhile
跳過滿足條件的事件

         //從0開始每隔1000毫秒傳送50個事件  初始延時0  
        Observable.intervalRange(0,50,0,1000, TimeUnit.MILLISECONDS).skipWhile(new Predicate<Long>() {
          @Override
          public boolean test(Long aLong) throws Exception {
              //跳過<10的事件
              return aLong<10;
          }
      }).subscribe(new Consumer<Long>() {
          @Override
          public void accept(Long aLong) throws Exception {
              System.out.println(aLong);
          }
      });

五、合併操作符

將被觀察者進行合併

startWith
把需要的事件合併成一個事件進行處理,會先處理startWith新增的事件

        //把需要的事件合併成一個事件進行處理,會先處理2，4，6，8的事件
      Observable.just(1,3,5,7).startWith(Observable.just(2,4,6,8))
      .subscribe(new Consumer<Integer>() {
          @Override
          public void accept(Integer integer) throws Exception {
              System.out.println(integer);
          }
      });

concat
合併最多4個事件以先來後到的順序進行處理，跟startWith相反。

        //合併兩個事件 123 會優先處理
      Observable.concat(
              Observable.just(1,2,3),
              Observable.just(4,5,6))
      .subscribe(new Consumer<Integer>() {
          @Override
          public void accept(Integer integer) throws Exception {
              System.out.println(integer);
          }
      });

merge
merge合併多個被觀察者，合併之後按照時間順序並行執行

        Flowable observable1 = Flowable.intervalRange(0,4,1,500,TimeUnit.MILLISECONDS);
      Flowable observable2 = Flowable.intervalRange(10,4,1,500,TimeUnit.MILLISECONDS);
      Flowable observable3 = Flowable.intervalRange(20,4,1,500,TimeUnit.MILLISECONDS);

      Flowable.merge(observable2,observable3,observable1).subscribe(new Consumer() {
          @Override
          public void accept(Object o) throws Exception {
              System.out.println(o);
          }
      });

mergeDelayError
延遲丟擲異常事件,當合並的其它事件都執行完成之後再丟擲異常

//延遲丟擲異常事件
      Flowable observable1 = Flowable.create(new FlowableOnSubscribe<Publisher<?>>() {
          @Override
          public void subscribe(FlowableEmitter<Publisher<?>> emitter) throws Exception {
              //假設此處發生了異常
              emitter.onError(new NullPointerException());
          }
      }, BackpressureStrategy.BUFFER);
      Flowable observable2 = Flowable.intervalRange(10,4,1,500,TimeUnit.MILLISECONDS);


      Flowable.mergeDelayError(observable1,observable2).subscribe(new Consumer() {
          @Override
          public void accept(Object o) throws Exception {
              System.out.println(o);
          }
      });

zip
將多個被觀察者壓縮成單個，輸出事件最少的被觀察者結果

RxJava操作符之建立操作符(三)
2017-10-31
RxJava
RxJava操作符之組合操作符(六)
2019-03-04
RxJava
RxJava操作符之轉換操作符(四)
2017-10-31
RxJava
RxJava操作符之過濾操作符(五)
2017-10-31
RxJava
SQL UNION 操作符和 UNION ALL 操作符
2012-06-14
SQL
JavaScript in 操作符
2018-09-07
JavaScript
Java操作符
2015-12-15
Java
%操作符與/操作符（寫給自己看，以防忘記）
2013-03-24
【Java】位操作符
2021-02-08
Java
Java 操作符（3）
2019-01-19
Java
JavaScript中 |、& 、!!操作符
2018-11-21
JavaScript
操作符詳解
2020-11-05
[譯] Pipeable 操作符
2018-01-16
RxJava常用操作符
2016-09-19
RxJava
RxJava操作符列表
2016-11-26
RxJava
[譯] 谷歌搜尋操作符大全（包含 42 個高階操作符）
2019-02-25
谷歌
RxJava 學習筆記 -- 條件操作符和布林操作符
2018-09-18
RxJava筆記
Kotlin——初級篇（五）：操作符與操作符過載一
2018-01-08
Kotlin
3章 RxJava操作符
2019-05-13
RxJava
JavaScript （,）逗號操作符
2018-10-18
JavaScript
PostgreSQL：模式匹配操作符
2020-12-19
SQL模式
PHP goto操作符使用
2020-11-06
PHPGo
RxJava 操作符系列二
2016-12-13
RxJava
RxJava操作符系列一
2016-12-15
RxJava
RxJava操作符系列二
2016-12-15
RxJava
RxJava操作符系列三
2016-12-14
RxJava
RxJava 操作符系列五
2016-12-18
RxJava
RxJava操作符系列四
2016-12-15
RxJava
RxJS操作符（一）
2018-06-05
JS
RxJS操作符（二）
2018-06-05
JS
JavaScript 中的操作符
2017-12-26
JavaScript
java 操作符詳解
2017-11-09
Java
ORACLE之q操作符
2011-05-12
Oracle
c#按位操作符&^|與邏輯條件操作符運算子&&_||_?:
2012-07-06
C#
JavaScript騷操作之操作符
2018-12-16
JavaScript
深入理解typeof操作符
2018-08-07
操作符offset 和 jmp指令
2020-11-12
C++操作符過載
2017-03-12
C++