Rxjava学习(二操作符)

500 0 0

作者:安卓笔记侠

操作符是为了解决对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对象。

特性:

它不必返回Observable对象返回的类型，你可以使用map操作符返回一个发出新的数据类型的observable对象。
可以对一个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.

from(Iterable<? extends T> iterable)
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         });

内容来源于网络如有侵权请私信删除

标签： Android开发 Android手机开发 Android应用开发

你还没有登录，请先登录或注册！

还没有人评论，欢迎说说您的想法！

Rxjava学习(二操作符)

Rxjava学习(二操作符)

热门标签

推荐文章