Android开发面试之RxJava，经典面试问题及答案

最新推荐文章于 2024-05-17 10:56:58 发布

2401_84104532

最新推荐文章于 2024-05-17 10:56:58 发布

阅读量999

点赞数 23

分类专栏：程序员文章标签： android 面试 rxjava

本文链接：https://blog.csdn.net/2401_84104532/article/details/137732008

版权

程序员专栏收录该内容

30 篇文章 0 订阅

订阅专栏

先自我介绍一下，小编浙江大学毕业，去过华为、字节跳动等大厂，目前阿里P7

深知大多数程序员，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年最新Android移动开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上Android开发知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

如果你需要这些资料，可以添加V获取：vip204888 （备注Android）

正文

您可以通过如下代码测试：

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 createObservable = Observable.create(new ObservableOnSubscribe() {

@Override

public void subscribe(@NonNull ObservableEmitter emitter) throws Throwable {

emitter.onNext(1);

emitter.onNext(2);

emitter.onNext(3);

emitter.onComplete();

}

});

Observable mapObservable = createObservable.map(new Function<Integer, String>() {

@Override

public String apply(Integer integer) throws Throwable {

return String.valueOf(integer + 1);

}

});

Observer observer = new Observer() {

@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 flatMapObservable = mapObservable.flatMap(new Function<String, ObservableSource>() {

@Override

public ObservableSource apply(String s) throws Throwable {

return Observable.create(new ObservableOnSubscribe() {

@Override

public void subscribe(@NonNull ObservableEmitter 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 createObservable = Observable.just(“1”, “2”, “3”, “4”, “5”, “6”, “7”, “8”, “9”);

Observable flatMapObservable = createObservable.flatMap(new Function<String, ObservableSource>() {

@Override

public ObservableSource apply(String s) throws Throwable {

if (s.equals(“2”)) {

return Observable.create(new ObservableOnSubscribe() {

@Override

public void subscribe(@NonNull ObservableEmitter emitter) throws Throwable {

emitter.onNext(Integer.valueOf(s) + 1);

emitter.onComplete();

}

}).delay(500, TimeUnit.MILLISECONDS);

} else {

return Observable.create(new ObservableOnSubscribe() {

@Override

public void subscribe(@NonNull ObservableEmitter emitter) throws Throwable {

emitter.onNext(Integer.valueOf(s) + 1);

emitter.onComplete();

}

});

}

});

Observable observeOnObservable = flatMapObservable.subscribeOn(Schedulers.io()).observeOn(AndroidSchedulers.mainThread());

Observer observer = new Observer() {

@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

public void subscribeActual(final Observer<? super T> observer) {

//创建了内部的Observer，其实这里类似上面介绍的Observable.create创建的发射器，只不过发射器是Emitter

final SubscribeOnObserver parent = new SubscribeOnObserver<>(observer);

//给下游的observer添加订阅的监听

observer.onSubscribe(parent);

//给SubscribeOnObserver设置disposable对象

parent.setDisposable(scheduler.scheduleDirect(new SubscribeTask(parent)));

}

创建了SubscribeOnObserver对象，它是Observer类型的，其实类似上面介绍的Observable.create创建的发射器，只不过发射器是Emitter类型。接着给下游的observer添加订阅的监听，最后是给SubscribeOnObserver设置disposable对象，还记得在observable.create最后一步是给上游的ObservableOnSubscribe添加订阅吗，那我们看看此处是如果给上游的observable添加订阅的，首先scheduler是Schedulers.io()，最终它是一个IoScheduler对象，里面是通过CachedWorkerPool内部类创建了线程池，创建线程池如下:

evictor = Executors.newScheduledThreadPool(1, EVICTOR_THREAD_FACTORY);

而scheduler.scheduleDirect(new SubscribeTask(parent))中的SubscribeTask是一个Runnable，所以最终通过线程池执行SubscribeTask的run方法：

到了最后还是通过线程池执行Runnable来添加上游Observable的订阅，并且把当前创建的SubscribeOnObserver传给了上游的observable，这个跟我们上面介绍Observable.create中给上游的ObservableOnSubscribe添加订阅是一样的。

小总结

subscribeOn实际是创建了ObservableSubscribeOn的Observable，它的订阅方法里面创建了SubscribeOnObserver，通过线程池执行Runnable来达到上游Observable的订阅在子线程中执行，这就是为什么subscribeOn能控制observable在哪个线程中执行的原因。

observeOn(AndroidSchedulers.mainThread())

同样如此observeOn也会有对应的observable，它是ObservableObserveOn，我们直接看它订阅的方法：

同样如此，可以看到先是拿到AndroidSchedulers中的worker，它是HandlerWorker类型，按道理说应该给下游的observer添加订阅监听啊，怎么没有呢，看官别急，我们继续看ObserveOnObserver的订阅方法：

我们的重点不在下游的observer订阅监听这，在ObserveOnObserver的onNext方法中，会调用schedule方法，最终是通过HandlerWorker的schedule执行ObserveOnObserver，因为ObserveOnObserver也是一个runnable实现类，HandlerWorker中的schedule方法是通过主线程的Handler给主线程发送了一个Message，所以我们回到ObserveOnObserver的run方法，在run方法中会执行下游的onNext、onError等方法，所以这就是为什么observeOn能让observer能在主线程中执行。

小总结

observeOn实际是创建了ObservableObserveOn的Observable，它的订阅方法里面创建了ObserveOnObserver，而ObserveOnObserver是实现了Runnable接口，把它包装成message给主线程的Handler发送一条消息，而ObserveOnObserver的run方法中会给下游的Observer发送数据。所以这就是observeOn能让observer在哪个线程中执行。

RxJava的subscribeOn只有第一次生效?

如果你理解了订阅的过程，其实该问题很好理解，subscribeOn是规定上游的observable在哪个线程中执行，如果我们执行多次的subscribeOn的话，从下游的observer到上游的observable的订阅过程，最开始调用的subscribeOn返回的observable会把后面执行的subscribeOn返回的observable给覆盖了，因此我们感官的是只有第一次的subscribeOn能生效。

那如何才能知道它实际在里面生效了呢，我们可以通过doOnSubscribe来监听切实发生线程切换了。

RxJava的observeOn多次调用哪个有效?

上面分析了observeOn是指定下游的observer在哪个线程中执行，所以这个更好理解，看observeOn下一个observer是哪一个，所以多次调用observeOn肯定是最后一个observeOn控制有效。

RxJava1.0、RxJava2.0、RxJava3.0有什么区别？

RxJava2.0相比于RxJava1.0

添加背压的策略Flowable
添加Observer的变体consumer
ActionN 和 FuncN 改名（Action0 改名成Action，Action1改名成Consumer，而Action2改名成了BiConsumer，而Action3 - Action9都不再使用了，ActionN变成了Consumer<Object[]> 。Func改名成Function，Func2改名成BiFunction，Func3 - Func9 改名成 Function3 - Function9，FuncN 由 Function<Object[], R> 取代。）
Observable.OnSubscribe 变成 ObservableOnSubscribe
ObservableOnSubscribe 中使用 ObservableEmitter 发射数据给 Observer，在RxJava中使用Subscriber发射数据。
Subscription 改名为 Disposable

RxJava3.0相比与RxJava2.0

提供Java 8 lambda友好的API
删除Maybe.toSingle(T)
删除Flowable.subscribe(4 args)
删除Observable.subscribe(4 args)
删除Single.toCompletable()

你以为完了吗，还有背压没介绍呢，好吧，由于篇幅原因，把背压放到下一篇单独来讲了。

总结

本文讲解了我对Android开发现状的一些看法，也许有些人会觉得我的观点不对，但我认为没有绝对的对与错，一切交给时间去证明吧！愿与各位坚守的同胞们互相学习，共同进步！

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加V获取：vip204888 （备注Android）

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

sable

RxJava3.0相比与RxJava2.0

提供Java 8 lambda友好的API
删除Maybe.toSingle(T)
删除Flowable.subscribe(4 args)
删除Observable.subscribe(4 args)
删除Single.toCompletable()

你以为完了吗，还有背压没介绍呢，好吧，由于篇幅原因，把背压放到下一篇单独来讲了。

总结

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加V获取：vip204888 （备注Android）
[外链图片转存中…(img-sLrwMGhP-1713037963088)]

2401_84104532

关注

23
点赞
踩
21

收藏

觉得还不错? 一键收藏
0
评论
Android开发面试之RxJava，经典面试问题及答案

onComplete是用来控制不能发送数据的，也就是不能onNext了，包括onError也是不能再发送onNext数据了，该方法中也是调用了dispose方法。从上面各个对应的observer接口来看，如果只想发一条数据，或者不发数据就用Maybe，如果想法多条数据或者不发数据就用Observable，如果只发一条数据或者失败就用Single，如果想用背压策略使用Flowable，如果不发数据就用Completable。
复制链接

扫一扫