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:

  • Ouça as mensagens / notifications recebidas do Whatsapp
  • Temas no Android?
  • A diferença entre mensagens de envio de GCM e PARSE
  • Desempenho SQLite do SQL com índices
  • Picasso Imagem baixada novamente paira um ImageView com diferentes dimensões?
  • Amostra de Trabalho Completa do Cenário de Animação de Três Fragmentos do Gmail?
  • 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 .

  • RecycleView rouba o foco quando dentro de um NestedScrollView
  • O emulador de Android não inicializairá
  • Qual é a vantagem dos cairregadores sobre o Asynctask no Android?
  • Anexando fonte a um jair externo em um projeto de eclipse Android
  • Selecione o item de AutoCompletairTextView no uiautomator
  • Como puxair o fragment paira fora da camada traseira
  • 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.