Rxjava的操作符（2）------组合操作符和过滤操作符

最新推荐文章于 2021-05-28 22:31:24 发布
最新推荐文章于 2021-05-28 22:31:24 发布
阅读量199 收藏
点赞数
分类专栏： Android的进阶知识 文章标签： java android
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/LY010106/article/details/116708718
版权

Rxjava的组合操作符和过滤操作符

Rxjava的组合操作符

组合操作符的作用

创建被观察者对象发送事件

组合多个被观察者

1. concat（）/concatArray（）

  • 作用：将多个被观察者组合在一个发送数据，合并后按顺序串行执行
  • 两者的区别：concat（）组合被观察者数量≤4个，而concatArray（）则可＞4个

原理图：

这里写图片描述

代码示例：

Observable.concat(Observable.just(1, 2, 3),
                Observable.just("z", "x", "c")
        ).subscribe(new Observer() {
            @Override
            public void onSubscribe(Disposable d) {
                Log.d(TAG, "onSubscribe: ");
            }

            @Override
            public void onNext(Object value) {

                Log.d(TAG, "onNext: "+value);
            }

            @Override
            public void onError(Throwable e) {
                Log.d(TAG, "onError: ");
            }

            @Override
            public void onComplete() {
                Log.d(TAG, "onComplete: ");
            }
        });
    }

2. merge（）/mergeArray（）

  • 作用：将多个被观察者组合在一起发送数据，合并后按时间线并行执行

  • 两者的区别：merge（）组合被观察者数量≤4个，而mergeArray（）则可＞4个

  • merge（）为时间并行执行，而concat（）是按照发送顺序串行执行

原理图：

img

代码示例：

Observable.concat( Observable.intervalRange(0, 3, 1, 1, TimeUnit.SECONDS), // 从0开始发送、共发送3个数据、第1次事件延迟发送时间 = 1s、间隔时间 = 1s
                Observable.intervalRange(2, 3, 1, 1, TimeUnit.SECONDS) // 从2开始发送、共发送3个数据、第1次事件延迟发送时间 = 1s、间隔时间 = 1s
        ).subscribe(new Observer<Long>() {
            @Override
            public void onSubscribe(Disposable d) {
                Log.d(TAG, "onSubscribe: ");
            }

            @Override
            public void onNext(Long value) {

                Log.d(TAG, "onNext: "+value);
            }

            @Override
            public void onError(Throwable e) {
                Log.d(TAG, "onError: ");
            }

            @Override
            public void onComplete() {
                Log.d(TAG, "onComplete: ");
            }
        });

在这里插入图片描述

3. concatDelayError（）/mergeDelayError（）

  • 作用：在concat和merge的相关方法中，如果其中一个被观察者发送了Error事件，那么就会停止发送事件。如果我们想把所有的正常事件都发送完成之后再发送Error事件的话，我们就可以使用mergeArrayDelayError()和concatArrayDelayError()

代码示例：

不使用concatDelayError（）的情况：

Observable.concat(
                Observable.create(new ObservableOnSubscribe<Integer>() {
                    @Override
                    public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
                        emitter.onNext(1);
                        emitter.onNext(2);
                        emitter.onNext(3);
                        emitter.onError(new NullPointerException()); // 发送Error事件，因为无使用concatDelayError，所以第2个Observable将不会发送事件 emitter.onComplete();
                    }
                }),

                Observable.just(4, 5, 6))
                .subscribe(new Observer<Integer>() {
                    @Override
                    public void onSubscribe(Disposable d) {
                        Log.d(TAG, "onSubscribe: ");
                    }

                    @Override
                    public void onNext(Integer value) {

                        Log.d(TAG, "onNext: " + value);
                    }

                    @Override
                    public void onError(Throwable e) {
                        Log.d(TAG, "onError: ");
                    }

                    @Override
                    public void onComplete() {
                        Log.d(TAG, "onComplete: ");
                    }
                });

在这里插入图片描述

使用concatDelayError（）：

Observable.concatArrayDelayError(
                Observable.create(new ObservableOnSubscribe<Integer>() {
                    @Override
                    public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
                        emitter.onNext(1);
                        emitter.onNext(2);
                        emitter.onNext(3);
                        emitter.onError(new NullPointerException()); // 发送Error事件，因为无使用concatDelayError，所以第2个Observable将不会发送事件 emitter.onComplete();
                    }
                }),

                Observable.just(4, 5, 6))
                .subscribe(new Observer<Integer>() {
                    @Override
                    public void onSubscribe(Disposable d) {
                        Log.d(TAG, "onSubscribe: ");
                    }

                    @Override
                    public void onNext(Integer value) {

                        Log.d(TAG, "onNext: " + value);
                    }

                    @Override
                    public void onError(Throwable e) {
                        Log.d(TAG, "onError: ");
                    }

                    @Override
                    public void onComplete() {
                        Log.d(TAG, "onComplete: ");
                    }
                });

在这里插入图片描述

合并多个事件

1. zip（）

  • 作用：合并两个Observable发射的事件，根据BiFunction函数生成一个新的值发射出去。当其中一个Observable发送数据结束或者出现异常后，另一个Observable也将停止发送数据。也就是说正常情况下，发送的数据长度会与两个Observable中最少事件的数量一样。

代码示例：

Observable.zip(
                Observable.just("a", "b", "c"),
                Observable.just(1, 2, 3),
                new BiFunction<String, Integer, String>() {

                    @Override
                    public String apply(String s, Integer integer) throws Exception {
                        return s + integer;
                    }
                }).subscribe(new Observer<String>() {
                    @Override
                    public void onSubscribe(Disposable d) {
                        Log.d(TAG, "onSubscribe: ");
                    }

                    @Override
                    public void onNext(String value) {

                        Log.d(TAG, "onNext: " + value);
                    }

                    @Override
                    public void onError(Throwable e) {
                        Log.d(TAG, "onError: ");
                    }

                    @Override
                    public void onComplete() {
                        Log.d(TAG, "onComplete: ");
                    }
                });

在这里插入图片描述

2. combineLatest（）

  • 作用：当两个Observables中的任何一个发送了数据后，将先发送了数据的Observables 的最后一个数据 与 另外一个Observable发送的每个数据结合，最终基于该函数的结果发送数据。
  • 与Zip（）的区别：Zip（） = 按个数合并，即1对1合并；CombineLatest（） = 按时间合并，即在同一个时间点上合并。

代码示例如下：

Observable.combineLatest(
                Observable.just("a", "b", "c"),
                Observable.intervalRange(0, 3, 1, 1, TimeUnit.SECONDS), // 第2个发送数据事件的Observable：从0开始发送、共发送3个数据、第1次事件延迟发送时间 = 1s、间隔时间 = 1s
                new BiFunction<String, Long, String>() {

                    @Override
                    public String apply(String s, Long l) throws Exception {
                        return s + l;
                    }
                }).subscribe(new Observer<String>() {
                    @Override
                    public void onSubscribe(Disposable d) {
                        Log.d(TAG, "onSubscribe: ");
                    }

                    @Override
                    public void onNext(String value) {

                        Log.d(TAG, "onNext: " + value);
                    }

                    @Override
                    public void onError(Throwable e) {
                        Log.d(TAG, "onError: ");
                    }

                    @Override
                    public void onComplete() {
                        Log.d(TAG, "onComplete: ");
                    }
                });

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Z86vLdgV-在这里插入图片描述

3. combineLatestDelayError（）

  • 作用类似于concatDelayError（） / mergeDelayError（）

4. reduce（）

  • 把被观察者需要发送的事件聚合成1个事件发送
  • 聚合的逻辑要求自己撰写，但是本质就是前两个数据聚合然后与后一个数据继续进行聚合，以此类推。

具体使用： 1+2+3+4+5

Observable.just(1,2,3,4,5).reduce(new BiFunction<Integer, Integer, Integer>() {
            @Override
            public Integer apply(Integer integer, Integer integer2) throws Exception {
                return integer + integer2;
            }
        }).subscribe(new Consumer<Integer>() {
            @Override
            public void accept(Integer integer) throws Exception {
                Log.d("TAG", "accept: "+integer);
            }
        });

在这里插入图片描述

5. collect（）

  • 将被观察者Observable发送的数据事件收集到一个数据结构里。

代码示例：

Observable.just("1","2","3","2")
                .collect(new Callable<List<Integer>>() { //创建数据结构
                    @Override
                    public List<Integer> call() throws Exception {
                        return new ArrayList<Integer>();
                    }
                }, new BiConsumer<List<Integer>, String>() {//收集器
                    @Override
                    public void accept(List<Integer> integers, String s) throws Exception {
                        integers.add(Integer.valueOf(s));
                    }
                }).subscribe(new Consumer<List<Integer>>() {
            		@Override
            		public void accept(List<Integer> integers) throws Exception {
                		Log.e("---",integers+"");
            		}
        		});

发送事件前追加发送事件

1. startWith（）/startWithArray（）

  • 作用：在一个被观察者发送事件前，追加发送一些数据/或者一个新的被观察者
  • 区别：startWith’（）为追加一个数据，startWithArray（）为追加多个数据
Observable.just(1, 2, 3)
                .startWith(0)  // 追加单个数据 = startWith()
                .startWithArray(1, 2, 3) // 追加多个数据 = startWithArray()
                .subscribe(new Observer<Integer>() {
                    @Override
                    public void onSubscribe(Disposable d) {
                        Log.d(TAG, "onSubscribe: ");
                    }

                    @Override
                    public void onNext(Integer value) {
                        Log.d(TAG, "onNext: " + value);
                    }

                    @Override
                    public void onError(Throwable e) {
                    }

                    @Override
                    public void onComplete() {
                        Log.d(TAG, "onComplete: ");
                    }
                });


        Observable.just(1, 2, 3).
                startWith(Observable.just(4, 5, 6)).
                subscribe(new Observer<Integer>() {
                    @Override
                    public void onSubscribe(Disposable d) {
                        Log.d(TAG, "onSubscribe: ");
                    }

                    @Override
                    public void onNext(Integer value) {
                        Log.d(TAG, "onNext: " + value);
                    }

                    @Override
                    public void onError(Throwable e) {
                    }

                    @Override
                    public void onComplete() {
                        Log.d(TAG, "onComplete: ");
                    }
                });

统计发送事件的数量

1. count（）

  • 统计被观察者发送事件的数量

代码示例：

Observable.just(1, 2, 3)
                .count()
                .subscribe(new Consumer<Long>() {
                    @Override
                    public void accept(Long aLong) throws Exception {
                        Log.e(TAG, "发送的事件数量 =  " + aLong);

                    }
                });

在这里插入图片描述

Rxjava的过滤操作符

  • 作用：Rxjava的过滤操作符常用来筛选/过滤被观察者发送的事件也可以说是观察者接收的事件。

根据指定事件条件来过滤事件

1. filter（）

  • 作用：通过一定逻辑来过滤被观察者发送的事件，如果返回true则发送事件，否则不会发送。
  • 应用场景：筛选符合要求的事件。

原理图：

这里写图片描述

代码示例：发送1—5中对三取余为1的数字

Observable.just(1,2,3,4,5).filter(new Predicate<Integer>() {
            @Override
            public boolean test(Integer integer) throws Exception {
                return integer % 3 == 1;
            }
        }).subscribe(new Observer<Integer>() {
            @Override
            public void onSubscribe(Disposable d) {
                Log.d(TAG, "onSubscribe: ");
            }

            @Override
            public void onNext(Integer integer) {
                Log.d(TAG, "onNext: "+integer);
            }

            @Override
            public void onError(Throwable e) {
                Log.d(TAG, "onError: ");
            }

            @Override
            public void onComplete() {
                Log.d(TAG, "onComplete: ");
            }
        });

2. ofType（）

  • 作用：ofType（）是filter操作符的一个特殊形式，他过滤一个被观察者只返回指定类型的数据。比如说发送1和”1“，就可以过滤String类型或者Integer类型。

原理图：

这里写图片描述

具体使用：

Observable.just(1, 2, "hello", "world")
                .ofType(Integer.class)
                .subscribe(new Observer<Integer>() {
                    @Override
                    public void onSubscribe(Disposable d) {
                        Log.d(TAG, "onSubscribe: ");
                    }

                    @Override
                    public void onNext(Integer integer) {
                        Log.d(TAG, "onNext: " + integer);
                    }

                    @Override
                    public void onError(Throwable e) {
                        Log.d(TAG, "onError: ");
                    }

                    @Override
                    public void onComplete() {
                        Log.d(TAG, "onComplete: ");
                    }
                });

skip（）和skipLast（）

  • skip（）作用：忽略Observable发射的前n项数据，只保留之后的数据。
  • skipLast（）作用：从结尾往前数跳过指定数量的事件。
  • 区别就是一个跳前面一个跳后面。

原理图：

这里写图片描述

代码示例：

 Observable.just(1, 2, 3,4)
                .skip(2)
                .subscribe(new Observer<Integer>() {
                    @Override
                    public void onSubscribe(Disposable d) {
                        Log.d(TAG, "onSubscribe: ");
                    }

                    @Override
                    public void onNext(Integer integer) {
                        Log.d(TAG, "onNext: " + integer);
                    }

                    @Override
                    public void onError(Throwable e) {
                        Log.d(TAG, "onError: ");
                    }

                    @Override
                    public void onComplete() {
                        Log.d(TAG, "onComplete: ");
                    }
                });



Observable.just(1, 2, 3,4)
                .skipLast(2)
                .subscribe(new Observer<Integer>() {
                    @Override
                    public void onSubscribe(Disposable d) {
                        Log.d(TAG, "onSubscribe: ");
                    }

                    @Override
                    public void onNext(Integer integer) {
                        Log.d(TAG, "onNext: " + integer);
                    }

                    @Override
                    public void onError(Throwable e) {
                        Log.d(TAG, "onError: ");
                    }

                    @Override
                    public void onComplete() {
                        Log.d(TAG, "onComplete: ");
                    }
                });

distinct（）/distinctUntilChanged（）

  • 作用：过滤被观察者发送事件序列中的重复的事件。
  • 区别是：distinct（）方法过滤重复的事件，而distinctUntilChanged（）过滤连续重复的事件。

原理图：

这里写图片描述

这里写图片描述

具体使用：

// 使用1：过滤事件序列中重复的事件
        Observable.just(1, 2, 3,4,1,2,1)
                .distinct()
                .subscribe(new Observer<Integer>() {
                    @Override
                    public void onSubscribe(Disposable d) {
                        Log.d(TAG, "onSubscribe: ");
                    }

                    @Override
                    public void onNext(Integer integer) {
                        Log.d(TAG, "onNext: " + integer);
                    }

                    @Override
                    public void onError(Throwable e) {
                        Log.d(TAG, "onError: ");
                    }

                    @Override
                    public void onComplete() {
                        Log.d(TAG, "onComplete: ");
                    }
                });


        //使用2：过滤事件序列中 连续重复的事件
        // 下面序列中，连续重复的事件 = 3、4
        Observable.just(1,2,3,1,2,3,3,4,4 )
                .distinctUntilChanged()
                .subscribe(new Observer<Integer>() {
                    @Override
                    public void onSubscribe(Disposable d) {
                        Log.d(TAG, "onSubscribe: ");
                    }

                    @Override
                    public void onNext(Integer integer) {
                        Log.d(TAG, "onNext: " + integer);
                    }

                    @Override
                    public void onError(Throwable e) {
                        Log.d(TAG, "onError: ");
                    }

                    @Override
                    public void onComplete() {
                        Log.d(TAG, "onComplete: ");
                    }
                });

根据指定事件数量过滤事件

需求场景：通过设置指定的事件数量，仅发送特定数量的事件

1. take（）

  • 作用：只发送前面的N项数据

原理图：

这里写图片描述

代码示例：

        Observable.just(1, 2, 3,4,1,2,1)
                .take(4)
                .subscribe(new Observer<Integer>() {
                    @Override
                    public void onSubscribe(Disposable d) {
                        Log.d(TAG, "onSubscribe: ");
                    }

                    @Override
                    public void onNext(Integer integer) {
                        Log.d(TAG, "onNext: " + integer);
                    }

                    @Override
                    public void onError(Throwable e) {
                        Log.d(TAG, "onError: ");
                    }

                    @Override
                    public void onComplete() {
                        Log.d(TAG, "onComplete: ");
                    }
                });

2. takeLast（）

  • 作用：发射被观察者后面的N项数据

原理图：

这里写图片描述

代码示例：

Observable.just(1, 2, 3,4,1,2,1)
                .takeLast(2)
                .subscribe(new Observer<Integer>() {
                    @Override
                    public void onSubscribe(Disposable d) {
                        Log.d(TAG, "onSubscribe: ");
                    }

                    @Override
                    public void onNext(Integer integer) {
                        Log.d(TAG, "onNext: " + integer);
                    }

                    @Override
                    public void onError(Throwable e) {
                        Log.d(TAG, "onError: ");
                    }

                    @Override
                    public void onComplete() {
                        Log.d(TAG, "onComplete: ");
                    }
                });

根据指定时间过滤事件

1. throttleFirst（）/throttleLast（）

  • 作用：在某段时间内，只发送该段时间内的第一次时间/最后一次事件。比如在一段时间内连续点击按钮，但是只执行第一次的点击操作。

原理图：

这里写图片描述

具体使用：

Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> e) throws Exception {
                e.onNext(1);
                Thread.sleep(500);
                e.onNext(2);
                Thread.sleep(400);
                e.onNext(3);
                Thread.sleep(300);
                e.onNext(4);
                Thread.sleep(300);
                e.onNext(5);
                Thread.sleep(300);
                e.onNext(6);
                Thread.sleep(400);
                e.onNext(7);
                Thread.sleep(300);
                e.onNext(8);
                Thread.sleep(300);
                e.onNext(9);
                Thread.sleep(300);
                e.onComplete();

            }
        }).throttleFirst(1, TimeUnit.SECONDS)//每1秒中采用数据
                .subscribe(new Observer<Integer>() {
                    @Override
                    public void onSubscribe(Disposable d) {
                        Log.d(TAG, "onSubscribe: ");
                    }

                    @Override
                    public void onNext(Integer integer) {
                        Log.d(TAG, "onNext: " + integer);
                    }

                    @Override
                    public void onError(Throwable e) {
                        Log.d(TAG, "onError: ");
                    }

                    @Override
                    public void onComplete() {
                        Log.d(TAG, "onComplete: ");
                    }
                });

在这里插入图片描述

以上代码若采用throttleLast（），则发送得事件是3，6，9。

2. Sample（）

  • 作用:在某段时间内，只发送该段时间内最新（最后）1次事件
  • 和throttleLast（） 操作符类似，仅需要把上文的 throttleLast（） 改成Sample（）操作符即可

3. throttleWithTimeout （） / debounce（）

  • 作用：发送数据事件时，若两次发送事件的间隔小于指定时间，就会丢弃前一次的数据，直到指定时间内都没有新数据发射时才会发送后一次的数据。

原理图：

这里写图片描述

代码示例：

Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> e) throws Exception {
                e.onNext(1);
                Thread.sleep(500);
                e.onNext(2);
                Thread.sleep(1011);
                e.onNext(3);
                Thread.sleep(300);
                e.onNext(4);
                Thread.sleep(600);
                e.onNext(5);
                Thread.sleep(1200);
                e.onNext(6);
                Thread.sleep(400);
                e.onNext(7);
                Thread.sleep(300);
                e.onNext(8);
                Thread.sleep(300);
                e.onNext(9);
                Thread.sleep(300);
                e.onComplete();

            }
        }).throttleWithTimeout(1, TimeUnit.SECONDS)//每1秒中采用数据
                .subscribe(new Observer<Integer>() {
                    @Override
                    public void onSubscribe(Disposable d) {
                        Log.d(TAG, "onSubscribe: ");
                    }

                    @Override
                    public void onNext(Integer integer) {
                        Log.d(TAG, "onNext: " + integer);
                    }

                    @Override
                    public void onError(Throwable e) {
                        Log.d(TAG, "onError: ");
                    }

                    @Override
                    public void onComplete() {
                        Log.d(TAG, "onComplete: ");
                    }
                });

在这里插入图片描述

根据指定事件位置过滤事件

1. firstElement（）/lastElement（）

  • 作用：仅选取第一个元素/最后一个元素

具体使用：

Observable.just(1, 2, 3, 4, 5)
                .firstElement()
                .subscribe(new Consumer<Integer>() {
                    @Override
                    public void accept(Integer integer) throws Exception {
                        Log.d(TAG, "获取到的第一个事件是： " + integer);
                    }
                });

        Observable.just(1, 2, 3, 4, 5)
                .lastElement()
                .subscribe(new Consumer<Integer>() {
                    @Override
                    public void accept(Integer integer) throws Exception {
                        Log.d(TAG, "获取到的第一个事件是： " + integer);
                    }
                });

在这里插入图片描述

2. elementAt（）

  • 作用：指定接收某个元素（通过索引值确定）
  • 允许越界，即获取的位置索引>发送事件的序列长度

代码示例：

Observable.just(1, 2, 3, 4, 5)
                .elementAt(2)
                .subscribe(new Consumer<Integer>() {
                    @Override
                    public void accept(Integer integer) throws Exception {
                        Log.d(TAG, "获取到的第一个事件是： " + integer);
                    }
                });

3. elementAtOrError（）

  • 在elementAt（）的基础上，当出现越界情况时抛出异常
3gAndroid
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
RxJava2.0操作符详解
qq_43093708的博客
03-06 532
Rxjava2.0概述 通过前面的文章介绍，读者对RxJava2.0应该有了初步的认识。RxJava2.0相对1.0没有增加新的功能，最大的变化是把原来与背压有关的操作符抽取出来放在Flowable中处理；另外2.0的接口定义更符合ReactiveStream的规范。操作符的功能和1.0相比没有太大的变化，不过Flowable是背压相关的功能抽离出来的，本篇我们来详细分析下各种操作符的作用和用法...
rxjava2操作符
weixin_39877109的博客
12-09 113
rxjava2操作符 1. 创建操作符 create() 创建一个被观察者 public static <T> Observable<T> create(ObservableOnSubscribe<T> source) just() 创建一个被观察者，并发送事件，发送的事件不可以超过10个以上。 public static <T> Observable<T> just(T item) ...... public static <T>
RxJava系列5(组合操作符)
苏白的专栏
09-01 799
作者：张磊(BaronZhang) 链接：https://zhuanlan.zhihu.com/p/22039934 来源：知乎 著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。 这一章我们接着介绍组合操作符，这类operators可以同时处理多个Observable来创建我们所需要的Observable。组合操作符主要包含： Merge,StartWith,C
Rxjava操作符之组合合并操作符
qq_15327675的博客
11-09 444
Rxjava常见的组合合并操作符如下: 1.concat()/ concatArray() //组合 / 合并操作符concat() concatArray() //组合多个被观察者的事件，合并后在一起按照串行顺序进行发送 //concat()和concatArray()前者最多合并4个而后者则可以合并&gt;4个的Observable对象的事件序列 ...
RxJava2极速入门——Rxjava操作符详解之过滤操作符
易庞宙的博客
04-06 1343
RxJava2极速入门——Rxjava操作符详解之过滤操作符RxJava操作符——过滤操作符elementAt直接index索引直接索引并设置默认角标elementAt(long index, T defaultItem) 与 elementAt(long index) 区别fristlast RxJava操作符——过滤操作符 清明时节雨纷纷，路上行人欲断魂。感慨一下，哪怕是祭奠先人，也别忘了学习...
Rxjava2 Observable的条件操作符详解及实例
JiangMing-JIM的博客
12-30 842
文章目录简要：1. Amb2. DefaultIfEmpty3. SkipUntil4. SkipWhile小结 简要： 需求了解： 在使用 Rxjava 开发中，经常有一些各种条件的操作 ，如比较两个 Observable 谁先发射了数据、跳过指定条件的 Observable 等一系列的条件操作需求，那么很幸运， Rxjava 中已经有了很多条件操作符，一起来了解一下吧。 下面列出了一些Rxja...
RxJava2-Samples-master_ThisIsIt_rxjava-samples_
09-30
在RxJava中，数据可以被视为一种流，可以通过一系列操作符进行转换和处理，这些操作符允许我们定义如何处理数据流，包括过滤、合并、延迟执行等。 **RxJava2的改进** RxJava2是RxJava的第二个主要版本，相比第一版...
RxOperators:RxJava使用整理-操作符、使用方式
05-09
操作符预览图创建操作符变换操作符组合/合并操作符功能性操作符常用功能操作符-【subscribe】【subscribeOn】【observeOn】其他功能操作符-【delay】【repeat】【repeatWhen】【do】错误处理功能
Java操作符总结-动力节点共20页.pdf.zip
最新发布
10-29
Java编程语言中的操作符是程序设计中的重要组成部分，它们用于执行特定的数学或逻辑运算，帮助我们构建复杂的表达式和控制程序流程。本篇总结主要围绕Java中的各种操作符进行详细阐述，旨在帮助开发者深入理解并熟练...
RxJava之三——RxJava 2.0 全部操作符示例
薛瑄的博客
04-10 6474
转载请标明出处：http://blog.csdn.net/xx326664162/article/details/69945077 文章出自：薛瑄的博客关于RxJava，从表面上看起来很容易使用，但是如果理解不够深刻，使用过程中，往往会出现一些问题，所以我写了五篇文章，从入门到精通，从简单的使用到部分源码详解，希望能给读者一个质的飞跃： 1、RxJava之一——一次性学会使用RxJava RxJa
android rxjava2 简书,Android拾萃 - RxJava2操作符汇总
weixin_34364310的博客
05-28 370
几种主要的需求：直接创建一个Observable(创建操作)组合多个Observable(组合操作)对Observable发射的数据执行变换操作(变换操作)从Observable发射的数据中取特定的值(过滤操作)转发Observable的部分值(条件/布尔/过滤操作)对Observable发射的数据序列求值(算术/聚合操作)创建操作符名称解析just()将一个或多个对象转换成发射这个或这些对象的一...
Rxjava2操作符的使用
ThinksAgain的博客
02-13 387
之前学习了一些Rxjava2的操作符在此记录一下，以后用到了方便查询 import android.os.Bundle; import android.support.annotation.NonNull; import android.support.v7.app.AppCompatActivity; import android.text.TextUtils; import android....
Rxjava2基础概念和操作符
让技术为我所用
03-16 295
文章目录RxJava概念与观察者模式RxJava的上游与下游流程整理 1流程整理 2流程整理 3Rxjava创建型操作符createjustfromArrayemptyrangeRxjava变换型操作符mapflatMapconcatMapgroupBybufferRxJava过滤型操作符filter 过滤take 过滤操作符distinct 过滤重复事件elementAt 操作符RxJava条件型操作符All操作符contains操作符any操作符RxJava合并型操作符startWait操作符conca
RxJava 操作符整理 收集
xufeifandj的专栏
11-17 626
RxJava 操作符整理 收集
(待续)异步编程-RxJava2解读
云梦九章～
12-01 9041
阿里专家杜万：Java响应式编程，一文全面解读 RxJava2.x+ReTrofit2.x多线程下载文件 RxJava2.0│基础简介
Rxjava collect
new_abc的专栏
11-22 1437
Observable.just(1, 2, 3, 4) .collect(() -&gt; new ArrayList&lt;Integer&gt;(), new BiConsumer&lt;ArrayList&lt;Integer&gt;, Integer&gt;() { @Override ...
rxjava : collectInto、collect、all、any、将集合中元素以逗号连接并返回
火星男孩的分享空间
04-29 930
参考： RxJava 算术和聚合操作符 tbruyelle / RxPermissions tbruyelle / RxPermissions : 无界面fragment collectInto /** * 将集合中元素以逗号连接并返回 * public final <U> Single<U> collectInto( ...
RxJava 学习笔记
墨奕仙起
07-26 883
目录 参考 添加依赖 创建被观察者、观察者、订阅 一、创建操作符 1.1 create() 1.2 just()    最多不超过10个 1.3 From操作符 1.3.1 fromArray().  1.3.2 fromCallable().   1.3.3 fromFuture() 1.3.4 fromIterable(). 1.4 defer(). 1.5 time...
rx java操作符_RxJava操作符（一）
weixin_33217202的博客
02-22 345
本篇将介绍rxjava中的创建操作、合并操作、过滤操作、条件/布尔操作、聚合操作、转换操作以及变换操作，只针对用法不涉及原理，对RxJava不熟悉的可参考：http://gank.io/post/560e15be2dca930e00da1083创建操作create:使用OnSubscrib直接创建一个ObservableObservable.create(new Observable.OnSubs...
"C语言基础-操作符详解：算数与移位操作符
本文通过对C语言中的操作符进行详细讲解，特别是算术操作符和移位操作符的使用，为读者提供了理解这些操作符的基础。操作符在C语言中起着至关重要的作用，它们的正确使用可以提高程序的效率，并简化代码的编写。因此...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值