我都不知道自己哪里來的毅力。死扣這幾個方法 但是 我想在就是想。 這幾個方法 扣到哪里算哪里。今天沒完成，會在轉(zhuǎn)天繼續(xù)完成。我會一直補(bǔ)充

Paste_Image.png

fromCallable

This allows you to defer the execution of the function you specify until an observer subscribes to the ObservableSource. That is to say, it makes the function "lazy."

這是官網(wǎng)的解釋。

Calls a Callable and emits its resulting single value or signals its exception.
這句話是對
ObservableFromCallable的描述

我們現(xiàn)不解釋 先來看來那個例子
<pre>

    Observable.fromCallable(new Callable<Object>() {
        @Override
        public Object call() throws Exception {
            return Observable.just("one", "two", "three", "four", "five");
        }
    }).subscribe( getSubscriber() );

    Observable.defer(new Callable<ObservableSource<? extends String>>() {
        @Override
        public ObservableSource<? extends String> call() throws Exception {
            // Do some long running operation
            SystemClock.sleep(2000);
            return Observable.just("one", "two", "three", "four", "five");
        }
    }).subscribe( getSubscriber() );



 Observer<Object> getSubscriber() {
    return new Observer<Object>() {

        @Override
        public void onError(Throwable e) {
            Log.i("RxJava", "onError : " + e.toString());
        }

        @Override
        public void onComplete() {
            Log.i("RxJava", "onCompleted");

        }

        @Override
        public void onSubscribe(Disposable d) {

        }

        @Override
        public void onNext(Object o) {
            Log.i("RxJava", "onNext : " + o);
            Log.i("RxJava", Thread.currentThread().getName());
        }
    };
}

</pre>

<pre>
06-23 08:55:53.313 26651-26651/com.rxjava2.android.samples I/RxJava: onNext : io.reactivex.internal.operators.observable.ObservableFromArray@39ee6818
06-23 08:55:53.313 26651-26651/com.rxjava2.android.samples I/RxJava: main
06-23 08:55:53.313 26651-26651/com.rxjava2.android.samples I/RxJava: onCompleted
06-23 08:55:55.315 26651-26651/com.rxjava2.android.samples I/RxJava: onNext : one
06-23 08:55:55.315 26651-26651/com.rxjava2.android.samples I/RxJava: main
06-23 08:55:55.315 26651-26651/com.rxjava2.android.samples I/RxJava: onNext : two
06-23 08:55:55.315 26651-26651/com.rxjava2.android.samples I/RxJava: main
06-23 08:55:55.315 26651-26651/com.rxjava2.android.samples I/RxJava: onNext : three
06-23 08:55:55.315 26651-26651/com.rxjava2.android.samples I/RxJava: main
06-23 08:55:55.315 26651-26651/com.rxjava2.android.samples I/RxJava: onNext : four
06-23 08:55:55.315 26651-26651/com.rxjava2.android.samples I/RxJava: main
06-23 08:55:55.315 26651-26651/com.rxjava2.android.samples I/RxJava: onNext : five
06-23 08:55:55.315 26651-26651/com.rxjava2.android.samples I/RxJava: main
06-23 08:55:55.315 26651-26651/com.rxjava2.android.samples I/RxJava: onCompleted
</pre>

可以看出來來什么？fromCallable的接口直接傳過來的是一個對象，defer根據(jù)對象個的個人分別傳送。這是因為什么呢？ 我們往下看

這是ObservableDefer的subscribeActual
<pre>
public void subscribeActual(Observer<? super T> s) {
ObservableSource<? extends T> pub;
try {
pub = ObjectHelper.requireNonNull(supplier.call(), "null publisher supplied");
} catch (Throwable t) {
Exceptions.throwIfFatal(t);
EmptyDisposable.error(t, s);
return;
}

    pub.subscribe(s);
}

</pre>
我們之前分析過pub.subscribe(s);這方法決定了 。 你call的值還是要按照Observable對象的創(chuàng)建方式去別人調(diào)用onnext這些方法。

這是ObservableFromCallable的subscribeActual
<pre>
public void subscribeActual(Observer<? super T> s) {
DeferredScalarDisposable<T> d = new DeferredScalarDisposable<T>(s);
s.onSubscribe(d);
if (d.isDisposed()) {
return;
}
T value;
try {
value = ObjectHelper.requireNonNull(callable.call(), "Callable returned null");
} catch (Throwable e) {
Exceptions.throwIfFatal(e);
if (!d.isDisposed()) {
s.onError(e);
} else {
RxJavaPlugins.onError(e);
}
return;
}
d.complete(value);
}
</pre>

發(fā)現(xiàn)了沒有這個并沒有。而是直接一個value,全部發(fā)送回去。
因此 我們可以說這個方法?；卣{(diào)回去的值不論幾個都會全部發(fā)送

下面看第二個方法

Observable.fromArray()這個方法
<pre>
public static <T> Observable<T> fromArray(T... items) {
ObjectHelper.requireNonNull(items, "items is null");
if (items.length == 0) {
return empty();
} else
if (items.length == 1) {
return just(items[0]);
}
return RxJavaPlugins.onAssembly(new ObservableFromArray<T>(items));
}
</pre>

看著眼熟嗎？ 沒錯和just 一模一樣。區(qū)別 just有數(shù)量限制

第三個方法
fromFuture