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 功能防抖

• 需求場景

示意圖

• 具體使用
  具體請看文章：Android RxJava 實際應用講解：功能防抖

4.2 聯想搜索優化

• 場景說明

示意圖

• 具體使用
  具體請看文章：Android RxJava 實際應用講解：聯想搜索優化

---

5. Demo地址

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

---

6. 總結

• 下面，我將用一張圖總結 RxJava2 中常用的條件 / 布爾操作符

示意圖

作者：Carson_Ho
鏈接：https://www.jianshu.com/p/c3a930a03855
來源：簡書
著作權歸作者所有。商業轉載請聯繫作者獲得授權，非商業轉載請註明出處。