RxJava3 转换型操作符

最新推荐文章于 2024-05-09 13:51:21 发布
最新推荐文章于 2024-05-09 13:51:21 发布
阅读量633 收藏
点赞数
分类专栏： # RxJava 文章标签： android rxjava
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/bigfc/article/details/127273309
版权

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

1.Buffer  ⭐️

Buffer操作符将发出项目的Observable转换为发出这些项目的缓冲集合的Observable。也就是根据buffer的大小缓冲发出的项目，达到缓冲大小时再发出项目集合。其中onError事件不会进入缓冲区，原Observable一旦发出onError，那么buffer会立即传递此通知。

示例：

Observable.interval(100, TimeUnit.MILLISECONDS)
    .take(10)
    .buffer(5)
    .subscribe(object : Observer<List<Long>> {
        override fun onSubscribe(d: Disposable) {
            Log.e(TAG, "---------onSubscribe---------")
        }
        override fun onNext(t: List<Long>) {
            Log.e(TAG, "---------onNext--------${t}-")
        }
        override fun onError(e: Throwable) {
            Log.e(TAG, "---------onError---------")
        }
        override fun onComplete() {
            Log.e(TAG, "---------onComplete---------")
        }
    })

输出结果：

2022-10-11 22:42:31.000 E/TransformingOperator: ---------onSubscribe---------
2022-10-11 22:42:31.502 E/TransformingOperator: ---------onNext--------[0, 1, 2, 3, 4]-
2022-10-11 22:42:32.003 E/TransformingOperator: ---------onNext--------[5, 6, 7, 8, 9]-
2022-10-11 22:42:32.003 E/TransformingOperator: ---------onComplete---------

 2.FlatMap  ⭐️

将源Observable发出的每个项目转换为新的Observable，并将新的Observable的发射结果合并结果作为自己的序列发射。其中新生成的Observable发射的项目是可以交错的。如果想要严格按照顺序发射，那么可以使用ConcatMap。

示例：

Observable.interval(100, TimeUnit.MILLISECONDS)
    .take(10)
    .flatMap(object : Function<Long, ObservableSource<String>> {
        override fun apply(t: Long): Observable<String> {
            return Observable.just("flatMap ------${t}")
        }
    })
    .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---------")
        }
    })

输出结果：

2022-10-11 22:48:05.264 E/TransformingOperator: ---------onSubscribe---------
2022-10-11 22:48:05.366 E/TransformingOperator: ---------onNext--------flatMap ------0-
2022-10-11 22:48:05.466 E/TransformingOperator: ---------onNext--------flatMap ------1-
2022-10-11 22:48:05.566 E/TransformingOperator: ---------onNext--------flatMap ------2-
2022-10-11 22:48:05.567 E/TransformingOperator: ---------onComplete---------

3.GroupBy

把原来的一个Observable拆分成多个Observable，并将生成的Observable作为事项进行发送。

每个组的事项各自发送，事项之间存在交错发送。

示例：

Observable.just(1,2,3,4,5,6)
    .groupBy(object : Function<Int, String> {
        override fun apply(t: Int): String {
            return if (t % 2 == 0) {
                "偶数"
            } else {
                "奇数"
            }
        }
    })
    .subscribe(object : Observer<GroupedObservable<String, Int>> {
        override fun onSubscribe(d: Disposable) {
            Log.e(TAG, "----GroupedObservable-----onSubscribe---------")
        }
        override fun onNext(observable:GroupedObservable<String, Int>) {
            Log.e(TAG, "----GroupedObservable-----onNext---------")
            observable.subscribe(object:Observer<Int>{
                override fun onSubscribe(d: Disposable) {
                    Log.d(TAG, "----Observer-----onSubscribe---------")
                }
                override fun onNext(t: Int) {
                    Log.d(TAG, " ----Observer-----onNext---------组：" + observable.getKey() + "  值：" + t);
                }
                override fun onError(e: Throwable) {
                    Log.d(TAG, "----Observer-----onError---------")
                }
                override fun onComplete() {
                    Log.d(TAG, "----Observer-----onComplete---------")
                }
            })
        }
        override fun onError(e: Throwable) {
            Log.e(TAG, "----GroupedObservable-----onError---------")
        }
        override fun onComplete() {
            Log.e(TAG, "----GroupedObservable-----onComplete---------")
        }
    })

输出结果：

E/TransformingOperator: ----GroupedObservable-----onSubscribe---------
E/TransformingOperator: ----GroupedObservable-----onNext---------
D/TransformingOperator: ----Observer-----onSubscribe---------
D/TransformingOperator:  ----Observer-----onNext---------组：奇数  值：1
E/TransformingOperator: ----GroupedObservable-----onNext---------
D/TransformingOperator: ----Observer-----onSubscribe---------
D/TransformingOperator:  ----Observer-----onNext---------组：偶数  值：2
D/TransformingOperator:  ----Observer-----onNext---------组：奇数  值：3
D/TransformingOperator:  ----Observer-----onNext---------组：偶数  值：4
D/TransformingOperator:  ----Observer-----onNext---------组：奇数  值：5
D/TransformingOperator:  ----Observer-----onNext---------组：偶数  值：6
D/TransformingOperator: ----Observer-----onComplete---------
D/TransformingOperator: ----Observer-----onComplete---------
E/TransformingOperator: ----GroupedObservable-----onComplete---------

4. Map ⭐️

对源Observable发出的每个项进行转换操作后，再发出。

示例：

Observable.range(1,5)
    .map(object:Function<Int,String>{
        override fun apply(t: Int): String {
            return "-- map >> -------${t}-----------"
        }
    })
    .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---------")
        }
    })

输出结果：

E/TransformingOperator: ---------onSubscribe---------
E/TransformingOperator: ---------onNext---------- map >> -------1------------
E/TransformingOperator: ---------onNext---------- map >> -------2------------
E/TransformingOperator: ---------onNext---------- map >> -------3------------
E/TransformingOperator: ---------onNext---------- map >> -------4------------
E/TransformingOperator: ---------onNext---------- map >> -------5------------
E/TransformingOperator: ---------onComplete---------

 5.Scan

将当前的事项和前一次结果进行运算后的新结果作为事项发出，有时称scan运算符为“累加器”。

示例：

Observable.range(1,5)
    .scan(object:BiFunction<Int,Int,Int>{
        // t1 上次的结果，t2 本次的值，返回t1和t2的运算结果
        override fun apply(t1: Int, t2: Int): Int {
            Log.e(TAG, "---------apply--------${t1}----${t2}----")
            return t1+t2
        }
    })
    .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---------")
        }
    })

输出结果：

E/TransformingOperator: ---------onSubscribe---------
E/TransformingOperator: ---------onNext--------1-
E/TransformingOperator: ---------apply--------1----2----
E/TransformingOperator: ---------onNext--------3-
E/TransformingOperator: ---------apply--------3----3----
E/TransformingOperator: ---------onNext--------6-
E/TransformingOperator: ---------apply--------6----4----
E/TransformingOperator: ---------onNext--------10-
E/TransformingOperator: ---------apply--------10----5----
E/TransformingOperator: ---------onNext--------15-
E/TransformingOperator: ---------onComplete---------

6.Window

Window类似于Buffer，但它不是从源Observable发出项目数据包，而是发出Observables，每个Observable都从源Observable发送一个子集项目，然后以onCompleted通知终止。

前一个窗口关闭后，新的窗口才会打开，也就是子集项目不会交错。

 

示例：

Observable.range(1,6)
    .window(3)
    .subscribe(object : Observer<Observable<Int>> {
        override fun onSubscribe(d: Disposable) {
            Log.e(TAG, "---window-----onSubscribe---------")
        }
        override fun onNext(observable: Observable<Int>) {
            Log.e(TAG, "---window-----onNext--------")
            observable.subscribe(object:Observer<Int>{
                override fun onSubscribe(d: Disposable) {
                    Log.d(TAG, "----Observer-----onSubscribe---------")
                }
                override fun onNext(t: Int) {
                    Log.d(TAG, " ----Observer-----onNext--------$t-");
                }
                override fun onError(e: Throwable) {
                    Log.d(TAG, "----Observer-----onError---------")
                }
                override fun onComplete() {
                    Log.d(TAG, "----Observer-----onComplete---------")
                }
            })
        }
        override fun onError(e: Throwable) {
            Log.e(TAG, "---window------onError---------")
        }
        override fun onComplete() {
            Log.e(TAG, "---window------onComplete---------")
        }
    })

输出结果：

E/TransformingOperator: ---window------onSubscribe---------
E/TransformingOperator: ---window------onNext--------
D/TransformingOperator: ----Observer-----onSubscribe---------
D/TransformingOperator:  ----Observer-----onNext--------1-
D/TransformingOperator:  ----Observer-----onNext--------2-
D/TransformingOperator:  ----Observer-----onNext--------3-
D/TransformingOperator: ----Observer-----onComplete---------
E/TransformingOperator: ---window------onNext--------
D/TransformingOperator: ----Observer-----onSubscribe---------
D/TransformingOperator:  ----Observer-----onNext--------4-
D/TransformingOperator:  ----Observer-----onNext--------5-
D/TransformingOperator:  ----Observer-----onNext--------6-
D/TransformingOperator: ----Observer-----onComplete---------
E/TransformingOperator: ---window------onComplete---------

大脸猫6_6
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Android代码-RxJava3 预览版 Demo
08-06
RxJava3-preview Discontinued. Version 3 development will be branched off of 2.x sometime after 2.2 has been finalized in the main RxJava repository. Preview for version 3 of RxJava, the modern ReactiveX style library for composing (a)synchronous sequences of data and events. Dependency // shared components compile "com.github.akarnokd:rxjava3-common:0.2.0" // Flowable only compile "com.github.akarnokd:rxjava3-flowable:0.2.0" // Observable, Single, Maybe, Completable compile "com.github.ak
RxJava 操作符 图片
03-31
在这个主题中，我们将深入探讨 RxJava 中的操作符，这些操作符是 RxJava 的核心组成部分，它们提供了丰富的功能来创建、转换、过滤和组合数据流。 首先，我们来了解一下什么是操作符。在 RxJava 中，操作符是用于...
RxJava操作符(三)
测试
07-20 144
doOnNext操作符 这个操作符就是让观察者在接受事件之前干一点是,doOnNext()也接受一个consumer的接口 public class RxJavaDemo { public static void main(String[] args) { Observable<String> myObservableF = Observab...
Android最全RxJava-2-0还没熟悉，RxJava-3-0说来就来了！（基础篇），2024年最新四轮面试
最新发布
2301_82244125的博客
05-09 842
代码真的是重质不重量，质量高的代码，是当前代码界提倡的，当然写出高质量的代码肯定需要一个相当高的专业素养，这需要在日常的代码书写中逐渐去吸收掌握，谁不是每天都在学习呀，目的还不是为了一个，为实现某个功能写出高质量的代码。所以，长征路还长，大家还是好好地做个务实的程序员吧。最后，小编这里有一系列Android提升学习资料，有兴趣的小伙伴们可以来看下哦~网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。需要这份系统化学习资料的朋友，可以戳这里获取。
Rxjava 3
qq_34498620的博客
05-09 177
一、debounce debounce操作符就是起到了限流的作用，可以理解为阀门，当你半开阀门的时候，水会以较慢的速度流出来。不同之处就是阀门里的水不会浪费掉，而debounce过滤掉的数据会被丢弃掉。在Rxjava中，将这个操作符氛围了throttleWithTimeout和debounce两个操作符。先来看一下throttleWithTimeOut吧，如下图所示，这个操作符通过时间来
RxJava 3.x
LZW_00007的博客
04-11 163
3.ReplaySubject不管Observer何时订阅ReplaySubject，ReplaySubject均会发射所有来自原始Observable的数据给Observer。Subject 既可以是一个 Observer 也可以是一个Observerable，它是连接 Observer 和Observerable的桥梁。RxJava的异步操作是通过扩展的观察者模式来实现的，RxJava有4个角色Observable、Observer、Subscriber、Suject。•onNext：普通的事件。
关于rxjava（三）
cygjay123的博客
05-29 200
首先抛出一个问题：如果是一个新用户, 必须先注册, 等注册成功之后再自动登录该怎么做呢.当然可以想当然的写成private void login() { api.login(new LoginRequest()) .subscribeOn(Schedulers.io()) //在IO线程进行网络请求 ...
Android + Rxjava + Rxjava操作符
04-23
Rxjava源码剖析 1：Rxjava创建操作符：...2: 转换操作符：（map() , flatMap() ） 3: 合并操作符：（merge() , collect()） 4: 功能操作符：（delay() , subscribeOn() ，observerOn()） 5：过滤操作符：（filter() ）
RxJava操作符
07-01
2. **转换操作符** - `map()`: 对Observable发射的每个项应用一个函数，然后发射结果。 - `flatMap()`: 将一个Observable的每一项转换为另一个Observable，然后合并这些Observables的结果。 - `concatMap()`: ...
Rxjava功能操作符的使用方法详解
08-28
Rxjava功能操作符的使用方法详解 Rxjava是一个非常强大的Reactive Extensions库，提供了多种功能操作符来处理异步数据。下面我们将逐一介绍Rxjava功能操作符的使用方法详解。 一、Rxjava的基本概念 在Rxjava中，...
Java的RxJava库操作符的用法及实例讲解
09-02
RxJava的核心是Observable（可观测序列）和Subscriber（订阅者），它们之间的交互通过一系列的操作符来实现。操作符是RxJava的核心特性，它们允许对Observable发出的数据进行各种变换和过滤。 首先，让我们深入了解...
RxJava 3 Android示例-从RxJava 2迁移到RxJava 3-如何在Android中使用RxJava 3-Android开发
05-26
RxJava3-Android-示例-通过示例学习Android的RxJava3参加MindOrks Android在线课程并学习RxJava该项目适用于：谁将从j的RxJava 2迁移到RxJava3。RxJava3-Android-示例-通过示例学习Android的RxJava3参加MindOrks Android在线课程并学习RxJava该项目适用于：谁将从RxJava 2迁移到RxJava 3，谁刚刚开始使用RxJava。只需构建该项目并通过示例开始学习RxJava 3。 本示例项目Map中的RxJava 3 Operators示例Map->通过对每个项目应用函数来转换Observable发射的项目Zip->合并多个Ob的发射
Android 函数响应式编程（RxJava3）
csdn1225987336的专栏
01-18 605
文章目录一、RxJava 基本用法1.1、RxJava3 基本使用 一、RxJava 基本用法 说到异步操作，我们会想到 Android 的 AsyncTask 和 Handler。但是随着请求的数量越来越多，代码逻辑将会变得越来越复杂，而 RxJava 却能保持清晰的逻辑。RxJava 的原理就是创建一个 Observable 对象来干活，然后使用各种操作符建立起来的链式操作，就如同流水线一样，把想要处理的数据一步步加工成成品，再发射给 Subscriber 处理。 RxJava 的异步操作时通过扩展的观
Android RxJava3入门
舒小羽的博客
08-06 3664
RxJava3简介一些概念观察者模式背压最基础的使用配置创建被观察者Observable创建观察者Observer订阅Subscribe运行结果基于事件流的链式调用（简洁使用）全部代码 简介 RxJava3是Android的一个响应式编程框架。 Android的异步操作是用AsyncTask和Handler，但是当请求多了以后，代码的逻辑将会变得十分的复杂，这时候使用RxJava就可以让整个代码的逻辑变得清晰。 RxJava是基于事件流的链式调用，将链式编程风格和异步结合在一起。RxJava的原理其实就是：
RxJava3 知识点
不再烦恼
09-14 263
Rxjava的一些知识点
【RxJava】RxJava3核心功能讲解和源码分析
天天向上 Up Up Up (*^▽^*)
02-27 1146
一个是Observable的订阅顺序，一个是doOnSubscribe的执行顺序，Observable的订阅顺序上面已经得出结论了，是从后往前执行的。当没有指定ObserveOn，但是指定了SubscribeOn时，由于onNext代码是从最上游的Observable.subscribeActual开始的，所以所有的onNext都会在最近一个SubscribeOn指定的线程中执行。reduce：将上游Observable的相邻两个数据进行运算，再拿结果与下一个数据进行运算，如此循环，得到一个最终值。
【从零学 RxJava】RxJava 3 —— 变换操作符、过滤操作符
小水牛的博客
11-23 358
【从零学 RxJava】RxJava 3 —— 变换操作符、过滤操作符前言版本mapdemoflatmapdemogroupBydemobufferdemowindowdemofirst & lastdemotakedemotakeLastdemoskipdemoskipLastdemoelementAtdemoignoreElementsdemodistinctdemodistinctUntilChangeddemofilterdemodebouncedemo总结github参考 前言 操作符是
Android实战派-RxJava3.x(一) 入门
KyungLip的博客
09-05 8388
以实战立足，坚信实践出真知，唯有理论结合实践才能真正理解并掌握所学的知识。 Rxjava:https://github.com/ReactiveX/RxJava Reativex:https://github.com/ReactiveX 官网:http://reactivex.io/ Table of Contents 一.内容 二.简单集成 1.开发环境 2.添加依赖 ...
Rxjava3文档级教程一： 介绍和基本使用
热门推荐
许进进的博客
04-05 4万+
一 Rxjava3简介 RxJava是响应式编程(Reactive Extensions)的java实现，它基于观察者模式的实现了异步编程接口。 Rxjava 3.x 的github官网 RxJava2将被支持到2021年2月28日，错误的会同时在2.x和3.x修复，但新功能只会在3.x上添加。 Rxjava 3.0的一些改变：官方Wiki Rxjava 3.x 文档可以在官方javad...
rxjava2的flatMap操作符为什么不能保证数据顺序
06-08
RxJava2中的flatMap操作符在处理数据时，会将每个数据项转换成一个Observable，然后将这些Observable发射的数据进行合并，并发射出去。由于flatMap操作符是异步的，因此在处理数据时，无法保证数据的顺序。 具体来说，当flatMap操作符接收到一个数据项时，它会立即将其转换成一个Observable，并将这个Observable添加到一个内部的Observable队列中。然后，它会订阅这个Observable，并将它发射的数据添加到最终的Observable队列中。当这个Observable发射完数据后，flatMap操作符会将其从队列中移除，并继续处理下一个数据项。 由于flatMap操作符是异步的，因此在处理数据时，不同的数据项可能会被不同的线程处理。这样就可能导致数据的顺序被打乱。例如，如果一个数据项的处理需要耗费很长时间，而另一个数据项的处理很快，那么这两个数据项的顺序就可能被颠倒。 因此，如果需要保证数据的顺序，可以使用RxJava2中的concatMap操作符，它和flatMap操作符类似，但是可以保证数据的顺序。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值