关于RxJava简单用法(二)

最新推荐文章于 2023-11-06 22:59:58 发布

QQNKW

最新推荐文章于 2023-11-06 22:59:58 发布

阅读量341

点赞数

本文链接：https://blog.csdn.net/QQNKW/article/details/54314102

版权

常用操作符

创建Observable

可以通过create方式创建.但也是最基本的.RxJava为我们提供了一些操作符直接创建Observable;实现不同的功能

just( ):将为你创建一个Observable并自动为你调用onNext( )发射数据

Observable<String> just = Observable.just("A","B", "C");//依次发送A,B,C三个字符串

from( ):遍历集合或数组，发送每个item：

   List<String> list = new ArrayList<>();
   list.add("from1");
   list.add("from2");
   list.add("from3");
   Observable<String> from = Observable.from(list);//遍历list 每次发送一个
/** 注意，just()方法也可以传list，但是发送的是整个list对象，而from（）发送的是list的一个item** /

defer( ):有观察者订阅时才创建Observable，并且为每个观察者创建一个新的Observable：

    Observable<String> defer = Observable.defer(new Func0<Observable<String>>() {
       @Override
    //注意此处的call方法没有Subscriber参数
        public Observable<String> call() {
           return Observable.just("deferObservable");
       }
    });

interval( ):创建一个按固定时间间隔发射整数序列的Observable，可用作定时器：
```
Observable<Long> interval = Observable.interval(1, TimeUnit.SECONDS);//每隔一秒发送一次
```

range( ):创建一个发射特定整数序列的Observable，第一个参数为起始值，第二个为发送的个数，如果为0则不发送，负数则抛异常：
```
Observable<Integer> range = Observable.range(10, 5);//将发送整数10，11，12，13，14
```

timer( ):创建一个Observable，它在一个给定的延迟后发射一个特殊的值，等同于Android中Handler的postDelay( )方法：
```
Observable<Long> timer = Observable.timer(3, TimeUnit.SECONDS);//3秒后发射一个值
```

repeat( ):创建一个重复发射特定数据的Observable:

Observable<String> repeat = Observable.just("repeatObservable").repeat(3);//重复发射3次

其他一些常用转换符
  map:最常用且最实用的操作符之一，将对象转换成另一个对象发射出去，应用范围非常广，如数据的转换，数据的预处理等。
  Observable.just(student1, student2, student2)
                //使用map进行转换，参数1：转换前的类型，参数2：转换后的类型
                .map(new Func1<Student, String>() {
                    @Override
                    public String call(Student i) {
                        String name = i.getName();//获取Student对象中的name
                        return name;//返回name
                    }
                })
                .subscribe(new Action1<String>() {
                    @Override
                    public void call(String s) {
                        nameList.add(s);
                    }
                });
可以看到Observable中原来的参数是Student对象，而最后我们需要的是name，这里使用了map来实现这一转换的过程。当然，map可以多次使用。
//多次使用map，想用几个用几个
        Observable.just("Hello", "World")
                .map(new Func1<String, Integer>() {//将String类型的转化为Integer类型的哈希码
                    @Override
                    public Integer call(String s) {
                        return s.hashCode();
                    }
                })
                .map(new Func1<Integer, String>() {//将转化后得到的Integer类型的哈希码再转化为String类型
                    @Override
                    public String call(Integer integer) {
                        return integer.intValue() + "";
                    }
                })
                .subscribe(new Action1<String>() {
                    @Override
                    public void call(String s) {
                        Log.i(TAG, s);
                    }
                });
  FlatMap：和Map很像但又有所区别，Map只是转换发射的数据类型，而FlatMap可以将原始Observable转换成另一个Observable。
打印所有学校学生的名字:
贴下javaBean
public class School {

  private String name;
  private List<Student> studentList;

  public List<Student> getStudentList() {
      return studentList;
  }
  public void setStudentList(List<Student> studentList) {
      this.studentList = studentList;
  }
  public String getName() {
      return name;
  }
  public void setName(String name) {
      this.name = name;
  }
  public static class Student{
      private String name;
      public String getName() {
          return name;
      }
      public void setName(String name) {
          this.name = name;
      }
  }
}
Observable.from(schoolList).flatMap(new Func1<School, Observable<School.Student>>() {
  @Override//Func第一个泛型是from发射的数据类型,第二个泛型是call的返回值类型,也是最终将要转换成什么类型的Observable发射数据;
  public Observable<School.Student> call(School school) {

      return Observable.from(school.getStudentList()); //关键，将学生列表以另外一个Observable发射出去

  }}).subscribe(new Action1<School.Student>() {

  @Override
  public void call(School.Student student) {
      Log.i("mytag",student.getName());
  }});
  Buffer：缓存，可以设置缓存大小，缓存满后，以list的方式将数据发送出去；
Observable.just(1,2,3).buffer(2).subscribe(new Action1<List<Integer>>() {
  @Override
  public void call(List<Integer> list) {
      Log.i("mytag","size:"+list.size());
  }});
运行打印结果如下：11-02 20:49:58.370 23392-23392/? I/mytag: size:2
11-02 20:49:58.370 23392-23392/? I/mytag: size:1
在开发当中，个人经常将Buffer和Map一起使用，常发生在从后台取完数据，对一个List中的数据进行预处理后，再用Buffer缓存后一起发送，保证最后数据接收还是一个List，如下：
List<School> schoolList = new ArrayList<>();
Observable.from(schoolList).map(new Func1<School, School>() {
  @Override
  public School call(School school) {
      school.setName("NB大学");  //将所有学校改名
      return school;
  }}).buffer(schoolList.size())  //缓存起来，最后一起发送
.subscribe(new Action1<List<School>>() {
  @Override
  public void call(List<School> schools) {   
}});
  Take：发射前n项数据，还是用上面的例子，假设不要改所有学校的名称了，就改前四个学校的名称：
Observable.from(schoolList).take(4).map(new Func1<School, School>() {
  @Override
  public School call(School school) {
      school.setName("NB大学");
      return school;
  }}).buffer(4).subscribe(new Action1<List<School>>() {
  @Override
  public void call(List<School> schools) {
  }});
  Distinct:去掉重复的项，比较好理解:
Observable.just(1, 2, 1, 1, 2, 3)
      .distinct()
      .subscribe(new Action1<Integer>() {
          @Override
          public void call(Integer item) {
              System.out.println("Next: " + item);
          }
      });
输出:
Next: 1
Next: 2
Next: 3
  Filter：过滤，通过谓词判断的项才会被发射，例如，发射小于4的数据：
Observable.just(1, 2, 3, 4, 5)
      .filter(new Func1<Integer, Boolean>() {
          @Override
          public Boolean call(Integer item) {
              return( item < 4 );
          }
      }).subscribe(new Action1<Integer>() {
        @Override
        public void call(Integer item) {
              System.out.println("Next: " + item);
    }});
输出:
Next: 1
Next: 2
Next: 3
操作符大全: 
 
 
  
  创建操作
 
 
用于创建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的操作符
 
   
  
  操作符决策树
 
 
几种主要的需求
 
 直接创建一个Observable（创建操作）
组合多个Observable（组合操作）
对Observable发射的数据执行变换操作（变换操作）
从Observable发射的数据中取特定的值（过滤操作）
转发Observable的部分值（条件/布尔/过滤操作）
对Observable发射的数据序列求值（算术/聚合操作）
参考三位大神的文章合并后形成本文章
https://www.apkdv.com/rxjava-operator-classification/
http://www.jianshu.com/p/52cd2d514528
http://www.jianshu.com/p/5c221c58e141