RxJava操作符(6)-通用

最新推荐文章于 2019-07-06 09:27:00 发布
最新推荐文章于 2019-07-06 09:27:00 发布
阅读量804 收藏
点赞数 1
分类专栏： rxjava 文章标签： rxjava 通用操作符
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/DylanZhuang/article/details/52204161
版权

Delay

Delay操作符是延时数据的发射。

原理图如下：


Delay操作符使用如下：

    @Override
    protected void createObservable() {
        super.createObservable();
        mObservable = Observable.just(1, 2, 3)
                .delay(2, TimeUnit.SECONDS)
                .observeOn(AndroidSchedulers.mainThread());
    }


运行代码，结果如下：

DelaySubscription

DelaySubscription操作符是延时订阅Observable。

原理图如下：


DelaySubscription操作符使用如下：

    @Override
    protected void createObservable() {
        super.createObservable();
        mObservable = Observable.just(1, 2, 3)
                .delaySubscription(2, TimeUnit.SECONDS)
                .observeOn(AndroidSchedulers.mainThread());
    }


运行代码，结果如下：

DoOnEach

DoOnEach操作符为Observable设置一个回调，每当Observable发射数据时，都会触发这个回调，类似于观察者模式。

原理图如下：


DoOnEach操作符使用如下：

    @Override
    protected void createObservable() {
        super.createObservable();
        mObservable = createObservable(5).doOnEach(new Action1<Notification<? super Integer>>() {
            @Override
            public void call(Notification<? super Integer> notification) {
                String message = "value = " + notification.getValue() + " kind = " + notification.getKind();
                displayLogcat(message);
            }
        });
    }

    private Observable createObservable(final int index) {
        return Observable.create(new Observable.OnSubscribe<Integer>() {
            @Override
            public void call(Subscriber<? super Integer> subscriber) {
                for (int i = 0; i < index; i++) {
                    subscriber.onNext(i);
                    if (i == index - 1) {
                        subscriber.onError(new Throwable("error"));
                    }
                }
            }
        });
    }


运行代码，结果如下：

DoNext

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

原理图如下：


DoNext操作符使用如下：

    @Override
    protected void createObservable() {
        super.createObservable();
        mObservable = createObservable(5).doOnNext(new Action1<Integer>() {
            @Override
            public void call(Integer integer) {
                displayLogcat("integer = " + integer);
            }
        });
    }

    private Observable createObservable(final int index) {
        return Observable.create(new Observable.OnSubscribe<Integer>() {
            @Override
            public void call(Subscriber<? super Integer> subscriber) {
                for (int i = 0; i < index; i++) {
                    subscriber.onNext(i);
                    if (i == index - 1) {
                        subscriber.onError(new Throwable("error"));
                    }
                }
            }
        });
    }


运行代码，结果如下：

DoOnSubscribe

doOnSubscribe操作符注册一个动作，当观察者订阅它生成的Observable它就会被调用。

原理图如下：


DoOnSubscribe操作符使用如下：

    @Override
    protected void createObservable() {
        super.createObservable();
        mObservable = Observable.just(1, 2, 3).doOnSubscribe(new Action0() {
            @Override
            public void call() {
                displayLogcat("doOnSubscribe");
            }
        });
    }


运行代码，结果如下：

DoOnUnSubscribe

doOnUnsubscribe操作符注册一个动作，当观察者取消订阅它生成的Observable它就会被调用。

原理图如下：


DoOnUnSubscribe操作符使用如下：

    @Override
    protected void createObservable() {
        super.createObservable();
        mObservable = Observable.just(1, 2, 3).doOnUnsubscribe(new Action0() {
            @Override
            public void call() {
                displayLogcat("doOnUnsubscribe");
            }
        });
    }


运行代码，结果如下：

DoOnCompleted

doOnCompleted操作符注册一个动作，当它产生的Observable正常终止调用onCompleted时会被调用。

原理图如下：


DoOnCompleted操作符使用如下：

    @Override
    protected void createObservable() {
        super.createObservable();
        mObservable = Observable.just(1, 2, 3).doOnCompleted(new Action0() {
            @Override
            public void call() {
                displayLogcat("doOnCompleted");
            }
        });
    }


运行代码，结果如下：

DoOnError

doOnError操作符注册一个动作，当它产生的Observable异常终止调用onError时会被调用。

原理图如下：


DoOnError操作符使用如下：

    @Override
    protected void createObservable() {
        super.createObservable();
        mObservable = createObservable(5).doOnError(new Action1<Throwable>() {
            @Override
            public void call(Throwable throwable) {
               displayLogcat("doOnError throwable = " + throwable);
            }
        });
    }

    private Observable createObservable(final int index) {
        return Observable.create(new Observable.OnSubscribe<Integer>() {
            @Override
            public void call(Subscriber<? super Integer> subscriber) {
                for (int i = 0; i < index; i++) {
                    subscriber.onNext(i);
                    if (i == index - 1) {
                        subscriber.onError(new Throwable("error"));
                    }
                }
            }
        });
    }


运行代码，结果如下：

DoOnTerminate

doOnTerminate操作符注册一个动作，当它产生的Observable终止之前会被调用，无论是正常还是异常终止。

原理图如下：


DoOnTerminate操作符使用如下：

    @Override
    protected void createObservable() {
        super.createObservable();
        mObservable = Observable.just(1, 2, 3).doOnTerminate(new Action0() {
            @Override
            public void call() {
                displayLogcat("doOnTerminate");
            }
        });
    }


运行代码，结果如下：

FinallyDo

finallyDo操作符注册一个动作，当它产生的Observable终止之后会被调用，无论是正常还是异常终止。

原理图如下：


FinallyDo操作符使用如下：

    @Override
    protected void createObservable() {
        super.createObservable();
        mObservable = Observable.just(1, 2, 3).finallyDo(new Action0() {
            @Override
            public void call() {
                displayLogcat("finallyDo");
            }
        });
    }


运行代码，结果如下：

Materialize

Materialize操作符将OnNext/OnError/OnComplete都转化为一个Notification对象并按照原来的顺序发射出来。

原理图如下：


Materialize操作符使用如下：

    @Override
    protected void createObservable() {
        super.createObservable();
        mObservable = Observable.just(1, 2, 3).materialize();
    }


运行代码，结果如下：

Dematerialize

Dematerialize操作符跟Materialize操作符正好相反。

原理图如下：


Dematerialize操作符使用如下：

    @Override
    protected void createObservable() {
        super.createObservable();
        mObservable = Observable.just(Notification.createOnNext(1),
                Notification.createOnNext(2),
                Notification.createOnNext(3),
                Notification.<Integer>createOnCompleted()).dematerialize();
    }


运行代码，结果如下：

SubscribeOn

SubscribeOn操作符用来决定Observable在哪个线程上运行。

原理图如下：


SubscribeOn操作符使用如下：

    @Override
    protected void createObservable() {
        super.createObservable();
        mObservable = Observable.create(new Observable.OnSubscribe<Integer>() {
            @Override
            public void call(Subscriber<? super Integer> subscriber) {
                for (int i = 0; i < 5; i++) {
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    subscriber.onNext(i);
                }
                subscriber.onCompleted();
            }
        }).subscribeOn(Schedulers.newThread()).observeOn(AndroidSchedulers.mainThread());
    }


运行代码，结果如下：

ObserverOn

ObserverOn操作符用来决定观察者运行在哪个线程上。

原理图如下：


ObserverOn操作符使用如下：

    @Override
    protected void createObservable() {
        super.createObservable();
        mObservable = Observable.timer(2, TimeUnit.SECONDS)
                .observeOn(AndroidSchedulers.mainThread());
    }


运行代码，结果如下：

TimeInterval

TimeInterval操作符拦截原始Observable发射的数据项，替换为发射表示相邻发射物时间间隔。

原理图如下：


TimeInterval操作符使用如下：

    @Override
    protected void createObservable() {
        super.createObservable();
        mObservable = Observable.create(new Observable.OnSubscribe<Integer>() {
            @Override
            public void call(Subscriber<? super Integer> subscriber) {
                for (int i = 0; i < 5; i++) {
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    subscriber.onNext(i);
                }
                subscriber.onCompleted();
            }
        }).timeInterval().observeOn(AndroidSchedulers.mainThread());
    }


运行代码，结果如下：

Timestamp

TimeStamp操作符会对数据封装为Timestamped对象，该对象包含发射出去的数据和发射该数据时的时间戳。

原理图如下：


Timestamp操作符使用如下：

    @Override
    protected void createObservable() {
        super.createObservable();
        mObservable = Observable.create(new Observable.OnSubscribe<Integer>() {
            @Override
            public void call(Subscriber<? super Integer> subscriber) {
                for (int i = 0; i < 5; i++) {
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    subscriber.onNext(i);
                }
                subscriber.onCompleted();
            }
        }).timestamp().observeOn(AndroidSchedulers.mainThread());
    }


运行代码，结果如下：

Timeout

TimeOut操作符是如果Observable是timeout指定的时间内，没发射出数据，timeout则会终止这次Observable的发射，并自己发射一个数据；反之发射Observable的数据。

原理图如下：


Timeout操作符使用如下：

    @Override
    protected void createObservable() {
        super.createObservable();
        mObservable = Observable.create(new Observable.OnSubscribe<Integer>() {
            @Override
            public void call(Subscriber<? super Integer> subscriber) {
                try {
                    Thread.sleep(5000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                subscriber.onNext(123);
            }
        }).timeout(3, TimeUnit.SECONDS, Observable.just(456))
        .subscribeOn(Schedulers.newThread())
        .observeOn(AndroidSchedulers.mainThread());
    }


运行代码，结果如下：

Using

Using操作符是创建一个资源，让Observable引用这个资源，在Observable用完之后对资源进行回收。

原理图如下：


Using操作符使用如下：

    @Override
    protected void createObservable() {
        super.createObservable();
        mObservable = Observable.using(new Func0<Integer>() {
            @Override
            public Integer call() {
                return 1;
            }
        }, new Func1<Integer, Observable<Integer>>() {
            @Override
            public Observable call(Integer o) {
                displayLogcat("Func1 call o = " + o);
                return Observable.just(o);
            }
        }, new Action1<Integer>() {
            @Override
            public void call(Integer o) {
                displayLogcat("Action1 call o = " + o);
                unsubscribe();
            }
        });
    }


运行代码，结果如下：




dylanzhuang
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
RxJava框架时序图-map操作符
01-04
RxJava框架时序图-map操作符,RxJava框架时序图-map操作符
[RxJava学习]操作符Do的使用
chwnpp2的专栏
08-24 2835
Observable中Do系列的函数，是通过注册回调的方式，来侦听链式操作过程的各个动作节点。 函数名 函数用途 函数原型 doOnNext 在每次发射元素之前（调用subScriber.onNext()）做一些额外的事情,不改变发射元素的值，只是插入了一个侦听 Observable doOnNext(final Action1 onNext) doOnC
RxJava2（二）五种被观察者
qq_39507260的博客
11-11 1060
Observable 一简介 1.Observable即被观察者，决定什么时候触发事件以及触发怎样的事件。 2.Oberver即观察者，他可以在不同的线程中执行任务，极大的简化了并发操作，因为他创建了一个处于待命状态的观察者，可以在某一时刻相应Observable的通知，而不会造成阻塞。 3.subscribe() 订阅用户，只有调用此方法才会开始发射数据。其有4个构造方法： subscribe...
RxJava 源码笔记(1)
fyfcauc的专栏
09-25 511
Notification： An object representing a notification sent to an {@link Observable} 注释已经解释的很清楚，代表的是响应式编程信息流中的一条消息(onNext/onError/onComplete) 正如上面所说的，Notification承载的是复数种类型，因此需要一个Kind对象来进行标记属于哪种信息。 Kind是
RxJava操作符repeatWhen()和retryWhen()
Dream It Possible
05-26 9306
第一次见到.repeatWhen()和.retryWhen()这两个操作符的时候就非常困惑了。不得不说，它们绝对是“最令人困惑弹珠图”的有力角逐者。然而它们都是非常有用的操作符：允许你有条件的重新订阅已经结束的Observable。我最近研究了它们的工作原理，现在我希望尝试着去解释它们（因为，我也是耗费了一些精力才参透它们）。Repeat与Retry的对比首先，来了解一下.repeat()和.ret
RxJava----Utility 辅助操作
东子的博客 细节决定成败，点滴铸就辉煌。
03-21 2523
这个页面列出了很多用于Observable的辅助操作符 materialize( ) — 将Observable转换成一个通知列表convert an Observable into a list of Notifications dematerialize( ) — 将上面的结果逆转回一个Observable timestamp( ) — 给Observable发射的每个数据项添加一个时间戳 se
RxJava 操作符 图片
03-31
RxJava 操作符图片,, 根据Flowable.java 上面的http链接下载的图片,
Android + Rxjava + Rxjava操作符
04-23
1：Rxjava创建操作符：（create() ， just()，fromArray()，fromIterable() ，time() , interval()） 2: 转换操作符：（map() , flatMap() ） 3: 合并操作符：（merge() , collect()） 4: 功能操作符：（delay() , ...
RxJava 操作符使用
最新发布
03-27
RxJava 操作符、线程调度 观察者 RxJava是一种事件驱动的基于异步数据流的编程模式，整个数据流就像一条河流，它可以被观测（监听），过滤，操控或者与其他数据流合并为一条新的数据流。三要素Rxjava原理 基于 一种...
RxJava操作符
07-01
RxJava操作符的简单使用示例，不是全部，还有很多后边慢慢学习了会补上
Rxjs中Notification介绍(一)
weixin_30745641的博客
07-06 124
一、概念： 　　Notification是什么？ 　　Notification中文意思是通知、通告和告示。在rxjs中Notification是一个类class，这个类主要基于操作符operators对其实例进行管理，比如通过materialize、dematerialize函数进行物质化和去物质化，不仅对实际交付的值进行封装，而且还对封装的值用元数据进行注解它是什么类型的推送消息（...
RxJava与RxAndroid 接收消息通知
小炫风技术旅行
12-25 2770
RxJava与RxAndroid 接收消息通知 主要通过两个类 rx.Observer rx.Subscriber 这两个类的关系:继承关系rx.Observer被rx.Subscriber继承 作用 Provides a mechanism for receiving push-based notifications from Observables, and pe
RxJava操作符大全
热门推荐
maplejaw的博客
09-01 3万+
再也不用担心记不住RxJava中的操作符了，RxJava操作符大全，需要用时Ctrl+F一下，还有使用例子哦。
RxJava操作符(7)-条件
DylanZhuang的博客
09-24 2198
All All操作符对Observable发送的所有数据根据某个条件进行判断，当其发射出去的数据都满足该条件时，则返回true，否则返回false。 原理图如下： All操作符使用如下： @Override protected void createObservable() { super.createObservable();
RxJava操作符(1)-创建
DylanZhuang的博客
08-08 702
RxJava现在感觉挺火的，这段时间就抽空学习了RxJava相关API。在网上也看到过RxJava相关文章，总感觉看了好多遍也记不住，于是就打算用博客记下来，毕竟好记性不如烂笔头，下面介绍创建操作符的相关api的使用。
RxJava操作符(3)-过滤
DylanZhuang的博客
08-11 693
RxJava现在感觉挺火的，这段时间就抽空学习了RxJava相关API。在网上也看到过RxJava相关文章，总感觉看了好多遍也记不住，于是就打算用博客记下来，毕竟好记性不如烂笔头。下面介绍下过滤操作符。
RxJava操作符(4)-结合
DylanZhuang的博客
08-13 675
RxJava现在感觉挺火的，这段时间就抽空学习了RxJava相关API。在网上也看到过RxJava相关文章，总感觉看了好多遍也记不住，于是就打算用博客记下来，毕竟好记性不如烂笔头，下面介绍下结合操作符。
RxJava操作符(8)-聚合
DylanZhuang的博客
09-28 652
Concat Concat操作符将2到9个Observable，按照顺序将他们合并为一个Observable发射出去。 原理图如下： Concat操作符使用如下： @Override protected void createObservable() { super.createObservable(); mObservable
.操作符和->操作符的区别
06-02
`.`操作符和`->`操作符都是用来访问结构体或类的成员变量或成员函数的。它们的区别在于： `.`操作符用于访问结构体或类的成员变量或成员函数，左边的操作数必须是一个结构体或类的实例。例如，`data.x`表示访问`...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值