Carson帶你學Android：RxJava過濾操作符

前言

Rxjava，由于其基于事件流的鏈式調用、邏輯簡潔 & 使用簡單的特點，深受各大 Android開發者的歡迎。

如果還不了解 RxJava，請看文章：Android：這是一篇 清晰 & 易懂的Rxjava 入門教程

  • RxJava如此受歡迎的原因，在于其提供了豐富 & 功能強大的操作符，幾乎能完成所有的功能需求
  • 今天，我將為大家詳細介紹RxJava操作符中最常用的 過濾操作符，希望你們會喜歡。

Carson帶你學RxJava系列文章，包括 原理、操作符、應用場景、背壓等等，請關注看文章：Android：這是一份全面 & 詳細的RxJava學習指南

目錄

示意圖

1. 作用

過濾 / 篩選 被觀察者（Observable）發送的事件 & 觀察者 （Observer）接收的事件

2. 類型

  • RxJava2中，過濾操作符的類型包括：

    示意圖

  • 下面，我將對每個操作符進行詳細講解

3. 應用場景 & 對應操作符詳解

  • 過濾操作符的應用場景包括：
    1. 根據 指定條件 過濾事件
    2. 根據 指定事件數量 過濾事件
    3. 根據 指定時間 過濾事件
    4. 根據 指定事件位置 過濾事件
  • 下面，我將根據上述應用場景，講解對應的操作符使用

注：在使用RxJava 2操作符前，記得在項目的Gradle中添加依賴：

dependencies {
      compile 'io.reactivex.rxjava2:rxandroid:2.0.1'
      compile 'io.reactivex.rxjava2:rxjava:2.0.7'
      // 注：RxJava2 與 RxJava1 不能共存，即依賴不能同時存在
}

3.1 根據 指定條件 過濾事件

  • 需求場景
    通過設置指定的過濾條件，當且僅當該事件滿足條件，就將該事件過濾（不發送）

  • 對應操作符類型

示意圖
  • 對應操作符使用

Filter（）

  • 作用
    過濾 特定條件的事件

  • 原理

示意圖
  • 具體使用
Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
                // 1. 發送5個事件
                emitter.onNext(1);
                emitter.onNext(2);
                emitter.onNext(3);
                emitter.onNext(4);
                emitter.onNext(5);
            }

            // 2. 采用filter（）變換操作符
        }).filter(new Predicate<Integer>() {
            // 根據test()的返回值 對被觀察者發送的事件進行過濾 & 篩選
              // a. 返回true，則繼續發送
              // b. 返回false，則不發送（即過濾）
            @Override
            public boolean test(Integer integer) throws Exception {
                return integer > 3;
                // 本例子 = 過濾了整數≤3的事件
            }
        }).subscribe(new Observer<Integer>() {

            @Override
            public void onSubscribe(Disposable d) {
                Log.d(TAG, "開始采用subscribe連接");
            }

            @Override
            public void onNext(Integer value) {
                Log.d(TAG, "過濾后得到的事件是："+ value  );
            }

            @Override
            public void onError(Throwable e) {
                Log.d(TAG, "對Error事件作出響應");
            }

            @Override
            public void onComplete() {
                Log.d(TAG, "對Complete事件作出響應");
            }
        });
  • 測試結果
示意圖

ofType（）

  • 作用
    過濾 特定數據類型的數據

  • 具體使用

Observable.just(1, "Carson", 3, "Ho", 5)
                  .ofType(Integer.class) // 篩選出 整型數據
                  .subscribe(new Consumer<Integer>() {
                      @Override
                      public void accept( Integer integer) throws Exception {
                          Log.d(TAG,"獲取到的整型事件元素是： "+ integer);
                      }
        });
  • 測試結果
示意圖

skip（） / skipLast（）

  • 作用
    跳過某個事件

  • 具體使用

// 使用1：根據順序跳過數據項
        Observable.just(1, 2, 3, 4, 5)
                .skip(1) // 跳過正序的前1項
                .skipLast(2) // 跳過正序的后2項
                  .subscribe(new Consumer<Integer>() {
                      @Override
                      public void accept( Integer integer) throws Exception {
                          Log.d(TAG,"獲取到的整型事件元素是： "+ integer);
                      }
        });

// 使用2：根據時間跳過數據項
        // 發送事件特點：發送數據0-5，每隔1s發送一次，每次遞增1；第1次發送延遲0s
        Observable.intervalRange(0, 5, 0, 1, TimeUnit.SECONDS)
                .skip(1, TimeUnit.SECONDS) // 跳過第1s發送的數據
                .skipLast(1, TimeUnit.SECONDS) // 跳過最后1s發送的數據
                .subscribe(new Consumer<Long>() {

                    @Override
                    public void accept( Long along ) throws Exception {
                        Log.d(TAG,"獲取到的整型事件元素是： "+ along);
                    }
                });
  • 測試結果
image.png

distinct（） / distinctUntilChanged（）

  • 作用
    過濾事件序列中重復的事件 / 連續重復的事件

  • 具體使用

// 使用1：過濾事件序列中重復的事件
        Observable.just(1, 2, 3, 1 , 2 )
                .distinct()
                .subscribe(new Consumer<Integer>() {
                      @Override
                      public void accept( Integer integer) throws Exception {
                          Log.d(TAG,"不重復的整型事件元素是： "+ integer);
                      }
        });

        // 使用2：過濾事件序列中 連續重復的事件
        // 下面序列中，連續重復的事件 = 3、4
        Observable.just(1,2,3,1,2,3,3,4,4 )
                .distinctUntilChanged()
                .subscribe(new Consumer<Integer>() {
                    @Override
                    public void accept( Integer integer) throws Exception {
                        Log.d(TAG,"不連續重復的整型事件元素是： "+ integer);
                    }
                });
  • 測試結果
示意圖

3.2 根據 指定事件數量 過濾事件

  • 需求場景
    通過設置指定的事件數量，僅發送特定數量的事件

  • 對應操作符類型
    take（） & takeLast（）

  • 對應操作符使用

take（）

  • 作用
    指定觀察者最多能接收到的事件數量

  • 原理

示意圖
  • 具體使用
Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
                // 1. 發送5個事件
                emitter.onNext(1);
                emitter.onNext(2);
                emitter.onNext(3);
                emitter.onNext(4);
                emitter.onNext(5);
            }

            // 采用take（）變換操作符
            // 指定了觀察者只能接收2個事件
        }).take(2)
        .subscribe(new Observer<Integer>() {

            @Override
            public void onSubscribe(Disposable d) {
                Log.d(TAG, "開始采用subscribe連接");
            }

            @Override
            public void onNext(Integer value) {
                Log.d(TAG, "過濾后得到的事件是："+ value  );
            }

            @Override
            public void onError(Throwable e) {
                Log.d(TAG, "對Error事件作出響應");
            }

            @Override
            public void onComplete() {
                Log.d(TAG, "對Complete事件作出響應");
            }
        });

// 實際上，可理解為：被觀察者還是發送了5個事件，只是因為操作符的存在攔截了3個事件，最終觀察者接收到的是2個事件
  • 測試結果
示意圖

takeLast（）

  • 作用
    指定觀察者只能接收到被觀察者發送的最后幾個事件

  • 具體使用

Observable.just(1, 2, 3, 4, 5)
          .takeLast(3) //指定觀察者只能接受被觀察者發送的3個事件
          .subscribe(new Observer<Integer>() {
            @Override
            public void onSubscribe(Disposable d) {
                Log.d(TAG, "開始采用subscribe連接");
            }

            @Override
            public void onNext(Integer value) {
                Log.d(TAG, "過濾后得到的事件是："+ value  );
            }

            @Override
            public void onError(Throwable e) {
                Log.d(TAG, "對Error事件作出響應");
            }

            @Override
            public void onComplete() {
                Log.d(TAG, "對Complete事件作出響應");
            }
        });
  • 測試結果
示意圖

3.3 根據 指定時間 過濾事件

  • 需求場景
    通過設置指定的時間，僅發送在該時間內的事件

  • 對應操作符類型

示意圖
  • 對應操作符使用

throttleFirst（）/ throttleLast（）

  • 作用
    在某段時間內，只發送該段時間內第1次事件 / 最后1次事件

如，1段時間內連續點擊按鈕，但只執行第1次的點擊操作

  • 原理示意圖
示意圖
  • 具體使用
<<- 在某段時間內，只發送該段時間內第1次事件 ->>
Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> e) throws Exception {
                // 隔段事件發送時間
                e.onNext(1);
                Thread.sleep(500);
                
                e.onNext(2);
                Thread.sleep(400);
                
                e.onNext(3);
                Thread.sleep(300);
                
                e.onNext(4);
                Thread.sleep(300);
                
                e.onNext(5);
                Thread.sleep(300);
                
                e.onNext(6);
                Thread.sleep(400);
                
                e.onNext(7);
                Thread.sleep(300);
                e.onNext(8);

                Thread.sleep(300);
                e.onNext(9);

                Thread.sleep(300);
                e.onComplete();
            }
        }).throttleFirst(1, TimeUnit.SECONDS)//每1秒中采用數據
                .subscribe(new Observer<Integer>() {
                    @Override
                    public void onSubscribe(Disposable d) {
                        Log.d(TAG, "開始采用subscribe連接");
                    }

                    @Override
                    public void onNext(Integer value) {
                        Log.d(TAG, "接收到了事件"+ value  );
                    }

                    @Override
                    public void onError(Throwable e) {
                        Log.d(TAG, "對Error事件作出響應");
                    }

                    @Override
                    public void onComplete() {
                        Log.d(TAG, "對Complete事件作出響應");
                    }
                });


<<- 在某段時間內，只發送該段時間內最后1次事件 ->>
Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> e) throws Exception {
                // 隔段事件發送時間
                e.onNext(1);
                Thread.sleep(500);

                e.onNext(2);
                Thread.sleep(400);

                e.onNext(3);
                Thread.sleep(300);

                e.onNext(4);
                Thread.sleep(300);

                e.onNext(5);
                Thread.sleep(300);

                e.onNext(6);
                Thread.sleep(400);

                e.onNext(7);
                Thread.sleep(300);
                e.onNext(8);

                Thread.sleep(300);
                e.onNext(9);

                Thread.sleep(300);
                e.onComplete();
            }
        }).throttleLast(1, TimeUnit.SECONDS)//每1秒中采用數據
                .subscribe(new Observer<Integer>() {
                    @Override
                    public void onSubscribe(Disposable d) {
                        Log.d(TAG, "開始采用subscribe連接");
                    }

                    @Override
                    public void onNext(Integer value) {
                        Log.d(TAG, "接收到了事件"+ value  );
                    }

                    @Override
                    public void onError(Throwable e) {
                        Log.d(TAG, "對Error事件作出響應");
                    }

                    @Override
                    public void onComplete() {
                        Log.d(TAG, "對Complete事件作出響應");
                    }
                });
  • 測試結果
示意圖

Sample（）

  • 作用
    在某段時間內，只發送該段時間內最新（最后）1次事件

與 throttleLast（） 操作符類似

  • 具體使用

僅需要把上文的 throttleLast（） 改成Sample（）操作符即可，此處不作過多描述

throttleWithTimeout （） / debounce（）

  • 作用
    發送數據事件時，若2次發送事件的間隔＜指定時間，就會丟棄前一次的數據，直到指定時間內都沒有新數據發射時才會發送后一次的數據

  • 具體使用

Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> e) throws Exception {
                // 隔段事件發送時間
                e.onNext(1);
                Thread.sleep(500);
                e.onNext(2); // 1和2之間的間隔小于指定時間1s，所以前1次數據（1）會被拋棄，2會被保留
                Thread.sleep(1500);  // 因為2和3之間的間隔大于指定時間1s，所以之前被保留的2事件將發出
                e.onNext(3);
                Thread.sleep(1500);  // 因為3和4之間的間隔大于指定時間1s，所以3事件將發出
                e.onNext(4);
                Thread.sleep(500); // 因為4和5之間的間隔小于指定時間1s，所以前1次數據（4）會被拋棄，5會被保留
                e.onNext(5);
                Thread.sleep(500); // 因為5和6之間的間隔小于指定時間1s，所以前1次數據（5）會被拋棄，6會被保留
                e.onNext(6);
                Thread.sleep(1500); // 因為6和Complete實踐之間的間隔大于指定時間1s，所以之前被保留的6事件將發出

                e.onComplete();
            }
        }).throttleWithTimeout(1, TimeUnit.SECONDS)//每1秒中采用數據
                .subscribe(new Observer<Integer>() {
                    @Override
                    public void onSubscribe(Disposable d) {

                    }

                    @Override
                    public void onNext(Integer value) {
                        Log.d(TAG, "接收到了事件"+ value  );
                    }

                    @Override
                    public void onError(Throwable e) {
                        Log.d(TAG, "對Error事件作出響應");
                    }

                    @Override
                    public void onComplete() {
                        Log.d(TAG, "對Complete事件作出響應");
                    }
                });
  • 測試結果
示意圖

3.4 根據 指定事件位置 過濾事件

  • 需求場景
    通過設置指定的位置，過濾在該位置的事件

  • 對應操作符類型

示意圖
  • 對應操作符使用

firstElement（） / lastElement（）

  • 作用
    僅選取第1個元素 / 最后一個元素

  • 具體使用

// 獲取第1個元素
        Observable.just(1, 2, 3, 4, 5)
                  .firstElement()
                  .subscribe(new Consumer<Integer>() {
                      @Override
                      public void accept( Integer integer) throws Exception {
                          Log.d(TAG,"獲取到的第一個事件是： "+ integer);
                      }
        });

// 獲取最后1個元素
        Observable.just(1, 2, 3, 4, 5)
                .lastElement()
                .subscribe(new Consumer<Integer>() {
                    @Override
                    public void accept( Integer integer) throws Exception {
                        Log.d(TAG,"獲取到的最后1個事件是： "+ integer);
                    }
                });
  • 測試結果
示意圖

elementAt（）

  • 作用
    指定接收某個元素（通過 索引值 確定）

注：允許越界，即獲取的位置索引 ＞ 發送事件序列長度

  • 具體使用
// 使用1：獲取位置索引 = 2的 元素
        // 位置索引從0開始
        Observable.just(1, 2, 3, 4, 5)
                  .elementAt(2)
                  .subscribe(new Consumer<Integer>() {
                      @Override
                      public void accept( Integer integer) throws Exception {
                          Log.d(TAG,"獲取到的事件元素是： "+ integer);
                      }
        });

// 使用2：獲取的位置索引 ＞ 發送事件序列長度時，設置默認參數
        Observable.just(1, 2, 3, 4, 5)
                .elementAt(6,10)
                .subscribe(new Consumer<Integer>() {
                    @Override
                    public void accept( Integer integer) throws Exception {
                        Log.d(TAG,"獲取到的事件元素是： "+ integer);
                    }
                });
  • 測試結果
示意圖

elementAtOrError（）

  • 作用
    在elementAt（）的基礎上，當出現越界情況（即獲取的位置索引 ＞ 發送事件序列長度）時，即拋出異常

  • 具體使用

Observable.just(1, 2, 3, 4, 5)
                .elementAtOrError(6)
                .subscribe(new Consumer<Integer>() {
                    @Override
                    public void accept( Integer integer) throws Exception {
                        Log.d(TAG,"獲取到的事件元素是： "+ integer);
                    }
                });
  • 測試結果
示意圖

至此，RxJava2中常用的過濾操作符講解完畢。

4. 實際開發需求案例

  • 在實際開發中，常見的過濾操作符實際需求場景有：功能防抖 & 聯想搜索請求優化
  • 下面，我將通過具體實例來講解上述2個需求

4.1 功能防抖

  • 需求場景
示意圖

4.2 聯想搜索優化

  • 場景說明
示意圖

5. Demo地址

上述所有的Demo源代碼都存放在：Carson_Ho的Github地址：RxJava2_過濾操作符

6. 總結

  • 下面，我將用一張圖總結 RxJava2 中常用的條件 / 布爾操作符
示意圖
  • Carson帶你學RxJava系列文章：

入門
Carson帶你學Android：這是一篇清晰易懂的Rxjava入門教程
Carson帶你學Android：面向初學者的RxJava使用指南
Carson帶你學Android：RxJava2.0到底更新了什么？
原理
Carson帶你學Android：圖文解析RxJava原理
Carson帶你學Android：手把手帶你源碼分析RxJava
使用教程：操作符
Carson帶你學Android：RxJava操作符教程
Carson帶你學Android：RxJava創建操作符
Carson帶你學Android：RxJava功能性操作符
Carson帶你學Android：RxJava過濾操作符
Carson帶你學Android：RxJava組合/合并操作符
Carson帶你學Android：RxJava變換操作符
Carson帶你學Android：RxJava條件/布爾操作符
實戰
Carson帶你學Android：什么時候應該使用Rxjava？(開發場景匯總)
Carson帶你學Android：RxJava線程控制(含實例講解)
Carson帶你學Android：圖文詳解RxJava背壓策略
Carson帶你學Android：RxJava、Retrofit聯合使用匯總(含實例教程)
Carson帶你學Android：優雅實現網絡請求嵌套回調
Carson帶你學Android：網絡請求輪詢(有條件)
Carson帶你學Android：網絡請求輪詢(無條件)
Carson帶你學Android：網絡請求出錯重連(結合Retrofit)
Carson帶你學Android：合并數據源
Carson帶你學Android：聯想搜索優化
Carson帶你學Android：功能防抖
Carson帶你學Android：從磁盤/內存緩存中獲取緩存數據
Carson帶你學Android：聯合判斷

歡迎關注Carson_Ho的簡書

不定期分享關于安卓開發的干貨，追求短、平、快，但卻不缺深度。

請點贊！因為你的鼓勵是我寫作的最大動力！

最后編輯于 ：
?著作權歸作者所有,轉載或內容合作請聯系作者
平臺聲明：文章內容（如有圖片或視頻亦包括在內）由作者上傳并發布，文章內容僅代表作者本人觀點，簡書系信息發布平臺，僅提供信息存儲服務。
  • 人面猴
    序言：七十年代末，一起剝皮案震驚了整個濱河市，隨后出現的幾起案子，更是在濱河造成了極大的恐慌，老刑警劉巖，帶你破解...
    沈念sama閱讀 228,646評論 6贊 533
  • 死咒
    序言：濱河連續發生了三起死亡事件，死亡現場離奇詭異，居然都是意外死亡，警方通過查閱死者的電腦和手機，發現死者居然都...
    沈念sama閱讀 98,595評論 3贊 418
  • 救了他兩次的神仙讓他今天三更去死
    文/潘曉璐 我一進店門，熙熙樓的掌柜王于貴愁眉苦臉地迎上來，“玉大人，你說我怎么就攤上這事。” “怎么了？”我有些...
    開封第一講書人閱讀 176,560評論 0贊 376
  • 道士緝兇錄：失蹤的賣姜人
    文/不壞的土叔 我叫張陵，是天一觀的道長。 經常有香客問我，道長，這世上最難降的妖魔是什么？ 我笑而不...
    開封第一講書人閱讀 63,035評論 1贊 314
  • ?港島之戀（遺憾婚禮）
    正文 為了忘掉前任，我火速辦了婚禮，結果婚禮上，老公的妹妹穿的比我還像新娘。我一直安慰自己，他們只是感情好，可當我...
    茶點故事閱讀 71,814評論 6贊 410
  • 惡毒庶女頂嫁案：這布局不是一般人想出來的
    文/花漫 我一把揭開白布。 她就那樣靜靜地躺著，像睡著了一般。 火紅的嫁衣襯著肌膚如雪。 梳的紋絲不亂的頭發上，一...
    開封第一講書人閱讀 55,224評論 1贊 324
  • 城市分裂傳說
    那天，我揣著相機與錄音，去河邊找鬼。 笑死，一個胖子當著我的面吹牛，可吹牛的內容都是我干的。 我是一名探鬼主播，決...
    沈念sama閱讀 43,301評論 3贊 442
  • 雙鴛鴦連環套：你想象不到人心有多黑
    文/蒼蘭香墨 我猛地睜開眼，長吁一口氣：“原來是場噩夢啊……” “哼！你這毒婦竟也來了？” 一聲冷哼從身側響起，我...
    開封第一講書人閱讀 42,444評論 0贊 288
  • 萬榮殺人案實錄
    序言：老撾萬榮一對情侶失蹤，失蹤者是張志新（化名）和其女友劉穎，沒想到半個月后，有當地人在樹林里發現了一具尸體，經...
    沈念sama閱讀 48,988評論 1贊 335
  • ?護林員之死
    正文 獨居荒郊野嶺守林人離奇死亡，尸身上長有42處帶血的膿包…… 初始之章·張勛 以下內容為張勛視角 年9月15日...
    茶點故事閱讀 40,804評論 3贊 355
  • ?白月光啟示錄
    正文 我和宋清朗相戀三年，在試婚紗的時候發現自己被綠了。 大學時的朋友給我發了我未婚夫和他白月光在一起吃飯的照片。...
    茶點故事閱讀 42,998評論 1贊 370
  • 活死人
    序言：一個原本活蹦亂跳的男人離奇死亡，死狀恐怖，靈堂內的尸體忽然破棺而出，到底是詐尸還是另有隱情，我是刑警寧澤，帶...
    沈念sama閱讀 38,544評論 5贊 360
  • ?日本核電站爆炸內幕
    正文 年R本政府宣布，位于F島的核電站，受9級特大地震影響，放射性物質發生泄漏。R本人自食惡果不足惜，卻給世界環境...
    茶點故事閱讀 44,237評論 3贊 347
  • 男人毒藥：我在死后第九天來索命
    文/蒙蒙 一、第九天 我趴在偏房一處隱蔽的房頂上張望。 院中可真熱鬧，春花似錦、人聲如沸。這莊子的主人今日做“春日...
    開封第一講書人閱讀 34,665評論 0贊 26
  • 一樁弒父案，背后竟有這般陰謀
    文/蒼蘭香墨 我抬頭看了看天上的太陽。三九已至，卻和暖如春，著一層夾襖步出監牢的瞬間，已是汗流浹背。 一陣腳步聲響...
    開封第一講書人閱讀 35,927評論 1贊 287
  • 情欲美人皮
    我被黑心中介騙來泰國打工， 沒想到剛下飛機就差點兒被人妖公主榨干…… 1. 我叫王不留，地道東北人。 一個月前我還...
    沈念sama閱讀 51,706評論 3贊 393
  • 代替公主和親
    正文 我出身青樓，卻偏偏與公主長得像，于是被迫代替她去往敵國和親。 傳聞我的和親對象是個殘疾皇子，可洞房花燭夜當晚...
    茶點故事閱讀 47,993評論 2贊 374