fromCallable 和 defer 有什么區別？

Question

fromCallable和defer有不同的實現。 我聽到有人說defer有助於遞歸，但我無法生成任何顯示它們之間差異的代碼。

我嘗試了無限數量的實現：

private Observable<Integer> numbers(int start) {
         return Observable.just(start)
                .concatWith(Observable.defer(() -> numbers(start + 1)));
    }

但是訂閱時我仍然收到堆棧溢出異常

Answer 1

fromCallable創建發出單個值的 observable，然后完成。

defer推遲實際可觀察​​的創建，直到它被訂閱。 因此，您可以根據訂閱時的狀態創建多值observable。 例如：

Observable<Integer> daysOfWeekLeft =
    Observable.defer(() -> 
        Observable.range(currentDayOfWeek(), 7 - currentDayOfWeek()));

基本上你可以像這樣使用fromCallable實現相同的fromCallable ：

Observable<Integer> daysOfWeekLeft =
    Observable.fromCallable(() -> currentDayOfWeek())
        .flatMap(day -> Observable.range(day, 7 - day));

附注。 您的無限數字流代碼會導致無限遞歸。 可能需要使用調度程序來避免這種情況。

Answer 2

我正在查看Single術語，它沒有 Observable 復雜，因為它只能有 1 個值。 （即具有 1 個發射的可觀察對象）。 以下內容也適用於其他類型（Observable、Flowable、Completable）

Single.fromCallable

Single.fromCallable實際上從它調用的函數內部的值創建一個新的 Single 。 這就是為什么 Aaron He 說的是評論：

fromCallable 是 Observable.defer(() -> Observable.just(value)) 的一種方便的方法

它通過使用.just來.just創建 Observable 的額外步驟。 如果你調用一個已經創建了 Single 的fromCallable函數，你會得到一個嵌套的 single。

// Not very useful to get a Single<Single<*>>
val fromCallable: Single<Single<String>> = Single.fromCallable {
    Single.just("Example")
}

// Better in these cases, where the function inside doesn't create a Single already:
 fun heavyFunction(): String { return "Heavy" }
val fromCallable2: Single<String> = Single.fromCallable {heavyFunction()}

Single.defer

Single.defer調用其中的函數，如果它返回一個 Single，那么您可以稍后使用該 Single。 如果沒有，它將無法編譯。

val defer: Single<String> = Single.defer {
    Single.just("Example")
}

// This line won't compile:
Single.defer {heavyFunction()}

// You need to wrap it in a Single:
val defer2: Single<String> = Single.defer {Single.just(heavyFunction())}

---

因此， Single.fromCallable從callable創建了一個 Single ，因此得名。 這個不需要創建 Single 的可調用對象，它可以是任何東西。

Defer 不會創建一個新的Single，它只是調用它的 body，它應該創建一個 Single。 這就是為什么它的函數名中沒有from的原因。