RxJava操作符
<h3 id="創建操作">創建操作</h3>
<h4 id="Range">Range</h4>
Range操作符根據初始值n和數目m發射一系列大于等于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來訂閱的時候才會創建一個新的Observable對象,也就是說每次訂閱都會得到一個剛創建的最新的Observable對象，這可以確保Observable對象里的數據是最新的。
<h4> Repeat</h4>
Repeat會將一個Observable對象重復發射，我們可以指定其發射的次數。
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...重復5次
}
});
<h4>Timer</h4>
Timer會在指定時間后發射一個數字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>
創建一個按固定時間間隔發射整數序列的Observable.
interval默認在computation調度器上執行。你也可以傳遞一個可選的Scheduler參數來指定調度器。
// 間隔時間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的數據放進一個數據包裹，然后發射這些數據包裹，而不是一次發射一個值。
Buffer操作符將一個Observable變換為另一個，原來的Observable正常發射數據，變換產生的Observable發射這些數據的緩存集合。
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秒內點擊了" + viewClickEvents.size() + "次", Toast.LENGTH_SHORT).show();
} else {
}
}
});
如果原來的Observable發射了一個onError通知，Buffer會立即傳遞這個通知，而不是首先發射緩存的數據，即使在這之前緩存中包含了原始Observable發射的數據。
<h4>GroupBy</h4>
GroupBy操作符將原始Observable發射的數據按照key來拆分成一些小的Observable，然后這些小的Observable分別發射其所包含的的數據。
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方法轉換為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操作符對一個序列的數據應用一個函數，并將這個函數的結果發射出去作為下個數據應用這個函數時候的第一個參數使用。
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操作符用來除去重復數據。
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操作符用來過濾掉連續的重復數據。
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只會返回指定位置的數據。
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返回滿足過濾條件的數據。
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操作符返回第一條數據或者返回滿足條件的第一條數據。
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 返回第一條數據
}
});
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 返回滿足條件的第一條數據
}
});
<h4>Last</h4>
Last操作符返回最后一條數據或者滿足條件的最后一條數據。
<h4>Skip</h4>
Skip操作符將源Observable發射的數據過濾掉前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操作符會定時地發射源Observable最近發射的數據，其他的都會被過濾掉。
<h4>ThrottleLast</h4>
<h3 id="結合操作">結合操作</h3>
<h4 id="CombineLatest">CombineLatest</h4>
當兩個Observables中的任何一個發射了數據時，使用一個函數結合每個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.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)
}
});
在實際的開發中我們可以利用該操作符結合RxBinding來實現表單提交的校驗。
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發射的數據整合起來發射，就如同是一個Observable發射的數據一樣。
當某一個Observable發出onError的時候，merge的過程會被停止并將錯誤分發給Subscriber，如果不想讓錯誤終止merge的過程，可以使用MeregeDelayError操作符，會將錯誤在merge結束后再分發。
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發射的數據前面插上一些數據。
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發射的數據按順序組合起來，每個數據只能組合一次，而且都是有序的。最終組合的數據的數量由發射數據最少的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操作符讓發射數據的時機延后一段時間，這樣所有的數據都會依次延后一段時間發射。在Rxjava中將其實現為Delay和DelaySubscription。不同之處在于Delay是延時數據的發射，而DelaySubscription是延時注冊Subscriber。
<h4>Do操作符</h4>
Do操作符就是給Observable的生命周期的各個階段加上一系列的回調監聽，當Observable執行到這個階段的時候，這些回調就會被觸發。在Rxjava實現了很多的doXxx操作符。
doOnEach可以給Observable加上這樣的樣一個回調：Observable每發射一個數據的時候就會觸發這個回調，不僅包括onNext還包括onError和onCompleted。
DoOnNext則只有onNext的時候才會被觸發。
doOnNext則只有onNext的時候才會被觸發。
doOnError會在OnError發生的時候觸發回調，并將Throwable對象作為參數傳進回調函數里
doOnComplete會在OnCompleted發生的時候觸發回調。
doOnTerminate會在Observable結束前觸發回調，無論是正常還是異常終止；finallyDo會在Observable結束后觸發回調，無論是正常還是異常終止。
doOnSubscribe和doOnUnSubscribe則會在Subscriber進行訂閱和反訂閱的時候觸發回調。當一個Observable通過OnError或者OnCompleted結束的時候，會反訂閱所有的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都轉化為一個Notification對象并按照原來的順序發射出來，而DeMeterialize則是執行相反的過程。
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會攔截發射出來的數據，然后發射兩個發射數據的間隔時間。對于第一個發射的數據，其時間間隔為訂閱后到首次發射的間隔。
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會將每個數據項給重新包裝一下，加上了一個時間戳來標明每次發射的時間。
<h4>Timeout</h4>
Timeout操作符給Observable加上超時時間，每發射一個數據后就重置計時器，當超過預定的時間還沒有發射下一個數據，就拋出一個超時的異常。
<h4>All操作符</h4>
All操作符根據一個函數對源Observable發射的所有數據進行判斷，最終返回的結果就是這個判斷結果。這個函數使用發射的數據作為參數，內部判斷所有的數據是否滿足我們定義好的判斷條件，如果全部都滿足則返回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結合起來，讓他們競爭。哪個Observable首先發射了數據（包括onError和onComplete)就會繼續發射這個Observable的數據，其他的Observable所發射的數據都會別丟棄。
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所發射的數據是否包含某一個數據，如果包含會返回true，如果源Observable已經結束了卻還沒有發射這個數據則返回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是否發射過數據，如果發射過就會返回false，如果源Observable已經結束了卻還沒有發射這個數據則返回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是否發射數據，如果源Observable發射了數據則正常發射這些數據，如果沒有則發射一個默認的數據。
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發射的數據序列是否相同（發射的數據相同，數據的序列相同，結束的狀態相同），如果相同返回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根據一個標志Observable來跳過一些數據，當這個標志Observable沒有發射數據的時候，所有源Observable發射的數據都會被跳過；當標志Observable發射了一個數據，則開始正常地發射數據。
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根據一個函數來判斷是否跳過數據，當函數返回值為true的時候則一直跳過源Observable發射的數據；當函數返回false的時候則開始正常發射數據。
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是否發射數據來判斷，當標志Observable沒有發射數據時，正常發射數據，而一旦標志Observable發射過了數據則后面的數據都會被丟棄。
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則是根據一個函數來判斷是否發射數據，當函數返回值為true的時候正常發射數據；當函數返回false的時候丟棄所有后面的數據。
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結合成一個Observable并發射數據，并且嚴格按照先后順序發射數據，前一個Observable的數據沒有發射完，是不能發射后面Observable的數據的。
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發生錯誤的時候，發射會終止。
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操作符用來統計源Observable發射了多少個數據，最后將數目給發射出來；如果源Observable發射錯誤，則會將錯誤直接報出來；在源Observable沒有終止前，count是不會發射統計數據的。
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發射的數據并利用提供的函數的計算結果作為下次計算的參數，輸出最后的結果。首次沒有計算結果傳入前兩個參數。
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>
