RxJava3 辅助操作符

最新推荐文章于 2024-04-22 02:22:42 发布
最新推荐文章于 2024-04-22 02:22:42 发布
阅读量261 收藏
点赞数
分类专栏： # RxJava 文章标签： android kotlin rxjava
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/bigfc/article/details/128602032
版权
本文通过示例详细介绍了RxJava中的几个关键操作符，包括Delay在事件发出前的延迟功能，Do操作符注册的回调处理，Materialize/Dematerialize用于转换Observable的通知，以及SubscribeOn和ObserveOn用于线程切换的操作。此外，还讨论了TimeInterval记录发射间时间、Timeout处理超时和Timestamp添加时间戳的功能。
摘要由CSDN通过智能技术生成

通过具体的示例，学习每个操作符的用法~

1.Delay

Delay操作符修改源Observable，在发出源Observable的每个项目之前暂停特定的时间增量。使Observable发出的整个项目序列在时间上向前移动指定的增量。

示例：

Observable.just(1, 2, 3)
	.delay(2, TimeUnit.SECONDS)
	.subscribe(object : Observer<Int> {
		override fun onSubscribe(d: Disposable) {
			Log.e(TAG, "---------onSubscribe---------")
		}
		override fun onNext(t: Int) {
			Log.e(TAG, "---------onNext--------${t}-")
		}
		override fun onError(e: Throwable) {
			Log.e(TAG, "---------onError---------")
		}
		override fun onComplete() {
			Log.e(TAG, "---------onComplete---------")
		}
	})

执行结果：

从订阅到onNext接收到事件，中间间隔了2S。

2023-01-08 15:47:47.081 E/UtilityOperator: ---------onSubscribe---------
2023-01-08 15:47:49.083 E/UtilityOperator: ---------onNext--------1-
2023-01-08 15:47:49.083 E/UtilityOperator: ---------onNext--------2-
2023-01-08 15:47:49.083 E/UtilityOperator: ---------onNext--------3-
2023-01-08 15:47:49.083 E/UtilityOperator: ---------onComplete---------

2.Do ⭐⭐⭐

通过Do操作符注册将在Observable上发生某些事件时调用的回调，其中这些回调将独立于与Observable级联关联的正常通知集进行调用。do操作符调用优先于正常的通知事件。

示例：

Observable.just(1, 2, 3)
	.doOnEach {
		Log.e(TAG, "---------doOnEach-------${it.value}--")
	}
	.doOnNext {
		Log.e(TAG, "---------doOnNext-------${it}--")
	}
	.doOnSubscribe {
		Log.e(TAG, "---------doOnSubscribe--------")
	}
	.doOnComplete {
		Log.e(TAG, "---------doOnComplete--------")
	}
	.doOnError {
		Log.e(TAG, "---------doOnError--------")
	}
	.doOnTerminate {
		Log.e(TAG, "---------doOnTerminate--------")
	}
	.doFinally {
		Log.e(TAG, "---------doFinally--------")
	}
	.subscribe(object : Observer<Int> {
		override fun onSubscribe(d: Disposable) {
			Log.e(TAG, "---------onSubscribe---------")
		}
		override fun onNext(t: Int) {
			Log.e(TAG, "---------onNext--------${t}-")
		}
		override fun onError(e: Throwable) {
			Log.e(TAG, "---------onError---------")
		}
		override fun onComplete() {
			Log.e(TAG, "---------onComplete---------")
		}
	})

输出结果：

2023-01-08 15:50:56.708 E/UtilityOperator: ---------doOnSubscribe--------
2023-01-08 15:50:56.708 E/UtilityOperator: ---------onSubscribe---------
2023-01-08 15:50:56.709 E/UtilityOperator: ---------doOnEach-------1--
2023-01-08 15:50:56.709 E/UtilityOperator: ---------doOnNext-------1--
2023-01-08 15:50:56.709 E/UtilityOperator: ---------onNext--------1-
2023-01-08 15:50:56.709 E/UtilityOperator: ---------doOnEach-------2--
2023-01-08 15:50:56.709 E/UtilityOperator: ---------doOnNext-------2--
2023-01-08 15:50:56.709 E/UtilityOperator: ---------onNext--------2-
2023-01-08 15:50:56.709 E/UtilityOperator: ---------doOnEach-------3--
2023-01-08 15:50:56.709 E/UtilityOperator: ---------doOnNext-------3--
2023-01-08 15:50:56.709 E/UtilityOperator: ---------onNext--------3-
2023-01-08 15:50:56.709 E/UtilityOperator: ---------doOnEach-------null--
2023-01-08 15:50:56.709 E/UtilityOperator: ---------doOnComplete--------
2023-01-08 15:50:56.709 E/UtilityOperator: ---------doOnTerminate--------
2023-01-08 15:50:56.709 E/UtilityOperator: ---------onComplete---------
2023-01-08 15:50:56.709 E/UtilityOperator: ---------doFinally--------

 

3.Materialize/Dematerialize

Material将源Observable的通知转换为Notification对象，并将其作为返回的Observable发出的通知。

Dematerialize逆转了这个过程：将源Observable中发出的Notification对象转换为结果Observable的通知。

示例：

Observable.just(1, 2, 3)
	.materialize()
	.flatMap {it->
		//it是Notification<Int>
		Observable.just(it)
	}
	.dematerialize {
		it
	}
	.flatMap {it->
		//it是Int
		Observable.just(it)
	}
	.subscribe(object : Observer<Int> {
		override fun onSubscribe(d: Disposable) {
			Log.e(TAG, "---------onSubscribe---------")
		}
		override fun onNext(t: Int) {
			Log.e(TAG, "---------onNext--------${t}-----")
		}
		override fun onError(e: Throwable) {
			Log.e(TAG, "---------onError---------")
		}
		override fun onComplete() {
			Log.e(TAG, "---------onComplete---------")
		}
	})

输出结果：

2023-01-08 16:09:37.336 E/UtilityOperator: ---------onSubscribe---------
2023-01-08 16:09:37.336 E/UtilityOperator: ---------onNext--------1-----
2023-01-08 16:09:37.336 E/UtilityOperator: ---------onNext--------2-----
2023-01-08 16:09:37.337 E/UtilityOperator: ---------onNext--------3-----
2023-01-08 16:09:37.337 E/UtilityOperator: ---------onComplete---------

4.SubscribeOn/ObserveOn ⭐⭐⭐

ObserveOn和SubscribeOn操作符可以用于实现Rxjava上下游线程切换。

SubscribeOn：指定Observable将在哪个线程上开始操作。SubscribeOn这个操作符，与调用的位置无关，而且只有第一次调用时会指定Observable自己在哪个调度器执行。

ObserveOn：指定Observable应在哪个线程上调用其观察者的onNext、onCompleted和onError方法。ObservableOn操作符可以多次调用，调用后Map和Subscribe操作符都会发生在指定的调度器中，实现了线程的切换。

示例：

Observable.just(1, 2, 3)
	.subscribeOn(Schedulers.io())//指定Observable在Io线程执行
	.observeOn(Schedulers.newThread())//切换新的线程
	.map {
		Log.e(TAG, "---------map1-----$it-----${Thread.currentThread().name}--")
		it * 2
	}
	.observeOn(Schedulers.newThread())//切换新的线程
	.map {
		Log.e(TAG, "---------map2-----$it-----${Thread.currentThread().name}--")
		it/2
	}
	.observeOn(AndroidSchedulers.mainThread())//切换Android主线程中监听回调，方便更新UI
	.subscribe(object : Observer<Int> {

		override fun onSubscribe(d: Disposable) {
			Log.e(TAG, "---------onSubscribe---------")
		}

		override fun onNext(t: Int) {
			Log.e(TAG, "---------onNext--------${t}----${Thread.currentThread().name}-")
		}

		override fun onError(e: Throwable) {
			Log.e(TAG, "---------onError---------")
		}

		override fun onComplete() {
			Log.e(TAG, "---------onComplete---------")
		}
	})

输出结果：

2023-01-08 16:32:27.975 E/UtilityOperator: ------onSubscribe---------
2023-01-08 16:32:27.977 E/UtilityOperator: ------map1-----1-----RxNewThreadScheduler-1--
2023-01-08 16:32:27.978 E/UtilityOperator: ------map1-----2-----RxNewThreadScheduler-1--
2023-01-08 16:32:27.978 E/UtilityOperator: ------map1-----3-----RxNewThreadScheduler-1--
2023-01-08 16:32:27.979 E/UtilityOperator: ------map2-----2-----RxNewThreadScheduler-2--
2023-01-08 16:32:27.979 E/UtilityOperator: ------onNext--------1----main-
2023-01-08 16:32:27.979 E/UtilityOperator: ------map2-----4-----RxNewThreadScheduler-2--
2023-01-08 16:32:27.979 E/UtilityOperator: ------onNext--------2----main-
2023-01-08 16:32:27.979 E/UtilityOperator: ------map2-----6-----RxNewThreadScheduler-2--
2023-01-08 16:32:27.979 E/UtilityOperator: ------onNext--------3----main-
2023-01-08 16:32:27.979 E/UtilityOperator: ------onComplete---------

5.TimeInterval

TimeInterval运算符将源Observable进行转换，为每个发射添加连续发射之间经过的时间量的指示。其中第一次发射的时间量是从观测者订阅Observable到源Observable发射其第一个项目所经过的时间。最后一次发射的时间量是从最后一次发射到调用onCompleted之间的时间间隔。

示例：

Observable.create(object : ObservableOnSubscribe<Int> {
		override fun subscribe(emitter: ObservableEmitter<Int>) {
			for (index in 3..7) {
				try {
					Thread.sleep(1000)
				} catch (e: Exception) {
					e.printStackTrace()
				}
				emitter.onNext(index)
			}
			emitter.onComplete()
		}
	})
		.timeInterval()
		.subscribe(object : Observer<Timed<Int>> {
			override fun onSubscribe(d: Disposable) {
				Log.e(TAG, "---------onSubscribe---------")
			}
			override fun onNext(t: Timed<Int>) {
				Log.e(TAG, "---------onNext--------${t.value()}-------${t.time()}-------")
			}
			override fun onError(e: Throwable) {
				Log.e(TAG, "---------onError---------")
			}
			override fun onComplete() {
				Log.e(TAG, "---------onComplete---------")
			}
		})

输出结果：

2023-01-08 16:39:34.747 E/UtilityOperator: ---------onSubscribe---------
2023-01-08 16:39:35.748 E/UtilityOperator: ---------onNext--------3-------1001-------
2023-01-08 16:39:36.749 E/UtilityOperator: ---------onNext--------4-------1001-------
2023-01-08 16:39:37.750 E/UtilityOperator: ---------onNext--------5-------1001-------
2023-01-08 16:39:38.751 E/UtilityOperator: ---------onNext--------6-------1001-------
2023-01-08 16:39:39.752 E/UtilityOperator: ---------onNext--------7-------1000-------
2023-01-08 16:39:39.752 E/UtilityOperator: ---------onComplete---------

6.Timeout

如果Observable在指定的时间段内未能发出任何项目，则Timeout运算符允许您使用onError终止中止该Observable。

timeout(long,TimeUnit,Observable)

第一个参数：时长

第二个参数：时间单位

第三个参数：备选Observable，当原Observable因超时被终止时，会切换到此备选Observable继续发送事件。

示例：

Observable.create(object : ObservableOnSubscribe<Int> {
		override fun subscribe(emitter: ObservableEmitter<Int>) {
			for (index in 0..5) {
				try {
					Thread.sleep(index * 1000L)
				} catch (e: Exception) {
					e.printStackTrace()
				}
				emitter.onNext(index)
			}
			emitter.onComplete()
		}
	})
		.timeout(2000, TimeUnit.MILLISECONDS, Observable.just(100, 200))
		.subscribe(object : Observer<Int> {
			override fun onSubscribe(d: Disposable) {
				Log.e(TAG, "---------onSubscribe---------")
			}
			override fun onNext(t: Int) {
				Log.e(TAG, "---------onNext--------${t}---------")
			}
			override fun onError(e: Throwable) {
				Log.e(TAG, "---------onError---------")
			}
			override fun onComplete() {
				Log.e(TAG, "---------onComplete---------")
			}
		})

输出结果：

2023-01-08 16:54:18.950 E/UtilityOperator: ---------onSubscribe---------
2023-01-08 16:54:18.951 E/UtilityOperator: ---------onNext--------0---------
2023-01-08 16:54:19.952 E/UtilityOperator: ---------onNext--------1---------
2023-01-08 16:54:21.954 E/UtilityOperator: ---------onNext--------100---------
2023-01-08 16:54:21.954 E/UtilityOperator: ---------onNext--------200---------
2023-01-08 16:54:21.954 E/UtilityOperator: ---------onComplete---------

7.Timestamp

为Observable发出的每个项目附加一个时间戳，指示其发出的时间。

示例：

Observable.just(1, 2, 3)
	.timestamp()
	.subscribe(object : Observer<Timed<Int>> {
		override fun onSubscribe(d: Disposable) {
			Log.e(TAG, "---------onSubscribe---------")
		}
		override fun onNext(t: Timed<Int>) {
			Log.e(TAG, "---------onNext--------${t.value()}------${t.time()}---")
		}
		override fun onError(e: Throwable) {
			Log.e(TAG, "---------onError---------")
		}
		override fun onComplete() {
			Log.e(TAG, "---------onComplete---------")
		}
	})

输出结果：

2023-01-08 17:14:17.353 E/UtilityOperator: ---------onSubscribe---------
2023-01-08 17:14:17.353 E/UtilityOperator: ---------onNext--------1------1673169257353---
2023-01-08 17:14:17.353 E/UtilityOperator: ---------onNext--------2------1673169257353---
2023-01-08 17:14:17.353 E/UtilityOperator: ---------onNext--------3------1673169257353---
2023-01-08 17:14:17.353 E/UtilityOperator: ---------onComplete---------

8.Using

Using操作符将使用observableFactory函数创建Observble，同时Using操作符使用resourceFactory函数创建资源。当观察者取消订阅Observable时，或者当Observable终止时（正常或出现错误），Using操作符将调用disposeFunction来处理它创建的资源。如下图：

示例：

Observable.using(object : Supplier<Int> { //resourceFactory
		override fun get(): Int {
			Log.e(TAG, "---resourceFactory------get()---------")
			return Random().nextInt(100)
		}
	}, object : Function<Int, Observable<String>> { //observableFactory
		override fun apply(t: Int): Observable<String> {
			Log.e(TAG, "--observableFactory-------apply()---------")
			return Observable.just("-apply--$t--")
		}
	}, object : Consumer<Int> { //disposeFunction
		override fun accept(t: Int) {
			Log.e(TAG, "---disposeFunction------accept()---------")
		}
	}).subscribe(object : Observer<String> {
		override fun onSubscribe(d: Disposable) {
			Log.e(TAG, "---------onSubscribe---------")
		}
		override fun onNext(t: String) {
			Log.e(TAG, "---------onNext--------${t}-------")
		}
		override fun onError(e: Throwable) {
			Log.e(TAG, "---------onError---------")
		}
		override fun onComplete() {
			Log.e(TAG, "---------onComplete---------")
		}
	})

输出结果：

2023-01-08 17:49:36.724 E/UtilityOperator: ---resourceFactory------get()---------
2023-01-08 17:49:36.724 E/UtilityOperator: --observableFactory-------apply()---------
2023-01-08 17:49:36.725 E/UtilityOperator: ---------onSubscribe---------
2023-01-08 17:49:36.725 E/UtilityOperator: ---------onNext---------apply--92---------
2023-01-08 17:49:36.725 E/UtilityOperator: ---disposeFunction------accept()---------
2023-01-08 17:49:36.725 E/UtilityOperator: ---------onComplete---------

大脸猫6_6
关注
专栏目录
RxJava 四：RxJava 3 操作符（Operators）
qingjuyashi的博客
05-19 737
操作符（Operators）的实质是函数式编程中的高阶函数，是对响应式编程的各个过程拆分封装后的产物。目的在于灵活操作数据流。
RxJava 操作符篇 - 创建操作符
doris_d的专栏
09-27 277
Create 创建Observable。 Observable.create(new ObservableOnSubscribe<Integer>() { @Override public void subscribe(@NonNull ObservableEmitter<Integer> emitter) throws Throwable { try { for (int i=0; i<10; i++) {
Rxjava3 全新详解及常用操作符
ezconn的博客
10-15 2807
RxJava 是一个基于 Java 的响应式编程库，用于处理异步事件流和数据流。它是由 Netflix 开发并开源，现在广泛用于 Android 和 Java 后端开发。RxJava 提供了一种用于组合和处理异步数据的丰富工具集，它的核心思想是将数据流视为一系列事件，以响应事件的方式进行处理。RxJava 提供了丰富的操作符，用于处理和转换数据流。这些操作符可以帮助你执行各种操作，包括过滤、映射、合并、变换等，以便更好地处理异步数据流。
Rxjava3文档级教程二： 操作符全解
热门推荐
许进进的博客
04-05 1万+
1 前言 1.1 用操作符组合Observable 对于ReactiveX来说，Observable和Observer仅仅是个开始，它们本身不过是标准观察者模式的一些轻量级扩展，目的是为了更好的处理事件序列。 ReactiveX真正强大的地方在于它的操作符，操作符让你可以变换、组合、操纵和处理Observable发射的数据。 Rx的操作符让你可以用声明式的风格组合异步操作序列，它拥有...
RxJava3.x入门(三)——组合操作符
AthonyDavis的博客
07-30 647
RxJava3.x入门指南(三)——组合操作符和过滤操作符 组合操作符 一、合并观察者操作符 1.concat()/concatArray() 作用：组合多个被观察者一起发送数据，合并后 按发送顺序串行执行 两者区别:组合被观察者的数量，即concat（）组合被观察者数量≤4个，而concatArray（）则可＞4个 代码演示： Observable.concat(Observable.just(1,2,3),Observable.just("x","y","z"))
RxJava之辅助操作符
行云间
09-05 4616
Observable的创建源于数据源，如何从Observable转换回数据源呢？观察者订阅后，如何推迟Observable发射数据呢？观察者订阅后，在Observable调用观察者的方法前，做一些其他的事情又该如何做呢？…带着思考的问题，让我们看下辅助操作符带给我们的无限遐想！delay流程图概述delay操作符让原Observable在发射每项数据之前都暂停一段指定的时间段，其效果是Observa
Android RxJava： 这是一份全面的 操作符 使用汇总 （含详细实例讲解）(1)
最新发布
2401_84132298的博客
04-22 752
最后为了帮助大家深刻理解Android相关知识点的原理以及面试相关知识，这里放上相关的我搜集整理的24套。
RxJava2极速入门——Rxjava操作符详解之合并操作符
易庞宙的博客
05-17 1291
RxJava2极速入门——Rxjava操作符详解之合并操作符Rxjava操作符详解合并操作符MergemergemergeWithmerge总结ZipzipzipWithzip总结combineLatestwithLatestFromjoinstartWith总结 Rxjava操作符详解合并操作符 最近公司事务比较繁忙，导致文章更新晚了，尽量保证在6月底的时候更新完RxJava2相关的东西。 好了...
RxJava2 Flowable forEach (辅助操作符)
无问西东的博客
10-07 2315
forEach（辅助操作符） 目录 1forEach作用和使用场景 2forEach接口 3 forEach测试用例 1forEach作用和使用场景 同subscribe类似，订阅Publisher并接其发出的每一个元素的通知，有点遍历的意思。 2forEach接口 Disposable forEach(Consumer<? superT>onN...
一点一点啃RxJava(三#操作符#)
new洪彬的博客
04-25 292
本文将分析RxJava2中常见的操作符。· justjust的作用是将参数依次发射出来，而且有很多的重载方法除了单参数的之外，别的方法都会调用fromArray，这个放到后面说。        just单参数方法返回ObservableJust对象：public final class ObservableJust&lt;T&gt; extends Observable&lt;T&gt; impl...
【从零学 RxJava】RxJava 3 —— 变换操作符、过滤操作符
小水牛的博客
11-23 981
【从零学 RxJava】RxJava 3 —— 变换操作符、过滤操作符前言版本mapdemoflatmapdemogroupBydemobufferdemowindowdemofirst & lastdemotakedemotakeLastdemoskipdemoskipLastdemoelementAtdemoignoreElementsdemodistinctdemodistinctUntilChangeddemofilterdemodebouncedemo总结github参考 前言 操作符是
RxJava操作符
JokAr
08-14 786
Observable – 被观察者（事件源）Observer – 观察者 Create — 通过observer的方法创建一个新的ObservableDefer — 直到observer订阅的时候才会创建这个Observable，并且为每一个observer创建一个ObservableEmpty/Never/Throw — 创建行为受限特殊的Observable Empty 
RxJava笔记3：操作符
ganduwei的博客
06-13 654
RxJava笔记3：操作符
RxJava3 创建型操作符
bigfc的博客
10-11 482
通过具体的示例，每个操作符的使用方法~
RxJava3.x入门(五)——功能操作符
AthonyDavis的博客
07-30 634
RxJava3.x入门指南(五)——功能操作符 一、线程调度操作符 1.subscribeOn() 作用：指定被观察者的线程，如果多次调用此方法，只有第一次有效。 代码演示： Observable.create(new ObservableOnSubscribe<Integer>() { @Override public void subscribe(@NonNull ObservableEmitter<Integer&g
Rxjava的操作符（3）------功能操作符和条件操作符
LY010106的博客
05-12 314
Rxjava的功能操作符和条件操作符Rxjava的功能操作符线程调度1. subscribeOn（）2. observeOn（）延迟操作1. delay（）在事件的生命周期中操作1. do（）错误处理1. onErrorReturn()2. onErrorResumeNext（）/onExceptionResumeNext（）3.retry（）retryUntil（）retryWhen（）重复发生操作1. repeat（）2. repeatWhen（）Rxjava的条件操作符1.all（）takeWhile
RxJava3 过滤型操作符
bigfc的博客
11-19 487
通过具体的示例，学习RxJava3 过滤型操作符的用法~
RxJava3.0 操作符之转换操作符使用
sky丶伤心欲绝的博客
05-14 360
RxJava 转换操作符, map flatmap
RxJava3.x入门(二)——创建操作符和变换操作符
AthonyDavis的博客
07-30 563
RxJava3.x入门指南(二)——创建操作符和变换操作符 创建操作符 一、基础创建 1.create() 使用Create操作符创建一个完整的Observable，可以传递onNext，onError和onCompleted等事件。 代码演示： Observable.create((ObservableOnSubscribe<Integer>) e -> { e.onNext(1); e.onNext(2);
RxJava1中文文档： Observables与操作符解析
RxJava的核心概念是Observable（可观察者）和Observer（观察者），它们之间通过一系列的操作符进行数据流的处理。 1. **Observables（可观察者）** 可观察者是RxJava中的核心组件，它可以发出一系列的数据项或一个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值