rx-java
operators

Opmerkingen

Operators, een inleiding

Een operator kan worden gebruikt om de stroom van objecten van Observable naar Subscriber te manipuleren.

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

De output zou zijn:

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

De map operator veranderde de Integer waarneembaar een String waarneembaar, waardoor de stroom voorwerpen manipuleren.

Operator Chaining

Meerdere operators kunnen chained elkaar worden chained voor krachtigere transformaties en manipulaties.

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

Een willekeurig aantal operatoren kan worden toegevoegd tussen de Observable en de Subscriber .

flatMap-operator

De operator flatMap helpt u bij het transformeren van een gebeurtenis naar een andere Observable (of een gebeurtenis om te zetten in nul, één of meer gebeurtenissen).

Het is een perfecte operator als je een andere methode wilt aanroepen die een Observable retourneert

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

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

flatMap zal flatMap abonnementen perform maar evenementen die worden uitgezonden door perform kunnen niet worden besteld. U kunt dus gebeurtenissen ontvangen die zijn uitgezonden door de laatste uitvoerende oproep vóór gebeurtenissen van de eerste perform oproep (in plaats daarvan moet u concatMap gebruiken).

Als je het creëren van een andere Observable in uw abonnees, moet u gebruik maken flatMap plaats. Het hoofdidee is: verlaat de Observable nooit

Bijvoorbeeld :

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

kan eenvoudig worden vervangen door:

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

Reactivex.io-documentatie: http://reactivex.io/documentation/operators/flatmap.html

filter operator

U kunt de filter gebruiken om items uit de waardenstroom te filteren op basis van een resultaat van een predikaatmethode.

Met andere woorden, de items passeren van de waarnemer bij de Abonnee worden weggegooid op basis van de functie die u passeert filter , wanneer de functie terugkeert false voor een bepaalde waarde, zal die waarde worden uitgefilterd.

Voorbeeld:

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

Deze code wordt afgedrukt

0.0
4.0
16.0
36.0
64.0

kaart Operator

U kunt de map gebruiken om de waarden van een stream toe te wijzen aan verschillende waarden op basis van de uitkomst voor elke waarde van de functie die is doorgegeven aan de map . De uitkomststroom is een nieuwe kopie en wijzigt de opgegeven waardenstroom niet. De resultaatstroom heeft dezelfde lengte als de invoerstroom maar kan van verschillende typen zijn.

De functie die wordt doorgegeven aan .map() , moet een waarde retourneren.

Voorbeeld:

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

Deze code wordt afgedrukt

"1"
"2"
"3"

In dit voorbeeld heeft de Observable een List<Integer> geaccepteerd, de lijst zal worden omgezet in een List<String> in de pijplijn en het .subscribe zal String 's uitzenden

doOnNext-operator

doOnNext operator wordt elke keer opgeroepen wanneer de bron Observable een item uitzendt. Het kan worden gebruikt voor het opsporen van fouten, het toepassen van enige actie op het uitgezonden item, logboekregistratie, enz ...

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

In het onderstaande doOnNext wordt doOnNext nooit aangeroepen omdat de bron Observable niets uitzendt omdat Observable.empty() onCompleted aanroept na aanmelding.

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

herhaal operator

repeat toestaan om hele reeks van bron Observable te herhalen.

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

Uitvoer van het bovenstaande voorbeeld

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

Deze reeks wordt oneindig vaak herhaald en wordt nooit voltooid.

Om het eindige aantal keren van de reeks te herhalen, geeft u gewoon het gehele getal door als een argument om de operator te repeat .

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

Dit voorbeeld wordt afgedrukt

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

Het is heel belangrijk om te begrijpen dat de repeat abonneert op de bron Observable wanneer de Observable reeks is voltooid. Laten we het bovenstaande voorbeeld herschrijven met 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")
        );

Dit voorbeeld wordt afgedrukt

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

Bij het gebruik van operator chaining is het belangrijk om te weten dat repeat hele reeks herhaalt in plaats van voorafgaande operator.

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

Dit voorbeeld wordt afgedrukt

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

Dit voorbeeld toont dat repeat operator herhaalt hele reeks opnieuw te abonneren op Observable plaats herhalen vorige map operator en het maakt niet uit waarin plaats in de reeks repeat operator gebruikt.

Deze reeks

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

is gelijk aan deze reeks

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