Rx java 以下情况下出现RxJava编译错误

我想尝试一下非常简单的RxJava代码，如下所示

 int[] test = {1,2,3,4};
 Observable<Integer> findAverage = Observable.fromArray(test);
 averageInteger(findAverage).subscribe(System.out::println); 

int[]test={1,2,3,4}；
可观测的findAverage=可观测的数组（测试）；
averageInteger（findAverage）.subscribe（System.out:：println）；

首先，我遇到了observable.fromArray（test）的编译错误（不可数边界）

---

第二，似乎再也找不到几位企业家了。我使用的是RxJava的2.0.8版本。

这是因为findAverage的类型错误：

应该是：

Observable<int[]> observable = Observable.fromArray(array);

Observable-Observable=Observable.fromArray（数组）；

带有以下Gradle包的完整示例：“com.github.akarnokd:rxjava2扩展：0.16.4”

List integers=Arrays.asList（1,2,3,4）；
可观测的整数可观测=可观测的。可观测的（整数）；
Observable doubleObservable=MathObservable.averageDouble（整数可观测）；
doubleObservable.subscribe（System.out:：println）；

作为操作员执行：

@Test
public void averageDoubleOperator() throws Exception {
    List<Integer> integers = Arrays.asList(1, 2, 3, 4);

    Observable<Integer> integerObservable = Observable.fromIterable(integers);

    integerObservable.lift(new AvgOperator())
            .test()
            .assertResult(2.5);
}

@Test
public void averageDoubleOperator_empty() throws Exception {
    List<Integer> integers = Collections.emptyList();

    Observable<Integer> integerObservable = Observable.fromIterable(integers);

    integerObservable.lift(new AvgOperator())
            .test()
            .assertTerminated()
            .assertError(IllegalStateException.class);
}

class Avg {
    long count;
    int sum;

    Avg(long count, int sum) {
        this.count = count;
        this.sum = sum;
    }
}

class AvgOperator implements ObservableOperator<Double, Integer> {
    @Override
    public Observer<? super Integer> apply(Observer<? super Double> observer) throws Exception {
        return new Operation(observer);
    }

    class Operation implements Observer<Integer> {
        private final Observer<? super Double> observer;
        private Subscription s;
        private long sum;
        private int count;

        Operation(Observer<? super Double> observer) {
            this.observer = observer;
        }

        @Override
        public void onSubscribe(Disposable d) {
            observer.onSubscribe(d);
        }

        @Override
        public void onNext(Integer integer) {
            ++count;
            sum = sum + integer;
        }

        @Override
        public void onError(Throwable t) {
            this.observer.onError(t);
        }

        @Override
        public void onComplete() {
            if (count == 0) {
                this.onError(new IllegalStateException("Average is not defined for 0 values."));
                return;
            }
            this.observer.onNext(sum / (double) count);
            this.observer.onComplete();
        }
    }
}

@测试
public void averageDoubleOperator（）引发异常{
List integers=Arrays.asList（1,2,3,4）；
可观测的整数可观测=可观测的。可观测的（整数）；
integerObservable.lift（新的AvgOperator（））
.test（）
.资产评估结果（2.5）；
}
@试验
public void averageDoubleOperator_empty（）引发异常{
List integers=Collections.emptyList（）；
可观测的整数可观测=可观测的。可观测的（整数）；
integerObservable.lift（新的AvgOperator（））
.test（）
.资产终止（）
.assertError（IllegalStateException.class）；
}
平均等级{
长计数；
整数和；
平均值（长计数、整数和）{
this.count=计数；
this.sum=sum；
}
}
类AVGOOperator实现ObserveOperator{
@凌驾
公共观察者这是因为findAverage类型错误：

应该是：

Observable<int[]> observable = Observable.fromArray(array);

Observable-Observable=Observable.fromArray（数组）；

带有以下Gradle包的完整示例：“com.github.akarnokd:rxjava2扩展：0.16.4”

List integers=Arrays.asList（1,2,3,4）；
可观测的整数可观测=可观测的。可观测的（整数）；
Observable doubleObservable=MathObservable.averageDouble（整数可观测）；
doubleObservable.subscribe（System.out:：println）；

作为操作员执行：

@Test
public void averageDoubleOperator() throws Exception {
    List<Integer> integers = Arrays.asList(1, 2, 3, 4);

    Observable<Integer> integerObservable = Observable.fromIterable(integers);

    integerObservable.lift(new AvgOperator())
            .test()
            .assertResult(2.5);
}

@Test
public void averageDoubleOperator_empty() throws Exception {
    List<Integer> integers = Collections.emptyList();

    Observable<Integer> integerObservable = Observable.fromIterable(integers);

    integerObservable.lift(new AvgOperator())
            .test()
            .assertTerminated()
            .assertError(IllegalStateException.class);
}

class Avg {
    long count;
    int sum;

    Avg(long count, int sum) {
        this.count = count;
        this.sum = sum;
    }
}

class AvgOperator implements ObservableOperator<Double, Integer> {
    @Override
    public Observer<? super Integer> apply(Observer<? super Double> observer) throws Exception {
        return new Operation(observer);
    }

    class Operation implements Observer<Integer> {
        private final Observer<? super Double> observer;
        private Subscription s;
        private long sum;
        private int count;

        Operation(Observer<? super Double> observer) {
            this.observer = observer;
        }

        @Override
        public void onSubscribe(Disposable d) {
            observer.onSubscribe(d);
        }

        @Override
        public void onNext(Integer integer) {
            ++count;
            sum = sum + integer;
        }

        @Override
        public void onError(Throwable t) {
            this.observer.onError(t);
        }

        @Override
        public void onComplete() {
            if (count == 0) {
                this.onError(new IllegalStateException("Average is not defined for 0 values."));
                return;
            }
            this.observer.onNext(sum / (double) count);
            this.observer.onComplete();
        }
    }
}

@测试
public void averageDoubleOperator（）引发异常{
List integers=Arrays.asList（1,2,3,4）；
可观测的整数可观测=可观测的。可观测的（整数）；
integerObservable.lift（新的AvgOperator（））
.test（）
.资产评估结果（2.5）；
}
@试验
public void averageDoubleOperator_empty（）引发异常{
List integers=Collections.emptyList（）；
可观测的整数可观测=可观测的。可观测的（整数）；
integerObservable.lift（新的AvgOperator（））
.test（）
.资产终止（）
.assertError（IllegalStateException.class）；
}
平均等级{
长计数；
整数和；
平均值（长计数、整数和）{
this.count=计数；
this.sum=sum；
}
}
类AVGOOperator实现ObserveOperator{
@凌驾
public observer您至少需要
Integer[]test={1,2,3,4}；
因为RxJava本身不支持基元数组。您至少需要
Integer[]test={1,2,3,4}因为RxJava本身不支持基元数组。看起来MathObservable来自RxJava math，rxjava2不支持它。MathObservable来自rxjava2扩展，因为原生rxjava2不支持它。您可以复制MathObservable的实现，或者使用reduce oper编写自己的实现ator。看起来MathObservable来自rxjava math，RxJava2a不支持它，因为MathObservable来自rxjava2扩展，因为原生rxjava2不支持它。您可以复制MathObservable的实现，也可以使用reduce运算符编写自己的实现。