Completable # andThen（） 源码：

先订阅Completable，
再订阅 ObservableSource 、 Publisher 、 SingleSource 、 MaybeSource 、 CompletableSource ，
并返回新的Observable、Flowable、Single、Maybe、Completable

来自此Completable的【错误事件】将传播到下游订阅者，
并且将导致跳过 ObservableSource 、 Publisher 、 SingleSource 、 MaybeSource 、 CompletableSource 的订阅。

/**
 * 返回一个Observable，它将订阅此Completable，一旦完成，则将订阅{@code next}ObservableSource。
 * 来自此Completable的错误事件将传播到下游订阅者，并且将导致跳过 Observable的订阅。
 */
public final <T> Observable<T> andThen(ObservableSource<T> next) {
    ObjectHelper.requireNonNull(next, "next is null");
    return RxJavaPlugins.onAssembly(new CompletableAndThenObservable<T>(this, next));
}

/**
 * 返回一个Flowable，它将订阅此Completable，一旦完成，则将订阅{@code next} Flowable。
 * 来自此Completable的错误事件将传播到下游订阅者，并且将导致跳过 Publisher的订阅。
 */
public final <T> Flowable<T> andThen(Publisher<T> next) {
    ObjectHelper.requireNonNull(next, "next is null");
    return RxJavaPlugins.onAssembly(new CompletableAndThenPublisher<T>(this, next));
}

/**
 * 返回一个将订阅此Completable的Single，一旦完成，则将订阅{@code next} SingleSource。
 * 来自此Completable的错误事件将传播到下游订阅者，并且将导致跳过 Single的订阅。
 */
public final <T> Single<T> andThen(SingleSource<T> next) {
    ObjectHelper.requireNonNull(next, "next is null");
    return RxJavaPlugins.onAssembly(new SingleDelayWithCompletable<T>(next, this));
}

/**
 * 返回{@link Maybe}，它将订阅此Completable，一旦完成，则将订阅{@code next} MaybeSource。 
 * 来自此Completable的错误事件将传播到下游订阅者，并导致跳过 Maybe的订阅。
 */
public final <T> Maybe<T> andThen(MaybeSource<T> next) {
    ObjectHelper.requireNonNull(next, "next is null");
    return RxJavaPlugins.onAssembly(new MaybeDelayWithCompletable<T>(next, this));
}

/**
 * 返回一个Completable，它首先运行此Completable，然后再运行另一个Completable。
 * 这是{@link #concatWith（CompletableSource）}的别名。
 */
public final Completable andThen(CompletableSource next) {
    ObjectHelper.requireNonNull(next, "next is null");
    return RxJavaPlugins.onAssembly(new CompletableAndThenCompletable(this, next));
}

/**
 * 将此Completable与另一个Completable串联。
 * 返回:新的Completable，该Completable订阅了此内容，然后订阅了另一个Completable
 * @see #andThen(MaybeSource)
 * @see #andThen(ObservableSource)
 * @see #andThen(SingleSource)
 * @see #andThen(Publisher)
 */
@CheckReturnValue
@NonNull
@SchedulerSupport(SchedulerSupport.NONE)
public final Completable concatWith(CompletableSource other) {
    ObjectHelper.requireNonNull(other, "other is null");
    return RxJavaPlugins.onAssembly(new CompletableAndThenCompletable(this, other));
}

示例：

private Completable getCompletableComplete() {
    return Completable.create(new CompletableOnSubscribe() {
        @Override
        public void subscribe(CompletableEmitter emitter) throws Exception {
            emitter.onComplete();//
        }
    });
}

private Completable getCompletableError() {
    return Completable.create(new CompletableOnSubscribe() {
        @Override
        public void subscribe(CompletableEmitter emitter) throws Exception {
            emitter.onError(new Error());//
        }
    });
}




@Test
public void andThen1() {
    getCompletableComplete().andThen(Observable.range(0, 5))
            .subscribe(getObserver());
}
//========onSubscribe=========
//========onNext=========0
//========onNext=========1
//========onNext=========2
//========onNext=========3
//========onNext=========4
//=========onComplete========


//返回一个Observable，它将订阅此Completable，
//一旦完成，则将订阅{@code next} ObservableSource。
// 来自此Completable的错误事件将传播到下游订阅者，并且将导致跳过 Observable的订阅。
@Test
public void andThen2() {
    getCompletableError().andThen(Observable.range(0, 5))
            .subscribe(getObserver());
}
//========onSubscribe=========
//========onError=========null



private Observer<Integer> getObserver() {
    return new Observer<Integer>() {
        @Override
        public void onSubscribe(Disposable d) {
            System.out.println("========onSubscribe=========");
        }

        @Override
        public void onNext(Integer integer) {
            System.out.println("========onNext=========" + integer);
        }

        @Override
        public void onError(Throwable e) {
            System.out.println("========onError=========" + e.getMessage());
        }

        @Override
        public void onComplete() {
            System.out.println("=========onComplete========");
        }
    };
}