Rxjava操作符之创建操作符

最新推荐文章于 2022-10-21 10:04:57 发布
最新推荐文章于 2022-10-21 10:04:57 发布
阅读量449 收藏
点赞数 1
分类专栏： android 文章标签： Android Rxjava 操作符
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wernerzeiss/article/details/80998734
版权

Rxjava创建类操作符

基本创建

  • 操作符：create()

  • 描述：创建一个最基本Observable对象

  • 示例：

Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(ObservableEmitter<String> emitter) throws Exception {
                emitter.onNext("第一条");
                emitter.onNext("第二条");
                emitter.onNext("第三条");
                emitter.onComplete();
            }
        }).subscribe(new Observer<String>() {
            @Override
            public void onSubscribe(Disposable d) {
                Log.i(TAG, "onSubscribe");
            }

            @Override
            public void onNext(String value) {
                Log.i(TAG, "onNext接收value：" + value);
            }

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

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

  • 打印log：

快速创建
1，just()

  • 描述：快速创建Observable并发送事件。最多只能发送10个参数，它有10个重载方法

  • 示例：

        Observable.just(1, 2, 3).subscribe(new Observer<Integer>() {
            @Override
            public void onSubscribe(Disposable d) {
                Log.i(TAG, "onSubscribe");
            }

            @Override
            public void onNext(Integer value) {
                Log.i(TAG, "onNext接收value：" + value);
            }

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

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

  • 打印：

2，fromArray()

  • 描述：根据传入的数组快速创建并发送事件。

  • 示例：

        String[] arrs = {"一条", "两条", "三条"};
        Observable.fromArray(arrs)
                .subscribe(new Observer<String>() {
                    @Override
                    public void onSubscribe(Disposable d) {
                        Log.i(TAG, "onSubscribe");
                    }

                    @Override
                    public void onNext(String value) {
                        Log.i(TAG, "onNext接收value：" + value);
                    }

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

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

  • 打印：

3，fromIterable()

  • 描述：根据传入的List快速创建并发送事件

  • 示例：

        List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);

        Observable.fromIterable(list)
                .subscribe(new Observer<Integer>() {
                    @Override
                    public void onSubscribe(Disposable d) {
                        Log.i(TAG, "onSubscribe");
                    }

                    @Override
                    public void onNext(Integer value) {
                        Log.i(TAG, "onNext接收value：" + value);
                    }

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

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

  • 打印：

4，empty()

  • 描述：创建后仅发送onComplete事件

  • 示例：

        Observable.empty().subscribe(new Observer<Object>() {
            @Override
            public void onSubscribe(Disposable d) {
                Log.i(TAG, "onSubscribe");
            }

            @Override
            public void onNext(Object o) {
                Log.i(TAG, "onNext");
            }

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

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

  • 打印：

5，error()

  • 描述：创建后发送错误事件Error

  • 示例：

        Observable.error(new RuntimeException())
                .subscribe(new Observer<Object>() {
            @Override
            public void onSubscribe(Disposable d) {
                Log.i(TAG, "onSubscribe");
            }

            @Override
            public void onNext(Object o) {
                Log.i(TAG, "onNext");
            }

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

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

  • 打印：

6，never()

  • 描述：创建后什么都不做

  • 示例：

        Observable.never()
                .subscribe(new Observer<Object>() {
            @Override
            public void onSubscribe(Disposable d) {
                Log.i(TAG, "onSubscribe");
            }

            @Override
            public void onNext(Object o) {
                Log.i(TAG, "onNext");
            }

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

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

  • 打印：

延时创建
1，defer()

  • 描述：当订阅时重新创建新的Observable

  • 重载：无

  • 示例：

        i = 20;
        Observable<Integer> observable = Observable.defer(new Callable<ObservableSource<? extends Integer>>() {
            @Override
            public ObservableSource<? extends Integer> call() throws Exception {
                return Observable.just(i);
            }
        });

        i = 30;
        observable.subscribe(new Observer<Integer>() {
            @Override
            public void onSubscribe(Disposable d) {
                Log.i(TAG,"onSubscribe");
            }

            @Override
            public void onNext(Integer value) {
                Log.i(TAG,"onNext,value:"+value);
            }

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

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

  • 打印：

2，timer()

  • 描述：创建一个在给定的延时之后发射数据项为0的Observable

  • 重载：timer(long,TimeUnit)，timer(long,TimeUnit,Scheduler)

  • 示例：

        Observable.timer(3000, TimeUnit.MILLISECONDS)
                .subscribe(new Observer<Long>() {
                    @Override
                    public void onSubscribe(Disposable d) {
                        Log.i(TAG, "onSubscribe");
                    }

                    @Override
                    public void onNext(Long value) {
                        Log.i(TAG, "onNext,value:" + value);
                    }

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

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

  • 打印：

3，interval()

  • 描述：创建一个按照给定的时间间隔发射从0开始的整数序列的Observable

  • 重载：

    第一类：interval(long,TimeUnit)，interval(long,TimeUnit,Scheduler)，

    第二类：interval(long,long,TimeUnit)，interval(long,long,TimeUnit,Scheduler)，其中第一个参数为延迟多少时间后开始发送第一个事件，之后按照第二个参数的固定间隔时间发送

  • 示例：

        Observable.interval(1,TimeUnit.SECONDS)
                .subscribe(new Observer<Long>() {
                    @Override
                    public void onSubscribe(Disposable d) {
                        Log.i(TAG, "onSubscribe");
                    }

                    @Override
                    public void onNext(Long value) {
                        Log.i(TAG, "onNext,value:" + value);
                    }

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

                    @Override
                    public void onComplete() {
                        Log.i(TAG, "onComplete");
                    }
                });
  • 打印：

4，intervalRange()

  • 描述：创建一个按照给定的起始值、发送总数、延时时间和时间间隔来发射整数序列的Observable

  • 重载：intervalRange(long, long, long, long, TimeUnit)，intervalRange(long, long, long, long, TimeUnit, Scheduler)

  • 示例：

        /**
         * 参数1：第几个数字开始
         * 参数2：一共发送几个数字
         * 参数3：延时多久后开始发送第一个
         * 参数4：发送第一个后，每间隔多久发送后续事件
         * 参数5：时间单位
         */
        Observable.intervalRange(3,5,2,1,TimeUnit.SECONDS)
                .subscribe(new Observer<Long>() {
                    @Override
                    public void onSubscribe(Disposable d) {
                        Log.i(TAG, "onSubscribe");
                    }

                    @Override
                    public void onNext(Long value) {
                        Log.i(TAG, "onNext,value:" + value);
                    }

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

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

  • 打印：

5，range()

  • 描述：创建一个发射特定整数序列的Observable

  • 重载：range(int,int)，range(int,int,scheduler)

  • 示例：

        //参数1：从第几个数字开始。参数2：一共发送几个
        Observable.range(3,4)
                .subscribe(new Observer<Integer>() {
                    @Override
                    public void onSubscribe(Disposable d) {
                        Log.i(TAG, "onSubscribe");
                    }

                    @Override
                    public void onNext(Integer value) {
                        Log.i(TAG, "onNext,value:" + value);
                    }

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

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

  • 打印：

6，rangeLong()

  • 描述：创建一个发射特Long类型整数序列的Observable，功能使用与range()相同。

  • 重载：无，只有一个rangeLong(long,long)

  • 示例：与range()相同

其他操作符介绍：

Rxjava操作符之变换操作符

Rxjava操作符之结合类操作符

Rxjava操作符之过滤操作

Rxjava操作符之辅助操作

ZCrainy
关注
专栏目录
RxJava2极速入门——Rxjava操作符详解之创建操作符
易庞宙的博客
03-22 1118
目录 RxJava操作符——创建操作符 create操作符 defer操作符 from操作符 fromArray操作符 fromIterable操作符 fromFuture操作符 interval操作符 just操作符 range操作符 repeat操作符 repeat操作符分析 repeatWhen操作符 repeatUntil操作符 timer操作符 empty...
android Observable.interval定时执行快速上手和分析
热门推荐
u013750244的博客
05-08 1万+
Observable.interval可以执行定时任务， Observable.interval是来源于Rxjava2的函数，我引用的是： compile 'io.reactivex.rxjava2:rxjava:2.2.6' 使用如下： import java.util.concurrent.TimeUnit; import io.reactivex.Observable; import............
Android基础之倒计时多种实现方式与倒计时暂停重启
chenliguan的博客
06-26 6065
1 倒计时方法介绍handler+postDelayed() 方式 Timer + TimerTask + handler 方式 ScheduledExecutorService + handler 方式 RxJava 方式 CountDownTimer 方式1.11.21.31.4 RxJava 方式（1）RxJava的Observable.timer方法Observable.timer
Rxjava(创建类)--Empty
new_abc的专栏
10-24 1728
创建一个不发射任何数据但是正常终止的Observable Observable.empty().subscribe(new Observer() { @Override public void onNext(String s) { log("onNext:" + s); }
RxJava2在Android中的使用之一 ----- 创建Observable
weixin_42504805的博客
10-21 1799
RxJava2在Android中的使用之一 ----- 创建Observable
RxJava 操作符 图片
03-31
在这个主题中，我们将深入探讨 RxJava 中的操作符，这些操作符是 RxJava 的核心组成部分，它们提供了丰富的功能来创建、转换、过滤和组合数据流。 首先，我们来了解一下什么是操作符。在 RxJava 中，操作符是用于...
RxJava操作符
07-01
1. **创建操作符** - `just()`: 用于将一个或多个值包装成Observable，常用于简单的数据注入。 - `from()`/`fromArray()`: 可以将数组、集合或其他可迭代对象转换为Observable。 - `range()`: 生成一个包含指定...
Android + Rxjava + Rxjava操作符
04-23
1：Rxjava创建操作符：（create() ， just()，fromArray()，fromIterable() ，time() , interval()） 2: 转换操作符：（map() , flatMap() ） 3: 合并操作符：（merge() , collect()） 4: 功能操作符：（delay() , ...
Android RxJava创建操作符Interval
01-04
Interval操作符：用于创建Observable，跟TimerTask类似，用于周期性发送信息，是一个可以指定线程的TimerTask 首先添加类库 // RxAndroid compile 'io.reactivex:rxandroid:1.2.1' // RxJava compile 'io.reactivex...
rxjava : empty、never、error
火星男孩的分享空间
09-27 1066
empty() ： 直接发送 onComplete() 事件 never() ： 不发送任何事件 error() ： 发送 onError() 事件 empty @Test public void empty() { Observable.empty() .subscribe(new Observer<Object>() { @Over...
Android 利用 RXJAVA interval 操作符 实现 计时器 功能
TracyEminem的博客
08-18 5831
原理是利用interval操作符每1秒刷新一下UI。。代码如下 int currentMillers = 0; String Minute; String seconds; Observable.interval(0,1, TimeUnit.SECONDS) .subscribeOn(Schedulers.io())
RxJava（十）switchIfEmpty 操作符实现 Android 检查本地缓存逻辑判断
Chiclaim
09-19 1万+
RxJava系列文章目录导读： 一、RxJava create操作符的用法和源码分析 二、RxJava map操作符用法详解 三、RxJava flatMap操作符用法详解 四、RxJava concatMap操作符用法详解 五、RxJava onErrorResumeNext操作符实现app与服务器间token机制 六、RxJava retryWhen操作符...
Observable.interval定时执行
冰雪世界
10-22 1万+
Observable.interval方法可以定时执行自定义的逻辑，常用方法如下： /** * 定时执行 * * @param period 每次执行的间隔的时间 * @param unit 时间单位 * @return Observable对象 */ public static Observable<Long> interval(long period, Time...
android Rxjava interval 操作符实现 倒计时功能
TracyEminem的博客
01-04 1228
currentTime = System.currentTimeMillis()/1000; terminal = Long.valueOf(detailData.getDeadline_timestamp()) -currentTime; if(subscription.isUnsubscribed() && terminal >
android 函数式编程,响应式编程在Android中的应用
weixin_35648203的博客
05-25 286
响应式编程简介响应式编程是一种基于异步数据流概念的编程模式。数据流就像一条河：它可以被观测，被过滤，被操作，或者为新的消费者与另外一条流合并为一条新的流。响应式编程的一个关键概念是事件。事件可以被等待，可以触发过程，也可以触发其它事件。事件是唯一的以合适的方式将我们的现实世界映射到我们的软件中：如果屋里太热了我们就打开一扇窗户。同样的，当我们更改电子表(变化的传播)中的一些数值时，我们需要更新整个...
android fragment结束当前,[Android] 如何在 Activity 或者 Fragment 的生命周期结束时停止订阅 Observable...
weixin_39820588的博客
05-27 463
NavUtil利用 NavUtil，你可以在 Activity 或 Fragment 的生命周期发生变化时，停止订阅你的 Observable。Usage在Activity 中，为你的 Observable 应用 compose 操作符，如下所示：// 假设这是你的 ObservableObservable.interval(1, TimeUnit.SECONDS)// 你的 Observable...
RxJava2 Flowable 静态操作符
无问西东的博客
10-02 6701
RxJava的学习成本其实蛮高的，我写RxJava这个系列是希望缩短学习RxJava的时间，我这里完全根据官网来学习一遍，写用例，做笔记，对于对英文不太感冒的同学，我相信看我的博客可以舒服不少！ 国庆两天假初步整理了一下Flowable的静态操作符，后续将会继续写Flowable的实例操作符，Observable、Single、Completable、Maybe操作符以及对各操作符的分类和总结，...
Java RxJava库操作符实战与示例
map操作符是RxJava中最常用的操作符之一，它的作用是将一个Observable对象中的事件转换为另一个事件。例如，我们可以看到以下代码示例： ```java Observable.just("Hello, world!") .map(new Func1, String>() { ...
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值