2015-09-29 22 views
5

Per qualche motivo, a volte voglio utilizzare RxOperators invece del normale modo java di trasformare le strutture dati, perché è più pulito e più pulito. Per esempio:RxJava Return Valore inserito in una funzione

Observable.from(listOfStrings) 
.filter(string -> string.getNumber() >5) 
.toList() 

Esiste un modo di attesa per il risultato della osservabile e tornare in in una funzione: Questo farebbe (ma non funziona):

private String getFilteredString(String string){ 
    Observable.from(listOfStrings) 
     .filter(string -> string.getNumber() >5) 
     .toList() 
     .subscribe(finalStirng -> { 
     return finalString; 
     }) 
} 

risposta

7

Puoi trasformare qualsiasi Observable ad uno sincrono con .toBlocking():

private List<String> getFilteredString(List<String> strings) { 
    return Observable.from(strings) 
     .filter(string -> string.length() > 5) 
     .toList() 
     .toBlocking() 
     .single(); 
} 

UPDATE: Sebbene il codice sopra è perfettamente valido e funzionerà come previsto, non è così che si suppone che venga utilizzato RxJava. Se il vostro unico obiettivo è quello di trasformare una collezione, ci sono modi migliori per farlo:

+1

sì, sono d'accordo ma, nel mio caso, non sono d'accordo: p Innanzitutto perché sono su Android, quindi non ho java8. Un'altra ragione, devo comunque fare le trasformazioni nel modo normale-java, quindi per me rxOperators è più pulito. Vedi il mio punto? –

+0

@ user3806331 un'altra opzione per Android è Solid https://github.com/konmik/solid – LordRaydenMK

+1

Android non ha (ancora) Stream e Guava contiene un numero * enorme * di riferimenti al metodo (non valido per il limite di dex 65k di Android) . RxJava è popolare nelle app Android e usarlo al posto di Stream ecc. È abbastanza ragionevole. – Tom

2

C'è un metodo di istanza su rx.Observable chiamato x() (link) che può essere utilizzato per nascondere un valore osservabile ad un altro direttamente e in modo scorrevole. L'intento di questo operatore è quello di creare un repository di funzioni di conversione in grado di trasformare un Osservabile in altri tipi di strutture di dati concorrenti/asincrone (come altri tipi di osservabili) o semplicemente semplicemente scartare il contenuto dell'osservabile nei valori contenuti. Scrivi una volta la funzione di conversione e conservala per l'uso ripetuto. firma

Metodo:

public <R> R x(Func1<? super OnSubscribe<T>, ? extends R> conversion); 

utilizzati per convertire una potenzialmente asincrono osservabile ad una lista concorrente:

List<Integer> list = Observable.range(1, 10).x(new Func1<OnSubscribe<Integer>, List<Integer>>() { 
    @Override 
    public List<Integer> call(OnSubscribe<Integer> onSubscribe) { 
     List<Integer> allElements = new ArrayList<Integer>(); 
     CountDownLatch latch = new CountDownLatch(1); 
     AtomicReference<Throwable> failure = new AtomicReference<Throwable>(); 
     onSubscribe.call(new Subscriber<Integer>(){ 
      @Override 
      public void onCompleted() { 
       latch.countDown(); 
      } 

      @Override 
      public void onError(Throwable e) { 
       failure.set(e); 
      } 

      @Override 
      public void onNext(Integer t) { 
       allElements.add(t); 
      }}); 
     while (true) { 
      try { 
       latch.await(); 
       break; 
      } catch (InterruptedException e1) { 
       // continue waiting 
      } 
     } 
     Throwable e = failure.get(); 
     if (e != null) 
      throw new RuntimeException(e); 
     return allElements; 

    }}); 
System.out.println(list); 

uscita

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10] 

prega di notare che questo operatore è attualmente @Experimental e è molto probabile che venga rinominato (per "estendere"), tuttavia e La funzionalità xperimentale in RxJava può essere changed in any release.

Problemi correlati