Rxjava學習(二操做符)

操做符是爲了解決對Observable對象的變換的問題，操做符用於在Observable和最終的Subscriber之間修改Observable發出的事件

1.filter

  filter()操做符是能夠對Observable流程的數據進行一層過濾處理,返回一個新的Observable,filter()返回爲false的值將不會發出到Subscriber,咱們來看下具體的代碼

 1 Observable.just("2", "3").filter(new Func1<String, Boolean>() {
 2         @Override
 3         public Boolean call(String s) {
 4             if ("2".equals(s)) {
 5                 return true;
 6             }
 7             //只發送"2"到Subscriber
 8             return false;
 9         }
10     }).subscribe(new Action1<String>() {
11         @Override
12         public void call(String s) {
13             Log.i(TAG, "call3: " + s);
14         }
15 });

2.map  

①事件對象的直接變換；它是 RxJava最經常使用的變換；能夠將Observable深刻的對象1轉換爲對象2發送給Subscriber。

一個Observable對象上能夠屢次使用map操做符

 1  Observable.just("images/logo.png") // 輸入類型 String
 2      .map(new Func1<String, Bitmap>() {
 3          @Override
 4          public Bitmap call(String filePath) { // 參數類型 String
 5              return getBitmapFromPath(filePath); // 返回類型 Bitmap
 6          }
 7      }).subscribe(new Action1<Bitmap>() {
 8         @Override
 9         public void call(Bitmap bitmap) { // 將修改的結果傳到Subscriber中處理
10             showBitmap(bitmap);
11         }
12      });

②用來把一個事件轉換爲另外一個事件。

map()操做符就是用於變換Observable對象的，map操做符返回一個Observable對象，這樣就能夠實現鏈式調用，在一個Observable對象上屢次使用map操做符，最終將最簡潔的數據傳遞給Subscriber對象。

 

特性:

 

1. 它沒必要返回Observable對象返回的類型，你可使用map操做符返回一個發出新的數據類型的observable對象。
2. 能夠對一個Observable屢次使用map

 

用一個例子來練習:

//剛建立的Observable是String類型的
Observable.just("Hellp Map Operator")
.map(new Func1<String, Integer>() {
    @Override
    public Integer call(String s) {
        return 2015;//經過第一個map轉成Integer
    }
}).map(new Func1<Integer, String>() {
    @Override
    public String call(Integer integer) {
        return String.valueOf(integer);//再經過第二個map轉成String
    }
}).subscribe(new Action1<String>() {
    @Override
    public void call(String s) {
        System.out.println(s);
    }
});

 

3.flatMap

flatMap() 也和 map() 相同，也是把傳入的參數轉化以後返回另外一個對象；和 map() 不一樣的是， flatMap() 中返回的是個 Observable 對象，而且這個 Observable 對象並非被直接發送到了 Subscriber 的回調方法中。

         flatMap() 的原理：

       1. 使用傳入的事件對象建立一個 Observable 對象；

       2. 並不發送這個 Observable, 而是將它激活，因而它開始發送事件；

       3. 每個建立出來的 Observable 發送的事件，都被匯入同一個 Observable ，而這個 Observable 負責將這些事件統一交給 Subscriber 的回調方法。

       這三個步驟，把事件拆成了兩級，經過一組新建立的 Observable 將初始的對象『鋪平』以後經過統一路徑分發了下去。

       擴展：因爲能夠在嵌套的Observable 中添加異步代碼， flatMap() 也經常使用於嵌套的異步操做，例如嵌套的網絡請求。

 

使用場景:

有方法根據輸入的字符串返回一個List集合信息 Observable<List<String>> query(String text);
 假如不用flatMap()咱們應該這樣寫:

 query("message")
      .subscribe(new Action1<List<String>>() {
            @Override
            public void call(List<String> mLists) {
              
              Observable.from(mLists)  
               .subscribe(new Action1<String>() {
                @Override
                public void call(String message) {
                      log.i(TAG,message);           
                }
             });      
          }
      }); 

使用flatMap()這樣寫:

query("Hello, world!")  
    .flatMap(new Func1<List<String>, Observable<String>>() {  
        @Override  
        public Observable<String> call(List<String> urls) {  
            return Observable.from(urls);  
        }  
    })  
    .subscribe(new Action1<String>() {
                @Override
                public void call(String message) {
                      log.i(TAG,message);           
                }
   });

4.From

from()接收一個集合做爲輸入，而後每次輸出一個元素給subscriber.

1. from(Iterable<? extends T> iterable)
2. from(T[] array)

Demo

List<String> s = Arrays.asList("Java", "Android", "Ruby", "Ios", "Swift");
Observable.from(s).subscribe(new Action1<String>() {
    @Override
    public void call(String s) {
        System.out.println(s);
    }
});

Log:

Java
Android
Ruby
Ios
Swift

 

 

5.Do操做符

Do操做符是在Observable的生命週期的各個階段加上一系列的回調監聽

 

doOnEach --- Observable每發射一個數據的時候就會觸發這個回調，不只包括onNext還包括onError和onCompleted。
doOnNext --- 只有onNext的時候纔會被觸發
doOnError --- 只有onError發生的時候觸發回調
doOnComplete --- 只有onComplete發生的時候觸發回調
doOnSubscribe和DoOnUnSubscribe --- 在Subscriber進行訂閱和反訂閱的時候觸發回調

doOnTerminate --- 在Observable結束前觸發回調，不管是正常仍是異常終止
finallyDo --- 在Observable結束後觸發回調，不管是正常仍是異常終止

 1 Observable.just(1,2,3)
 2         .doOnEach(new Action1<Notification<? super Integer>>() {
 3             @Override
 4             public void call(Notification<? super Integer> notification) {
 5                 Log.d(TAG,"doOnEach send" + notification);
 6             }
 7         })
 8         .doOnNext(new Action1<Integer>() {
 9             @Override
10             public void call(Integer integer) {
11                 Log.d(TAG,"doOnNext send" + integer);
12             }
13         })
14         .doOnCompleted(new Action0() {
15             @Override
16             public void call() {
17                 Log.d(TAG,"onCompleted");
18             }
19         })
20         .doOnSubscribe(new Action0() {
21             @Override
22             public void call() {
23                 Log.d(TAG,"onSubscribe");
24             }
25         })
26         .doOnUnsubscribe(new Action0() {
27             @Override
28             public void call() {
29                 Log.d(TAG,"onUnSubscribe");
30             }
31         })
32         .subscribe(new Action1<Integer>() {
33             @Override
34             public void call(Integer integer) {
35                 Log.d(TAG,"do:" + integer);
36             }
37         });