RxJava flatMapIterable with a Single

Question

I'm trying to tidy up my code a little, and Single is looking like a good choice for me as I'm doing something that will only ever emit one result.

I'm having an issue though as I was using flatMapIterable previously to take my response (a list) and do something on each item. I'm not seeing how I can achieve this with Single.

getListOfItems()
.flatMapIterable(items -> items)
.flatMap(item -> doSomethingWithItem())
.toList()

This works fine if getListOfItems is returning an Observable but if I try and make it return a Single, then I can't do flatMapIterable and can't see an alternative, any ideas?

score 63 · Accepted Answer · edited Mar 14 '17 at 15:07

63

flattenAsObservable should do the trick, it will map Single success value to Iterable (list), and emit each item of the list as an Observable.

  getListOfItems()
            .flattenAsObservable(new Function<Object, Iterable<?>>() {
                @Override
                public Iterable<?> apply(@NonNull Object o) throws Exception {
                    return toItems(o);
                }
            })
            .flatMap(item -> doSomethingWithItem())
            .toList()

edited Mar 14 '17 at 15:07

akarnokd

69,132
14
157
192

answered Mar 14 '17 at 13:11

yosriz

10,147
2
24
38

Thank you! This is what I was looking for – spO_oks Mar 16 '17 at 10:52
1

Single.flattenAsObservable doesn't exist. Was it a RxJava 1 thing? Is there a v2 equivalent? – miguel Apr 14 '17 at 23:25
1

@miguel, it's RxJava 2 only. – yosriz Apr 15 '17 at 18:55
@miguel it only exists for Single and Maybe. Not for Observable, Flowable or Completable. – Peter F Sep 14 '18 at 12:02

Sebastian · Answer 2 · 2018-09-15T21:17:11.273

15

Building on the answer from yosriz, this is what I ended up with in Kotlin

getListOfItems()
        .flattenAsObservable { it }
        .flatMap { doSomethingWithItem(it) }
        .toList()

The same can be achieved using Kotlin's map, depending on your preference:

getListOfItems()
        .map { items ->
            items.map {
                doSomethingWithItem(it)
            }
        }

edited Sep 15 '18 at 21:17

answered Jul 29 '18 at 10:29

Sebastian

2,896
23
36

2

In Kotlin you can even write `getListOfItems().map { items -> items.map { doSomethingWithItem(it) }` While the first `map` is from RxJava and operates on the stream emission, the second one is from Kotlin and operates on the Iterable. – Peter F Sep 14 '18 at 12:06

score 4 · Answer 3 · answered Apr 06 '18 at 08:32

4

You can convert Single to Observable by using operator toObservable()

It will look like this:

getListOfItems()
    .toObservable()
    .flatMapIterable(items -> items)
    .flatMap(item -> doSomethingWithItem())
    .toList()

answered Apr 06 '18 at 08:32

TermLog

81
3

score 2 · Answer 4 · answered Nov 07 '17 at 10:23

I've made something like this

@Override
public Single<List<String>> getAvailablePaths() {
        return mongoClient.rxFind("t_polygons", new JsonObject())
                            .toObservable()
                            .flatMapIterable(list -> list)
                            .map(json -> json.getString("path"))
                            .filter(Objects::nonNull)
                            .toList()
                            .toSingle();
    }

score 0 · Answer 5 · answered Feb 28 '19 at 11:24

0

Another way to do it is by using flatMapPublisher and Flowable::fromIterable

getListOfItems()
    .flatMapPublisher(Flowable::fromIterable)
    .flatMap(item -> doSomethingWithItem())
    .toList()

answered Feb 28 '19 at 11:24

kosev

2,125
1
20
18

score 0 · Answer 6 · answered Jul 23 '20 at 05:00

0

getListOfItems()
  .flattenAsObservable { it }
  .flatMapSingle { getSingleDoSomeThing(it) }
  .toList()

answered Jul 23 '20 at 05:00

최봉재

4,039
3
16
21

This answer would be improved if you give an explanation of your code. – Michael Jul 23 '20 at 06:29

RxJava flatMapIterable with a Single

6 Answers6

Linked