Android之Rxjava2.X 2————Rxjava 创建操作符

最新推荐文章于 2024-08-16 11:58:00 发布
最新推荐文章于 2024-08-16 11:58:00 发布
阅读量1.7k 收藏 5
点赞数 3
分类专栏： Android 应用层 文章标签： rxjava
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38499859/article/details/81637932
版权

Android之Rxjava2.X 2————Rxjava 创建操作符

一.目录

文章目录

二.概述

1.作用

创建 被观察者（ Observable） 对象 & 发送事件。

2. 类型

这里写图片描述

三.基本创建

需求场景: 完整的创建被观察者对象

1. create（）

你可以使用Create操作符创建一个完整的Observable，可以传递onNext，onError和onCompleted等事件。
这里写图片描述
代码示例：

 Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> e) throws Exception {
                e.onNext(1);
                e.onNext(2);
                e.onNext(3);
            }
        }).subscribe(new Observer<Integer>() {
            @Override
            public void onSubscribe(Disposable d) {
                Log.d(TAG, "onSubscribe: ");
            }

            @Override
            public void onNext(Integer integer) {
                Log.d(TAG, "onNext: "+integer);
            }

            @Override
            public void onError(Throwable e) {
                Log.d(TAG, "onError: "+e);
            }

            @Override
            public void onComplete() {
                Log.d(TAG, "onComplete: ");
            }
        });

运行结果
这里写图片描述

注意:当观察者发送一个Complete/Error事件后，被观察者在，Complrte/Error事件将会继续发送，但观察者收到Complete/Error事件后，不会继续接收任何事件。被观察者可以不发生Complete/Erroe事件

四.快速创建

需求场景：快速的创建被观察者对象

1.just()
  • 作用:快速创建1个被观察者对象（Observable）
  • 发送事件的特点：直接发送传入的事件
  • 注意1:just最多只能发送9个参数
  • 注意2：如果你传递null给Just，它会返回一个发射null值的Observable
    这里写图片描述
    代码示例
  Observable.just(1, 2, 3)
               .subscribe(new Observer<Integer>() {
                   @Override
                   public void onSubscribe(Disposable d) {
                       Log.d(TAG, "onSubscribe: "+d);
                   }

                   @Override
                   public void onNext(Integer integer) {
                       Log.d(TAG, "onNext: "+integer);
                   }

                   @Override
                   public void onError(Throwable e) {
                       Log.d(TAG, "onError: ");
                   }

                   @Override
                   public void onComplete() {
                       Log.d(TAG, "onComplete: ");
                   }
               });

这里写图片描述

2.fromArray（）
  • 作用：快速创建一个被观察者对象
  • 发送事件的特点：直接发送传入的数据数组
  • fromArray会将数组中的数据转换为Observable对象
  • 应用场景:被观察者对象（Observable） & 发送10个以上事件（数组形式),数组遍历

图中的From包括fromArray（）以及下面的fromIterable（）
这里写图片描述

Integer[] items = { 0, 1, 2, 3, 4 };
        Observable.fromArray(items)
               .subscribe(new Observer<Integer>() {
                   @Override
                   public void onSubscribe(Disposable d) {
                       Log.d(TAG, "onSubscribe: "+d);
                   }

                   @Override
                   public void onNext(Integer integer) {
                       Log.d(TAG, "onNext: "+integer);
                   }

                   @Override
                   public void onError(Throwable e) {
                       Log.d(TAG, "onError: ");
                   }

                   @Override
                   public void onComplete() {
                       Log.d(TAG, "onComplete: ");
                   }
               });

这里写图片描述

3.fromIterable（）
  • 作用:快速创建1个被观察者对象（Observable）
  • 发送事件的特点:直接发送 传入的集合List数据
  • 应用场景:1.快速创建 被观察者对象（Observable） & 发送10个以上事件（集合形式）2.集合元素遍历
  List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        Observable.fromIterable(list)
               .subscribe(new Observer<Integer>() {
                   @Override
                   public void onSubscribe(Disposable d) {
                       Log.d(TAG, "onSubscribe: "+d);
                   }

                   @Override
                   public void onNext(Integer integer) {
                       Log.d(TAG, "onNext: "+integer);
                   }

                   @Override
                   public void onError(Throwable e) {
                       Log.d(TAG, "onError: ");
                   }

                   @Override
                   public void onComplete() {
                       Log.d(TAG, "onComplete: ");
                   }
               });
    }

这里写图片描述

4.其他

下列方法一般用于测试使用
empty():仅发送Complete事件，直接通知完成
error():仅发送Error事件，直接通知异常
never():不发送任何事件

 Observable.empty()
               .subscribe(new Observer<Object>() {
                   @Override
                   public void onSubscribe(Disposable d) {
                       Log.d(TAG, "onSubscribe: "+d);
                   }

                   @Override
                   public void onNext(Object o) {
                       Log.d(TAG, "onNext: "+o);
                   }

                   @Override
                   public void onError(Throwable e) {
                       Log.d(TAG, "onError: ");
                   }

                   @Override
                   public void onComplete() {
                       Log.d(TAG, "onComplete: ");
                   }
               });

 Observable.error(new RuntimeException())
               .subscribe(new Observer<Object>() {
                   @Override
                   public void onSubscribe(Disposable d) {
                       Log.d(TAG, "onSubscribe: "+d);
                   }

                   @Override
                   public void onNext(Object o) {
                       Log.d(TAG, "onNext: "+o);
                   }

                   @Override
                   public void onError(Throwable e) {
                       Log.d(TAG, "onError: ");
                   }

                   @Override
                   public void onComplete() {
                       Log.d(TAG, "onComplete: ");
                   }
               });
Observable.never()
               .subscribe(new Observer<Object>() {
                   @Override
                   public void onSubscribe(Disposable d) {
                       Log.d(TAG, "onSubscribe: "+d);
                   }

                   @Override
                   public void onNext(Object o) {
                       Log.d(TAG, "onNext: "+o);
                   }

                   @Override
                   public void onError(Throwable e) {
                       Log.d(TAG, "onError: ");
                   }

                   @Override
                   public void onComplete() {
                       Log.d(TAG, "onComplete: ");
                   }
               });

这里写图片描述

这里写图片描述

这里写图片描述

五. 延迟创建

需求场景：

  • 定时操作：在经过了x秒后，需要自动执行y操作
  • 周期性操作：每隔x秒后，需要自动执行y操作
1.defer（）
  • 作用:defer（）操作符会一直等待直到有观察者订阅它，然后它使用Observable工厂方法生成一个Observable。在某些情况下，等待直到最后一分钟（就是知道订阅发生时）才生成Observable可以确保Observable包含最新的数据。
  • 使用场景：动态创建被观察者对象（Observable） & 获取最新的Observable对象数据

这里写图片描述

  //  1. 第1次对i赋值
         i= 10;

        Observable<Integer> observable = Observable.defer(new Callable<ObservableSource<? extends Integer>>() {
            @Override
            public ObservableSource<? extends Integer> call() throws Exception {
                return Observable.just(i);
            }
        });

        //  1. 第1次对i赋值
        i = 15;
        observable
                .subscribe(new Observer<Object>() {
                    @Override
                    public void onSubscribe(Disposable d) {
                        Log.d(TAG, "onSubscribe: " + d);
                    }

                    @Override
                    public void onNext(Object o) {
                        Log.d(TAG, "onNext: " + o);
                    }

                    @Override
                    public void onError(Throwable e) {
                        Log.d(TAG, "onError: ");
                    }

                    @Override
                    public void onComplete() {
                        Log.d(TAG, "onComplete: ");
                    }
                });

这里写图片描述

2.timer（）
  • 作用:创建一个Observable，它在一个给定的延迟后发射一个特殊的值。
  • 应用:延迟指定事件，发送一个0，一般用于检测
    这里写图片描述
        // 该例子 = 延迟2s后，发送一个long类型数值
        Observable.timer(2, TimeUnit.SECONDS).subscribe(new Observer<Long>() {
            @Override
            public void onSubscribe(Disposable d) {
                Log.d(TAG, "开始采用subscribe连接");
            }

            @Override
            public void onNext(Long value) {
                Log.d(TAG, "接收到了事件" + value);
            }

            @Override
            public void onError(Throwable e) {
                Log.d(TAG, "对Error事件作出响应");
            }

            @Override
            public void onComplete() {
                Log.d(TAG, "对Complete事件作出响应");
            }
        });

这里写图片描述

3.interval（）
  • 作用 : 按固定的时间间隔发射一个无限递增的整数序列。
  • interval(long,TimeUnit,Scheduler))
  • 参数说明： 参数1 = 第1次延迟时间，参数2 = 间隔时间数字，参数3 = 时间单位；
    这里写图片描述
    Observable.interval(3, 1, TimeUnit.SECONDS)
                // 该例子发送的事件序列特点：延迟3s后发送事件，每隔1秒产生1个数字（从0开始递增1，无限个）
                .subscribe(new Observer<Long>() {
                    @Override
                    public void onSubscribe(Disposable d) {
                        Log.d(TAG, "开始采用subscribe连接");
                    }

                    @Override
                    public void onNext(Long value) {
                        Log.d(TAG, "接收到了事件" + value);
                    }

                    @Override
                    public void onError(Throwable e) {
                        Log.d(TAG, "对Error事件作出响应");
                    }

                    @Override
                    public void onComplete() {
                        Log.d(TAG, "对Complete事件作出响应");
                    }
                });

这里写图片描述

4.intervalRange（）
  • 作用:发送事件的特点：每隔指定时间 就发送 事件，可指定发送的数据（从0开始、无限递增1的的整数）的数量
	// 参数1 = 事件序列起始点；
        // 参数2 = 事件数量；
        // 参数3 = 第1次事件延迟发送时间；
        // 参数4 = 间隔时间数字；
        // 参数5 = 时间单位
Observable.intervalRange(3, 10, 2, 1, TimeUnit.SECONDS)
                // 该例子发送的事件序列特点： 
                // 1. 从3开始，一共发送10个事件； 
                // 2. 第1次延迟2s发送，之后每隔2秒产生1个数字（从0开始递增1，无限个） 
                .subscribe(new Observer<Long>() {
                    @Override
                    public void onSubscribe(Disposable d) {
                        Log.d(TAG, "开始采用subscribe连接");
                    } // 默认最先调用复写的 onSubscribe（） 

                    @Override
                    public void onNext(Long value) {
                        Log.d(TAG, "接收到了事件" + value);
                    }

                    @Override
                    public void onError(Throwable e) {
                        Log.d(TAG, "对Error事件作出响应");
                    }

                    @Override
                    public void onComplete() {
                        Log.d(TAG, "对Complete事件作出响应");
                    }
                });

这里写图片描述

5.range（） /rangeLong（）

range（） 作用：连续发送 1个事件序列，可指定范围,作用类似于intervalRange（），但区别在于：无延迟发送事件

rangeLong（）类似于range（），区别在于该方法支持数据类型 = Long
这里写图片描述

 // 参数说明：
        // 参数1 = 事件序列起始点；
        // 参数2 = 事件数量；
        // 注：若设置为负数，则会抛出异常
        Observable.range(3,10)
                // 该例子发送的事件序列特点：从3开始发送，每次发送事件递增1，一共发送10个事件
                .subscribe(new Observer<Integer>() {
                    @Override
                    public void onSubscribe(Disposable d) {
                        Log.d(TAG, "开始采用subscribe连接");
                    } // 默认最先调用复写的 onSubscribe（）

                    @Override
                    public void onNext(Integer value) {
                        Log.d(TAG, "接收到了事件" + value);
                    }

                    @Override
                    public void onError(Throwable e) {
                        Log.d(TAG, "对Error事件作出响应");
                    }

                    @Override
                    public void onComplete() {
                        Log.d(TAG, "对Complete事件作出响应");
                    }
                });

这里写图片描述

六. 总结

这里写图片描述

七.参考资料

ReactiveX文档中文翻译
Android Rxjava：这是一篇 清晰 & 易懂的Rxjava 入门教程
Rxjava2入门教程一：函数响应式编程及概述
这可能是最好的RxJava 2.x 教程（完结版）
那些年我们错过的响应式编程

八.文章索引

冰炭不投day
关注
专栏目录
Android RxJava使用介绍（二） RxJava的操作符
呼啸而过的专栏
06-03 3万+
上一篇文章我们通过一个简单的例子来给大家展示了RxJava的基本用法，相信大家已经对RxJava有了大概的了解，由于上篇文章对RxJava的使用介绍都是点到为止，并没有进行深入展开，也许你对RxJava有种名不副实的感觉。OK，下面我们就进入正题，一步步的揭开RxJava的神秘面纱！一个例子RxJava的强大之处，在于它提供了非常丰富且功能强悍的操作符，通过使用和组合这些操作符，你几乎能完成所有你想
Android RxJava之操作符
weixin_40929353的博客
09-27 374
最近参照文档对RxJava一系列操作符作了一下理解。 一、创建类操作符 1、Create 创建一个Observable，返回一个emitter（发射器），手动调用onNext()，onError()，onComplete()方法。 2、from Array，Just 创建一个将要发出的一个或一组对象的Observable，会自行调用onNext()，onComplete方法。Just...
深入浅出RxJava(二：操作符)
热门推荐
大头鬼Bruce
03-06 10万+
RxJava operator介绍，介绍了RxJava中几种常见的operator的用法
Android RxJava： 这是一份全面的 操作符 使用汇总 （含详细实例讲解）
最新发布
2401_86022640的博客
08-16 893
RxJava作为一名从事Android的开发者，很多人最近都在和我吐槽Android是不是快要凉了？而在我看来这正是市场成熟的表现，所有的市场都是温水煮青蛙，永远会淘汰掉不愿意学习改变，安于现状的那批人，希望所有的人能在大浪淘沙中留下来，因为对于市场的逐渐成熟，平凡并不是我们唯一的答案！，所有的市场都是温水煮青蛙，永远会淘汰掉不愿意学习改变，安于现状的那批人，希望所有的人能在大浪淘沙中留下来，因为对于市场的逐渐成熟，平凡并不是我们唯一的答案！
Carson带你学Android：RxJava创建操作符
Carson带你学Android
10-16 1万+
前言 Rxjava，由于其基于事件流的链式调用、逻辑简洁 & 使用简单的特点，深受各大 Android开发者的欢迎。 如果还不了解 RxJava，请看文章：Android：这是一篇 清晰 & 易懂的Rxjava 入门教程 RxJava如此受欢迎的原因，在于其提供了丰富 & 功能强大的操作符，几乎能完成所有的功能需求 今天，我将为大家详细介绍RxJava操作符中最常用的创建操作符，并附带 Ret
RxJava操作符概述
qq_42216184的博客
12-11 255
一、RxJava操作符概述 RxJava中的操作符就是为了提供函数式的特性，函数式最大的好处就是使得数据处理简洁易懂。操作符实质上就是RxJava函数式编程模式的体现，在上篇文章中，我详细阐述了RxJava中观察者模式、Iterator模式、函数式编程模式概念的解读，详情请戳→文章传送门 。 Rxjava操作符的类型众多，在本文中，我详细解释如图1.1所示的9种操作符。 图1.1 RxJa...
Android开发之从零开始学RxJava 2.x(一)认识Rxjava
weixin_34087503的博客
07-07 250
欢迎转载，转载请注明出处：https://mp.csdn.net/mdeditor/80772129 落地98k,没有倍镜怪谁，让你扶我你却丢个手雷。 哈哈，大家好，喜欢装逼的我又出现了，今天给大家带来的是RxJava的相关讨论,RxJava已经出来很久了，也是一直在用，但是总感觉没有完全掌握它，所以花了点时间也阅读了很多文章以及官方的文档，决定对其好好总结一番分享点有价值的文章，写一个系列，对...
Android之Rxjava2.X 1————Rxjava概述
冰炭不投day的博客
08-13 1241
Android之Rxjava2.X 1————Rxjava概述 一.目录 Android之Rxjava2.X 1————Rxjava概述 一.目录 二.前言 三.Rx的概述 1.Rx介绍 2.Rx的特点 四.函数响应式编程 1.响应式编程 2.函数响应式编程 五.Rxjava的原理 1.扩展的观察者模式 2.Rxjava的观察者模式流程 六.Rxjava的基本使用 1. 分步...
RxJava3.x入门(二)——创建操作符和变换操作符
AthonyDavis的博客
07-30 564
RxJava3.x入门指南(二)——创建操作符和变换操作符 创建操作符 一、基础创建 1.create() 使用Create操作符创建一个完整的Observable，可以传递onNext，onError和onCompleted等事件。 代码演示： Observable.create((ObservableOnSubscribe<Integer>) e -> { e.onNext(1); e.onNext(2);
RxJava3.x入门(三)——组合操作符
AthonyDavis的博客
07-30 648
RxJava3.x入门指南(三)——组合操作符和过滤操作符 组合操作符 一、合并观察者操作符 1.concat()/concatArray() 作用：组合多个被观察者一起发送数据，合并后 按发送顺序串行执行 两者区别:组合被观察者的数量，即concat（）组合被观察者数量≤4个，而concatArray（）则可＞4个 代码演示： Observable.concat(Observable.just(1,2,3),Observable.just("x","y","z"))
Rxjava2操作符大全
04-24
Rxjava2操作符大全，方便你使用Rxjava2；Rxjava2操作符大全，方便你使用Rxjava2；Rxjava2操作符大全，方便你使用Rxjava2
RxJava3.x入门(一)——概述及使用
AthonyDavis的博客
07-29 966
RxJava3.x入门指南(一) RxJava简介 ReactiveX是Reactive Extensions的缩写，一般简写为Rx。 Rx是一个编程模型，目标是提供一致的编程接口，帮助开发者更方便的处理异步数据流。Rx的大部分语言库由ReactiveX这个组织负责维护，比较流行的有RxJava/RxJS/Rx.NET… 其有一下特点： 观察者模式 函数式风格：对可观察数据流使用无副作用的输入输出函数，避免了程序里错综复杂的状态 简化代码 ：Rxjava的操作符通常可以将复杂的难题简化为很少的几行代码 异
Android RxJava操作符详解系列： 创建操作符
Oliver Lau的博客
12-01 323
前言 Rxjava，由于其基于事件流的链式调用、逻辑简洁 & 使用简单的特点，深受各大 Android开发者的欢迎。 如果还不了解 RxJava，请看文章：Android：这是一篇 清晰 & 易懂的Rxjava 入门教程 RxJava如此受欢迎的原因，在于其提供了丰富 & 功能强大的操作符，几乎能完成所有的功能需求今天，我将为大家详细介绍RxJav
Rxjava2操作符
相公
01-15 540
RxJava2操作符 RxJava2操作符 just fromArray fromIterable map flatMap concatMap zip filter samplethrottleLast take do系列 repeat repeatUntil range rangeLong intervalRange delay delaySubscription materialize
RxJava2操作符
qq_27753689的博客
10-08 295
RxJava2操作符RxJava2操作符创建操作符变换操作符过滤操作符组合操作符其他操作符 RxJava2操作符 总结一下RxJava2的操作符，方便记忆和查询。 创建操作符 1.from：fromArray，将数组转换成observable；fromIterable，将集合转换成observable 2.just：将一个或一些数据转换成observable 3.range：创建以发送范围内的整数...
RXJava的操作符
xiechengfa的技术笔记
07-04 3088
在Rxjava当中最重要的就是操作符，RxJava当中有着庞大的操作符 创建操作符：负责创建Observable对象 just( ) — 将一个或多个对象转换成发射这个或这些对象的一个Observablefrom( ) — 将一个Iterable, 一个Future, 或者一个数组转换成一个Observablerepeat( ) — 创建一个重复发射指定数据或数据序列的Observab
RxJava的操作符
我是永恒的博客
12-04 250
RxJava中提供了大量不同种类，不同场景的Operators(操作符)，RxJava的强大性就来自于它所定义的操作符。主要分类： 创建操作：用于创建Observable的操作符； 变换操作：这些操作符可用于对Observable发射的数据进行变换； 过滤操作：这些操作符用于从Observable发射的数据中进行选择； 组合操作：组合操作符用于将多个Observable组合成一个单一的Ob...
RxJava 的操作符
流水不腐小夏
01-21 1387
著作权归作者所有。 商业转载请联系作者获得授权，非商业转载请注明出处。 作者：冷月 链接：https://www.zhihu.com/question/32209660/answer/63984697 来源：知乎ReactiveX的每种编程语言的实现都实现了一组操作符的集合。不同的实现之间有很多重叠的部分，也有一些操作符只存在特定的实现中。每种实现都倾向于用那种编程语言中他们熟悉的上下文中相
RxJava 2.x新特性深度解析与实战指南
为了简化API和提高易用性，RxJava 2.x 改进了原有的API结构，如移除了一些旧的创建方法和操作符，引入新的函数式编程风格，使代码更加简洁。 RxJava 2.x 新特性旨在提供更好的用户体验，通过改进的流模型、背压...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值