RxJava2.0的使用：操作符(一)

最新推荐文章于 2022-09-22 15:16:20 发布
最新推荐文章于 2022-09-22 15:16:20 发布
阅读量285 收藏
点赞数
分类专栏： IT 文章标签： RxJava2.0 操作符
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/csclmf/article/details/79180558
版权

1、创建被观察者以及发射一个Integer事件

     //创建被观察者
        Observable.create(
                //创建发射器<要发射事件的类型>
                new ObservableOnSubscribe<Integer>() {
                    @Override
                    public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {

                        //发射事件
                        emitter.onNext(1);
                        emitter.onNext(2);
                        emitter.onNext(3);

                        //发射完成事件
                        emitter.onComplete();


                    }
                }
        )
        //订阅，使被观察者和观察者建立联系
        .subscribe(

                //创建观察者
                new Observer<Integer>() {
                    @Override
                    public void onSubscribe(Disposable d) {
                        System.out.println("开始订阅");
                    }

                    @Override
                    public void onNext(Integer integer) {
                        System.out.println("接受事件"+integer);

                    }

                    @Override
                    public void onError(Throwable e) {
                        System.out.println("响应Error事件"+e);

                    }

                    @Override
                    public void onComplete() {
                        System.out.println("响应Complete事件");

                    }
                }

        );
运行结果:


2、快速发送传入的事件

①发送基本数据类型(Integer，Double，String等)

       //快速创建，直接发送传入的事件
        Observable
                //最多只能传送10个参数
                .just("数据1","数据2","数据3","数据4","数据5","数据6","数据7","数据8","数据9","数据10")
                //订阅
                .subscribe(
                        //创建观察者
                        new Observer<String>() {
                            @Override
                            public void onSubscribe(Disposable d) {

                            }

                            @Override
                            public void onNext(String s) {
                                System.out.println("接收到的事件:"+s);

                            }

                            @Override
                            public void onError(Throwable e) {

                            }

                            @Override
                            public void onComplete() {

                            }
                        }
                );

运行结果:



② 快速发送数组:

        List<Boolean> lists=new ArrayList<>();
        lists.add(true);
        lists.add(true);
        lists.add(true);
        lists.add(false);
        lists.add(false);

        Observable.fromArray(lists)
              .subscribe(
                      new Observer<List<Boolean>>() {
                          @Override
                          public void onSubscribe(Disposable d) {

                          }

                          @Override
                          public void onNext(List<Boolean> booleen) {
                              System.out.println("接收到的事件:"+booleen);

                          }

                          @Override
                          public void onError(Throwable e) {

                          }

                          @Override
                          public void onComplete() {

                          }
                      }
              );

运行结果:



③传入数据，并且遍历出每个数据

     List<Integer> lists=new ArrayList<>();
        lists.add(0);
        lists.add(2);
        lists.add(3);
        lists.add(4);
        lists.add(5);
        Observable.fromIterable(lists)
                .subscribe(
                        new Observer<Integer>() {
                            @Override
                            public void onSubscribe(Disposable d) {

                            }

                            @Override
                            public void onNext(Integer integer) {
                                System.out.println("遍历到的每一个数据:"+integer);

                            }

                            @Override
                            public void onError(Throwable e) {

                            }

                            @Override
                            public void onComplete() {

                            }
                        }
                );

运行结果:


3、延迟创建：

应用场景:

1)、定时：经过多少时间以后，去做什么操作

2)、周期性：每隔多长的时间，需要自动执行什么操作

①、defer：(延迟)

作用：直到观察者订阅的时候，才会创建被观察者并且发送事件(举个我项目中的应用场景：我需要上传好多的图片，当时上传图片之前我要把图片进行压缩，

只用当图片全部压缩完成以后才去做上传操作，这时就可以使用defer)

     //实现的效果是:当count=5的时候，观察者才订阅，这时被观察者会给观察者发送数据:100

        int count=0;

        //通过 defer 定义被观测者对象，注意这时被观测者是还没被创建的
        final Observable<Integer> observable=Observable.defer(new Callable<ObservableSource<? extends Integer>>() {
            @Override
            public ObservableSource<? extends Integer> call() throws Exception {

                return Observable.just(100);
            }
        });


        for (int i = 0; i <= 10; i++) {
            count++;
            System.out.println("当前的数据是"+count);

            if (count==5){

                //这时观察者开始订阅，这时才会创建被观测者对象
               observable.subscribe(
                       new Observer<Integer>() {
                           @Override
                           public void onSubscribe(Disposable d) {

                           }

                           @Override
                           public void onNext(Integer integer) {
                               System.out.println("接收到的数据:"+integer);

                           }

                           @Override
                           public void onError(Throwable e) {

                           }

                           @Override
                           public void onComplete() {

                           }
                       }
               );
            }
运行结果:


②、Timer：作用就是延迟多长时间以后，去做某一操作(应用场景:一般用于检测)

       //作用就是延迟多长时间以后发送一个数值：0(只会执行一次)
        Observable.timer(1, TimeUnit.MINUTES)//延迟一分钟
                .subscribe(new Observer<Long>() {
                    @Override
                    public void onSubscribe(Disposable d) {

                    }

                    @Override
                    public void onNext(Long aLong) {
                        System.out.println("接收到的数据"+aLong);

                    }

                    @Override
                    public void onError(Throwable e) {

                    }

                    @Override
                    public void onComplete() {

                    }
                });
运行结果:


③interval:(轮询)

作用：每隔多长时间发送一个事件（应用场景：比如NBA文字直播，设置间隔多长时间刷新数据）

发送的事件序列=从0开始，无限递增1的正数序列

         //参数说明
            //参数1：第一次延迟的时间
            //参数2：间隔的时间
            //参数3：时间单位
        Observable.interval(5,2,TimeUnit.SECONDS)
                .subscribe(
                        new Observer<Long>() {
                            @Override
                            public void onSubscribe(Disposable d) {

                            }

                            @Override
                            public void onNext(Long aLong) {
                                System.out.println("接收到的数据:"+aLong);

                            }

                            @Override
                            public void onError(Throwable e) {

                            }

                            @Override
                            public void onComplete() {

                            }
                        }
                );

运行结果:



④intervalRange():有限次的轮询

      //参数代表的意义:
            //参数1：事件序列的起点
            //参数2：事件的数量
            //参数3：第一次事件的延迟发送时间
            //参数3：时间间隔
            //参数4：时间单位
        Observable.intervalRange(5,10,3,2,TimeUnit.SECONDS)
                .subscribe(
                        new Observer<Long>() {
                            @Override
                            public void onSubscribe(Disposable d) {

                            }

                            @Override
                            public void onNext(Long aLong) {
                                System.out.println("接收到的事件:"+aLong);

                            }

                            @Override
                            public void onError(Throwable e) {

                            }

                            @Override
                            public void onComplete() {

                            }
                        }
                );
运行结果:



⑤range:范围

        //参数的意义:
            //参数1：时间序列的起点
            //参数2：事件数量
        Observable.range(5,10)
                .subscribe(
                        new Observer<Integer>() {
                            @Override
                            public void onSubscribe(Disposable d) {

                            }

                            @Override
                            public void onNext(Integer integer) {
                                System.out.println("接收到的事件:"+integer);

                            }

                            @Override
                            public void onError(Throwable e) {

                            }

                            @Override
                            public void onComplete() {

                            }
                        }
                );
运行结果：


⑥rangeLong() 类似range()


4、案例：网络请求轮询

private void doNetForData() {
        Observable
                //延迟2秒发起请求，然后每个5秒无限轮询请求
                .interval(2,5,TimeUnit.SECONDS)

                //每隔5秒产生一个数字前，就发送一次网络请求，从而实现轮询效果
                .doOnNext(
                        //Consumer是简易版的Observer
                        new Consumer<Long>() {
                            @Override
                            public void accept(@NonNull Long aLong) throws Exception {
                                System.out.println("现在是第:"+aLong+"次轮询");
                                RetrofitFactory.getRetrofit().create(NetApi.class)//发情网络请求
                                        .requestData()
                                        //在IO线程进行网络请求
                                        .subscribeOn(Schedulers.io())
                                        //切换到主线程获取网络请求结果
                                        .observeOn(AndroidSchedulers.mainThread())
                                        //订阅
                                        .subscribe(
                                                //创建观察者
                                                new Observer<WordEntity>() {
                                                    @Override
                                                    public void onSubscribe(Disposable d) {

                                                    }

                                                    @Override
                                                    public void onNext(WordEntity wordEntity) {
                                                        System.out.println("请求到数据结果");

                                                    }

                                                    @Override
                                                    public void onError(Throwable e) {
                                                        System.out.println("请求数据出错"+e);

                                                    }

                                                    @Override
                                                    public void onComplete() {

                                                    }
                                                }
                                        );
                            }
                        }
                ).subscribe(
                new Observer<Long>() {
                    @Override
                    public void onSubscribe(Disposable d) {

                    }

                    @Override
                    public void onNext(Long aLong) {
                        System.out.println("interval发送的事件"+aLong);

                    }

                    @Override
                    public void onError(Throwable e) {

                    }

                    @Override
                    public void onComplete() {

                    }
                }
        );

    }
运行结果:







csc_1024
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
word源码java-RxJava2.0:RxJava2.0使用介绍，官方文档翻译
06-05
RxJava2.0使用介绍，参考官方文档，每个操作符对应一个示例，帮助更好理解RxJava2.0 RxJava是什么？ Rx（Reactive Extensions）历史 是LINQ的一个扩展，由微软的架构师Erik Meijer领导的团队开发，在2012年11月开源...
RxJava2.0在android开发中的实用操作符总结
04-14
本文将深入探讨RxJava2.0的一些实用操作符，帮助开发者更好地理解和运用这个强大的工具。 1. **创建Observable** - `just()`: 用于从单个或多个值创建Observable。 - `fromArray()`: 将数组转换为Observable，...
从零开始的RxJava2.0教程(二)操作符
热门推荐
宇不语的博客
11-06 2万+
1. 前言在上一篇中，我介绍了RxJava 2.0的一些基础知识，同时也介绍了map()操作符。这篇blog将介绍许多RxJava中的操作符，RxJava的强大性就来自于它所定义的操作符。 首先先看一个例子： 2. 准备工作假设我的 Flowable 发射的是一个列表，接收者要把列表内容依次输出。根据上一篇blog的内容，你可以会写出这样的代码:List<Integer> list = new
手把手教你使用 RxJava 2.0（一）
LRH0211的博客
06-02 1623
网上有很多关于RxJava的技术文章，大多数是关于1.x版本的。随着 RxJava 2.0 的推出，有些文章也介绍了2.x版本新增的内容以及与1.x版本的对比。有些同学如果刚刚接触RxJava，仅仅看RxJava 1.x 的一些技术文章，有时候会有些出入。因此本篇文章基于RxJava 2.0 进行由浅入深的学习，逐步掌握RxJava。 1.作用RxJava的目的就是异步。 RxJava的特点就是可
RxJava2.0的使用-3
备忘录
05-27 1489
RxJava Flowable
RXJava 2.0操作符学习
天花板的随笔
10-17 282
1、merge操作符、zip操作符和join操作符 merge是把两个数组的数据合并到一个新的数组中，新的数组是两个数组长度之和。 zip合并后的新数组长度是两个数组中长度小的那个，并且合并的方式可以由我们自己定义。 join合并后的新数组是连个数组的乘积（较少用到）。 ...
RxJava2.0操作符（三）
Android开发那些年
02-20 302
RxJava操作符图谱 先对RxJava的操作符有一个整体结构的认识，然后从简单的操作符入手开始研究。 转换操作符 – map map是RxJava中最简单的一个变换操作符了, 它的作用就是对Observable发送的每一个事件应用一个函数, 使得每一个事件都按照指定的函数去变化. 一个简单的例子： Observable.create(new ObservableOnSubscribe&amp;amp;lt;In...
RxJava2.0（初学者教程+实用操作符总结及原理简析）
最新发布
06-21
RxJava2.0 是一个强大的响应式编程库，尤其在Android开发中被广泛使用。它引入了一种新的处理异步数据流的方式，通过观察者模式和一系列操作符，简化了事件处理和数据管理。本教程将针对初学者，详细介绍如何入门...
RxJava2.0 结合Retrofit2.0 的简单的封装
06-14
在"Demo"项目中，可能包含了具体的示例代码，展示了如何将RxJava2.0和Retrofit2.0结合使用，实现一个简单的网络请求封装。通过查看这些代码，你可以更深入地理解这两者如何协同工作，以及如何在实际项目中应用。对于...
Rxjava 2.0+Retrofit 2.0+Mvp架构研究
02-06
RxJava的核心概念包括Observable（可观察者）、Observer（观察者）和Operator（操作符）。在2.0版本中，对线程控制和错误处理进行了优化，使得开发者能够更方便地管理数据流的生命周期和异常。例如，使用 `....
RxJava2.0 学习（1）—— 操作符总结
章鱼哥的博客
11-20 333
RxJava2.0 学习（1）----操作符总结 2018年 看了 nanchen 大神得 Rxjava2.0 demo 自己做下总结 demo地址 https://github.com/nanchen2251/RxJava2Examples 1操作符 Create （获取一个observable 被观察这对象） 时间传递 和 拦截 Disposable.isDisposed 返回 false ...
RxJava2.0(二)常用操作符
weixin_34179968的博客
11-30 185
过滤操作符 filter： 功能：过滤掉不需要的数据，往观察者中传入需要的数据。 例子： Observable.just(1,2,3,4,5,6,7,8,9) .filter(new Predicate&lt;Integer&gt;() { @Override public bo...
RxJava2.0（三）强大的操作符
m0_49508485的博客
09-22 823
上一节讲解了线程调度, 并且举了两个实际中的例子, 其中有一个登录的例子, 不知大家有没有想过这么一个问题, 如果是一个新用户, 必须先注册, 等注册成功之后再自动登录该怎么做呢.很明显, 这是一个嵌套的网络请求, 首先需要去请求注册, 待注册成功回调了再去请求登录的接口..subscribeOn(Schedulers.io()) //在IO线程进行网络请求.observeOn(AndroidSchedulers.mainThread()) //回到主线程去处理请求结果@Override。
从零学习RxJava2.0-功能性操作符
小黄人的博客
07-26 519
功能性操作符 辅助被观察者（Observable） 在发送事件时实现一些功能性需求 来张盗的图 来一一学习吧 订阅（连接被观察者 &amp; 观察者） subscribe 对于这个这里就不再说了，太熟悉了 线程调度（切换被观察者和观察者的线程） subscribeOn ， observeOn 代码 Observable.create(new Ob...
RxJava 之 操作符
魔法小黑屋
07-28 810
什么是RxJava 操作符？ 可以说，操作符是RxJava 最强大的武器 操作符一个重要的理念就是，使数据始终处于流上。 RxJava的操作符是干什么用的呢？ 简单理解，就是用于进行转换、结合、过滤和数学运算等操作的方法。看看之前的Demo看看我们是如何输出Hello
RxJava2.0的使用详解
weixin_40399313的博客
12-19 314
RxJava2.0的使用详解   1,初识RxJava RxJava就是一种用Java语言实现的响应式编程，来创建基于事件的异步程序 RxJava是一个基于事件订阅的异步执行的一个类库,目前比较火的一些技术框架！ 参考资料: Github上RxJava的项目地址: https://github.com/ReactiveX/RxJava 技术文档Api: http://reac
RxJava2.0简介（一）
WillScorpio
04-17 1535
本文参考：https://www.jianshu.com/p/464fa025229e 这个作者写的特别好。
RxJava之三——RxJava 2.0 全部操作符示例
薛瑄的博客
04-10 6483
转载请标明出处：http://blog.csdn.net/xx326664162/article/details/69945077 文章出自：薛瑄的博客关于RxJava，从表面上看起来很容易使用，但是如果理解不够深刻，使用过程中，往往会出现一些问题，所以我写了五篇文章，从入门到精通，从简单的使用到部分源码详解，希望能给读者一个质的飞跃： 1、RxJava之一——一次性学会使用RxJava RxJa
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值