RxJava组合操作符

最新推荐文章于 2021-02-21 21:40:44 发布

hbgaozhiwei

最新推荐文章于 2021-02-21 21:40:44 发布

阅读量175

点赞数

分类专栏： RxJava 文章标签： RxJava 组合 concat count

本文链接：https://blog.csdn.net/hbgaozhiwei/article/details/86537331

版权

RxJava 专栏收录该内容

6 篇文章 0 订阅

订阅专栏

1、concat():可以将多个观察者组合在一起，然后按照之前发送顺序发送事件。需要注意的是，concat()最多只可以发送4个事件。

方法签名：
public static <T> Observable<T> concat(ObservableSource<? extends T> source1, ObservableSource<? extends T> source2, ObservableSource<? extends T> source3, ObservableSource<? extends T> source4)
......

Observable.concat(Observable.just(1, 2),
Observable.just(3, 4),
Observable.just(5, 6),
Observable.just(7, 8))
.subscribe(new Observer < Integer > () {
    @Override
    public void onSubscribe(Disposable d) {

    }

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

    @Override
    public void onError(Throwable e) {

    }

    @Override
    public void onComplete() {

    }
});

输出结果

================onNext 1
================onNext 2
================onNext 3
================onNext 4
================onNext 5
================onNext 6
================onNext 7
================onNext 8

2、concatArray():与concat()作用一样，不过concatArray可以发送4个被观察者。

方法签名：
public static <T> Observable<T> concatArray(ObservableSource<? extends T>... sources)

Observable.concatArray(Observable.just(1, 2),
Observable.just(3, 4),
Observable.just(5, 6),
Observable.just(7, 8),
Observable.just(9, 10))
.subscribe(new Observer < Integer > () {
    @Override
    public void onSubscribe(Disposable d) {

    }

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

    @Override
    public void onError(Throwable e) {

    }

    @Override
    public void onComplete() {

    }
});

输出结果

================onNext 1
================onNext 2
================onNext 3
================onNext 4
================onNext 5
================onNext 6
================onNext 7
================onNext 8
================onNext 9
================onNext 10

3、merge():这个方法与concat（）作用基本一样，只是concat()是串行发送事件，而merge()是并行发送事件,并且只能发送4个被观察者，mergeArray()可以发送4个以上的被观察者。


方法签名：
  public static <T> Observable<T> merge(ObservableSource<? extends T> source1, ObservableSource<? extends T> source2, ObservableSource<? extends T> source3, ObservableSource<? extends T> source4)
......

Observable.merge(
Observable.interval(1, TimeUnit.SECONDS).map(new Function < Long, String > () {
    @Override
    public String apply(Long aLong) throws Exception {
        return "A" + aLong;
    }
}),
Observable.interval(1, TimeUnit.SECONDS).map(new Function < Long, String > () {
    @Override
    public String apply(Long aLong) throws Exception {
        return "B" + aLong;
    }
}))
    .subscribe(new Observer < String > () {
    @Override
    public void onSubscribe(Disposable d) {

    }

    @Override
    public void onNext(String s) {
        Log.d(TAG, "=====================onNext " + s);
    }

    @Override
    public void onError(Throwable e) {

    }

    @Override
    public void onComplete() {

    }
});

打印结果如下：

=====================onNext B0
=====================onNext A0
=====================onNext A1
=====================onNext B1
=====================onNext A2
 =====================onNext B2
=====================onNext A3
 =====================onNext B3
=====================onNext A4
=====================onNext B4
=====================onNext A5
=====================onNext B5
......

将以上代码换成concat()

=====================onNext A0
=====================onNext A1
=====================onNext A2
=====================onNext A3
=====================onNext A4
=====================onNext A5
......

从结果可以直到，只有等到第一个被观察者发送事件之后，第二个被观察者才会发送事件。

4、concatArrayDelayError和mergeArrayDelayError()
在cocatArray()和mergeArray()两个方法当中，如果其中有一个被观察者发送了一个Error事件，那就会停止发送事件。如果你想onError（）事件延迟到所有被观察者都发送事件后再执行的话，就可以用concatArrayError()和mergeArrayDelayError()
首先使用concatArray()来验证一下发送onError()事件是否会中断其他被观察者发送事件。

方法签名：
public static <T> Observable<T> concatArrayDelayError(ObservableSource<? extends T>... sources)
public static <T> Observable<T> mergeArrayDelayError(ObservableSource<? extends T>... sources)


Observable.concatArray(
Observable.create(new ObservableOnSubscribe < Integer > () {
    @Override
    public void subscribe(ObservableEmitter < Integer > e) throws Exception {
        e.onNext(1);
        e.onError(new NumberFormatException());
    }
}), Observable.just(2, 3, 4))
    .subscribe(new Observer < Integer > () {
    @Override
    public void onSubscribe(Disposable d) {

    }

    @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() {

    }
});

输出结果：

===================onNext 1
===================onError

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

Observable.concatArrayDelayError(
Observable.create(new ObservableOnSubscribe < Integer > () {
    @Override
    public void subscribe(ObservableEmitter < Integer > e) throws Exception {
        e.onNext(1);
        e.onError(new NumberFormatException());
    }
}), Observable.just(2, 3, 4))
.subscribe(new Observer < Integer > () {
    @Override
    public void onSubscribe(Disposable d) {

    }

    @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() {

    }
});

输出结果

===================onNext 1
===================onNext 2
===================onNext 3
===================onNext 4
===================onError

从结果可以看到，onError事件是在所有被观察者发送完事件才发送的。mergeArrayDelayError()同样的作用。

5、zip():会将多个被观察者合并，根据各个被观察者发送事件的顺序一个个结合起来，最终发送的事件数量会跟源Observable中最少事件的数量一样

方法签名：
public static <T1, T2, R> Observable<R> zip(ObservableSource<? extends T1> source1, ObservableSource<? extends T2> source2, BiFunction<? super T1, ? super T2, ? extends R> zipper)
......


Observable.zip(Observable.intervalRange(1, 5, 1, 1, TimeUnit.SECONDS)
    .map(new Function<Long, String>() {
        @Override
        public String apply(Long aLong) throws Exception {
            String s1 = "A" + aLong;
            Log.d(TAG, "===================A 发送的事件 " + s1);
            return s1;
        }}),
        Observable.intervalRange(1, 6, 1, 1, TimeUnit.SECONDS)
            .map(new Function<Long, String>() {
            @Override
            public String apply(Long aLong) throws Exception {
                String s2 = "B" + aLong;
                Log.d(TAG, "===================B 发送的事件 " + s2);
                return s2;
            }
        }),
        new BiFunction<String, String, String>() {
            @Override
            public String apply(String s, String s2) throws Exception {
                String res = s + s2;
                return res;
            }
        })
.subscribe(new Observer<String>() {
    @Override
    public void onSubscribe(Disposable d) {
        Log.d(TAG, "===================onSubscribe ");
    }

    @Override
    public void onNext(String s) {
        Log.d(TAG, "===================onNext " + s);
    }

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

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

上面代码中有两个Observable，第一个发送事件的数量为5个，第二个发送事件的数量为6个，打印结果如下：

===================onSubscribe 
===================A 发送的事件 A1
===================B 发送的事件 B1
===================onNext A1B1
 ===================A 发送的事件 A2
===================B 发送的事件 B2
===================onNext A2B2
===================A 发送的事件 A3
===================B 发送的事件 B3
===================onNext A3B3
===================A 发送的事件 A4
===================B 发送的事件 B4
===================onNext A4B4
===================A 发送的事件 A5
===================B 发送的事件 B5
===================onNext A5B5
===================onComplete

可以发现最终接收到的事件数量是5个，那么为什么第二个Observable没有发送第6个事件呢？因为在这之前第一个Observable已经发送了onComplete事件，所以第二个Observable不会再发送事件。

6、combineLatest() & combineLatestDelayError()
combineLatest()的作用与zip()类似，但是combineLatest()发送事件的序列是与发送的时间线有关系的，当combineLatest()中所有Observable都发送了事件，只要其中有一个Observable发送事件这个事件就会和其他Observable最近发送的事件结合起来发送。

方法签名：
public static <T1, T2, R> Observable<R> combineLatest(ObservableSource<? extends T1> source1, ObservableSource<? extends T2> source2, BiFunction<? super T1, ? super T2, ? extends R> combiner)
....... 


Observable.combineLatest(
Observable.intervalRange(1, 4, 1, 1, TimeUnit.SECONDS)
    .map(new Function < Long, String > () {@Override
    public String apply(Long aLong) throws Exception {
        String s1 = "A" + aLong;
        Log.d(TAG, "===================A 发送的事件 " + s1);
        return s1;
    }
}),
Observable.intervalRange(1, 5, 2, 2, TimeUnit.SECONDS)
    .map(new Function < Long, String > () {@Override
    public String apply(Long aLong) throws Exception {
        String s2 = "B" + aLong;
        Log.d(TAG, "===================B 发送的事件 " + s2);
        return s2;
    }
}),
new BiFunction < String, String, String > () {@Override
    public String apply(String s, String s2) throws Exception {
        String res = s + s2;
        return res;
    }
})
.subscribe(new Observer < String > () {
    @Override
    public void onSubscribe(Disposable d) {
        Log.d(TAG, "===================onSubscribe ");
    }

    @Override
    public void onNext(String s) {
        Log.d(TAG, "===================最终接收到的事件 " + s);
    }

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

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

Observable会每隔1秒发送一个事件，ObservableB会每隔2秒发送一个事件，打印结果：

===================onSubscribe 
===================A 发送的事件 A1
===================A 发送的事件 A2
===================B 发送的事件 B1
===================最终接收到的事件 A2B1
===================A 发送的事件 A3
===================最终接收到的事件 A3B1
===================A 发送的事件 A4
===================B 发送的事件 B2
===================最终接收到的事件 A4B1
===================最终接收到的事件 A4B2
===================B 发送的事件 B3
===================最终接收到的事件 A4B3
===================B 发送的事件 B4
===================最终接收到的事件 A4B4
===================B 发送的事件 B5
===================最终接收到的事件 A4B5
===================onComplete

分析上面结果可以直到，当发送A1事件之后，因为B并没有发送任何事件，所以根本不会发生结合。当B发送了B1事件之后，就会与A最近发送的事件A2结合成A2B1,这样只有后面一有被观察者发送事件，这个事件就会与其他被观察者最近发送的事件结合起来。
因为combineLatestDelayError（）就是多了延迟发送OnError()功能，不再举例。
7、reduce():与scan()操作符的作用也是将发送数据以一定的逻辑聚合起来，这两个的区别在于scan()每处理一个数据就会将事件发送给观察者，而reduce()会将所有数据聚合在一起才会发送事件给观察者。

方法签名：
public final Maybe<T> reduce(BiFunction<T, T, T> reducer)


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

打印结果

 ====================integer 0
====================integer2 1
====================res 1
====================integer 1
====================integer2 2
====================res 3
====================integer 3
====================integer2 3
====================res 6
==================accept 6

从结果上看，其实就是前两个数据聚合之后，然后再与后一个数据进行聚合，一直到没有数据为止。

8、collect():将数据收集到数据结构当中

方法签名：
public final <U> Single<U> collect(Callable<? extends U> initialValueSupplier, BiConsumer<? super U, ? super T> collector)

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.d(TAG, "===============accept " + integers);
    }
});

打印结果：

 ===============accept [1, 2, 3, 4]

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

方法签名：
public final Observable<T> startWith(T item)
public final Observable<T> startWithArray(T... items)

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

打印结果：

================accept 1
================accept 2
================accept 3
================accept 4
================accept 5
================accept 6
================accept 7

10、count()：
返回被观察者发送事件的数量

方法签名：
public final Single<Long> count()

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

打印结果：

=======================aLong 3

hbgaozhiwei

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
RxJava组合操作符

1、concat():可以将多个观察者组合在一起，然后按照之前发送顺序发送事件。需要注意的是，concat()最多只可以发送4个事件。方法签名：public static &lt;T&gt; Observable&lt;T&gt; concat(ObservableSource&lt;? extends T&gt; source1, ObservableSource&lt;? extends ...
复制链接

扫一扫

专栏目录