RxJava2操作符之Zip

梦里梦外; 2022-05-04 05:56 515阅读 0赞

# 概述 #

在文章[RxJava2操作符之flatMap与concatMap][RxJava2_flatMap_concatMap]中介绍了RxJava2中常用到的两个操作符，本文介绍一下另一个比较常用的操作符**zip**

# 使用场景 #

**zip**一般用在某一个界面的数据通过不同的来源获取时。例如我们要展示一个页面，而这个页面的数据一部分是通过A接口获得的，另一部分是通过B接口获得的，还有一部分是本地文件读取的，那么这种场景下就可以使用zip操作符，将三方数据组合好后同时展示出来。

# zip详解 #

## 定义 ##

官方解释：

> Returns an Observable that emits the results of a specified combiner function applied to combinations of n items emitted, in sequence, by n other ObservableSources.  
> 操作符返回一个Observable ，这个Observable会按顺序发射由多个ObservableSources 发射的数据通过一个组合函数组合而成的多个数据项。

定义过于抽象，让我们来看一下说明图  
![在这里插入图片描述][zip.png]  
上图演示的是由两个Observable 来进行合并的过程，第一行的数据项与第二行的数据项按照顺序合并。  
首先我们看到中间的zip操作符采用的组合函数的含义为：将一个白色的图形与某个颜色的三角形组合后就会将白色图形染上三角形的颜色。  
通过这个zip操作，可以看到第一个数据源的白色圆圈与第二个数据源的黄色三角形组合后变成了一个黄色的圆圈，剩下的数据项以此类推，可以看到是顺序执行的。  
**note**:上图存在没有表现出的信息: 如果第一个数据源只有两个数据项，例如只有圆圈和五边形，那么最后组合后的数据也只有两项。

## 实例 ##

**zip**有很多重载，可以组合多达九个数据源，我们最常使用的也就是2到3个数据源的场景。

假设我们有一个程序员类,包括姓名，年龄和地址等属性。

class Programmer{
            private int age;
            private String name;
            private String address;
    
            public Programmer(int age, String name) {
                this(age,name,null);
            }
    
            public Programmer(int age, String name, String address) {
                this.age = age;
                this.name = name;
                this.address = address;
            }
    
            @Override
            public String toString() {
                return "Programmer{" +
                        "age=" + age +
                        ", name='" + name + '\'' +
                        ", address='" + address + '\'' +
                        '}';
            }
        }

其中假设年龄，姓名以及地址信息只能单独获取到，我们的任务就是将单独获取到的这些信息最终生成一个程序员对象。下面的代码是获取姓名，年龄等的方法。

//获取年龄，会耗时3秒
        private Observable<Integer> getSs007Age(){
            return Observable.just(18).delay(3,TimeUnit.SECONDS);
        }
        private Observable<String> getSs007Name(){
            return Observable.just("WangBen");
        }
        private Observable<String> getSs007Address(){
            return Observable.just("TianJin");
        }
    
        //下面两个为批量获取程序员年龄与姓名的函数
        private Observable<Integer> getProgrammersAge(){
            return Observable.fromArray(new Integer[]{18,19});
        }
        private Observable<String> getProgrammersName(){
            return Observable.fromArray(new String[]{"max","ben","leo"});
        }

下面通过几种场景的实际操作来演示其具体的使用方式：

1.  获取年龄和姓名来生成一个`Programer`对象。

Observable.zip(getSs007Age(), getSs007Name(), new BiFunction<Integer, String, Programmer>() {
         @Override
         public Programmer apply(Integer integer, String s) throws Exception {
             return new Programmer(integer,s);
         }
     }).subscribe(new Consumer<Programmer>() {
         @Override
         public void accept(Programmer programmer) throws Exception {
             Log.d("zip",programmer.toString());
         }
     });

输出结果：

Programmer{age=18, name='WangBen', address=null}

值得注意的是，这句log不是立刻展示的，而是过了大概3秒后出现，所以我们可以知道，最后的组合结果生成的时间是由耗时最长那个数据源决定的。

可以看到我们使用的组合函数是实现的`BiFunction`函数接口。

1.  获取年龄和姓名以及地址来生成一个`Programer`对象。

Observable.zip(getSs007Age(), getSs007Name(), getSs007Address(), new Function3<Integer, String, String, Programmer>() {
        @Override
        public Programmer apply(Integer integer, String s, String s2) throws Exception {
            return new Programmer(integer,s,s2);
        }
    } ).subscribe(new Consumer<Programmer>() {
        @Override
        public void accept(Programmer programmer) throws Exception {
            Log.d("zip",programmer.toString());
        }
    });

输出结果为：

Programmer{age=18, name='WangBen', address='TianJin'}

与使用两个数据源组合几乎一样，只是组合函数使用了`Function3`函数接口。以此类推，4个数据源组合就使用`Function4`函数接口，直到`Function9`。

1.  批量获取程序员姓名与年龄，然后生成程序员实例

Observable.zip(getProgrammersAge(), getProgrammersName(), new BiFunction<Integer, String, Programmer>() {
        @Override
        public Programmer apply(Integer age, String name) throws Exception {
            return new Programmer(age,name);
        }
    }).subscribe(new Consumer<Programmer>() {
        @Override
        public void accept(Programmer programmers) throws Exception {
            Log.d("zip",programmers.toString());
        }
    });

输出结果为：

Programmer{age=18, name='max', address='null'}
     Programmer{age=19, name='ben', address='null'}

其中`getProgrammersAge()`发射两个数据项18、19，而 `getProgrammersName()`发射3个数据项“max”、“ben”、“leo”，但是最后的结果只组合了两个对象。可见最终的组合结果是受发射数据最少的那个Observable限制的。

# 总结 #

善用RxJava的Java程序员会很幸福的！

[RxJava2_flatMap_concatMap]: https://blog.csdn.net/ShuSheng0007/article/details/83244212
[zip.png]: /images/20220504/b6a24ea455664a7094895720c9dd1b5e.png