(二)Rxjava操作符

---

如果把整个事件看作是工厂的流水线，Observable就是原料。Observer就是我们的产品经理，这个产品是怎么交到我们产品经理手上的呢？ 中间很重要的就是工人，也就是操作符。它负责在Observable发出的事件和Observable的响应之间做一些处理。

Map

用来把一个事件转换为另一个事件，

Observable.just("RxJava")     
   .map(new Func1<String, Integer>() {
        @Override
        public Integer call(String s) {
            return 2016;                    //将String转为Integer            
        }      
    }).map(new Func1<Integer, String>() {            
        @Override
        public String call(Integer integer) {
            return integer.toString();      //再通过第二个map转成String
        }      
    }).subscribe(new Action1<String>() {
        @Override            
        public void call(String s) {
            System.out.println(s);
        }   
    });

From

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

//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);
                }
          });

FlatMap

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

先加一个函数

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);
           }
      });

假设，我们要在输出的String上加个前缀，在不修改Obserble的基础上怎么修改.

增加一个方法，用来增加前缀

    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);
       }
  });

更多操作符

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

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

query().flatMap(new Func1<List<String>, Observable<? extends String>>() {
     @Override
     public Observable<? extends String> call(List<String> strings) {
      return Observable.from(strings);
     }
 }).filter(new Func1<String, Boolean>() {
  @Override
public Boolean call(String s) {
    return s.contains("a");    //只发射包含“a”的事件
}
 }).take(3).doOnNext(new Action1<String>() {
    @Override
    public void call(String s) {

    }
}).subscribe(new Action1<String>() {
    @Override
    public void call(String s1) {
      System.out.println("_flatMap:" + s1);
    }
});

操作符决策树
几种主要的需求
直接创建一个Observable（创建操作）
组合多个Observable（组合操作）
对Observable发射的数据执行变换操作（变换操作）
从Observable发射的数据中取特定的值（过滤操作）
转发Observable的部分值（条件/布尔/过滤操作）
对Observable发射的数据序列求值（算术/聚合操作）
创建操作
用于创建Observable的操作符

• Create — 通过调用观察者的方法从头创建一个Observable
• Defer — 在观察者订阅之前不创建这个Observable，为每一个观察者创建一个新的Observable
• Empty/Never/Throw — 创建行为受限的特殊Observable
• From — 将其它的对象或数据结构转换为Observable
• Interval — 创建一个定时发射整数序列的Observable
• Just — 将对象或者对象集合转换为一个会发射这些对象的Observable
• Range — 创建发射指定范围的整数序列的Observable
• Repeat — 创建重复发射特定的数据或数据序列的Observable
• Start — 创建发射一个函数的返回值的Observable
• Timer — 创建在一个指定的延迟之后发射单个数据的Observable

变换操作
这些操作符可用于对Observable发射的数据进行变换，详细解释可以看每个操作符的文档

• Buffer — 缓存，可以简单的理解为缓存，它定期从Observable收集数据到一个集合，然后把这些数据集合打包发射，而不是一次发射一个
• FlatMap — 扁平映射，将Observable发射的数据变换为Observables集合，然后将这些Observable发射的数据平坦化的放进一个单独的Observable，可以认为是一个将嵌套的数据结构展开的过程。
• GroupBy — 分组，将原来的Observable分拆为Observable集合，将原始Observable发射的数据按Key分组，每一个Observable发射一组不同的数据
• Map — 映射，通过对序列的每一项都应用一个函数变换Observable发射的数据，实质是对序列中的每一项执行一个函数，函数的参数就是这个数据项
• Scan — 扫描，对Observable发射的每一项数据应用一个函数，然后按顺序依次发射这些值
• Window — 窗口，定期将来自Observable的数据分拆成一些Observable窗口，然后发射这些窗口，而不是每次发射一项。类似于Buffer，但Buffer发射的是数据，Window发射的是Observable，每一个Observable发射原始Observable的数据的一个子集

过滤操作
这些操作符用于从Observable发射的数据中进行选择

• Debounce — 只有在空闲了一段时间后才发射数据，通俗的说，就是如果一段时间没有操作，就执行一次操作
• Distinct — 去重，过滤掉重复数据项
• ElementAt — 取值，取特定位置的数据项
• Filter — 过滤，过滤掉没有通过谓词测试的数据项，只发射通过测试的
• First — 首项，只发射满足条件的第一条数据
• IgnoreElements — 忽略所有的数据，只保留终止通知(onError或onCompleted)
• Last — 末项，只发射最后一条数据
• Sample — 取样，定期发射最新的数据，等于是数据抽样，有的实现里叫ThrottleFirst
• Skip — 跳过前面的若干项数据
• SkipLast — 跳过后面的若干项数据
• Take — 只保留前面的若干项数据
• TakeLast — 只保留后面的若干项数据

组合操作
组合操作符用于将多个Observable组合成一个单一的Observable

• And/Then/When — 通过模式(And条件)和计划(Then次序)组合两个或多个Observable发射的数据集
• CombineLatest — 当两个Observables中的任何一个发射了一个数据时，通过一个指定的函数组合每个>* >* Observable发射的最新数据（一共两个数据），然后发射这个函数的结果
• Join — 无论何时，如果一个Observable发射了一个数据项，只要在另一个Observable发射的数据项定义的时间窗口内，就将两个Observable发射的数据合并发射
• Merge — 将两个Observable发射的数据组合并成一个
• StartWith — 在发射原来的Observable的数据序列之前，先发射一个指定的数据序列或数据项
• Switch — 将一个发射Observable序列的Observable转换为这样一个Observable：它逐个发射那些>* Observable最近发射的数据
• Zip — 打包，使用一个指定的函数将多个Observable发射的数据组合在一起，然后将这个函数的结果作为单项数据发射

错误处理
这些操作符用于从错误通知中恢复

• Catch — 捕获，继续序列操作，将错误替换为正常的数据，从onError通知中恢复
• Retry — 重试，如果Observable发射了一个错误通知，重新订阅它，期待它正常终止

辅助操作
一组用于处理Observable的操作符

• Delay — 延迟一段时间发射结果数据
• Do — 注册一个动作占用一些Observable的生命周期事件，相当于Mock某个操作
• Materialize/Dematerialize — 将发射的数据和通知都当做数据发射，或者反过来
• ObserveOn — 指定观察者观察Observable的调度程序（工作线程）
• Serialize — 强制Observable按次序发射数据并且功能是有效的
• Subscribe — 收到Observable发射的数据和通知后执行的操作
• SubscribeOn — 指定Observable应该在哪个调度程序上执行
• TimeInterval — 将一个Observable转换为发射两个数据之间所耗费时间的Observable
• Timeout — 添加超时机制，如果过了指定的一段时间没有发射数据，就发射一个错误通知
• Timestamp — 给Observable发射的每个数据项添加一个时间戳
• Using — 创建一个只在Observable的生命周期内存在的一次性资源

条件和布尔操作
这些操作符可用于单个或多个数据项，也可用于Observable

• All — 判断Observable发射的所有的数据项是否都满足某个条件
• Amb — 给定多个Observable，只让第一个发射数据的Observable发射全部数据
• Contains — 判断Observable是否会发射一个指定的数据项
• DefaultIfEmpty — 发射来自原始Observable的数据，如果原始Observable没有发射数据，就发射一个默认数据
• SequenceEqual — 判断两个Observable是否按相同的数据序列
• SkipUntil — 丢弃原始Observable发射的数据，直到第二个Observable发射了一个数据，然后发射原始Observable的剩余数据
• SkipWhile — 丢弃原始Observable发射的数据，直到一个特定的条件为假，然后发射原始Observable剩余的数据
• TakeUntil — 发射来自原始Observable的数据，直到第二个Observable发射了一个数据或一个通知
• TakeWhile — 发射原始Observable的数据，直到一个特定的条件为真，然后跳过剩余的数据

算术和聚合操作
这些操作符可用于整个数据序列

• Average — 计算Observable发射的数据序列的平均值，然后发射这个结果
• Concat — 不交错的连接多个Observable的数据
• Count — 计算Observable发射的数据个数，然后发射这个结果
• Max — 计算并发射数据序列的最大值
• Min — 计算并发射数据序列的最小值
• Reduce — 按顺序对数据序列的每一个应用某个函数，然后返回这个值
• Sum — 计算并发射数据序列的和

连接操作
一些有精确可控的订阅行为的特殊Observable

• Connect — 指示一个可连接的Observable开始发射数据给订阅者
• Publish — 将一个普通的Observable转换为可连接的
• RefCount — 使一个可连接的Observable表现得像一个普通的Observable
• Replay — 确保所有的观察者收到同样的数据序列，即使他们在Observable开始发射数据之后才订阅

转换操作

• To — 将Observable转换为其它的对象或数据结构

Blocking 阻塞Observable的操作符