RxJava 1.x 理解-3
在 RxJava 1.x 理解-1 中,我们说到了RxJava的简单用法,但是这还远远不够,因为
输入的数据 ---> 被监听者(订阅源)对这些数据进行操作,或者执行响应的处理 --> 产生新的数据,或者事件发送给监听者 --> 监听者执行自己的方法。
其中,RxJava还可以对输入的数据进行变换,产生新数据(可以是复杂的数据),而不是简单的事件触发。
先将数据的提供,进阶一下:
rxJava just 使用
/**
* rxJava just 使用
* just --> 还是使用的create方法
*/
private void rxJavaJust() {
Log.d(TAG, "----------- just ---------"); Observable
.just("just 1", "just 2", "just 3")
.subscribe(new Action1<String>() {
@Override
public void call(String s) {
Log.d(TAG, "Item: " + s);
}
});
}
just会不断的将可变参数数据 just 1 ;just 2 ;just 3 .... 发送出去
rxJava from 使用
/**
* rxJava from 使用
* from --> 还是使用的create方法
*/
private void rxJavaFrom() {
Log.d(TAG, "----------- from ---------"); String[] names = {"1", "2", "3"};
Observable.from(names)
.subscribe(new Subscriber<String>() {
@Override
public void onNext(String s) {
Log.d(TAG, "Item: " + s);
} @Override
public void onCompleted() {
Log.d(TAG, "Completed!");
} @Override
public void onError(Throwable e) {
Log.d(TAG, "Error!");
}
}); Log.d(TAG, "----------- from2 ---------"); // 简单来说就是数据提供了,而且是一个个的提供了,至于要如何执行,那就按观察者自己的事情了。
Observable.from(names)
.subscribe(new Action1<String>() { @Override
public void call(String s) {
Log.d(TAG, "Item: " + s);
} });
}
from会不断的将数组或者集合中的数据一个个发送出去
数据变换
rxjava map 变换
/**
* rxjava map 变换
* 将类型转化成另一个类型
*/
private void rxJavaMap() {
Log.d(TAG, "----------- Map ---------"); Observable.just("1") // 输入类型 String
.map(new Func1<String, Integer>() {
@Override
public Integer call(String s) {
return Integer.parseInt(s);
}
})
.subscribe(new Action1<Integer>() {
@Override
public void call(Integer integer) {
Log.d(TAG, "Item: " + integer + " 执行调用 获取线程id:" + Thread.currentThread().getId());
}
});
}
Observable.just("999", "11") // 输入类型 String
.map(new Func1<String, List<Integer>>() {
@Override
public List<Integer> call(String s) {
List<Integer> ints = new ArrayList<>();
ints.add(Integer.parseInt(s));
ints.add(Integer.parseInt(s));
ints.add(Integer.parseInt(s));
return ints;
}
}).subscribe(new Action1<List<Integer>>() {
@Override
public void call(List<Integer> integers) {
int i = 0;
// 这里进行遍历
for (Integer integer : integers) {
Log.e(TAG, "Item " + i + " :" + +integer);
i += 1;
}
}
}); }
可以看到,将String格式的数据转换成了Integer格式的数据,或者是String格式的数据转换成List<Integer>格式的数据。map是一对一的变换。
rxjava flatMap 变换
/**
* rxjava flatMap 变换
* 事件再次分发:
*
* 从上面的代码可以看出, flatMap() 和 map() 有一个相同点:它也是把传入的参数转化之后返回另一个对象。
* 但需要注意,和 map() 不同的是, flatMap() 中返回的是个 Observable 对象,但这个 Observable 对象并不是被直接发送到了 Subscriber 的回调方法中。
* flatMap() 的原理是这样的:
* 1. 使用传入的事件对象创建一个 Observable 对象;
* 2. 并不发送这个 Observable, 而是将它激活,于是它开始发送事件;
* 3. 每一个创建出来的 Observable 发送的事件,都被汇入同一个 Observable ,而这个 Observable 负责将这些事件统一交给 Subscriber 的回调方法。
* 这三个步骤,把事件拆成了两级,通过一组新创建的 Observable 将初始的对象『铺平』之后通过统一路径分发了下去。而这个『铺平』就是 flatMap() 所谓的 flat。
*/
private void rxJavaFlatMap() {
Log.d(TAG, "----------- rxJavaFlatMap ---------"); List<Student> students = new ArrayList<>();
List<Source> sources = new ArrayList<>();
sources.add(new Source(1, "化学", 80));
sources.add(new Source(2, "物理", 79));
sources.add(new Source(3, "生物", 78));
students.add(new Student("小明1", 1, sources));
students.add(new Student("小明2", 1, sources));
Observable.from(students)
.flatMap(new Func1<Student, Observable<Source>>() {
@Override
public Observable<Source> call(Student student) {
Log.d(TAG, "Item: " + student.name);
return Observable.from(student.mSources);
}
})
.subscribe(new Action1<Source>() {
@Override
public void call(Source source) {
Log.d(TAG, "Item: " + source + " 执行调用 获取线程id:" + Thread.currentThread().getId());
}
});
}
// ------------------------ 测试使用的类 ----------------------------- class Student {
String name;//学生名字
int id;
List<Source> mSources;//每个学生的所有课程 public Student(String name, int id, List<Source> sources) {
this.name = name;
this.id = id;
mSources = sources;
} @Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", id=" + id +
", mSources=" + mSources +
'}';
}
} class Source {
int sourceId;//id
String name;//课程名
int score;//成绩 public Source(int sourceId, String name, int score) {
this.sourceId = sourceId;
this.name = name;
this.score = score;
} @Override
public String toString() {
return "Source{" +
"sourceId=" + sourceId +
", name='" + name + '\'' +
", score=" + score +
'}';
}
}
输出结果:
02-09 15:45:50.580 3223-3223/pers.bolin.rxjavademo D/MainActivity: Item: 小明1
02-09 15:45:50.581 3223-3223/pers.bolin.rxjavademo D/MainActivity: Item: Source{sourceId=1, name='化学', score=80} 执行调用 获取线程id:2
02-09 15:45:50.581 3223-3223/pers.bolin.rxjavademo D/MainActivity: Item: Source{sourceId=2, name='物理', score=79} 执行调用 获取线程id:2
02-09 15:45:50.582 3223-3223/pers.bolin.rxjavademo D/MainActivity: Item: Source{sourceId=3, name='生物', score=78} 执行调用 获取线程id:2
02-09 15:45:50.582 3223-3223/pers.bolin.rxjavademo D/MainActivity: Item: 小明2
02-09 15:45:50.582 3223-3223/pers.bolin.rxjavademo D/MainActivity: Item: Source{sourceId=1, name='化学', score=80} 执行调用 获取线程id:2
02-09 15:45:50.582 3223-3223/pers.bolin.rxjavademo D/MainActivity: Item: Source{sourceId=2, name='物理', score=79} 执行调用 获取线程id:2
02-09 15:45:50.583 3223-3223/pers.bolin.rxjavademo D/MainActivity: Item: Source{sourceId=3, name='生物', score=78} 执行调用 获取线程id:2
其实上述代码,也可以用map实现:
Observable.from(students).map(new Func1<Student, List<Source>>() {
@Override
public List<Source> call(Student student) {
Log.d(TAG, "Item: " + student.name);
return student.mSources;
}
}).subscribe(new Action1<List<Source>>() {
@Override
public void call(List<Source> sources) {
// 主要的差距是这里,我们自己进行了一次循环遍历。而flatMap则不用,直接获取到的就是Source对象,而不是List<Source>对象
for (Source source:sources){
Log.d(TAG, "Item: " + source + " 执行调用 获取线程id:" + Thread.currentThread().getId());
}
}
});
从上面的代码可以看出,
flatMap() 和 map() 有一个相同点:它也是把传入的参数转化之后返回另一个对象。
但需要注意,和 map() 不同的是, flatMap() 中返回的是个 Observable 对象,但这个 Observable 对象并不是被直接发送到了 Subscriber 的回调方法中。
flatMap() 的原理是这样的:
1. 使用传入的事件对象创建一个 Observable 对象;
2. 并不发送这个 Observable, 而是将它激活,于是它开始发送事件;
3. 每一个创建出来的 Observable 发送的事件,都被汇入同一个 Observable ,而这个 Observable 负责将这些事件统一交给 Subscriber 的回调方法。
这三个步骤,把事件拆成了两级,通过一组新创建的 Observable 将初始的对象『铺平』之后通过统一路径分发了下去。而这个『铺平』就是 flatMap() 所谓的 flat。 总结:RxJava的作用就是
对于数据:对输入的数据进行变换,转换成想要的数据,并且可以指定执行的线程,得到最终的结果。
对于事件:触发事件,观察者感知,观察者执行操作,并且可以指定执行的线程。
参考资料:
RxJava 1.x 理解-3的更多相关文章
- RxJava 2.x 理解-3
背压:Flowable / Subscriber 在RxJava 1.x 理解 中,没有讲到背压这个概念,是因为学习太落后了,RxJava都出2了,所以直接在2上学. 背压是下游控制上游流速的一种手段 ...
- RxJava 2.x 理解-1
在RxJava 1.x 系列中,讲解了RxJava的大致用法,因为现在都用RxJava 2了,所以Rxjava 1就不细讲,主要来学习RxJava 2. 基本使用: /** * rajava2 的基本 ...
- RxJava 1.x 理解-2
给RxJava 加入线程控制 -- Scheduler 在 RxJava 1.x 理解-1 中,我们说到了RxJava的简单用法,但是这还远远不够,因为这简单用法是在同一个线程中使用的.比如我们需要在 ...
- RxJava 2.x 理解-2
操作符总结: http://reactivex.io/documentation/operators.html https://github.com/ReactiveX/RxJava/wiki Ope ...
- RxJava 1.x 理解-1
先看下别人实现的最基本的RxJava的实现方式: 在RxJava里面,有两个必不可少的角色:Subscriber(观察者) 和 Observable(订阅源). Subscriber(观察者) Sub ...
- RxJava+RxAndroid+MVP入坑实践(基础篇)
转载请注明出处:http://www.blog.csdn.net/zhyxuexijava/article/details/51597230.com 前段时间看了MVP架构和RxJava,最近也在重构 ...
- 如何深入理解Java泛型
一.泛型的作用与定义 1.1泛型的作用 使用泛型能写出更加灵活通用的代码泛型的设计主要参照了C++的模板,旨在能让人写出更加通用化,更加灵活的代码.模板/泛型代码,就好像做雕塑时的模板,有了模板,需要 ...
- 必读的 Android 文章
必读的 Android 文章 掘金官方 关注 2017.06.07 13:58* 字数 25218 阅读 8782评论 2喜欢 218 写给 Android 开发者的混淆使用手册 - Android ...
- Android 使用Retrofit2.0+OkHttp3.0实现缓存处理+Cookie持久化第三方库
1.Retrofit+OkHttp的缓存机制 1.1.第一点 在响应请求之后在 data/data/<包名>/cache 下建立一个response 文件夹,保存缓存数据. 1.2.第二点 ...
随机推荐
- CSS三大特性(继承、优先级、层叠)之个人见解
首先声明一下CSS三大特性——继承.优先级和层叠.继承即子类元素继承父类的样式,比如font-size,font-weight等f开头的css样式以及text-align,text-indent等t开 ...
- [51nod1009]数字1的数量
解题关键:数位dp,对每一位进行考虑,通过过程得出每一位上1出现的次数 1位数的情况: 在解法二中已经分析过,大于等于1的时候,有1个,小于1就没有. 2位数的情况: N=13,个位数出现的1的次数为 ...
- VR行业纷纷倒闭:有硬件没内容
从去年年底开始,VR就成为了一个流行词汇,不仅是巨头公司砸钱布局,众多创业公司也纷纷投入其中.但是,一窝蜂拥入的企业基本都没有成熟的商业模式和赢利模式,只能靠融资供血.在资本寒冬中,大部分的VR企业开 ...
- 【洛谷 P3469】[POI2008]BLO-Blockade(割点)
题目链接 题意:一个无向联通图,求删去每个点及其所有边后有多少有序点对的连通性发生了变化. Tarjan求割点的例题.. 如果当前点不是割点,那么它对整个图的连通性不产生影响,只有自己与其他\(n-1 ...
- UVALIVE 3307 Adventurous Driving
一开始重新建图搞的.然后参照了别人的博客.这个解法比较好 利用在SPFA维护入队次数.入队次数大于节点数目的位于负环. 那么负环中的点如何DFS到终点.(SPFA从起点开始如果能找到入队大于N那么一定 ...
- maven自动建立目录骨架
maven提供archetype插件,用于创建符合maven规定的目录骨架. 方式一: 命令行执行mvn archetype:generate,在回显中依次写入如下参数: 执行完成会自动的生成响应的标 ...
- 【反演复习计划】【bzoj3994】约数个数和
首先要用数学归纳证明一个结论,不过因为我实在是懒得打公式了... 先发代码吧. #include<bits/stdc++.h> #define N 50005 using namespac ...
- Selenium2+python自动化52-unittest执行顺序【转载】
前言 很多初学者在使用unittest框架时候,不清楚用例的执行顺序到底是怎样的.对测试类里面的类和方法分不清楚,不知道什么时候执行,什么时候不执行. 本篇通过最简单案例详细讲解unittest执行顺 ...
- Deep Learning关于Vision的Reading List
最近开始学习深度学习了,加油! 下文转载自:http://blog.sina.com.cn/s/blog_bda0d2f10101fpp4.html 主要是顺着Bengio的PAMI review的文 ...
- 安装配置Elasticserch的方法
1.安装java环境 先查看环境是否安装 yum list installed |grep java 如果存在自带的环境则卸载 yum -y remove java--openjdk* 查看安装包 y ...