目录
RxJava提供了大量操作符，本文主要列一些常用到的操作符
1. 创建类型
create
Observable.create(new ObservableOnSubscribe<String>() {
@Override
public void subscribe(ObservableEmitter<String> emitter) throws Exception {
emitter.onNext("1");
}
});
just
Observable.just(1).subscribe(new Consumer<Integer>() {
@Override
public void accept(Integer integer) throws Exception {
}
});
fromArray
Observable.fromArray(1).subscribe(new Consumer<Integer>() {
@Override
public void accept(Integer integer) throws Exception {
}
});
fromCallable
Observable.fromCallable(new Callable<String>() {
@Override
public String call() throws Exception {
return "1";
}
});
它们之间的区别
- create需要主动调用onNext来发送事件，这样下游才能接收到事件
- just用于发送有限个事件(1到9个)，fromArray用于发送数组类型的事件集
2. 转换型
map
map事件流向.png
图中map的作用就是将上游的圆形事件转化成了矩形事件，下面来看看代码例子
Observable.create(new ObservableOnSubscribe<String>() {
@Override
public void subscribe(ObservableEmitter<String> emitter) throws Exception {
emitter.onNext("1");
}
}).map(new Function<String, Integer>() {
@Override
public Integer apply(String s) throws Exception {
return Integer.valueOf(s);
}
}).subscribe(new Consumer<Integer>() {
@Override
public void accept(Integer integer) throws Exception {
Log.d("TAG","integer:"+integer);
}
});
结果输出
D/TAG: integer:1
结果分析
上游我们发送了一个String类型的数据
下游我们收到的是一个Integer类型的数据
map的作用就是将上游的数据转化成下游所需要的任意类型
flatMap
flatMap流向图.png
flatMap与map的区别
map只能处理一对一的转换，而flatMap可以处理一对多，多对多的转换
map直接返回的是要转化的类型，flatMap返回的是Observable对象，这将相当于创建了一个新的管道，下游收到的将是这个管道的东西。
举个栗子
在举例子之前，我们先看一段代码，来看看Observable的的create，just，fromXXX的区别
String[] courses={"数据结构","操作系统","算法导论"};
String[] students={"王二","张三","李四"};
List<Course> courseList=new ArrayList<>();
for(int i=0;i<courses.length;i++){
Course course=new Course();
course.name=courses[I];
courseList.add(course);
}
List<Student> studentList=new ArrayList<>();
for(int i=0;i<students.length;i++){
Student student=new Student();
student.name=students[I];
student.courseList=courseList;
studentList.add(student);
}
Observable.create(new ObservableOnSubscribe<Student>() {
@Override
public void subscribe(ObservableEmitter<Student> emitter) throws Exception {
}
}).subscribe(new Consumer<Student>() {
@Override
public void accept(Student student) throws Exception {
Log.d("TAG","create");
}
});
Observable.just(studentList).subscribe(new Consumer<List<Student>>() {
@Override
public void accept(List<Student> students) throws Exception {
Log.d("TAG","just");
}
});
Observable.fromIterable(studentList).subscribe(new Consumer<Student>() {
@Override
public void accept(Student students) throws Exception {
Log.d("TAG","fromIterable");
}
});
输出结果
D/TAG: just
D/TAG: fromIterable
D/TAG: fromIterable
D/TAG: fromIterable
结果分析
create没有输出，是因为没有主动调用next事件
create只能传递单对象，如果是事件集，需要在subscribe写for循环
jsut可以直接传递事件集，但接收方接收的也是事件集，可以在接收方主动写for循环来拿到每一个对象
fromXXX中也很多个系列，如果是集合则调用fromIterable，数组则可以调用fromArray，from可以直接传递事件集，接收方也会自动将集合遍历
回到主题，假设我们现在有这样一个需求，上游发送一个学生集合，下游需要打印出每一个学生的各个课程，每个学生都有多门课程。
发送学生对象，接收课程对象，我们首先想到的是map的转化
Observable.fromIterable(studentList).map(new Function<Student, List<Course>>() {
@Override
public List<Course> apply(Student student) throws Exception {
Log.d("TAG",student.name);
return student.courseList;
}
}).subscribe(new Consumer<List<Course>>() {
@Override
public void accept(List<Course> courses) throws Exception {
for(int i=0;i<courses.size();i++){
Log.d("TAG",courseList.get(i).name);
}
}
});
输出结果
D/TAG: 王二
D/TAG: 数据结构
D/TAG: 操作系统
D/TAG: 算法导论
D/TAG: 张三
D/TAG: 数据结构
D/TAG: 操作系统
D/TAG: 算法导论
D/TAG: 李四
D/TAG: 数据结构
D/TAG: 操作系统
D/TAG: 算法导论
这样写是没有问题的，但在输出时，多了一层for循环的嵌套，我们来试试flatMap
Observable.fromIterable(studentList).flatMap(new Function<Student, ObservableSource<Course>>() {
@Override
public ObservableSource<Course> apply(Student student) throws Exception {
Log.d("TAG",student.name);
return Observable.fromIterable(student.courseList);
}
}).subscribe(new Consumer<Course>() {
@Override
public void accept(Course course) throws Exception {
Log.d("TAG",course.name);
}
});
输出结果
D/TAG: 王二
D/TAG: 数据结构
D/TAG: 操作系统
D/TAG: 算法导论
D/TAG: 张三
D/TAG: 数据结构
D/TAG: 操作系统
D/TAG: 算法导论
D/TAG: 李四
D/TAG: 数据结构
D/TAG: 操作系统
D/TAG: 算法导论
结果分析
两种方式都能达到我们的目的，即输出每一个学生的多门课程。
不过显然flatMap比map少了一层嵌套，代码格式看着更舒服。
3. 其它
doOnNext
- do系列的作用是side effect,当onNext发生时，它被调用，不改变数据流。
- doOnNext()允许我们在每次输出一个元素之前做一些额外的事情。
举个例子
getUser(userId)
.doOnNext(new Action1<User>() {
@Override
public void call(User user) {
processUser(user);
})
.observeOn(AndroidSchedulers.mainThread())
.subscribe(new Observer<User>() {
@Override
public void onNext(User user) {
userView.setUser(user);
}
@Override
public void onCompleted() {
}
@Override
public void onError(Throwable error) {
// Error handling
...
}
});
在使用User信息之前，在doOnNext方法里对User信息进行了处理，最后执行了subscriber里的OnNext方法。
zip
zip操作示意图.png
简单来讲，zip可以将多个操作合并在一起
场景，有一个页面在展示之前，需要等待两个接口都请求完成之后，将两个接口的数据整合在一起，然后才展示页面
看一下zip的源码
@SuppressWarnings("unchecked")
@CheckReturnValue
@SchedulerSupport(SchedulerSupport.NONE)
public static <T1, T2, R> Observable<R> zip(
ObservableSource<? extends T1> source1, ObservableSource<? extends T2> source2,
BiFunction<? super T1, ? super T2, ? extends R> zipper) {
ObjectHelper.requireNonNull(source1, "source1 is null");
ObjectHelper.requireNonNull(source2, "source2 is null");
return zipArray(Functions.toFunction(zipper), false, bufferSize(), source1, source2);
}
举个例子，我们的两个接口分别是
Observable<Response1>和Observable<Response2>
调用zip操作可以在Response1和Response2都请求完之后，合并成Response3，即BiFunction< Response1,Response2,Response3>
关于RxJava的使用就先到这，要了解更多，请点击文章开头的链接学习，接下来我来谈一谈RxJava和Retrofit的混合使用
网友评论