java español rxjava2 - RxJava: Cómo convertir la Lista de objetos a la Lista de otros objetos




3 Answers

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

  • flatMapIterable (transforma tu lista en un Observable de elementos)
  • map (transforma tu artículo a otro artículo)
  • operadores toList (transforman un Observable completado en un Observable que emite una lista de elementos del Observable completado)

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

Tengo la Lista de SourceObjects y necesito convertirla a la Lista de ResultObjects.

Puedo buscar un objeto en otro usando el método de ResultObject:

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 le agradeceré mucho a alguien que pueda mostrarle cómo hacer lo mismo usando rxJava .




El método de fábrica Observable.from() permite convertir una colección de objetos en una secuencia observable. Una vez que tenga una secuencia, puede usar el operador de map para transformar cada elemento emitido. Finalmente, tendrá que suscribirse al Observable resultante para usar 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 usa lambdas se vería así:

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



Si lo que necesita es simplemente List<A> to List<B> sin manipular el resultado de List<B> .

La versión más limpia es:

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



Related