RxJava学习第二篇---RxJava调度器以及操作符使用

最新推荐文章于 2024-05-04 11:33:56 发布
最新推荐文章于 2024-05-04 11:33:56 发布
阅读量271 收藏
点赞数 1
分类专栏： RxJava
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_28051795/article/details/80094540
版权

第一篇：重新认识RxJava以及基本使用

第二篇：RxJava调度器以及操作符使用

第三篇：反压学习，RxAndroid的使用和总结


RxJava中操作符主要有  创建、变换、组合、功能、过滤、布尔。

创建操作符：用于创建 被观察者和发送事件。上文中我们用到的create()就是一个创建操作符，当然创建操作符不止只一个，还有很多，不如：just()   timer()  interval()  等等；

    //just用于快速创建被观察者并发送数据，just最多只能发送10个数据
        Observable.just(1,2,3,4,5,6,7,8,9,10)
                .subscribe(new Consumer<Integer>() {
                    @Override
                    public void accept(Integer integer) throws Exception {

                    }
                });
     //快速创建并发行Array数组
        Observable.fromArray(strarr)
                .subscribe(new Consumer<String>() {
                    @Override
                    public void accept(String s) throws Exception {

                    }
                });
      //定时发送一次
        Observable.timer(1000, TimeUnit.MILLISECONDS)
                .subscribe();
        //轮循固定时间不间断发送
        Observable.interval(1000,10000,TimeUnit.MILLISECONDS)
                .subscribe();
        //每隔固定时间发送一个事件，事件的数量可以指定
        Observable.intervalRange(1000,10,0,1000,TimeUnit.MILLISECONDS)
                .subscribe();
        //无延迟的从指定开始值 发送指定数量的事件
        Observable.range(1,100)
                .subscribe();
剩下的大家可以自行测试。


变换操作符：主要用于将发送的时间进行加工处理，处理成我们需要的消息，比如有：map()  buffer()等

        //通过map将发送的Integer类型转换为String类型
        Observable.just(1, 2, 3, 4, 5)
                .map(new Function<Integer, String>() {
                    @Override
                    public String apply(Integer integer) throws Exception {
                        return integer + "";
                    }
                }).subscribe();
        //将原先的事件拆分，然后将单个事件重新整合然后在无序发出
        Observable.just(1,2,3,4,5)
                .flatMap(new Function<Integer, ObservableSource<?>>() {
                    @Override
                    public ObservableSource<?> apply(Integer integer) throws Exception {
                        List<String> list = new ArrayList<>();
                        for (int i = 5; i < 8; i++) {
                            list.add("原事件："+integer+"新增事件："+i);
                        }
                        return Observable.fromIterable(list);
                    }
                }).subscribe();
concatMap()和flatMap()基本一致，只是整合后有序的发出
        //定义一个缓存区，每次从被观察者中取指定个数的事件发送
        Observable.just(1,2,3,4,5)
                .buffer(3,1)
                .subscribe();

组合操作符：用于用于合并多个被观察者发送事件，比如：concat() count()等

        //组合多个被观察者按组合顺序发出(concatArray区别在于发送个数)
        Observable.concat(Observable.just(1,2,3),Observable.just(4,5,6))
                .subscribe();
        //组合多个被观察者按事件时间顺序发出(mergeArray区别在于发送个数)
        Observable.merge(Observable.just(1,2,3),Observable.just(4,5,6))
                .subscribe();
        //将两个被观察者中的事件合并，然后发出，事件数量以少的被贯穿者为准
        Observable.zip(Observable.just(1, 2, 3), Observable.just("A", "B", "C", "D"), new BiFunction<Integer, String, String>() {
            @Override
            public String apply(Integer integer, String s) throws Exception {
                return integer + s;
            }
        }).subscribe();

        //将被观察者发送的数据整理到一个数据结构里发送
        Observable.just(1,2,3,4)
                .collect(new Callable<List<Integer>>() {
                    @Override
                    public List<Integer> call() throws Exception {
                        return new ArrayList<>();
                    }
                }, new BiConsumer<List<Integer>, Integer>() {
                    @Override
                    public void accept(List<Integer> integers, Integer integer) throws Exception {
                        integers.add(integer);
                    }
                }).subscribe();

功能操作符：在被观察者和观察者之间做桥梁，比如 subscribe() subscribeOn()等

        Observable.just(1, 2, 3, 4, 5)
                .subscribeOn(Schedulers.newThread())//被观察者的线程
                .observeOn(Schedulers.io())//观察者的线程
                .delay(1000, TimeUnit.MILLISECONDS)//被观察者延迟一段时间发送
                .doOnEach(new Consumer<Notification<Integer>>() {//被观察者每次发送数据都会调用（结束异常都会调用）
                    @Override
                    public void accept(Notification<Integer> integerNotification) throws Exception {

                    }
                })
                .doOnNext(new Consumer<Integer>() {//被观察者发送onNext之前调用
                    @Override
                    public void accept(Integer integer) throws Exception {

                    }
                })
                .doAfterNext(new Consumer<Integer>() {//被观察者发送onNext之后调用
                    @Override
                    public void accept(Integer integer) throws Exception {

                    }
                })
                .doOnError(new Consumer<Throwable>() {//被观察者发送错误时候调用
                    @Override
                    public void accept(Throwable throwable) throws Exception {

                    }
                })
                .doOnComplete(new Action() {//被观察者正茬发送完毕调用
                    @Override
                    public void run() throws Exception {

                    }
                })
                .doOnTerminate(new Action() {//被观察者无论正常还是异常结束都会调用
                    @Override
                    public void run() throws Exception {

                    }
                })
                .doFinally(new Action() {//最后执行
                    @Override
                    public void run() throws Exception {

                    }
                })
                .doOnSubscribe(new Consumer<Disposable>() {//订阅时候调用
                    @Override
                    public void accept(Disposable disposable) throws Exception {

                    }
                })
                .onErrorReturn(new Function<Throwable, Integer>() {//如果遇到异常，发送一个特定的事件正常终止
                    @Override
                    public Integer apply(Throwable throwable) throws Exception {
                        return null;
                    }
                })
                .retry()//如果出现错误重试
                .subscribe();


过滤操作符：主要用于过滤筛选被观察者发送的事件，比如 ：skip()  take()等

        //当filter中返回true时候继续发送
        Observable.just(1, 2, 3, 4, 5)
                .filter(new Predicate<Integer>() {
                    @Override
                    public boolean test(Integer integer) throws Exception {
                        return integer > 2;
                    }
                }).subscribe(); 
        //过滤指定类型
        Observable.just(1,"",2,"")
                .ofType(Integer.class)
                .subscribe();
        Observable.just(1,2,3,4)
                .skip(1)//跳过正序指定个事件
                .skipLast(2)//跳过正序最后指定个数事件
                .subscribe();
        Observable.just(1, 2, 3, 1, 2, 3, 3, 4, 4)
                .distinctUntilChanged()//过滤连续重复事件
                .distinct()//过滤全部重复事件
                .take(2)//观察者只能接收两个事件
                .takeLast(2)//观察者只能接收最后两个事件
                .throttleFirst(1, TimeUnit.MILLISECONDS)//指定时间间隔后的第一个事件
                .throttleLast(1, TimeUnit.MILLISECONDS)//指定试讲间隔前最后一个事件
                .throttleWithTimeout(1, TimeUnit.MILLISECONDS)//如果间隔小于指定时间，丢掉前一个数据
                .firstElement()//只发送第一个数据
                .subscribe();

布尔操作符：判断被观察者发送的事件是否符合要求 ，比如：all() amb()等

        Observable.just(1, 2, 3, 4, 5, 6)
                .all(new Predicate<Integer>() {//验证所有事件是否都满足条件，然后发送一个结果
                    @Override
                    public boolean test(Integer integer) throws Exception {
                        return integer < 10;
                    }
                }).subscribe();
        Observable.just(1, 2, 3, 4, 5.6)
                .takeWhile(new Predicate<Number>() {//事件满足条件才会发送
                    @Override
                    public boolean test(Number number) throws Exception {
                        return (number.intValue() > 2);
                    }
                }).subscribe();
        Observable.just(1, 2, 3, 4, 5, 6)
                .takeUntil(new Predicate<Integer>() {//事件满足条件时候停止发送
                    @Override
                    public boolean test(Integer integer) throws Exception {
                        return integer == 2;
                    }
                }).subscribe();
        Observable.just(1,2,3,4,5)
                .contains(4)//判断发送的事件中时候有指定事件
                .subscribe();


（在没有经过别人同意的情况下盗用一张图，如果该博主介意的话请联系我！）


qq_28051795
关注
专栏目录
RxJava 操作符篇 - 过滤操作符
doris_d的专栏
09-29 280
Debounce 仅在过了一段指定的时间还没发射数据时才发射一个数据，会过滤掉发射速率过快的数据项。 Distinct 过滤掉重复的数据项，只允许还没有发射过的数据项通过。 ElementAt 只发射指定索引位置的数据项。 Filter 指定函数过滤数据项。 First 只发射第一个数据项。 IgnoreElements 抑制原始 Observable 发射的所有数据，只允许它的终止通知（onError和onCompleted）通过。 Last 只发射最后一个数据项。 Sample 定时发射 Observa
Android-学习笔记-RxJava操作符(二)
zuochunsheng的博客
11-15 229
5 错误处理 onErrorResumeNext( ) — 指示Observable在遇到错误时发射一个数据序列 onErrorReturn( ) — 指示Observable在遇到错误时发射一个特定的数据 onExceptionResumeNext( ) — 指示Observable遇到错误时继续发射数据 retry( ) — 指示Observable遇到错误时重试。Retry操作符不会将原始...
RxJavaSchedulers:更多与 RxJava 一起使用的调度器
06-18
RxJava 调度器 更多与 RxJava 一起使用的调度程序。
rxJava基础篇之六--调度器
qq_34723470的博客
11-21 328
线程控制----Scheduler（调度器） Schedulers.immediate(): 直接在当前线程运行，相当于不指定线程。这是默认的 Scheduler。 Schedulers.newThread(): 总是启用新线程，并在新线程执行操作。 Schedulers.io(): I/O 操作（读写文件、读写数据库、网络信息交互等）所使用的 Scheduler。
RxJava(11-线程调度Scheduler)
热门推荐
openXu的专栏
07-04 1万+
转载请标明出处： http://blog.csdn.net/xmxkf/article/details/51791120 本文出自:【openXu的博客】目录：使用示例 subscribeOn原理 多次subscribeOn的情况 observeOn原理 调度器的种类 各种操作符的默认调度器 源码下载  RxJava中 使用observeOn和subscribeOn操作符，你可以让Obser
RxJava2 中 的线程调度器 Scheduler
Kevin_s_gun的博客
11-06 302
5.RxJava2 线程调度器 调度器 Scheduler 用于控制操作符和被观察者事件所执行的线程，不同的调度器对应不同的线程。RxJava提供了5种调度器： RxJava 线程调度器 说明 Schedulers.immediate() 默认线程，允许立即在当前线程执行所指定的工作。 Schedulers.newThread() 新建线程，总是启用新线程，并在新线程...
RxJava线程调度的使用
m0_64365896的博客
11-17 472
在不指定线程的状况下， RxJava 遵循的是线程不变的原则，即：在哪一个线程调用 subscribe()，就在哪一个线程生产事件；在哪一个线程生产事件，就在哪一个线程消费事件。若是须要切换线程，就须要用到 Scheduler （调度器）● 在 RxJava 的默认规则中，事件的发出和消费都是在同一个线程的。也就是说，若是只用上面的方法，实现出来的只是一个同步的观察者模式。观察者模式自己的目的就是『后台处理，前台回调』的异步机制，所以异步对于 RxJava 是相当重要的。
RxJava-Intro-For-Android:Android中RxJava的快速入门项目
05-12
RxJava的`cache()`操作符可以实现这一点，让数据流只在第一次请求时执行，之后的请求将直接从缓存中获取数据。 **8. 生命周期管理** 在Android环境中，必须考虑Activity和Fragment的生命周期。RxJava的`RxLifecycle...
Android-学习笔记-RxJava操作符
zuochunsheng的博客
11-12 427
1 创建操作 just() — 将一个或多个对象转换成发射这个或这些对象的一个Observable fromArray(), fromFuture()，fromIterable(), — 将一个数组, 一个Future, 或者一个Iterable转换成一个Observable create() — 使用一个函数从头创建一个Observable defer() —只有当订阅者订阅才创...
RxJava-2-0还没熟悉，RxJava-3-0说来就来了！（基础篇）
最新发布
2401_84408378的博客
05-04 735
如果你觉得文章写得不错就给个赞呗？如果你觉得那里值得改进的，请给我留言。一定会认真查询，修正不足。，第一时间获取最新知识点Android架构师之路很漫长，一起共勉吧！
RxJava2.0（二）Schedulers线程调度器
m0_49508485的博客
09-22 889
上一节教程讲解了最基本的RxJava2的使用, 在本节中, 我们将学习RxJava强大的线程控制Schedulers.
面试：Rxjava线程调度使用
王温暖的博客
12-13 1083
RxJava2线程调度使用： 最简单易懂的RxJava2.0学习教程之RxJava2的线程调度（二）_简简单单_zz的博客-CSDN博客 使用RxJava的时候，在没有切换线程的情况下, 上游==被观察者(observable)和下游==观察者(observer)是工作在同一个线程中的,即都在主线程中。 话不多说上代码： Observable<Integer> observable = Observable.create(new ObservableOnSubscribe<Int
Rxjava2入门教程四：Scheduler线程调度器
不积跬步无以至千里，不积小流无以成江河
03-12 740
Scheduler(线程调度器)赋予RxJava简洁明了的异步操作,可以说是RxJava中最值得称道的地方。 在之前的代码中，Observable发射数据流，Observer接收响应数据流，以及Operators加工数据流均是在同一个线程中，实现出来的是一个同步的函数响应式。但是函数响应式的实际应用却不是这样的，大部分都是后台处理，前台响应的一个过程。Observable生成发射数据流，以及Ope...
RxJava2总结之操作详解(二)
狂健小夫的博客
08-17 4642
目录目录 辅助操作 repeat repeatUntil delay delaySubscription do系列 doOnEach doOnNext doOnSubscribe doOnComplete doOnError doOnTerminate doFinally doOnDispose materialize dematerialize observeOn subscribeOn subs
Rxjava(2.Schedulers调度器)
androidxiaogang的博客
02-22 2780
1、Schedulers调度器Schedulers将用简单的方式创建多线程。对于android移动端来说，做耗时操作只能在子线程中，返回结果后刷新UI又得切换到主线程中。很多时候我们需要new Thread(),然后用Handler进行请求后的回调，或者借助Asynctask类。这样代码在一个类中这样写可能不多，但对于android来说，每个界面几乎都要请求网络，刷新UI。因此这样的工作一来增加的代
Rxjava的线程调度器
红豆和绿豆的博客
02-22 258
package rxjava.scheduler; import io.reactivex.schedulers.Schedulers; public class SchedulerTest { public static void main(String[] args) { // Schedulers.computation() 用于cpu密集任务，不适合io操作 线程数量等于cpu数量 // Schedulers.io() 用于io密集性 提升阻塞io的异步性.
RxJava—Schedule（调度器）
会飞的鱼~的博客
12-09 1850
RxJava—Schedule（调度器） 在不指定线程的情况下， RxJava 遵循的是线程不变的原则，即：在哪个线程调用 subscribe()，就在哪个线程生产事件；在哪个线程生产事件，就在哪个线程消费事件。如果需要切换线程，就需要用到 Scheduler （调度器）。调度器以一种最简单的方式将多线程用在你的Apps的中。
【Rxjava学习】timer、interval、take、map实现计时器
Ikulm的博客
10-25 1822
1.Timer：创建一个延时的Obsevable发送给观察者，即延时一段时间做某事 LogUtils.e("开始"); Observable.timer(3000, TimeUnit.MILLISECONDS) .subscribeOn(Schedulers.io()) .observeOn(AndroidSch...
RxJava操作符汇总
zengke的博客
05-21 9203
1、创建操作符 ：创建被观察者（Observable）对象&amp;amp;amp;amp;amp;amp;amp;发送事件 2、转换操作符：变换被观察者(Observable)发送的事件。将Observable发送的数据按照一定的规则做一些变换，然后再将变换的数据发射出去。变换的操作符有map,flatMap，concatMap,switchMap,buffer,groupBy等等。 3、 合并操作符：组合多个被观察者(Obser...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值