RxJava过滤并发出其他项

有可能像下面这样过滤并继续发射ITEN吗

---

我呼叫订户2次的代码：

Observable<Map.Entry<String, ArrayList<MockOverview>>> requestEntries =
        this.requestView.request(request)
        .map(HashMap::entrySet)
        .flatMapIterable(entries -> entries);

requestEntries.filter(entry -> entry.getKey().equals("featured"))
        .map((Func1<Map.Entry<String, ArrayList<MockOverview>>, List<MockOverview>>) Map.Entry::getValue)
        .subscribe(mockOverviews -> {
            Log.i("subscrive", "featured");
        });

requestEntries.filter(entry -> entry.getKey().equals("done"))
        .map((Func1<Map.Entry<String, ArrayList<MockOverview>>, List<MockOverview>>) Map.Entry::getValue)
        .subscribe(mockOverviews -> {
            Log.i("subscrive", "featured");
        });

可观察的请求条目=
this.requestView.request（请求）
.map（HashMap:：entrySet）
.flatMapIterable（条目->条目）；
requestEntries.filter（entry->entry.getKey（）.equals（“特色”））
.map（（Func1）map.Entry:：getValue）
.订阅（模拟概述->{
Log.i（“订阅”、“特色”）；
});
requestEntries.filter（entry->entry.getKey（）.equals（“done”））
.map（（Func1）map.Entry:：getValue）
.订阅（模拟概述->{
Log.i（“订阅”、“特色”）；
});

---

我想要的是：

 requestEntries.filter(entry -> entry.getKey().equals("featured"))
        .map((Func1<Map.Entry<String, ArrayList<MockOverview>>, List<MockOverview>>) Map.Entry::getValue)
        .subscribe(mockOverviews -> {

        })
        .filter(entry -> entry.getKey().equals("done"))
        .map((Func1<Map.Entry<String, ArrayList<MockOverview>>, List<MockOverview>>) Map.Entry::getValue)
        .subscribe(mockOverviews -> {

        });

requestEntries.filter（entry->entry.getKey（）.equals（“特色”））
.map（（Func1）map.Entry:：getValue）
.订阅（模拟概述->{
})
.filter（entry->entry.getKey（）.equals（“完成”））
.map（（Func1）map.Entry:：getValue）
.订阅（模拟概述->{
});

您可以使用

doOnNext

代替第一个

subscribe（）

或者使用

发布（Func1）

：

---

从外观上看，您的第二个版本并不等同于第一个版本：前者两次查看

requestEntries

流，分别过滤特征键和完成键，并使用它们做自己的事情。但是，您的第二个版本首先过滤功能，然后进行一些转换和副作用，然后过滤掉已完成的内容。然而，在第二个过滤器lambda中，

可观察的

根本不在范围内

这里需要做的是在

requestEntries

上使用，在lambda中使用第一个版本中的内容，使用

onNext

而不是

subscribe

，

合并

流并返回组合流。然后在

publish

之外订阅一次（在那里什么也不做），或者继续在其他地方使用流的结果

requestEntries.publish(re -> {
    Observable<...> x = re.filter(...<featured>...).map(...).doOnNext(...Log.i(...));
    Observable<...> y = re.filter(...<done>...).map(...).doOnNext(...Log.i(...));
    return x.mergeWith(y);
})

requestEntries.publish（re->{
可观测x=re.filter（…）.map（…）.doOnNext（…Log.i（…）；
可观测y=re.filter（…）.map（…）.doOnNext（…Log.i（…）；
返回x.mergeWith（y）；
})

 requestEntry.filter(v -> ...)
 .map(v -> ...)
 .publish(o -> {
     o.subscribe(...);
     return o;
 })
 .filter(v -> ...)
 .map(v -> ...)
 .subscribe(...)

requestEntries.publish(re -> {
    Observable<...> x = re.filter(...<featured>...).map(...).doOnNext(...Log.i(...));
    Observable<...> y = re.filter(...<done>...).map(...).doOnNext(...Log.i(...));
    return x.mergeWith(y);
})