RxJava: Cómo convertir Lista de objetos en Lista de otros objetos
Tengo la lista de SourceObjects y necesito convertirla a la lista de ResultObjects.
Puedo obtener un objeto a otro usando el método de ResultObject:
- Utilizar RxJava para encadenar la solicitud en un solo hilo
- ¿Por qué RxJava con Retrofit en Android doOnError () no funciona, pero el suscriptor onError no
- Limitar el rendimiento con RxJava
- ¿Cómo utilizar Rx para gestionar múltiples observadores con el fin de mantener una sola conexión abierta a un servicio?
- Encadenamiento de servicios de Retrofit con soporte de RxJava
convertFromSource(srcObj);
Por supuesto que puedo hacerlo así:
public void onNext(List<SourceObject> srcObjects) { List<ResultsObject> resObjects = new ArrayList<>(); for (SourceObject srcObj : srcObjects) { resObjects.add(new ResultsObject().convertFromSource(srcObj)); } }
Pero voy a ser muy apreciar a alguien que puede mostrar cómo hacer lo mismo con rxJava .
- InterruptedException en el subproceso de caché RxJava al depurar en Android
- Encadenamiento de observables basado en resultados
- Combinación de escuchas de datos en tiempo real Firebase con RxJava
- ¿Cómo implementar la función de búsqueda con SearchView, Retrofit y RxJava (RxBindings)?
- Hacer cola de tareas con RxJava en Android
- RxJava se vuelve a suscribir al evento tras la restauración de la actividad
- NetworkOnMainThreadException con retrofit-beta2 y rxjava
- Prueba Espresso con RxLoader
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 elObservable
. Es decir, si la fuente emite 3 listas, habrá 3 listas transformadas en el otro extremo - El uso de
Observable.fromIterable()
garantizará que elObservable
interno termine para que se pueda usartoList()
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())
- Cambiar el lado que aparece el texto en un botón de opción
- Cómo afirmar dentro de un RecyclerView en Espresso?