rx-java
operatori

Osservazioni

Operatori, un'introduzione

Un operatore può essere utilizzato per manipolare il flusso di oggetti da Observable a Subscriber .

Observable<Integer> integerObservable = Observable.just(1, 2, 3); // creating a simple Integer observable
Subscriber<String> mSubscriber = new Subscriber<String>() {
    @Override
    public void onCompleted() {
        System.out.println("onCompleted called!");
    }

    @Override
    public void onError(Throwable throwable) {
        System.out.println("onError called");
    }

    @Override
    public void onNext(String string) {
        System.out.println("onNext called with: " + string);
    }
}; // a simple String subscriber

integerObservable
    .map(new Func1<Integer, String>() {
        @Override
        public String call(Integer integer) {
            switch (integer) {
                case 1:
                    return "one";
                case 2:
                    return "two";
                case 3:
                    return "three";
                default:
                    return "zero";
            }
        }
}).subscribe(mSubscriber);

L'output sarebbe:

onNext called with: one
onNext called with: two
onNext called with: three
onCompleted called!

L'operatore della map cambiato il numero Integer osservabile in una String osservabile, manipolando il flusso degli oggetti.

Concatenamento dell'operatore

Più operatori possono essere chained insieme per trasformazioni e manipolazioni più potenti.

integerObservable // emits 1, 2, 3
            .map(i -> i + 10) // adds 10 to each item; emits 11, 12, 13
            .filter(i -> i > 11) // emits items that satisfy condition; 12, 13
            .last() // emits last item in observable; 13
            // unlimited operators can be added ...
            .subscribe(System.out::println); // prints 13

È possibile aggiungere un numero qualsiasi di operatori tra Observable e Subscriber .

operatore flatMap

L'operatore flatMap ti aiuta a trasformare un evento in un altro Observable (o trasformare un evento in zero, uno o più eventi).

È un operatore perfetto quando vuoi chiamare un altro metodo che restituisce un Observable

 public Observable<String> perform(int i) {
      // ...
 }

 Observable.just(1, 2, 3)
           .flatMap(i -> perform(i))
           .subscribe(result -> System.out.println("result ->" + result);

flatMap serializzare perform abbonamenti, ma gli eventi emited da perform non può essere ordinato. Pertanto, è possibile ricevere eventi emessi dall'ultima chiamata di esecuzione prima degli eventi dalla prima chiamata di perform (è necessario utilizzare invece concatMap ).

Se crei un altro Observable nel tuo abbonato, dovresti usare flatMap . L'idea principale è: non lasciare mai l'osservabile

Per esempio :

 Observable.just(1, 2, 3)
           .subscribe(i -> perform(i));

può essere facilmente sostituito da:

 Observable.just(1, 2, 3)
           .flatMap(i -> perform(i))
           .subscribe();

Documentazione Reactivex.io: http://reactivex.io/documentation/operators/flatmap.html

filtro Operatore

È possibile utilizzare l'operatore filter per filtrare gli elementi dal flusso dei valori in base a un risultato di un metodo di predicati.

In altre parole, gli elementi che passano dall'Observer al Sottoscrittore verranno scartati in base al filter Function pass, se la funzione restituisce false per un determinato valore, tale valore verrà filtrato.

Esempio:

List<Integer> integers = Arrays.asList(0, 1, 2, 3, 4, 5, 6, 7, 8, 9);

Observable.from(integers)
    .filter(number -> {
        return (number  % 2 == 0); 
        // odd numbers will return false, that will cause them to be filtered 
    })
    .map(i -> {
        return Math.pow(i, 2); // take each number and multiply by power of 2
    }) 
    .subscribe(onNext -> {
         System.out.println(onNext); // print out the remaining numbers
    });

Questo codice verrà stampato

0.0
4.0
16.0
36.0
64.0

mappa Operatore

È possibile utilizzare la map all'operatore di mappare i valori di un flusso di valori diversi sulla base del risultato per ogni valore dalla funzione passata a map . Il flusso di risultati è una nuova copia e non modificherà il flusso di valori fornito, il flusso di risultati avrà la stessa lunghezza del flusso di input ma potrebbe essere di tipi diversi.

La funzione passata a .map() , deve restituire un valore.

Esempio:

List<Integer> numbers = Arrays.asList(1, 2, 3);
Observable.from(numbers)
    .map(number -> {
        return number.toString(); // convert each integer into a string and return it
    }) 
    .subscribe(onNext -> {
         System.out.println(onNext); // print out the strings
    });

Questo codice verrà stampato

"1"
"2"
"3"

In questo esempio Observable accetta un List<Integer> l'elenco verrà trasformato in un List<String> nella pipeline e il .subscribe emetterà String 's

Operatore doOnNext

doOnNext operatore doOnNext chiamato ogni volta quando Source Observable emette un elemento. Può essere utilizzato per scopi di debug, applicando alcune azioni all'elemento emesso, alla registrazione, ecc ...

Observable.range(1, 3)
    .doOnNext(value -> System.out.println("before transform: " + value))
    .map(value -> value * 2)
    .doOnNext(value -> System.out.println("after transform: " + value))
    .subscribe();

Nell'esempio seguente doOnNext non viene mai chiamato perché l' Observable origine non emette nulla perché Observable.empty() chiama onCompleted dopo la sottoscrizione.

Observable.empty()
    .doOnNext(item -> System.out.println("item: " + item))
    .subscribe();

ripetere operatore

repeat operatore di repeat consente di ripetere l'intera sequenza dalla sorgente Observable .

Observable.just(1, 2, 3)
    .repeat()
    .subscribe(
        next -> System.out.println("next: " + next),
        error -> System.out.println("error: " + error),
        () -> System.out.println("complete")
    );

Uscita dell'esempio sopra

next: 1
next: 2
next: 3
next: 1
next: 2
next: 3

Questa sequenza ripete un numero infinito di volte e non completa mai.

Per ripetere il numero finito di volte in sequenza basta passare il numero intero come argomento per repeat operatore.

Observable.just(1, 2, 3)
    // Repeat three times and complete
    .repeat(3)
    .subscribe(
        next -> System.out.println("next: " + next),
        error -> System.out.println("error: " + error),
        () -> System.out.println("complete")
    );

Questo esempio stampa

next: 1
next: 2
next: 3
next: 1
next: 2
next: 3
next: 1
next: 2
next: 3
complete

È molto importante capire che l'operatore di repeat iscrive nuovamente alla fonte Observable quando la sequenza Observable fonte completa. Riscriveremo l'esempio sopra usando Observable.create .

Observable.<Integer>create(subscriber -> {

    //Same as Observable.just(1, 2, 3) but with output message
    System.out.println("Subscribed");
    subscriber.onNext(1);
    subscriber.onNext(2);
    subscriber.onNext(3);
    subscriber.onCompleted();
})
        .repeat(3)
        .subscribe(
                next -> System.out.println("next: " + next),
                error -> System.out.println("error: " + error),
                () -> System.out.println("complete")
        );

Questo esempio stampa

Subscribed
next: 1
next: 2
next: 3
Subscribed
next: 1
next: 2
next: 3
Subscribed
next: 1
next: 2
next: 3
complete

Quando si utilizza operatore concatenamento è importante sapere che repeat operatore ripete intera sequenza piuttosto che precede operatore.

Observable.<Integer>create(subscriber -> {
    System.out.println("Subscribed");
    subscriber.onNext(1);
    subscriber.onNext(2);
    subscriber.onNext(3);
    subscriber.onCompleted();
})
        .map(value -> value * 2) //First chain operator
        .map(value -> "modified " + value) //Second chain operator
        .repeat(3)
        .subscribe(
                next -> System.out.println("next: " + next),
                error -> System.out.println("error: " + error),
                () -> System.out.println("complete")
        );

Questo esempio stampa

Subscribed
next: modified 2
next: modified 4
next: modified 6
Subscribed
next: modified 2
next: modified 4
next: modified 6
Subscribed
next: modified 2
next: modified 4
next: modified 6
complete

Questo esempio mostra che repeat operatore ripete intera sequenza reiscriversi alle Observable invece di ripetere ultima map operatore e non importa in quale posizione nella sequenza repeat operatore usato.

Questa sequenza

Observable.<Integer>create(subscriber -> {
        //...
    })
    .map(value -> value * 2) //First chain operator
    .map(value -> "modified " + value) //Second chain operator
    .repeat(3)
    .subscribe(
        /*....*/
    );

è uguale a questa sequenza

Observable.<Integer>create(subscriber -> {
        //...
    })
    .repeat(3)
    .map(value -> value * 2) //First chain operator
    .map(value -> "modified " + value) //Second chain operator
    .subscribe(
        /*....*/
    );