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         });