Question

在以下情况下使用Observable.just vs 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)失败了。同样，我必须将它包装在一个列表或数组中。我只是好奇他们为什么不能定义无限的论点。

更新：我进行了实验，发现just没有采用数组结构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})发出一个带有onNext(Integer[] integers)的Observer回调的发射

fromArray() –产生N排放。 Observable.fromArray(new Integer[]{1, 2, 3})使用观察者回调作为onNext(Integer integer)发出三声发射

Answer 3

from主要用于数据结构（数组和可迭代）和期货，因此，获得的Observable将从这些数据结构或期货中发出单个物品。

just将所有内容都视为项目，无论它是数组项目还是整数项目。关于just的困惑是由于存在一些just变体可以接受多达10个参数的事实。

因此，实际上，您可能会解释所有这些just变体，例如它们分别发出“仅”一项，“仅”两项，“仅”三种……等等。

Answer 4

inRxJava Just（）运算符获取参数列表，并将其转换为可观察项。所需的参数在1到10之间（但是官方文件说是1到9，可能是特定于语言的）。

与刚刚不同的是， 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);
    }

两者都返回相同的可观察对象。

RxJava - Just vs From

5 个答案: