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