rx-java
Operatoren

Bemerkungen

Betreiber, eine Einführung

Ein Operator kann verwendet werden, um den Fluss von Objekten von Observable zu Subscriber zu manipulieren.

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

Die Ausgabe wäre:

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

Der map geändert , um die Integer beobachtbaren an einen String beobachtbar, wodurch der Fluss von Objekten zu manipulieren.

Operator-Verkettung

Mehrere Operatoren können miteinander chained werden, um leistungsfähigere Transformationen und Manipulationen durchzuführen.

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

Zwischen Observable und Subscriber kann eine beliebige Anzahl von Operatoren hinzugefügt werden.

flatMap Operator

Der flatMap Operator hilft Ihnen, ein Ereignis in ein anderes Observable (oder ein Ereignis in null, ein oder mehrere Ereignisse) umzuwandeln.

Es ist ein perfekter Operator, wenn Sie eine andere Methode aufrufen möchten, die ein Observable

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

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

flatMap serialisiert perform Abonnements, aber Ereignisse, die von perform ausgegeben werden perform können möglicherweise nicht bestellt werden. Möglicherweise empfangen Sie Ereignisse, die vom letzten Perform-Aufruf concatMap , vor Ereignissen vom ersten perform Aufruf (Sie sollten stattdessen concatMap verwenden).

Wenn Sie ein anderes Observable in Ihrem Abonnenten erstellen, sollten flatMap stattdessen flatMap verwenden. Die Hauptidee lautet: Verlassen Sie niemals das Observable

Zum Beispiel :

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

kann leicht ersetzt werden durch:

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

Dokumentation zu Reactivex.io: http://reactivex.io/documentation/operators/flatmap.html

Filter Operator

Sie können den filter , um Elemente aus dem Wertestrom basierend auf einem Ergebnis einer Prädikatmethode herauszufiltern.

Mit anderen Worten, die Elemente, die vom Observer an den Abonnenten übergeben werden, werden auf der Grundlage des filter , den Sie übergeben, verworfen. Wenn die Funktion für einen bestimmten Wert false zurückgibt, wird dieser Wert herausgefiltert.

Beispiel:

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

Dieser Code wird ausgedruckt

0.0
4.0
16.0
36.0
64.0

Kartenoperator

Sie können den map , um die Werte eines Streams basierend auf dem Ergebnis für jeden Wert aus der an map Funktion verschiedenen Werten map . Der Ergebnisstrom ist eine neue Kopie und ändert den bereitgestellten Wertestrom nicht. Der Ergebnisstrom hat dieselbe Länge wie der Eingabestrom, kann jedoch unterschiedliche Typen aufweisen.

Die an .map() Funktion muss einen Wert zurückgeben.

Beispiel:

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

Dieser Code wird ausgedruckt

"1"
"2"
"3"

Die beobachtbare eine akzeptierte In diesem Beispiel List<Integer> die Liste wird in einen umgewandelt werden List<String> in der Pipeline und die .subscribe emittieren String ‚s

doOnNext-Operator

doOnNext Operator genannt , jedes Mal , wenn die Quelle Observable ein Element emittiert. Es kann für Debug-Zwecke verwendet werden, eine Aktion für das emittierte Element Anwendung, Protokollierung, etc ...

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

Im Beispiel unten doOnNext heißt nie , weil die Quelle Observable nichts abgibt , weil Observable.empty() ruft onCompleted nach der Anmeldung.

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

Operator wiederholen

repeat ermöglicht die Wiederholung der gesamten Sequenz aus der Quelle Observable .

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

Ausgabe des obigen Beispiels

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

Diese Sequenz wiederholt sich unendlich oft und wird nie abgeschlossen.

Um eine endliche Anzahl von Wiederholungen zu wiederholen, übergeben Sie einfach eine Ganzzahl als Argument für den 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")
    );

Dieses Beispiel wird gedruckt

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

Es ist sehr wichtig zu verstehen, dass der repeat die Quelle Observable abonniert, wenn die Quelle Observable Source abgeschlossen ist. Lassen Sie uns das obige Beispiel mit Observable.create neu schreiben.

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

Dieses Beispiel wird gedruckt

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

Bei der Verwendung der Operator-Verkettung ist es wichtig zu wissen, dass der repeat gesamte Sequenz und nicht den vorhergehenden Operator wiederholt.

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

Dieses Beispiel wird gedruckt

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

Dieses Beispiel zeigt , dass repeat Operator wiederholt ganze Sequenz resubscribing Observable und nicht zuletzt Wiederholung map Operator und es spielt keine Rolle , an welcher Stelle in der Sequenz repeat Operator verwendet.

Diese Reihenfolge

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

ist gleich dieser Reihenfolge

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