RxJava 和 RxAndroid 二（操做符的使用）
前言：對Rx不瞭解的朋友能夠先看個人第一篇博文 RxJava 和 RxAndroid 一 (基礎)，是對Rxjava的基本介紹html
一、merge操做符，合併觀察對象
19 List<String> list1 = new ArrayList<>() ; 20 List<String> list2 = new ArrayList<>() ; 21 22 list1.add( "1" ) ; 23 list1.add( "2" ) ; 24 list1.add( "3" ) ; 25 26 list2.add( "a" ) ; 27 list2.add( "b" ) ; 28 list2.add( "c" ) ; 29 30 Observable observable1 = Observable.from( list1 ) ; 31 Observable observable2 = Observable.from( list2 ) ; 32 33 //合併數據 先發送observable2的所有數據，而後發送 observable1的所有數據 34 Observable observable = Observable.merge( observable2 , observable1 ) ; 35 36 observable.subscribe(new Action1() { 37 @Override 38 public void call(Object o) { 39 System.out.println( "rx-- " + o ); 40 } 41 }) ; 42
運行結果java
二、zip 操做符，合併多個觀察對象的數據。而且容許 Func2（）函數從新發送合併後的數據
List<String> list1 = new ArrayList<>() ;
List<String> list2 = new ArrayList<>() ;
list1.add( "1" ) ;
list1.add( "2" ) ;
list1.add( "3" ) ;
list2.add( "a" ) ;
list2.add( "b" ) ;
list2.add( "c" ) ;
list2.add( "d" ) ;
Observable observable1 = Observable.from( list1 ) ;
Observable observable2 = Observable.from( list2 ) ;
Observable observable3 = Observable.zip(observable1, observable2, new Func2<String , String , String >() {
@Override
public String call(String s1 , String s2 ) {
return s1 + s2 ;
}
}) ;
observable3.subscribe(new Action1() {
@Override
public void call(Object o) {
System.out.println( "zip-- " + o );
}
}) ;
運行效果：從效果圖上能夠看出，合併兩個的觀察對象數據項應該是相等的；若是出現了數據項不等的狀況，合併的數據項以最小數據隊列爲準。android
三、scan累加器操做符的使用
Observable observable = Observable.just( 1 , 2 , 3 , 4 , 5 ) ;
observable.scan(new Func2<Integer,Integer,Integer>() {
@Override
public Integer call(Integer o, Integer o2) {
return o + o2 ;
}
})
.subscribe(new Action1() {
@Override
public void call(Object o) {
System.out.println( "scan-- " + o );
}
}) ;
運行效果：緩存
第一次發射獲得1，做爲結果與2相加；發射獲得3，做爲結果與3相加，以此類推，打印結果：安全
四、filter 過濾操做符的使用
Observable observable = Observable.just( 1 , 2 , 3 , 4 , 5 , 6 , 7 ) ;
observable.filter(new Func1<Integer , Boolean>() {
@Override
public Boolean call(Integer o) {
//數據大於4的時候纔會被髮送
return o > 4 ;
}
})
.subscribe(new Action1() {
@Override
public void call(Object o) {
System.out.println( "filter-- " + o );
}
}) ;
運行效果服務器
五、 消息數量過濾操做符的使用
- take ：取前n個數據
- takeLast：取後n個數據
- first 只發送第一個數據
- last 只發送最後一個數據
- skip() 跳過前n個數據發送後面的數據
- skipLast() 跳過最後n個數據，發送前面的數據
//take 發送前3個數據
Observable observable = Observable.just( 1 , 2 , 3 , 4 , 5 , 6 , 7 ) ;
observable.take( 3 )
.subscribe(new Action1() {
@Override
public void call(Object o) {
System.out.println( "take-- " + o );
}
}) ;
//takeLast 發送最後三個數據
Observable observable2 = Observable.just( 1 , 2 , 3 , 4 , 5 , 6 , 7 ) ;
observable2.takeLast( 3 )
.subscribe(new Action1() {
@Override
public void call(Object o) {
System.out.println( "takeLast-- " + o );
}
}) ;
//first 只發送第一個數據
Observable observable3 = Observable.just( 1 , 2 , 3 , 4 , 5 , 6 , 7 ) ;
observable3.first()
.subscribe(new Action1() {
@Override
public void call(Object o) {
System.out.println( "first-- " + o );
}
}) ;
//last 只發送最後一個數據
Observable observable4 = Observable.just( 1 , 2 , 3 , 4 , 5 , 6 , 7 ) ;
observable4.last()
.subscribe(new Action1() {
@Override
public void call(Object o) {
System.out.println( "last-- " + o );
}
}) ;
//skip() 跳過前2個數據發送後面的數據
Observable observable5 = Observable.just( 1 , 2 , 3 , 4 , 5 , 6 , 7 ) ;
observable5.skip( 2 )
.subscribe(new Action1() {
@Override
public void call(Object o) {
System.out.println( "skip-- " + o );
}
}) ;
//skipLast() 跳過最後兩個數據，發送前面的數據
Observable observable6 = Observable.just( 1 , 2 , 3 , 4 , 5 , 6 , 7 ) ;
observable5.skipLast( 2 )
.subscribe(new Action1() {
@Override
public void call(Object o) {
System.out.println( "skipLast-- " + o );
}
}) ;
效果圖
六、elementAt 、elementAtOrDefault
//elementAt() 發送數據序列中第n個數據 ，序列號從0開始
//若是該序號大於數據序列中的最大序列號，則會拋出異常，程序崩潰
//因此在用elementAt操做符的時候，要注意判斷髮送的數據序列號是否越界
Observable observable7 = Observable.just( 1 , 2 , 3 , 4 , 5 , 6 , 7 ) ;
observable7.elementAt( 3 )
.subscribe(new Action1() {
@Override
public void call(Object o) {
System.out.println( "elementAt-- " + o );
}
}) ;
//elementAtOrDefault( int n , Object default ) 發送數據序列中第n個數據 ，序列號從0開始。
//若是序列中沒有該序列號，則發送默認值
Observable observable9 = Observable.just( 1 , 2 , 3 , 4 , 5 ) ;
observable9.elementAtOrDefault( 8 , 666 )
.subscribe(new Action1() {
@Override
public void call(Object o) {
System.out.println( "elementAtOrDefault-- " + o );
}
}) ;
運行結果網絡
七、startWith() 插入數據
//插入普通數據
//startWith 數據序列的開頭插入一條指定的項 , 最多插入9條數據
Observable observable = Observable.just( "aa" , "bb" , "cc" ) ;
observable
.startWith( "11" , "22" )
.subscribe(new Action1() {
@Override
public void call(Object o) {
System.out.println( "startWith-- " + o );
}
}) ;
//插入Observable對象
List<String> list = new ArrayList<>() ;
list.add( "ww" ) ;
list.add( "tt" ) ;
observable.startWith( Observable.from( list ))
.subscribe(new Action1() {
@Override
public void call(Object o) {
System.out.println( "startWith2 -- " + o );
}
}) ;
運行結果app
八、delay操做符，延遲數據發送
Observable<String> observable = Observable.just( "1" , "2" , "3" , "4" , "5" , "6" , "7" , "8" ) ;
//延遲數據發射的時間，僅僅延時一次，也就是發射第一個數據前延時。發射後面的數據不延時
observable.delay( 3 , TimeUnit.SECONDS ) //延遲3秒鐘
.subscribe(new Action1() {
@Override
public void call(Object o) {
System.out.println("delay-- " + o);
}
}) ;
九、Timer 延時操做符的使用
使用場景：xx秒後，執行xx ide
//5秒後輸出 hello world , 而後顯示一張圖片
Observable.timer( 5 , TimeUnit.SECONDS )
.observeOn(AndroidSchedulers.mainThread() )
.subscribe(new Action1<Long>() {
@Override
public void call(Long aLong) {
System.out.println( "timer--hello world " + aLong );
findViewById( R.id.image).setVisibility(View.VISIBLE );
}
}) ;
timer 返回一個 Observable , 它在延遲一段給定的時間後發射一個簡單的數字0函數
timer 操做符默認在computation調度器上執行，固然也能夠用 Scheduler 在定義執行的線程。
delay 、timer 總結：
- 相同點：delay 、 timer 都是延時操做符。
- 不一樣點：delay 延時一次，延時完成後，能夠連續發射多個數據。timer延時一次，延時完成後，只發射一次數據。
十、interval 輪詢操做符，循環發送數據，數據從0開始遞增
package app.com.myapplication;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import java.util.concurrent.TimeUnit;
import rx.Observable;
import rx.Subscription;
import rx.functions.Action1;
public class IntervalActivity extends AppCompatActivity {
Subscription subscription ;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_interval);
//參數一：延遲時間 參數二：間隔時間 參數三：時間顆粒度
Observable observable = Observable.interval(3000, 3000, TimeUnit.MILLISECONDS) ;
subscription = observable.subscribe(new Action1() {
@Override
public void call(Object o) {
System.out.println( "interval- " + o );
}
}) ;
}
@Override
protected void onDestroy() {
super.onDestroy();
if ( subscription != null ){
subscription.unsubscribe();
}
}
}
十一、doOnNext() 操做符，在每次 OnNext() 方法被調用前執行
使用場景：從網絡請求數據，在數據被展現前，緩存到本地
Observable observable = Observable.just( "1" , "2" , "3" , "4" ) ;
observable.doOnNext(new Action1() { @Override public void call(Object o) { System.out.println( "doOnNext--緩存數據" + o ); } }) .subscribe(new Observer() { @Override public void onCompleted() { } @Override public void onError(Throwable e) { } @Override public void onNext(Object o) { System.out.println( "onNext--" + o ); } }) ;
十二、Buffer 操做符
- Buffer( int n ) 把n個數據打成一個list包，而後再次發送。
- Buffer( int n , int skip) 把n個數據打成一個list包，而後跳過第skip個數據。
使用場景：一個按鈕每點擊3次，彈出一個toast
List<String> list = new ArrayList<>();
for (int i = 1; i < 10; i++) {
list.add("" + i);
}
Observable<String> observable = Observable.from(list);
observable
.buffer(2) //把每兩個數據爲一組打成一個包，而後發送
.subscribe(new Action1<List<String>>() {
@Override
public void call(List<String> strings) {
System.out.println( "buffer---------------" );
Observable.from( strings ).subscribe(new Action1<String>() {
@Override
public void call(String s) {
System.out.println( "buffer data --" + s );
}
}) ;
}
});
例子2：
//第一、2 個數據打成一個數據包，跳過第三個數據 ； 第四、5個數據打成一個包，跳過第6個數據
observable.buffer( 2 , 3 ) //把每兩個數據爲一組打成一個包，而後發送。第三個數據跳過去
.subscribe(new Action1<List<String>>() {
@Override
public void call(List<String> strings) {
System.out.println( "buffer22---------------" );
Observable.from( strings ).subscribe(new Action1<String>() {
@Override
public void call(String s) {
System.out.println( "buffer22 data --" + s );
}
}) ;
}
}) ;
1三、throttleFirst 操做符
在一段時間內，只取第一個事件，而後其餘事件都丟棄。
使用場景：一、button按鈕防抖操做，防連續點擊 二、百度關鍵詞聯想，在一段時間內只聯想一次，防止頻繁請求服務器
Observable.interval( 1 , TimeUnit.SECONDS) .throttleFirst( 3 , TimeUnit.SECONDS ) .subscribe(new Action1<Long>() { @Override public void call(Long aLong) { System.out.println( "throttleFirst--" + aLong ); } }) ;
這段代碼，是循環發送數據，每秒發送一個。throttleFirst( 3 , TimeUnit.SECONDS ) 在3秒內只取第一個事件，其餘的事件丟棄。
運行結果
1四、distinct 過濾重複的數據
List<String> list = new ArrayList<>() ; list.add( "1" ) ; list.add( "2" ) ; list.add( "1" ) ; list.add( "3" ) ; list.add( "4" ) ; list.add( "2" ) ; list.add( "1" ) ; list.add( "1" ) ; Observable.from( list ) .distinct() .subscribe(new Action1<String>() { @Override public void call(String s) { System.out.println( "distinct--" + s ); } }) ;
從結果能夠看出，重複的數據已經被過濾掉了
distinctUntilChanged() 過濾連續重複的數據
List<String> list = new ArrayList<>() ; list.add( "1" ) ; list.add( "2" ) ; list.add( "1" ) ; list.add( "3" ) ; list.add( "4" ) ; list.add( "4" ) ; list.add( "2" ) ; list.add( "1" ) ; list.add( "1" ) ; Observable.from( list ) .distinctUntilChanged() .subscribe(new Action1<String>() { @Override public void call(String s) { System.out.println( "distinctUntilChanged--" + s ); } }) ;
運行結果
從結果能夠看出，連續重複的數據已經被過濾掉了
1五、debounce() 操做符
一段時間內沒有變化，就會發送一個數據。
使用場景：百度關鍵詞聯想提示。在輸入的過程當中是不會從服務器拉數據的。當輸入結束後，在400毫秒沒有輸入就會去獲取數據。
避免了，屢次請求給服務器帶來的壓力.
1六、doOnSubscribe()
使用場景： 能夠在事件發出以前作一些初始化的工做，好比彈出進度條等等
注意：
一、doOnSubscribe() 默認運行在事件產生的線程裏面，然而事件產生的線程通常都會運行在 io 線程裏。那麼這個時候作一些，更新UI的操做，是線程不安全的。
因此若是事件產生的線程是io線程，可是咱們又要在doOnSubscribe() 更新UI ， 這時候就須要線程切換。
二、若是在 doOnSubscribe() 以後有 subscribeOn() 的話，它將執行在離它最近的 subscribeOn() 所指定的線程。
三、 subscribeOn() 事件產生的線程 ； observeOn() : 事件消費的線程
Observable.create(onSubscribe) .subscribeOn(Schedulers.io()) .doOnSubscribe(new Action0() { @Override public void call() { progressBar.setVisibility(View.VISIBLE); // 須要在主線程執行 } }) .subscribeOn(AndroidSchedulers.mainThread()) // 指定主線程 .observeOn(AndroidSchedulers.mainThread()) .subscribe(subscriber);
1七、range 操做符的使用
首先看range 方法的源碼
public static Observable<Integer> range(int start, int count) {
if (count < 0) {
throw new IllegalArgumentException("Count can not be negative");
}
if (count == 0) {
return Observable.empty();
}
if (start > Integer.MAX_VALUE - count + 1) {
throw new IllegalArgumentException("start + count can not exceed Integer.MAX_VALUE");
}
if(count == 1) {
return Observable.just(start);
}
return Observable.create(new OnSubscribeRange(start, start + (count - 1)));
}
//能夠經過第三個參數控制range執行的線程
public static Observable<Integer> range(int start, int count, Scheduler scheduler) {
return range(start, count).subscribeOn(scheduler);
}
Range操做符發射一個範圍內的有序整數序列，你能夠指定範圍的起始和長度。
RxJava將這個操做符實現爲range函數，它接受兩個參數，一個是範圍的起始值，一個是範圍的數據的數目。若是你將第二個參數設爲0，將致使Observable不發射任何數據（若是設置爲負數，會拋異常）。
range默認不在任何特定的調度器上執行。有一個變體能夠經過可選參數指定Scheduler。
例子
Observable.range( 10 , 3 )
.subscribe(new Action1<Integer>() {
@Override
public void call(Integer integer) {
Log.v( "rx_range " , "" + integer ) ;
}
}) ;
結果
/rx_range: 10
/rx_range: 11
/rx_range: 12
1八、defer 操做符
例子
package app.com.myapplication;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.util.Log;
import rx.Observable;
import rx.functions.Action1;
import rx.functions.Func0;
public class DeferActivity extends AppCompatActivity {
String i = "10" ;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_defer);
i = "11 " ;
Observable<String> defer = Observable.defer(new Func0<Observable<String>>() {
@Override
public Observable<String> call() {
return Observable.just( i ) ;
}
}) ;
Observable test = Observable.just( i ) ;
i = "12" ;
defer.subscribe(new Action1<String>() {
@Override
public void call(String s) {
Log.v( "rx_defer " , "" + s ) ;
}
}) ;
test.subscribe(new Action1() {
@Override
public void call(Object o) {
Log.v( "rx_just " , "" + o ) ;
}
}) ;
}
}
結果
/rx_defer: 12
/rx_just: 11
- 能夠看到，just操做符是在建立Observable就進行了賦值操做，而defer是在訂閱者訂閱時才建立Observable，此時才進行真正的賦值操做。
Defer操做符會一直等待直到有觀察者訂閱它，而後它使用Observable工廠方法生成一個Observable。它對每一個觀察者都這樣作，所以儘管每一個訂閱者都覺得本身訂閱的是同一個Observable，事實上每一個訂閱者獲取的是它們本身的單獨的數據序列。- 在某些狀況下，等待直到最後一分鐘（就是知道訂閱發生時）才生成Observable能夠確保Observable包含最新的數據。
RxJava 和 RxAndroid 三（生命週期控制和內存優化）
相關文章
- 1. RxJava 和 RxAndroid 二（操作符的使用）
- 2. RxJava和RxAndroid
- 3. RxJava操做符（二）----轉換操做符
- 4. RxJava操做符使用
- 5. RxJava操做符
- 6. RxJava 和 RxAndroid 四（RxBinding的使用）
- 7. Rxjava學習(二操做符)
- 8. RxJava 操做符系列二
- 9. 初識RXJava 和 RxAndroid
- 10. Rxjava(三)、操做符的使用
- 更多相關文章...
- • SQL BETWEEN 操作符 - SQL 教程
- • SQL UNION 操作符 - SQL 教程
- • RxJava操作符（二）Transforming Observables
- • RxJava操作符（一）Creating Observables
相關標籤/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
最新文章
歡迎關注本站公眾號,獲取更多信息
