rx-java
operatörer

Anmärkningar

Operatörer, en introduktion

En operatör kan användas för att manipulera flödet av objekt från Observable till 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);

Utgången skulle vara:

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

Den map Operatören ändrade Integer observerbar till en String observerbar, därigenom manipulera flödet av föremål.

Operatörkedja

Flera operatörer kan chained ihop för mer kraftfulla omvandlingar och manipulationer.

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

Vilket antal operatörer som helst kan läggas till mellan Observable och Subscriber .

flatMap Operator

flatMap operatören hjälper dig att omvandla en händelse till en annan Observable (eller omvandla en händelse till noll, en eller flera händelser).

Det är en perfekt operatör när du vill ringa en annan metod som returnerar en Observable

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

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

flatMap kommer att serialisera perform prenumerationer men händelser som emitteras av perform kanske inte beställs. Så du kan få händelser som avges av den sista utför samtalet innan händelser från den första perform samtal (du bör använda concatMap istället).

Om du skapar en annan Observable i din prenumerant bör du använda flatMap istället. Huvudtanken är: lämna aldrig det observerbara

Till exempel :

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

kan enkelt ersättas av:

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

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

filteroperatör

Du kan använda filter att filtrera bort objekt från värdeströmmen baserat på ett resultat av en predikatmetod.

Med andra ord kommer objekt som passerar från observatören till abonnenten kasseras baserat på den funktion du passerar filter , om funktionen returnerar false för ett visst värde kommer det värdet att filtreras bort.

Exempel:

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

Den här koden kommer att skrivas ut

0.0
4.0
16.0
36.0
64.0

kartoperatör

Du kan använda map operatören att kartlägga värdena för en ström till olika värden baserat på utfallet för varje värde från funktionen skickas till map . Utfallsströmmen är en ny kopia och kommer inte att modifiera den medföljande värdeströmmen, resultatströmmen har samma längd på ingångsströmmen men kan vara av olika typer.

Funktionen som skickas till .map() måste returnera ett värde.

Exempel:

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

Den här koden kommer att skrivas ut

"1"
"2"
"3"

I det här exemplet accepterade den observerbara en List<Integer> listan kommer att omvandlas till en List<String> i pipeline och .subscribe kommer att avge String

doOnNext-operatör

doOnNext operatör som anropas varje gång Observable avger ett objekt. Det kan användas för felsökningsändamål, tillämpa vissa åtgärder på det utsända objektet, loggning, 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();

I exemplet nedan doOnNext aldrig doOnNext eftersom källan Observable avger ingenting för att Observable.empty() anropar onCompleted efter prenumerationen.

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

upprepa operatören

repeat operatören tillåta att upprepa hela sekvensen från källan Observable .

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

Utgång från exemplet ovan

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

Denna sekvens upprepas oändligt många gånger och slutförs aldrig.

För att upprepa sekvensen begränsat antal gånger passera bara heltal som ett argument för att repeat operatören.

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

Detta exempel skrivs ut

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

Det är mycket viktigt att förstå att repeat återanmälar källan Observable när Observable sekvens är klar. Låt oss skriva om exemplet ovan med hjälp av 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")
        );

Detta exempel skrivs ut

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

När man använder operatorkedjning är det viktigt att veta att repeat operatör upprepar hela sekvensen snarare än föregående operatör.

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

Detta exempel skrivs ut

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

Detta exempel visar att repeat operatör upprepar hela sekvensen därefter förnya prenumerationen till Observable snarare än att upprepa förra map operatör och det spelar ingen roll i vilken plats i sekvensen repeat operatören används.

Denna sekvens

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

är lika med denna sekvens

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