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


评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值