RxJava操作符
<h3 id="創(chuàng)建操作">創(chuàng)建操作</h3>
<h4 id="Range">Range</h4>
Range操作符根據(jù)初始值n和數(shù)目m發(fā)射一系列大于等于n的m個值
Observable.range(5, 5).subscribe(new Action1<Integer>() {
@Override
public void call(Integer integer) {
Log.d(TAG, "integer=" + integer); //5,6,7,8,9
}
});
<h4>Defer</h4>
Defer操作符只有當有Subscriber來訂閱的時候才會創(chuàng)建一個新的Observable對象,也就是說每次訂閱都會得到一個剛創(chuàng)建的最新的Observable對象，這可以確保Observable對象里的數(shù)據(jù)是最新的。
<h4> Repeat</h4>
Repeat會將一個Observable對象重復(fù)發(fā)射，我們可以指定其發(fā)射的次數(shù)。
Observable.just(1, 2, 3).repeat(5).subscribe(new Action1<Integer>() {
@Override
public void call(Integer integer) {
Log.d(TAG, "integer=" + integer); // 1,2,3,1,2,3...重復(fù)5次
}
});
<h4>Timer</h4>
Timer會在指定時間后發(fā)射一個數(shù)字0，該操作符運行在Computation Scheduler。
Observable.timer(3, TimeUnit.SECONDS).observeOn(AndroidSchedulers.mainThread())
.subscribe(new Action1<Long>() {
@Override
public void call(Long aLong) {
Log.d(TAG, "aLong=" + aLong); // 延時3s
}
});
<h4>Interval</h4>
創(chuàng)建一個按固定時間間隔發(fā)射整數(shù)序列的Observable.
interval默認在computation調(diào)度器上執(zhí)行。你也可以傳遞一個可選的Scheduler參數(shù)來指定調(diào)度器。
// 間隔時間1秒
Observable.interval(1, TimeUnit.SECONDS, AndroidSchedulers.mainThread())
.subscribe(new Action1<Long>() {
@Override
public void call(Long aLong) {
Log.d(TAG, "aLong=" + aLong); //
}
});
<h3 id="變換操作">變換操作</h3>
<h4 id="Buffer">Buffer</h4>
Buffer操作符定期收集Observable的數(shù)據(jù)放進一個數(shù)據(jù)包裹，然后發(fā)射這些數(shù)據(jù)包裹，而不是一次發(fā)射一個值。
Buffer操作符將一個Observable變換為另一個，原來的Observable正常發(fā)射數(shù)據(jù)，變換產(chǎn)生的Observable發(fā)射這些數(shù)據(jù)的緩存集合。
RxView.clickEvents(mButton)
.buffer(2, TimeUnit.SECONDS)
.observeOn(AndroidSchedulers.mainThread())
.subscribe(new Subscriber<List<ViewClickEvent>>() {
@Override
public void onCompleted() {}
@Override
public void onError(Throwable e) {}
@Override
public void onNext(List<ViewClickEvent> viewClickEvents) {
if (viewClickEvents.size() > 0) {
Toast.makeText(MainActivity.this, "2秒內(nèi)點擊了" + viewClickEvents.size() + "次", Toast.LENGTH_SHORT).show();
} else {
}
}
});
如果原來的Observable發(fā)射了一個onError通知，Buffer會立即傳遞這個通知，而不是首先發(fā)射緩存的數(shù)據(jù)，即使在這之前緩存中包含了原始Observable發(fā)射的數(shù)據(jù)。
<h4>GroupBy</h4>
GroupBy操作符將原始Observable發(fā)射的數(shù)據(jù)按照key來拆分成一些小的Observable，然后這些小的Observable分別發(fā)射其所包含的的數(shù)據(jù)。
Observable.just(1, 2, 3, 4, 5, 6)
.groupBy(new Func1<Integer, Boolean>() {
@Override
public Boolean call(Integer integer) {
return integer % 2 == 0;
}
})
.subscribe(new Action1<GroupedObservable<Boolean, Integer>>() {
@Override
public void call(final GroupedObservable<Boolean, Integer> observable) {
//toList方法轉(zhuǎn)換為Observable<List<T>>
observable.toList().subscribe(new Action1<List<Integer>>() {
@Override
public void call(List<Integer> integers) {
Log.d(TAG, "key=" + observable.getKey() + ",values=" + integers);
//key=false,values=[1, 3, 5]
//key=true,values=[2, 4, 6]
}
});
}
});
<h4>Scan</h4>
Scan操作符對一個序列的數(shù)據(jù)應(yīng)用一個函數(shù)，并將這個函數(shù)的結(jié)果發(fā)射出去作為下個數(shù)據(jù)應(yīng)用這個函數(shù)時候的第一個參數(shù)使用。
Observable.from(new Integer[]{1,2,3,4,5,6,7,8,9,10}).scan(new Func2<Integer, Integer, Integer>() {
@Override
public Integer call(Integer x, Integer y) {
return x+y;
}
}).subscribe(new Action1<Integer>() {
@Override
public void call(Integer integer) {
Log.d(TAG, "integer=" + integer);// 1,3,6,10,15,21,28,36,45,55
}
});
<h3>過濾操作</h3>
<h4>Debounce</h4>
<h4>ThrottleWithTimeout</h4>
<h4>Distinct/DistinctUntilChanged</h4>
Distinct操作符用來除去重復(fù)數(shù)據(jù)。
Observable.from(new Integer[]{1,2,2,3,3,3,2,2,1}).distinct().subscribe(new Action1<Integer>() {
@Override
public void call(Integer integer) {
Log.d(TAG, "integer=" + integer); //1,2,3
}
});
DistinctUntilChanged操作符用來過濾掉連續(xù)的重復(fù)數(shù)據(jù)。
Observable.from(new Integer[]{1,2,2,3,3,3,2,2,1}).distinctUntilChanged().subscribe(new Action1<Integer>() {
@Override
public void call(Integer integer) {
Log.d(TAG, "integer=" + integer); //1,2,3,2,1
}
});
<h4>ElementAt</h4>
ElementAt只會返回指定位置的數(shù)據(jù)。
Observable.from(new Integer[]{1,2,3,4,5,6,7,8,9})
.elementAt(4)
.subscribe(new Action1<Integer>() {
@Override
public void call(Integer integer) {
Log.d(TAG, "integer=" + integer); //5
}
});
<h4>Filter</h4>
Filter返回滿足過濾條件的數(shù)據(jù)。
Observable.from(new Integer[]{1, 2, 3, 4, 5, 6, 7, 8, 9})
.filter(new Func1<Integer, Boolean>() {
@Override
public Boolean call(Integer integer) {
return integer < 5;
}
})
.subscribe(new Action1<Integer>() {
@Override
public void call(Integer integer) {
Log.d(TAG, "integer=" + integer); //1,2,3,4
}
});
<h4>First</h4>
First操作符返回第一條數(shù)據(jù)或者返回滿足條件的第一條數(shù)據(jù)。
Observable.from(new Integer[]{1, 2, 3, 4, 5, 6, 7, 8, 9})
.first()
.subscribe(new Action1<Integer>() {
@Override
public void call(Integer integer) {
Log.d(TAG, "integer=" + integer); //1 返回第一條數(shù)據(jù)
}
});
Observable.from(new Integer[]{1, 2, 3, 4, 5, 6, 7, 8, 9})
.first(new Func1<Integer, Boolean>() {
@Override
public Boolean call(Integer integer) {
return integer > 3;
}
})
.subscribe(new Action1<Integer>() {
@Override
public void call(Integer integer) {
Log.d(TAG, "integer=" + integer); //4 返回滿足條件的第一條數(shù)據(jù)
}
});
<h4>Last</h4>
Last操作符返回最后一條數(shù)據(jù)或者滿足條件的最后一條數(shù)據(jù)。
<h4>Skip</h4>
Skip操作符將源Observable發(fā)射的數(shù)據(jù)過濾掉前n項。
Observable.from(new Integer[]{1, 2, 3, 4, 5, 6, 7, 8, 9})
.skip(6)
.subscribe(new Action1<Integer>() {
@Override
public void call(Integer integer) {
Log.d(TAG, "integer=" + integer); //7,8,9
}
});
<h4>Take</h4>
Take操作符只取前n項。
Observable.from(new Integer[]{1, 2, 3, 4, 5, 6, 7, 8, 9})
.take(2)
.subscribe(new Action1<Integer>() {
@Override
public void call(Integer integer) {
Log.d(TAG, "integer=" + integer); //1,2
}
});
<h4>Sample</h4>
Sample操作符會定時地發(fā)射源Observable最近發(fā)射的數(shù)據(jù)，其他的都會被過濾掉。
<h4>ThrottleLast</h4>
<h3 id="結(jié)合操作">結(jié)合操作</h3>
<h4 id="CombineLatest">CombineLatest</h4>
當兩個Observables中的任何一個發(fā)射了數(shù)據(jù)時，使用一個函數(shù)結(jié)合每個Observable發(fā)射的最近數(shù)據(jù)項，并且基于這個函數(shù)的結(jié)果發(fā)射數(shù)據(jù)。
// (200)(400)(600) (800) (1000)
// ---0--- 5---10----15----20
// (300) (600) (900) (1200)(1500)
//------0------5------10--- 15----20
Observable<Long> observable1=Observable.interval(200,TimeUnit.MILLISECONDS)
.map(new Func1<Long, Long>() {
@Override
public Long call(Long aLong) {
return aLong*5;
}
}).take(5);
Observable<Long> observable2=Observable.interval(300,TimeUnit.MILLISECONDS)
.map(new Func1<Long, Long>() {
@Override
public Long call(Long aLong) {
return aLong*5;
}
}).take(5);
Observable.combineLatest(observable1, observable2, new Func2<Long, Long, Long>() {
@Override
public Long call(Long aLong, Long aLong2) {
return aLong+aLong2;
}
}).subscribe(new Action1<Long>() {
@Override
public void call(Long aLong) {
Log.d(TAG, "aLong=" + aLong);
//0(300) ,5+0(400) ,10+0(600),10+5(600),15+5(800),15+10(900)
//20+10(1000),20+15(1200),20+20(1500)
}
});
在實際的開發(fā)中我們可以利用該操作符結(jié)合RxBinding來實現(xiàn)表單提交的校驗。
final Observable<TextViewTextChangeEvent> usernameChangeObservable = RxTextView.textChangeEvents(mUsernameEditText);
final Observable<TextViewTextChangeEvent> passwordChangeObservable = RxTextView.textChangeEvents(mPasswordEditText);
submitButton.setEnabled(false);
Observable.combineLatest(usernameChangeObservable, passwordChangeObservable,
new Func2<TextViewTextChangeEvent, TextViewTextChangeEvent, Boolean>() {
@Override
public Boolean call(TextViewTextChangeEvent event1, TextViewTextChangeEvent event2) {
boolean emailCheck = event1.text().length() >= 3;
boolean passwordCheck = event2.text().length() >= 3;
return emailCheck && passwordCheck;
}
})
.subscribe(new Action1<Boolean>() {
@Override
public void call(Boolean aBoolean) {
submitButton.setEnabled(aBoolean);
}
});
<h4 id="Join">Join</h4>
<h4 id=”Merge“>Merge</h4>
Merge操作符將多個Observable發(fā)射的數(shù)據(jù)整合起來發(fā)射，就如同是一個Observable發(fā)射的數(shù)據(jù)一樣。
當某一個Observable發(fā)出onError的時候，merge的過程會被停止并將錯誤分發(fā)給Subscriber，如果不想讓錯誤終止merge的過程，可以使用MeregeDelayError操作符，會將錯誤在merge結(jié)束后再分發(fā)。
Observable<Long> observable1 = Observable.interval(200, TimeUnit.MILLISECONDS)
.map(new Func1<Long, Long>() {
@Override
public Long call(Long aLong) {
return aLong * 5;
}
}).take(5);
Observable<Long> observable2 = Observable.interval(300, TimeUnit.MILLISECONDS)
.map(new Func1<Long, Long>() {
@Override
public Long call(Long aLong) {
return aLong * 5;
}
}).take(5);
Observable.merge(observable1, observable2).subscribe(new Action1<Long>() {
@Override
public void call(Long aLong) {
Log.d(TAG, "aLong=" + aLong); //0,0,5,10,5,15,10,20,15,20
}
});
<h4 id="StartWith">StartWith</h4>
StartWith操作符會在源Observable發(fā)射的數(shù)據(jù)前面插上一些數(shù)據(jù)。
Observable.just(1, 2, 3, 4).startWith(-1, 0)
.subscribe(new Action1<Integer>() {
@Override
public void call(Integer integer) {
Log.d(TAG,"integer="+integer); // -1,0,1,2,3,4
}
});
Observable.just(1,2,3,4).startWith(Observable.just(-1,0))
.subscribe(new Action1<Integer>() {
@Override
public void call(Integer integer) {
Log.d(TAG,"integer="+integer); // -1,0,1,2,3,4
}
});
<h4 id="Zip">Zip</h4>
Zip操作符將多個Observable發(fā)射的數(shù)據(jù)按順序組合起來，每個數(shù)據(jù)只能組合一次，而且都是有序的。最終組合的數(shù)據(jù)的數(shù)量由發(fā)射數(shù)據(jù)最少的Observable來決定。
// (200)(400)(600) (800) (1000)
// ---0--- 5---10----15----20
// (300) (600) (900) (1200)(1500)
//------0------5------10--- 15----20
Observable<Long> observable1=Observable.interval(200,TimeUnit.MILLISECONDS)
.map(new Func1<Long, Long>() {
@Override
public Long call(Long aLong) {
return aLong*5;
}
}).take(5);
Observable<Long> observable2=Observable.interval(300,TimeUnit.MILLISECONDS)
.map(new Func1<Long, Long>() {
@Override
public Long call(Long aLong) {
return aLong*5;
}
}).take(5);
Observable.zip(observable1, observable2, new Func2<Long, Long, Long>() {
@Override
public Long call(Long aLong, Long aLong2) {
return aLong+aLong2;
}
}).subscribe(new Action1<Long>() {
@Override
public void call(Long aLong) {
Log.d(TAG, "aLong=" + aLong); //0,10,20,30,40
}
});
<h4>Delay操作符</h4>
Delay操作符讓發(fā)射數(shù)據(jù)的時機延后一段時間，這樣所有的數(shù)據(jù)都會依次延后一段時間發(fā)射。在Rxjava中將其實現(xiàn)為Delay和DelaySubscription。不同之處在于Delay是延時數(shù)據(jù)的發(fā)射，而DelaySubscription是延時注冊Subscriber。
<h4>Do操作符</h4>
Do操作符就是給Observable的生命周期的各個階段加上一系列的回調(diào)監(jiān)聽，當Observable執(zhí)行到這個階段的時候，這些回調(diào)就會被觸發(fā)。在Rxjava實現(xiàn)了很多的doXxx操作符。
doOnEach可以給Observable加上這樣的樣一個回調(diào)：Observable每發(fā)射一個數(shù)據(jù)的時候就會觸發(fā)這個回調(diào)，不僅包括onNext還包括onError和onCompleted。
DoOnNext則只有onNext的時候才會被觸發(fā)。
doOnNext則只有onNext的時候才會被觸發(fā)。
doOnError會在OnError發(fā)生的時候觸發(fā)回調(diào)，并將Throwable對象作為參數(shù)傳進回調(diào)函數(shù)里
doOnComplete會在OnCompleted發(fā)生的時候觸發(fā)回調(diào)。
doOnTerminate會在Observable結(jié)束前觸發(fā)回調(diào)，無論是正常還是異常終止；finallyDo會在Observable結(jié)束后觸發(fā)回調(diào)，無論是正常還是異常終止。
doOnSubscribe和doOnUnSubscribe則會在Subscriber進行訂閱和反訂閱的時候觸發(fā)回調(diào)。當一個Observable通過OnError或者OnCompleted結(jié)束的時候，會反訂閱所有的Subscriber。
Observable.just(1, 2, 3, 4)
.doOnEach(new Action1<Notification<? super Integer>>() {
@Override
public void call(Notification<? super Integer> notification) {
Log.d(TAG, "doOnEach" + notification.getKind().name()); // onNext,onNext,onNext,onNext,onCompleted
}
})
.doOnSubscribe(new Action0() {
@Override
public void call() {
Log.d(TAG, "doOnSubscribe");
}
})
.doOnUnsubscribe(new Action0() {
@Override
public void call() {
Log.d(TAG, "doOnUnsubscribe");
}
})
.subscribe(new Action1<Integer>() {
@Override
public void call(Integer integer) {
Log.d(TAG, "integer = " + integer);
}
});
<h4>Meterialize操作符</h4>
Meterialize操作符將OnNext/OnError/OnComplete都轉(zhuǎn)化為一個Notification對象并按照原來的順序發(fā)射出來，而DeMeterialize則是執(zhí)行相反的過程。
Observable.just(1,2,3)
.materialize()
.subscribe(new Action1<Notification<Integer>>() {
@Override
public void call(Notification<Integer> integerNotification) {
Log.d(TAG,"kind="+integerNotification.getKind().name()+"value="+integerNotification.getValue());
}
});
<h4>SubscribOn/ObserverOn</h4>
SubscribOn用來指定Observable在哪個線程上運行。
ObserverOn用來指定觀察者所運行的線程。
<h4>TimeInterval/TimeStamp</h4>
TimeInterval會攔截發(fā)射出來的數(shù)據(jù)，然后發(fā)射兩個發(fā)射數(shù)據(jù)的間隔時間。對于第一個發(fā)射的數(shù)據(jù)，其時間間隔為訂閱后到首次發(fā)射的間隔。
Observable.interval(1,TimeUnit.SECONDS,AndroidSchedulers.mainThread()).
timeInterval().subscribe(new Action1<TimeInterval<Long>>() {
@Override
public void call(TimeInterval<Long> longTimeInterval) {
Log.d(TAG,"value = "+longTimeInterval.getIntervalInMilliseconds());//
}
});
TimeStamp會將每個數(shù)據(jù)項給重新包裝一下，加上了一個時間戳來標明每次發(fā)射的時間。
<h4>Timeout</h4>
Timeout操作符給Observable加上超時時間，每發(fā)射一個數(shù)據(jù)后就重置計時器，當超過預(yù)定的時間還沒有發(fā)射下一個數(shù)據(jù)，就拋出一個超時的異常。
<h4>All操作符</h4>
All操作符根據(jù)一個函數(shù)對源Observable發(fā)射的所有數(shù)據(jù)進行判斷，最終返回的結(jié)果就是這個判斷結(jié)果。這個函數(shù)使用發(fā)射的數(shù)據(jù)作為參數(shù)，內(nèi)部判斷所有的數(shù)據(jù)是否滿足我們定義好的判斷條件，如果全部都滿足則返回true，否則就返回false。
Observable.from(new Integer[]{1,2,3,4,5,6,7,8,9,10}).all(new Func1<Integer, Boolean>() {
@Override
public Boolean call(Integer integer) {
return integer<=10;
}
}).subscribe(new Action1<Boolean>() {
@Override
public void call(Boolean aBoolean) {
Log.d(TAG,"result is "+ aBoolean); //result is true
}
});
<h4>Amb操作符</h4>
Amb操作符可以將至多9個Observable結(jié)合起來，讓他們競爭。哪個Observable首先發(fā)射了數(shù)據(jù)（包括onError和onComplete)就會繼續(xù)發(fā)射這個Observable的數(shù)據(jù)，其他的Observable所發(fā)射的數(shù)據(jù)都會別丟棄。
Observable<Integer> delay3 = Observable.just(1, 2, 3).delay(3000, TimeUnit.MILLISECONDS);
Observable<Integer> delay2 = Observable.just(4, 5, 6).delay(2000, TimeUnit.MILLISECONDS);
Observable<Integer> delay1 = Observable.just(7, 8, 9).delay(1000, TimeUnit.MILLISECONDS);
Observable.amb(delay1, delay2, delay3).subscribe(new Action1<Integer>() {
@Override
public void call(Integer integer) {
Log.d(TAG, "integer=" + integer); // 7,8,9
}
});
<h4>Contains操作符</h4>
Contains操作符用來判斷源Observable所發(fā)射的數(shù)據(jù)是否包含某一個數(shù)據(jù)，如果包含會返回true，如果源Observable已經(jīng)結(jié)束了卻還沒有發(fā)射這個數(shù)據(jù)則返回false。
Observable.from(new Integer[]{1, 2, 3, 4, 5, 6, 7, 8, 9, 10})
.contains(11)
.subscribe(new Action1<Boolean>() {
@Override
public void call(Boolean aBoolean) {
Log.d(TAG, "result is " + aBoolean);//result is false
}
});
<h4>IsEmpty操作符</h4>
IsEmpty操作符用來判斷源Observable是否發(fā)射過數(shù)據(jù)，如果發(fā)射過就會返回false，如果源Observable已經(jīng)結(jié)束了卻還沒有發(fā)射這個數(shù)據(jù)則返回true。
Observable.create(new Observable.OnSubscribe<Object>() {
@Override
public void call(Subscriber<? super Object> subscriber) {
subscriber.onCompleted();
}
}).isEmpty().subscribe(new Action1<Boolean>() {
@Override
public void call(Boolean aBoolean) {
Log.d(TAG, "result is " + aBoolean);//result is true
}
});
<h4>DefaultIfEmpty</h4>
DefaultIfEmpty操作符會判斷源Observable是否發(fā)射數(shù)據(jù)，如果源Observable發(fā)射了數(shù)據(jù)則正常發(fā)射這些數(shù)據(jù)，如果沒有則發(fā)射一個默認的數(shù)據(jù)。
Observable.create(new Observable.OnSubscribe<Integer>() {
@Override
public void call(Subscriber<? super Integer> subscriber) {
subscriber.onCompleted();
}
}).defaultIfEmpty(100).subscribe(new Action1<Integer>() {
@Override
public void call(Integer integer) {
Log.d(TAG, "integer= " + integer); // 100
}
});
<h4>SequenceEqual操作符</h4>
SequenceEqual操作符用來判斷兩個Observable發(fā)射的數(shù)據(jù)序列是否相同（發(fā)射的數(shù)據(jù)相同，數(shù)據(jù)的序列相同，結(jié)束的狀態(tài)相同），如果相同返回true，否則返回false。
Observable.sequenceEqual(Observable.just(1,2,3),Observable.just(1,2,3)).subscribe(new Action1<Boolean>() {
@Override
public void call(Boolean aBoolean) {
Log.d(TAG,"result is "+ aBoolean);//result is true
}
});
Observable.sequenceEqual(Observable.just(1,2),Observable.just(1,2,3)).subscribe(new Action1<Boolean>() {
@Override
public void call(Boolean aBoolean) {
Log.d(TAG,"result is "+ aBoolean);//result is false
}
});
<h4>SkipUntil操作符</h4>
SkipUnitl根據(jù)一個標志Observable來跳過一些數(shù)據(jù)，當這個標志Observable沒有發(fā)射數(shù)據(jù)的時候，所有源Observable發(fā)射的數(shù)據(jù)都會被跳過；當標志Observable發(fā)射了一個數(shù)據(jù)，則開始正常地發(fā)射數(shù)據(jù)。
Observable.interval(1, TimeUnit.SECONDS)
.skipUntil(Observable.timer(3, TimeUnit.SECONDS)) //延遲3s
.subscribe(new Action1<Long>() {
@Override
public void call(Long aLong) {
Log.d(TAG, "aLong = " + aLong); //2,3,4...
}
});
<h4>SkipWhile操作符</h4>
SkipWhile根據(jù)一個函數(shù)來判斷是否跳過數(shù)據(jù)，當函數(shù)返回值為true的時候則一直跳過源Observable發(fā)射的數(shù)據(jù)；當函數(shù)返回false的時候則開始正常發(fā)射數(shù)據(jù)。
Observable.from(new Integer[]{1, 2, 3, 4, 5, 6, 5, 4,3,2,1})
.skipWhile(new Func1<Integer, Boolean>() {
@Override
public Boolean call(Integer integer) { //1,2,3,4,5
Log.d(TAG,"integer -> "+integer ); //如果首次為true后面的將不進行判斷
return integer<5; //
}
}).subscribe(new Action1<Integer>() {
@Override
public void call(Integer integer) {
Log.d(TAG, "integer = " + integer); //5, 6, 5, 4,3,2,1
}
});
<h4>TakeUntil操作符</h4>
TakeUntil使用一個標志Observable是否發(fā)射數(shù)據(jù)來判斷，當標志Observable沒有發(fā)射數(shù)據(jù)時，正常發(fā)射數(shù)據(jù)，而一旦標志Observable發(fā)射過了數(shù)據(jù)則后面的數(shù)據(jù)都會被丟棄。
Observable.interval(1, TimeUnit.SECONDS)
.takeUntil(Observable.timer(3, TimeUnit.SECONDS)) //延遲3s
.subscribe(new Action1<Long>() {
@Override
public void call(Long aLong) {
Log.d(TAG, "aLong = " + aLong); //0,1
}
});
<h4>TakeWhile操作符</h4>
TakeWhile則是根據(jù)一個函數(shù)來判斷是否發(fā)射數(shù)據(jù)，當函數(shù)返回值為true的時候正常發(fā)射數(shù)據(jù)；當函數(shù)返回false的時候丟棄所有后面的數(shù)據(jù)。
Observable.from(new Integer[]{1, 2, 3, 4, 5, 6, 5, 4, 3, 2, 1})
.takeWhile(new Func1<Integer, Boolean>() {
@Override
public Boolean call(Integer integer) { //1,2,3,4,5
Log.d(TAG, "integer -> " + integer); //如果首次為false后面的將不進行判斷
return integer < 5; //
}
}).subscribe(new Action1<Integer>() {
@Override
public void call(Integer integer) {
Log.d(TAG, "integer = " + integer); //1,2,3,4,5
}
});
<h4>Concat操作符</h4>
Concat操作符將多個Observable結(jié)合成一個Observable并發(fā)射數(shù)據(jù)，并且嚴格按照先后順序發(fā)射數(shù)據(jù)，前一個Observable的數(shù)據(jù)沒有發(fā)射完，是不能發(fā)射后面Observable的數(shù)據(jù)的。
Observable<Integer> observable1 = Observable.just(1,2,3);
Observable<Integer> observable2 = Observable.just(4,5,6);
Observable<Integer> observable3 = Observable.just(7,8,9);
Observable.concat(observable1,observable2,observable3).subscribe(new Subscriber<Integer>() {
@Override
public void onCompleted() {}
@Override
public void onError(Throwable e) {}
@Override
public void onNext(Integer integer) {
Log.d(TAG,"integer="+integer);// 1,2,3,4,5,6,7,8,9
}
});
當一個Observable發(fā)生錯誤的時候，發(fā)射會終止。
Observable<Integer> observable1 = Observable.just(1, 2, 3);
Observable<Integer> observable2 = Observable.create(new Observable.OnSubscribe<Integer>() {
@Override
public void call(Subscriber<? super Integer> subscriber) {
subscriber.onError(new Throwable("error"));
}
});
Observable<Integer> observable3 = Observable.just(7, 8, 9);
Observable.concat(observable1, observable2, observable3).subscribe(new Subscriber<Integer>() {
@Override
public void onCompleted() {}
@Override
public void onError(Throwable e) {
Log.e(TAG, e.getMessage());
}
@Override
public void onNext(Integer integer) {
Log.d(TAG, "integer=" + integer);// 1,2,3,error
}
});
<h4>Count操作符</h4>
Count操作符用來統(tǒng)計源Observable發(fā)射了多少個數(shù)據(jù)，最后將數(shù)目給發(fā)射出來；如果源Observable發(fā)射錯誤，則會將錯誤直接報出來；在源Observable沒有終止前，count是不會發(fā)射統(tǒng)計數(shù)據(jù)的。
Observable.just(1, 2, 3).count().subscribe(new Subscriber<Integer>() {
@Override
public void onCompleted() {}
@Override
public void onError(Throwable e) {}
@Override
public void onNext(Integer integer) {
Log.d(TAG, "integer=" + integer); // integer=3
}
});
<h4>Reduce</h4>
Reduce操作符接收Observable發(fā)射的數(shù)據(jù)并利用提供的函數(shù)的計算結(jié)果作為下次計算的參數(shù)，輸出最后的結(jié)果。首次沒有計算結(jié)果傳入前兩個參數(shù)。
Observable.from(new Integer[]{1,2,3,4,5,6,7,8,9,10}).reduce(new Func2<Integer, Integer, Integer>() {
@Override
public Integer call(Integer x, Integer y) {
return x+y; // 1+2+3+4+5+6+7+8+9+10
}
}).subscribe(new Action1<Integer>() {
@Override
public void call(Integer integer) {
Log.d(TAG,"result="+ integer); // result = 55
}
});
<h3>參考</h3>
