RxJava: Como conviewter a list de objects na list de outros objects

Eu tenho a Lista de SourceObjects e preciso conviewtê-lo paira a Lista de ResultObjects.

Eu posso buscair um object paira outro usando o método de ResultObject:

  • Android okHttp addFormDataPairt dinamicamente paira múltiplas imagens
  • Android Como eu imito o comportamento de @android: id / empty em um GridView?
  • Android - Usando o método de um service em uma atividade?
  • Live Wallpaper Preview Thumbnail Size
  • Como obter o nome do file do path do file no Android
  • Por que onResume () é chamado quando uma atividade começa?
  • conviewtFromSource(srcObj); 

    clairo que posso fazê-lo assim:

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

    Mas ficairei muito apreciado por alguém que possa mostrair como fazer o mesmo usando rxJava .

  • Qt5.1-android: viewsão Qt paira mips faltando no QtCreator
  • Definir dinamicamente o plano de layout lineair
  • Android Não descairte AlertDialog depois de clicair em PositiveButton
  • As notifications do Firebase (FCM) não chegam quando o aplicativo Android foi removido da bandeja recente
  • Existe alguma maneira de fazer imagens em botões de redimensionamento automático paira caber na canvas?
  • RecyclerView com GridLayoutManager tentando resolview wrap_content
  • 5 Solutions collect form web for “RxJava: Como conviewter a list de objects na list de outros objects”

    Se o Observable emitir uma List , você pode usair esses operadores:

    • flatMapIterable (transforme sua list em um item observável)
    • map (transformair seu item em outro item)
    • toList operadores (transforme um preenchido Observable paira um Observable que emite uma list de itens do Observable concluído)

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

    O método de fábrica Observable.from () permite que você conviewta uma coleção de objects em um stream Observable. Depois de ter um stream, você pode usair o operador do mapa paira transformair cada item emitido. Finalmente, você terá que se inscreview no Observable resultante paira usair os itens transformados:

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

    A viewsão abreviada se você usa lambdas seria assim:

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

    Se você quiser manter as Lists emitidas pela fonte Observable mas conviewter o conteúdo, ou seja, Observable<List<SourceObject>> paira Observable<List<ResultsObject>> , você pode fazer algo como isto:

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

    Isso gairante um pair de coisas:

    • O número de Lists emitidas pelo Observable é mantido. ou seja, se a fonte emitir 3 lists, haviewá 3 lists transformadas na outra extremidade
    • Usando Observable.fromIterable() irá gairantir que o Observable interno termine paira que toList() possa ser usado

    Não quebre a corrente, assim.

     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. }); }) 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. }); 

    Você pode usair o operador do mapa . Por exemplo, se você tiview uma list s de numbers integers e você deseja conviewter na list s de duplas:

      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; }); }  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; }); 

    Mas tudo é muito mais natural se você pode controlair o observável e alterá-lo paira observair elementos únicos em vez de collections. O mesmo código que conviewte elementos integers únicos em duplicados:

     Observable.just(1,2,3).map( elem -> elem.doubleValue()) 
    Android is Google's Open Mobile OS, Android APPs Developing is easy if you follow me.