RxJava 2.0配置
在项目Build.gradle文件里面添加如下代码，即可：
compile 'io.reactivex.rxjava2:rxandroid:2.0.1'
compile 'io.reactivex.rxjava2:rxjava:2.0.1'
基本操作
1.Observable.create()
Observable.create(new ObservableOnSubscribe() {
@Override
public void subscribe(ObservableEmitter e) throws Exception {
for(int i=0; i<5; i++){
e.onNext(String.valueOf(i));
}
e.onComplete();
}
})
.subscribe(new Consumer() {
@Override
public void accept(String s) throws Exception {
System.out.println(s);
}
});
a). 传入ObservableOnSubscribe 里面就一个方法subscribe，传入一个可观察的数据发射器，继承关系：ObservableEmitter -> Emitter。Emitter代表发射器，代码如下：
public interface Emitter {
void onNext(T value);
void onError(Throwable error);
void onComplete();
}
这和RxJava1.0使用的Subscriber的主要功能是一模一样的，提供数据源的发送。
public interface Subscriber {
public void onSubscribe(Subscription s);
public void onNext(T t);
public void onError(Throwable t);
public void onComplete();
}
b).我们常用的subscribe方法列表，如下：
Disposable subscribe(Consumer onNext)
Disposable subscribe(Consumer onNext, Consumer onError)
Disposable subscribe(Consumer onNext, Consumer onError, Action onComplete， Consumer onSubscribe)
void subscribe(Observer observer)
Disposable定义如下，与RxJava1.0 Subscription对应，提供流的解除订阅：
public interface Disposable {
void dispose();
boolean isDisposed();
}
Observer定义如下：
public interface Observer {
void onSubscribe(Disposable d);
void onNext(T t);
void onError(Throwable e);
void onComplete();
}
其中，我们将看不到RxJava1.0的action1之类的接口，取而代之的是与Java8命名类似的函数式接口。
查看源码，subscribe前几个方法最后都是调用的都是subscribe(Observer observer)，如下：
public Disposable subscribe(Consumer onNext, Consumer onError,
Action onComplete, Consumer onSubscribe) {
...
LambdaObserver ls = new LambdaObserver(onNext, onError, onComplete, onSubscribe);
subscribe(ls);
return ls;
}
LambdaObserver简单封装了我们传入的函数接口，作为一个Observer。
我们再看最基本的方法subscribe(Observer)的实现，如下：
public final void subscribe(Observer observer) {
observer = RxJavaPlugins.onSubscribe(this, observer);
subscribeActual(observer);
}
RxJavaPlugins就是以前RxJava的RxJavaHooks，可以看成代理包装，不设置就是直接返回原对象，可以忽略，最后调用subscribeActual（）这个是抽象方法，真正调用流都是在这个方法里面进一步实现的。
2.分析Observable.just()调用
示例代码，打印“5”，如下：
Disposable d = Observable.just("5").subscribe(s -> System.out.println(s));
Observable.just 是最简单的rxjava操作了，就是生成数据，如下：
public static Observable just(T item) {
return RxJavaPlugins.onAssembly(new ObservableJust(item));
}
很简单，生成一个ObservableJust对象，内容如下：
public final class ObservableJust extends Observable implements ScalarCallable {
private final T value;
public ObservableJust(final T value) {
this.value = value;
}
@Override
protected void subscribeActual(Observer s) {
ScalarDisposable sd = new ScalarDisposable(s, value);
s.onSubscribe(sd);
sd.run();
}
@Override
public T call() {
return value;
}
}
所以，我们调用Observable.just()，会拿到我们调用链的第一个Observable对象---ObservableJust，它继承了Observable
下一步，传入obersver和value，生成ScalarDisposable对象，直接调用该对象的run方法，完成了整个调用过程。ScalarDisposable.run方法，如下：
@Override
public void run() {
if (get() == START && compareAndSet(START, ON_NEXT)) {
observer.onNext(value);
if (get() == ON_NEXT) {
lazySet(ON_COMPLETE);
observer.onComplete();
}
}
}
忽略其他代码，基本看出，调用了我们传入的observer.onNext() -> observer.onComplete()，完成打印。
3.组合Observable.just() 和 Observable.map()
示例代码，将数字转换为字符串，并打印，如下：
Disposable d = Observable.just(1).map(i -> String.valueOf(i)).subscribe(s -> System.out.println(s));
我们知道，Observable.just()返回了一个ObservableJust对象，也就是Observable
new ObservableJust().map(xxx);
因此我们先记住，当前对象是ObservableJust，打开map方法定义，如下：
public final Observable map(Function mapper) {
return RxJavaPlugins.onAssembly(new ObservableMap(this, mapper));
}
可以看到，返回了一个ObservableMap对象，该对象传入了一个this，也就是当前的Observable对象，所以我们可以知道，如果这个操作符是转换用的，肯定会传入this当前observable对象，而Just操作是数据源的开头，所以不需要。ObservableMap代码如下：
public final class ObservableMap extends AbstractObservableWithUpstream {
final Function function;
public ObservableMap(ObservableSource source, Function function) {
super(source);
this.function = function;
}
@Override
public void subscribeActual(Observer t) {
source.subscribe(new MapObserver(t, function));
}
}
一样的我们点开AbstractObservableWithUpstream
static final class MapObserver extends BasicFuseableObserver {
final Function mapper;
MapObserver(Observer actual, Function mapper) {
super(actual);
this.mapper = mapper;
}
@Override
public void onNext(T t) {
...
U v;
v = ObjectHelper.requireNonNull(mapper.apply(t), "The mapper
actual.onNext(v);
}
}
代码可以看出，收到ObservableJust对象的Integer值后，通过转换函数接口Function，将T类型转换了U类型，也就是我们要的String类型，然后发送给实际的接收者，完成整个流过程。伪代码如下：
方法组合过程：
ObservableJust just = new ObservableJust(数据);
ObservableMap map = new ObservableMap (just, function);
订阅过程：
Observer 实际接收者；
--->
map.subscribe(实际接收者)；
--->
Observer mapObserver = new Observer(实际接收者);
just.subsribe(mapObserver);
--->
导致数据流动开始，int ---> mapObserver --> string --> 实际接收者
简单分析了一下组合调用流程。