设为首页收藏本站
开启辅助访问

在路上

 找回密码
 立即注册
在路上 › 站点首页 ›学习 › 查看内容

RxJava操作符学习笔记

2017-2-7 13:43| 发布者: zhangjf| 查看: 507| 评论: 0

摘要: 操作符 操作符是为了解决对Observable对象的变换的问题，操作符用于在Observable和最终的Subscriber之间修改Observable发出的事件。 RxJava提供了很多很有用的操作符。 Subscribers更应该做的事情是“响应”，响应 ...
操作符

操作符是为了解决对Observable对象的变换的问题，操作符用于在Observable和最终的Subscriber之间修改Observable发出的事件。
RxJava提供了很多很有用的操作符。

Subscribers更应该做的事情是“响应”，响应Observable发出的事件，而不是去修改。

所以修改就交给操作符吧.

Map

用来把一个事件转换为另一个事件。
map()操作符就是用于变换Observable对象的，map操作符返回一个Observable对象，这样就可以实现链式调用，在一个Observable对象上多次使用map操作符，最终将最简洁的数据传递给Subscriber对象。

RxJava操作符学习笔记
原理 RxJava操作符学习笔记
实效


特性:

它不必返回Observable对象返回的类型，你可以使用map操作符返回一个发出新的数据类型的observable对象。 可以对一个Observable多次使用map

用一个例子来练习:

  1. //刚创建的Observable是String类型的 Observable.just("Hellp Map Operator")
  2. .map(new Func1<String, Integer>() { @Override public Integer call(String s) { return 2015;//通过第一个map转成Integer }
  3. }).map(new Func1<Integer, String>() { @Override public String call(Integer integer) { return String.valueOf(integer);//再通过第二个map转成String }
  4. }).subscribe(new Action1<String>() { @Override public void call(String s) {
  5. System.out.println(s);
  6. }
  7. });
复制代码

Run起来输出日志:

  1. 2015
复制代码
From

from()接收一个集合作为输入，然后每次输出一个元素给subscriber.

RxJava操作符学习笔记
from

看个例子,将集合的数据都输出:

  1. List<String> s = Arrays.asList("Java", "Android", "Ruby", "Ios", "Swift");
  2. Observable.from(s).subscribe(new Action1<String>() {
  3. @Override public void call(String s) {
  4. System.out.println(s);
  5. }
  6. });
复制代码

Log:

  1. Java
  2. Android
  3. Ruby
  4. Ios
  5. Swift
复制代码

另外from也接受数组类型:

  1. Observable.from(new String[]{"Java","Android"}).subscribe(new Action1<String>() {
  2. @Override public void call(String s) {
  3. System.out.println(s);
  4. }
  5. });
复制代码
FlatMap

Observable.flatMap()接收一个Observable的输出作为输入，同时输出另外一个Observable。

RxJava操作符学习笔记

先加一个函数

  1. static Observable<List<String>>query(){ List<String> s = Arrays.asList("Java", "Android", "Ruby", "Ios", "Swift"); return Observable.just(s);
  2. }
复制代码

我们打印所有query到的语言:

  1. // 注意这里的参数是 query所返回的Observable的输出,并且返会一个Observable<String> query().flatMap(new Func1<List<String>, Observable<String>>() {
  2. @Override public Observable<String> call(List<String> strings) { //结合from处理 return Observable.from(strings);
  3. }
  4. }).subscribe(new Action1<String>() {
  5. @Override public void call(String s) {
  6. System.out.println("_flatMap:"+s);
  7. }
  8. });
复制代码

日志:

  1. _from:Java
  2. _from:Android
  3. _flatMap:Java
  4. _flatMap:Android
  5. _flatMap:Ruby
  6. _flatMap:Ios
  7. _flatMap:Swift
复制代码
  1. 注意:query返回的Observable的输出是List<String>,在flatMap中变成了参数,而处理过后,返回一个Observable<String>.
复制代码

假设这时候我们需要处理一下所获取的结果,我们加个前缀,在保证不修改subscribe的前提下我们可以这么做:

增加个函数,用来增加个前缀:

  1. static Observable<String>addPre(String lan){ return Observable.just("addPre_"+lan);
  2. }
复制代码

代码可以这么写:

  1. query().flatMap(new Func1<List<String>, Observable<String>>() {
  2. @Override
  3. public Observable<String> call(List<String> strings) { return Observable.from(strings);
  4. }
  5. }).flatMap(new Func1<String, Observable<String>>() {
  6. @Override
  7. public Observable<String> call(String s) { //我们在这里调用`addPre`方法,就行处理 return addPre(s);
  8. }
  9. }).subscribe(new Action1<String>() {
  10. @Override
  11. public void call(String s) {
  12. System.out.println(s);
  13. }
  14. });
复制代码

输出日志

  1. addPre_Java
  2. addPre_Android
  3. addPre_Ruby
  4. addPre_Ios
  5. addPre_Swift
复制代码

map与flatMap的区别(出自朱凯):

map 是在一个 item 被发射之后，到达 map 处经过转换变成另一个 item ，然后继续往下走；
flapMap 是 item 被发射之后，到达 flatMap 处经过转换变成一个 Observable ，而这个 Observable 并不会直接被发射出去，而是会立即被激活，然后把它发射出的每个 item 都传入流中，再继续走下去。
所以 flatMap 和 map 有两个区别：

经过 Observable 的转换，相当于重新开了一个异步的流； item 被分散了，个数发生了变化。

这个flatMap还是比较难以理解,它到底是如何工作的.
自己还需要多去了解一下.

更多操作符 filter 过滤,把不符合条件的过滤掉,留下符合条件的 take 指定最多输出的数量 doOnNext 允许我们在每次输出一个元素之前做一些额外的事情(其实就是在onNext里调用的)

就用一个例子来演示一下吧:

  1. query().flatMap(new Func1<List<String>, Observable<String>>() {
  2. @Override
  3. public Observable<String> call(List<String> strings) { return Observable.from(strings);
  4. }
  5. }).flatMap(new Func1<String, Observable<String>>() {
  6. @Override
  7. public Observable<String> call(String s) { return addPre(s);
  8. }
  9. }).filter(new Func1<String, Boolean>() {
  10. @Override
  11. public Boolean call(String s) { //包含a的留下 return s.contains("a");
  12. }
  13. }).take(3)//最多只取3个 .doOnNext(new Action1<String>() {
  14. @Override
  15. public void call(String s) { //onNext之前 输出一下 System.out.println("doOnNext:"+s);
  16. }
  17. }).subscribe(new Action1<String>() {
  18. @Override
  19. public void call(String s) {
  20. System.out.println(s);
  21. }
  22. });
复制代码

输出:

  1. doOnNext:addPre_Java
  2. addPre_Java doOnNext:addPre_Android
  3. addPre_Android doOnNext:addPre_Ruby
  4. addPre_Ruby
复制代码

还有很多很多很多操作符需要去学习,这里就列举这么几个.

来自：http://www.jianshu.com/p/88779bda6691

收藏 邀请
上一篇：java spi 深入研究以及 ClassLoader下一篇：java常见错误的列表

最新评论

相关分类

小黑屋|在路上 ( 蜀ICP备15035742号-1 )  

;

GMT+8, 2025-7-9 16:27

Copyright 2015-2025 djqfx

返回顶部