Cannot resolve method Observable.from in rxjava 2

Question

There is a from method in the Observable class in rxjava 1 but not found in rxjava 2. How can I replace the from method in rxjava 2 in the following code:

    List<Integer> ints = new ArrayList<>();
    for (int i=1; i<10; i++) {
        ints.add(new Integer(i));
    }
    Observable.just(ints)
            .flatMap(new Function<List<Integer>, Observable<Integer>>() {
                @Override
                public Observable<Integer> apply(List<Integer> ints) {
                    return Observable.from(ints);
                }
            })

Answer 1

You can use Observable.fromIterable(source)

From documentation:

Some operator overloads have been renamed with a postfix, such as fromArray, fromIterable etc. The reason for this is that when the library is compiled with Java 8, the javac often can't disambiguate between functional interface types.

List<Integer> ints = new ArrayList<>();
for (int i=1; i<10; i++) {
    ints.add(new Integer(i));
}
Observable.just(ints)
        .flatMap(new Function<List<Integer>, Observable<Integer>>() {
            @Override
            public Observable<Integer> apply(List<Integer> ints) {
                return Observable.fromIterable(ints);
            }
        })

Answer 2

You don't need to use .just() because you can create Observable directly from your list via fromIterable() operator.

    Observable.fromIterable(ints)

Answer 3

I guess it's a bit late, but I just wanted to let people know, the API changes related to the from operator in the RxJava documentation:

from disambiguated into fromArray, fromIterable, fromFuture

Answer 4

If you need a List then you can simply use Java Stream and create a List from it and then pass it directly to the Observable.fromIterable method. Like this:

Observable.fromIterable(IntStream.rangeClosed(lowerLimitInclusive,upperLimitInclusive)
            .boxed()
            .collect(Collectors.toList()));   

Or

Observable.fromIterable(Stream.iterate(lowerLimitInclusive, integer -> integer + 1)
                .filter(integer -> integer < (upperLimit+1))
                .limit((long(upperLimit+1)-long(lowerLimitInclusive))
                .collect(Collectors.toList()));