rxjava操作符

创建操作
Create、Defer、Empty/Never/Throw、From、Interval、Just、Range、Repeat、Start、Timer
变换操作
Buffer、FlatMap、GroupBy、Map、Scan、Window
过滤操作
Debounce、Distinct、ElementAt、Filter、First、IgnoreElements、Last、Sample、Skip、SkipLast、Take、TakeLast
组合操作
And/Then/When、CombineLatest、Join、Merge、StartWith、Switch、Zip
错误处理
Catch、Retry
辅助操作
Delay、Do、Materialize/Dematerialize、ObserveOn、Serialize、Subscribe、SubscribeOn、TimeInterval、TimeOut、Timestamp、Using
条件和布尔操作
All、Amb、Contains、DefaultIfEmpty、SequenceEqual、SkipUntil、SkipWhile、TakeUntil、TakeWhile
算数和集合操作
Average、Concat、Count、Max、Min、Reduce、Sum
转换操作
To
连接操作
Connect、Publish、RefCount、Replay
反压操作
用于增加特殊的流程控制策略的操作符
 

 

 

• takeUntil：使用一个标志Observable是否发射数据来判断，当标志Observable没有发射数据时，正常发射数据，而一旦标志Observable发射过了数据则后面的数据都会被丢弃。 

包含“示”即结束轮询

Observable.interval(0, 5, TimeUnit.SECONDS).flatMap(new Function<Long, ObservableSource<Content>>() {
            @Override
            public ObservableSource<Content> apply(@NonNull Long aLong) throws Exception {
                return EasyHttp.get("/ajax.php")
                        .baseUrl("http://fy.iciba.com")
                        .params("a", "fy")
                        .params("f", "auto")
                        .params("t", "auto")
                        .params("w", "hello world")
                        //采用代理
                        .execute(new CallClazzProxy<TestApiResult6<Content>, Content>(Content.class) {
                        });
            }
        }).takeUntil(new Predicate<Content>() {
            @Override
            public boolean test(@NonNull Content content) throws Exception {
                //如果条件满足，就会终止轮询，这里逻辑可以自己写
                //结果为true，说明满足条件了，就不在轮询了
                return content.getOut().contains("示");
            }
        }).subscribeWith(new BaseSubscriber<Content>() {
            @Override
            public void onError(ApiException e) {
                showToast(e.getMessage());
            }

            @Override
            public void onNext(@NonNull Content content) {
                showToast(content.toString());
            }
        });

}

• concat合并数据observale，有序

• interval周期性操作

  Observable.interval(2,1, TimeUnit.SECONDS)

• timer定时操作 

  Observable.timer(2, TimeUnit.SECONDS)

• fromIterable数据发送，将集合中的对象 / 数据发送出去

• fromArray  创建后就会将该数组转换成Observable & 发送该对象中的所有数据

• firstElement所发出的所有事件中，第一个有效时间即停止判断
  

• merge合并事件
  //merge和mergeDelayError都是合并，但是需要注意二者区别。
  //merge：合并的请求，如果有一个接口报错了，就立马报错，会终止整个流，另外的接口也不会请求。
  //mergeDelayError：合并的请求，如果有一个接口报错了，会延迟错误处理，后面的接口会继续执行没有被中断。

• skip跳过

• combineLatest联合判断

 /*
         * 步骤2：为每个EditText设置被观察者，用于发送监听事件
         * 说明：
         * 1. 此处采用了RxBinding，需要引入依赖：compile 'com.jakewharton.rxbinding2:rxbinding:2.0.0'
         * 2. 传入EditText控件，点击任1个EditText撰写时，都会发送数据事件 = Function3（）的返回值（下面会详细说明）
         * 3. 采用skip(1)原因：跳过 一开始EditText无任何输入时的空值
         **/
        Observable<CharSequence> nameObservable = RxTextView.textChanges(name).skip(1);
        Observable<CharSequence> ageObservable = RxTextView.textChanges(age).skip(1);
        Observable<CharSequence> jobObservable = RxTextView.textChanges(job).skip(1);

        /*
         * 步骤3：通过combineLatest（）合并事件 & 联合判断
         **/
        Observable.combineLatest(nameObservable,ageObservable,jobObservable,new Function3<CharSequence, CharSequence, CharSequence,Boolean>() {
            @Override
            public Boolean apply(@NonNull CharSequence charSequence, @NonNull CharSequence charSequence2, @NonNull CharSequence charSequence3) throws Exception {

                /*
                 * 步骤4：规定表单信息输入不能为空
                 **/
                // 1. 姓名信息
                boolean isUserNameValid = !TextUtils.isEmpty(name.getText()) ;
                // 除了设置为空，也可设置长度限制
                // boolean isUserNameValid = !TextUtils.isEmpty(name.getText()) && (name.getText().toString().length() > 2 && name.getText().toString().length() < 9);

                // 2. 年龄信息
                boolean isUserAgeValid = !TextUtils.isEmpty(age.getText());
                // 3. 职业信息
                boolean isUserJobValid = !TextUtils.isEmpty(job.getText()) ;

                /*
                 * 步骤5：返回信息 = 联合判断，即3个信息同时已填写，"提交按钮"才可点击
                 **/
                return isUserNameValid && isUserAgeValid && isUserJobValid;
            }

        }).subscribe(new Consumer<Boolean>() {
            @Override
            public void accept(Boolean s) throws Exception {
                /*
                 * 步骤6：返回结果 & 设置按钮可点击样式
                 **/
                Log.e(TAG, "提交按钮是否可点击： "+s);
                list.setEnabled(s);
            }
        });

• repeatWhen轮询

        // 步骤4：发送网络请求 & 通过repeatWhen（）进行轮询
                        observable.repeatWhen(new Function<Observable<Object>, ObservableSource<?>>() {
                            @Override
                            // 在Function函数中，必须对输入的 Observable<Object>进行处理，此处使用flatMap操作符接收上游的数据
                            public ObservableSource<?> apply(@NonNull Observable<Object> objectObservable) throws Exception {
                                // 将原始 Observable 停止发送事件的标识（Complete（） /  Error（））转换成1个 Object 类型数据传递给1个新被观察者（Observable）
                                // 以此决定是否重新订阅 & 发送原来的 Observable，即轮询
                                // 此处有2种情况：
                                // 1. 若返回1个Complete（） /  Error（）事件，则不重新订阅 & 发送原来的 Observable，即轮询结束
                                // 2. 若返回其余事件，则重新订阅 & 发送原来的 Observable，即继续轮询
                                return objectObservable.flatMap(new Function<Object, ObservableSource<?>>() {
                                    @Override
                                    public ObservableSource<?> apply(@NonNull Object throwable) throws Exception {

                                        // 加入判断条件：当轮询次数 = 5次后，就停止轮询
                                        if (i > 3) {
                                            // 此处选择发送onError事件以结束轮询，因为可触发下游观察者的onError（）方法回调
                                            return Observable.error(new Throwable("轮询结束"));
                                        }
                                        // 若轮询次数＜4次，则发送1Next事件以继续轮询
                                        // 注：此处加入了delay操作符，作用 = 延迟一段时间发送（此处设置 = 2s），以实现轮询间间隔设置
                                        return Observable.just(1).delay(2000, TimeUnit.MILLISECONDS);
                                    }
                                });

                            }
                        }).subscribeOn(Schedulers.io())               // 切换到IO线程进行网络请求
                                .observeOn(AndroidSchedulers.mainThread())  // 切换回到主线程 处理请求结果

• buffer

 Observable.just(1, 2, 3, 4, 5)
                .buffer(3)//一次发送三个；（1，2，3 ）（4，5）
                .buffer(3, 1) //一次发送三，步长为一；结果为（1，2，3）、（2，3，4）、（3，4，5）、（4，5）、（5）

• zip  实际效果是依次发送第一个observable1请求，等第一个请求完成后发送第二个observable2 的请求，并且都请求完成后进入最终处理阶段

Observable<sas.dad> homeCmsObservable = kwQueryHomeTab();

Observable<dad> abObservable = kwQueryAbTest();

return Observable.zip(homwqObservable, abObservable, new BiFunction<TabModel.eTabModel, AppRangeRespModel.ApeweContentModel, TabModel.wqbModel>() {
}

Distinct 过滤掉重复的数据项，只允许还没有发射过的数据项通过

Filter  只发射通过测试的数据

Observable.just(1, 2, 3, 4, 5)
          .filter(new Func1<Integer, Boolean>() {
              @Override
              public Boolean call(Integer item) {
                return( item < 4 );
              }
          }).subscribe(new Subscriber<Integer>() {
        @Override
        public void onNext(Integer item) {
            System.out.println("Next: " + item);
        }

        @Override
        public void onError(Throwable error) {
            System.err.println("Error: " + error.getMessage());
        }

        @Override
        public void onCompleted() {
            System.out.println("Sequence complete.");
        }
    });