Menu
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?
219
RxJava (and its derivatives like RxGroovy & RxScala) has developed an Observable variant called “Single.” A Single is something like an Observable, but instead of emitting a series of values — anywhere from none at all to an infinite number — it always either emits one value or an error notification.
If I understood correctly, you want to convert Single<List<Item>> into stream of Item2 objects, and be able to work with them sequentially. In this case, you need to transform list into observable that sequentially emits items using . toObservable(). flatMap(...) to change the type of the observable.
flatMapIterable : Maps the values of the upstream source into Iterable s and iterates each of them one after the other. In other words, it merges dynamically generated pull sources. You can express flatMapIterable as flatMap(Observable::fromIterable) or concatMap(Observable::fromIterable) .
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()
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)
}
}
You can convert Single to Observable by using operator toObservable()
It will look like this:
getListOfItems()
.toObservable()
.flatMapIterable(items -> items)
.flatMap(item -> doSomethingWithItem())
.toList()
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With
