RxJava操作符有哪些

這篇文章主要講解了“RxJava操作符有哪些”，文中的講解內容簡單清晰，易于學習與理解，下面請大家跟著小編的思路慢慢深入，一起來研究和學習“RxJava操作符有哪些”吧！

Filter

該操作符接收一個Func1參數，我們可以在其中通過運用你自己的判斷條件去判斷我們要過濾的數據，當數據通過判斷條件后返回true表示發射該項數據，否則就不發射，這樣就過濾出了我們想要的數據。如下，我們過濾出不能被2整除的數

Integer[] ints = {1, 2, 3, 4, 5, 6, 7, 8, 9};         Observable observable = Observable.from(ints).filter(new Func1<Integer, Boolean>() {             @Override             public Boolean call(Integer integer) {                 return integer % 2 != 0;//返回true，就不會過濾掉，會發射數據，過濾掉返回false的值             }         });         Action1 action1 = new Action1<Integer>() {             @Override             public void call(Integer i) {                 Log.e(TAG, "call: "+i );             }         };         observable.subscribe(action1);

輸出日志信息

call: 1  call: 3  call: 5  call: 7  call: 9

ofType

該操作符是filter操作符的一個特殊形式。它過濾一個Observable只返回指定類型的數據，例如當數據源有字符串和int型數據時，我們想要過濾出字符串就可以使用這個操作符，如下示例代碼

Observable.just(0, "one", 6, 4, "two", 8, "three", 1, "four", 0)  .ofType(String.class)  .subscribe(new Subscriber<String>() {  @Override  public void onCompleted() {  Log.e(TAG, "onCompleted:ofType ");  }     @Override  public void onError(Throwable e) {  Log.e(TAG, "onError:ofType ");  }     @Override  public void onNext(String string) {  Log.e(TAG, "onNext:ofType " + string);  }  });

輸出日志信息

onNext:ofType one  onNext:ofType two  onNext:ofType three  onNext:ofType four  onCompleted:ofType

當然除了過濾基本類型的數據，也可以過濾自定義類型數據。

First

如果我們只對Observable發射的***項數據，或者滿足某個條件的***項數據感興趣，則可以使用First操作符。

Observable.just(10, 11, 12, 13).first().subscribe(new Action1() {              @Override              public void call(Integer integer) {                  Log.e(TAG, integer+"");              }          });

上面日志只打印一個值10，當然我們也可以給first傳一個參數Fun1，指定一個條件如下

Observable.just(10, 11, 12, 13).first(new Func1<Integer, Boolean>() {              @Override              public Boolean call(Integer integer) {                  return integer > 12;              }          }).subscribe(new Action1<Integer>() {              @Override              public void call(Integer integer) {                  Log.e(TAG, integer+"");              }          });

此時輸出的信息就是滿足integer > 12的***項數據13。

firstOrDefault

該操作符是first操作符的變形。主要是在沒有發射任何數據時發射一個你在參數中指定的默認值。如下，它有有兩個重載方法。

Observable.just(11,12,13).firstOrDefault(10).subscribe(new Action1<Object>() {              @Override              public void call(Object o) {                  Log.e(TAG, o.toString());              }          });

如果寫成上面的代碼，這個執行會和first效果一樣。因為沒有發射數據的時候才用到默認值，那么我們將上面代碼更改如下，使用empty創建一個不發射任何數據但是正常終止的Observable。

Observable.empty().firstOrDefault(10).subscribe(new Action1<Object>() {              @Override              public void call(Object o) {                  Log.e(TAG, o.toString());              }          });

發現此時輸出了數據10.該操作符還提供了兩個參數的重載方法firstOrDefault(T defaultValue, Func1 super T,  Boolean> predicate)。我們可以增加一個條件。如下示例

Observable.just(10，13,16).firstOrDefault(15, new Func1<Integer, Boolean>() {              @Override              public Boolean call(Integer integer) {                  return integer>20;              }          }).subscribe(new Action1<Integer>() {              @Override              public void call(Integer integer) {                  Log.e(TAG, ""+integer);              }          });

此時數據源10,13,16都不滿足大于20,則此時將輸出默認值15，如果我們將數據源數據增加一個值22.那么此時將不再輸出默認值，而是輸出22。

takeFirst

該操作符與first操作符的區別就是如果原始Observable沒有發射任何滿足條件的數據，first會拋出一個NoSuchElementException直接執行onError()，而takeFist會返回一個空的Observable(不調用onNext()但是會調用onCompleted)

如下面下面示例代碼

Observable.just(10,11).filter(new Func1<Integer, Boolean>() {              @Override              public Boolean call(Integer integer) {                  return integer>20;              }          }).first().subscribe(new Subscriber<Object>() {                 @Override              public void onCompleted() {                  Log.e(TAG, "onCompleted: ");              }                 @Override              public void onError(Throwable e) {                  Log.e(TAG, "onError: "+e.toString());              }                 @Override              public void onNext(Object o) {                  Log.e(TAG, "onNext: "+o.toString());              }          });

執行后輸出的信息如下

onError: java.util.NoSuchElementException: Sequence contains no elements

若此時用takeFirst

Observable.just(10,11).takeFirst(new Func1<Integer, Boolean>() {              @Override              public Boolean call(Integer integer) {                  Log.e(TAG, "call: takeFirst" );                  return integer>30;              }          }).subscribe(new Subscriber<Object>() {                 @Override              public void onCompleted() {                  Log.e(TAG, "onCompleted: ");              }                 @Override              public void onError(Throwable e) {                  Log.e(TAG, "onError: "+e.toString());              }                 @Override              public void onNext(Object o) {                  Log.e(TAG, "onNext: "+o.toString());              }          });

發現此時不會出現異常，而是執行了onCompleted()。

single

如果原始Observable在完成之前不是正好發射一次數據，它會拋出一個NoSuchElementException，白話可以理解為發送數據是一項的話輸出此項的值，若是多個數據則拋出異常執行onError()方法。

如下代碼

Observable.just(10, 11, 12, 13).single().subscribe(new Subscriber<Integer>() {              @Override              public void onCompleted() {                   Log.e(TAG, "onCompleted");              }                 @Override              public void onError(Throwable e) {                   Log.e(TAG, "onError"+e.toString());              }                 @Override              public void onNext(Integer integer) {                   Log.e(TAG,  integer);              }          });

輸出信息

onError: java.util.NoSuchElementException: Sequence contains no elements

如果將上述代碼做下簡單更改

Observable.just(10, 11, 12, 13).filter(new Func1<Integer, Boolean>() {              @Override              public Boolean call(Integer integer) {                  return integer > 12;              }          }).subscribe(new Subscriber<Integer>() {              @Override              public void onCompleted() {                   Log.e(TAG, "onCompleted");              }                 @Override              public void onError(Throwable e) {                   Log.e(TAG, "onError"+e.toString());              }                 @Override              public void onNext(Integer integer) {                   Log.e(TAG,  integer);              }          });

此時會輸出數據13,因為此時通過filter后就只有一條數據。single也有singleOrDefault(T)和singleOrDefault(T,Func1)兩個變體，具體可以自己代碼測試區別。

Last

該操作符與first意義相反，若我們只對Observable發射的***一項數據，或者滿足某個條件的***一項數據感興趣時使用該操作符。

示例代碼

Observable.just(10, 11, 12, 13).last().subscribe(new Action1<Integer>() {              @Override              public void call(Integer integer) {                 Log.e(TAG, "call: "+integer);              }          });

執行后輸出13.它有一個重載方法可以指定條件，獲取滿足條件的***一項數據的。將上面代碼修改如下

Observable.just(10, 11, 12, 13).last(new Func1<Integer, Boolean>() {              @Override              public Boolean call(Integer integer) {                  return integer < 12;              }          }).subscribe(new Action1<Integer>() {              @Override              public void call(Integer integer) {                  Log.e(TAG, "call: "+integer);              }          });

此時最終輸出數據就是11.該操作符和first一樣也有幾種變體，如lastOrDefault，TakeLast，具體效果可自己測試。

Skip

該操作符是跳過之前的前幾項數據，然后再發射數據。

Observable.range(1, 10).skip(6).subscribe(new Action1<Integer>() {              @Override              public void call(Integer integer) {                 Log.e(TAG, "call: "+integer );              }          });

輸出日志信息

call: 7  call: 8  call: 9  call: 10

skip還有兩個重載方法.skip(long time, TimeUnit  unit)默認是在computation調度器上執行，如果要有更新UI操作需要通過observeOn方法指定為AndroidSchedulers.mainThread()，當然還有一個重載方法skip(long  time, TimeUnit unit, Scheduler  scheduler)可以指定調度器。注意的一點是這兩個重載方法的***個參數不是跳過的數據數量，指的是時間。

Observable.interval(500, TimeUnit.MILLISECONDS)                  .skip(2, TimeUnit.SECONDS)                  .observeOn(AndroidSchedulers.mainThread())                  .subscribe(new Subscriber<Long>() {                      @Override                      public void onCompleted() {                         }                         @Override                      public void onError(Throwable e) {                         }                         @Override                      public void onNext(Long aLong) {                          tv.append("\n" + aLong);                          if (aLong > 10) {                              this.unsubscribe();                          }                      }                  });

如上代碼，通過interval每隔500毫秒產生一個數據，通過skip設定跳過時間為2秒。并且當數據大于10時解除訂閱。

skipLast

正好和skip 相反，忽略***產生的n個數據項

Observable.range(1, 10).skipLast(6).subscribe(new Action1<Integer>() {              @Override              public void call(Integer integer) {                 Log.e(TAG, "call: "+integer );              }          });

輸出日志信息

call: 1  call: 2  call: 3  call: 4

感謝各位的閱讀，以上就是“RxJava操作符有哪些”的內容了，經過本文的學習后，相信大家對RxJava操作符有哪些這一問題有了更深刻的體會，具體使用情況還需要大家實踐驗證。這里是億速云，小編將為大家推送更多相關知識點的文章，歡迎關注！