1. create
You can create an Observable from scratch by using the Create operator. You pass this operator a function that accepts the observer as its parameter. Write this function so that it behaves as an Observable — by calling the observer’s onNext, onError, and onCompleted methods appropriately.
使用create操作符，你可以从头开始(from scratch)创建一个Observable 。该操作符有个方法，接收Observer作为它的参数。需要在该方法内写相关内容，这样才能表现的像是个Observable。很明显在这个方法内要必须要写的内容是：调用Observer的onNext，onError和onCompleted方法。
A well-formed finite Observable must attempt to call either the observer’s onCompleted method exactly once or its onError method exactly once, and must not thereafter attempt to call any of the observer’s other methods.
一个符合语法限定的Observable必须恰巧调用Observer的onCompleted方法一次或者onError方法一次，两者不能同时出现，并且在调用其中任意一个方法之后，不得再调用Observer任何其他方法。
上面是ReactiveX的说明。但是第一条并不符合RxJava2.x的实际情况：
第一条说的接收Observer作为参数的方法，这个方法所属的类，映射到RxJava2.x后：
对于Observable而言是：ObservableOnSubscribe
对于Flowable而言是：FlowableOnSubscribe
然而这两个类的那个方法，不再接收Observer，而是分别接收：
ObservableEmitter和FlowableEmitter
例子，先是Observable：
/**
* Create — create an Observable from scratch by calling observer methods programmatically
* 从头开始创建一个Observable，代码中需要显示的调用Observer的方法( onNext,onComplete,onError )
*/
Observable.create(new ObservableOnSubscribe() {
@Override
public void subscribe(ObservableEmitter e) throws Exception {
Logger.log("before emit：" + 1);
e.onNext(1);
Logger.log("before emit：" + 2);
e.onNext(2);
Logger.log("before emit：" + 3);
e.onNext(3);
e.onComplete();
}
}).subscribe(new Observer() {
private Disposable mDisposable;
@Override
public void onSubscribe(Disposable d) {
Logger.log("onSubscribe");
mDisposable = d;
}
@Override
public void onNext(Integer integer) {
Logger.log("onNext：" + integer);
// if (integer == 2) {
// mDisposable.dispose();
// }
}
@Override
public void onError(Throwable e) {
Logger.log("onError" + e.toString());
}
@Override
public void onComplete() {
Logger.log("onComplete");
}
});
输出结果：
onSubscribe
before emit：1
onNext：1
before emit：2
onNext：2
before emit：3
onNext：3
onComplete
如果onNext中if那段代码打开：
onSubscribe
before emit：1
onNext：1
before emit：2
onNext：2
before emit：3
结论
onSubscribe最先调用。Disposable dispose()后，只是关闭下游的接收，对上游的发送无影响。另外一旦dispose()后，Observer的任何方法都不会被调用，包括onComplete和onError。
看下Flowable的：
Flowable.create(new FlowableOnSubscribe() {
@Override
public void subscribe(FlowableEmitter e) throws Exception {
Logger.log("before emit：" + 1);
e.onNext(1);
Logger.log("before emit：" + 2);
e.onNext(2);
Logger.log("before emit：" + 3);
e.onNext(3);
e.onComplete();
}
}, BackpressureStrategy.LATEST).subscribe(new Subscriber() {
private Subscription mSubscription;
@Override
public void onSubscribe(Subscription s) {
Logger.log("onSubscribe");
mSubscription = s;
s.request(Integer.MAX_VALUE);
}
@Override
public void onNext(Integer integer) {
Logger.log("onNext：" + integer);
// if (integer == 2) {
// mSubscription.cancel();
// }
}
@Override
public void onError(Throwable t) {
Logger.log("onError" + t.toString());
}
@Override
public void onComplete() {
Logger.log("onComplete");
}
});
onNex中if那段打开或者关闭，输出结果与Observable的输出结果完全一致。
只从这段例子，看出Flowable和Observable的区别：
Observable对应Observer，Flowable对应Subscriber。- 传给
Observer的onSubscribe()方法的参数是Disposable，而传给Subscriber的onSubscribe()方法的参数是Subscription。- 在
Subscriber的onSubscribe()方法体内，要调用Subscription的request()方法，指定下游接收数量。若不指定，则下游接收不到任何数据。create时多了一个参数BackpressureStrategy，用于控制背压策略。
2. defer
The Defer operator waits until an observer subscribes to it, and then it generates an Observable, typically with an Observable factory function. It does this afresh for each subscriber, so although each subscriber may think it is subscribing to the same Observable, in fact each subscriber gets its own individual sequence.
In some circumstances, waiting until the last minute (that is, until subscription time) to generate the Observable can ensure that this Observable contains the freshest data.
Defer操作符会一直等待到有Observer订阅后才会创建Observable，通常会使用Observable工程方法来创建。
Defer会对每个订阅者重复同样操作，所以每个订阅者都可能会认为他们订阅是的同一个Observable，
而实际上每个订阅者都获取他们各自独立的发送队列。
在某些情况下，直到最后一刻（指的是：直到订阅时）才生成Observable可以保证这个Observable包含最新的数据。
Observable.defer(new Callable>() {
@Override
public ObservableSource call() throws Exception {
return new ObservableSource() {
@Override
public void subscribe(Observer observer) {
Logger.log("before emit：" + 1);
observer.onNext(1);
Logger.log("before emit：" + 2);
observer.onNext(2);
Logger.log("before emit：" + 3);
observer.onNext(3);
observer.onComplete();
}
};
}
})
.subscribeOn(Schedulers.io()) \\**\\
.subscribe(new Observer() {
private Disposable mDisposable;
@Override
public void onSubscribe(Disposable d) {
Logger.log("onSubscribe");
mDisposable = d;
}
@Override
public void onNext(Integer integer) {
Logger.log("onNext：" + integer);
}
@Override
public void onError(Throwable e) {
Logger.log("onError" + e.toString());
}
@Override
public void onComplete() {
Logger.log("onComplete");
}
});
输出结果：
onSubscribe
before emit：1
onNext：1
before emit：2
onNext：2
before emit：3
onNext：3
onComplete
两点：
-
defer和create传值的区别：
public static Observable defer(Callable> supplier)
public static Observable create(ObservableOnSubscribe source) {
- 隐掉
.subscribeOn(Schedulers.io())这句话，则Observer的onSubscribe(Disposable d)方法不会被调用。
Flowable的defer用法同Observable，同样有如上两点区别.
public static Flowable defer(Callable> supplier)
3. from
这个操作符官方的文档有点不太好理解。
决策树对于
from的描述是:
convert some other object or data structure into an Observable
将一些其他对象或者数据结构转化为一个Observable.
但是进入from的详情页时，总述就变成了：
convert various other objects and data types into Observables
将各种其他对象和数据类型转化为Observables.
When you work with Observables, it can be more convenient if all of the data you mean to work with can be represented as Observables, rather than as a mixture of Observables and other types. This allows you to use a single set of operators to govern the entire lifespan of the data stream.
当你使用Observables时，如果所有你要处理的数据都可以表示为Observables，而非混合使用Observables和其他类型，这样便会非常的便利。
这样可以你使用一组操作符去管理数据流的整个生命周期。
Iterables, for example, can be thought of as a sort of synchronous Observable; Futures, as a sort of Observable that always emits only a single item. By explicitly converting such objects to Observables, you allow them to interact as peers with other Observables.
例如：Iterables可以看作一种同步的Observable；Futures可以看作只发射单个元素的Observable。
通过明确地将这种对象转换为Observables，你可以让他们融洽的与其他Observables一起交互。
For this reason, most ReactiveX implementations have methods that allow you to convert certain language-specific objects and data structures into Observables.
正因如此，大多数ReactiveX的实现语言有很多方法可以让你将某些语言-特定的的对象和数据结构转换为Observables.
From操作符在RxJava1和2中有很大的区别：
RxJava 1․x：
decode from fromAction fromCallable fromFunc0 fromRunnable runAsync
RxJava 2․x：
fromArray fromCallable fromFuture fromIterable fromPublisher