RxJava: Cómo convertir Lista de objetos en Lista de otros objetos

Si su Observable emite una List , puede utilizar estos operadores:

• flatMapIterable (transforma tu lista en un Observable de items)
• map (transforma tu elemento en otro elemento)

• toList operadores (transformar un observable completado a un observable que emiten una lista de elementos del Observable completado)

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

El método de fábrica Observable.from () le permite convertir una colección de objetos en un flujo observable. Una vez que tenga una secuencia, puede utilizar el operador de mapa para transformar cada elemento emitido. Por último, tendrá que suscribirse a la Observable resultante para utilizar los elementos transformados:

 // Assuming List<SourceObject> srcObjects Observable<ResultsObject> resultsObjectObservable = Observable.from(srcObjects).map(new Func1<SourceObject, ResultsObject>() { @Override public ResultsObject call(SourceObject srcObj) { return new ResultsObject().convertFromSource(srcObj); } }); resultsObjectObservable.subscribe(new Action1<ResultsObject>() { // at this point is where the transformation will start @Override public void call(ResultsObject resultsObject) { // this method will be called after each item has been transformed // use each transformed item } }); 

La versión abreviada si usas lambdas sería así:

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

Si desea mantener las Lists emitidas por la fuente Observable pero convertir el contenido, es decir, Observable<List<SourceObject>> a Observable<List<ResultsObject>> , puede hacer algo como esto:

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

Esto asegura un par de cosas:

• Se mantiene el número de Lists emitidas por el Observable . Es decir, si la fuente emite 3 listas, habrá 3 listas transformadas en el otro extremo
• El uso de Observable.fromIterable() garantizará que el Observable interno termine para que se pueda usar toList()

No rompan la cadena, así.

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

Puede utilizar el operador de mapa . Por ejemplo, si tiene lista s de enteros y desea convertir a lista s de dobles:

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

Pero todo es mucho más natural si puedes controlar lo observable y cambiarlo para observar elementos únicos en lugar de colecciones. El mismo código que convierte los elementos enteros individuales en los dobles:

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