RxJava2 Flowable 静态操作符

最新推荐文章于 2024-07-26 18:00:43 发布

_无问西东

最新推荐文章于 2024-07-26 18:00:43 发布

阅读量6.6k

点赞数 1

分类专栏： rxjava2 文章标签： RxJava Flowable 静态操作符

本文链接：https://blog.csdn.net/weixin_36709064/article/details/82919785

版权

本文详细介绍了RxJava2中的Flowable的静态操作符，包括amb、bufferSize、combineLatest等38种操作符的用法、图解和测试案例，旨在帮助读者更好地理解和掌握RxJava的Flowable部分。此外，文章还提到了Flowable与其他类型的关系，以及对错误处理的延迟操作。

摘要由CSDN通过智能技术生成

RxJava的学习成本其实蛮高的，我写RxJava这个系列是希望缩短学习RxJava的时间，我这里完全根据官网来学习一遍，写用例，做笔记，对于对英文不太感冒的同学，我相信看我的博客可以舒服不少！

国庆两天假初步整理了一下Flowable的静态操作符，后续将会继续写Flowable的实例操作符，Observable、Single、Completable、Maybe操作符以及对各操作符的分类和总结，使用场景，目标是可以当做RxJava的字典来查，并且快速学习看懂。希望喜欢的同学收藏点赞，给我鼓励和批评，谢谢！

5 combineLatestDelayError

6 Concat

7 concatArray

8 concatArrayDelayError

9 concatArrayEager

10 concatArrayEagerError

34 switchOnNextDelayError

35 timer

36 unsafeCreate

37 using

38 zip、zipArray、zipIterable

1 Flowable简介

见上一篇：RxJava2系列 (一) 五大重要角色基本功能介绍

2 Flowable的静态作符

1 amb

static <T> Flowable<T>

amb(Iterable<? extends Publisher<? extends T>> sources)

参数传入的是Publisher的集合，Iterable是Collection的父类，Collection是List的父类

给定两个或多个源Publisher，仅从这些Publisher中的第一个发出所有项目以发出项目或通知

1.1 amb图解

注意并不是一定是排在第一位的20、40、60获得优先权，可能有时候Publisher会有延迟操作

1.2 amb测试用例

测试

    private void doAmb() {

        List<Flowable<Integer>> flowables = new ArrayList<Flowable<Integer>>();
        flowables.add(Flowable.just(20,40,60).delay(1, TimeUnit.SECONDS));
        flowables.add(Flowable.just(1,2,3));
        flowables.add(Flowable.just(0,0,0));

        Flowable
                .amb(flowables)
                .subscribe(new Consumer<Integer>() {
                    @Override
                    public void accept(Integer integer) throws Exception {
                        System.out.println("value is " + integer);
                    }
                });
    }

测试结果：
10-02 21:11:27.958 14733-14733/hq.demo.net I/System.out: value is 1
10-02 21:11:27.958 14733-14733/hq.demo.net I/System.out: value is 2
10-02 21:11:27.958 14733-14733/hq.demo.net I/System.out: value is 3
10-02 21:11:30.970 14733-14763/hq.demo.net I/System.out: Done!

从上面例子来看，也就是在一个以Flowable为元素的集合中，那个元素最先开始发射数据，那么它只发射其中首先发射数据或通知（onError或onCompleted）的那个Flowable的中的数据流，而其他的Flowable将被丢弃。

2 ambArray

static <T> Flowable<T>

ambArray(Publisher<? extends T>... sources)

参数传入的是Publisher的数组

给定两个或多个源Publisher，仅从这些Publisher中的第一个发出所有项目以发出项目或通知

2.1 图解

其实ambArray跟amb的用法类似，只是换成以Publisher为元素的数组，所以上面的图解与amb相同

2.2 测试用例

private void doAmbArray() {
        Log.d("#Flowable#","do ambArray###############");
        Flowable[] flowables = {Flowable.just(20,40,60).delay(1,TimeUnit.SECONDS),Flowable.just(1,2,3),Flowable.just(0,0,0),Flowable.just(1,2,3)};
        Flowable.ambArray(flowables).subscribe(new Consumer<Integer>() {
            @Override
            public void accept(Integer integer) throws Exception {
                System.out.println("accept:"+integer);
            }
        });
    }


结果输出：
09-30 20:58:23.684 5885-5885/hq.demo.net D/#Flowable#: do ambArray###############
09-30 20:58:23.716 5885-5885/hq.demo.net I/System.out: accept:1
09-30 20:58:23.716 5885-5885/hq.demo.net I/System.out: accept:2
09-30 20:58:23.716 5885-5885/hq.demo.net I/System.out: accept:3

3 bufferSize

static int

bufferSize()

返回大多数异步运算符使用的默认内部缓冲区大小

3.1 bufferSize图解

无，只是返回一个内部缓冲区大小的int值，返回值默认大小128

3.2 bufferSize测试用例

  private void doBufferSize() {
        Log.d("#Flowable#", "do bufferSize###############");
        int bufferSize = Flowable.bufferSize();
        System.out.println("bufferSize = " + bufferSize);
    }

结果输出：
09-30 21:16:07.242 6381-6381/hq.demo.net D/#Flowable#: do bufferSize###############
09-30 21:16:07.242 6381-6381/hq.demo.net I/System.out: bufferSize = 128

4 combineLatest

combineLatest一共有13个重载方法，说明的都是一个功能，就是自定义一个函数来，根据函数规则处理两个以上被观察源发出的消息，得到一个结果，再把这个结果发射出去，只是这些重载方法涵盖的比较全面，传入参数可以使数组（动态数组、已知长度数组）、集合、2个到9个发布源。

`static <T,R> Flowable<R>`	`combineLatest(Function<? super Object[],? extends R> combiner, Publisher<? extends T>... sources)` 当一个项目由两个以上的`Publisher`中的任何一个发出时，通过指定的函数组合每个`Publisher`发出的最新项目，并根据此函数的结果发出最终项目
`static <T,R> Flowable<R>`	`combineLatest(Iterable<? extends Publisher<? extends T>> sources, Function<? super Object[],? extends R> combiner)` 通过发出一个项目来合并源发布者的集合，该项目在每次从任何源发布者接收项目时聚合每个源发布者的最新值，其中此聚合由指定的函数定义。
`static <T,R> Flowable<R>`	`combineLatest(Iterable<? extends Publisher<? extends T>> sources, Function<? super Object[],? extends R> combiner, int bufferSize)` 通过发出一个项目来合并源发布者的集合，该项目在每次从任何源发布者接收项目时聚合每个源发布者的最新值，其中此聚合由指定的函数定义。
`static <T,R> Flowable<R>`	`combineLatest(Publisher<? extends T>[] sources, Function<? super Object[],? extends R> combiner)` 通过发出一个项目来合并源发布者的集合，该项目在每次从任何源发布者接收项目时聚合每个源发布者的最新值，其中此聚合由指定的函数定义。
`static <T,R> Flowable<R>`	`combineLatest(Publisher<? extends T>[] sources, Function<? super Object[],? extends R> combiner, int bufferSize)` 通过发出一个项目来合并源发布者的集合，该项目在每次从任何源发布者接收项目时聚合每个源发布者的最新值，其中此聚合由指定的函数定义。注意：上面连着的4个函数都是一个意思，其中两个重载方法能够指定缓存大小
`static <T1,T2,R> Flowable<R>`	`combineLatest(Publisher<? extends T1> source1, Publisher<? extends T2> source2, BiFunction<? super T1,? super T2,? extends R> combiner)` 通过发出一个项目来合并两个源发布者，每次从任一源发布者接收项目时，该项目都会聚合每个源发布者的最新值，其中此聚合由指定的函数定义。
`<T1,T2,T3,T4,T5,T6,T7,T8,T9,R>`	这里省略了其他7个重载方法，说的都是一个意思每次从任何源发布者接收项目时，通过发出一个聚合每个源发布者的最新值的项目来合并3（4、5、6、7、8、9）个源发布者，其中此聚合由指定的函数定义。

4.1 combineLatest图解

4.2 combineLatest测试用例

这个方法是一个多重重载的静态方法，这里只举一个最简单的例子，根据上图做2个发射源的发出的消息的合并

 private void doCombineLatest() {
        Log.d("#Flowable#", "do combineLatest###############");
        Flowable sourceA = Flowable.just(1, 2, 3);
        Flowable sourceB = Flowable.just(4, 5, 6);
        Flowable sourceC = Flowable.just(7, 8, 9);

        Flowable.combineLatest(sourceA, sourceB, sourceC, new Function3<Integer,Integer,Integer, String>() {
            @Override
            public String apply(Integer o, Integer o2, Integer o3) throws Exception {
                return (o + o2 + o3) + "";
            }
        }).subscribe(new Consumer<String>() {
            @Override
            public void accept(String o) throws Exception {
                System.out.println("accept:value="+o);
            }
        });
    }


测试结果：
09-30 23:56:40.523 11747-11747/hq.demo.net D/#Flowable#: do combineLatest###############
09-30 23:56:40.523 11747-11747/hq.demo.net I/System.out: accept:value=16
09-30 23:56:40.523 11747-11747/hq.demo.net I/System.out: accept:value=17
09-30 23:56:40.524 11747-11747/hq.demo.net I/System.out: accept:value=18

5 combineLatestDelayError

combineLatestDelayError在combineLatest的基础上增加了对error的延迟处理，让error延迟到所有项目被发射完毕

`static <T,R> Flowable<R>`	`combineLatestDelayError(Function<? super Object[],? extends R> combiner, int bufferSize, Publisher<? extends T>... sources)` 通过发出一个项来合并源发布者的集合，该项在每次从任何源发布者接收项时聚合每个源发布者的最新值，其中此聚合由指定的函数定义并延迟来自源的任何错误直到所有源发布者终止。
`static <T,R> Flowable<R>`	`combineLatestDelayError(Function<? super Object[],? extends R> combiner, Publisher<? extends T>... sources)` 通过发出一个项来合并源发布者的集合，该项在每次从任何源发布者接收项时聚合每个源发布者的最新值，其中此聚合由指定的函数定义并延迟来自源的任何错误直到所有源发布者终止。
`static <T,R> Flowable<R>`	`combineLatestDelayError(Iterable<? extends Publisher<? extends T>> sources, Function<? super Object[],? extends R> combiner)` 通过发出一个项来合并源发布者的集合，该项在每次从任何源发布者接收项时聚合每个源发布者的最新值，其中此聚合由指定的函数定义并延迟来自源的任何错误直到所有源发布者终止。
`static <T,R> Flowable<R>`	`combineLatestDelayError(Iterable<? extends Publisher<? extends T>> sources, Function<? super Object[],? extends R> combiner, int bufferSize)` 通过发出一个项来合并源发布者的集合，该项在每次从任何源发布者接收项时聚合每个源发布者的最新值，其中此聚合由指定的函数定义并延迟来自源的任何错误直到所有源发布者终止。
`static <T,R> Flowable<R>`	`combineLatestDelayError(Publisher<? extends T>[] sources, Function<? super Object[],? extends R> combiner)` `通过发出一个项目来合并源发布者的集合，该项目在每次从任何源发布者接收项目时聚合每个源发布者的最新值，其中此聚合由指定的函数定义。`
`static <T,R> Flowable<R>`	`combineLatestDelayError(Publisher<? extends T>[] sources, Function<? super Object[],? extends R> combiner, int bufferSize)` 通过发出一个项来合并源发布者的集合，该项在每次从任何源发布者接收项时聚合每个源发布者的最新值，其中此聚合由指定的函数定义并延迟来自源的任何错误直到所有源发布者终止。

5.1 combineLatestDelayError图解

同4.1

5.2 combineLatestDelayError测试用例

略

6 Concat

`static <T> Flowable<T>`	`concat(Iterable<? extends Publisher<? extends T>> sources)` 将通过Iterable序列提供的以Publisher为元素的集合中的每一个Publisher连接到单个元素序列中，而不进行交错。
`static <T> Flowable<T>`	`concat(Publisher<? extends Publisher<? extends T>> sources)` 返回一个Flowable，它一个接一个地发出源Publisher发出的每个发布者发出的项，而不进行交错。
`static <T> Flowable<T>`	`concat(Publisher<? extends Publisher<? extends T>> sources, int prefetch)` 返回一个Flowable，它一个接一个地发出源Publisher发出的每个项，而不进行交错。
`static <T> Flowable<T>`	`concat(Publisher<? extends T> source1, Publisher<? extends T> source2)` 返回一个Flowable，它一个接一个地发出2个Publishers发出的项，而不进行交错。
`static <T> Flowable<T>`	`concat(Publisher<? extends T> source1, Publisher<? extends T> source2, Publisher<? extends T> source3)` 返回一个Flowable，它一个接一个地发出3个Publishers发出的项，而不进行交错。
`static <T> Flowable<T>`	`concat(Publisher<? extends T> source1, Publisher<? extends T> source2, Publisher<? extends T> source3,Publisher<? extends T> source4)` 返回一个Flowable，它一个接一个地发出4个发布者发出的项目，而不进行交错。

6.1 Concat图解

6.2 Concat测试用例


测试1：
private void doConcat() {
        Flowable<Integer> sourceA = Flowable.just(1, 2, 3);
        Flowable<Integer> sourceB = Flowable.just(11, 12, 13);
        Flowable<Integer> sourceC = Flowable.just(21, 22, 23);
        List<Publisher<Integer>> source = new ArrayList<>();
        source.add(sourceA);
        source.add(sourceB);
        source.add(sourceC);

        Flowable.concat(source).subscribe(new Consumer<Integer>() {
            @Ove