RxJava----操作符：创建操作符

最新推荐文章于 2023-05-16 15:30:14 发布
最新推荐文章于 2023-05-16 15:30:14 发布
阅读量785 收藏
点赞数
分类专栏： 开源框架 文章标签： RxJava
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_20198405/article/details/51244181
版权

Creating Observables（创建操作符）

just

创建一个发射预定义好的数据的 Observable ，发射完这些数据后，事件流就结束了。
这里写图片描述

        Observable.just(1,2,3)
                 .subscribe(new Observer<Integer>() {
                    @Override
                    public void onCompleted() {
                        log("Complete!");
                    }
                    @Override
                    public void onError(Throwable e) {
                        log(e.getMessage().toString());
                    }
                    @Override
                    public void onNext(Integer integer) {
                        log(integer+"");
                    }
                });

结果：

1
2
3
Complete！

from

这里写图片描述

使用这个特殊的“创建”函数，我们可以从一个列表（可以了List或者Array）中创建一个Observable。Observable将发射出列表中的每一个元素，我们可以通过订阅它们来对这些发出的元素做出响应。

        Integer[] items=new Integer[]{1,2,3};
        List<Integer> list= Arrays.asList(items);
        Observable.from(items)
                .subscribe(new Action1<Integer>() {
                    @Override
                    public void call(Integer integer) {
                        log(integer+"");
                    }
                });

结果：

1
2
3

defer

defer 并没有定义一个新的 Observable， defer 只是用来声明当 Subscriber 订阅到一个 Observable 上时，该 Observable 应该如何创建。例如，如果我们想创建一个发射当前时间然后就结束的 Observable， 发射一个数据然后结束，看起来用 just 实现即可：
这里写图片描述

        Observable<Long> now = Observable.just(System.currentTimeMillis()); 
        now.subscribe(new Action1<Long>() {
            @Override
            public void call(Long aLong) {
                log(String.valueOf(aLong));
            }
        });
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        now.subscribe(new Action1<Long>() {
            @Override
            public void call(Long aLong) {
                log(String.valueOf(aLong));
            }
        });

结果：

1461721257817
1461721257817

注意上面两个 subscriber 相隔 1秒订阅这个 Observable，但是他们收到的时间数据是一样的！这是因为当订阅的时候，时间数据只调用一次。其实你希望的是，当 一个 subscriber 订阅的时候才去获取当前的时间。 defer 的参数是一个返回一个 Observable 对象的函数。该函数返回的 Observable 对象就是 defer 返回的 Observable 对象。重点是，每当一个新的 Subscriber 订阅的时候，这个函数就重新执行一次。 

        Observable<Long> now = Observable.defer(new Func0<Observable<Long>>() {
            @Override
            public Observable<Long> call() {
                return Observable.just(System.currentTimeMillis());
            }
        });

        now.subscribe(new Action1<Long>() {
            @Override
            public void call(Long aLong) {
                log(String.valueOf(aLong));
            }
        });
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        now.subscribe(new Action1<Long>() {
            @Override
            public void call(Long aLong) {
                log(String.valueOf(aLong));
            }
        });

结果：

1461721097102
1461721098103

range

range()方法用两个数字作为参数：第一个是起始点，第二个是我们想发射数字的个数。
这里写图片描述

        Observable.range(5,3)
        .subscribe(new Action1<Integer>() {
            @Override
            public void call(Integer integer) {
                log(integer+"");
            }
        });

结果：

5
6
7

interval

创建一个无限的计时序列，每隔一段时间发射一个数字，从 0 开始：

这里写图片描述

interval操作符默认情况下是运行在一个新线程上的，当然你可以通过传入参数来修改其运行的线程。

         Subscription subscription = Observable.interval(3, TimeUnit.SECONDS)
                .subscribe(new Action1<Long>() {
                    @Override
                    public void call(Long aLong) {
                        log(aLong+"");
                    }
                });
        try {
            System.in.read();
        } catch (IOException e) {
            e.printStackTrace();
        }

结果：

0
1
2
...

如果我们不调用 unsubscribe 的话，这个序列是不会停止的。
上面的代码在最后有个 System.in.read(); 阻塞语句，这个语句是有必要的，不然的话，程序不会打印任何内容就退出了。原因是我们的操作不是阻塞的：我们创建了一个每隔一段时间就发射数据的 Observable，然后我们注册了一个 Subscriber 来打印收到的数据。这两个操作都是非阻塞的，而 发射数据的计时器是运行在另外一个线程的，但是这个线程不会阻止 JVM 结束当前的程序，所以 如果没有 System.in.read(); 这个阻塞操作，还没发射数据则程序就已经结束运行了。

timer

Observable.timer 有两个重载函数。timer操作符默认情况下是运行在一个新线程上的，当然你可以通过传入参数来修改其运行的线程。
第一个示例创建了一个 Observable， 该 Observable 等待一段时间，然后发射数据 0 ，然后就结束了。
这里写图片描述

        Observable.timer(3,TimeUnit.SECONDS)
                .subscribe(new Action1<Long>() {
                    @Override
                    public void call(Long aLong) {
                        log(aLong+"");
                    }
                });

结果：

0

它将3秒后发射0,然后就完成了。
另外一个示例是，先等待一段时间，然后开始按照间隔的时间一直发射数据:
这里写图片描述

        Observable.timer(4,2,TimeUnit.SECONDS)
                .subscribe(new Action1<Long>() {
                    @Override
                    public void call(Long aLong) {
                        log(aLong+"");
                    }
                });

结果：

0
1
2
...

上面的示例，先等待 4秒，然后每隔2秒开始发射数据。

empty

这里写图片描述

这个函数创建的 Observable 只发射一个 onCompleted 事件就结束了。

        Observable<Integer> observable = Observable.empty();
        Subscription subscription = observable.subscribe(new Subscriber<Integer>() {
            public void onCompleted() {
                log("Complete!");
            }
            @Override
            public void onError(Throwable e) {
                log(e.getMessage().toString());
            }
            @Override
            public void onNext(Integer integer) {
                log(integer+"");
            }
        });

结果：

Complete!

never

这个 Observable 将不会发射任何事件和数据。
这里写图片描述

        Observable<Integer> observable = Observable.empty();
        Subscription subscription = observable.subscribe(new Subscriber<Integer>() {
            public void onCompleted() {
                log("Complete!");
            }
            @Override
            public void onError(Throwable e) {
                log(e.getMessage().toString());
            }
            @Override
            public void onNext(Integer integer) {
                log(integer+"");
            }
        });

结果不打印任何数据

error

这个 Observable 将会发射一个 error 事件，然后结束。
这里写图片描述

         Observable<Integer> observable =  Observable.error(new Exception("Oops"));
        Subscription subscription = observable.subscribe(new Subscriber<Integer>() {
            public void onCompleted() {
                log("Complete!");
            }
            @Override
            public void onError(Throwable e) {
                log(e.getMessage().toString());
            }
            @Override
            public void onNext(Integer integer) {
                log(integer+"");
            }
        });

结果：

Oops

create

create 是非常强大的一个函数。可以创建任何你需要的 Observable。

static <T> Observable<T> create(Observable.OnSubscribe<T> f)

这里写图片描述
上面是 create 函数的定义，参数 Observable.OnSubscribe 看起来很简单。OnSubscribe 只有一个方法，该方法的参数为 Subscriber。在该方法内我们可以手工的发射事件和数据到 subscriber。

        Observable<String> observable = Observable.create(new Observable.OnSubscribe<String>() {
            @Override
            public void call(Subscriber<? super String> subscriber) {
                subscriber.onNext("Hello RxJava");
                subscriber.onCompleted();
            }
        });
        Subscriber<String> subscriber = new Subscriber<String>() {
            public void onCompleted() {
                log("Complete!");
            }
            @Override
            public void onError(Throwable e) {
                log(e.getMessage().toString());
            }
            @Override
            public void onNext(String s) {
                log(s);
            }
        };
        observable.subscribe(subscriber);

结果：

Hello RxJava
Complete！

在使用create操作符时，最好要在回调的call函数中增加isUnsubscribed的判断，以便在subscriber在取消订阅时不会再执行call函数中相关代码逻辑，从而避免导致一些意想不到的错误出现；

当有 Subscriber 订阅到这个 Observable 时（上面示例中的 observable ），这个 Subscriber 对象就是你实现的函数中的参数 Subscriber。然后你可以在你的代码中把数据发射到这个 subscriber 中。注意，当数据发射完后，你需要手工的调用 onCompleted 来表明发射完成了。

项目源码 GitHub求赞，谢谢！
引用：
RxJava 教程第二部分：事件流基础之 创建事件流 - 云在千峰
再多几个例子 | RxJava Essentials CN

pepe_士奇
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
RxOperators:RxJava使用整理-操作符、使用方式
05-09
操作符预览图创建操作符变换操作符组合/合并操作符功能性操作符常用功能操作符-【subscribe】【subscribeOn】【observeOn】其他功能操作符-【delay】【repeat】【repeatWhen】【do】错误处理功能
RxJava3 创建型操作符
bigfc的博客
10-11 456
通过具体的示例，每个操作符的使用方法~
RxJava（一）创建操作符
牛永志的专栏
09-18 471
RxJava创建操作符
RxJava操作符入门
肇秋贰拾捌的博客
05-16 900
【代码】RxJava操作符入门。
RxJava2复习笔记一、操作符Create
haoyuegongzi的博客
09-03 286
create操作符应该是最常见的操作符，主要是观察者Observer（我们也称为下游事件）用来创建一个被观察者对象Obserable（我们也称为上游事件）。被观察者对象Obserable用于发送事件，观察者Observer用于接收事件。 好了，废话不多说，直接上代码： //创建一个上游 Observable： Observable&amp;amp;lt;Integer&amp;amp;gt; observab...
RxJava（一） create 操作符的用法和源码分析
Chiclaim
05-28 1万+
RxJava系列文章目录导读： 一、RxJava create操作符的用法和源码分析 二、RxJava map操作符用法详解 三、RxJava flatMap操作符用法详解 四、RxJava concatMap操作符用法详解 五、RxJava onErrorResumeNext操作符实现app与服务器间token机制 六、RxJava retryWhen操作符...
Android RxJava创建操作符Interval
01-04
Interval操作符：用于创建Observable，跟TimerTask类似，用于周期性发送信息，是一个可以指定线程的TimerTask 首先添加类库 // RxAndroid compile 'io.reactivex:rxandroid:1.2.1' // RxJava compile 'io.reactivex...
Android RxJava创建操作符Timer的方法
01-20
本文实例为大家分享了Android RxJava创建操作符Timer的具体代码，供大家参考，具体内容如下 之前有写过Android实现倒计时之使用CountDownTimer，除了CountDownTimer，开发中我们也会用到handler，例如 mHandler....
Android + Rxjava + Rxjava操作符
04-23
1：Rxjava创建操作符：（create() ， just()，fromArray()，fromIterable() ，time() , interval()） 2: 转换操作符：（map() , flatMap() ） 3: 合并操作符：（merge() , collect()） 4: 功能操作符：（delay() , ...
Rxjava从入门到精通：创建操作符之：just()，From()，create()操作符
C++ JAVA的专栏
04-23 2830
Rxjava从入门到精通：创建操作符之：just()，From()，create() ，fromIterable() 操作符
RxJava3.0 操作符之创建操作符使用
sky丶伤心欲绝的博客
05-10 374
RxJava3.0 创建操作符
RxJava2.x 创建操作符之 create & just (打怪升级版)！！！
「程序员飞飞」的博客
05-18 1630
题图：来自网络 哈喽，朋友们，好久不见了，有段时间没推文了。从今天开始，我将计划更新 RxJava2.x 系列的文章，RxJava 是什么东西，我想也不用给大家介绍了吧。 其实，网上关于 RxJava 的相关文章一大堆，我之前也看过不少，对于新手来说，那些文章，要么就是比较长，不容易看下去，要么就是讲的全是理论，晦涩难懂，缺少实践性。 因此，我打算从今天开始，更新一系列的 RxJava2.x 教...
关于RxJava2的操作符示例
The blog of CSDN in 杨天福
08-26 7434
关于Rxjava2的操作符示例： Create just doOnNext filter skip Flowable take distinct single concat merge buffer map FlatMap concatMap timer(过时) interval defer reduce scan debounce last window publishSubject as...
RxJava2.0-Observable原理分析之Create操作符
热门推荐
fengluoye2012的博客
01-24 2万+
简介 RxJava一个在 Java VM 上使用可观测的序列来组成异步的、基于事件的程序的库；扩展了观察者模式以支持数据/事件的序列，并添加操作符，允许您以声明的方式组合序列，同时抽象出对诸如低层次线程、同步、线程安全和conc等问题的关注。 相关的入门的介绍有很多，可参考https://www.jianshu.com/p/15b2f3d7141a系列的文章介绍的非常全面；这篇文章的主要介绍相...
Android：rxjava简单实现原理（create操作符）
JMW1407的博客
08-07 353
rxjavarxjava1、观察者模式2、Rxjava的观察者模式？3、Rxjava简单实现 rxjava 1、观察者模式 观察者模式基于Subject这个概念，Subject是一种特殊对象，又叫做主题或者被观察者。当它改变时那些由它保存的一系列对象将会得到通知，而这一系列对象被称作Observer(观察者)。它们会对外暴漏了一个通知方法(比方说update之类的)，当Subject状态发生变化时会调用的这个方法。 观察者模式很适合下面这些场景中的任何一个： 1、当你的架构有两个实体类，一个依赖另一个，你
create用法java_RxJava（一） create操作符的用法和源码分析
weixin_35745051的博客
03-01 1418
RxJava系列文章目录导读：1 create操作符的基本使用顾名思义，Create操作符是用来创建一个Observable的。下面来看一个简单的代码段：Observable.create(new Observable.OnSubscribe() {@Overridepublic void call(Subscriber super String> subscriber) {//Emit D...
RxJava----操作符：组合操作符
qq_20198405的博客
04-28 8793
本节介绍如何把多个数据源的数据组合为一个数据源的操作函数。 Concatenation 一个数据流发射完后继续发射下一个数据流是一种很常见的组合方法。 concat concat 操作函数把多个数据流按照顺序一个一个的发射数据。第一个数据流发射完后，继续发射下一个。 concat 函数有多个重载函数： public static final <T> Observable<T> concat(
RxJava----操作符：过滤操作符
qq_20198405的博客
04-26 3946
Filtering Observables（过滤操作符） 到目前为止我们看到的示例都很简单。你也可以用 Rx 来处理大批量实时数据，但是如果把所有大批量数据整个打包发给你的话，使用 Rx 还有啥优势呢？ 本节 我们将介绍一些操作符（operators ）来过滤数据、或者把所有数据变成一个需要的数据。 如果你了解过函数式编程（functional programming）或者 Java
Glide---使用
qq_20198405的博客
05-18 3236
添加GlideGradlecompile 'com.github.bumptech.glide:glide:3.6.1'MavenGlide 也支持 Maven 项目：<dependency> <groupId>com.github.bumptech.glide</groupId> <artifactId>glide</artifactId> <version>3.6.1</version> <ty
Rxjava 只执行一段代码不做任何返回的操作符
最新发布
07-20
您可以使用`doOnNext`操作符来执行一段代码而不做任何返回操作。`doOnNext`操作符会在每次发射数据项之前执行指定的代码。以下是一个示例： ```java Observable.just("Hello") .doOnNext(item -> { // 在发射数据...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值