Android 动态观察多个改装组合

我有一个观察列表，如下所示：

 List<Observable<MyObj>> listObservables = new ArrayList<Observable<MyObj>>();

我有一个包装obj：

class MyWrapperObj {
    private MyObj1 onj1;
    private MyObj2 onj2;
    private MyObj3 onj3;

    public MyWrapperObj(MyObj1 onj1, MyObj2 onj2, MyObj3 onj3) {
        this.onj1 = onj1;
        this.onj2 = onj2;
        this.onj3 = onj3;
    }
}

所以我可以这样组合它们：

 Observable<MyWrapperObj> combinedObservable = Observable.zip(obs1, obs2, obs3, new Func3<MyObj1, MyObj2, MyObj3, MyWrapperObj>() {
        @Override
        public MyWrapperObj call(MyObj1 obj1, MyObj2 obj2, MyObj3 obj3) {
            return new MyWrapperObj(obj1, obj2, obj3);
        }
    });

    combinedObservable.observeOn(AndroidSchedulers.mainThread())
            .subscribeOn(Schedulers.io())
            .subscribe(new Subscriber<MyWrapperObj>() {
                @Override
                public void onCompleted() {                       
                }

                @Override
                public void onError(Throwable throwable) {
                }

                @Override
                public void onNext(MyWrapperObj wrapperObj) {
                }
            });

Observable combinedbservable=Observable.zip（obs1、obs2、obs3、newfunc3（）{
@凌驾
公共MyWrapperObj调用（MyObj1 obj1、MyObj2 obj2、MyObj3 obj3）{
返回新的MyWrapperObj（obj1、obj2、obj3）；
}
});
组合的observable.observeOn（AndroidSchedulers.mainThread（））
.subscribeOn（Schedulers.io（））
.subscribe（新订户（）{
@凌驾
未完成的公共void（）{
}
@凌驾
公共作废登记员（可丢弃）{
}
@凌驾
public void onNext（MyWrapperObj wrapperObj）{
}
});

一切都很好，所以我的问题是，如何组织这个组合，使它成为n个可观察的

响应

正如@maciekjanusz在其回答中提到的，我做到了：

  Observable<MyWrapperObj> combinedObservable = Observable.zip(listObservables, new FuncN<MyWrapperObj>() {
        @Override
        public MyWrapperObjcall(Object... args) {
            return null;
        }
    });

Observable combinedbservable=Observable.zip（listObservables，new FuncN（）{
@凌驾
公共MyWrapperObjcall（对象…参数）{
返回null；
}
});

您可以使用 .zip（observe1，…，observeen，funcN）.first（）运算符。有一个重载，接受Observable>参数（如在FlatMap中）

---

第一个重载接受Iterable>-您可以传递任意大小的可观察对象列表，第二个参数-FuncN-接收值列表

假设您拥有以下列表：

List<Observable<MyObj>> listObservables

---

如果要

zip

n可观察对象，请将它们放入列表中，并应用

公共静态可观察zip（@NotNull java.lang.Iterable>ws，rx.functions.FuncN问题是我不知道n，它可以是1-10，所以我不能设置FunNfirst重载接受Iterable和FuncN，所以你可以传递观察列表，FuncN接收参数数组。你说的压缩代码是什么意思？我需要接收一个MyObj的列表作为对f Observable在我的示例中
Observable.zip（observables，Arrays:：asList）；
如果
observables
类型为
Iterable
List<Observable<MyObj>> listObservables

Observable.concatDelayError(listObservables);

List<Observable<String>> observables = Arrays.asList(Observable.just("String 1"), Observable.just("String 2"));

Observable.zip(observables, args -> {
    // put your zipping code here
});

Observable.zip(observables, Arrays::asList);

Observable.zip(observables, args -> Arrays.asList(args));