RxJava基础知识

已于 2022-08-26 09:25:50 修改
阅读量779 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： Rxjava 系列 文章标签： rxjava android
于 2022-08-13 21:54:45 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/libocellon/article/details/126324098

RxJava基础知识

一、引入依赖

    implementation 'io.reactivex.rxjava2:rxandroid:2.1.1'
    implementation 'io.reactivex.rxjava2:rxjava:2.2.7'

二、转换操作符

2.1 create

 private void testCrate() {
        Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(@NonNull ObservableEmitter<String> emitter) throws Exception {
                emitter.onNext("first");
                emitter.onComplete();
            }
        }).subscribe(new Observer<String>() {
            @Override
            public void onSubscribe(@NonNull Disposable d) {
                Log.d(TAG,"onSubscribe " + d);
            }

            @Override
            public void onNext(@NonNull String o) {
                Log.d(TAG,"onSubscribe " + o);
            }

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

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

输出结果

2022-08-13 20:41:05.253 12124-12124/com.yhcode.rxjava D/MainActivity: onSubscribe CreateEmitter{null}
2022-08-13 20:41:05.255 12124-12124/com.yhcode.rxjava D/MainActivity: onSubscribe first
2022-08-13 20:41:05.255 12124-12124/com.yhcode.rxjava D/MainActivity: onComplete

2.2 just

just 1-10个参数，内部调用的是fromArray方法

private void testJust() {
        Observable.just("first","second","third").subscribe(new Observer<String>() {
            @Override
            public void onSubscribe(@NonNull Disposable d) {
                Log.d(TAG,"onSubscribe");
            }

            @Override
            public void onNext(@NonNull String s) {
                Log.d(TAG,"onNext:" + s);
            }

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

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

输出结果

2022-08-13 20:56:48.905 12737-12737/com.yhcode.rxjava D/MainActivity: onSubscribe
2022-08-13 20:56:48.905 12737-12737/com.yhcode.rxjava D/MainActivity: onNext:first
2022-08-13 20:56:48.905 12737-12737/com.yhcode.rxjava D/MainActivity: onNext:second
2022-08-13 20:56:48.909 12737-12737/com.yhcode.rxjava D/MainActivity: onNext:third
2022-08-13 20:56:48.909 12737-12737/com.yhcode.rxjava D/MainActivity: onComplete

2.3 fromArray

和just的区别是，just内部调用的是fromArray,并且最多只能10个参数，而fromArray参数没有限制

 private void testFromArray() {
        Observable.fromArray("one","two","three","four").subscribe(new Observer<String>() {
            @Override
            public void onSubscribe(@NonNull Disposable d) {
                Log.d(TAG,"onSubscribe");
            }

            @Override
            public void onNext(@NonNull String s) {
                Log.d(TAG,"onNext " + s);
            }

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

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

输出结果

2022-08-13 21:09:33.794 13144-13144/com.yhcode.rxjava D/MainActivity: onSubscribe
2022-08-13 21:09:33.794 13144-13144/com.yhcode.rxjava D/MainActivity: onNext one
2022-08-13 21:09:33.795 13144-13144/com.yhcode.rxjava D/MainActivity: onNext two
2022-08-13 21:09:33.795 13144-13144/com.yhcode.rxjava D/MainActivity: onNext three
2022-08-13 21:09:33.802 13144-13144/com.yhcode.rxjava D/MainActivity: onNext four
2022-08-13 21:09:33.802 13144-13144/com.yhcode.rxjava D/MainActivity: onComplete

2.4 fromIterable

参数可以接收为实现了Iterable接口的对象

 private void testFromIterable() {
        List<String> list = new ArrayList<>();
        list.add("one");
        list.add("two");
        Observable.fromIterable(list).subscribe(new Consumer<String>() {
            @Override
            public void accept(String s) throws Exception {
                Log.d(TAG,"accept" + s);
            }
        });

输出结果

2022-08-13 21:17:52.470 13383-13383/com.yhcode.rxjava D/MainActivity: acceptone
2022-08-13 21:17:52.470 13383-13383/com.yhcode.rxjava D/MainActivity: accepttwo

2.5 fromFuture

private void testFromFuture() {
        Observable.fromFuture(new Future<String>() {
            @Override
            public boolean cancel(boolean mayInterruptIfRunning) {
                return false;
            }

            @Override
            public boolean isCancelled() {
                return false;
            }

            @Override
            public boolean isDone() {
                return false;
            }

            @Override
            public String get() throws ExecutionException, InterruptedException {
                return "from future result";
            }

            @Override
            public String get(long timeout, TimeUnit unit) throws ExecutionException, InterruptedException, TimeoutException {
                return null;
            }
        }).subscribe(new Consumer<String>() {
            @Override
            public void accept(String s) throws Exception {
                Log.d(TAG,"accept:" + s);
            }
        });

输出结果

2022-08-13 21:21:24.496 13560-13560/com.yhcode.rxjava D/MainActivity: accept:from future result

2.6 fromCallable

private void testFromCallback() {
        Observable.fromCallable(new Callable<String>() {
            @Override
            public String call() throws Exception {
                return "Callable";
            }
        }).subscribe(new Consumer<String>() {
            @Override
            public void accept(String s) throws Exception {
                Log.d(TAG,"accept " + s);
            }
        });
    }

输出结果

2022-08-13 21:24:43.179 13681-13681/com.yhcode.rxjava D/MainActivity: accept Callable

2.7 map

map 对事件进行处理

 private void testMap() {
        //把aaa字符串转为大写
        Observable.just("aaa").map(new Function<String, String>() {
            @Override
            public String apply(@NonNull String s) throws Exception {
                return s.toUpperCase();
            }
        }).subscribe(new Consumer<String>() {
            @Override
            public void accept(String s) throws Exception {
                Log.d(TAG,"aaa upper letter :" + s);
            }
        });
    }

输出结果

2022-08-13 21:35:29.839 13952-13952/com.yhcode.rxjava D/MainActivity: aaa upper letter :AAA

2.8 flatMap

flatMap会产生新的被观察者，模拟实现先注册账号，然后登录账号流程

private void testFlatMap() {
        Observable.just("user register for accont libo").flatMap(new Function<String, ObservableSource<?>>() {
            @Override
            public ObservableSource<?> apply(@NonNull String s) throws Exception {
                return Observable.just(s + "begin login");
            }
        }).subscribe(new Consumer<Object>() {
            @Override
            public void accept(Object o) throws Exception {
                Log.d(TAG,"login result:" + o);
            }
        });
    }

输出结果

2022-08-13 21:49:41.780 14359-14359/com.yhcode.rxjava D/MainActivity: login result:user register accountbegin login

2.9 Buffer

把事件按照传入buffer的数量为一组一起发送

 Observable.just("li1","li2","li3","zhang1","zhang2","zhang3","wang1").buffer(3).subscribe(new Consumer<List<String>>() {
            @Override
            public void accept(List<String> strings) throws Exception {
                Log.d(TAG,"result:" + strings);
            }
        });

输出结果

2022-08-26 08:49:03.639 13941-13941/com.yhcode.rxjava D/MainActivity: result:[li1, li2, li3]
2022-08-26 08:49:03.639 13941-13941/com.yhcode.rxjava D/MainActivity: result:[zhang1, zhang2, zhang3]
2022-08-26 08:49:03.639 13941-13941/com.yhcode.rxjava D/MainActivity: result:[wang1]

未完待续，持续更新

三、组合操作符

3.1 contact

contact 操作符将多个观察者组合在一起然后顺序发送，最多可以支持4个，如果需要支持超过4个，可以使用contactArray

 Observable.concat(Observable.just("one"),Observable.just("two"))
                .subscribe(new Consumer<String>() {
            @Override
            public void accept(String s) throws Exception {
                Log.d(TAG,"result:" + s);
            }
        });

输出结果

2022-08-26 09:00:39.715 14158-14158/com.yhcode.rxjava D/MainActivity: result:one
2022-08-26 09:00:39.716 14158-14158/com.yhcode.rxjava D/MainActivity: result:two

3.2 contactArray操作符

与contact操作符功能一样，差异是可以传入超过4个参数

        Observable.concatArray(Observable.just("A"),Observable.just("B"),Observable.just("C"),Observable.just("D"),Observable.just("E"),Observable.just("F"))
                .subscribe(new Consumer<String>() {
                    @Override
                    public void accept(String s) throws Exception {
                        Log.d(TAG,s);
                    }
                });

输出结果

2022-08-26 09:00:39.718 14158-14158/com.yhcode.rxjava D/MainActivity: A
2022-08-26 09:00:39.718 14158-14158/com.yhcode.rxjava D/MainActivity: B
2022-08-26 09:00:39.718 14158-14158/com.yhcode.rxjava D/MainActivity: C
2022-08-26 09:00:39.718 14158-14158/com.yhcode.rxjava D/MainActivity: D
2022-08-26 09:00:39.718 14158-14158/com.yhcode.rxjava D/MainActivity: E
2022-08-26 09:00:39.718 14158-14158/com.yhcode.rxjava D/MainActivity: F

3.3 merge

merge操作符与contact 类似都是将多个观察者组合在一起发送，区别是contact（contactArray）是串行发送，merge是并行发送

Observable observableOne = Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(@NonNull ObservableEmitter<String> emitter) throws Exception {
                Thread.sleep(2000);
                emitter.onNext("First Emitter");
                emitter.onComplete();
            }
        });

        Observable observableTwo = Observable.just("Second Emitter");

        Observable observableThree = Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(@NonNull ObservableEmitter<String> emitter) throws Exception {
                Thread.sleep(5000);
                emitter.onNext("Three Emitter");
                emitter.onComplete();
            }
        });

        Observable.merge(observableOne,observableTwo,observableThree).subscribe(new Consumer() {
            @Override
            public void accept(Object o) throws Exception {
                Log.d(TAG,"result:" + o);
            }
        });

输出结果

2022-08-26 09:13:16.974 14297-14297/com.yhcode.rxjava D/MainActivity: result:First Emitter
2022-08-26 09:13:16.974 14297-14297/com.yhcode.rxjava D/MainActivity: result:Second Emitter
2022-08-26 09:13:21.975 14297-14297/com.yhcode.rxjava D/MainActivity: result:Three Emitter

源码下载

RxJava

RxJava2极速入门——Rxjava理念与基础知识
易庞宙的博客
03-16 1642
目录 RxJava入门理念 函数响应式编程的概念及特点 函数编程概念 函数编程特性 响应式编程概念 响应式编程的特性 RxJava的基础知识 RxJava的创建 RxJava的生命周期回调 RxJava的五种观察者模式 Observable与Observer Flowable Single与SingleObserver Completable Maybe 总结心得 ...
RxJava3.0.0 操作符篇 - 过滤操作符
yangjunjin的博客
02-28 281
Debounce 仅在过了一段指定的时间还没发射数据时才发射一个数据，会过滤掉发射速率过快的数据项。 debounce 默认在 computation 调度器上执行，也可指定调度器。 Observable.range(1, 10) .flatMap((Function<Integer, ObservableSource<Integer>>) integer -> { int delay = new Random().nextInt(...
RxJava2.0功能性操作符（五）
csclmf的博客
02-07 491
1、subscribe() 作用：订阅，连接被观察者和观察者 //创建观察者 Observable observable=Observable.create(new ObservableOnSubscribe() { @Override public void subscribe(@NonNull ObservableEmit
盘点常用的Android开发库（4 ) -- Rxjava2的基本使用
ledding的博客
02-25 1160
一、简介 二、使用 三、分析 四、参考链接
RXJava的简单使用
weixin_58124208的博客
08-19 761
RXJava
Java中ReactiveX（RxJava）的使用
晨曦的博客
04-30 4125
1.1 ReactiveX概述 ReactiveX官网：ReactiveX 1.1.1 Android的MVP开发模式 MVP的工作流程 Presenter负责逻辑的处理 Model提供数据 View负责显示 作为一种新的模式，在MVP中View并不直接使用Model，它们之间的通信是通过Presenter来进行的，所有的交互都发生在Presenter内部，而在MVC中View会从直接Model中读取数据而不是通过 Controller。 1.1.2 ReactiveX简介 RX.
RxJava基础实践：JUnit测试挑战精讲
知识点一：RxJava基础 - RxJava是一种响应式编程库，用于Java和JVM语言，它通过使用可观察序列来处理异步和基于事件的程序。RxJava将异步操作抽象成Observable和Observer模式。 - 在RxJava中，Observable是核心概念...
探索Java reactive编程：RxJava基础入门
书中不仅涵盖了理论知识，还提供了丰富的实例，有助于读者理解和运用RxJava处理复杂的数据流，提升应用程序的可读性和可维护性。无论是初学者还是经验丰富的开发者，都能从中收获到宝贵的经验和见解。
RxJava基础演示与实例解析
创建Observable是RxJava编程的基础。有多种方法可以创建Observable，如使用just()、from()、create()、range()等方法。just()方法可以创建一个发出特定序列（如单个对象或一系列对象）的Observable，而create()方法...
探索RxJava基础：从.NET到Java的世界
第1章，"从.NET到RxJava：RX基础"，介绍了微软的Reactive Extensions（Rx.NET），并着重讨论了它如何迁移到Java平台。该章节会对比RxJava与其他语言版本的不同之处，如异步编程模型、流处理的优势和简洁性。通过这个...
rxjava2系列：android网络请求的线程切换实例
知道这个有什么用？
03-27 274
借用这篇Okhttp系列：简单的Get请求示例的网络请求实例。 最终效果： Okhttp导入需要配置java8，网络权限，具体参考：Okhttp系列：简单的Get请求示例 rxjava2导入： implementation 'io.reactivex.rxjava2:rxandroid:2.1.1' implementation 'io.reactivex.rxjava2:rxjava:2.2.8' 要达到上图的效果，必须用Console字体，我的坚果云网盘上有，也可以下载：下载链接 完整代码.
rxJava源码解析系列二之observer订阅
dxyadc的博客
10-01 1031
接着上一篇的demo继续写下去。没看过的朋友请点击 rxJava和rxAndroid源码解析系列一之链式调用Observable嵌套 创建完Observable对象后，以后一步ObservableObserveOn.subscribe(new Observer&lt;String&gt;() {.....})这一步又发生了什么呢? 接着跟踪源码。 @SchedulerSupport(Sc...
kotlin java版本_Rxjava2基本用法（一），kotlin及Java版本对照
weixin_42525328的博客
02-19 651
今天写一写Rxjava2的基本使用，Rxjava2虽然使用广泛，但已经不算是什么新框架了，从16年大火到现在已经好几年了。网上也有很多例子，总体来讲就像是官方文档的翻译，再具体项目中的实际案例很少，本系列将从浅入深逐步讲解，希望都有所收获。本篇文章主要写Rxjava2最基本的使用，并且会有Kotlin与java两个版本的对照。Rxjava，RxAndroid使用写作时的最新版本implementa...
发布者订阅者模式
bailaoshi666的博客
12-01 2908
文章来源于字母哥。 https://my.oschina.net/zimug/blog/4677315 Java 9的 Reactive Streams是对异步流式编程的一种实现。它基于异步发布和订阅模型，具有非阻塞“背压”数据处理的特点。 下面是Java 响应式编程中的一些重要角色和概念，先简单理解一下 发布者（Publisher）是潜在的无限数量的有序数据元素的生产者。 它根据收到的需求(subscription)向当前订阅者发布一定数量的数据元素。 订阅者（Subscriber）从.
redis 的发布订阅
dongxiexiaoadou的博客
06-16 265
Redis 发布订阅 (pub/sub) 是一种消息通信模式：发送者 (pub) 发送消息，订阅者 (sub) 接收消息。 Redis 客户端可以订阅任意数量的频道。 下图展示了频道 channel1 ， 以及订阅这个频道的三个客户端 —— client2 、 client5 和 client1 之间的关系： ...
关于RxJava2.0你不知道的事
热门推荐
Dream It Possible
02-03 3万+
前言如果你对RxJava1.x还不是了解，可以参考下面文章。1. RxJava使用介绍 【视频教程】 2. RxJava操作符   • Creating Observables(Observable的创建操作符) 【视频教程】   • Transforming Observables(Observable的转换操作符) 【视频教程】   • Filtering Observa
Android studio——RxJava导入依赖失败
S_jGgod的博客
06-05 2448
这个时候才接触RxJava的我，在导入依赖的时候，随便网上一搜就有很多怎么添加Gradle配置的 但是但是，我导入过后同步失败，对于新入门的小白来说，这真的令人头大 换来换去，导了好几种版本的依赖都不行 直到我，新建一个项目接着导，看到了Androidstudio的提示说compile在2018年就已经全部被implementation替换掉了 我立马把compi...
RxJava2从入门到精通-源码分析篇
11-19
适合所有初中级工程师，从RxJava的每个知识点进行讲解，并在每个知识点中都带有文字说明和代码例子说明。通过这次系统化的学习，您将可以完整的学习到RxJava家族的所有特性和常用的操作符，掌握操作符的使用，掌握RxJava与Rx其他第三方库的使用。可以用三句简单的话进行概括面试加分利器 = 加大录取机会加快工作效率 = 早点下班回家系统化的学习 = 能力全面提升
android rxjava工具类,RxJava(十三)：RxAndroid 2.x 和 Retrofit 的使用
weixin_32392583的博客
05-28 549
1. RxAndroid 2.x 简介1.1 介绍近几年 RxJava 逐渐成为 Android 开发的新宠，越来越多的 Android 开发者正在使用或者即将使用 RxJava 。要想在 Android 上使用 RxJava, RxAndroid 必不可少.RxAndroid GitHub 地址https://github.com/ReactiveX/RxAndroidRxAndroid 也隶属...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值