RXJava入门04

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);                    }                });    }

1. 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);                    }                });    }