RxJava操作符学习笔记

Map

transform the items emitted by an Observable by applying a function to
each item

用来把一个轩然大波转换为另一个事件。
map()操作符就是用来变换Observable对象的,map操作符再次回到一个Observable对象,那样就足以完成链式调用,在一个Observable对象上屡次应用map操作符,最后将最精简的多少传递给Subscriber对象。

图片 1

原理

实效

特性:

  1. 它不必重临Observable对象回来的品种,你可以应用map操作符重返一个爆发新的数据类型的observable对象。
  2. 可以对一个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);
    }
});

Run起来输出日志:

2015

FlatMap

transform the items emitted by an Observable into Observables, then
flatten the emissions from those into a single Observable

Observable.flatMap()接收一个Observable的出口作为输入,同时输出别的一个Observable。

图片 2

先加一个函数

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

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

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

日志:

_flatMap:Java
_flatMap:Android
_flatMap:Ruby
_flatMap:Ios
_flatMap:Swift

注意:query返回的Observable的输出是List<String>,在flatMap中变成了参数,而处理过后,返回一个Observable<String>.

要是这时候我们要求处理一下所收获的结果,大家加个前缀,在确保不修改subscribe的前提下我们可以如此做:

充实个函数,用来充实个前缀:

static Observable<String>addPre(String lan){
        return Observable.just("addPre_"+lan);
}

代码可以那样写:

query().flatMap(new Func1<List<String>, Observable<String>>() {
    @Override
    public Observable<String> call(List<String> strings) {
        return Observable.from(strings);
    }
}).flatMap(new Func1<String, Observable<String>>() {
    @Override
    public Observable<String> call(String s) {
        //我们在这里调用`addPre`方法,就行处理
        return addPre(s);
    }
}).subscribe(new Action1<String>() {
    @Override
    public void call(String s) {
        System.out.println(s);
    }
});

输出日志

addPre_Java
addPre_Android
addPre_Ruby
addPre_Ios
addPre_Swift

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

map 是在一个 item 被发射之后,到达 map 处经过转换成为另一个 item
,然后继续往下走;
flapMap 是 item 被发射之后,到达 flatMap 处经过转换成为一个 Observable
,而以此 Observable
并不会直接被发射出来,而是会立时被激活,然后把它发出出的种种 item
都流传流中,再持续走下来。
所以 flatMap 和 map 有七个分别:

  1. 透过 Observable 的转换,相当于重新开了一个异步的流;
  2. item 被分流了,个数暴发了扭转。

本条flatMap如故相比难以通晓,它究竟是如何工作的.
协调还亟需多去了然一下.

From

convert various other objects and data types into Observables

from()接过一个集同盟为输入,然后老是输出一个因素给subscriber.

  1. from(Iterable<? extends T> iterable)
  2. from(T[] array)

from

看个例证,将集纳的数额都输出:

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

另外from也承受数组类型:

Observable.from(new String[]{"Java","Android"}).subscribe(new Action1<String>() {
    @Override
    public void call(String s) {
        System.out.println(s);
    }
});

越多操作符

  1. filter 过滤,把不符合条件的过滤掉,留下符合条件的
  2. take 指定最多输出的数额
  3. doOnNext
    允许大家在每一回输出一个要素往日做一些额外的业务(其实就是在onNext里调用的)

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

query().flatMap(new Func1<List<String>, Observable<String>>() {
    @Override
    public Observable<String> call(List<String> strings) {
        return Observable.from(strings);
    }
}).flatMap(new Func1<String, Observable<String>>() {
    @Override
    public Observable<String> call(String s) {
        return addPre(s);
    }
}).filter(new Func1<String, Boolean>() {
    @Override
    public Boolean call(String s) {
        //包含a的留下
        return s.contains("a");
    }
}).take(3)//最多只取3个
  .doOnNext(new Action1<String>() {
    @Override
    public void call(String s) {
        //onNext之前 输出一下
        System.out.println("doOnNext:"+s);
    }
}).subscribe(new Action1<String>() {
    @Override
    public void call(String s) {
        System.out.println(s);
    }
});

输出:

doOnNext:addPre_Java
addPre_Java
doOnNext:addPre_Android
addPre_Android
doOnNext:addPre_Ruby
addPre_Ruby

还有许多居多过多操作符须求去读书,这里就罗列这么多少个.

参考

深切浅出RxJava(二:操作符)
Operators

安利:
我的Github
我的今日头条
自己的微信公众号:

微信公众号

操作符

操作符是为了缓解对Observable对象的更换的题材,操作符用于在Observable和最终的Subscriber里头修改Observable发出的事件。
RxJava提供了好多很有用的操作符。

Subscribers更应有做的工作是“响应”,响应Observable发出的事件,而不是去修改。

从而修改就提交操作符吧.