創(chuàng)建操作

Create

使用一個函數(shù)從頭開始創(chuàng)建一個Observable

create

你可以使用Create操作符從頭開始創(chuàng)建一個Observable，給這個操作符傳遞一個接受觀察者作為參數(shù)的函數(shù)，編寫這個函數(shù)讓它的行為表現(xiàn)為一個Observable--恰當?shù)恼{用觀察者的onNext驯杜，onError和onCompleted方法旨涝。

一個形式正確的有限Observable必須嘗試調用觀察者的onCompleted正好一次或者它的onError正好一次，而且此后不能再調用觀察者的任何其它方法。

create

RxJava將這個操作符實現(xiàn)為 create 方法。

建議你在傳遞給create方法的函數(shù)中檢查觀察者的isUnsubscribed狀態(tài)，以便在沒有觀察者的時候稠肘，讓你的Observable停止發(fā)射數(shù)據(jù)或者做昂貴的運算。

示例代碼：

Observable.create(new Observable.OnSubscribe<Integer>() {
    @Override
    public void call(Subscriber<? super Integer> observer) {
        try {
            if (!observer.isUnsubscribed()) {
                for (int i = 1; i < 5; i++) {
                    observer.onNext(i);
                }
                observer.onCompleted();
            }
        } catch (Exception e) {
            observer.onError(e);
        }
    }
 } ).subscribe(new Subscriber<Integer>() {
        @Override
        public void onNext(Integer item) {
            System.out.println("Next: " + item);
        }

        @Override
        public void onError(Throwable error) {
            System.err.println("Error: " + error.getMessage());
        }

        @Override
        public void onCompleted() {
            System.out.println("Sequence complete.");
        }
    });

輸出：

Next: 1
Next: 2
Next: 3
Next: 4
Sequence complete.

create方法默認不在任何特定的調度器上執(zhí)行萝毛。

• Javadoc: create(OnSubscribe)

Defer

直到有觀察者訂閱時才創(chuàng)建Observable项阴，并且為每個觀察者創(chuàng)建一個新的Observable

defer

Defer操作符會一直等待直到有觀察者訂閱它，然后它使用Observable工廠方法生成一個Observable笆包。它對每個觀察者都這樣做环揽，因此盡管每個訂閱者都以為自己訂閱的是同一個Observable，事實上每個訂閱者獲取的是它們自己的單獨的數(shù)據(jù)序列庵佣。

在某些情況下歉胶，等待直到最后一分鐘（就是知道訂閱發(fā)生時）才生成Observable可以確保Observable包含最新的數(shù)據(jù)。

defer

RxJava將這個操作符實現(xiàn)為 defer 方法巴粪。這個操作符接受一個你選擇的Observable工廠函數(shù)作為單個參數(shù)通今。這個函數(shù)沒有參數(shù)，返回一個Observable肛根。

defer方法默認不在任何特定的調度器上執(zhí)行辫塌。

• Javadoc: defer(Func0)

switchCase

switchCase

可選包 rxjava-computation-expressions 中有一個類似的操作符。switchCase操作符有條件的創(chuàng)建并返回一個可能的Observables集合中的一個派哲。

ifThen

可選包 rxjava-computation-expressions 中還有一個更簡單的操作符叫ifThen臼氨。這個操作符檢查某個條件，然后根據(jù)結果狮辽，返回原始Observable的鏡像一也，或者返回一個空Observable。

Empty/Never/Throw

Empty

創(chuàng)建一個不發(fā)射任何數(shù)據(jù)但是正常終止的Observable

Never

創(chuàng)建一個不發(fā)射數(shù)據(jù)也不終止的Observable

Throw

創(chuàng)建一個不發(fā)射數(shù)據(jù)以一個錯誤終止的Observable

這三個操作符生成的Observable行為非常特殊和受限喉脖。測試的時候很有用椰苟，有時候也用于結合其它的Observables，或者作為其它需要Observable的操作符的參數(shù)树叽。

RxJava將這些操作符實現(xiàn)為 empty舆蝴，never和error。error操作符需要一個Throwable參數(shù)题诵，你的Observable會以此終止洁仗。這些操作符默認不在任何特定的調度器上執(zhí)行，但是empty和error有一個可選參數(shù)是Scheduler性锭，如果你傳遞了Scheduler參數(shù)赠潦，它們會在這個調度器上發(fā)送通知。

• Javadoc: empty()
• Javadoc: never()
• Javadoc: error(java.lang.Throwable)

From

將其它種類的對象和數(shù)據(jù)類型轉換為Observable

[圖片上傳失敗...(image-52a925-1572186452758)]

當你使用Observable時草冈，如果你要處理的數(shù)據(jù)都可以轉換成展現(xiàn)為Observables她奥，而不是需要混合使用Observables和其它類型的數(shù)據(jù)，會非常方便怎棱。這讓你在數(shù)據(jù)流的整個生命周期中哩俭，可以使用一組統(tǒng)一的操作符來管理它們。

例如拳恋，Iterable可以看成是同步的Observable凡资；Future，可以看成是總是只發(fā)射單個數(shù)據(jù)的Observable谬运。通過顯式地將那些數(shù)據(jù)轉換為Observables隙赁，你可以像使用Observable一樣與它們交互。

因此吩谦，大部分ReactiveX實現(xiàn)都提供了將語言特定的對象和數(shù)據(jù)結構轉換為Observables的方法鸳谜。

from

在RxJava中，from操作符可以轉換Future咐扭、Iterable和數(shù)組。對于Iterable和數(shù)組滑废，產(chǎn)生的Observable會發(fā)射Iterable或數(shù)組的每一項數(shù)據(jù)蝗肪。

示例代碼

Integer[] items = { 0, 1, 2, 3, 4, 5 };
Observable myObservable = Observable.from(items);

myObservable.subscribe(
    new Action1<Integer>() {
        @Override
        public void call(Integer item) {
            System.out.println(item);
        }
    },
    new Action1<Throwable>() {
        @Override
        public void call(Throwable error) {
            System.out.println("Error encountered: " + error.getMessage());
        }
    },
    new Action0() {
        @Override
        public void call() {
            System.out.println("Sequence complete");
        }
    }
);

輸出

0
1
2
3
4
5
Sequence complete

對于Future，它會發(fā)射Future.get()方法返回的單個數(shù)據(jù)蠕趁。from方法有一個可接受兩個可選參數(shù)的版本薛闪，分別指定超時時長和時間單位。如果過了指定的時長Future還沒有返回一個值俺陋，這個Observable會發(fā)射錯誤通知并終止豁延。

from默認不在任何特定的調度器上執(zhí)行昙篙。然而你可以將Scheduler作為可選的第二個參數(shù)傳遞給Observable，它會在那個調度器上管理這個Future诱咏。

• Javadoc: from(array)
• Javadoc: from(Iterable)
• Javadoc: from(Future)
• Javadoc: from(Future,Scheduler)
• Javadoc: from(Future,timeout, timeUnit)

RxJavaAsyncUtil

from func)

此外苔可，在可選包 RxJavaAsyncUtil 中，你還可以用下面這些操作符將actions袋狞，callables焚辅，functions和runnables轉換為發(fā)射這些動作的執(zhí)行結果的Observable：

• fromAction
• fromCallable
• fromFunc0
• fromRunnable

在這個頁面 Start 查看關于這些操作符的更多信息。

from

注意：還有一個可選的StringObservable類中也有一個from方法苟鸯，它將一個字符流或者一個REader轉換為一個發(fā)射字節(jié)數(shù)組或字符串的Observable同蜻。

runAsync2

注意：這里與后面start操作符里的runAsync說明重復了

在單獨的RxJavaAsyncUtil包中（默認不包含在RxJava中）,還有一個runAsync函數(shù)。傳遞一個Action和一個Scheduler給runAsync早处，它會返回一個StoppableObservable湾蔓，這個Observable使用Action產(chǎn)生發(fā)射的數(shù)據(jù)項。

傳遞一個Action和一個Scheduler給runAsync砌梆，它返回一個使用這個Action產(chǎn)生數(shù)據(jù)的StoppableObservable卵蛉。這個Action接受一個Observable和一個Subscription作為參數(shù)，它使用Subscription檢查unsubscribed條件么库，一旦發(fā)現(xiàn)條件為真就立即停止發(fā)射數(shù)據(jù)傻丝。在任何時候你都可以使用unsubscribe方法手動停止一個StoppableObservable（這會同時取消訂閱與這個StoppableObservable關聯(lián)的Subscription）。

由于runAsync會立即調用Action并開始發(fā)射數(shù)據(jù)诉儒，在你創(chuàng)建StoppableObservable之后到你的觀察者準備好接受數(shù)據(jù)之前這段時間里葡缰，可能會有一部分數(shù)據(jù)會丟失。如果這不符合你的要求忱反，可以使用runAsync的一個變體泛释，它也接受一個Subject參數(shù)，傳遞一個ReplaySubject給它温算，你可以獲取其它丟失的數(shù)據(jù)了怜校。

decode

decode

StringObservable類不是默認RxJava的一部分，包含一個decode操作符注竿，這個操作符將一個多字節(jié)字符流轉換為一個發(fā)射字節(jié)數(shù)組的Observable茄茁，這些字節(jié)數(shù)組按照字符的邊界劃分。

Interval

創(chuàng)建一個按固定時間間隔發(fā)射整數(shù)序列的Observable

interval

Interval操作符返回一個Observable巩割，它按固定的時間間隔發(fā)射一個無限遞增的整數(shù)序列裙顽。

interval

RxJava將這個操作符實現(xiàn)為interval方法。它接受一個表示時間間隔的參數(shù)和一個表示時間單位的參數(shù)宣谈。

• Javadoc: interval(long,TimeUnit)
• Javadoc: interval(long,TimeUnit,Scheduler)

timer

還有一個版本的interval返回一個Observable愈犹，它在指定延遲之后先發(fā)射一個零值，然后再按照指定的時間間隔發(fā)射遞增的數(shù)字闻丑。這個版本的interval在RxJava 1.0.0中叫做timer漩怎，但是那個方法已經(jīng)不建議使用了勋颖，因為一個名叫interval的操作符有同樣的功能。

Javadoc: interval(long,long,TimeUnit) Javadoc: interval(long,long,TimeUnit,Scheduler)

interval默認在computation調度器上執(zhí)行勋锤。你也可以傳遞一個可選的Scheduler參數(shù)來指定調度器牙言。

Just

創(chuàng)建一個發(fā)射指定值的Observable

just

Just將單個數(shù)據(jù)轉換為發(fā)射那個數(shù)據(jù)的Observable。

Just類似于From怪得，但是From會將數(shù)組或Iterable的數(shù)據(jù)取出然后逐個發(fā)射，而Just只是簡單的原樣發(fā)射卑硫，將數(shù)組或Iterable當做單個數(shù)據(jù)徒恋。

注意：如果你傳遞null給Just，它會返回一個發(fā)射null值的Observable欢伏。不要誤認為它會返回一個空Observable（完全不發(fā)射任何數(shù)據(jù)的Observable）入挣，如果需要空Observable你應該使用Empty操作符。

RxJava將這個操作符實現(xiàn)為just函數(shù)硝拧，它接受一至九個參數(shù)径筏，返回一個按參數(shù)列表順序發(fā)射這些數(shù)據(jù)的Observable。

示例代碼：

Observable.just(1, 2, 3)
          .subscribe(new Subscriber<Integer>() {
        @Override
        public void onNext(Integer item) {
            System.out.println("Next: " + item);
        }

        @Override
        public void onError(Throwable error) {
            System.err.println("Error: " + error.getMessage());
        }

        @Override
        public void onCompleted() {
            System.out.println("Sequence complete.");
        }
    });

輸出

Next: 1
Next: 2
Next: 3
Sequence complete.

• Javadoc: just(item) (還有其它接受二到九個參數(shù)的版本)

Range

創(chuàng)建一個發(fā)射特定整數(shù)序列的Observable

range

Range操作符發(fā)射一個范圍內的有序整數(shù)序列障陶，你可以指定范圍的起始和長度滋恬。

RxJava將這個操作符實現(xiàn)為range函數(shù)，它接受兩個參數(shù)抱究，一個是范圍的起始值恢氯，一個是范圍的數(shù)據(jù)的數(shù)目。如果你將第二個參數(shù)設為0鼓寺，將導致Observable不發(fā)射任何數(shù)據(jù)（如果設置為負數(shù)勋拟，會拋異常）。

range默認不在任何特定的調度器上執(zhí)行妈候。有一個變體可以通過可選參數(shù)指定Scheduler敢靡。

• Javadoc: range(int,int)
• Javadoc: range(int,int,Scheduler)

Repeat

創(chuàng)建一個發(fā)射特定數(shù)據(jù)重復多次的Observable

repeat

Repeat重復地發(fā)射數(shù)據(jù)。某些實現(xiàn)允許你重復的發(fā)射某個數(shù)據(jù)序列苦银，還有一些允許你限制重復的次數(shù)啸胧。

repeat

RxJava將這個操作符實現(xiàn)為repeat方法。它不是創(chuàng)建一個Observable幔虏，而是重復發(fā)射原始Observable的數(shù)據(jù)序列吓揪，這個序列或者是無限的，或者通過repeat(n)指定重復次數(shù)所计。

repeat操作符默認在trampoline調度器上執(zhí)行柠辞。有一個變體可以通過可選參數(shù)指定Scheduler。

Javadoc: repeat() Javadoc: repeat(long) Javadoc: repeat(Scheduler) Javadoc: repeat(long,Scheduler)

repeatWhen

repeatWhen

還有一個叫做repeatWhen的操作符主胧，它不是緩存和重放原始Observable的數(shù)據(jù)序列叭首，而是有條件的重新訂閱和發(fā)射原來的Observable习勤。

將原始Observable的終止通知（完成或錯誤）當做一個void數(shù)據(jù)傳遞給一個通知處理器，它以此來決定是否要重新訂閱和發(fā)射原來的Observable焙格。這個通知處理器就像一個Observable操作符图毕，接受一個發(fā)射void通知的Observable為輸入，返回一個發(fā)射void數(shù)據(jù)（意思是眷唉，重新訂閱和發(fā)射原始Observable）或者直接終止（意思是予颤，使用repeatWhen終止發(fā)射數(shù)據(jù)）的Observable。

repeatWhen操作符默認在trampoline調度器上執(zhí)行冬阳。有一個變體可以通過可選參數(shù)指定Scheduler蛤虐。

• Javadoc: repeatWhen(Func1)
• Javadoc: repeatWhen(Func1,Scheduler)

doWhile

doWhile

doWhile 屬于可選包rxjava-computation-expressions，不是RxJava標準操作符的一部分肝陪。doWhile在原始序列的每次重復后檢查某個條件驳庭，如果滿足條件才重復發(fā)射。

whileDo

whileDo

whileDo 屬于可選包rxjava-computation-expressions氯窍，不是RxJava標準操作符的一部分饲常。whileDo在原始序列的每次重復前檢查某個條件，如果滿足條件才重復發(fā)射

Start

返回一個Observable狼讨，它發(fā)射一個類似于函數(shù)聲明的值

Start

編程語言有很多種方法可以從運算結果中獲取值贝淤，它們的名字一般叫functions, futures, actions, callables, runnables等等。在Start目錄下的這組操作符可以讓它們表現(xiàn)得像Observable政供，因此它們可以在Observables調用鏈中與其它Observable搭配使用霹娄。

Start操作符的多種RxJava實現(xiàn)都屬于可選的rxjava-async模塊。

rxjava-async模塊包含start操作符鲫骗，它接受一個函數(shù)作為參數(shù)犬耻，調用這個函數(shù)獲取一個值，然后返回一個會發(fā)射這個值給后續(xù)觀察者的Observable执泰。

注意：這個函數(shù)只會被執(zhí)行一次枕磁，即使多個觀察者訂閱這個返回的Observable。

toAsync

toAsync

rxjava-async模塊還包含這幾個操作符：toAsync, asyncAction, 和asyncFunc术吝。它們接受一個函數(shù)或一個Action作為參數(shù)计济。

對于函數(shù)(functions)，這個操作符調用這個函數(shù)獲取一個值排苍，然后返回一個會發(fā)射這個值給后續(xù)觀察者的Observable（和start一樣）沦寂。對于動作(Action)，過程類似淘衙，但是沒有返回值传藏，在這種情況下，這個操作符在終止前會發(fā)射一個null值。

注意：這個函數(shù)或動作只會被執(zhí)行一次毯侦，即使多個觀察者訂閱這個返回的Observable哭靖。

startFuture

startFuture

rxjava-async模塊還包含一個startFuture操作符，傳遞給它一個返回Future的函數(shù)侈离，startFuture會立即調用這個函數(shù)獲取Future對象试幽，然后調用Future的get()方法嘗試獲取它的值。它返回一個發(fā)射這個值給后續(xù)觀察者的Observable卦碾。

deferFuture

deferFuture

rxjava-async模塊還包含一個deferFuture操作符铺坞，傳遞給它一個返回Future的函數(shù)（這個Future返回一個Observable），deferFuture返回一個Observable洲胖，但是不會調用你提供的函數(shù)济榨，直到有觀察者訂閱它返回的Observable。這時宾濒，它立即調用Future的get()方法，然后鏡像發(fā)射get()方法返回的Observable發(fā)射的數(shù)據(jù)屏箍。

用這種方法绘梦，你可以在Observables調用鏈中包含一個返回Observable的Future對象。

fromAction

fromAction

rxjava-async模塊還包含一個fromAction操作符赴魁，它接受一個Action作為參數(shù)卸奉，返回一個Observable，一旦Action終止颖御，它發(fā)射這個你傳遞給fromAction的數(shù)據(jù)榄棵。

fromCallable

fromCallable

rxjava-async模塊還包含一個fromCallable操作符，它接受一個Callable作為參數(shù)潘拱，返回一個發(fā)射這個Callable的結果的Observable疹鳄。

fromRunnable

fromRunnable

rxjava-async模塊還包含一個fromRunnable操作符，它接受一個Runnable作為參數(shù)芦岂，返回一個Observable瘪弓，一旦Runnable終止，它發(fā)射這個你傳遞給fromRunnable的數(shù)據(jù)禽最。

forEachFuture

forEachFuture

rxjava-async模塊還包含一個forEachFuture操作符腺怯。它其實不算Start操作符的一個變體，而是有一些自己的特點川无。你傳遞一些典型的觀察者方法（如onNext, onError和onCompleted）給它呛占，Observable會以通常的方式調用它。但是forEachFuture自己返回一個Future并且在get()方法處阻塞懦趋，直到原始Observable執(zhí)行完成晾虑，然后它返回，完成還是錯誤依賴于原始Observable是完成還是錯誤。

如果你想要一個函數(shù)阻塞直到Observable執(zhí)行完成走贪，可以使用這個操作符佛猛。

runAsync

rxjava-async模塊還包含一個runAsync操作符舶胀。它很特殊谓谦，返回一個叫做StoppableObservable的特殊Observable。

傳遞一個Action和一個Scheduler給runAsync负溪，它返回一個使用這個Action產(chǎn)生數(shù)據(jù)的StoppableObservable逃沿。這個Action接受一個Observable和一個Subscription作為參數(shù)婴渡，它使用Subscription檢查unsubscribed條件，一旦發(fā)現(xiàn)條件為真就立即停止發(fā)射數(shù)據(jù)凯亮。在任何時候你都可以使用unsubscribe方法手動停止一個StoppableObservable（這會同時取消訂閱與這個StoppableObservable關聯(lián)的Subscription）边臼。

由于runAsync會立即調用Action并開始發(fā)射數(shù)據(jù)，在你創(chuàng)建StoppableObservable之后到你的觀察者準備好接受數(shù)據(jù)之前這段時間里假消，可能會有一部分數(shù)據(jù)會丟失柠并。如果這不符合你的要求，可以使用runAsync的一個變體富拗，它也接受一個Subject參數(shù)臼予，傳遞一個ReplaySubject給它，你可以獲取其它丟失的數(shù)據(jù)了啃沪。

在RxJava中還有一個版本的From操作符可以將Future轉換為Observable粘拾，與start相似。

Timer

創(chuàng)建一個Observable创千，它在一個給定的延遲后發(fā)射一個特殊的值缰雇。

timer

Timer操作符創(chuàng)建一個在給定的時間段之后返回一個特殊值的Observable。

RxJava將這個操作符實現(xiàn)為timer函數(shù)追驴。

timer返回一個Observable械哟，它在延遲一段給定的時間后發(fā)射一個簡單的數(shù)字0。

timer操作符默認在computation調度器上執(zhí)行殿雪。有一個變體可以通過可選參數(shù)指定Scheduler戒良。

• Javadoc: timer(long,TimeUnit)
• Javadoc: timer(long,TimeUnit,Scheduler)

變換操作

這個頁面展示了可用于對Observable發(fā)射的數(shù)據(jù)執(zhí)行變換操作的各種操作符。

• map(?) — 對序列的每一項都應用一個函數(shù)來變換Observable發(fā)射的數(shù)據(jù)序列
• flatMap(?), concatMap(?), and flatMapIterable(?) — 將Observable發(fā)射的數(shù)據(jù)集合變換為Observables集合冠摄，然后將這些Observable發(fā)射的數(shù)據(jù)平坦化的放進一個單獨的Observable
• switchMap(?) — 將Observable發(fā)射的數(shù)據(jù)集合變換為Observables集合糯崎，然后只發(fā)射這些Observables最近發(fā)射的數(shù)據(jù)
• scan(?) — 對Observable發(fā)射的每一項數(shù)據(jù)應用一個函數(shù)，然后按順序依次發(fā)射每一個值
• groupBy(?) — 將Observable分拆為Observable集合河泳，將原始Observable發(fā)射的數(shù)據(jù)按Key分組沃呢，每一個Observable發(fā)射一組不同的數(shù)據(jù)
• buffer(?) — 它定期從Observable收集數(shù)據(jù)到一個集合，然后把這些數(shù)據(jù)集合打包發(fā)射拆挥，而不是一次發(fā)射一個
• window(?) — 定期將來自Observable的數(shù)據(jù)分拆成一些Observable窗口薄霜，然后發(fā)射這些窗口某抓，而不是每次發(fā)射一項
• cast(?) — 在發(fā)射之前強制將Observable發(fā)射的所有數(shù)據(jù)轉換為指定類型

Buffer

定期收集Observable的數(shù)據(jù)放進一個數(shù)據(jù)包裹，然后發(fā)射這些數(shù)據(jù)包裹惰瓜，而不是一次發(fā)射一個值否副。

buffer

Buffer操作符將一個Observable變換為另一個，原來的Observable正常發(fā)射數(shù)據(jù)崎坊，變換產(chǎn)生的Observable發(fā)射這些數(shù)據(jù)的緩存集合备禀。Buffer操作符在很多語言特定的實現(xiàn)中有很多種變體，它們在如何緩存這個問題上存在區(qū)別奈揍。

注意：如果原來的Observable發(fā)射了一個onError通知曲尸，Buffer會立即傳遞這個通知，而不是首先發(fā)射緩存的數(shù)據(jù)男翰，即使在這之前緩存中包含了原始Observable發(fā)射的數(shù)據(jù)另患。

Window操作符與Buffer類似，但是它在發(fā)射之前把收集到的數(shù)據(jù)放進單獨的Observable蛾绎，而不是放進一個數(shù)據(jù)結構昆箕。

在RxJava中有許多Buffer的變體：

buffer(count)

buffer3

buffer(count)以列表(List)的形式發(fā)射非重疊的緩存，每一個緩存至多包含來自原始Observable的count項數(shù)據(jù)（最后發(fā)射的列表數(shù)據(jù)可能少于count項）

• Javadoc: buffer(int)

buffer(count, skip)

buffer4

buffer(count,?skip)從原始Observable的第一項數(shù)據(jù)開始創(chuàng)建新的緩存租冠，此后每當收到skip項數(shù)據(jù)鹏倘，用count項數(shù)據(jù)填充緩存：開頭的一項和后續(xù)的count-1項，它以列表(List)的形式發(fā)射緩存肺稀，取決于count和skip的值第股，這些緩存可能會有重疊部分（比如skip < count時）应民，也可能會有間隙（比如skip > count時）话原。

• Javadoc: buffer(int,int)

buffer(bufferClosingSelector)

buffer1

當它訂閱原來的Observable時，buffer(bufferClosingSelector)開始將數(shù)據(jù)收集到一個List诲锹，然后它調用bufferClosingSelector生成第二個Observable繁仁，當?shù)诙€Observable發(fā)射一個TClosing時，buffer發(fā)射當前的List归园，然后重復這個過程：開始組裝一個新的List黄虱，然后調用bufferClosingSelector創(chuàng)建一個新的Observable并監(jiān)視它。它會一直這樣做直到原來的Observable執(zhí)行完成庸诱。

• Javadoc: buffer(Func0)

buffer(boundary)

buffer8

buffer(boundary)監(jiān)視一個名叫boundary的Observable捻浦，每當這個Observable發(fā)射了一個值，它就創(chuàng)建一個新的List開始收集來自原始Observable的數(shù)據(jù)并發(fā)射原來的List桥爽。

• Javadoc: buffer(Observable)
• Javadoc: buffer(Observable,int)

buffer(bufferOpenings, bufferClosingSelector)

buffer2

buffer(bufferOpenings,?bufferClosingSelector)監(jiān)視這個叫bufferOpenings的Observable（它發(fā)射BufferOpening對象）朱灿，每當bufferOpenings發(fā)射了一個數(shù)據(jù)時，它就創(chuàng)建一個新的List開始收集原始Observable的數(shù)據(jù)钠四，并將bufferOpenings傳遞給closingSelector函數(shù)盗扒。這個函數(shù)返回一個Observable。buffer監(jiān)視這個Observable，當它檢測到一個來自這個Observable的數(shù)據(jù)時侣灶，就關閉List并且發(fā)射它自己的數(shù)據(jù)（之前的那個List）甸祭。

• Javadoc: buffer(Observable,Func1)

buffer(timespan, unit[, scheduler])

buffer5

buffer(timespan,?unit)定期以List的形式發(fā)射新的數(shù)據(jù)，每個時間段褥影，收集來自原始Observable的數(shù)據(jù)（從前面一個數(shù)據(jù)包裹之后池户，或者如果是第一個數(shù)據(jù)包裹，從有觀察者訂閱原來的Observale之后開始）伪阶。還有另一個版本的buffer接受一個Scheduler參數(shù)煞檩，默認情況下會使用computation調度器。

• Javadoc: buffer(long,TimeUnit)
• Javadoc: buffer(long,TimeUnit,Scheduler)

buffer(timespan, unit, count[, scheduler])

buffer6

每當收到來自原始Observable的count項數(shù)據(jù)栅贴，或者每過了一段指定的時間后斟湃，buffer(timespan,?unit,?count)就以List的形式發(fā)射這期間的數(shù)據(jù)，即使數(shù)據(jù)項少于count項檐薯。還有另一個版本的buffer接受一個Scheduler參數(shù)凝赛，默認情況下會使用computation調度器。

• Javadoc: buffer(long,TimeUnit,int)
• Javadoc: buffer(long,TimeUnit,int,Scheduler)

buffer(timespan, timeshift, unit[, scheduler])

buffer7

buffer(timespan,?timeshift,?unit)在每一個timeshift時期內都創(chuàng)建一個新的List,然后用原始Observable發(fā)射的每一項數(shù)據(jù)填充這個列表（在把這個List當做自己的數(shù)據(jù)發(fā)射前坛缕，從創(chuàng)建時開始墓猎，直到過了timespan這么長的時間）。如果timespan長于timeshift赚楚，它發(fā)射的數(shù)據(jù)包將會重疊毙沾，因此可能包含重復的數(shù)據(jù)項。

還有另一個版本的buffer接受一個Scheduler參數(shù)宠页，默認情況下會使用computation調度器左胞。

• Javadoc: buffer(long,long,TimeUnit)
• Javadoc: buffer(long,long,TimeUnit,Scheduler)

buffer-backpressure

你可以使用Buffer操作符實現(xiàn)反壓backpressure（意思是，處理這樣一個Observable：它產(chǎn)生數(shù)據(jù)的速度可能比它的觀察者消費數(shù)據(jù)的速度快）举户。

bp.buffer2

Buffer操作符可以將大量的數(shù)據(jù)序列縮減為較少的數(shù)據(jù)緩存序列烤宙，讓它們更容易處理。例如俭嘁，你可以按固定的時間間隔躺枕，定期關閉和發(fā)射來自一個爆發(fā)性Observable的數(shù)據(jù)緩存。這相當于一個緩沖區(qū)供填。

示例代碼

Observable<List<Integer>> burstyBuffered = bursty.buffer(500, TimeUnit.MILLISECONDS);

bp.buffer1

或者拐云，如果你想更進一步，可以在爆發(fā)期將數(shù)據(jù)收集到緩存近她，然后在爆發(fā)期終止時發(fā)射這些數(shù)據(jù)叉瘩，使用 Debounce 操作符給buffer操作符發(fā)射一個緩存關閉指示器(buffer closing indicator)可以做到這一點。

代碼示例：

// we have to multicast the original bursty Observable so we can use it
// both as our source and as the source for our buffer closing selector:
Observable<Integer> burstyMulticast = bursty.publish().refCount();
// burstyDebounced will be our buffer closing selector:
Observable<Integer> burstyDebounced = burstyMulticast.debounce(10, TimeUnit.MILLISECONDS);
// and this, finally, is the Observable of buffers we're interested in:
Observable<List<Integer>> burstyBuffered = burstyMulticast.buffer(burstyDebounced);

參見

FlatMap

FlatMap將一個發(fā)射數(shù)據(jù)的Observable變換為多個Observables泄私，然后將它們發(fā)射的數(shù)據(jù)合并后放進一個單獨的Observable

flatMap

FlatMap操作符使用一個指定的函數(shù)對原始Observable發(fā)射的每一項數(shù)據(jù)執(zhí)行變換操作房揭，這個函數(shù)返回一個本身也發(fā)射數(shù)據(jù)的Observable备闲，然后FlatMap合并這些Observables發(fā)射的數(shù)據(jù)，最后將合并后的結果當做它自己的數(shù)據(jù)序列發(fā)射捅暴。

這個方法是很有用的恬砂，例如，當你有一個這樣的Observable：它發(fā)射一個數(shù)據(jù)序列蓬痒，這些數(shù)據(jù)本身包含Observable成員或者可以變換為Observable泻骤，因此你可以創(chuàng)建一個新的Observable發(fā)射這些次級Observable發(fā)射的數(shù)據(jù)的完整集合。

注意：FlatMap對這些Observables發(fā)射的數(shù)據(jù)做的是合并(merge)操作梧奢，因此它們可能是交錯的狱掂。

在許多語言特定的實現(xiàn)中，還有一個操作符不會讓變換后的Observables發(fā)射的數(shù)據(jù)交錯亲轨，它按照嚴格的順序發(fā)射這些數(shù)據(jù)趋惨，這個操作符通常被叫作ConcatMap或者類似的名字。

mergeMap

RxJava將這個操作符實現(xiàn)為flatMap函數(shù)惦蚊。

注意：如果任何一個通過這個flatMap操作產(chǎn)生的單獨的Observable調用onError異常終止了器虾，這個Observable自身會立即調用onError并終止。

這個操作符有一個接受額外的int參數(shù)的一個變體蹦锋。這個參數(shù)設置flatMap從原來的Observable映射Observables的最大同時訂閱數(shù)兆沙。當達到這個限制時，它會等待其中一個終止然后再訂閱另一個莉掂。

• Javadoc: flatMap(Func1)
• Javadoc: flatMap(Func1,int)

mergeMap.nce

還有一個版本的flatMap為原始Observable的每一項數(shù)據(jù)和每一個通知創(chuàng)建一個新的Observable（并對數(shù)據(jù)平坦化）葛圃。

它也有一個接受額外int參數(shù)的變體。

• Javadoc: flatMap(Func1,Func1,Func0)
• Javadoc: flatMap(Func1,Func1,Func0,int)

[圖片上傳失敗...(image-5ffcff-1572186452759)]

還有一個版本的flatMap會使用原始Observable的數(shù)據(jù)觸發(fā)的Observable組合這些數(shù)據(jù)憎妙，然后發(fā)射這些數(shù)據(jù)組合库正。它也有一個接受額外int參數(shù)的版本。

• Javadoc: flatMap(Func1,Func2)
• Javadoc: flatMap(Func1,Func2,int)

flatMapIterable

mergeMapIterable

flatMapIterable這個變體成對的打包數(shù)據(jù)尚氛，然后生成Iterable而不是原始數(shù)據(jù)和生成的Observables诀诊，但是處理方式是相同的洞渤。

• Javadoc: flatMapIterable(Func1)
• Javadoc: flatMapIterable(Func1,Func2)

concatMap

concatMap

還有一個concatMap操作符阅嘶，它類似于最簡單版本的flatMap，但是它按次序連接而不是合并那些生成的Observables载迄，然后產(chǎn)生自己的數(shù)據(jù)序列讯柔。

• Javadoc: concatMap(Func1)

switchMap

switchMap

RxJava還實現(xiàn)了switchMap操作符。它和flatMap很像护昧，除了一點：當原始Observable發(fā)射一個新的數(shù)據(jù)（Observable）時魂迄，它將取消訂閱并停止監(jiān)視產(chǎn)生執(zhí)之前那個數(shù)據(jù)的Observable，只監(jiān)視當前這一個惋耙。

• Javadoc: switchMap(Func1)

split

St.split

在特殊的StringObservable類（默認沒有包含在RxJava中）中還有一個split操作符捣炬。它將一個發(fā)射字符串的Observable轉換為另一個發(fā)射字符串的Observable熊昌，只不過，后者將原始的數(shù)據(jù)序列當做一個數(shù)據(jù)流湿酸，使用一個正則表達式邊界分割它們婿屹，然后合并發(fā)射分割的結果。

GroupBy

將一個Observable分拆為一些Observables集合推溃，它們中的每一個發(fā)射原始Observable的一個子序列

groupBy

GroupBy操作符將原始Observable分拆為一些Observables集合昂利，它們中的每一個發(fā)射原始Observable數(shù)據(jù)序列的一個子序列。哪個數(shù)據(jù)項由哪一個Observable發(fā)射是由一個函數(shù)判定的铁坎，這個函數(shù)給每一項指定一個Key蜂奸，Key相同的數(shù)據(jù)會被同一個Observable發(fā)射。

RxJava實現(xiàn)了groupBy操作符硬萍。它返回Observable的一個特殊子類GroupedObservable扩所，實現(xiàn)了GroupedObservable接口的對象有一個額外的方法getKey，這個Key用于將數(shù)據(jù)分組到指定的Observable朴乖。

有一個版本的groupBy允許你傳遞一個變換函數(shù)碌奉，這樣它可以在發(fā)射結果GroupedObservable之前改變數(shù)據(jù)項。

注意：groupBy將原始Observable分解為一個發(fā)射多個GroupedObservable的Observable寒砖，一旦有訂閱赐劣，每個GroupedObservable就開始緩存數(shù)據(jù)。因此哩都，如果你忽略這些GroupedObservable中的任何一個魁兼，這個緩存可能形成一個潛在的內存泄露。因此漠嵌，如果你不想觀察咐汞，也不要忽略GroupedObservable。你應該使用像take(0)這樣會丟棄自己的緩存的操作符儒鹿。

如果你取消訂閱一個GroupedObservable化撕，那個Observable將會終止。如果之后原始的Observable又發(fā)射了一個與這個Observable的Key匹配的數(shù)據(jù)约炎，groupBy將會為這個Key創(chuàng)建一個新的GroupedObservable植阴。

groupBy默認不在任何特定的調度器上執(zhí)行。

• Javadoc: groupBy(Func1)
• Javadoc: groupBy(Func1,Func1)

Map

對Observable發(fā)射的每一項數(shù)據(jù)應用一個函數(shù)圾浅，執(zhí)行變換操作

map

Map操作符對原始Observable發(fā)射的每一項數(shù)據(jù)應用一個你選擇的函數(shù)掠手，然后返回一個發(fā)射這些結果的Observable。

RxJava將這個操作符實現(xiàn)為map函數(shù)狸捕。這個操作符默認不在任何特定的調度器上執(zhí)行喷鸽。

• Javadoc: map(Func1)

cast

cast

cast操作符將原始Observable發(fā)射的每一項數(shù)據(jù)都強制轉換為一個指定的類型，然后再發(fā)射數(shù)據(jù)灸拍，它是map的一個特殊版本做祝。

• Javadoc: cast(Class)

encode

encode

encode在StringObservable類中砾省，不是標準RxJava的一部分，它也是一個特殊的map操作符混槐。encode將一個發(fā)射字符串的Observable變換為一個發(fā)射字節(jié)數(shù)組（這個字節(jié)數(shù)組按照原始字符串中的多字節(jié)字符邊界劃分）的Observable纯蛾。

byLine

byLine

byLine同樣在StringObservable類中，也不是標準RxJava的一部分纵隔，它也是一個特殊的map操作符翻诉。byLine將一個發(fā)射字符串的Observable變換為一個按行發(fā)射來自原始Observable的字符串的Observable。

Scan

連續(xù)地對數(shù)據(jù)序列的每一項應用一個函數(shù)捌刮，然后連續(xù)發(fā)射結果

scan

Scan操作符對原始Observable發(fā)射的第一項數(shù)據(jù)應用一個函數(shù)碰煌，然后將那個函數(shù)的結果作為自己的第一項數(shù)據(jù)發(fā)射。它將函數(shù)的結果同第二項數(shù)據(jù)一起填充給這個函數(shù)來產(chǎn)生它自己的第二項數(shù)據(jù)绅作。它持續(xù)進行這個過程來產(chǎn)生剩余的數(shù)據(jù)序列芦圾。這個操作符在某些情況下被叫做accumulator。

scan

RxJava實現(xiàn)了scan操作符俄认。

示例代碼：

Observable.just(1, 2, 3, 4, 5)
    .scan(new Func2<Integer, Integer, Integer>() {
        @Override
        public Integer call(Integer sum, Integer item) {
            return sum + item;
        }
    }).subscribe(new Subscriber<Integer>() {
        @Override
        public void onNext(Integer item) {
            System.out.println("Next: " + item);
        }

        @Override
        public void onError(Throwable error) {
            System.err.println("Error: " + error.getMessage());
        }

        @Override
        public void onCompleted() {
            System.out.println("Sequence complete.");
        }
    });

輸出

Next: 1
Next: 3
Next: 6
Next: 10
Next: 15
Sequence complete.

• Javadoc: scan(Func2)

scanSeed

有一個scan操作符的變體个少，你可以傳遞一個種子值給累加器函數(shù)的第一次調用（Observable發(fā)射的第一項數(shù)據(jù)）。如果你使用這個版本眯杏，scan將發(fā)射種子值作為自己的第一項數(shù)據(jù)夜焦。注意：傳遞null作為種子值與不傳遞是不同的，null種子值是合法的岂贩。

• Javadoc: scan(R,Func2)

這個操作符默認不在任何特定的調度器上執(zhí)行茫经。

Window

定期將來自原始Observable的數(shù)據(jù)分解為一個Observable窗口，發(fā)射這些窗口萎津，而不是每次發(fā)射一項數(shù)據(jù)

window

Window和Buffer類似卸伞，但不是發(fā)射來自原始Observable的數(shù)據(jù)包，它發(fā)射的是Observables锉屈，這些Observables中的每一個都發(fā)射原始Observable數(shù)據(jù)的一個子集荤傲，最后發(fā)射一個onCompleted通知。

和Buffer一樣颈渊，Window有很多變體遂黍，每一種都以自己的方式將原始Observable分解為多個作為結果的Observable，每一個都包含一個映射原始數(shù)據(jù)的window儡炼。用Window操作符的術語描述就是妓湘，當一個窗口打開(when a window "opens")意味著一個新的Observable已經(jīng)發(fā)射（產(chǎn)生）了查蓉，而且這個Observable開始發(fā)射來自原始Observable的數(shù)據(jù)乌询；當一個窗口關閉(when a window "closes")意味著發(fā)射(產(chǎn)生)的Observable停止發(fā)射原始Observable的數(shù)據(jù)，并且發(fā)射終止通知onCompleted給它的觀察者們豌研。

在RxJava中有許多種Window操作符的變體妹田。

window(closingSelector)

window1

window的這個變體會立即打開它的第一個窗口唬党。每當它觀察到closingSelector返回的Observable發(fā)射了一個對象時，它就關閉當前打開的窗口并立即打開一個新窗口鬼佣。用這個方法驶拱，這種window變體發(fā)射一系列不重疊的窗口，這些窗口的數(shù)據(jù)集合與原始Observable發(fā)射的數(shù)據(jù)是一一對應的晶衷。

• Javadoc: window(Func0)

window(windowOpenings, closingSelector)

window2

無論何時蓝纲，只要window觀察到windowOpenings這個Observable發(fā)射了一個Opening對象，它就打開一個窗口晌纫，并且同時調用closingSelector生成一個與那個窗口關聯(lián)的關閉(closing)Observable税迷。當這個關閉(closing)Observable發(fā)射了一個對象時，window操作符就會關閉那個窗口锹漱。對這個變體來說箭养，由于當前窗口的關閉和新窗口的打開是由單獨的Observable管理的，它創(chuàng)建的窗口可能會存在重疊（重復某些來自原始Observable的數(shù)據(jù)）或間隙（丟棄某些來自原始Observable的數(shù)據(jù)）哥牍。

• Javadoc: window(Observable,Func1)

window(count)

window3

這個window的變體立即打開它的第一個窗口毕泌。每當當前窗口發(fā)射了count項數(shù)據(jù)，它就關閉當前窗口并打開一個新窗口嗅辣。如果從原始Observable收到了onError或onCompleted通知它也會關閉當前窗口撼泛。這種window變體發(fā)射一系列不重疊的窗口，這些窗口的數(shù)據(jù)集合與原始Observable發(fā)射的數(shù)據(jù)是一一對應的澡谭。

• Javadoc: window(int)

window(count, skip)

window4

這個window的變體立即打開它的第一個窗口坎弯。原始Observable每發(fā)射skip項數(shù)據(jù)它就打開一個新窗口（例如，如果skip等于3译暂，每到第三項數(shù)據(jù)抠忘，它會打開一耳光新窗口）。每當當前窗口發(fā)射了count項數(shù)據(jù)外永，它就關閉當前窗口并打開一個新窗口崎脉。如果從原始Observable收到了onError或onCompleted通知它也會關閉當前窗口。如果skip=count伯顶，它的行為與window(source, count)相同囚灼；如果skip < count，窗口可會有count - skip 個重疊的數(shù)據(jù)祭衩；如果skip > count灶体，在兩個窗口之間會有skip - count項數(shù)據(jù)被丟棄。

• Javadoc: window(int,int)

window(timespan, unit[, scheduler])

window5

這個window的變體立即打開它的第一個窗口掐暮。每當過了timespan這么長的時間它就關閉當前窗口并打開一個新窗口（時間單位是unit蝎抽，可選在調度器scheduler上執(zhí)行）。如果從原始Observable收到了onError或onCompleted通知它也會關閉當前窗口路克。這種window變體發(fā)射一系列不重疊的窗口樟结，這些窗口的數(shù)據(jù)集合與原始Observable發(fā)射的數(shù)據(jù)也是一一對應的养交。

• Javadoc: window(long,TimeUnit)
• Javadoc: window(long,TimeUnit,Scheduler)

window(timespan, unit, count[, scheduler])

window6

這個window的變體立即打開它的第一個窗口。這個變體是window(count)和window(timespan, unit[, scheduler])的結合瓢宦，每當過了timespan的時長或者當前窗口收到了count項數(shù)據(jù)碎连，它就關閉當前窗口并打開另一個。如果從原始Observable收到了onError或onCompleted通知它也會關閉當前窗口。這種window變體發(fā)射一系列不重疊的窗口，這些窗口的數(shù)據(jù)集合與原始Observable發(fā)射的數(shù)據(jù)也是一一對應的逼泣。

• Javadoc: window(long,TimeUnit,int)
• Javadoc: window(long,TimeUnit,int,Scheduler)

window(timespan, timeshift, unit[, scheduler])

window7

buffer(timespan,?timeshift,?unit)在每一個timeshift時期內都創(chuàng)建一個新的List,然后用原始Observable發(fā)射的每一項數(shù)據(jù)填充這個列表（在把這個List當做自己的數(shù)據(jù)發(fā)射前，從創(chuàng)建時開始座每，直到過了timespan這么長的時間）。如果timespan長于timeshift摘悴，它發(fā)射的數(shù)據(jù)包將會重疊峭梳，因此可能包含重復的數(shù)據(jù)項。

這個window的變體立即打開它的第一個窗口蹂喻。隨后每當過了timeshift的時長就打開一個新窗口（時間單位是unit葱椭，可選在調度器scheduler上執(zhí)行），當窗口打開的時長達到timespan口四，它就關閉當前打開的窗口孵运。如果從原始Observable收到了onError或onCompleted通知它也會關閉當前窗口。窗口的數(shù)據(jù)可能重疊也可能有間隙蔓彩，取決于你設置的timeshift和timespan的值治笨。

這個變體的window默認在computation調度器上執(zhí)行它的定時器。

• Javadoc: window(long,long,TimeUnit)
• Javadoc: window(long,long,TimeUnit,Scheduler)

window-backpressure

你可以使用Window操作符實現(xiàn)反壓backpressure（意思是赤嚼，處理這樣一個Observable：它產(chǎn)生數(shù)據(jù)的數(shù)據(jù)可能比它的觀察者消費數(shù)據(jù)的數(shù)據(jù)快）旷赖。

bp.window1

Window操作符可以將大量的數(shù)據(jù)序列縮減為較少的數(shù)據(jù)窗口序列，讓它們更容易處理更卒。例如等孵，你可以按固定的時間間隔，定期關閉和發(fā)射來自一個爆發(fā)性Observable的數(shù)據(jù)窗口蹂空。

示例代碼

Observable<Observable<Integer>> burstyWindowed = bursty.window(500, TimeUnit.MILLISECONDS);

bp.window2

你還可以選擇每當收到爆發(fā)性Observable的N項數(shù)據(jù)時發(fā)射一個新的數(shù)據(jù)窗口俯萌。

示例代碼

Observable<Observable<Integer>> burstyWindowed = bursty.window(5);

過濾操作

這個頁面展示的操作符可用于過濾和選擇Observable發(fā)射的數(shù)據(jù)序列。

• filter(?) — 過濾數(shù)據(jù)
• takeLast(?) — 只發(fā)射最后的N項數(shù)據(jù)
• last(?) — 只發(fā)射最后的一項數(shù)據(jù)
• lastOrDefault(?) — 只發(fā)射最后的一項數(shù)據(jù)上枕，如果Observable為空就發(fā)射默認值
• takeLastBuffer(?) — 將最后的N項數(shù)據(jù)當做單個數(shù)據(jù)發(fā)射
• skip(?) — 跳過開始的N項數(shù)據(jù)
• skipLast(?) — 跳過最后的N項數(shù)據(jù)
• take(?) — 只發(fā)射開始的N項數(shù)據(jù)
• first(?) and takeFirst(?) — 只發(fā)射第一項數(shù)據(jù)咐熙，或者滿足某種條件的第一項數(shù)據(jù)
• firstOrDefault(?) — 只發(fā)射第一項數(shù)據(jù)，如果Observable為空就發(fā)射默認值
• elementAt(?) — 發(fā)射第N項數(shù)據(jù)
• elementAtOrDefault(?) — 發(fā)射第N項數(shù)據(jù)辨萍，如果Observable數(shù)據(jù)少于N項就發(fā)射默認值
• sample(?) or throttleLast(?) — 定期發(fā)射Observable最近的數(shù)據(jù)
• throttleFirst(?) — 定期發(fā)射Observable發(fā)射的第一項數(shù)據(jù)
• throttleWithTimeout(?) or debounce(?) — 只有當Observable在指定的時間后還沒有發(fā)射數(shù)據(jù)時棋恼，才發(fā)射一個數(shù)據(jù)
• timeout(?) — 如果在一個指定的時間段后還沒發(fā)射數(shù)據(jù)，就發(fā)射一個異常
• distinct(?) — 過濾掉重復數(shù)據(jù)
• distinctUntilChanged(?) — 過濾掉連續(xù)重復的數(shù)據(jù)
• ofType(?) — 只發(fā)射指定類型的數(shù)據(jù)
• ignoreElements(?) — 丟棄所有的正常數(shù)據(jù)，只發(fā)射錯誤或完成通知

Debounce

僅在過了一段指定的時間還沒發(fā)射數(shù)據(jù)時才發(fā)射一個數(shù)據(jù)

debounce

Debounce操作符會過濾掉發(fā)射速率過快的數(shù)據(jù)項蘸泻。

RxJava將這個操作符實現(xiàn)為throttleWithTimeout和debounce琉苇。

注意：這個操作符會會接著最后一項數(shù)據(jù)發(fā)射原始Observable的onCompleted通知嘲玫，即使這個通知發(fā)生在你指定的時間窗口內（從最后一項數(shù)據(jù)的發(fā)射算起）悦施。也就是說，onCompleted通知不會觸發(fā)限流去团。

throttleWithTimeout

debounce

throtleWithTimeout/debounce的一個變體根據(jù)你指定的時間間隔進行限流抡诞，時間單位通過TimeUnit參數(shù)指定。

這種操作符默認在computation調度器上執(zhí)行土陪，但是你可以通過第三個參數(shù)指定昼汗。

• Javadoc: throttleWithTimeout(long,TimeUnit) and debounce(long,TimeUnit)
• Javadoc: throttleWithTimeout(long,TimeUnit,Scheduler) and debounce(long,TimeUnit,Scheduler)

debounce

debounce

debounce操作符的一個變體通過對原始Observable的每一項應用一個函數(shù)進行限流，這個函數(shù)返回一個Observable鬼雀。如果原始Observable在這個新生成的Observable終止之前發(fā)射了另一個數(shù)據(jù)顷窒，debounce會抑制(suppress)這個數(shù)據(jù)項。

debounce的這個變體默認不在任何特定的調度器上執(zhí)行源哩。

Rxjava操作符四