Rxjava学习(二操作符)

上一篇说道我们可以利用操作符对Observable发出的消息进行拦截和修改，Rxjava的操作符很多，这里只介绍几种常用的

filter

  filter()操作符是可以对Observable流程的数据进行一层过滤处理,返回一个新的Observable,filter()返回为false的值将不会发出到Subscriber,我们来看下具体的代码

 

 Observable.just("2", "3").filter(new Func1<String, Boolean>() {
            @Override
            public Boolean call(String s) {
                if ("2".equals(s)) {
                    return true;
                }
                //只发送"2"到Subscriber
                return false;
            }
        }).subscribe(new Action1<String>() {
            @Override
            public void call(String s) {
                Log.i(TAG, "call3: " + s);
            }
        });

map 

  事件对象的直接变换；它是 RxJava最常用的变换；可以将Observable深入的对象1转换为对象2发送给Subscriber。

一个Observable对象上可以多次使用map操作符

 Observable.just("images/logo.png") // 输入类型 String
     .map(new Func1<String, Bitmap>() {
         @Override
         public Bitmap call(String filePath) { // 参数类型 String
             return getBitmapFromPath(filePath); // 返回类型 Bitmap
         }
     }).subscribe(new Action1<Bitmap>() {
        @Override
        public void call(Bitmap bitmap) { // 将修改的结果传到Subscriber中处理
            showBitmap(bitmap);
        }
     });

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

Do操作符

Do操作符是在Observable的生命周期的各个阶段加上一系列的回调监听

doOnEach --- Observable每发射一个数据的时候就会触发这个回调，不仅包括onNext还包括onError和onCompleted。
doOnNext --- 只有onNext的时候才会被触发
doOnError --- 只有onError发生的时候触发回调
doOnComplete --- 只有onComplete发生的时候触发回调
doOnSubscribe和DoOnUnSubscribe --- 在Subscriber进行订阅和反订阅的时候触发回调

doOnTerminate --- 在Observable结束前触发回调，无论是正常还是异常终止
finallyDo --- 在Observable结束后触发回调，无论是正常还是异常终止

Observable.just(1,2,3)
        .doOnEach(new Action1<Notification<? super Integer>>() {
            @Override
            public void call(Notification<? super Integer> notification) {
                Log.d(TAG,"doOnEach send" + notification);
            }
        })
        .doOnNext(new Action1<Integer>() {
            @Override
            public void call(Integer integer) {
                Log.d(TAG,"doOnNext send" + integer);
            }
        })
        .doOnCompleted(new Action0() {
            @Override
            public void call() {
                Log.d(TAG,"onCompleted");
            }
        })
        .doOnSubscribe(new Action0() {
            @Override
            public void call() {
                Log.d(TAG,"onSubscribe");
            }
        })
        .doOnUnsubscribe(new Action0() {
            @Override
            public void call() {
                Log.d(TAG,"onUnSubscribe");
            }
        })
        .subscribe(new Action1<Integer>() {
            @Override
            public void call(Integer integer) {
                Log.d(TAG,"do:" + integer);
            }
        });