Convertire un tipo di elenco in un altro RXJava? (Equivalente mappa Javascript)

Question

Diciamo che ho un osservabile Observable<List<A>> e voglio convertirlo in un Osservabile come Observable<List<B>>. C'è un modo migliore per convertire List<A> in List<B>. L'implementazione di Javascript map sarebbe la situazione ideale.

Answer 1

È possibile utilizzare Observable.from(Iterable<A>) per ottenere Observable<A>, mappare (A => B), e convertire in List<B> con Observable.toList()

Observable.from(Arrays.asList(1, 2, 3)) 
.map(val -> mapIntToString(val)).toList() 

Ad es

Observable.from(Arrays.asList(1, 2, 3)) 
.map(val -> val + "mapped").toList() 
.toBlocking().subscribe(System.out::println); 

cede

[1mapped, 2mapped, 3mapped]

Answer 2

È anche possibile utilizzare comporre che otterrà un osservabile e restituirà un diverso.

Observable.Transformer<Integer, String> transformIntegerToString() { 
    return observable -> observable.map(String::valueOf); 
    } 


    @Test 
public void observableWithTransformToString() { 
    Observable.from(Arrays.asList(1,2,3)) 
       .map(number -> { 
        System.out.println("Item is Integer:" + Integer.class.isInstance(number)); 
        return number; 
       }) 
       .compose(transformIntegerToString()) 
       .subscribe(number -> System.out.println("Item is String:" + (String.class.isInstance(number)))); 

} 

È possibile vedere più esempi qui

https://github.com/politrons/reactive

Answer 3

ho risposto un'altra domanda simile qui: https://stackoverflow.com/a/42055221/454449

Ho copiato la risposta qui per convenienza (non so se questo va contro le regole):

Se si desidera mantenere lo Lists emesso dalla sorgente Observable ma convertire il contenuto, vale a dire Observable<List<SourceObject>> a Observable<List<ResultsObject>>, si può fare qualcosa di simile:

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

Questo assicura un paio di cose:

• viene mantenuto il numero di Lists emessa dal Observable. cioè se la sorgente emette 3 liste, ci saranno 3 elenca trasformati sull'altra estremità
• Uso Observable.fromIterable() garantirà interno Observable termina modo che toList() può essere utilizzato