RxJava操作符系列三

Code4Android發表於2016-12-14
RxJava

RxJava操作符系列傳送門

RxJava操作符原始碼
RxJava操作符系列一
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<? 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複製程式碼

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。
今天的這篇文章就到此結束，歡迎大家閱讀，若發現文中有錯誤的地方歡迎留言提出，感謝。

相關文章