RxJava2 入门详细笔记（二）—— 转换操作符和组合操作符

最新推荐文章于 2024-01-03 14:14:27 发布
最新推荐文章于 2024-01-03 14:14:27 发布
阅读量243 收藏
点赞数 1
分类专栏： Rx系列 文章标签： RxJava2 入门 RxJava2 转换操作符 RxJava2 组合操作符
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yonbor605/article/details/83310513
版权

一、转换操作符

1.1、map()

map() 用于将被观察者发送的数据类型转变成其他的类型

    Observable.just(1, 2, 3)
        .map(new Function<Integer, String>() {
            @Override
            public String apply(Integer integer) {
                return "I'm " + integer;
            }
        })
        .subscribe(new Consumer<String>() {
            @Override
            public void accept(String s) {
                Log.e(TAG, s);
            }
        });
10-06 10:53:16.364 18099-18099/leavesc.hello.rxjavademo E/MainActivity: I'm 1
10-06 10:53:16.364 18099-18099/leavesc.hello.rxjavademo E/MainActivity: I'm 2
10-06 10:53:16.364 18099-18099/leavesc.hello.rxjavademo E/MainActivity: I'm 3

1.2、flatMap()

用于将事件序列中的元素进行整合加工，返回一个新的被观察者

        List<List<String>> listArrayList = new ArrayList<>();

        List<String> stringList = new ArrayList<>();
        for (int j = 0; j < 2; j++) {
            stringList.add("A_" + j);
        }
        listArrayList.add(stringList);

        stringList = new ArrayList<>();
        for (int j = 0; j < 2; j++) {
            stringList.add("B_" + j);
        }
        listArrayList.add(stringList);

        Observable.fromIterable(listArrayList).flatMap(new Function<List<String>, ObservableSource<String>>() {
            @Override
            public ObservableSource<String> apply(List<String> stringList1) throws Exception {
                return Observable.fromIterable(stringList1);
            }
        }).subscribe(new Consumer<String>() {
            @Override
            public void accept(String s) throws Exception {
                Log.e(TAG, "value is: " + s);
            }
        });
10-06 11:02:47.246 18230-18230/leavesc.hello.rxjavademo E/MainActivity: value is: A_0
10-06 11:02:47.246 18230-18230/leavesc.hello.rxjavademo E/MainActivity: value is: A_1
10-06 11:02:47.246 18230-18230/leavesc.hello.rxjavademo E/MainActivity: value is: B_0
10-06 11:02:47.246 18230-18230/leavesc.hello.rxjavademo E/MainActivity: value is: B_1

1.3、concatMap()

concatMap() 和 flatMap() 基本一样，只不过 concatMap() 转发出来的事件是有序的，而 flatMap() 是无序的

还是用 flatMap()的例子来看

Observable.fromIterable(listArrayList).flatMap(new Function<List<String>, ObservableSource<String>>() {
            @Override
            public ObservableSource<String> apply(List<String> stringList1) throws Exception {
                if (stringList1.get(0).startsWith("A")) {
                    return Observable.fromIterable(stringList1).delay(200, TimeUnit.MILLISECONDS);
                }
                return Observable.fromIterable(stringList1);
            }
        }).subscribe(new Consumer<String>() {
            @Override
            public void accept(String s) throws Exception {
                Log.e(TAG, "value is: " + s);
            }
        });

进行了一次延时操作，可以看到两次事件的发送顺序颠倒了

10-06 11:07:30.753 18702-18702/leavesc.hello.rxjavademo E/MainActivity: value is: B_0
10-06 11:07:30.753 18702-18702/leavesc.hello.rxjavademo E/MainActivity: value is: B_1
10-06 11:07:30.953 18702-18716/leavesc.hello.rxjavademo E/MainActivity: value is: A_0
10-06 11:07:30.953 18702-18716/leavesc.hello.rxjavademo E/MainActivity: value is: A_1

使用 concatMap() 则顺序将保持一致

1.4、buffer()

从需要发送的事件当中获取指定数量的事件，并将这些事件放到缓冲区当中一并发出。buffer 有两个参数，参数一count用于指点缓冲区大小，参数二 skip用指定当缓冲区满了时，发送下一次事件序列的时候要跳过多少元素

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

                    @Override
                    public void onNext(List<Integer> integers) {
                        Log.e(TAG, "缓冲区大小： " + integers.size());
                        for (Integer i : integers) {
                            Log.e(TAG, "元素： " + i);
                        }
                    }

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

                    @Override
                    public void onComplete() {
                        Log.e(TAG, "onComplete");
                    }
                });
 onSubscribe
 缓冲区大小： 2
 元素： 1
 元素： 2
 缓冲区大小： 2
 元素： 3
 元素： 4
 缓冲区大小： 2
 元素： 5
 元素： 6
 onComplete

1.5、groupBy()

用于将数据进行分组，每个分组都会返回一个被观察者。groupBy() 方法的返回值用于指定分组名，每返回一个新值就代表会创建一个分组

             Observable.just(1, 2, 3, 4, 5, 6, 7)
                .groupBy(new Function<Integer, String>() {
                    @Override
                    public String apply(Integer integer) {
                        if (integer < 4) {
                            return "hello";
                        }
                        return "hi";
                    }
                })
                .subscribe(new Observer<GroupedObservable<String, Integer>>() {
                    @Override
                    public void onSubscribe(Disposable d) {
                        Log.e(TAG, "onSubscribe");
                    }

                    @Override
                    public void onNext(final GroupedObservable<String, Integer> observable) {
                        observable.subscribe(new Observer<Integer>() {
                            @Override
                            public void onSubscribe(Disposable d) {
                                Log.e(TAG, "GroupedObservable onSubscribe");
                            }

                            @Override
                            public void onNext(Integer integer) {
                                Log.e(TAG, "GroupedObservable onNext key :" + observable.getKey());
                                Log.e(TAG, "GroupedObservable onNext value :" + integer);
                            }

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

                            @Override
                            public void onComplete() {
                                Log.e(TAG, "GroupedObservable onComplete");
                            }
                        });
                    }

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

                    @Override
                    public void onComplete() {
                        Log.e(TAG, "onComplete");
                    }
                });
10-06 11:16:35.616 19015-19015/? E/MainActivity: onSubscribe
10-06 11:16:35.616 19015-19015/? E/MainActivity: GroupedObservable onSubscribe
10-06 11:16:35.616 19015-19015/? E/MainActivity: GroupedObservable onNext key :hello
10-06 11:16:35.616 19015-19015/? E/MainActivity: GroupedObservable onNext value :1
10-06 11:16:35.616 19015-19015/? E/MainActivity: GroupedObservable onNext key :hello
10-06 11:16:35.616 19015-19015/? E/MainActivity: GroupedObservable onNext value :2
10-06 11:16:35.616 19015-19015/? E/MainActivity: GroupedObservable onNext key :hello
10-06 11:16:35.616 19015-19015/? E/MainActivity: GroupedObservable onNext value :3
10-06 11:16:35.616 19015-19015/? E/MainActivity: GroupedObservable onSubscribe
10-06 11:16:35.616 19015-19015/? E/MainActivity: GroupedObservable onNext key :hi
10-06 11:16:35.616 19015-19015/? E/MainActivity: GroupedObservable onNext value :4
10-06 11:16:35.616 19015-19015/? E/MainActivity: GroupedObservable onNext key :hi
10-06 11:16:35.616 19015-19015/? E/MainActivity: GroupedObservable onNext value :5
10-06 11:16:35.616 19015-19015/? E/MainActivity: GroupedObservable onNext key :hi
10-06 11:16:35.616 19015-19015/? E/MainActivity: GroupedObservable onNext value :6
10-06 11:16:35.616 19015-19015/? E/MainActivity: GroupedObservable onNext key :hi
10-06 11:16:35.616 19015-19015/? E/MainActivity: GroupedObservable onNext value :7
10-06 11:16:35.616 19015-19015/? E/MainActivity: GroupedObservable onComplete
10-06 11:16:35.616 19015-19015/? E/MainActivity: GroupedObservable onComplete
10-06 11:16:35.616 19015-19015/? E/MainActivity: onComplete

1.6、scan()

scan() 操作符对原始 Observable 发射的第一条数据应用一个函数，然后将那个函数的结果作为自己的第一项数据发射。它将函数的结果同第二项数据一起填充给这个函数来产生它自己的第二项数据。它持续进行这个过程来产生剩余的数据序列

        Observable.just(1, 5, 8, 12).scan(new BiFunction<Integer, Integer, Integer>() {
            @Override
            public Integer apply(Integer integer, Integer integer2) {
                Log.e(TAG, "integer : " + integer);
                Log.e(TAG, "integer2 : " + integer2);
                return integer + integer2;
            }
        }).subscribe(new Consumer<Integer>() {
            @Override
            public void accept(Integer integer) {
                Log.e(TAG, "accept : " + integer);
            }
        });
10-06 11:25:19.389 19158-19158/leavesc.hello.rxjavademo E/MainActivity: accept : 1
10-06 11:25:19.389 19158-19158/leavesc.hello.rxjavademo E/MainActivity: integer : 1
10-06 11:25:19.389 19158-19158/leavesc.hello.rxjavademo E/MainActivity: integer2 : 5
10-06 11:25:19.399 19158-19158/leavesc.hello.rxjavademo E/MainActivity: accept : 6
10-06 11:25:19.399 19158-19158/leavesc.hello.rxjavademo E/MainActivity: integer : 6
10-06 11:25:19.399 19158-19158/leavesc.hello.rxjavademo E/MainActivity: integer2 : 8
10-06 11:25:19.399 19158-19158/leavesc.hello.rxjavademo E/MainActivity: accept : 14
10-06 11:25:19.399 19158-19158/leavesc.hello.rxjavademo E/MainActivity: integer : 14
10-06 11:25:19.409 19158-19158/leavesc.hello.rxjavademo E/MainActivity: integer2 : 12
10-06 11:25:19.409 19158-19158/leavesc.hello.rxjavademo E/MainActivity: accept : 26

二、组合操作符

2.1、concat() & concatArray()

用于将多个观察者组合在一起，然后按照参数的传入顺序发送事件，concat() 最多只可以发送4个事件

        Observable.concat(Observable.just(1, 2),
                Observable.just(3, 4),
                Observable.just(5, 6),
                Observable.just(7, 8)).subscribe(new Consumer<Integer>() {
            @Override
            public void accept(Integer integer) throws Exception {
                Log.e(TAG, "accept: " + integer);
            }
        });
accept: 1
accept: 2
accept: 3
accept: 4
accept: 5
accept: 6
accept: 7
accept: 8

concatArray() 作用与 concat() 作用一样，不过前者可以发送多于 4 个的被观察者

2.2、merge() & mergeArray()

这个方法与 concat() 作用基本一样，只是 concat() 是串行发送事件，而 merge() 并行发送事件

    Observable.merge(Observable.interval(1, TimeUnit.SECONDS).map(new Function<Long, String>() {
                    @Override
                    public String apply(Long aLong) {
                        return "Test_A_" + aLong;
                    }
                }),
                Observable.interval(1, TimeUnit.SECONDS).map(new Function<Long, String>() {
                    @Override
                    public String apply(Long aLong) {
                        return "Test_B_" + aLong;
                    }
                })).subscribe(new Consumer<String>() {
            @Override
            public void accept(String s) {
                Log.e(TAG, "accept: " + s);
            }
        });
Test_A_0
Test_B_0
Test_A_1
Test_B_1
Test_A_2
Test_B_2
Test_B_3
Test_A_3
Test_A_4
Test_B_4
Test_A_5
Test_B_5

mergeArray() 可以发送 4 个以上的被观察者

2.3、concatArrayDelayError() & mergeArrayDelayError()

在 concatArray() 和 mergeArray() 两个方法当中，如果其中有一个被观察者发送了一个 Error事件，那么就会停止发送事件，如果想 onError() 事件延迟到所有被观察者都发送完事件后再执行的话，可以使用 concatArrayDelayError() 和 mergeArrayDelayError()

首先使用 concatArray() 来验证其发送 onError() 事件是否会中断其他被观察者的发送事件

Observable.concatArray(Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> emitter) {
                emitter.onNext(1);
                emitter.onNext(2);
                emitter.onError(new Exception("Normal Exception"));
            }
        }), Observable.just(30, 40, 50)).subscribe(new Observer<Integer>() {
            @Override
            public void onSubscribe(Disposable d) {

            }

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

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

            @Override
            public void onComplete() {

            }
        });
onNext: 1
onNext: 2
onError: Normal Exception

从结果可以知道，确实中断了，现在换用 concatArrayDelayError()

10-06 04:00:04.935 6514-6514/? E/MainActivity: onNext: 1
10-06 04:00:04.935 6514-6514/? E/MainActivity: onNext: 2
10-06 04:00:04.935 6514-6514/? E/MainActivity: onNext: 30
10-06 04:00:04.935 6514-6514/? E/MainActivity: onNext: 40
10-06 04:00:04.935 6514-6514/? E/MainActivity: onNext: 50
10-06 04:00:04.935 6514-6514/? E/MainActivity: onError: Normal Exception

从结果可以看到，onError 事件是在所有被观察者发送完事件才发送的

2.4、zip()

zip() 操作符返回一个 Obversable，它使用这个函数按顺序结合两个或多个 Observables 发射的数据项，然后它发射这个函数返回的结果。它按照严格的顺序应用这个函数。它只发射与发射数据项最少的那个 Observable 一样多的数据

        Observable.zip(Observable.just(1, 2, 3, 4), Observable.just(5, 6, 7, 8, 9),
                new BiFunction<Integer, Integer, String>() {
                    @Override
                    public String apply(Integer integer, Integer integer2) throws Exception {
                        return String.valueOf(integer) + "_" + String.valueOf(integer2);
                    }
                })
                .subscribe(new Consumer<String>() {
                    @Override
                    public void accept(String s) throws Exception {
                        Log.e(TAG, "accept: " + s);
                    }
                });
accept: 1_5
accept: 2_6
accept: 3_7
accept: 4_8

2.5、combineLatest() & combineLatestDelayError()

combineLatest() 的作用与 zip() 类似，combineLatest() 发送事件的序列是与发送的时间线有关的，当两个 Observables 中的任何一个发射了一个数据时，通过一个指定的函数组合每个 Observable 发射的最新数据，然后发射这个函数的结果

Observable.zip(
               Observable.intervalRange(1, 4, 1, 1, TimeUnit.SECONDS)
                        .map(new Function<Long, String>() {
                            @Override
                            public String apply(Long aLong) {
                                String s1 = "A" + aLong;
                                Log.e(TAG, "A 发送的事件 " + s1);
                                return s1;
                            }
                        }), Observable.intervalRange(1, 4, 2, 1, TimeUnit.SECONDS)
                        .map(new Function<Long, String>() {
                            @Override
                            public String apply(Long aLong) {
                                String s1 = "B" + aLong;
                                Log.e(TAG, "B 发送的事件 " + s1);
                                return s1;
                            }
                        }),
                new BiFunction<String, String, String>() {
                    @Override
                    public String apply(String value1, String value2) throws Exception {
                        return value1 + "_" + value2;
                    }
                })
                .subscribe(new Consumer<String>() {
                    @Override
                    public void accept(String s) throws Exception {
                        Log.e(TAG, "accept: " + s);
                    }
                });
10-06 05:17:06.337 7227-7241/leavesc.hello.rxjavademo E/MainActivity: A 发送的事件 A1
10-06 05:17:07.337 7227-7241/leavesc.hello.rxjavademo E/MainActivity: A 发送的事件 A2
10-06 05:17:07.337 7227-7242/leavesc.hello.rxjavademo E/MainActivity: B 发送的事件 B1
10-06 05:17:07.337 7227-7242/leavesc.hello.rxjavademo E/MainActivity: accept: A1_B1
10-06 05:17:08.337 7227-7241/leavesc.hello.rxjavademo E/MainActivity: A 发送的事件 A3
10-06 05:17:08.337 7227-7242/leavesc.hello.rxjavademo E/MainActivity: B 发送的事件 B2
10-06 05:17:08.337 7227-7242/leavesc.hello.rxjavademo E/MainActivity: accept: A2_B2
10-06 05:17:09.337 7227-7242/leavesc.hello.rxjavademo E/MainActivity: B 发送的事件 B3
10-06 05:17:09.337 7227-7242/leavesc.hello.rxjavademo E/MainActivity: accept: A3_B3
10-06 05:17:09.337 7227-7241/leavesc.hello.rxjavademo E/MainActivity: A 发送的事件 A4
10-06 05:17:10.337 7227-7242/leavesc.hello.rxjavademo E/MainActivity: B 发送的事件 B4
10-06 05:17:10.337 7227-7242/leavesc.hello.rxjavademo E/MainActivity: accept: A4_B4

当发送 A1 和 A2 事件时，B 并没有发送任何事件，所以不会触发到 accept 方法。当发送了 B1 事件之后，就会与 A 最新发送的事件 A2 结合成 A1_B2，之后的发射规则也以此类推

combineLatestDelayError() 多了延迟发送 onError() 的功能

2.6、reduce()

与 scan() 操作符的作用类似，也是将发送数据以一定逻辑聚合起来，区别在于 scan() 每处理一次数据就会将事件发送给观察者，而 reduce() 会将所有数据聚合在一起才会发送事件给观察者

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

2.7、collect()

collect() 与 reduce() 类似，但它的目的是收集原始 Observable 发射的所有数据到一个可变的数据结构

Observable.just(1, 2, 3, 4)
                .collect(new Callable<ArrayList<Integer>>() {
                    @Override
                    public ArrayList<Integer> call() throws Exception {
                        return new ArrayList<>();
                    }
                }, new BiConsumer<ArrayList<Integer>, Integer>() {
                    @Override
                    public void accept(ArrayList<Integer> integers, Integer integer) throws Exception {
                        integers.add(integer);
                    }
                })
                .subscribe(new Consumer<ArrayList<Integer>>() {
                    @Override
                    public void accept(ArrayList<Integer> integers) throws Exception {
                        Log.e(TAG, "accept : " + integers);
                    }
                });
accept : [1, 2, 3, 4]

2.8、startWith() & startWithArray()

在发送事件之前追加事件，startWith() 追加一个事件，startWithArray() 可以追加多个事件，追加的事件会先发出

        Observable.just(4, 5)
                .startWithArray(2, 3)
                .startWith(1)
                .subscribe(new Consumer<Integer>() {
                    @Override
                    public void accept(Integer integer) throws Exception {
                        Log.e(TAG, "accept : " + integer);
                    }
                });
10-06 05:38:21.081 8033-8033/leavesc.hello.rxjavademo E/MainActivity: accept : 1
10-06 05:38:21.081 8033-8033/leavesc.hello.rxjavademo E/MainActivity: accept : 2
10-06 05:38:21.081 8033-8033/leavesc.hello.rxjavademo E/MainActivity: accept : 3
10-06 05:38:21.081 8033-8033/leavesc.hello.rxjavademo E/MainActivity: accept : 4
10-06 05:38:21.081 8033-8033/leavesc.hello.rxjavademo E/MainActivity: accept : 5

2.9、count()

返回被观察者发送事件的数量

        Observable.just(1, 2, 3)
                .count()
                .subscribe(new Consumer<Long>() {
                    @Override
                    public void accept(Long aLong) throws Exception {
                        Log.e(TAG, "aLong : " + aLong);
                    }
                });
aLong : 3

 

 

 

yonbor605
关注
专栏目录
Android RxJava： 这是一份全面的 操作符 使用汇总 （含详细实例讲解）(1)
2401_84132298的博客
04-22 757
最后为了帮助大家深刻理解Android相关知识点的原理以及面试相关知识，这里放上相关的我搜集整理的24套。
RxJava2 Flowable 静态操作符
无问西东的博客
10-02 6662
RxJava的学习成本其实蛮高的，我写RxJava这个系列是希望缩短学习RxJava的时间，我这里完全根据官网来学习一遍，写用例，做笔记，对于对英文不太感冒的同学，我相信看我的博客可以舒服不少！ 国庆两天假初步整理了一下Flowable的静态操作符，后续将会继续写Flowable的实例操作符，Observable、Single、Completable、Maybe操作符以及对各操作符的分类和总结，...
Rxjava2(三)合并操作符
oneblue123的博客
06-04 3260
1.concatprivate void concat() { final Integer[] items={1,2,3,4}; Observable.concat(Observable.just(1,2,3),Observable.just(4,5)) .subscribe(new Consumer&lt;Integer&gt;() { ...
RxJava 操作符 concat
Pizza_Lawson的专栏
04-22 7058
Concat操作符 public void test() { Observable.concat(Observable.just("a"), Observable.just("b"), Observable.just("c")).subscribe( new Observer() { @Override public void onComple
Rxjava操作符之结合类操作符
WernerZeiss的博客
07-16 472
前言 本篇介绍结合类操作符，包括：concat、concatArray、concatDelayError、merge、mergeArray、mergeDelayError、zip、zipWith、combineLatest、combineLatestDelayError、join、joinGroup、startWith、startWithArray、switchOnNext 1，concat(...
Rxjava合并，连接操作符
路漫漫其修远兮
07-26 922
Rxjava合并操作符 合并操作符 作用 startWith 在Observable发射的数据前添加一个数据， merge, mergeDelayError 将多个Observable合并为一个，mergeDelayError,是全部Observable发射完执行onError zip 使用一个函数组合多个Observable发射的数据，然后再...
rxjava： concat \ concatWith \ concatEager \ concatDelayError \ concatMap \ concatArray
火星男孩的分享空间
10-14 1054
concat : concatWith : concatEager concatDelayError concatMap concatMapEager concatMapDelayError concatMapEagerDelayError concatMapMaybe concatMapMaybeDelayError concatMapSingle ...
Word分页符和分节符的区别、设置、使用指南——附案例操作
最新发布
干吧滴！
01-03 1万+
分页/分节符是我们使用Word的常用小组件，但如何清晰、明了、高效地使用分页符/分节符，之前一直没有弄清楚，本文总结了这两个组件的具体功用，并明晰二者之间的区别，为了便于大家理解和操作，附上了各个功能的案例操作。
python提供了9个基本的数值运算操作符_Python学习笔记（三）Python基本数字类型及其简单操作（1）...
weixin_33128371的博客
02-04 3155
一、数字类型表示数字或数值的数据类型称为数字类型,Python语言提供3种数字类型：整数、浮点数和复数，分别对应数学中的整数、实数和复数，下面就一起来了解一下他们吧！1.整数类型整数类型与数学中整数的概念一致，整数类型共有4种进制表示：十进制、二进制、八进制和十六进制。例：进制种类引导符号描述十进制无默认情况，例如123，-456二进制0b 或 0B由字符 0 到 1 组成，例如，0b1101，0...
5. RxJava合并条件操作符
NorthStar的博客
07-30 1161
RxJava合并条件操作符
java 数组 concat_RxJava2操作符之“Concat”与“ConcatArray”
weixin_42097533的博客
02-24 646
作用跟Merge操作符很像，但是这个操作符是能保证输出顺序的Concat：emit the emissions from two or more Observables without interleaving them从两个或更多的被观察者中发送事件，而且还能保证输出顺序(将两个被观察者合并成一个)ConcatArray：将数组中的被观察者合并成一个整体，并且保证发送顺序示例用法final St...
Android RxJava2(三)组合操作符
好好学习 天天向上
06-06 1755
Rxjava由于其基于事件流的链式调用、逻辑简洁 &amp;amp;amp;amp; 使用简单的特点，深受各大 Android开发者的欢迎。因此在学习过程中全面的了解了下RxJava的组合操作符。 merge() mergeArray() concat() concatArray() startWith() &amp;amp;amp;amp; startWithArray() mergeArrayDelayError() &amp;amp;amp;amp; c...
RXJAVA使用详解
keep_moving12138的博客
11-07 808
前言 Rxjava，由于其基于事件流的链式调用、逻辑简洁 & 使用简单的特点，深受各大 Android开发者的欢迎。 如果还不了解 RxJava，请看文章：Android：这是一篇 清晰 & 易懂的Rxjava 入门教程 RxJava如此受欢迎的原因，在于其提供了丰富 & 功能强大的操作符，几乎能完成所有的功能需求今天，我将为大家详细介绍RxJava操
RxJava2.0组合与合并操作符（三）
csclmf的博客
01-30 718
1、组合操作符 (1)、组合多个观察者：concat() / concatArray() 作用：组合多个 被观测者 一起发送数据，合并后 按发送顺序串行执行 两者的区别:组合被观察者的数量，concat()组合被观察者 =5 具体使用: Observable //创建组合操作符(concat必须，<=4个) .conc
Android之Rxjava2.X 4————Rxjava 组合操作符
冰炭不投day的博客
08-14 953
Android之Rxjava2.X 4————Rxjava 创建操作符 一.目录 Android之Rxjava2.X 4————Rxjava 创建操作符 一.目录 二.概述 1.作用 2. 类型 三.组合多个被观察者 1.concat()/concatArray() 2.merge()/mergeArray() 3.concatDelayError（） / mergeDelayE...
Rxjava操作符之组合合并操作符
qq_15327675的博客
11-09 495
Rxjava常见的组合合并操作符如下: 1.concat()/ concatArray() //组合 / 合并操作符concat() concatArray() //组合多个被观察者的事件，合并后在一起按照串行顺序进行发送 //concat()和concatArray()前者最多合并4个而后者则可以合并&gt;4个的Observable对象的事件序列 ...
Carson带你学Android：RxJava组合/合并操作符
Carson带你学Android
11-06 1万+
前言 Rxjava，由于其基于事件流的链式调用、逻辑简洁 & 使用简单的特点，深受各大 Android开发者的欢迎。 如果还不了解 RxJava，请看文章：Android：这是一篇 清晰 & 易懂的Rxjava 入门教程 RxJava如此受欢迎的原因，在于其提供了丰富 & 功能强大的操作符，几乎能完成所有的功能需求 今天，我将为大家详细介绍RxJava操作符中最常用的 组合 / 合并操作符，并
PHP学习：操作符与控制结构详解
"php学习笔记（三）操作符与控制结构" 在PHP编程中，操作符与控制结构是构建逻辑流程和执行计算的核心元素。本文将深入探讨PHP中的字符串插入、操作符以及控制结构。 首先，我们来看字符串插入。在PHP中，有多种...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值