Chain of any number of Observable::flatMap calls - rx-java2

Question

Let's say I have a few Observable suppliers with the side effect on get call:
Subject<String> firstSubject = PublishSubject.create();
Supplier<Observable<String>> firstSupplier = () -> {
System.out.println("side effect of first one");
return firstSubject;
};
Subject<String> secondSubject = PublishSubject.create();
Supplier<Observable<String>> secondSupplier = () -> {
System.out.println("side effect of second one");
return secondSubject;
};
Subject<String> thirdSubject = PublishSubject.create();
Supplier<Observable<String>> thirdSupplier = () -> {
System.out.println("side effect of third one");
return thirdSubject;
};
Now I want to combine them in the following way - the get of the next supplier is called after the Observable from previous one emits a value (onNext is called).
I can do it with the following code:
firstSupplier.get()
.flatMap(__ -> secondSupplier.get())
.flatMap(__ -> thirdSupplier.get())
.subscribe();
// output: side effect of first one
firstSubject.onNext("");
// output: side effect of second one
secondSubject.onNext("");
// output: side effect of third one
How can I rewrite this code to accept unknown number of suppliers, passed as a - for example - Collection<Supplier<Observable>>?
I've reviewed various factory methods of Observable (like merge, concat), however they all are taking a collection of ObservableSource, which means I have to call get on all of my suppliers eagerly. However in my case it is important to call it lazily - only after previous Observable emits a value.

Answer 1

Edit 2:
I completely forgot that Observable.flatMap calls the mapper even if maxConcurrency is set to 1 and queues up the generated Observables to be run later.
I hope the following setup works as expected (i.e, it wasn't specified what should happen to the subsequent onNexts to the subjects).
Subject<String> firstSubject = PublishSubject.create();
Supplier<Observable<String>> firstSupplier = () -> {
System.out.println("side effect of first one");
return firstSubject;
};
Subject<String> secondSubject = PublishSubject.create();
Supplier<Observable<String>> secondSupplier = () -> {
System.out.println("side effect of second one");
return secondSubject;
};
Subject<String> thirdSubject = PublishSubject.create();
Supplier<Observable<String>> thirdSupplier = () -> {
System.out.println("side effect of third one");
return thirdSubject;
};
Collection<Supplier<Observable<String>>> collection =
Arrays.asList(firstSupplier, secondSupplier, thirdSupplier);
Observable.fromIterable(collection)
.concatMap(supplier -> supplier.get().take(1))
.subscribe();
System.out.println("// output: side effect of first one");
firstSubject.onNext("");
System.out.println("// output: side effect of second one");
secondSubject.onNext("");
System.out.println("// output: side effect of third one");
prints:
side effect of first one
// output: side effect of first one
side effect of second one
// output: side effect of second one
side effect of third one
// output: side effect of third one