RxJava: How to convert List of objects to List of another objects

JavaAndroidRx Java

Java Problem Overview

I have the List of SourceObjects and I need to convert it to the List of ResultObjects.

I can fetch one object to another using method of ResultObject:


of course I can do it like this:

public void onNext(List<SourceObject> srcObjects) {
   List<ResultsObject> resObjects = new ArrayList<>();
   for (SourceObject srcObj : srcObjects) {
       resObjects.add(new ResultsObject().convertFromSource(srcObj));

but I will be very appreciate to someone who can show how to do the same using rxJava.

Java Solutions

Solution 1 - Java

If your Observable emits a List, you can use these operators:

  • flatMapIterable (transform your list to an Observable of items)

  • map (transform your item to another item)

  • toList operators (transform a completed Observable to a Observable which emit a list of items from the completed Observable)

      Observable<SourceObjet> source = ...
      source.flatMapIterable(list -> list)
            .map(item -> new ResultsObject().convertFromSource(item))
            .subscribe(transformedList -> ...);

Solution 2 - Java

If you want to maintain the Lists emitted by the source Observable but convert the contents, i.e. Observable<List<SourceObject>> to Observable<List<ResultsObject>>, you can do something like this:

Observable<List<SourceObject>> source = ...
source.flatMap(list ->
            .map(item -> new ResultsObject().convertFromSource(item))
            .toObservable() // Required for RxJava 2.x
    .subscribe(resultsList -> ...);

This ensures a couple of things:

  • The number of Lists emitted by the Observable is maintained. i.e. if the source emits 3 lists, there will be 3 transformed lists on the other end
  • Using Observable.fromIterable() will ensure the inner Observable terminates so that toList() can be used

Solution 3 - Java

The Observable.from() factory method allows you to convert a collection of objects into an Observable stream. Once you have a stream you can use the map operator to transform each emitted item. Finally, you will have to subscribe to the resulting Observable in order to use the transformed items:

// Assuming List<SourceObject> srcObjects
Observable<ResultsObject> resultsObjectObservable = Observable.from(srcObjects).map(new Func1<SourceObject, ResultsObject>() {
    public ResultsObject call(SourceObject srcObj) {
        return new ResultsObject().convertFromSource(srcObj);

resultsObjectObservable.subscribe(new Action1<ResultsObject>() { // at this point is where the transformation will start
    public void call(ResultsObject resultsObject) { // this method will be called after each item has been transformed
        // use each transformed item

The abbreviated version if you use lambdas would look like this:

  .map(srcObj -> new ResultsObject().convertFromSource(srcObj))
  .subscribe(resultsObject -> ...);

Solution 4 - Java

Don't break the chain, just like this.

Observable.from(Arrays.asList(new String[] {"1", "2", "3", }))
.map(s -> Integer.valueOf(s))
.reduce(new ArrayList<Integer>, (list, s) -> {
    return list;
.subscribe(i -> {
    // Do some thing with 'i', it's a list of Integer.

Solution 5 - Java

Non blocking conversion using nested map function

val ints: Observable<List<Int>> = Observable.fromArray(listOf(1, 2, 3))

val strings: Observable<List<String>> = ints.map { list -> list.map { it.toString() } }

Solution 6 - Java

You can use map operator. For example if you have lists of integers and you want to convert to lists of doubles:

    List<Integer> li = new ArrayList<>();
    Observable.just(li).map( l -> {
        List<Double> lr = new ArrayList<Double>();
        for(Integer e:l) {
        return lr;

But all it's a lot more natural if you can control the observable and change it to observe single elements instead of collections. Same code that converts single integer elements into double ones:

Observable.just(1,2,3).map( elem -> elem.doubleValue())

Solution 7 - Java

As an extension to Noel great answer. Let's say transformation also depends on some server data that might change during subscription. In that case use flatMap + scan.

As a result when id list changes, transformations will restart anew. And when server data changes related to a specific id, single item will be retransformed as well.

fun getFarmsWithGroves(): Observable<List<FarmWithGroves>> {

        return subscribeForIds() //may change during subscription
                .switchMap { idList: Set<String> ->

                            .flatMap { id: String -> transformId(id) } //may change during subscription
                            .scan(emptyList<FarmWithGroves>()) { collector: List<FarmWithGroves>, candidate: FarmWithGroves ->
                                updateList(collector, candidate)

Solution 8 - Java

Using toList() waits for the source observable to complete, so if you do that on an infinite observable (like one bound to UI events and Database calls), you will never get anything in your subscribe().

The solution to that is to Use FlatMapSingle or SwitchMapSingle.

Observable<List<Note>> observable =   noteDao.getAllNotes().flatMapSingle(list -> Observable.fromIterable(list).toList());

Now,everytime your list is updated, you can make that event behave as an observable.

Solution 9 - Java

If what you need is simply List<A> to List<B> without manipulating result of List<B>.

The cleanest version is:

List<A> a = ... // ["1", "2", ..]
List<B> b = Observable.from(a)
                      .map(a -> new B(a))


All content for this solution is sourced from the original question on Stackoverflow.

The content on this page is licensed under the Attribution-ShareAlike 4.0 International (CC BY-SA 4.0) license.

Content TypeOriginal AuthorOriginal Content on Stackoverflow
QuestionYura BuyaroffView Question on Stackoverflow
Solution 1 - JavadwursteisenView Answer on Stackoverflow
Solution 2 - JavaNoelView Answer on Stackoverflow
Solution 3 - JavamurkiView Answer on Stackoverflow
Solution 4 - JavaAtanLView Answer on Stackoverflow
Solution 5 - JavatomrozbView Answer on Stackoverflow
Solution 6 - JavalujopView Answer on Stackoverflow
Solution 7 - JavaAndrewView Answer on Stackoverflow
Solution 8 - JavaUsman ZaferView Answer on Stackoverflow
Solution 9 - JavasaidayView Answer on Stackoverflow