Android RxJava加入列表

试图理解所有RxJava的东西。我在做下面的例子：

private Observable<List<String>> query1() {
    List<String> urls = new ArrayList<>();
    urls.add("1");
    urls.add("2");
    urls.add("3");
    urls.add("4");

    return Observable.just(urls);
}

private Observable<List<String>> query2() {
    List<String> urls = new ArrayList<>();
    urls.add("A");
    urls.add("B");
    urls.add("C");
    urls.add("D");

    return Observable.just(urls);
}

私有可观察查询1（）{
列表URL=新的ArrayList（）；
添加（“1”）；
添加（“2”）；
添加（“3”）；
添加（“4”）；
返回可观察的.just（URL）；
}
私有可观察查询2（）{
列表URL=新的ArrayList（）；
URL。添加（“A”）；
URL。添加（“B”）；
添加（“C”）；
URL。添加（“D”）；
返回可观察的.just（URL）；
}

然后尝试加入两个列表：

 Observable.zip(
            query1(),
            query2(),
            new Func2<List<String>, List<String>, Observable<String>>() {
                @Override
                public Observable<String> call(List<String> a1, List<String> a2) {
                    List<String> list = new ArrayList<>();
                    list.addAll(a1);
                    list.addAll(a2);
                    return Observable.from(list);
                }
            })
            .subscribe(new Action1<String>() {  // <-- It says, cannot resolve method subscribe
                @Override
                public void call(String string) {
                    String text = testTextView.getText().toString();
                    testTextView.setText(text + "\n" + string);
                }
            });

Observable.zip(
查询1（），
query2（），
新功能2（）{
@凌驾
公共可观测呼叫（列表a1、列表a2）{
列表=新的ArrayList（）；
列表。添加全部（a1）；
列表。addAll（a2）；
从（列表）中可观察到的返回；
}
})
.subscribe（new Action1（）{/这是因为您试图从zip函数返回Observable，但随后您传递了
Action

Observable.zip(
查询1（），
query2（），
新功能2（）{
@凌驾
公共列表呼叫（列表a1、列表a2）{
列表=新的ArrayList（）；
列表。添加全部（a1）；
列表。addAll（a2）；
退货清单；
}
})
.订阅(
（字符串）->System.out.println（字符串）
);
我相信您正在寻找的运营商是
concat
或
merge

Concat
将从两个或多个
可观察的
s发出排放，而不交错它们

另一方面，
Merge
将通过合并其发射来合并多个观测值

例如：

    String[] numbers = {"1", "2", "3", "4"};

    String[] letters = {"a", "b", "c", "d"};

    Observable<String> query1 = Observable.from(numbers).delay(1, TimeUnit.SECONDS);
    Observable<String> query2 = Observable.from(letters);

    Observable
            .concat(query1, query2)
            .subscribe(s -> {
                System.out.printf("-%s-" + s);
            });

将输出
-（1，a）-（2，b）-（3，c）-（4，d）
可观察查询1（）{
列表s=新的ArrayList（）；
s、 添加（“1”）；s.add（“1”）；s.add（“1”）；
可观察到的回报。仅（s）；
}
可观测查询2（）{
列表s=新的ArrayList（）；
s、 添加（“1”）；s.add（“1”）；s.add（“1”）；
可观察到的回报。仅（s）；
}
void HelloRx（）{
Map map2=new LinkedHashMap（）；//在此处选择要返回的结果！
zip（query1（），//可观察方法1
query2（），//可观察方法2
（结果1，结果2）->{
for（String s:result1）{//result1是由query1、result2…返回的值。
//你想干什么就干什么
//地图放置（……）
}
返回null；
})
.subscribeOn（BackgroundSchedulers.getMultiThreadInstance（））
.observeOn（AndroidSchedulers.mainThread（））
.doOnCompleted（（）->{
//完成后执行一些操作，例如将数据传输到适配器
})
.subscribe（）；
}
显然，要将两个列表合并为一个列表，您可以对它们的
Observable.from（）
执行
Observable.concat（）
，然后调用
Observable.toList（）

RealmResults equalTo；
真正的结果始于；
@凌驾
公共void onViewRestored（）{
compositeSubscription=新compositeSubscription（）；
equalTo=realm.where（Cat.class）.equalTo（“字段”，filterString.findAllSorted（“字段”）；
beginsWith=realm.where（Cat.class）.beginsWith（“field”，filterString.findAllSorted（“field”）；
compositeSubscription.add（realm.asObservable（）
.switchMap（新函数1（）{
@凌驾
公共可观察调用（领域）{
返回可观测的concat（可观测的from（equalTo），可观测的from（beginsWith））；
}
})
托利斯先生（）
.订阅（猫->{
//使用列表更新适配器
}));
我不得不将flatMap添加到您发布的内容中（编辑了我的问题）。感谢
concat
示例。
Observable.zip(
            query1(),
            query2(),
            new Func2<List<String>, List<String>, List<String>>() {
                @Override
                public List<String> call(List<String> a1, List<String> a2) {
                    List<String> list = new ArrayList<>();
                    list.addAll(a1);
                    list.addAll(a2);
                    return list;
                }
            })
            .subscribe(
                    (string)-> System.out.println(string)
            );

    String[] numbers = {"1", "2", "3", "4"};

    String[] letters = {"a", "b", "c", "d"};

    Observable<String> query1 = Observable.from(numbers).delay(1, TimeUnit.SECONDS);
    Observable<String> query2 = Observable.from(letters);

    Observable
            .concat(query1, query2)
            .subscribe(s -> {
                System.out.printf("-%s-" + s);
            });

    Observable
            .zip(query1, query2, (String n, String l) -> String.format("(%s, %s)", n, l))
            .subscribe(s -> {
                System.out.printf("-%s-", s);
            });

    Observable<List<String>> query1(){
        List<String> s = new ArrayList<>();
        s.add("1");s.add("1");s.add("1");
        return Observable.just(s);
    }
    Observable<List<String>> query2(){
        List<String> s = new ArrayList<>();
        s.add("1");s.add("1");s.add("1");
        return Observable.just(s);
    }
    void HelloRx(){
        Map<String,String> map2=new LinkedHashMap<>();//pick the result you want to return  Here !
        Observable.zip(query1(),//Observable Method 1
                query2(),//Observable Method 2
                (result1,result2)->{
                    for(String s : result1){//result1 is the value returned by query1 , result2 ...u know.
                        //do whatever you want
                        //map.put(......)
                    }
                    return null;
                })
                .subscribeOn(BackgroundSchedulers.getMultiThreadInstance())
                .observeOn(AndroidSchedulers.mainThread())
                .doOnCompleted(() -> {
                   //Do Something when finish for example transmit data to your adapter
                })
                .subscribe();
    }

RealmResults<Cat> equalTo;
RealmResults<Cat> beginsWith;

@Override
public void onViewRestored() {
    compositeSubscription = new CompositeSubscription();
    equalTo = realm.where(Cat.class).equalTo("field", filterString).findAllSorted("field");
    beginsWith = realm.where(Cat.class).beginsWith("field", filterString).findAllSorted("field");
    compositeSubscription.add(realm.asObservable()
            .switchMap(new Func1<Realm, Observable<Cat>>() {
                @Override
                public Observable<Cat> call(Realm realm) {
                    return Observable.concat(Observable.from(equalTo), Observable.from(beginsWith));
                }
            })
            .toList()
            .subscribe(cats -> {
                // update adapter with List<Cat>
            }));