【知識整理】這多是最好的RxJava 2.x 入門教程（三）

目錄

• 1、前言
• 2、正題
  • 七、distinct
  • 八、Filter
  • 九、buffer
  • 十、timer
  • 十一、interval
  • 十二、doOnNext
  • 1三、skip
  • 1四、take
  • 1五、just
• 3、寫在最後

 

正文

 

 

這多是最好的RxJava 2.x入門教程系列專欄

文章連接：

這多是最好的RxJava 2.x 入門教程（一）

這多是最好的RxJava 2.x 入門教程（二）

這多是最好的RxJava 2.x 入門教程（三）

GitHub 代碼同步更新：https://github.com/nanchen2251/RxJava2Examples

爲了知足你們的飢渴難耐，GitHub將同步更新代碼，主要包含基本的代碼封裝，RxJava 2.x全部操做符應用場景介紹和實際應用場景，後期除了RxJava可能還會增添其餘東西，總之，GitHub上的Demo專爲你們傾心打造。傳送門：https://github.com/nanchen2251/RxJava2Examples

 

回到頂部

1、前言

      年輕的老司機們，我這麼勤的爲你們分享，卻少有催更的，好吧。其實寫這個系列不是爲了吸睛，那我們繼續寫咱們的 RxJava 2.x 的操做符。

回到頂部

2、正題

七、distinct

       這個操做符很是的簡單、通俗、易懂，就是簡單的去重嘛，我甚至都不想貼代碼，但人嘛，總得鍥而不捨。

1 Observable.just(1, 1, 1, 2, 2, 3, 4, 5)
2                 .distinct()
3                 .subscribe(new Consumer<Integer>() {
4                     @Override
5                     public void accept(@NonNull Integer integer) throws Exception {
6                         mRxOperatorsText.append("distinct : " + integer + "\n");
7                         Log.e(TAG, "distinct : " + integer + "\n");
8                     }
9                 });

輸出：

Log 日誌顯而易見，咱們在通過dinstinct() 後接收器接收到的事件只有1,2,3,4,5了。

八、Filter

      信我，Filter 你會很經常使用的，它的做用也很簡單，過濾器嘛。能夠接受一個參數，讓其過濾掉不符合咱們條件的值

 1 Observable.just(1, 20, 65, -5, 7, 19)
 2                 .filter(new Predicate<Integer>() {
 3                     @Override
 4                     public boolean test(@NonNull Integer integer) throws Exception {
 5                         return integer >= 10;
 6                     }
 7                 }).subscribe(new Consumer<Integer>() {
 8             @Override
 9             public void accept(@NonNull Integer integer) throws Exception {
10                 mRxOperatorsText.append("filter : " + integer + "\n");
11                 Log.e(TAG, "filter : " + integer + "\n");
12             }
13         });

輸出：

能夠看到，咱們過濾器捨去了小於10的值，因此最好的輸出只有20,65,19。

 

九、buffer

 buffer 操做符接受兩個參數，buffef(count,skip)，做用是將 Observable 中的數據按 skip (步長) 分紅最大不超過 count 的 buffer ，而後生成一個 Observable 。也許你還不太理解，咱們能夠經過咱們的示例圖和示例代碼來進一步深化它。

 1 Observable.just(1, 2, 3, 4, 5)
 2                 .buffer(3, 2)
 3                 .subscribe(new Consumer<List<Integer>>() {
 4                     @Override
 5                     public void accept(@NonNull List<Integer> integers) throws Exception {
 6                         mRxOperatorsText.append("buffer size : " + integers.size() + "\n");
 7                         Log.e(TAG, "buffer size : " + integers.size() + "\n");
 8                         mRxOperatorsText.append("buffer value : ");
 9                         Log.e(TAG, "buffer value : " );
10                         for (Integer i : integers) {
11                             mRxOperatorsText.append(i + "");
12                             Log.e(TAG, i + "");
13                         }
14                         mRxOperatorsText.append("\n");
15                         Log.e(TAG, "\n");
16                     }
17                 });

輸出：

如圖，咱們把1,2,3,4,5依次發射出來，通過buffer 操做符，其中參數 skip 爲3， count 爲2，而咱們的輸出 依次是 123，345，5。顯而易見，咱們 buffer 的第一個參數是count，表明最大取值，在事件足夠的時候，通常都是取count個值，而後天天跳過skip個事件。其實看 Log 日誌，我相信你們都明白了。

 

十、timer

timer 頗有意思，至關於一個定時任務。在1.x 中它還能夠執行間隔邏輯，但在2.x中此功能被交給了 interval，下一個會介紹。但須要注意的是，timer 和 interval 均默認在新線程。

 1 mRxOperatorsText.append("timer start : " + TimeUtil.getNowStrTime() + "\n");
 2         Log.e(TAG, "timer start : " + TimeUtil.getNowStrTime() + "\n");
 3         Observable.timer(2, TimeUnit.SECONDS)
 4                 .subscribeOn(Schedulers.io())
 5                 .observeOn(AndroidSchedulers.mainThread()) // timer 默認在新線程，因此須要切換回主線程
 6                 .subscribe(new Consumer<Long>() {
 7                     @Override
 8                     public void accept(@NonNull Long aLong) throws Exception {
 9                         mRxOperatorsText.append("timer :" + aLong + " at " + TimeUtil.getNowStrTime() + "\n");
10                         Log.e(TAG, "timer :" + aLong + " at " + TimeUtil.getNowStrTime() + "\n");
11                     }
12                 });

輸出：

顯而易見，當咱們兩次點擊按鈕觸發這個事件的時候，接收被延遲了2秒。

 

十一、interval

如同咱們上面可說，interval 操做符用於間隔時間執行某個操做，其接受三個參數，分別是第一次發送延遲，間隔時間，時間單位。

 1 mRxOperatorsText.append("interval start : " + TimeUtil.getNowStrTime() + "\n");
 2         Log.e(TAG, "interval start : " + TimeUtil.getNowStrTime() + "\n");
 3         Observable.interval(3,2, TimeUnit.SECONDS)
 4                 .subscribeOn(Schedulers.io())
 5                 .observeOn(AndroidSchedulers.mainThread()) // 因爲interval默認在新線程，因此咱們應該切回主線程
 6                 .subscribe(new Consumer<Long>() {
 7                     @Override
 8                     public void accept(@NonNull Long aLong) throws Exception {
 9                         mRxOperatorsText.append("interval :" + aLong + " at " + TimeUtil.getNowStrTime() + "\n");
10                         Log.e(TAG, "interval :" + aLong + " at " + TimeUtil.getNowStrTime() + "\n");
11                     }
12                 });

輸出：

如同 Log 日誌同樣，第一次延遲了3秒後接收到，後面每次間隔了2秒。

然而，心細的小夥伴可能會發現，因爲咱們這個是間隔執行，因此當咱們的Activity都銷燬的時候，實際上這個操做還依然在進行，因此，咱們得花點當心思讓咱們在不須要它的時候幹掉它。查看源碼發現，咱們subscribe(Cousumer<? super T> onNext)返回的是Disposable，咱們能夠在這上面作文章。

 1 @Override
 2     protected void doSomething() {
 3         mRxOperatorsText.append("interval start : " + TimeUtil.getNowStrTime() + "\n");
 4         Log.e(TAG, "interval start : " + TimeUtil.getNowStrTime() + "\n");
 5         mDisposable = Observable.interval(3, 2, TimeUnit.SECONDS)
 6                 .subscribeOn(Schedulers.io())
 7                 .observeOn(AndroidSchedulers.mainThread()) // 因爲interval默認在新線程，因此咱們應該切回主線程
 8                 .subscribe(new Consumer<Long>() {
 9                     @Override
10                     public void accept(@NonNull Long aLong) throws Exception {
11                         mRxOperatorsText.append("interval :" + aLong + " at " + TimeUtil.getNowStrTime() + "\n");
12                         Log.e(TAG, "interval :" + aLong + " at " + TimeUtil.getNowStrTime() + "\n");
13                     }
14                 });
15     }
16 
17     @Override
18     protected void onDestroy() {
19         super.onDestroy();
20         if (mDisposable != null && !mDisposable.isDisposed()) {
21             mDisposable.dispose();
22         }
23     }

哈哈，再次驗證，解決了咱們的疑惑。

 

十二、doOnNext

其實以爲 doOnNext 應該不算一個操做符，但考慮到其經常使用性，咱們仍是咬咬牙將它放在了這裏。它的做用是讓訂閱者在接收到數據以前乾點有意思的事情。假如咱們在獲取到數據以前想先保存一下它，無疑咱們能夠這樣實現。

 1 Observable.just(1, 2, 3, 4)
 2                 .doOnNext(new Consumer<Integer>() {
 3                     @Override
 4                     public void accept(@NonNull Integer integer) throws Exception {
 5                         mRxOperatorsText.append("doOnNext 保存 " + integer + "成功" + "\n");
 6                         Log.e(TAG, "doOnNext 保存 " + integer + "成功" + "\n");
 7                     }
 8                 }).subscribe(new Consumer<Integer>() {
 9             @Override
10             public void accept(@NonNull Integer integer) throws Exception {
11                 mRxOperatorsText.append("doOnNext :" + integer + "\n");
12                 Log.e(TAG, "doOnNext :" + integer + "\n");
13             }
14         });

輸出：

 

1三、skip

 skip 頗有意思，其實做用就和字面意思同樣，接受一個 long 型參數 count ，表明跳過 count 個數目開始接收。

1  Observable.just(1,2,3,4,5)
2                 .skip(2)
3                 .subscribe(new Consumer<Integer>() {
4                     @Override
5                     public void accept(@NonNull Integer integer) throws Exception {
6                         mRxOperatorsText.append("skip : "+integer + "\n");
7                         Log.e(TAG, "skip : "+integer + "\n");
8                     }
9                 });

輸出：

 

 

1四、take

take，接受一個 long 型參數 count ，表明至多接收 count 個數據。

1  Flowable.fromArray(1,2,3,4,5)
2                 .take(2)
3                 .subscribe(new Consumer<Integer>() {
4                     @Override
5                     public void accept(@NonNull Integer integer) throws Exception {
6                         mRxOperatorsText.append("take : "+integer + "\n");
7                         Log.e(TAG, "accept: take : "+integer + "\n" );
8                     }
9                 });

輸出：

 

1五、just

 just，沒什麼好說的，其實在前面各類例子都說明了，就是一個簡單的發射器依次調用onNext()方法。

 1 Observable.just("1", "2", "3")
 2                 .subscribeOn(Schedulers.io())
 3                 .observeOn(AndroidSchedulers.mainThread())
 4                 .subscribe(new Consumer<String>() {
 5                     @Override
 6                     public void accept(@NonNull String s) throws Exception {
 7                         mRxOperatorsText.append("accept : onNext : " + s + "\n");
 8                         Log.e(TAG,"accept : onNext : " + s + "\n" );
 9                     }
10                 });

 輸出：

 

回到頂部

3、寫在最後

      好吧，本節先講到這裏，下節咱們仍是繼續講簡單的操做符，雖然咱們的教程比較枯燥，如今也不那麼受人關注，但後面的系列我相信你們必定會很是喜歡的，咱們下期再見！