CODEWITHSUNDEEP
rx-javarx-java2
s-hunter
s-hunter

Reputation: 25796

Cannot resolve method Observable.from in rxjava 2

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);
                }
            })

Upvotes: 14

Views: 9719

Answers (4)

Shankha057
Shankha057

Reputation: 1361

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()));

Upvotes: 0

cesards
cesards

Reputation: 16319

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

Upvotes: 6

Alexander Perfilyev
Alexander Perfilyev

Reputation: 6839

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

    Observable.fromIterable(ints)

Upvotes: 9

Pavan Kumar
Pavan Kumar

Reputation: 4800

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);
            }
        })

Upvotes: 21

Related Questions