RXJava入门04

最新推荐文章于 2021-10-28 18:26:42 发布
最新推荐文章于 2021-10-28 18:26:42 发布
阅读量324 收藏
点赞数
分类专栏： RXJava 文章标签： RXJava android RXJava的条件函数 数学计算 异常处理
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/piziliul/article/details/77621028
版权 

  1. RXJava的添加函数
    1. all判断所有元素是否满足某个条件,判断是否Observable发射的所有数据都满足某个条件,如果原始的Observable的任何一个数据不满足条件,都返回false
      private static ArrayList<Student> initStudents() {
        ArrayList<Student> persons = new ArrayList<>();
        persons.add(new Student("张三", 16));
        persons.add(new Student("李四", 21));
        persons.add(new Student("王⼆麻⼦", 18));
        return persons;
    }

    //all 判断所有元素是否满足某个条件
    public static void test1() {
        // 需求组建一个篮球队,条件:年龄必须小于等于20岁,判断是否所有学生都满足条件
        // 只要有一个不满足条件就返回flase
        Observable
                .from(initStudents())
                //all函数是用来判断所有的队列里面的元素是否满足某个条件 如果都满足则返回true 如果有一个不满足 就返回false
                .all(new Func1<Student, Boolean>() {
                    @Override
                    public Boolean call(Student student) {
                        return student.getAge() <= 20;
                    }
                })
                .subscribe(new Action1<Boolean>() {
                    @Override
                    public void call(Boolean flag) {
                        Log.e("TAG", "call: " + flag);
                    }
                });
    }

    2. amb抢占式发送数据,给定两个或多个Observable,它只发射首先发射数据或通知的那个Observable的所有数据amb将忽略丢弃替他所有的Observable的发射数据
      // amb抢占式发送数据 ,只要抢占成功,后面的就会被忽略掉
    public static void test2() {
        //1.创建A被观察者
        Observable<String> aOvservable = Observable.just("A同学举手了", "A同学回答了问题");
        //2.创建B被观察者
        Observable<String> bOvservable = Observable.just("B同学举手了", "B同学回答了问题");
        //3.最后被订阅的被观察者
        //amb会发送那个先发送数据的被观察者里面的所有数据  后面的被观察者发送的数据会被忽略掉
        //抢占资源 只要抢占成功 后面的资源就由该成功的对象来处理
        //amb(...)里面可以存放多个被观察者,供处理
        Observable<String> ambObservable = Observable.amb(aOvservable, bOvservable);

        ambObservable.subscribe(new Action1<String>() {
            @Override
            public void call(String s) {
                Log.e("TAG", "call: " + s);
            }
        });

    }
    3. contains判断是否存在某个元素,给contains传一个指定的数据,如果原始Observable发射了这个数据,它返回的Observable将发射true,否则false
       // contains判断是否存在某个元素
    //contains 判断被观察者发射的数据,是否含有某一个数据,如果有,返回true,否则返回false
    public static void test3() {
        Observable<Integer> observable = Observable.just(1, 2, 3, 4);
        //相当于判断一个队列里面是否存在某个元素
        Observable<Boolean> booleanObservable = observable.contains(5);
        booleanObservable.subscribe(new Action1<Boolean>() {
            @Override
            public void call(Boolean aBoolean) {
                Log.e("TAG", "call: " + aBoolean);
            }
        });
    }
    4. defaultIfEmpty默认发送某个数据,将原始Observable,没有发射任何数据正常终止(以onCompleted的形式),DefaultlfEmpty返回的Observable就发射一个提供的默认值
      public static void test4() {
        //需求：从网络上读取一个字符串 如果找不到该字符串 则返回一个默认的值
        Observable
                .create(new Observable.OnSubscribe<String>() {
                    @Override
                    public void call(Subscriber<? super String> subscriber) {
                        //总结：如果被观察者有发送数据 则观察者直接接收数据
                        //如果被观察者不发送数据 而直接调用onCompleted方法 系统会自动使用defaultIfEmpty里面的默认值
                        String result = "从网络下读取的字符串";
                        //subscriber.onNext(result);
                        subscriber.onCompleted();
                    }
                })
                .defaultIfEmpty("显示默认的值")
                .subscribe(new Action1<String>() {
                    @Override
                    public void call(String s) {
                        Log.e("TAG", "call: " + s);
                    }
                });
    }
    5. SequenceEqual判断发送的数据是否相同,判定两个Observables是否发射相同的数据序列列,它会⽐比较两个Observable的发射物，如果两个序列列是相同的 （相同的数据，相同的顺序，相同的终⽌止状态），它就发射true，否则发射false。
      // SequenceEqual判断发送的数据是否相同
    public static void test5() {
        //1.创建两个被观察者对象
        Observable<Integer> o1 = Observable.just(1, 2, 3, 4);//网络的数据
        Observable<Integer> o2 = Observable.just(1, 2, 4, 3);//数据库中的数据
        //2.使用sequenceEqual函数  传入的参数的顺序无所谓
        Observable<Boolean> booleanObservable = Observable.sequenceEqual(o1, o2);
        //如果发送的元素稍微有点不同 或者说顺序不一样   那就会返回false
        booleanObservable.subscribe(new Action1<Boolean>() {
            @Override
            public void call(Boolean aBoolean) {
                Log.e("TAG", "test5 call: " + aBoolean);
            }
        });
    6. skipWhile,忽略略被观察者发射的数据，直到你指定的条件不不成⽴立的那⼀一刻，它开始发射后⾯面的数据。
      // skipWhile 直到条件为false的时候才会接收数据,包括后面的数据全部接受
    public static void test6() {
        Observable
                .just(1, 2, 3, 4, 5, 6)
                .skipWhile(new Func1<Integer, Boolean>() {
                    //skip=跳过
                    // 跳过发送的每一个数据  直到条件为false才开始让观察者接收发送过来的数据
                    @Override
                    public Boolean call(Integer value) {
                        return value != 4;
                    }
                })
                .subscribe(new Action1<Integer>() {
                    @Override
                    public void call(Integer integer) {
                        Log.e("TAG", "test6 call: " + integer);
                    }
                });
    }
    7. takeWhile,直到你指定的条件不不成⽴立的那⼀一刻，它停⽌止发射原始Observable。
      // takeWhile 表示当条件为false时候停止接收数据
    public static void test7() {
        Observable
                .just(1, 2, 3, 4, 5, 6)
                .takeWhile(new Func1<Integer, Boolean>() {
                    //take=取 拿
                    // 接收每一个数据  直到条件为false才开始停止让观察者接收发送过来的数据
                    @Override
                    public Boolean call(Integer value) {
                        return value != 4;
                    }
                })
                .subscribe(new Action1<Integer>() {
                    @Override
                    public void call(Integer integer) {
                        Log.e("TAG", "test7 call: " + integer);
                    }
                });
    }
  2. RXJava的数学计算

关于数学的计算，这里RxJava提供了一个依赖包,其开发包提供了了⼀一个核⼼心帮助类：MathObservable

    1. Average求平均数
      ic class MathDemo {
    //averageInteger 求平均值
    public static void test1() {
        Observable<Integer> integerObservable = Observable.just(1, 2, 3, 4, 5, 6);
        Observable<Integer> integerObservable1 = MathObservable.averageInteger(integerObservable);

        integerObservable1.subscribe(new Action1<Integer>() {
            @Override
            public void call(Integer integer) {
                Log.e("TAG", "test1 call: " + integer);
            }
        });
    }
    2. Max/Min求最大最小值
      // 求 最大值和最小值
    public static void test2() {
        Observable<Integer> integerObservable = Observable.just(1, 2, 3, 4, 5, 6);
        MathObservable
                //.max(integerObservable)//求数据的最大值
                .min(integerObservable)//求数据的最小值
                .subscribe(new Action1<Integer>() {
                    @Override
                    public void call(Integer integer) {
                        Log.e("TAG", "test2 call: " + integer);
                    }
                });
    }
    3. Count求数据个数
       // 求数据个数
    public static void test3() {
        Observable<Integer> integerObservable = Observable.just(1, 2, 3, 4, 5, 6);
        //需求：知道到底发送了多少个数据
        Observable<Integer> countObservable = integerObservable.count();
        countObservable.subscribe(new Action1<Integer>() {
            @Override
            public void call(Integer integer) {
                Log.e("TAG", "test3 call: "+integer);
            }
        });
    }
    4. Sum计算队列内数据总和
       // 求总和
    public static void test4() {
        Observable<Integer> integerObservable = Observable.just(1, 2, 3, 4, 5, 6);
        MathObservable
                .sumInteger(integerObservable)//求发送数据的总和
                .subscribe(new Action1<Integer>() {
                    @Override
                    public void call(Integer integer) {
                        Log.e("TAG", "test4 call: "+integer);
                    }
                });
    }
  2. RXJava的异常处理  : 很多操作符可用于对Observable发射的onError通知做出响应或者从错误中恢复 Catch操作符拦截原始Observable的onError通知，将它替换为其它的数据项或数据序列列，让产生的 Observable能够正常终止或者根本不终止
    1. RxJava异常捕获的三种方式
      1. onErrorReturn,，只要有异常发送，onErrorReturn()就会被调用
        //onErrorReturn onErrorReturn方法返回⼀个镜像原有Observable⾏为的新Observable，
    // 后者会忽略前者的onError调用，不会将错误传递给观察者，作为替代，
    // 它会发射⼀个特殊的项并调⽤用观察者的onCompleted⽅方法。
    public static void test1() {
        Observable
                .create(new Observable.OnSubscribe<Integer>() {
                    @Override
                    public void call(Subscriber<? super Integer> subscriber) {
                        subscriber.onNext(1);
                        subscriber.onNext(2);
                        //有可能是你的代码出现了空指针的异常  在这里我们也可以模拟的异常
                        subscriber.onError(new NullPointerException("mock nullPoint Exception !"));
                        subscriber.onNext(3);
                        subscriber.onCompleted();
                    }
                })
                //onErrorReturn 他就是用来捕获异常 并且返回一个默认的值
                .onErrorReturn(new Func1<Throwable, Integer>() {
                    @Override
                    public Integer call(Throwable throwable) {
                        Log.e("TAG", "call: " + throwable.getLocalizedMessage());
                        return 666;
                    }
                })
                .subscribe(new Action1<Integer>() {
                    @Override
                    public void call(Integer integer) {
                        Log.e("TAG", "call: " + integer);
                    }
                });
    }
      2. onErrorResumeNext
        public static void test2() {
        Observable
                .create(new Observable.OnSubscribe<Integer>() {
                    @Override
                    public void call(Subscriber<? super Integer> subscriber) {
                        subscriber.onNext(1);
                        subscriber.onNext(2);
                        //有可能是你的代码出现了空指针的异常  在这里我们也可以模拟的异常
                        subscriber.onError(new NullPointerException("mock nullPoint Exception !"));
                        //只要抛出了异常 后面的代码都不会执行的
                        subscriber.onNext(3);
                        subscriber.onCompleted();
                    }
                })
                //只要有异常 onErrorResumeNext就会被调用 该方法返回的被观察者就会重新订阅到下面的Action1并打印出对应的数据
                .onErrorResumeNext(Observable.just(666))
                .subscribe(new Action1<Integer>() {
                    @Override
                    public void call(Integer integer) {
                        Log.e("TAG", "call: " + integer);
                    }
                });
    }
      3. onExceptionResumeNext
        public static void test3() {
        Observable
                .create(new Observable.OnSubscribe<Integer>() {
                    @Override
                    public void call(Subscriber<? super Integer> subscriber) {
                        subscriber.onNext(1);
                        subscriber.onNext(2);
                        //有可能是你的代码出现了空指针的异常  在这里我们也可以模拟的异常
                        subscriber.onError(new NullPointerException("mock nullPoint Exception !"));
                        //只要抛出了异常 后面的代码都不会执行的
                        subscriber.onNext(3);
                        subscriber.onCompleted();
                    }
                })
                //onExceptionResumeNext 跟 onErrorResumeNext效果是一样 都是返回一个新的被观察者对象并订阅到观察者
                .onExceptionResumeNext(Observable.just(2333))
                .subscribe(new Action1<Integer>() {
                    @Override
                    public void call(Integer integer) {
                        Log.e("TAG", "call: " + integer);
                    }
                });
    }
    2. Retry重试机制
       // retry 重试机制
    public static void test4() {
        Observable
                .create(new Observable.OnSubscribe<Integer>() {
                    @Override
                    public void call(Subscriber<? super Integer> subscriber) {
                        subscriber.onNext(1);
                        subscriber.onNext(2);
                        //假如此刻 网络请求的读写超时 并抛出了一个异常
                        subscriber.onError(new NullPointerException("mock nullPoint Exception !"));
                        //只要抛出了异常 后面的代码都不会执行的
                        subscriber.onNext(3);
                        subscriber.onCompleted();
                    }
                })
                //.retry()//无限的尝试 直到不会发生异常为止
                .retry(3)//最大的操作次数n+1 如果n+1次后还失败 则直接抛出异常
                .onErrorReturn(new Func1<Throwable, Integer>() {
                    @Override
                    public Integer call(Throwable throwable) {
                        return 666;
                    }
                })
                .subscribe(new Action1<Integer>() {
                    @Override
                    public void call(Integer integer) {
                        Log.e("TAG", "call: " + integer);
                    }
                });
    }


piziliul
关注
专栏目录
Android DataBinding 笔记二
ItsFated的博客
04-01 511
这篇用来介绍可被观察的数据，用来实现界面当数据改变时自动更新。 可被观察的数据 参考官网：使用可观察的数据对象。基础的可被观察的数据： ObservableBoolean ObservableChar ObservableShort 等等……都是继承自androidx.databinding.BaseObservable，看下核心源码： public class BaseObservable implements Observable { private transient PropertyCh
RxJava 入门详解
一名互联网时代苟且偷生的 Android码农
05-13 482
RxJava——入门篇一、ReactiveX简介二、RxJava的使用1、RxJava的优势2、RxJava的配置三、RxJava的不完整回调1、不完整回调的代码示例2、不完整回调的原理分析四、RxJava的线程切换1、Scheduler线程调度器2、线程控制五、总结 一、ReactiveX简介 在学习RxJava前首先需要了解ReactiveX，因为RxJava是ReactiveX的一种Java的实现形式。 ReactiveX的官网地址为：ReactiveX的官网 ReactiveX官网对于自身的介绍是：
关于rxjava联合判断
qq_34250126的博客
02-12 604
近两年大火的rxjava有无数大神研究，其中就有一篇是rxjava联合判断。但是我认为rxjava联合判断毫无用处。首先，贴出代码。name = (EditText) findViewById(R.id.name); age = (EditText) findViewById(R.id.age); job = (EditText) findViewById(R.id.job); list = (B...
RxJava的布尔操作符实例
Hoist the Colours! Our world is wide!
11-02 900
布尔操作符我们可以使用布尔操作符，对源数据Observable发送的数据进行变换或者是直接的布尔操作，来达到一些目的。all 操作符Observable<Boolean> all(Func1<? super T, Boolean> predicate)用于判断Observable的所有数据是否满足某一个条件 例如： Observable.range(10,3).all(new Func1<Inte
Android WebSocket原理及实战（二）
diaostar的博客
10-28 3516
上期原理篇我们讲到了WebSocket和HTTP的区别及其优缺点，这期主要是实战部分，大多数Android项目不需要使用第三方重量级的WebSocket框架，所以我以OKHttp3.0自带的WebSocket为例，来进行讲解 添加依赖 implementation "com.squareup.okhttp3:okhttp:4.9.0" 实现步骤 构建OkHttpClient配置初始化一些参数。 使用WebSocket的Url地址连接。 设置WebSocket的连接状态回..
Android从零开始学习Rxjava2（九）—— 条件和布尔运算符
DYJALY的专栏
11-12 266
条件和布尔运算符 评估Observables发出的一个或多个Observable或项目的运算符。 All 确定Observable发出的所有项目是否符合某些标准。 当且仅当源Observable正常终止并且源Observable发出的每个项根据都test计算为true时才返回true; 如果源Observable发出的任何项test计算为false，则返回false。 举个例子： private...
RxJava入门之介绍与基本运用
01-20
RxJava入门之介绍与基本运用 RxJava是一个在Java虚拟机(JVM)上运行的库，它采用响应式编程范式来处理异步和基于事件的程序。响应式编程是一种编程模型，它允许程序员以声明式的方式处理数据流和变换，使得代码能够...
essentials中文 - rxjava 入门书籍推荐
02-05
在本文中，我们将深入探讨 RxJava 的基础知识，以及如何通过入门书籍来学习这一强大的工具。 首先，我们要理解什么是反应式编程。这是一种编程范式，它将数据流和变换视为计算的核心。RxJava 将事件、数据或任何...
RxJava入门教程
09-30
上个月RxJava2正式版发布了，但目前国内的资料还比较少，以前使用过RxJava1只需要看看更新文档就知道怎么使用了，但还有一些以前没用过RxJava的朋友可能就不...所以写下这个教程， 帮助那些没有用过RxJava的朋友入门。
Android DataBinding学习和实践（二）
shuaibiaoshishen的博客
09-24 395
书承上文，这次我们来探究一下DataBinding中控件事件的绑定和可观察对象的使用。 目录 一、自定义DataBinding生成类名以及import的使用 1、自定义DataBinding生成类名 2、import的使用 二、DataBinding中控件事件绑定 三、Observable Data Object（可观察数据对象） 1、Observable Field 2、Obserable Collections 3、Obserable Object 一、自定义DataBinding生
java后台传一个对象到前台_前台判断对象中的一个布尔值,java – 将两个可观察到的布尔值与ObservableBoolean或Observable组合在一起...
weixin_42512836的博客
03-15 452
在JavaFX中,您可以执行以下操作来组合两个可观察的布尔值：BooleanProperty imagesDownloaded = new SimpleBooleanProperty(false);BooleanProperty animationComplete = new SimpleBooleanProperty(false);BooleanBinding isValid = imagesD...
RxJava----操作符：条件和布尔操作符
qq_20198405的博客
04-27 1561
all all 函数用来判断 observable 中发射的所有数据是否都满足一个条件。 public final Observable<java.lang.Boolean> all(Func1<? super T,java.lang.Boolean> predicate)满足条件 Observable<Integer> values = Observable.create(new O
Observable常用知识点整理
^@Hu@^的博客
10-14 2306
Observable ###基础 概述 一个观察者订阅(Observer)一个可观察对象(Observable)。观察者对观察对象发射的数据或数据序列做出响应 普通方法调用流程 调用某方法 用变量保存方法保存结果 使用变量新值继续操作 代码表示为 // make the call, assign its return value to `returnVal` returnVal =...
RxJava之条件和布尔操作符
行云间
09-06 4915
在RxJava中，条件和布尔操作符作用于Observable中数据源，比如数据源中的数据是否满足某种条件，或者 数据源是否为空，又或者数据源为空时如何发射备份数据。在过滤操作符 曾了解take、skip操作符的使用，我们是否为它们设定一定的执行的条件呢？all流程图概述all操作符判定原Observable发射的所有数据是否全部满足满足某个条件。all操作符接收一个函数参数，创建并返回一个单布尔值的
Rxjava2 Observable的布尔操作符详解及实例
JiangMing-JIM的博客
12-30 573
文章目录简要：1. All2. Contains3. IsEmpty4. SequenceEqual小结 简要： 需求了解： 在 Rxjava 的众多操作符中，有数据变换、过滤等，但是有的时候是不是有一些判断的操作呢？比如判断一个 Observable 的所有数据是否满足一个指定的条件，判断某个 Observable 是否会发射一个指定的值等等的判断操作，答案是肯定的，Rxjava 中提供了一系列...
Java Observable 模式
陈小果的轨迹
10-01 1298
一、Observer模式的意图：                在对象的内部状态发生变化时，自动通知外部对象进行响应。        二、Observer模式的构成：               ·被观察者：内部状态有可能被改变，而且又需要通知外部的对象               ·观察者：需要对内部状态的改变做出响应的对象        三、Observer模式的Java实现：                Java的API中已经为我们提供了Observer模式的实现。具体由java.util.Obse
安卓DataBinding (三) Observable
风之子磊的博客
09-17 3363
Android DataBinding (一) 基本用法 Android DataBinding (二) 事件处理  Android DataBinding (三) Observable (本文) Android DataBinding (四) 自定义属性 Android DataBinding (五) 自定义 View 的双向绑定 Android DataBinding (六) EditText...
RxJava操作符（七）Conditional and Boolean
lizubing1992的专栏
05-05 671
在这篇文章里我们来了解一下条件和布尔操作符。 一、All/Amb All操作符根据一个函数对源Observable发射的所有数据进行判断，最终返回的结果就是这个判断结果。这个函数使用发射的数据作为参数，内部判断所有的数据是否满足我们定义好的判断条件，如果全部都满足则返回true，否则就返回false。 Amb操作符可以将至多9个Observable结合起来，让他们竞争。哪个Obser
Android Data Binding高级用法-Observable、动态生成Binding Class（三）
热门推荐
【博客地址迁移到】：https://zhengxiaoyong.com
08-06 1万+
设置View的id虽然说Data Binding这种分层模式使得我们对数据的传递简单明了，一般情况下我们可以不设置View的id，不使用findViewById即可对View进行数据上一系列的操作，不过有时候根据情况我们需要对某些View设置id，但是还是可以不findViewById即可得到该控件的对象，因为设置id后ViewDataBinding类会自动生成对应的控件对象，如：<layout x
RxJava入门精要
"RxJava Essentials 是一本适合RxJava初学者的英文书籍，由Ivan Morgillo撰写，并已有了中文版的翻译。这本书主要涵盖了RxJava的核心概念和实践应用。" RxJava是Java平台上的一个库，它引入了反应式编程的概念，这...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值