source.subscribe(parent);
} catch (Throwable ex) {
Exceptions.throwIfFatal(ex);
parent.onError(ex);
}}
先是创建`CreateEmitter`类型的发射器，把下游的observer传给发射器，注意此处的发射器是实现了`Disposable`接口，所以紧接着会把发射器通过下游的观察者的`onSubscribe`方法传给下游观察者，注意此处传的是`Disposable`对象。接着会给上游的`ObservableOnSubscribe`添加订阅，并且把下游的observer给上游的`ObservableOnSubscribe`。 为了描述订阅的过程，我们画一张时序图：
##### []( )小总结
> 订阅是从下游的Observer向上游的Observable发送订阅，然后在订阅的过程中，给下游的Observer发送订阅监听，并且给上游的被观察者添加订阅。
#### []( )发送数据
上面我们知道在ObservableCreate的subscribeActual方法中给上游的ObservableOnSubscribe添加了onSubscribe订阅过程，并且把当前的发射器传给了ObservableOnSubscribe，而在我们上面的示例中定义的`ObservableOnSubscribe`内部类的subscribe方法通过传过来的发射器添加了如下代码:
emitter.onNext(1);
emitter.onNext(2);
emitter.onNext(3);
emitter.onComplete();
所以到这里可以看到是通过发射器的onNext和onComplete发送数据，而emitter是上面订阅过程传过来的CreateEmitter，所以直接看它的onNext和onComplete：
@Override
public void onNext(T t) {
if (t == null) {
onError(ExceptionHelper.createNullPointerException("onNext called with a null value."));
return;
}
//如果isDisposed为false，则可以继续发送数据
if (!isDisposed()) {
observer.onNext(t);
}}
很简单，给`observer`发送数据，而当前的`observer`是订阅过程中传进来的下游`observer`，所以大家明白了吧，最终是下游的`observer`接收到数据。
##### []( )小总结
> 发送主要通过上游的被观察者通知发射器，然后发射器会发送给下游的observer。
### []( )Observer处理完onComplete后会还能onNext吗?
上面我们看到emitter.onNext三次完了后，会发送onComplete事件，那onComplete处理啥呢：
@Override
public void onComplete() {
if (!isDisposed()) {
try {
observer.onComplete();
} finally {
dispose();
}
}}
这是发射器中`onComplete`的定义，`dispose`方法是控制是否还能发送数据，其实这里的 `CreateEmitter`它是一个`AtomicReference<Disposable>`原子类包装Disposable的实现类，而我们`dispose`方法正是将该原子类添加了常量的`DISPOSED`，而在onNext方法中通过判断`isDisposed`是否为false才能继续发送数据。而`isDisposed`什么时候为false呢？当`AtomicReference<Disposable>`中的包装对象不是`DISPOSED`。所以我们的`onComplete`是用来控制不能发送数据的。
您可以通过如下代码测试：
emitter.onNext(1);
emitter.onNext(2);
emitter.onComplete();
emitter.onNext(3);
看看下游的observer是否还能收到3的数据。
##### []( )小总结
> `onComplete`是用来控制不能发送数据的，也就是不能`onNext`了，包括onError也是不能再发送`onNext`数据了，该方法中也是调用了`dispose`方法。
### []( )RxJava中map、flatMap的区别，你还用过其他哪些操作符?
map和flatMap是我们经常用的转换操作，我们先看看map如何使用：
Observable<Integer> createObservable = Observable.create(new ObservableOnSubscribe<Integer>() {
@Override
public void subscribe(@NonNull ObservableEmitter<Integer> emitter) throws Throwable {
emitter.onNext(1);
emitter.onNext(2);
emitter.onNext(3);
emitter.onComplete();
}
});
Observable<String> mapObservable = createObservable.map(new Function<Integer, String>() {
@Override
public String apply(Integer integer) throws Throwable {
return String.valueOf(integer + 1);
}
});
Observer<String> observer = new Observer<String>() {
@Override
public void onSubscribe(@NonNull Disposable d) {
Log.d(TAG, "onSubscribe:" + d.getClass().getName());
}
@Override
public void onNext(@NonNull String string) {
Log.d(TAG, "onNext: " + string);
}
@Override
public void onError(@NonNull Throwable e) {
Log.d(TAG, "onError: " + e.getMessage());
}
@Override
public void onComplete() {
Log.d(TAG, "onComplete");
}
};
mapObservable.subscribe(observer);}
通过`createObservable`的map操作生成了一个`mapObservable`的被观察者，最终通过`mapObservable`与`observer`形成订阅关系，而map操作需要一个Function的接口，第一个泛型是入参类型，第二个泛型是出参的类型，也就是apply的返回值，这里定义map的出参类型是String类型。 我们再来看下flatMap如何使用：
Observable<Integer> flatMapObservable = mapObservable.flatMap(new Function<String, ObservableSource<Integer>>() {
@Override
public ObservableSource<Integer> apply(String s) throws Throwable {
return Observable.create(new ObservableOnSubscribe<Integer>() {
@Override
public void subscribe(@NonNull ObservableEmitter<Integer> emitter) throws Throwable {
emitter.onNext(Integer.valueOf(s)+1);
emitter.onComplete();
}
});
}});
flatMapObservable.subscribe(observer);
在上面的mapObservable基础上通过flatMap返回flatMapObservable，最后通过flatMapObservable订阅observer。flatMap的Function第二个泛型是ObservableSource类型的，Observable的父类是ObservableSource类型，因此第二个参数返回Observable也可以。
**从上面可以看出map是通过原始数据类型返回另外一种数据类型，而flatMap是通过原始数据类型返回另外一种被观察者。**
关于面试也有问flatMap和concatMap的区别，下面我通过一个例子来演示他们的区别:
Observable<String> createObservable = Observable.just("1", "2", "3", "4", "5", "6", "7", "8", "9");
Observable<Integer> flatMapObservable = createObservable.flatMap(new Function<String, ObservableSource<Integer>>() {
@Override
public ObservableSource<Integer> apply(String s) throws Throwable {
if (s.equals("2")) {
return Observable.create(new ObservableOnSubscribe<Integer>() {
@Override
public void subscribe(@NonNull ObservableEmitter<Integer> emitter) throws Throwable {
emitter.onNext(Integer.valueOf(s) + 1);
emitter.onComplete();
}
}).delay(500, TimeUnit.MILLISECONDS);
} else {
return Observable.create(new ObservableOnSubscribe<Integer>() {
@Override
public void subscribe(@NonNull ObservableEmitter<Integer> emitter) throws Throwable {
emitter.onNext(Integer.valueOf(s) + 1);
emitter.onComplete();
}
});
}
}});
Observable<Integer> observeOnObservable = flatMapObservable.subscribeOn(Schedulers.io()).observeOn(AndroidSchedulers.mainThread());
Observer<Integer> observer = new Observer<Integer>() {
@Override
public void onSubscribe(@NonNull Disposable d) {
Log.d(TAG, "onSubscribe:" + d.getClass().getName());
}
@Override
public void onNext(@NonNull Integer string) {
Log.d(TAG, "onNext: " + string);
}
@Override
public void onError(@NonNull Throwable e) {
Log.d(TAG, "onError: " + e.getMessage());
}
@Override
public void onComplete() {
Log.d(TAG, "onComplete");
}};
observeOnObservable.subscribe(observer);
在上面`flatMap`操作过程中为了演示`flatMap`和`concatMap`的区别，在数据为2的时候让返回的`observable`延迟500毫秒，我们看到的结果如下: 
上面例子中3是由2的发射数据发射过来的，而正好数据为2的时候让延迟了500毫秒，那如果换成concatMap结果是按照发射数据的顺序来返回的。
**concatMap和flatMap的功能是一样的， 将一个发射数据的Observable变换为多个Observables，然后将它们发射的数据放进一个单独的Observable。只不过最后合并ObservablesflatMap采用的merge，而concatMap采用的是连接(concat)。总之一句一话,他们的区别在于：concatMap是有序的，flatMap是无序的，concatMap最终输出的顺序与原序列保持一致，而flatMap则不一定，有可能出现交错。**
关于其他的操作符比如merge、concat、zip都是合并，interval是周期执行，timer是延迟发送数据。如果要学习更多的操作符请[猛戳官网]( )
### []( )Maybe、Observer、Single、Flowable、Completable几种观察者的区别，以及他们在什么场景用？
其实想知道它们的区别，我们直接看对应的Observer的方法有哪些:
* Maybe
Maybe从字面意思是**可能**的意思，看下`MaybeObserver`接口：
public interface MaybeObserver<@NonNull T> {
void onSubscribe(@NonNull Disposable d);
void onSuccess(@NonNull T t);
void onError(@NonNull Throwable e);
void onComplete();}
**它没有onNext方法，也就是说不能发多条数据，如果回调到`onSuccess`再不能发消息了，如果直接回调`onComplete`相当于没发数据，也就是说Maybe可能不发送数据，如果发送数据只会发送单条数据。**
* Observer
**这个不用多说了，它是能发送多条数据的，直到发送`onError`或`onComplete`才不会再发送数据了，当然它也是可以不发送数据的，直接发送`onError`或`onComplete`。**
* Single
public interface SingleObserver<@NonNull T> {
void onSubscribe(@NonNull Disposable d);
void onSuccess(@NonNull T t);
void onError(@NonNull Throwable e);}
**single也是发送单条数据，单是它要么成功要么失败。**
* Flowable
**Flowable没有FlowableObserver接口，它是由FlowableSubscriber代表观察者，Flowable在后面被压的时候讲，我们只要知道它是被压策略的一个被观察者。**
* Completable
public interface CompletableObserver {
void onSubscribe(@NonNull Disposable d);
void onComplete();
void onError(@NonNull Throwable e);}
**Completable不发送数据，只会发送成功或失败的事件，当然这个用得很少。**
##### []( )小总结
> 从上面各个对应的observer接口来看，如果只想发一条数据，或者不发数据就用Maybe，如果想法多条数据或者不发数据就用Observable，如果只发一条数据或者失败就用Single，如果想用背压策略使用Flowable，如果不发数据就用Completable。
### []( )RxJava切换线程是怎么回事?
大家都知道RxJava切换线程使用`subscribeOn`指定被观察者的在哪个线程执行，使用`observeOn`指定观察者在哪个线程执行，通常我们写法如下:
subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
#### []( )subscribeOn(Schedulers.io())
subscribeOn会返回一个`ObservableSubscribeOn`，它是一个Observable，根据前面介绍的订阅流程，我们直接看`ObservableSubscribeOn`的`subscribeActual`操作：
@Override
结语
网上高级工程师面试相关文章鱼龙混杂，要么一堆内容，要么内容质量太浅， 鉴于此我整理了上述安卓开发高级工程师面试题以及答案。希望帮助大家顺利进阶为高级工程师。
目前我就职于某大厂安卓高级工程师职位，在当下大环境下也想为安卓工程师出一份力，通过我的技术经验整理了面试经常问的题，答案部分是一篇文章或者几篇文章，都是我认真看过并且觉得不错才整理出来。
大家知道高级工程师不会像刚入门那样被问的问题一句话两句话就能表述清楚，所以我通过过滤好文章来帮助大家理解。
现在都说互联网寒冬，其实只要自身技术能力够强，咱们就不怕！我这边专门针对Android开发工程师整理了一套【Android进阶学习视频】、【全套Android面试秘籍】、【Android知识点PDF】。如有需要获取资料文档的朋友，可以点击这里免费获取
原创文章，作者：ItWorker，如若转载，请注明出处：https://blog.ytso.com/140416.html