這個是Rx Observable和開發(fā)者對話的第六部，前面5部已經(jīng)由掘金翻譯計劃翻譯完畢，我也是看到前五篇，意猶未盡，所以找到第六部分，但是掘金計劃還沒翻譯出來，所以我就自行看了一下，想翻譯出來（但是很長很長），小弟英語水平比較低，如果有什么錯誤，請大家不要介懷，可以等“掘金翻譯計劃”出比較準(zhǔn)確的翻譯版，謝謝大家理解。之前五部分可以查看這里掘金翻譯計劃 后面的各部分鏈接我就不另外給鏈接了
原文：Continuation (Summer vs Winter Observable) of Dialogue between Rx Observable and a Developer (Me) [ Android RxJava2 ] ( What the hell is this ) Part6

WOW，我們有一天的時間學(xué)習(xí)新的東西讓這一天過得非常棒的。
朋友們，希望你們過得不錯，這是我們RxJava2 Android 的第六部分。在這部分，我們將繼續(xù)和Rx進行對話，清楚一件重要的事情，基本上Summer vs Winter Observable 是 Hot (熱)vs Cold(冷) 的意思
動機：
動機和我在第一部分part1中分享給大家的一樣。
介紹：
這部分沒有介紹，因為這是我們上一篇準(zhǔn)備要打算講的，在開始之前，我們回顧一下上一篇的內(nèi)容。在上一篇我們約見了Rx Observable,他給了我們一些學(xué)習(xí)Rx的建議，隨后又給我們分享了一些創(chuàng)建Observable的方法，當(dāng)我們準(zhǔn)備談到Hot and Cold Observable的時候，我們暫停了談話
續(xù)集：
Observable:這就很多了，但我想我可以解釋一下這兩種Observables。第一種叫Cold Observable ,第二種叫Hot Observable。有時候開發(fā)者們經(jīng)常稱作Hot vs Cold Observable。這兩個都是比較簡單的概念，為此，我會通過幾個小例子讓你理解這個概念，然后我會教你怎么在代碼里使用這些概念。最后，我想【Me】會給你提供一些例子，你覺得呢【Me】？
Me:必須的，我會嘗試走在你前面，這樣你就能看到我是對還是錯了
Observable:哈哈，可以。那現(xiàn)在有多少人知道銷售員里，哪些是超市里面最有價值的的，在超市門口又有誰試著通過一些口號去爭取客戶。
Me:我是這樣想的，沒有多少人知道像在巴基斯坦、印度等亞洲國家里面最有價值的文化是什么。你可以找來一些更加普遍的例子，好讓人們都能更容易的抓住到這個概念。
Observable:可以，沒問題啊，那有多少人知道咖啡店？
Me:我想所有人都知道。
Observable:很好，這里有兩家咖啡店，分別叫做Cold Music 咖啡店和Hot Music 咖啡點。一個人他去Cold Music 咖啡店買了一杯咖啡，然后他可以坐在店里的任何地方，在咖啡店的座位里，提供這一些耳機，耳機里有個播放列表，播放這三首詩歌。非常好的是所有人都能帶上這些耳機。而耳機里都是從第一首開始播放，如果有人期間放下再帶上耳機，也是重新從第一首開始播放。同樣，如果有人放下了耳機，就會停下播放。
與此相反，Hot Music咖啡點有一套完整的音樂系統(tǒng)，當(dāng)你進入這咖啡店你就能來時聽到詩歌，這是因為他們有一套很好音響設(shè)備和公放，他們也不限制歌曲，當(dāng)?shù)谝粋€店員開門營業(yè)便開始這個播放。這是一個相對獨立于客人外的系統(tǒng)，不管是誰進入這個咖啡店，他就會在當(dāng)前時間點聽到歌曲，但他不知道他進來之前已經(jīng)有多少歌曲已經(jīng)播放完了，這就等同于observables里面的概念.
就像ColdMusic咖啡店的耳機，cold observable 是懶惰的，就像一個耳機，在你需要用到的時候，才通過Observable.fromArray()或其他方法的去創(chuàng)建一個Observable。當(dāng)你(訂閱者)訂閱這個Observable,你會開始接受數(shù)據(jù)就像一個人帶上耳機，然后歌曲播放?，F(xiàn)在訂閱者(你)從Observable取消訂閱，這樣你就不能獲取到任何新的數(shù)據(jù)，就像放下耳機停止播發(fā)歌曲。
最后的重點是ColdMusic咖啡店有很多耳機，但每個耳機只要帶上就會開始播放。如果一個人已經(jīng)聽到了第二首，另外一個人帶上另外一個耳機，他也會從第一首開始聽。這就意味著每個人都會得到一個單獨的歌曲播放列表。同理，如果我們又三個訂閱者，他們同時訂閱了Cold Observable,他們都會獲得一個獨立的數(shù)據(jù)流（stream），意味著觀察者都能在訂閱的時候單獨調(diào)用onNext方法。在這里，我們可以說Cold Observables 就像耳機一樣，依賴上面這些訂閱者。
現(xiàn)在HotObservables 就像一間HotMusic 咖啡店的音樂系統(tǒng)，一旦咖啡店營業(yè)，音樂系統(tǒng)就不需要任何人照看開始播放歌曲。一直在播放歌曲，一旦有人進入店里，他就會開始聽到那個時間點的歌曲。這樣同樣發(fā)生在Hot Observables,一但他們被創(chuàng)建，他們就開始發(fā)送數(shù)據(jù)，任何訂閱者會訂閱這個Observable 并開始接收這個時間點的數(shù)據(jù)，但他們獲取不到舊的數(shù)據(jù)。這就意味著Hot Observable 是獨立于訂閱者，他們是不會介意任何之前的數(shù)據(jù)。無論什么時候，任何一個訂閱者會都在她訂閱的點上開始接收數(shù)據(jù)。我想我會通過代碼用同樣的例子說明，等下【Me】會給你一些真實的例子。
Cold Observable:

    public class HotVsCold {

    public static void main(String[] args) throws InterruptedException {

        List<String > poemsPlayList = Arrays.asList("Poem 1", "Poem 2", "Poem 3");
        Observable coldMusicCoffeCafe = Observable.fromArray(poemsPlayList);

        Consumer client1 = poem-> System.out.println(poem);
        Consumer client2 = poem-> System.out.println(poem);
        Consumer client3 = poem-> System.out.println(poem);
        Consumer client4 = poem-> System.out.println(poem);

        coldMusicCoffeCafe.subscribe(client1);
        coldMusicCoffeCafe.subscribe(client2);
        System.out.println(System.currentTimeMillis());
        Thread.sleep(2000);
        System.out.println(System.currentTimeMillis());
        coldMusicCoffeCafe.subscribe(client3);
        coldMusicCoffeCafe.subscribe(client4);
    }
}

這是一個很簡單的例子的代碼，我有4個客人和一個放在ColdMusic咖啡店的播放列表Observable，程序一開始，先是兩個客戶訂閱cold Observabler，我等2秒鐘，第三第四個客戶訂閱這cold observable ,然后最后當(dāng)我們看到輸出的時候，我們就能簡單看到所有訂閱者或者客戶會獲取所有開始到結(jié)束的歌曲

Output:

[Poem 1, Poem 2, Poem 3]

[Poem 1, Poem 2, Poem 3]

1494142518697

1494142520701

[Poem 1, Poem 2, Poem 3]

[Poem 1, Poem 2, Poem 3]

Hot Observable:

public static void main(String[] args) throws InterruptedException {

    Observable<Long> hotMusicCoffeeCafe = Observable.interval(1000, TimeUnit.MILLISECONDS);
    ConnectableObservable<Long> connectableObservable = hotMusicCoffeeCafe.publish();
    connectableObservable.connect(); //  Cafe open on this line and cafe boy start the system

    Consumer client1 = poem-> System.out.println("Client 1 poem"+poem);
    Consumer client2 = poem-> System.out.println("Client 2 poem"+poem);
    Consumer client3 = poem-> System.out.println("Client 3 poem"+poem);
    Consumer client4 = poem-> System.out.println("Client 4 poem"+poem);

    Thread.sleep(2000); // After two poems already played client 1 enter. So he should listens from poem 2.
    connectableObservable.subscribe(client1);
    Thread.sleep(1000); // Client two should start listening poem 3 
    connectableObservable.subscribe(client2);

    Thread.sleep(4000); // Client 3 and 4 enter will start from poem 9.
    connectableObservable.subscribe(client3);
    connectableObservable.subscribe(client4);

    while (true);
}

HotMusic咖啡點營業(yè)，服務(wù)業(yè)開啟播放系統(tǒng)，當(dāng)我們調(diào)用connect 方法時，歌曲如上所示開始播放，暫時不要只專注于connect方法，而是把握的概念。兩首詩或秒之后的第一個客戶進入咖啡館,所以他將從詩2開始傾聽。一秒后下一個顧客進入所以他開始從詩3開始傾聽。在顧客2的4秒后，第三第四個顧客進入咖啡店，現(xiàn)在，他們開始聽到詩9.你可以看到Hot Observable是依賴于訂閱者的。一旦他開始發(fā)射數(shù)據(jù)，他不會理會任何人有沒有訂閱，在另一方面所有訂閱者當(dāng)他們訂閱的時候獲取到對應(yīng)時間的數(shù)據(jù)，但他們獲取不到已經(jīng)發(fā)射了的歷史和事件數(shù)據(jù)。
現(xiàn)在我已經(jīng)感覺到你掌握了Hot vs Cold Observable 的概念了，是時候根據(jù)上面這些要點，看看怎么創(chuàng)建這些Observable。

Cold Observable:
1.所有Obesrvable 實際上都是Cold Observables,這就說明，如果我們使用Observable.create() 或者Observable.fromArray()等方法創(chuàng)建的Observable 都是Cold Observable.
2.所有訂閱者當(dāng)他訂閱Cold Observable時，都會單獨獲取到完整的數(shù)據(jù)流
3.如果沒有訂閱者訂閱,Cold Observable將不會做任何事，他們是懶惰的。
Hot Observable:
1.一旦Hot Observable 創(chuàng)建，他們就不理會所有訂閱者。
2.當(dāng)所有的訂閱者在同一時間訂閱一個Hot Observable時，將會獲取到相同的數(shù)據(jù)。
Me:嗯，好的。你能告訴我們怎么將Cold Observable轉(zhuǎn)化長Hot Observable.
Observable:可以，Cold 轉(zhuǎn)變成Hot Observable是件相當(dāng)容易的事

List<Integer> integers = new ArrayList<>();
Observable.range(0, 10000)
        .subscribe(count -> integers.add(count));

Observable<List<Integer>> listObservable = Observable.fromArray(integers);

現(xiàn)在上面的代碼，listObservable 是一個Cold Observable,這時候看看我們怎么將這個Cold Observable 轉(zhuǎn)變成Hot Observable.

Observable<List<Integer>> listObservable = Observable.fromArray(integers);
ConnectableObservable connectableObservable = listObservable.publish();

上面代碼所示，我們通過使用publish()方法將我的Cold Observable轉(zhuǎn)變成Hot Observable.我們可以說所有Cold Observable都能通過使用publish()方法將Cold 變成Hot ,并且返回一個當(dāng)前還沒開始發(fā)射數(shù)據(jù)的ConnectableObservable.這是一個有趣的事情，當(dāng)observable調(diào)用publish()方法,就意味著所有訂閱者將訂閱這個Observable，并在訂閱時共享這個時間點的相同數(shù)據(jù)。正如我們知道進入HotMusic咖啡店的每個人都進入了同一個歌曲數(shù)據(jù)播放流，不同的是當(dāng)他們不同時間點獲取到的數(shù)據(jù)不一樣。現(xiàn)在有趣的一點是，如果任何訂閱者訂閱的是conenectbleObservable,他們將獲取不了任何。可能你們會困惑，主要有兩點，當(dāng)我們調(diào)用publish()意味著這個Observable現(xiàn)在將發(fā)或射一組數(shù)據(jù)，或者說這個Observabel 有一組數(shù)據(jù)將要發(fā)射給所有的訂閱者，但要開始發(fā)送數(shù)據(jù)需要我調(diào)用connect()方法，就如下面所示:

Observable<List<Integer>> listObservable = Observable.fromArray(integers);
ConnectableObservable connectableObservable = listObservable.publish();
connectableObservable.connect();

就這么簡單的例子，記住publish()會將Cold轉(zhuǎn)換成Hot 但不開始發(fā)送數(shù)據(jù)。發(fā)送數(shù)據(jù)我們需要調(diào)用connect()方法，當(dāng)我調(diào)用ConnectableObservable的connect()方法時，不管有沒有訂閱者，還是成千上百的訂閱者，數(shù)據(jù)都將開始發(fā)送。現(xiàn)在也有一些其他的方法在現(xiàn)實生活中真正有用的項目,如：refCount(),share(),replay()，但我暫時不說，現(xiàn)在我們做一個回顧，[Me]會給你們一個很好的例子。好讓你們真的掌握這個概念。
Me:??，這這例子比較長但還是簡單的。
Observable:哈哈哈，沒關(guān)系的[Me]，我只需要通過這方法解釋好讓所有人都能把握。
Me:同意，所以現(xiàn)在我要給一個可能更有助于更準(zhǔn)確地把握這一概念的例子?？紤]現(xiàn)在我們有一個Observable的如下所示。

Observable<String> just = Observable.just("Hello guys");

現(xiàn)在有兩個不同的訂閱者，都訂閱了這個Observabel

public class HotVsCold {
    public static void main(String[] args) {
        Observable<String> just = Observable.just("Hello guys");
        just.subscribe(s-> System.out.println(s));
        just.subscribe(s-> System.out.println(s));
    }
}

Output:
Hello guys
Hello guys
現(xiàn)在，我有個問題？這個Observable是Cold還是Hot,我想你已經(jīng)知道這里沒有publish()，所以是Cold.想象一下這是Observable是我從第三方庫得到的，我們不知道這個Observable的類型。現(xiàn)在我需要一個新的例子讓大家都清晰很多東西。

public static void main(String[] args) {
    Random random = new Random();
    Observable<Integer> just = Observable.create(source->source.onNext(random.nextInt()));
    just.subscribe(s-> System.out.println(s));
    just.subscribe(s-> System.out.println(s));
}

在這里我有一個隨機值，同時用來審查程序輸出，和討論是Cold或Hot Observable?

Output:
1531768121
607951518

所示兩個值是不同的，這就意味著這是個Cold Observabel,因為根據(jù)Cold Observable的定義，每次我獲取到一個新的值，可見他們從來沒有分享數(shù)據(jù)的。每次產(chǎn)生一個新的或新數(shù)據(jù)，通過簡單的詞語onNext()方法調(diào)用兩次為兩個不同的用戶。
現(xiàn)在這是時候?qū)⑼粋€Cold變成Hot Observable。

public static void main(String[] args) {
    Random random = new Random();
    Observable<Integer> just = Observable.create(source->source.onNext(random.nextInt()));
    ConnectableObservable<Integer> publish = just.publish();
    publish.subscribe(s-> System.out.println(s));
    publish.subscribe(s-> System.out.println(s));
    publish.connect();
}

在解釋上面代碼之前，我們先看一下這輸出的結(jié)果：
Output:
1926621976
1926621976
這時候兩個訂閱者獲到相同的數(shù)據(jù)，這就表示這是一個Hot Observable,因為Hot Observable 總是從一個源發(fā)送的數(shù)據(jù)，簡單來說我們只有在調(diào)用onNext()方法時獲取一組數(shù)據(jù)。我等下準(zhǔn)備解釋一下publish()和connect()方法的調(diào)用。
當(dāng)我調(diào)用publish()的時候，就意味著我這個Observble獨立于訂閱者，只分享給所有訂閱者相同的數(shù)據(jù)源信息。簡單來講，Hot Observable給所有訂閱者 同一個onNext()方法來調(diào)取數(shù)據(jù)。這里可能有一點困惑，我在兩個訂閱者訂閱后調(diào)用connect()，是因為我想展示給你看Hot Observable 是獨立的，應(yīng)該由調(diào)用onNext時發(fā)送數(shù)據(jù)，我們知道只有當(dāng)我們調(diào)用connect(),HotObservable 才開始發(fā)送數(shù)據(jù)。所以之前我們兩個訂閱者訂閱，然后調(diào)用connect()方法，這樣我們同時接受到相同的數(shù)據(jù)?，F(xiàn)在我要給你一個相同的例子。

Random random = new Random();
Observable<Integer> just = Observable.create(source->source.onNext(random.nextInt()));
ConnectableObservable<Integer> publish = just.publish();
publish.connect();
publish.subscribe(s-> System.out.println(s));
publish.subscribe(s-> System.out.println(s))

這里有點不同，我在訂閱者訂閱之前調(diào)用connet.現(xiàn)在我們將會得到什么輸出，有人能說得出來嗎？
Output:

Process finished with exit code 0
是的，空的，你們困惑嗎？好，我來解釋一下，正如你看到的，我創(chuàng)建一個產(chǎn)生隨機int 值的Observable ，只調(diào)用一次。當(dāng)我創(chuàng)建的Cold通過調(diào)用publish()變成Hot.轉(zhuǎn)換完后我調(diào)用connect().現(xiàn)在，因為這個是HotObservable ,而且我們知道這個是獨立于訂閱者的，所以開始發(fā)送隨機數(shù)，而且我們只會生成一個隨機數(shù)。當(dāng)調(diào)用connect后，我們訂閱者訂閱，但這個時候，我們已經(jīng)獲取不到任何數(shù)據(jù)，因為Hot Observable已經(jīng)發(fā)射了一個值了。我相信大家都明白的，現(xiàn)在我們可以添加日志觀察內(nèi)部的發(fā)射。這樣我們就可以確認(rèn)，我說的是真的。

public static void main(String[] args) {
    Random random = new Random();
    Observable<Integer> just = Observable.create(source -> {
                int value = random.nextInt();
                System.out.println("Emitted data: " + value);
                source.onNext(value);
            }
    );
    ConnectableObservable<Integer> publish = just.publish();
    publish.connect();
    publish.subscribe(s -> System.out.println(s));
    publish.subscribe(s -> System.out.println(s));
}

Output:

Emitted data: -690044789

Process finished with exit code 0
你可以看到上面的輸出顯示，我的HotObservable在調(diào)用connect()后開始發(fā)送數(shù)據(jù)，但訂閱者訂閱慢了。這就是為什么我們獲取到空的值?，F(xiàn)在我打算進入下一節(jié)前回顧一下；
1、所有的Observables 都默認(rèn)是冷Observable.
2、Cold 轉(zhuǎn)換成Hot，只需要調(diào)用publish()，然后會返回一個ConnectableObservable.這是一個并不馬上發(fā)送數(shù)據(jù)的Hot Observable。
3、ConnectableObservable 開始發(fā)送數(shù)據(jù)需要我們調(diào)用connect()方法。
Observable:抱歉打斷一下，進入下一節(jié)前，你可以寫一個帶時間間隔的HotObservable代碼會更好一些。
Me:當(dāng)然。

public static void main(String[] args) throws InterruptedException {
    Random random = new Random();
    Observable<Integer> just = Observable.create(
            source -> {
                Observable.interval(1000, TimeUnit.MILLISECONDS)
                        .subscribe(aLong -> {
                            int value = random.nextInt();
                            System.out.println("Emitted data: " + value);
                            source.onNext(value);
                        });
            }
    ); // Simple same Observable which we are using only I added a one thing now this will produce data after every one second.
    ConnectableObservable<Integer> publish = just.publish();
    publish.connect();

    Thread.sleep(2000); // Hot observable start emitting data and our new subscribers will subscribe after 2 second.
    publish.subscribe(s -> System.out.println(s));
    publish.subscribe(s -> System.out.println(s));

    while (true);

Output:

Emitted data: -918083931
Emitted data: 697720136
Emitted data: 416474929
416474929
416474929
Emitted data: -930074666
-930074666
-930074666
Emitted data: 1694552310
1694552310
1694552310
Emitted data: -61106201
-61106201
-61106201
現(xiàn)在我們可以清楚的看到， 根據(jù)定義我們對Hot進行了100%的討論了。當(dāng)Hot開始發(fā)送數(shù)據(jù)，我們獲取到三個數(shù)據(jù)，但還沒有訂閱者。2秒后，我們兩個訂閱者訂閱Hot,他們開始獲得并相同的數(shù)字。
是時候到下一節(jié)。我們已經(jīng)掌握了Cold 和Hot的概念。關(guān)于Hot的下一個節(jié)，我要解釋的使用場景。
場景1：
我要一個HotObservable,任何訂閱者訂閱能獲取所有之前的值,這HotObservable已經(jīng)發(fā)出的值和所有的值應(yīng)該是同步的。為了解決這種情況下我們有一個非常簡單的方法。這叫replay()。只有我們需要調(diào)用該方法。

public static void main(String[] args) throws InterruptedException {

    Random random = new Random();
    Observable<Integer> just = Observable.create(
            source -> {
                Observable.interval(500, TimeUnit.MILLISECONDS)
                        .subscribe(aLong -> {
                            int value = random.nextInt();
                            System.out.println("Emitted data: " + value);
                            source.onNext(value);
                        });
            }
    );
    ConnectableObservable<Integer> publish = just.replay();
    publish.connect();

    Thread.sleep(2000);
    publish.subscribe(s -> System.out.println("Subscriber 1: "+s));
    publish.subscribe(s -> System.out.println("Subscriber 2: "+s));

    while (true);

}

Output:
Emitted data: -1320694608
Emitted data: -1198449126
Emitted data: -1728414877
Emitted data: -498499026
Subscriber 1: -1320694608
Subscriber 1: -1198449126
Subscriber 1: -1728414877
Subscriber 1: -498499026
Subscriber 2: -1320694608
Subscriber 2: -1198449126
Subscriber 2: -1728414877
Subscriber 2: -498499026
Emitted data: -1096683631
Subscriber 1: -1096683631
Subscriber 2: -1096683631
Emitted data: -268791291
Subscriber 1: -268791291
Subscriber 2: -268791291
在這里如果你一起查看我們輸出和代碼。你能比較簡單掌握Hot Observable的replay()概念。首先，我們創(chuàng)建HotObservable后開始發(fā)送數(shù)據(jù)。2秒鐘，我們第一第二個訂閱者訂閱這個Hot Observable,但這時候，我們已經(jīng)發(fā)送了4個值。所以我們能看到輸出，我們的訂閱者先是獲取到已經(jīng)發(fā)送了的值，隨后他們同步獲取到Hot Observable 發(fā)送的值。
場景2：
我要一個Hot Observable,當(dāng)?shù)谝粋€訂閱者訂閱時開始數(shù)據(jù)發(fā)射,并且在所有訂訂閱者取消訂閱時取消發(fā)射。這一個是很簡單實現(xiàn)的。

public static void main(String[] args) throws InterruptedException {

    Observable<Long> observable = Observable.interval(500, TimeUnit.MILLISECONDS).publish().refCount();

    Consumer<Long > firstSubscriber = s -> System.out.println("Subscriber 1: "+s);
    Consumer<Long > secondSubscriber = s -> System.out.println("Subscriber 2: "+s);

    Disposable subscribe1 = observable.subscribe(firstSubscriber);
    Disposable subscribe2 = observable.subscribe(secondSubscriber);

    Thread.sleep(2000);
    subscribe1.dispose();
    Thread.sleep(2000);
    subscribe2.dispose();

    Consumer<Long > thirdSubscriber = s -> System.out.println("Subscriber 3: "+s);
    Disposable subscribe3 = observable.subscribe(thirdSubscriber);

    Thread.sleep(2000);
    subscribe3.dispose();

    while (true);
}

Output:
Subscriber 1: 0
Subscriber 2: 0
Subscriber 1: 1
Subscriber 2: 1
Subscriber 1: 2
Subscriber 2: 2
Subscriber 1: 3
Subscriber 2: 3
Subscriber 2: 4
Subscriber 2: 5
Subscriber 2: 6
Subscriber 2: 7
Subscriber 3: 0
Subscriber 3: 1
Subscriber 3: 2
首先也是最重要的一點,這里的Observable 是一個Hot Observable,但只有在第一個訂閱者訂閱后才發(fā)射數(shù)據(jù)。并在所有訂閱者取消訂閱的時候停止發(fā)射。可以從上面的輸出。當(dāng)首先兩個訂閱者訂閱HotObservable,開始發(fā)送數(shù)據(jù)，然后一個訂閱者取消，但Hot Observable 沒有停止，因為當(dāng)前還有一個訂閱者訂閱著但隨后就取消訂閱，所以Hot Observable停止發(fā)送數(shù)據(jù)。然后第三個訂閱者在2秒之后訂閱同一個Hot Observable,這時候Observable 又開始發(fā)送數(shù)據(jù)，但不是從0這個點而是之前停止的那個點。
Observable :哇，你真是讓我[Me]驚喜，你通過一個好方式解釋這個概念。
Me:謝謝，Observable
Observable:現(xiàn)在你還有其他問題嗎？
Me:當(dāng)然有啦，你可以告訴我Subject和像Publish,Behaviour等不同subject的概念嗎？
Observable :恩，在這個概念，我有種感想。我會告訴你關(guān)于Observer 的API，他們是怎么工作的，在不使用一個完整的Observer接口下你要怎么使用Lambda or Functioal 接口。你怎么看？
Me:當(dāng)然可以，我隨你。
Observable:正如我們知道的Observables,Observe有一個概念,我們已經(jīng)使用在很多例子……。
Conclusion(總結(jié))：
朋友，這個對話非常長，我需要暫停在這里，否則這篇文章會像一本很厚的書，可能是好，但就會失去主要目的。我想我們都應(yīng)該學(xué)習(xí)和幾乎什么都知道。所以我打算在這里暫停對話，我會在下一部份繼續(xù)對話。如果可以的話，試著把你真實的項目和重構(gòu)這些實踐。最后我想說謝謝RxObservable,是他給我很多他/她的時間。

Happy Weekend Friends Bye.

‘’我翻譯的時候，沒想到第七部分已經(jīng)出來了
我也要去繼續(xù)學(xué)習(xí)啦 by 小砂‘’

Next post part7 (Continuation (Observable Marriage Proposal to Observer) of Dialogue between Rx Observable and a Developer (Me) [ Android RxJava2 ] ( What the hell is this ))