谁来讲讲Rxjava，rxandroid中的操作符的作用

Posted 2023-05-02

ReactiveX的每种编程语言的实现都实现了一组操作符的集合。不同的实现之间有很多重叠的部分，也有一些操作符只存在特定的实现中。每种实现都倾向于用那种编程语言中他们熟悉的上下文中相似的方法给这些操作符命名。 本文首先会给出ReactiveX的核心操作符列表和对应的文档链接，后面还有一个决策树用于帮助你根据具体的场景选择合适的操作符。最后有一个语言特定实现的按字母排序的操作符列表。 如果你想实现你自己的操作符，可以参考这里：实现自定义操作符 创建操作 用于创建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发射的数据序列求值（算术/聚合操作） 参考技术A ReactiveX的每种编程语言的实现都实现了一组操作符的集合。不同的实现之间有很多重叠的部分，也有一些操作符只存在特定的实现中。每种实现都倾向于用那种编程语言中他们熟悉的上下文中相似的方法给这些操作符命名。 本文首先会给出ReactiveX的核心操作符列表和对应的文档链接，后面还有一个决策树用于帮助你根据具体的场景选择合适的操作符。最后有一个语言特定实现的按字母排序的操作符列表。 如果你想实现你自己的操作符，可以参考这里：实现自定义操作符 创建操作 用于创建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发射的数据序列求值（算术/聚合操作）

RxAndroid中observable的基本使用和表单校验操作

RxAndroid 响应式编程 类似于监听-观察者模式

在观察者模式中，你的对象需要实现 RxJava 中的两个关键接口：Observable 和 Observer。当 Observable 的状态改变时，所有的订阅它的 Observer 对象都会被通知。

在 Observable 接口的众多方法中，调用 subscribe() 让 Observer 开始订阅该Observable。

从这时起，Observer 接口有三个方法是 Observable 调用时需要的：

• onNext(T value) 提供了一个新的 T 类型的条目给 Observer
• onComplete() 通知 Observer，Observable 已发送完条目
• onError(Throwable e) 通知 Observer，Observable 遇到了一个错误

gradle配置

 

observable操作大概分为以下几种

1.创建操作

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

2.组合操作

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

3.辅助操作（用于处理Observable的操作符）

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

4.条件和布尔操作（可用于单个或多个数据项，也可用于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的数据，直到一个特定的条件为真，然后跳过剩余的数据

5.错误处理

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

简单用法

  匹配字符串过滤

  

        final List<String> data = new ArrayList<String>() ;
        data.add("a");
        data.add("ac");
        data.add("acccc");
        data.add("a3ddcc");
        data.add("bnbbc");
        data.add("9if");

        RxTextView .textChanges(et_name)
                .debounce(500 , TimeUnit.MILLISECONDS)
                .map(new Function<CharSequence, String>() {
                    @Override
                    public String apply(CharSequence charSequence) throws Exception {
                        return charSequence.toString();
                    }
                })
                .observeOn(Schedulers.io())
//                .filter(new Predicate<String>() {
//                    @Override
//                    public boolean test(String s) throws Exception {
//                        return false;
//                    }
//                })
                .map(new Function<String, List<String>>() {
                    @Override
                    public List<String> apply(String s) throws Exception {
                        List<String> dataList = new ArrayList<String>() ;
                        if ( !TextUtils.isEmpty(s)){
                            //通过key s去过滤list集合
                            for(String bean : data){
                                if(bean.contains(s)){
                                    dataList.add(bean);
                                }
                            }
                        }
                        return dataList;
                    }
                })
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Consumer<List<String>>() {
                    @Override
                    public void accept(List<String> strings) throws Exception {
                        Log.e("LM" , "符合的数据个数  " + (strings == null ? 0 : strings.size()));
                    }
                });
上面的例子就是通过key去过滤list 最后打印出来符合数据的个数。

RxAndroid更好的实现了主/子线程之间的切换，上面的例子我们可以看到subscribeOn()指定向subscribe()动作发生的线程。observeOn（）指定观察者得到通知回调时的线程。

   AndroidSchedulers.mainThread()//主线程

   Schedulers.immediate()//当前线程立马执行

   Schedulers.newThread()//每次创建新线程运行代码

   Scheduler.io()//执行IO操作，或者是网络访问耗时但不耗费CPU的操作

   Schedulers.computation() //执行图形计算等复杂计算

最后 讲一个表单校验的例子，我们很多情况下会有这种场景，一个页面需要用户输入很多信息，刚开始按钮不可点击，当每项信息都输入了之后 按钮变成可点击的状态。这种情况我们一般会想到监听每个输入框的输入
事件，比较麻烦，我们可以通过observable去实现它，如下：
比如有三项准备要输入的内容

InitialValueObservable<CharSequence> observableName = RxTextView.textChanges(et_name);
InitialValueObservable<CharSequence> observablePhone = RxTextView.textChanges(et_phone);
InitialValueObservable<CharSequence> observablePwd = RxTextView.textChanges(et_pwd);
List<InitialValueObservable<CharSequence>> observableList = new ArrayList<>();

observableList.add(observableName);
observableList.add(observablePhone);
observableList.add(observablePwd);

Observable.combineLatest(observableList, new Function<Object[], Boolean>() {

    @Override
    public Boolean apply(Object[] objects) throws Exception {
        for (Object o : objects){
            if(TextUtils.isEmpty((CharSequence) o)){
                return false;
            }
        }
        return true;
    }
}).observeOn(AndroidSchedulers.mainThread()).subscribe(new Observer<Boolean>() {
    @Override
    public void onSubscribe(Disposable d) {

    }

    @Override
    public void onNext(Boolean aBoolean) {
        if(aBoolean){
            btn.setEnabled(true);
        }else{
            btn.setEnabled(false);
        }
    }

    @Override
    public void onError(Throwable e) {

    }

    @Override
    public void onComplete() {

    }
});

代码很清晰，通过apply方法的返回值 会判断按钮是否可以点击。未完待续...