Rx java RxJava zip在不同长度的可观测阵列上的操作

我有一个可变长度的可观测阵列。我希望压缩请求（即，生成一堆API请求并等待它们全部完成），但我不知道如何实现zip函数

Observable.zip(observables, new FuncN<List<ResponseBody>>() {
    @Override
    public List<ResponseBody> call(Object... args) {
        return Arrays.asList(args); <- compile error here
    }
});

Observable.zip（observables，new FuncN（）{
@凌驾
公共列表调用（对象…参数）{
返回Arrays.asList（args）；仅显示您的观察值，并使用
toList
收集结果：

Observable.merge(observables).toList()

我确认
merge
操作员工作并找到导致订单的罪魁祸首：
1st request，1st response，2nd request，2nd response，3rd request，3rd response

添加过程中，
observatables
列表中的observatable未在
Scheduler.io（）
上订阅

以前：

observables.add(mViewModelDelegate.get().getApiService()
                    .rxGetCategoryBrandList(baseUrl, categoryId));

之后：

observables.add(mViewModelDelegate.get().getApiService()
                    .rxGetCategoryBrandList(baseUrl, categoryId)
                    .subscribeOn(Schedulers.io())
                    .observeOn(AndroidSchedulers.mainThread());

用户合并并确保所有可观察的请求都有自己的线程。
您可以尝试以下方法：

private void runMyTest() {
    List<Single<String>> singleObservableList = new ArrayList<>();
    singleObservableList.add(getSingleObservable(500, "AAA"));
    singleObservableList.add(getSingleObservable(300, "BBB"));
    singleObservableList.add(getSingleObservable(100, "CCC"));
    Single.merge(singleObservableList)
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe(System.out::println);
}

private Single<String> getSingleObservable(long waitMilliSeconds, String name) {
    return Single
            .create((SingleOnSubscribe<String>) e -> {
                    try {
                        Thread.sleep(waitMilliSeconds);
                    } catch (InterruptedException exception) {
                        exception.printStackTrace();
                    }
                    System.out.println("name = " +name+ ", waitMilliSeconds = " +waitMilliSeconds+ ", thread name = " +Thread.currentThread().getName()+ ", id =" +Thread.currentThread().getId());
                    if(!e.isDisposed()) e.onSuccess(name);
                })
            .subscribeOn(Schedulers.io());
}

private void runMyTest（）{
List singleObservableList=新建ArrayList（）；
添加（getSingleObservable（500，“AAA”）；
添加（getSingleObservable（300，“BBB”）；
添加（getSingleObservable（100，“CCC”）；
Single.merge（singleobserveList）
.observeOn（AndroidSchedulers.mainThread（））
.subscribe（System.out:：println）；
}
私有单getSingleObservable（长等待毫秒，字符串名称）{
返回单
.创建（（SingleOnSubscribe）e->{
试一试{
睡眠（等待毫秒）；
}捕获（中断异常异常）{
异常。printStackTrace（）；
}
System.out.println（“name=“+name+”，waitmillizes=“+waitmillizes+”，thread name=“+thread.currentThread（）.getName（）+”，id=“+thread.currentThread（）.getId（））；
如果（！e.isDisposed（））e.onSuccess（名称）；
})
.subscribeOn（Schedulers.io（））；
}

输出：

System.out:name=CCC，waitms=100，线程名=
RxCachedThreadScheduler-4，id=463

系统输出：CCC

System.out:name=BBB，waitms=300，线程名=
RxCachedThreadScheduler-3，id=462

系统输出：BBB

System.out:name=AAA，wait毫秒=500，线程名=
RxCachedThreadScheduler-2，id=461

系统输出：AAA

到底是什么问题？返回的FuncN方法类型是由使用zip方法创建的运算符发出的项的类型，这意味着您将有Observable@yosriz，问题是
Arrays.asList（args）
不是
List
类型，它会导致编译错误。我可以知道
merge
操作是否会阻止每个请求吗？我希望同时异步启动请求，这样请求就不会相互阻止。
merge
不会阻止，但
可观察。concat
willI我只是想试试，我找到了请求uests正在一个接一个地发送，即，在第二个请求被激发之前，只有第一个请求的had响应…您的意思是您得到了以下顺序：
1st request，1st response，2nd request，2nd response，3rd request，3rd response
？是的，我使用merge时得到了这个顺序。