RxJava - 只是与来自

Question

我在以下情况下使用 Observable.just 与 Observable.from 时得到相同的输出：

 public void myfunc() {
 //swap out just for from here and i get the same results,why ?
        Observable.just(1,2,3).subscribe(new Subscriber<Integer>() {
            @Override
            public void onCompleted() {
                Log.d("","all done. oncompleted called");
            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onNext(Integer integer) {
                Log.d("","here is my integer:"+integer.intValue());
            }
        });

    }

我认为 just 应该只发出一个项目，而 from 应该发出某种列表中的项目。有什么不同？我还注意到 just 和 from 只接受有限数量的参数。所以 Observable.just(1,2,3,4,5,6,7,8,-1,-2) 没问题，但 Observable.just(1,2,3,4,5,6,7,8,-1,-2,-3) 失败了。 from 也是如此，我必须将它包装在一个列表或数组中。我很好奇为什么他们不能定义无限制的参数。

更新：我进行了实验，发现 just 不采用数组结构，它只采用参数。 from拍了一个合集。所以以下适用于 from 但不适用于 just:

 public Observable myfunc() {
    Integer[] myints = {1,2,3,4,5,6,7,8,-1,-2,9,10,11,12,13,14,15};
   return  Observable.just(myints).flatMap(new Func1<Integer, Observable<Boolean>>() {
        @Override
        public Observable<Boolean> call(final Integer integer) {
            return Observable.create(new Observable.OnSubscribe<Boolean>() {
                @Override
                public void call(Subscriber<? super Boolean> subscriber) {
                    if(integer.intValue()>2){
                        subscriber.onNext(integer.intValue()>2);

                    }
                }
            });
        }
    });

}

我假设这是明显的区别，对吗？

Answer 1

当您传递一个 Iterable（例如 List）时查看每个行为的行为时，差异应该会更清楚：

Observable.just(someList) 会给你 1 次发射 - List.

Observable.from(someList) 会给你 N 排放 - 列表中的每一项。

能够将多个值传递给 just 是一项方便的功能；以下功能相同：

Observable.just(1, 2, 3);
Observable.from(1, 2, 3);

Answer 2

just()和from()的区别：

尽管 just() 和 from() 似乎在做同样的工作，但排放量不同。

just() – 只发射 1 次。 Observable.just(new Integer[]{1, 2, 3}) 使用 Observer 回调进行一次发射 onNext(Integer[] integers)

fromArray() – 排放 N。 Observable.fromArray(new Integer[]{1, 2, 3}) 使用 Observer 回调进行三次发射 onNext(Integer integer)

Answer 3

from 主要与数据结构（数组和可迭代）和期货一起工作，因此获得的 Observable 将从这些数据结构或期货中发出单个项目。

just 将所有内容都视为项，无论它是数组项还是整数项。围绕 just 的混淆是由于有几个 just 变体最多可以接受 10 个参数。

所以实际上，您可能会像它们发出的那样解释所有这些 just 变体，分别是 "just" 一项，或 "just" 两项，"just" 三项等等...

Answer 4

inRxJava Just() 运算符获取参数列表并将项目转换为 Observable 项目。它接受一到十之间的参数（但官方文档说一到九，可能是特定于语言的）。

与刚才不同的是，From() 使用 Iterable 从一组项目创建一个 Observable，这意味着每个项目一次发射一个。

Answer 5

我们最多只能在 just() 中传递 10 个参数，而 fromArray 是列表类型。

在内部 just() 调用 fromArray().

检查下面的 RxJava 代码是否只有 4 个参数。

 public static <T> Observable<T> just(T item1, T item2, T item3, T item4) {
        ObjectHelper.requireNonNull(item1, "The first item is null");
        ObjectHelper.requireNonNull(item2, "The second item is null");
        ObjectHelper.requireNonNull(item3, "The third item is null");
        ObjectHelper.requireNonNull(item4, "The fourth item is null");

        return fromArray(item1, item2, item3, item4);
    }

两者都是 return 相同的可观察对象。

RxJava - 只是与来自

RxJava - Just vs From

java

rx-java