Rx java 在RxJava中，reduce表达式的类型是什么

考虑以下几点：

import io.reactivex.Observable;
import io.reactivex.observables.GroupedObservable;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;

public class TypeTest {
    public static void main(String[] args) throws Exception {
        CountDownLatch latch = new CountDownLatch(1);
        Observable<Long> source = Observable.interval(1,TimeUnit.MILLISECONDS).take(20);
        Observable<GroupedObservable<String,Long>> sgb = 
                         source.groupBy(x -> (x%2==0)?"Even":"Odd");

        // I'd like to introduce a variable for source.reduce but I get a type error.
        // Observable<Long> sreduce = source.reduce(new Long(0),(x,y) -> (x+y));

        source.reduce(new Long(0),(x,y)->(x+y)).subscribe(x -> {
            System.out.println(x);
            latch.countDown();
        });
        latch.await();
    }
}

import io.reactivex.Observable；
导入io.reactivex.observates.groupedobservatable；
导入java.util.concurrent.CountDownLatch；
导入java.util.concurrent.TimeUnit；
公共类类型测试{
公共静态void main（字符串[]args）引发异常{
CountDownLatch闩锁=新的CountDownLatch（1）；
可观测源=可观测间隔（1，时间单位毫秒）。取（20）；
可观测sgb=
groupBy（x->（x%2==0）？“偶数”：“奇数”）；
//我想为source.reduce引入一个变量，但我得到了一个类型错误。
//可观测的还原=源还原（新长（0），（x，y）->（x+y））；
source.reduce（新长（0）、（x，y）->（x+y））。订阅（x->{
系统输出println（x）；
倒计时（）；
});
satch.wait（）；
}
}

---

我可以订阅source.reduce，就好像它是可观察的一样，但我不能将它指定为它的类型。我应该分配什么类型？

如果您检查

reduce（）

方法的签名，您将看到：

public final <R> Observable<R> reduce(R initialValue, Func2<R, ? super T, R> accumulator) {

public final Observable reduce（R初始值，Func2累加器）{

在您的情况下，它将是一个可观察的

：

Observable source=Observable.interval（1，TimeUnit.ms）。取（20）；
可观测的还原=源还原（新长（0），（x，y）->（x+y））；

---

正如示例中的代码所示，您正在执行

source.reduce（…）.subscribe（…）

，它已经返回了

Subscription

。

如果检查

reduce（）

方法的签名，您将看到：

public final <R> Observable<R> reduce(R initialValue, Func2<R, ? super T, R> accumulator) {

public final Observable reduce（R初始值，Func2累加器）{

在您的情况下，它将是一个可观察的

：

Observable source=Observable.interval（1，TimeUnit.ms）。取（20）；
可观测的还原=源还原（新长（0），（x，y）->（x+y））；

---

正如示例中的代码所示，您正在执行

source.reduce（…）.subscribe（…）

，它已经返回了

订阅

。

您正在使用从包

io.reactivex

导入，这意味着您正在使用RxJava 2。在RxJava 2中，返回只有一项的反应流的方法（就像

reduce

的结果一样），返回

Single

，而不是

observeable

大多数方法/运算符都是相同的，甚至有一个

.toObservable（）

方法可以将特定的转换为泛型

侧重点1:your

grouped

操作符对键进行评估，但对结果不做任何处理；由于没有订阅该可观察项，因此不会启动计时器

旁白2：您不需要使用

倒计时闩锁来等待完成。您可以执行以下操作之一：

    source.reduce(new Long(0), (x, y) -> (x + y))
          .doOnSuccess(System.out::println)
          .toFuture()
          .get();

或

您使用的是从包
io.reactivex
导入，这意味着您使用的是RxJava 2。在RxJava 2中，返回只包含一个项的反应流的方法（如
reduce
），返回
单个
，而不是
可观察的

大多数方法/运算符都是相同的，甚至有一个
.toObservable（）
方法可以将特定的转换为泛型

侧重点1:your
grouped
操作符对键进行评估，但对结果不做任何处理；由于没有订阅该可观察项，因此不会启动计时器

旁白2：您不需要使用
倒计时闩锁来等待完成。您可以执行以下操作之一：

    source.reduce(new Long(0), (x, y) -> (x + y))
          .doOnSuccess(System.out::println)
          .toFuture()
          .get();

或

好的，这似乎是类型推断中的一个bug。如果我抛出它，它运行良好。好的，这似乎是类型推断中的一个bug。如果我抛出它，它运行良好。