RX操作符之辅助操作一（materialize、dematerialize、timestamp、serialize、replay、observeOn、subscribeon、dooneach）

最新推荐文章于 2021-02-14 21:09:33 发布
最新推荐文章于 2021-02-14 21:09:33 发布
阅读量2.6k 收藏
点赞数
分类专栏： RX
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/nicolelili1/article/details/52154389
版权

一、materialize

Materialize将数据项和事件通知都当做数据项发射，Dematerialize刚好相反。一个合法的有限的Obversable将调用它的观察者的onNext方法零次或多次，然后调用观察者的onCompleted或onError正好一次。Materialize操作符将这一系列调用，包括原来的onNext通知和终止通知onCompleted或onError都转换为一个Observable发射的数据序列。materialize将来自原始Observable的通知转换为Notification对象，然后它返回的Observable会发射这些数据。

 Observable<String> observable =  Observable.create(new Observable.OnSubscribe<String>() {

            @Override
            public void call(Subscriber<? super String> subscriber) {
                for (int i = 0; i < 5; i++) {
                        subscriber.onNext(i + "");
                    try {
                        Thread.sleep(1000);
                    } catch (Exception e) {

                    }
                }
                subscriber.onCompleted();
            }
        });


        Subscriber<Object> subscriber = new Subscriber<Object>() {

            @Override
            public void onNext(Object v) {
                Log.e(TAG,"onNext................."+v);
            }

            @Override
            public void onCompleted() {
                Log.e(TAG, "onCompleted.................");
            }

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

        observable.materialize().subscribe(subscriber);

运行结果：



二、dematerialize

Dematerialize操作符是Materialize的逆向过程，它将Materialize转换的结果还原成它原本的形式。

ematerialize反转这个过程，将原始Observable发射的Notification对象还原成Observable的通知。

 Observable<String> observable =  Observable.create(new Observable.OnSubscribe<String>() {

            @Override
            public void call(Subscriber<? super String> subscriber) {
                for (int i = 0; i < 5; i++) {
                    subscriber.onNext(i + "");
                    try {
                        Thread.sleep(1000);
                    } catch (Exception e) {

                    }
                }
                subscriber.onCompleted();
            }
        });


        Subscriber<Object> subscriber = new Subscriber<Object>() {

            @Override
            public void onNext(Object v) {
                Log.e(TAG,"onNext................."+v);
            }

            @Override
            public void onCompleted() {
                Log.e(TAG, "onCompleted.................");
            }

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

        observable.materialize().dematerialize().subscribe(subscriber);


运行结果：



三、timeStamp

timestamp发射T类型数据的Observable转换为一个发射类型为Timestamped<T>的数据的Observable，每一项都包含数据的原始发射时间。

String[] items = {"timeStamp1","timeStamp2","timeStamp3","timeStamp4","timeStamp5"};
        Observable<String> observable =  Observable.from(items);
        Subscriber<Object> subscriber = new Subscriber<Object>() {

            @Override
            public void onNext(Object v) {
                Log.e(TAG,"onNext................."+v);
            }

            @Override
            public void onCompleted() {
                Log.e(TAG, "onCompleted.................");
            }

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

        observable.timestamp().subscribe(subscriber);
运行结果：



四、serialize

一个Observable可以异步调用它的观察者的方法，可能是从不同的线程调用。这可能会让Observable行为不正确，它可能会在某一个onNext调用之前尝试调用onCompleted或onError方法，或者从两个不同的线程同时调用onNext方法。使用Serialize操作符，你可以纠正这个Observable的行为，保证它的行为是正确的且是同步的。

 Observable<Integer> observable =  Observable.create(new Observable.OnSubscribe<Integer>() {

            @Override
            public void call(Subscriber<? super Integer> subscriber) {
                    subscriber.onNext(1);
                    subscriber.onNext(2);
                    subscriber.onNext(3);
                    subscriber.onCompleted();
                    subscriber.onNext(4);
                    subscriber.onNext(5);
                    subscriber.onCompleted();
            }
        });

        Subscriber<Integer> subscriber = new Subscriber<Integer>() {

            @Override
            public void onNext(Integer v) {
                Log.e(TAG,"onNext................."+v);
            }

            @Override
            public void onCompleted() {
                Log.e(TAG, "onCompleted.................");
            }

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

        observable
                .doOnUnsubscribe(new Action0() {
                    @Override
                    public void call() {
                        Log.e(TAG,"call.................unsubscribed");
                    }
                })
                .serialize().subscribe(subscriber);

运行结果：



五、replay

保证所有的观察者收到相同的数据序列，即使它们在Observable开始发射数据之后才订阅。可连接的Observable (connectable Observable)与普通的Observable差不多，不过它并不会在被订阅时开始发射数据，而是直到使用了Connect操作符时才会开始。用这种方法，你可以在任何时候让一个Observable开始发射数据。如果在将一个Observable转换为可连接的Observable之前对它使用Replay操作符，产生的这个可连接Observable将总是发射完整的数据序列给任何未来的观察者，即使那些观察者在这个Observable开始给其它观察者发射数据之后才订阅。

 final ConnectableObservable<Long> observable =  Observable.interval(1,TimeUnit.SECONDS).observeOn(Schedulers.newThread())
                .take(5).replay(3);

        final Subscriber<Long> subscriber1 = new Subscriber<Long>() {

            @Override
            public void onNext(Long v) {
                Log.e(TAG,"onNext1................."+v);
            }

            @Override
            public void onCompleted() {
                Log.e(TAG, "onCompleted1.................");
            }

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


        Subscriber<Long> subscriber = new Subscriber<Long>() {

            @Override
            public void onNext(Long l) {
                Log.e(TAG,"onNext................."+l);
                if(l == 3){
                    observable.subscribe(subscriber1);
                }
            }

            @Override
            public void onCompleted() {
                Log.e(TAG, "onCompleted.................");
            }

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




        observable.subscribe(subscriber);
        observable.connect();

运行结果：



六、observeOn

指定一个观察者在哪个调度器上观察这个Observable

 Observable<String> observable =  Observable.create(new Observable.OnSubscribe<String>() {

            @Override
            public void call(Subscriber<? super String> subscriber) {
                for (int i = 0; i < 5; i++) {
                    subscriber.onNext(i + "");
                    try {
                        Thread.sleep(1000);
                    } catch (Exception e) {

                    }
                }
                subscriber.onCompleted();
            }
        }).observeOn(Schedulers.io());


        Subscriber<Object> subscriber = new Subscriber<Object>() {

            @Override
            public void onNext(Object v) {
                Log.e(TAG,"onNext................."+v+"............"+Thread.currentThread().getName());
            }

            @Override
            public void onCompleted() {
                Log.e(TAG, "onCompleted.................");
            }

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

        observable.subscribe(subscriber);

运行结果：



七、subscribeon

指定Observable自身在哪个调度器上执行

 Observable<String> observable =  Observable.create(new Observable.OnSubscribe<String>() {

            @Override
            public void call(Subscriber<? super String> subscriber) {
                for (int i = 0; i < 5; i++) {
                    subscriber.onNext(i + "");
                    try {
                        Thread.sleep(1000);
                    } catch (Exception e) {

                    }
                    Log.e(TAG, "call................."+ Thread.currentThread().getName());
                }
                subscriber.onCompleted();
            }
        })
                .subscribeOn(Schedulers.newThread());


        Subscriber<Object> subscriber = new Subscriber<Object>() {

            @Override
            public void onNext(Object v) {
                Log.e(TAG,"onNext................."+v+"............"+Thread.currentThread().getName());
            }

            @Override
            public void onCompleted() {
                Log.e(TAG, "onCompleted................."+Thread.currentThread().getName());
            }

            @Override
            public void onError(Throwable e) {
                Log.e(TAG, "onError....................."+Thread.currentThread().getName());
            }
        };

        observable.subscribe(subscriber);
运行结果：



八、doOnEach

发射完一个Observable时的回调

 Observable<Integer> observable = Observable.just(1,2,3,4,5,6);
        Subscriber<Integer> subscriber = new Subscriber<Integer>() {

            @Override
            public void onNext(Integer v) {
                Log.e(TAG,"onNext................."+v);
            }

            @Override
            public void onCompleted() {
                Log.e(TAG, "onCompleted.................");
            }

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

        observable
                .doOnEach(new Action1<rx.Notification<? super Integer>>() {
                    @Override
                    public void call(rx.Notification<? super Integer> notification) {
                        int i = (int) notification.getValue();
                        Log.e(TAG, "发射了一个数据....................."+i);
                    }
                })
                .subscribe(subscriber);

运行结果：



九、doOnNext

doOnNext操作符类似于doOnEach(Action1)，但是它的Action不是接受一个Notification参数，而是接受发射的数据项。

Observable<Integer> observable = Observable.just(1,2,3,4,5,6);
        Subscriber<Integer> subscriber = new Subscriber<Integer>() {

            @Override
            public void onNext(Integer v) {
                Log.e(TAG,"onNext................."+v);
            }

            @Override
            public void onCompleted() {
                Log.e(TAG, "onCompleted.................");
            }

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

        observable
                .doOnNext(new Action1<Integer>() {
                    @Override
                    public void call(Integer integer) {
                        if(integer == 3){
                            Log.e(TAG, "doOnNext.....................");
                        }
                    }
                })
                .subscribe(subscriber);
运行结果：


十、doOnSubscribe 

订阅生成时的回调 
Observable<Integer> observable = Observable.just(1,2,3,4,5,6);
        Subscriber<Integer> subscriber = new Subscriber<Integer>() {

            @Override
            public void onNext(Integer v) {
                Log.e(TAG,"onNext................."+v);
            }

            @Override
            public void onCompleted() {
                Log.e(TAG, "onCompleted.................");
            }

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

        observable
                .doOnSubscribe(new Action0() {
                    @Override
                    public void call() {
                        Log.e(TAG, "观察者订阅了它生成的Observable.....................");
                    }
                })
                .subscribe(subscriber);

运行结果：


nicolelili1
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
RxJava2 Flowable dematerialize && materialize（条辅助操作符）
无问西东的博客
10-06 632
dematerialize &&materialize 目录 dematerialize 1 dematerialize接口 2dematerialize图解 3dematerialize测试用例 4 dematerialize测试用例说明 materialize 1 materialize接口 ​​​​​​​2materialize图解 ​​​​...
Android-学习笔记-RxJava操作符(二)
zuochunsheng的博客
11-15 215
5 错误处理 onErrorResumeNext( ) — 指示Observable在遇到错误时发射一个数据序列 onErrorReturn( ) — 指示Observable在遇到错误时发射一个特定的数据 onExceptionResumeNext( ) — 指示Observable遇到错误时继续发射数据 retry( ) — 指示Observable遇到错误时重试。Retry操作符不会将原始...
RxJava----Utility 辅助操作
东子的博客 细节决定成败，点滴铸就辉煌。
03-21 2576
这个页面列出了很多用于Observable的辅助操作符 materialize( ) — 将Observable转换成一个通知列表convert an Observable into a list of Notifications dematerialize( ) — 将上面的结果逆转回一个Observable timestamp( ) — 给Observable发射的每个数据项添加一个时间戳 se
RxJava操作符
JokAr
08-14 786
Observable – 被观察者（事件源）Observer – 观察者 Create — 通过observer的方法创建一个新的ObservableDefer — 直到observer订阅的时候才会创建这个Observable，并且为每一个observer创建一个ObservableEmpty/Never/Throw — 创建行为受限特殊的Observable Empty 
RxJava 操作符之事件回调 do 系列操作符
sjh_389510506的博客
06-21 497
继续之前的RxJava 操作符系列文档，今天来研究一下do 操作符，也可以理解为 rxJava 各种事件的回调，比如当发生了onError ,我想在此做些什么，就可以使用一个回调操作，就可以用doOnError () 来实现。好了，老规矩，先列出参考文章 http://reactivex.io/documentation/operators/do.html 来看看官方解释 register ...
响应式学习（三）ProjectReactor
markren的博客
02-14 1062
Rxjava2与ProjectReactor 比较 Observable： Rxjava2对比Rxjava1不再接受null。Observable既不实现背压，也不实现Publisher（响应式规范），不推荐作用与大量元素，但其开销小于Flowable、具有toFlowable方法，转换需要选择背压策略。 Flowable： 直接对应Flux，实现了Publisher。 Single： 生成且仅生成一个元素的流，不继承Publisher，使用toFlowable不要背压策略。对比mono更
Rx 中文文档
10-25
根据提供的文件信息，我们可以深入探讨Rx（Reactive Extensions）的核心概念与操作符，特别是针对中文文档中的关键知识点进行详尽解读。 ### Introduction ReactiveX（通常简称为Rx）是一种用于构建响应式程序的库...
Rxjava2的笔记1 --操作符
小Tian的博客
08-21 320
implementation 'io.reactivex.rxjava2:rxjava:2.2.6' implementation 'io.reactivex.rxjava2:rxandroid:2.1.1' 创建操作符 create :创建操作符,创建最简单的事件流 其中Consumer为自定义观察者方法,不必全部实现观察者所有方法,此accept对应onNext()方法 Observable.create(new ObservableOnSubscribe<Integer...
RxJava 操作符整理 收集
xufeifandj的专栏
11-17 633
RxJava 操作符整理 收集
RxJava中文PDF文档
04-27
- 提供了一个按字母顺序排列的所有操作符的列表，方便查找。 #### 十四、RxJava文档和教程 - **RxJava入门指南**：介绍RxJava的基本概念和用法。 - **RxJava使用示例**：通过实际例子展示RxJava的各种操作符的使用...
RxJava2从入门到精通-初级篇
11-08
适合所有初中级工程师，从RxJava的每个知识点进行讲解，并在每个知识点中都带有文字说明和代码例子说明。通过这次系统化的学习，您将可以完整的学习到RxJava家族的所有特性和常用的操作符，掌握操作符的使用，掌握RxJava与Rx其他第三方库的使用。可以用三句简单的话进行概括面试加分利器 = 加大录取机会加快工作效率 = 早点下班回家系统化的学习 = 能力全面提升
RxJava之辅助操作符
行云间
09-05 4616
Observable的创建源于数据源，如何从Observable转换回数据源呢？观察者订阅后，如何推迟Observable发射数据呢？观察者订阅后，在Observable调用观察者的方法前，做一些其他的事情又该如何做呢？…带着思考的问题，让我们看下辅助操作符带给我们的无限遐想！delay流程图概述delay操作符让原Observable在发射每项数据之前都暂停一段指定的时间段，其效果是Observa
RxJava操作符大全
热门推荐
maplejaw的博客
09-01 3万+
再也不用担心记不住RxJava中的操作符了，RxJava操作符大全，需要用时Ctrl+F一下，还有使用例子哦。
[RxJava学习]操作符Do的使用
chwnpp2的专栏
08-24 2854
Observable中Do系列的函数，是通过注册回调的方式，来侦听链式操作过程的各个动作节点。 函数名 函数用途 函数原型 doOnNext 在每次发射元素之前（调用subScriber.onNext()）做一些额外的事情,不改变发射元素的值，只是插入了一个侦听 Observable doOnNext(final Action1 onNext) doOnC
RXjava学习笔记
jt_ontheway的博客
09-23 608
前言本文主要是自己学习RxJava的笔记整理学习的链接
observeOn(AndroidSchedulers.mainThread())报错的解决办法
fuzhongbin的博客
02-07 1万+
报错之前在使用： api 'io.reactivex.rxjava2:rxjava:2.1.7' api 'io.reactivex.rxjava2:rxandroid:2.0.1' api 'com.lzy.net:okgo:+' //版本号使用 + 可以自动引用最新版 api 'com.lzy.net:okrx2:+' api 'com.lzy.net:okserver:2.0.1'结果
RxJava操作符(07-辅助操作)
openXu的专栏
06-13 1万+
转载请标明出处： http://blog.csdn.net/xmxkf/article/details/51656736 本文出自:【openXu的博客】目录：Delay Do MaterializeDematerialize ObserveOnSubscribeOn TimeInterval Timeout Timestamp Using To 源码下载 1. Delay  delay的意
[J1900软路由] 系统断电后，重启后网卡异常：igb clearing RX timestamp hang
BigBirdKing的博客
01-29 3560
minipcie转pcieX4 接的是双口千兆网卡英特尔82576芯片 出现次数：异常断电必现 重启后显示异常：igb 0000:02:00:0clearing RX timestamp hang 可能跟这个转接卡有关或网卡有关，重启后网卡识别状态出现问题了 解决：minipcie转接卡的usb接口重新插拔一下，重启就好了 ...
RxJava do系列操作符
tinysakura的博客
02-27 660
转载自lluo2010的博客 介绍 RxJava的观察者类有许多方法，可以转换发出的字节流为任何你需要的数据类型。这些方法是RxJava非常核心的方法，是RxJava具有吸引力的重要缘故。 但是有些方法无论如何都不能改变流本身，这些方法称为副作用(Side Effect)方法。 Since those methods do not return anything, they cannot be ...
C#实战：Rx.NET 4.0 Swift 4.0 中的iOS开发与操作符详解
在书中，作者Tamir Dresher旨在帮助读者理解和掌握Rx.NET的核心概念，通过丰富的C#代码示例来展示如何运用各种Rx.NET操作符。以下是一些关键知识点的概要： 1. **创建观察者（Observables）**： - **显式逻辑**：...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值