啊灬啊别停灬用力啊黑人,成人久久久久久久久久久,性欧美XXXXX老少交

rxjava 的操作符可是一大亮點(diǎn)啊，之前就算是有相應(yīng)式變成的庫(kù)也沒(méi)有像 rxjava 這樣提供這樣可以變換的操作來(lái)。rxjava 操作符神神奇的地方在于他可以把一大堆無(wú)關(guān)的，單獨(dú)的異步操作編制成一條執(zhí)行的鏈子出來(lái)，讓這些異步操作按照指定的順序執(zhí)行，其中我們可以執(zhí)行大量的無(wú)法想想的操作，可以上上一個(gè)異步返回的數(shù)據(jù)，加工變成一個(gè)新的數(shù)據(jù)交給下一額個(gè)異步操作；可以把幾個(gè)異步做關(guān)聯(lián)，一個(gè)執(zhí)行不完，下一個(gè)不能執(zhí)行，一個(gè)執(zhí)行不過(guò)去，之后的也不能執(zhí)行；可以把異步并行執(zhí)行，知道最后一個(gè)異步返回?cái)?shù)據(jù)，然后結(jié)合這幾個(gè)數(shù)據(jù)，返回一個(gè)集合數(shù)據(jù)，等等這些操作再 rxjava 之前都是無(wú)法想象的，都是不敢想的，這決然都能封裝出來(lái)，但是 rxjava 還就是做到了，究其原因害的歸功于響應(yīng)式編程的思路啊。

廢話不來(lái)了，rxjava 的操作符根據(jù)目的是分為幾種的，我總結(jié)分類一下，便于大家記憶：

創(chuàng)建操作符

使用這類操作符可以不費(fèi)力的創(chuàng)建出 Observable 對(duì)象

基本創(chuàng)建
* create
快速創(chuàng)建，發(fā)送數(shù)據(jù)
- just
- from
- fromArray
- fromIterable
- never - 什么都不走
- empty - 只走 Complete 事件
- error - 走 error 事件
延遲創(chuàng)建
- defer - 延遲創(chuàng)建
- timer - 延遲發(fā)送
- interval - 延遲發(fā)送
- intervalRange - 定制循環(huán)
- range - 計(jì)數(shù)發(fā)射
- rangeLong - 計(jì)數(shù)發(fā)射
- repeat - 重復(fù)發(fā)射

變換操作符

可以把一個(gè)異步獲取的數(shù)據(jù)進(jìn)行操作，改變成另一個(gè)類型的數(shù)據(jù)發(fā)射，或是把一個(gè) Observable 異步操作變換成另一個(gè) Observable 異步操作

變換操作符
- map
- flatMap - 無(wú)序
- concatMap - 有序
- buffer
- groupBy

組合操作符

組合操作符可以把多個(gè)異步操作合并或是鏈接起來(lái)，這是日常我們最常用的場(chǎng)景了

多個(gè) Observable 操作
- concat - 多個(gè) Observable 按順序執(zhí)行
- concatArray -
- merge - 多個(gè) Observable 并行，同時(shí)執(zhí)行，不保證數(shù)據(jù)順序
- mergeArray
- concatDelayError - 錯(cuò)誤兼容處理
- mergeDelayError
- zip - 多個(gè) Observable 并行，合并多個(gè) Observable 的數(shù)據(jù)，然后返回一個(gè)總體的數(shù)據(jù)
- combineLatest
- combineLatestDelayError
- reduce
- collect
添加預(yù)處理
- startWith - 添加預(yù)處理數(shù)據(jù)
- startWithArray
統(tǒng)計(jì)
- count - 計(jì)數(shù)

功能操作符

條件操作符：
- takeWhile - 只發(fā)送滿足條件的,一旦碰到不滿足的,后面的均不會(huì)發(fā)送,complete 結(jié)束
- takeUntil - 一直發(fā)送,直到滿足條件時(shí)結(jié)束,并且,滿足條件的那一個(gè)也會(huì)發(fā)送,之后發(fā)complete 結(jié)束
判斷操作符
* all - 只有全部滿足的時(shí)候才會(huì)返回 true
* contains - 是否包含指定參數(shù)
* isEmpty - 是否為空
刷選操作符
* filter - 只發(fā)射符合條件的數(shù)據(jù)，數(shù)據(jù)從頭遍歷到尾，碰到不符合的數(shù)據(jù)也不會(huì)中斷發(fā)射
* ofType - 只發(fā)射符合類型的數(shù)據(jù)，數(shù)據(jù)從頭遍歷到尾，碰到不符合的數(shù)據(jù)也不會(huì)中斷發(fā)射
* elementAt - 選擇指定位置的元素,下標(biāo)準(zhǔn)許越界,如果越界,可以指定默認(rèn)值
* firstElement / lastElement - 獲得第一個(gè)數(shù)據(jù) / 獲得最后一個(gè)數(shù)據(jù)
* distinct - 過(guò)濾重復(fù),只要出現(xiàn)過(guò)得就不會(huì)再出現(xiàn)
* distinctUntilChanged - 過(guò)濾連續(xù)重復(fù)數(shù)據(jù)，注意必須是連續(xù)重復(fù)的才有有效
* take / takeLast - 從頭開(kāi)始 / 最后開(kāi)始獲取指定數(shù)目的數(shù)據(jù),如果數(shù)據(jù)量小于指定數(shù)目,則進(jìn)入 error
* skip / skipLast - 正序 / 倒序跳過(guò)指定 count,如果不足,則會(huì)進(jìn)入 onError
* throttleFirst / throttleLast - 指定時(shí)間間隔內(nèi)取第一個(gè) / 最后一個(gè) 數(shù)據(jù)
* throttleWithTimeout / debounce - 2次數(shù)據(jù)間隔超過(guò)指定時(shí)間才有效，若一直沒(méi)有合適的數(shù)據(jù)，默認(rèn)取最后一個(gè)數(shù)據(jù)

其他：
- delay - 延遲
- onErrorReturn - 錯(cuò)誤處理，不阻斷操作
- retry - 重試，內(nèi)容很多
- repeat - 重復(fù)發(fā)射

創(chuàng)建操作符

just

        Observable.just("AA","BB")
                .subscribe(new Consumer<String>() {
                    @Override
                    public void accept(String s) throws Exception {
                        Log.d("AA", "resylt:" + s);
                    }
                });

just 可以接受一個(gè)長(zhǎng)度最多為 10 的可變參數(shù)

注意 just 只創(chuàng)建出 1 個(gè) Observable 對(duì)象，復(fù)數(shù)的數(shù)據(jù)都是挨個(gè)發(fā)送出去，而不是創(chuàng)建多個(gè) Observable 對(duì)象

    public static <T> Observable<T> just(T item1, T item2) {
        ObjectHelper.requireNonNull(item1, "The first item is null");
        ObjectHelper.requireNonNull(item2, "The second item is null");

        return fromArray(item1, item2);
    }

看源碼就是返回一個(gè) Observable 對(duì)象

    public static <T> Observable<T> fromArray(T... items) {
        ObjectHelper.requireNonNull(items, "items is null");
        if (items.length == 0) {
            return empty();
        } else
        if (items.length == 1) {
            return just(items[0]);
        }
        return RxJavaPlugins.onAssembly(new ObservableFromArray<T>(items));
    }

public final class ObservableFromArray<T> extends Observable<T> {
    final T[] array;
    public ObservableFromArray(T[] array) {
        this.array = array;
    }

這時(shí)最終返回一個(gè)可以保存列數(shù)數(shù)據(jù)的 Observable 類型對(duì)象 ObservableFromArray

fromArray / fromIterable

fromArray / fromIterable 和 just 什么什么區(qū)別，區(qū)別就是 fromArray / fromIterable 的數(shù)據(jù)不限數(shù)量，fromArray 和 fromIterable 接受的數(shù)據(jù)集合類不同罷了

但是必須注意，他們都是只創(chuàng)建一個(gè) Observable 對(duì)象，然后遍歷集合，挨個(gè)發(fā)射數(shù)據(jù)

empty / error / never

<-- empty()  -->
// 該方法創(chuàng)建的被觀察者對(duì)象發(fā)送事件的特點(diǎn)：僅發(fā)送Complete事件，直接通知完成
Observable observable1=Observable.empty(); 
// 即觀察者接收后會(huì)直接調(diào)用onCompleted（）

<-- error()  -->
// 該方法創(chuàng)建的被觀察者對(duì)象發(fā)送事件的特點(diǎn)：僅發(fā)送Error事件，直接通知異常
// 可自定義異常
Observable observable2=Observable.error(new RuntimeException())
// 即觀察者接收后會(huì)直接調(diào)用onError（）

<-- never()  -->
// 該方法創(chuàng)建的被觀察者對(duì)象發(fā)送事件的特點(diǎn)：不發(fā)送任何事件
Observable observable3=Observable.never();
// 即觀察者接收后什么都不調(diào)用

defer 延遲創(chuàng)建

通過(guò) Observable工廠方法創(chuàng)建被觀察者對(duì)象Observable，每次訂閱后，都會(huì)得到一個(gè)剛創(chuàng)建的最新的Observable對(duì)象，這可以確保Observable對(duì)象里的數(shù)據(jù)是最新的

舉個(gè)例子，一個(gè) int 參數(shù)，我們?cè)趧?chuàng)建 Observable 之后修改這個(gè) int 的值，看看可能發(fā)射的數(shù)據(jù)是修改之前的還是之后的

        index = 10;

        Observable<Integer> just = Observable.just(index);

        index = 20;

        just.subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Consumer<Integer>() {
                    @Override
                    public void accept(Integer index) throws Exception {
                        Log.d(tag, "index:" + index);
                    }
                });

Snip20171011_29.png

看結(jié)果是修改之前的數(shù)值，那我們用 defer 來(lái)看看

  index = 10;

        Observable<Integer> defer = Observable.defer(new Callable<ObservableSource<Integer>>() {
            @Override
            public ObservableSource<Integer> call() throws Exception {
                return Observable.just(index);
            }
        });

        index = 20;

        defer.subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Consumer<Integer>() {
                    @Override
                    public void accept(Integer index) throws Exception {
                        Log.d(tag, "index:" + index);
                    }
                });

Snip20171011_30.png

這次打印的是修改之后的值，哈哈，大家不必?fù)?dān)心的，因?yàn)榛A(chǔ)數(shù)據(jù)類型是值傳遞才會(huì)這樣，有前后不一致的情況，引用類型就沒(méi)事啊，大家放心的修改，我做過(guò)測(cè)試修改的引用類型參數(shù)可以正常顯示的哦

  mBook.setName("AAA");

        Observable<Book> just = Observable.just(mBook);

        mBook.setName("BBB");

        just.subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Consumer<Book>() {
                    @Override
                    public void accept(Book book) throws Exception {
                        Log.d(tag, "book-name:" + book.getName());
                    }
                });

Snip20171011_31.png

說(shuō)實(shí)話這個(gè) defer 有些像 AAC 的 liveData ，只不過(guò)沒(méi)有 liveData 這么友好。

timer / interval

timer 和 interval 都是延遲操作，區(qū)別是 timer 只執(zhí)行一次，interval 會(huì)一直執(zhí)行

需要注意的是第一次發(fā)送都是在指定的延遲時(shí)間之后進(jìn)行的。

   // 
   Observable.timer(3, TimeUnit.SECONDS) / interval(3, TimeUnit.SECONDS)
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Consumer<Long>() {
                    @Override
                    public void accept(Long aLong) throws Exception {
                        Log.d(tag, "time:" + aLong);
                    }
                });

range / rangeLong

計(jì)數(shù)發(fā)射，指定開(kāi)始值，指定數(shù)據(jù)發(fā)射次數(shù)，每一次數(shù)據(jù)++，range 支持 int 類型，rangeLong 支持 long 類型

 Observable.range(0, 5)
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Consumer<Integer>() {
                    @Override
                    public void accept(Integer integer) throws Exception {
                        Log.d(tag, "range:" + integer);
                    }
                });

Snip20171011_26.png

intervalRange

指定開(kāi)始數(shù)值，指定發(fā)射次數(shù)，指定首次執(zhí)行延遲時(shí)間

// 參數(shù)說(shuō)明：
        // 參數(shù)1 = 事件序列起始點(diǎn)；
        // 參數(shù)2 = 事件數(shù)量；
        // 參數(shù)3 = 第1次事件延遲發(fā)送時(shí)間；
        // 參數(shù)4 = 間隔時(shí)間數(shù)字；
        // 參數(shù)5 = 時(shí)間單位
        Observable.intervalRange(3,10,2, 1, TimeUnit.SECONDS)
                // 該例子發(fā)送的事件序列特點(diǎn)：
                // 1. 從3開(kāi)始，一共發(fā)送10個(gè)事件；
                // 2. 第1次延遲2s發(fā)送，之后每隔2秒產(chǎn)生1個(gè)數(shù)字（從0開(kāi)始遞增1，無(wú)限個(gè)）
                .subscribe(new Observer<Long>() {
                    @Override
                    public void onSubscribe(Disposable d) {
                        Log.d(TAG, "開(kāi)始采用subscribe連接");
                    }
                    // 默認(rèn)最先調(diào)用復(fù)寫的 onSubscribe（）

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

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

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

                });

944365-ed225f309949bdeb.png

repeat 重復(fù)發(fā)射

repeat 顧名思義，就是重復(fù)發(fā)射，一般結(jié)合其他的操作符來(lái)使用，參數(shù)就是我們想要重復(fù)發(fā)射的次數(shù)

  Observable
                .range(0, 5)
                .repeat(2)
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Consumer<Integer>() {
                    @Override
                    public void accept(Integer integer) throws Exception {
                        Log.d(tag, "range:" + integer);
                    }
                });

Snip20171011_27.png

變換操作符

map

        Observable
                .just(11)
                .map(new Function<Integer, String>() {
                    @Override
                    public String apply(Integer integer) throws Exception {
                        return "AA";
                    }
                })
                .subscribe(new Consumer<String>() {
                    @Override
                    public void accept(String s) throws Exception {

                    }
                });

map 把一個(gè)數(shù)據(jù)類型的 Observable 轉(zhuǎn)成另一個(gè)類型的 Observable

flatmap

 Observable
                .just(11)
                .flatMap(new Function<Integer, ObservableSource<String>>() {
                    @Override
                    public ObservableSource<String> apply(Integer integer) throws Exception {
                        return Observable.just("AA");
                    }
                })
                .subscribe(new Consumer<String>() {
                    @Override
                    public void accept(String o) throws Exception {

                    }
                });

flatmap 就比 map 要復(fù)雜一些了，map 不管數(shù)據(jù)有多少，只是一個(gè)數(shù)據(jù)類型的 Observable 轉(zhuǎn)成另一個(gè)類型的 Observable

而 flatmap 會(huì)把沒(méi)每一個(gè)數(shù)據(jù)都轉(zhuǎn)成成一個(gè) 新的 Observable ，然后最總匯總所有的 Observable 統(tǒng)一生成一個(gè)最終的 Observable 。

原理：

為事件序列中每個(gè)事件都創(chuàng)建一個(gè) Observable 對(duì)象；
將對(duì)每個(gè) 原始事件轉(zhuǎn)換后的新事件都放入到對(duì)應(yīng) Observable對(duì)象；
將新建的每個(gè)Observable 都合并到一個(gè) 新建的、總的Observable 對(duì)象；
新建的、總的Observable 對(duì)象將新合并的事件序列發(fā)送給觀察者（Observer）

所以 flatmap 獲得的最終的 Observable 里面數(shù)據(jù)是無(wú)序的，這點(diǎn)是需要注意的。flatmap 過(guò)程中有大量的 Observable 對(duì)象產(chǎn)生銷毀，很消耗資源的，我們能用 map 就盡量不要用 flatmap

ConcatMap

ConcatMap 和 flatmap 一樣，flatmap 處理過(guò)的數(shù)據(jù)是無(wú)序的，ConcatMap 是有序的，就這點(diǎn)區(qū)別

Buffer

隔指定補(bǔ)償，從緩存里循環(huán)取出指定數(shù)據(jù)，感覺(jué)這個(gè)沒(méi)什么用啊，至少 android 里體會(huì)不到

// 被觀察者 需要發(fā)送5個(gè)數(shù)字
        Observable.just(1, 2, 3, 4, 5)
                .buffer(3, 1) // 設(shè)置緩存區(qū)大小 & 步長(zhǎng)
                                    // 緩存區(qū)大小 = 每次從被觀察者中獲取的事件數(shù)量
                                    // 步長(zhǎng) = 每次獲取新事件的數(shù)量
                .subscribe(new Observer<List<Integer>>() {
                    @Override
                    public void onSubscribe(Disposable d) {

                    }
                    @Override
                    public void onNext(List<Integer> stringList) {
                        //
                        Log.d(TAG, " 緩存區(qū)里的事件數(shù)量 = " +  stringList.size());
                        for (Integer value : stringList) {
                            Log.d(TAG, " 事件 = " + value);
                        }
                    }

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

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

944365-f1d4e320b7c62dd9.png

組合操作符

concat 、 concatArray

observable 順序操作符，把多個(gè) observable 按照前后順序串行執(zhí)行，執(zhí)行完一個(gè)才能執(zhí)行下一個(gè)，一個(gè) error 了直接中斷，不在往下走了，另外前一個(gè) observable 若有多個(gè)數(shù)據(jù)，只有等前一個(gè) observable 的復(fù)數(shù)數(shù)據(jù)全部發(fā)射完畢，才能執(zhí)行下一個(gè) observable 的數(shù)據(jù)發(fā)射任務(wù)

concat 只能就收最多4個(gè)數(shù)據(jù)，concatArray 沒(méi)有數(shù)量限制

        Observable.concat(Observable.just(11, 22), Observable.just(33, 44))
                .subscribe(new Consumer<Integer>() {
                    @Override
                    public void accept(Integer integer) throws Exception {
                        Log.d("CC", "result:" + integer);
                    }
                });

Snip20180403_7.png

merge / mergeArray

observable 同事執(zhí)行操作符，把多個(gè) observable 并行執(zhí)行，所有的 observable 均同時(shí)執(zhí)行，也沒(méi)有前后之分了

                Observable.merge(
                        Observable.intervalRange(20, 10, 2, 1, TimeUnit.SECONDS)
                        , Observable.intervalRange(1, 10, 2, 1, TimeUnit.SECONDS))
                        .subscribe(new Consumer<Long>() {
                            @Override
                            public void accept(Long integer) throws Exception {
                                Log.d("CC", "result:" + integer);
                            }
                        });

Snip20180403_9.png

concatDelayError / mergeDelayError

用來(lái)處理 concat 、 merge 中 error 的， concat 、 merge 中若有一個(gè)數(shù)據(jù) error 了，就會(huì)結(jié)束整個(gè)操作，這可能不是我們想要的，那么這個(gè)相應(yīng)的 DelayError 就可以讓 error 不阻斷操作，在數(shù)據(jù)都發(fā)射后在執(zhí)行 error 操作

Observable.concatArrayDelayError(
                Observable.create(new ObservableOnSubscribe<Integer>() {
                    @Override
                    public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {

                        emitter.onNext(1);
                        emitter.onNext(2);
                        emitter.onNext(3);
                        emitter.onError(new NullPointerException()); // 發(fā)送Error事件，因?yàn)槭褂昧薱oncatDelayError，所以第2個(gè)Observable將會(huì)發(fā)送事件，等發(fā)送完畢后，再發(fā)送錯(cuò)誤事件
                        emitter.onComplete();
                    }
                }),
                Observable.just(4, 5, 6))
                .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, "對(duì)Error事件作出響應(yīng)");
                    }

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

944365-804c8472fc60eb6a.png

zip

數(shù)據(jù)合并，多 Observable 并發(fā)執(zhí)行，組合多個(gè) Observable 的所有單次數(shù)據(jù)返回一個(gè)綜合的數(shù)據(jù)

                Observable
                        .zip(
                                Observable.intervalRange(100, 5, 2, 5, TimeUnit.SECONDS),
                                Observable.intervalRange(200, 5, 2, 5, TimeUnit.SECONDS),
                                new BiFunction<Long, Long, String>() {
                                    @Override
                                    public String apply(Long aLong, Long aLong2) throws Exception {
                                        return aLong + " / " + aLong2;
                                    }
                                })
                        .subscribe(new Consumer<String>() {
                            @Override
                            public void accept(String s) throws Exception {
                                Log.d("CC", "result: " + s);
                            }
                        });

Snip20180403_10.png

看上面的例子，每一次返回的數(shù)據(jù)都是 5秒而不是 10秒，所以證明 zip 組合的 observable 是并發(fā)執(zhí)行的，時(shí)間間隔由單次執(zhí)行最慢的 observable 決定

reduce

把前2個(gè)數(shù)據(jù)交給第三個(gè)數(shù)據(jù)，后面的以此類推

Observable.just(1,2,3,4)
                .reduce(new BiFunction<Integer, Integer, Integer>() {
                    // 在該復(fù)寫方法中復(fù)寫聚合的邏輯
                    @Override
                    public Integer apply(@NonNull Integer s1, @NonNull Integer s2) throws Exception {
                        Log.e(TAG, "本次計(jì)算的數(shù)據(jù)是： "+s1 +" 乘 "+ s2);
                        return s1 * s2;
                        // 本次聚合的邏輯是：全部數(shù)據(jù)相乘起來(lái)
                        // 原理：第1次取前2個(gè)數(shù)據(jù)相乘，之后每次獲取到的數(shù)據(jù) = 返回的數(shù)據(jù)x原始下1個(gè)數(shù)據(jù)每
                    }
                }).subscribe(new Consumer<Integer>() {
            @Override
            public void accept(@NonNull Integer s) throws Exception {
                Log.e(TAG, "最終計(jì)算的結(jié)果是： "+s);

            }
        });

944365-3f63477c864d7aae.png

collect

把所有發(fā)送的數(shù)據(jù)最終收集到一個(gè)集合里統(tǒng)一發(fā)送數(shù)據(jù)

Observable.just(1, 2, 3 ,4, 5, 6)
                .collect(
                        // 1. 創(chuàng)建數(shù)據(jù)結(jié)構(gòu)（容器），用于收集被觀察者發(fā)送的數(shù)據(jù)
                        new Callable<ArrayList<Integer>>() {
                            @Override
                            public ArrayList<Integer> call() throws Exception {
                                return new ArrayList<>();
                            }
                            // 2. 對(duì)發(fā)送的數(shù)據(jù)進(jìn)行收集
                        }, new BiConsumer<ArrayList<Integer>, Integer>() {
                            @Override
                            public void accept(ArrayList<Integer> list, Integer integer)
                                    throws Exception {
                                // 參數(shù)說(shuō)明：list = 容器，integer = 后者數(shù)據(jù)
                                list.add(integer);
                                // 對(duì)發(fā)送的數(shù)據(jù)進(jìn)行收集
                            }
                        }).subscribe(new Consumer<ArrayList<Integer>>() {
            @Override
            public void accept(@NonNull ArrayList<Integer> s) throws Exception {
                Log.e(TAG, "本次發(fā)送的數(shù)據(jù)是： "+s);

            }
        });

944365-ab51b84d6a373330.png

startWith / startWithArray

在正式發(fā)送數(shù)據(jù)前先發(fā)送指定數(shù)據(jù)

                Observable
                        .just(1, 2, 3, 4, 5, 6)
                        .startWith(0)
                        .startWithArray(-1, -2)
                        .subscribe(new Consumer<Integer>() {
                            @Override
                            public void accept(Integer s) throws Exception {
                                Log.d("CC", "result: " + s);
                            }
                        });

Snip20180403_11.png

count

統(tǒng)計(jì)發(fā)送次數(shù)，這個(gè)不知道實(shí)際沒(méi)有沒(méi)用

// 注：返回結(jié)果 = Long類型
        Observable.just(1, 2, 3, 4)
                  .count()
                  .subscribe(new Consumer<Long>() {
                    @Override
                    public void accept(Long aLong) throws Exception {
                        Log.e(TAG, "發(fā)送的事件數(shù)量 =  "+aLong);

                    }
                });

944365-45d279a5773edfc2.png

功能操作符

delay

延遲操作，和 time 不同的是 delay 不能創(chuàng)建出 observable 對(duì)象來(lái)

        Observable
                .just(1)
                .delay(2, TimeUnit.SECONDS)
                .subscribe(new Consumer<Integer>() {
                    @Override
                    public void accept(Integer integer) throws Exception {

                    }
                });

do

do 操作符包含游很多方法，都是在相應(yīng)的方法之前執(zhí)行

Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> e) throws Exception {
                e.onNext(1);
                e.onNext(2);
                e.onNext(3);
                e.onError(new Throwable("發(fā)生錯(cuò)誤了"));
                 }
               })
                // 1. 當(dāng)Observable每發(fā)送1次數(shù)據(jù)事件就會(huì)調(diào)用1次
                .doOnEach(new Consumer<Notification<Integer>>() {
                    @Override
                    public void accept(Notification<Integer> integerNotification) throws Exception {
                        Log.d(TAG, "doOnEach: " + integerNotification.getValue());
                    }
                })
                // 2. 執(zhí)行Next事件前調(diào)用
                .doOnNext(new Consumer<Integer>() {
                    @Override
                    public void accept(Integer integer) throws Exception {
                        Log.d(TAG, "doOnNext: " + integer);
                    }
                })
                // 3. 執(zhí)行Next事件后調(diào)用
                .doAfterNext(new Consumer<Integer>() {
                    @Override
                    public void accept(Integer integer) throws Exception {
                        Log.d(TAG, "doAfterNext: " + integer);
                    }
                })
                // 4. Observable正常發(fā)送事件完畢后調(diào)用
                .doOnComplete(new Action() {
                    @Override
                    public void run() throws Exception {
                        Log.e(TAG, "doOnComplete: ");
                    }
                })
                // 5. Observable發(fā)送錯(cuò)誤事件時(shí)調(diào)用
                .doOnError(new Consumer<Throwable>() {
                    @Override
                    public void accept(Throwable throwable) throws Exception {
                        Log.d(TAG, "doOnError: " + throwable.getMessage());
                    }
                })
                // 6. 觀察者訂閱時(shí)調(diào)用
                .doOnSubscribe(new Consumer<Disposable>() {
                    @Override
                    public void accept(@NonNull Disposable disposable) throws Exception {
                        Log.e(TAG, "doOnSubscribe: ");
                    }
                })
                // 7. Observable發(fā)送事件完畢后調(diào)用，無(wú)論正常發(fā)送完畢 / 異常終止
                .doAfterTerminate(new Action() {
                    @Override
                    public void run() throws Exception {
                        Log.e(TAG, "doAfterTerminate: ");
                    }
                })
                // 8. 最后執(zhí)行
                .doFinally(new Action() {
                    @Override
                    public void run() throws Exception {
                        Log.e(TAG, "doFinally: ");
                    }
                })
                .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, "對(duì)Error事件作出響應(yīng)");
                    }

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

944365-11213ae3bb321197.png

onErrorReturn

錯(cuò)誤處理，可以先于 onError 接受錯(cuò)誤信息，然后返回一個(gè)正常信息，不至于中斷整個(gè)操作

Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> e) throws Exception {
                e.onNext(1);
                e.onNext(2);
                e.onError(new Throwable("發(fā)生錯(cuò)誤了"));
                 }
               })
                .onErrorReturn(new Function<Throwable, Integer>() {
                    @Override
                    public Integer apply(@NonNull Throwable throwable) throws Exception {
                        // 捕捉錯(cuò)誤異常
                        Log.e(TAG, "在onErrorReturn處理了錯(cuò)誤: "+throwable.toString() );

                        return 666;
                        // 發(fā)生錯(cuò)誤事件后，發(fā)送一個(gè)"666"事件，最終正常結(jié)束
                    }
                })
                .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, "對(duì)Error事件作出響應(yīng)");
                    }

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

944365-53f108767f179f0b.png

onErrorResumeNext / onExceptionResumeNext

和 onErrorReturn 差不多，遇到錯(cuò)誤會(huì)拋出一個(gè)新的 Observable 來(lái)，這2個(gè)對(duì)象一個(gè)接受 Throwable 類型的錯(cuò)誤，一個(gè)接受 Exception 的錯(cuò)誤

retry 、retryWhen

重試，這個(gè)比較重要了，當(dāng)收到 error 決定是重新幾次執(zhí)行幾次，什么條件執(zhí)行

retry 共有5種重載方法

<-- 1. retry（） -->
// 作用：出現(xiàn)錯(cuò)誤時(shí)，讓被觀察者重新發(fā)送數(shù)據(jù)
// 注：若一直錯(cuò)誤，則一直重新發(fā)送

<-- 2. retry（long time） -->
// 作用：出現(xiàn)錯(cuò)誤時(shí)，讓被觀察者重新發(fā)送數(shù)據(jù)（具備重試次數(shù)限制
// 參數(shù) = 重試次數(shù)
 
<-- 3. retry（Predicate predicate） -->
// 作用：出現(xiàn)錯(cuò)誤后，判斷是否需要重新發(fā)送數(shù)據(jù)（若需要重新發(fā)送& 持續(xù)遇到錯(cuò)誤，則持續(xù)重試）
// 參數(shù) = 判斷邏輯

<--  4. retry（new BiPredicate<Integer, Throwable>） -->
// 作用：出現(xiàn)錯(cuò)誤后，判斷是否需要重新發(fā)送數(shù)據(jù)（若需要重新發(fā)送 & 持續(xù)遇到錯(cuò)誤，則持續(xù)重試
// 參數(shù) =  判斷邏輯（傳入當(dāng)前重試次數(shù) & 異常錯(cuò)誤信息）

<-- 5. retry（long time,Predicate predicate） -->
// 作用：出現(xiàn)錯(cuò)誤后，判斷是否需要重新發(fā)送數(shù)據(jù)（具備重試次數(shù)限制
// 參數(shù) = 設(shè)置重試次數(shù) & 判斷邏輯

<-- 1. retry（） -->
// 作用：出現(xiàn)錯(cuò)誤時(shí)，讓被觀察者重新發(fā)送數(shù)據(jù)
// 注：若一直錯(cuò)誤，則一直重新發(fā)送

Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> e) throws Exception {
                e.onNext(1);
                e.onNext(2);
                e.onError(new Exception("發(fā)生錯(cuò)誤了"));
                e.onNext(3);
                 }
               })
                .retry() // 遇到錯(cuò)誤時(shí)，讓被觀察者重新發(fā)射數(shù)據(jù)（若一直錯(cuò)誤，則一直重新發(fā)送
                .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, "對(duì)Error事件作出響應(yīng)");
                    }

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


<-- 2. retry（long time） -->
// 作用：出現(xiàn)錯(cuò)誤時(shí)，讓被觀察者重新發(fā)送數(shù)據(jù)（具備重試次數(shù)限制
// 參數(shù) = 重試次數(shù)
Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> e) throws Exception {
                e.onNext(1);
                e.onNext(2);
                e.onError(new Exception("發(fā)生錯(cuò)誤了"));
                e.onNext(3);
                 }
               })
                .retry(3) // 設(shè)置重試次數(shù) = 3次
                .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, "對(duì)Error事件作出響應(yīng)");
                    }

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

<-- 3. retry（Predicate predicate） -->
// 作用：出現(xiàn)錯(cuò)誤后，判斷是否需要重新發(fā)送數(shù)據(jù)（若需要重新發(fā)送& 持續(xù)遇到錯(cuò)誤，則持續(xù)重試）
// 參數(shù) = 判斷邏輯
Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> e) throws Exception {
                e.onNext(1);
                e.onNext(2);
                e.onError(new Exception("發(fā)生錯(cuò)誤了"));
                e.onNext(3);
                 }
               })
                // 攔截錯(cuò)誤后，判斷是否需要重新發(fā)送請(qǐng)求
                .retry(new Predicate<Throwable>() {
                    @Override
                    public boolean test(@NonNull Throwable throwable) throws Exception {
                        // 捕獲異常
                        Log.e(TAG, "retry錯(cuò)誤: "+throwable.toString());

                        //返回false = 不重新重新發(fā)送數(shù)據(jù) & 調(diào)用觀察者的onError結(jié)束
                        //返回true = 重新發(fā)送請(qǐng)求（若持續(xù)遇到錯(cuò)誤，就持續(xù)重新發(fā)送）
                        return true;
                    }
                })
                .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, "對(duì)Error事件作出響應(yīng)");
                    }

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

<--  4. retry（new BiPredicate<Integer, Throwable>） -->
// 作用：出現(xiàn)錯(cuò)誤后，判斷是否需要重新發(fā)送數(shù)據(jù)（若需要重新發(fā)送 & 持續(xù)遇到錯(cuò)誤，則持續(xù)重試
// 參數(shù) =  判斷邏輯（傳入當(dāng)前重試次數(shù) & 異常錯(cuò)誤信息）
Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> e) throws Exception {
                e.onNext(1);
                e.onNext(2);
                e.onError(new Exception("發(fā)生錯(cuò)誤了"));
                e.onNext(3);
                 }
               })

                // 攔截錯(cuò)誤后，判斷是否需要重新發(fā)送請(qǐng)求
                .retry(new BiPredicate<Integer, Throwable>() {
                    @Override
                    public boolean test(@NonNull Integer integer, @NonNull Throwable throwable) throws Exception {
                        // 捕獲異常
                        Log.e(TAG, "異常錯(cuò)誤 =  "+throwable.toString());

                        // 獲取當(dāng)前重試次數(shù)
                        Log.e(TAG, "當(dāng)前重試次數(shù) =  "+integer);

                        //返回false = 不重新重新發(fā)送數(shù)據(jù) & 調(diào)用觀察者的onError結(jié)束
                        //返回true = 重新發(fā)送請(qǐng)求（若持續(xù)遇到錯(cuò)誤，就持續(xù)重新發(fā)送）
                        return true;
                    }
                })
                .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, "對(duì)Error事件作出響應(yīng)");
                    }

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


<-- 5. retry（long time,Predicate predicate） -->
// 作用：出現(xiàn)錯(cuò)誤后，判斷是否需要重新發(fā)送數(shù)據(jù)（具備重試次數(shù)限制
// 參數(shù) = 設(shè)置重試次數(shù) & 判斷邏輯
Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> e) throws Exception {
                e.onNext(1);
                e.onNext(2);
                e.onError(new Exception("發(fā)生錯(cuò)誤了"));
                e.onNext(3);
                 }
               })
                // 攔截錯(cuò)誤后，判斷是否需要重新發(fā)送請(qǐng)求
                .retry(3, new Predicate<Throwable>() {
                    @Override
                    public boolean test(@NonNull Throwable throwable) throws Exception {
                        // 捕獲異常
                        Log.e(TAG, "retry錯(cuò)誤: "+throwable.toString());

                        //返回false = 不重新重新發(fā)送數(shù)據(jù) & 調(diào)用觀察者的onError（）結(jié)束
                        //返回true = 重新發(fā)送請(qǐng)求（最多重新發(fā)送3次）
                        return true;
                    }
                })
                .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, "對(duì)Error事件作出響應(yīng)");
                    }

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

Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> e) throws Exception {
                e.onNext(1);
                e.onNext(2);
                e.onError(new Exception("發(fā)生錯(cuò)誤了"));
                e.onNext(3);
            }
        })
                // 遇到error事件才會(huì)回調(diào)
                .retryWhen(new Function<Observable<Throwable>, ObservableSource<?>>() {
                    
                    @Override
                    public ObservableSource<?> apply(@NonNull Observable<Throwable> throwableObservable) throws Exception {
                        // 參數(shù)Observable<Throwable>中的泛型 = 上游操作符拋出的異常，可通過(guò)該條件來(lái)判斷異常的類型
                        // 返回Observable<?> = 新的被觀察者 Observable（任意類型）
                        // 此處有兩種情況：
                            // 1. 若 新的被觀察者 Observable發(fā)送的事件 = Error事件，那么 原始Observable則不重新發(fā)送事件：
                            // 2. 若 新的被觀察者 Observable發(fā)送的事件 = Next事件 ，那么原始的Observable則重新發(fā)送事件：
                        return throwableObservable.flatMap(new Function<Throwable, ObservableSource<?>>() {
                            @Override
                            public ObservableSource<?> apply(@NonNull Throwable throwable) throws Exception {

                                // 1. 若返回的Observable發(fā)送的事件 = Error事件，則原始的Observable不重新發(fā)送事件
                                // 該異常錯(cuò)誤信息可在觀察者中的onError（）中獲得
                                 return Observable.error(new Throwable("retryWhen終止啦"));
                                
                                // 2. 若返回的Observable發(fā)送的事件 = Next事件，則原始的Observable重新發(fā)送事件（若持續(xù)遇到錯(cuò)誤，則持續(xù)重試）
                                 // return Observable.just(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, "對(duì)Error事件作出響應(yīng)" + e.toString());
                        // 獲取異常錯(cuò)誤信息
                    }

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

repeat / repeatWhen

重復(fù)發(fā)射，這個(gè)也是可以決定從復(fù)發(fā)射幾次，什么條件從復(fù)發(fā)射

Observable.just(1,2,4).repeatWhen(new Function<Observable<Object>, ObservableSource<?>>() {
            @Override
            // 在Function函數(shù)中，必須對(duì)輸入的 Observable<Object>進(jìn)行處理，這里我們使用的是flatMap操作符接收上游的數(shù)據(jù)
            public ObservableSource<?> apply(@NonNull Observable<Object> objectObservable) throws Exception {
                // 將原始 Observable 停止發(fā)送事件的標(biāo)識(shí)（Complete（） /  Error（））轉(zhuǎn)換成1個(gè) Object 類型數(shù)據(jù)傳遞給1個(gè)新被觀察者（Observable）
                // 以此決定是否重新訂閱 & 發(fā)送原來(lái)的 Observable
                // 此處有2種情況：
                // 1. 若新被觀察者（Observable）返回1個(gè)Complete（） /  Error（）事件，則不重新訂閱 & 發(fā)送原來(lái)的 Observable
                // 2. 若新被觀察者（Observable）返回其余事件，則重新訂閱 & 發(fā)送原來(lái)的 Observable
                return objectObservable.flatMap(new Function<Object, ObservableSource<?>>() {
                    @Override
                    public ObservableSource<?> apply(@NonNull Object throwable) throws Exception {

                        // 情況1：若新被觀察者（Observable）返回1個(gè)Complete（） /  Error（）事件，則不重新訂閱 & 發(fā)送原來(lái)的 Observable
                        return Observable.empty();
                        // Observable.empty() = 發(fā)送Complete事件，但不會(huì)回調(diào)觀察者的onComplete（）

                        // return Observable.error(new Throwable("不再重新訂閱事件"));
                        // 返回Error事件 = 回調(diào)onError（）事件，并接收傳過(guò)去的錯(cuò)誤信息。

                        // 情況2：若新被觀察者（Observable）返回其余事件，則重新訂閱 & 發(fā)送原來(lái)的 Observable
                        // return Observable.just(1);
                       // 僅僅是作為1個(gè)觸發(fā)重新訂閱被觀察者的通知，發(fā)送的是什么數(shù)據(jù)并不重要，只要不是Complete（） /  Error（）事件
                    }
                });

            }
        })
                .subscribe(new Observer<Integer>() {
                    @Override
                    public void onSubscribe(Disposable d) {
                        Log.d(TAG, "開(kāi)始采用subscribe連接");
                    }

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

                    @Override
                    public void onError(Throwable e) {
                        Log.d(TAG, "對(duì)Error事件作出響應(yīng)：" + e.toString());
                    }

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

                });

takeWhile

只發(fā)送滿足條件的,但一旦碰到不滿足的,后面的均不會(huì)發(fā)送,complete 結(jié)束

//takeWhile 
Observable.just(1, 2, 3, 4, 5)
                .takeWhile(new Predicate<Integer>() {
                    @Override
                    public boolean test(Integer integer) throws Exception {
                        return integer != 4;
                    }
                })
                .subscribe(new Observer<Integer>() {

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

                    @Override
                    public void onComplete() {
                        Log.d(TAG, "onComplete");
                    }
                });

02-11 16:37:18.896 10620-10620/... D/SplashActivity: integer:1
02-11 16:37:18.896 10620-10620/... D/SplashActivity: integer:2
02-11 16:37:18.896 10620-10620/... D/SplashActivity: integer:3
02-11 16:37:18.896 10620-10620/... D/SplashActivity: onComplete

takeUntil

一直發(fā)送,直到滿足條件時(shí)結(jié)束,并且,滿足條件的那一個(gè)也會(huì)發(fā)送,之后發(fā)complete 結(jié)束

Observable.just(1, 2, 3, 4, 5, 6)
                .takeUntil(new Predicate<Integer>() {
                    @Override
                    public boolean test(Integer integer) throws Exception {
                        return integer == 4;
                    }
                })
                .subscribe(new Observer<Integer>() {

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

                    @Override
                    public void onComplete() {
                        Log.d(TAG, "onComplete");
                    }
                });

02-11 17:03:11.396 12703-12703/... D/SplashActivity: integer:1
02-11 17:03:11.396 12703-12703/... D/SplashActivity: integer:2
02-11 17:03:11.396 12703-12703/... D/SplashActivity: integer:3
02-11 17:03:11.396 12703-12703/... D/SplashActivity: integer:4
02-11 17:03:11.396 12703-12703/... D/SplashActivity: onComplete

all

只有全部滿足的時(shí)候才會(huì)返回 true

Disposable subscribe = Observable.just(1, 2, 3)
                .all(new Predicate<Integer>() {
                    @Override
                    public boolean test(Integer integer) throws Exception {
                        return integer>2;
                    }
                })
                .subscribe(aBoolean -> Log.d(TAG, "aBoolean:" + aBoolean));

02-11 16:33:45.936 10199-10199/... D/SplashActivity: aBoolean:false

contains

是否包含指定參數(shù)

 Disposable subscribe = Observable.just(1, 2, 3, 4, 5)
                .contains(1)
                .subscribe(aBoolean -> Log.d(TAG, "aBoolean:" + aBoolean));

02-11 17:28:06.486 15538-15538/... D/SplashActivity: aBoolean:true

isEmpty

是否為空

Disposable subscribe = Observable.just(1, 2, 3, 4, 5)
                .isEmpty()
                .subscribe(aBoolean -> Log.d(TAG, "aBoolean:" + aBoolean));

02-11 17:31:04.306 15894-15894/... D/SplashActivity: aBoolean:false

filter

只發(fā)射符合條件的數(shù)據(jù)，數(shù)據(jù)從頭遍歷到尾，碰到不符合的數(shù)據(jù)也不會(huì)中斷發(fā)射

Observable.just(1, 2, 3, 4, 5, 6).filter(new Predicate<Integer>() {
            @Override
            public boolean test(Integer integer) throws Exception {
                return integer != 4;
            }
        })
                .subscribe(new Observer<Integer>() {

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

                    @Override
                    public void onComplete() {
                        Log.d(TAG, "onComplete");
                    }
                });

02-11 17:46:46.206 17513-17513/... D/SplashActivity: integer:1
02-11 17:46:46.206 17513-17513/... D/SplashActivity: integer:2
02-11 17:46:46.206 17513-17513/... D/SplashActivity: integer:3
02-11 17:46:46.206 17513-17513/... D/SplashActivity: integer:5
02-11 17:46:46.206 17513-17513/... D/SplashActivity: integer:6
02-11 17:46:46.206 17513-17513/... D/SplashActivity: onComplete

ofType

只發(fā)射符合類型的數(shù)據(jù)，數(shù)據(jù)從頭遍歷到尾，碰到不符合的數(shù)據(jù)也不會(huì)中斷發(fā)射

Observable.just(1, "one", 2, "tow", 3, "three")
                .ofType(Integer.class)
                .subscribe(new Observer<Integer>() {

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

                    @Override
                    public void onComplete() {
                        Log.d(TAG, "onComplete");
                    }
                });

02-11 17:54:15.436 19570-19570/... D/SplashActivity: integer:1
02-11 17:54:15.436 19570-19570/... D/SplashActivity: integer:2
02-11 17:54:15.436 19570-19570/... D/SplashActivity: integer:3
02-11 17:54:15.436 19570-19570/... D/SplashActivity: onComplete

elementAt

選擇指定位置的元素,下標(biāo)準(zhǔn)許越界,如果越界,可以指定默認(rèn)值

有2個(gè)參數(shù)：

value1 - 指定數(shù)據(jù)下標(biāo)
value2 - 默認(rèn)數(shù)據(jù)

 Disposable subscribe = Observable.just(1, 2, 3, 4)
                .elementAt(5,10)
                .subscribe(integer ->
                        Log.d(TAG, "integer:" + integer));

02-12 09:37:34.093 13153-13153/... D/SplashActivity: integer:10

firstElement / lastElement

firstElement - 獲得第一個(gè)數(shù)據(jù)
lastElement - 獲得最后一個(gè)數(shù)據(jù)

Disposable subscribe = Observable.just(1, 2, 3, 4)
.firstElement()
.subscribe(new Consumer<Integer>() {
            @Override
            public void accept(Integer integer) throws Exception {
                Log.d(TAG, "integer:" + integer);
            }
        });

02-12 09:28:26.753 10462-10462/... D/SplashActivity: integer:1

distinct

過(guò)濾重復(fù),只要出現(xiàn)過(guò)得就不會(huì)再出現(xiàn)

Observable.just(1, 2,3,1,3)
                .distinct()
                .subscribe(new Observer<Integer>() {

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

                    @Override
                    public void onComplete() {
                        Log.d(TAG, "onComplete");
                    }
                });

02-11 18:00:08.836 20056-20056/... D/SplashActivity: integer:1
02-11 18:00:08.836 20056-20056/... D/SplashActivity: integer:2
02-11 18:00:08.836 20056-20056/... D/SplashActivity: integer:3
02-11 18:00:08.836 20056-20056/... D/SplashActivity: onComplete

distinctUntilChanged

過(guò)濾連續(xù)重復(fù)數(shù)據(jù)，注意必須是連續(xù)重復(fù)的才有有效

Observable.just(1, 2, 3, 1, 3, 3, 4, 4)
                .distinctUntilChanged()
                .subscribe(new Observer<Integer>() {

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

                    @Override
                    public void onComplete() {
                        Log.d(TAG, "onComplete");
                    }
                });

02-11 18:02:59.656 20334-20334/... D/SplashActivity: integer:1
02-11 18:02:59.656 20334-20334/... D/SplashActivity: integer:2
02-11 18:02:59.656 20334-20334/... D/SplashActivity: integer:3
02-11 18:02:59.656 20334-20334/... D/SplashActivity: integer:1
02-11 18:02:59.656 20334-20334/... D/SplashActivity: integer:3
02-11 18:02:59.656 20334-20334/... D/SplashActivity: integer:4
02-11 18:02:59.656 20334-20334/... D/SplashActivity: onComplete

take / takeLast

take - 從頭開(kāi)始獲取指定數(shù)目的數(shù)據(jù),如果數(shù)據(jù)量小于指定數(shù)目,則進(jìn)入 error
takeLast - 反向從最后開(kāi)始獲取數(shù)據(jù)

Observable.just(1, 2, 3, 4, 5, 6)
                .take(2)
                .subscribe(new Observer<Integer>() {

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

                    @Override
                    public void onComplete() {
                        Log.d(TAG, "onComplete");
                    }
                });

02-11 18:35:23.196 21766-21766/... D/SplashActivity: integer:1
02-11 18:35:23.196 21766-21766/... D/SplashActivity: integer:2
02-11 18:35:23.196 21766-21766/... D/SplashActivity: onComplete

skip

skip - 正序跳過(guò)指定 count,如果不足,則會(huì)進(jìn)入 onError
skipLast - 倒序跳過(guò)指定 count,如果不足,則會(huì)進(jìn)入 onError

Observable.just(1, 2, 3, 4).skip(2).subscribe(new Observer<Integer>() {

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

            @Override
            public void onComplete() {
                Log.d(TAG, "onComplete");
            }
        });

02-12 09:19:47.243 9691-9691/... D/SplashActivity: integer:3
02-12 09:19:47.243 9691-9691/... D/SplashActivity: integer:4
02-12 09:19:47.243 9691-9691/... D/SplashActivity: onComplete

throttleFirst / throttleLast

throttleFirst - 指定時(shí)間間隔內(nèi)取第一個(gè)數(shù)據(jù)
throttleLast - 指定時(shí)間間隔內(nèi)取最后一個(gè)數(shù)據(jù)

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(1600);
                e.onNext(3);

                Thread.sleep(2100);
                e.onNext(4);
                e.onComplete();
            }
        }).throttleFirst(2, TimeUnit.SECONDS)
                .subscribe(new Observer<Integer>() {

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

                    @Override
                    public void onComplete() {
                        Log.d(TAG, "complete");
                    }
                });

``log
02-12 10:01:16.243 14629-14629/... D/SplashActivity: integer:1
02-12 10:01:18.343 14629-14629/... D/SplashActivity: integer:3
02-12 10:01:20.443 14629-14629/... D/SplashActivity: integer:4
02-12 10:01:20.443 14629-14629/... D/SplashActivity: complete


##### throttleWithTimeout / debounce

throttleWithTimeout 同 debounce

2次數(shù)據(jù)間隔超過(guò)指定時(shí)間才有效，若一直沒(méi)有合適的數(shù)據(jù)，默認(rèn)取最后一個(gè)數(shù)據(jù)

```java
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(500);
                e.onNext(3);

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

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

                Thread.sleep(500);
                e.onNext(6);
                e.onComplete();
            }
        }).throttleWithTimeout(1, TimeUnit.SECONDS)
                .subscribe(new Observer<Integer>() {

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

                    @Override
                    public void onComplete() {
                        Log.d(TAG, "onComplete");
                    }
                });

02-12 10:15:56.573 16357-16357/... D/SplashActivity: integer:6
02-12 10:15:56.573 16357-16357/... D/SplashActivity: onComplete

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美 国产 综合 欧美 视频

我學(xué) rxjava 2（2）- 操作符

創(chuàng)建操作符

變換操作符

組合操作符

功能操作符

創(chuàng)建操作符

just

fromArray / fromIterable

empty / error / never

defer 延遲創(chuàng)建

timer / interval

range / rangeLong

intervalRange

repeat 重復(fù)發(fā)射

變換操作符

map

flatmap

ConcatMap

Buffer

組合操作符

concat 、 concatArray

merge / mergeArray

concatDelayError / mergeDelayError

zip

reduce

collect

startWith / startWithArray

count

功能操作符

delay

do

onErrorReturn

onErrorResumeNext / onExceptionResumeNext

retry 、retryWhen

repeat / repeatWhen

takeWhile

takeUntil

all

contains

isEmpty

filter

ofType

elementAt

firstElement / lastElement

distinct

distinctUntilChanged

take / takeLast

skip

throttleFirst / throttleLast

推薦閱讀更多精彩內(nèi)容

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美国产综合欧美视频