rx-java
Les opérateurs

Remarques

Opérateurs, une introduction

Un opérateur peut être utilisé pour manipuler le flux d'objets de Observable à 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);

La sortie serait:

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

L'opérateur de map changé le Integer observable en une String observable, manipulant ainsi le flux d'objets.

Chaînage de l'opérateur

Plusieurs opérateurs peuvent être chained pour des transformations et des manipulations plus puissantes.

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

Un nombre quelconque d'opérateurs peut être ajouté entre l' Observable et l' Subscriber .

FlatMap Operator

L'opérateur flatMap vous aide à transformer un événement en un autre Observable (ou à transformer un événement en zéro, un ou plusieurs événements).

C'est un opérateur parfait quand vous voulez appeler une autre méthode qui retourne une Observable

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

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

flatMap sérialise perform des abonnements , mais les événements emited par perform ne peuvent pas être commandés. Ainsi , vous pouvez recevoir des événements émis par le dernier appel avant effectuer les événements de la première perform l' appel (vous devez utiliser concatMap à la place).

Si vous créez une autre Observable dans votre abonné, vous devriez plutôt utiliser flatMap . L'idée principale est la suivante: ne jamais laisser l'observable

Par exemple :

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

peut facilement être remplacé par:

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

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

opérateur de filtre

Vous pouvez utiliser le filter opérateur pour filtrer les éléments du flux de valeurs en fonction du résultat d'une méthode sous - jacente.

En d'autres termes, les éléments passant de l'observateur à l'abonné seront supprimés en fonction du filter fonction que vous transmettez, si la fonction renvoie false pour une certaine valeur, cette valeur sera filtrée.

Exemple:

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

Ce code sera imprimé

0.0
4.0
16.0
36.0
64.0

Opérateur de carte

Vous pouvez utiliser la map opérateur pour cartographier les valeurs d'un flux de valeurs différentes en fonction du résultat pour chaque valeur de la fonction passée à la map . Le flux de résultats est une nouvelle copie et ne modifiera pas le flux de valeurs fourni, le flux de résultats aura la même longueur que le flux d'entrée, mais pourra être de différents types.

La fonction transmise à .map() doit renvoyer une valeur.

Exemple:

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

Ce code sera imprimé

"1"
"2"
"3"

Dans cet exemple, l'observable a accepté une List<Integer> la liste sera transformée en une List<String> dans le pipeline et le .subscribe émettra des String .

Opérateur doOnNext

Opérateur doOnNext appelé à chaque fois que la source Observable émet un élément. Il peut être utilisé à des fins de débogage, en appliquant une action à l'élément émis, la journalisation, 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();

Dans l'exemple ci-dessous, doOnNext n'est jamais appelé, car la source Observable n'émet rien car Observable.empty() appelle onCompleted après s'être abonné.

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

opérateur de répétition

repeat opérateur de repeat permet de répéter toute la séquence de la source Observable .

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

Sortie de l'exemple ci-dessus

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

Cette séquence répète un nombre infini de fois et ne se termine jamais.

Pour répéter la séquence nombre fini de fois, il suffit de passer un entier comme argument à l'opérateur de 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")
    );

Cet exemple imprime

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

Il est très important de comprendre que l'opérateur de repeat réabonne à la source Observable lorsque la séquence source Observable terminée. Réécrivons l'exemple ci-dessus en utilisant 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")
        );

Cet exemple imprime

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

Lors de l'utilisation du chaînage d'opérateur, il est important de savoir que l'opérateur repeat répète toute la séquence plutôt que l'opérateur précédent.

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

Cet exemple imprime

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

Cet exemple montre que la repeat opérateur répète la séquence entière réabonnant à Observable plutôt que de répéter la dernière map opérateur et il n'a pas d' importance à quel endroit dans la séquence repeat opérateur utilisé.

Cette séquence

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

est égal à cette séquence

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