RxJava操作符系列傳送門

前言

在之前的文章，我們介紹了一些Observable的創建以及數據轉換的操作符，其中的一些數據轉換的操作符理解還是有一定的難度的，但是相信如果敲一遍代碼並且修改各種參數的值，去觀察執行的日誌，相信還是很容易的理解的。在官網，每個操作符都給出了圖例，如果你對文字的理解不夠清楚明白，也可以去參考圖示幫助自己理解。在這篇文章中，我們將介紹一些常見的過濾操作符，在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<Integer>() {
            @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

 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

Take

Take操作符可以修改Observable的行爲，只返回前面的N項數據，然後發射完成通知，忽略剩餘的數據。

Observable.range(1,8)
          .take(4)
          .subscribe(new Subscriber<Integer>() {
        @Override
        public void onNext(Integer item) {
           Log.e(TAG, "Next: " + item);
        }

        @Override
        public void onError(Throwable error) {
            Log.e(TAG, "Error: " + error.getMessage());
        }

        @Override
        public void onCompleted() {
           Log.e(TAG, "complete.");
        }
    });

輸出日誌信息

Next: 1
Next: 2
Next: 3
Next: 4
complete

take和skip一樣也有其它兩個重載方法take(long time, TimeUnit unit)，take(long time, TimeUnit unit, Scheduler scheduler)，默認在computation調度器上執行。
take還有變體操作符TakeLast，takeLastBuffer具體執行效果可自行代碼。

Debounce

該操作符指的是過了一段指定的時間還沒發射數據時才發射一個數據，聽着可能有點繞。你可以理解對源Observable間隔期產生的結果進行過濾，如果在這個規定的間隔期內沒有別的結果產生，則將這個結果提交給訂閱者，否則忽略該結果，原理有點像光學防抖
上代碼

Integer[] ints = {1, 2, 3, 4, 5, 6, 7, 8, 9};
        Observable<String> observable = Observable.from(ints).flatMap(new Func1<Integer, Observable<String>>() {
            @Override
            public Observable<String> call(Integer integer) {
                try {
                    Thread.currentThread().sleep(200 * integer);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                return Observable.just(integer + "");
            }
        });
        observable.subscribeOn(Schedulers.newThread())
                .debounce(1, TimeUnit.SECONDS)
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Subscriber<String>() {
                    @Override
                    public void onCompleted() {
                        Log.e(TAG, "onCompleted: ");
                    }

                    @Override
                    public void onError(Throwable e) {
                        Log.e(TAG, "onError: ");
                    }

                    @Override
                    public void onNext(String s) {
                        Log.e(TAG, "onNext: " + s);
                    }
                });

輸出信息

onNext: 4
onNext: 5
onNext: 6
onNext: 7
onNext: 8
onNext: 9
onCompleted:

這個輸出數據不一定一樣，有可能從5開始。

Distinct

這個比較好理解，它就是過濾掉重複的數據，只允許還沒有發射過的數據項通過。
示例代碼

Observable.just(0, 0, 6, 4, 2, 8, 2, 1, 9, 0)
                .distinct()
                .subscribe(new Subscriber<Integer>() {
                    @Override
                    public void onCompleted() {
                        Log.e(TAG, "onCompleted:Distinct ");
                    }

                    @Override
                    public void onError(Throwable e) {
                        Log.e(TAG, "onError:Distinct ");
                    }

                    @Override
                    public void onNext(Integer integer) {
                        Log.e(TAG, "onNext:Distinct " + integer);
                    }
                });

輸出日誌信息

onNext:Distinct 0
onNext:Distinct 6
onNext:Distinct 4
onNext:Distinct 2
onNext:Distinct 8
onNext:Distinct 1
onNext:Distinct 9
onCompleted:Distinct

ElementAt

該操作符獲取原始Observable發射的數據序列指定索引位置的數據項，然後當做自己的唯一數據發射。給它傳遞一個基於0的索引值，它會發射原始Observable數據序列對應索引位置的值，如果你傳遞給elementAt的值爲4，那麼它會發射第5項的數據。如下示例代碼

        Observable.just(0, 0, 6, 4, 2, 8, 2, 1, 9, 0)
                .elementAt(4)
                .subscribe(new Subscriber<Integer>() {
                    @Override
                    public void onCompleted() {
                        Log.e(TAG, "onCompleted:ElementAt ");
                    }

                    @Override
                    public void onError(Throwable e) {
                        Log.e(TAG, "onError:ElementAt ");
                    }

                    @Override
                    public void onNext(Integer integer) {
                        Log.e(TAG, "onNext:ElementAt " + integer);
                    }
                });

輸出日誌信息

onNext:ElementAt 2
onCompleted:ElementAt

IgnoreElements

操作符抑制原始Observable發射的所有數據，只允許它的終止通知（onError或onCompleted）通過，使用該操作符onNext()方法不會執行。

        Observable.just(1, 2, 3).ignoreElements().subscribe(new Subscriber<Integer>() {
            @Override
            public void onCompleted() {
                Log.e(TAG, "onCompleted");
            }

            @Override
            public void onError(Throwable e) {
                Log.e(TAG, "onError");
            }

            @Override
            public void onNext(Integer integer) {
                Log.e(TAG, "onNext");
            }
        });

執行後只會輸出onCompleted。這個操作符效果就如同empty（）方法創建一個空的Observable,只會執行onCompleted()方法，不同的是ignoreElements是對數據源的處理，而empty（）是創建Observable。
今天的這篇文章就到此結束，歡迎大家閱讀，若發現文中有錯誤的地方歡迎留言提出，感謝。

RxJava操作符系列三

RxJava操作符系列傳送門

前言

Filter

ofType

First

firstOrDefault

takeFirst

single

Last

Skip

skipLast

Take

Debounce

Distinct

ElementAt

IgnoreElements

致敬我奮起直追的2016

RxJava操作符系列三

RecyclerView實現滑動刪除和拖拽功能

RxJava操作符系列二

ReactNative WebView組件詳解屬性函數實戰分析 JavaScript 最後補充：

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結