Réintroduction aux opérateurs avec RxJava Partie 1

Cet article est le 10ème article du Calendrier de l'Avent RxJava 2016.

Je me suis précipité dans le calendrier de l'Avent RxJava avec élan, mais je me demandais quoi écrire, Au fait, j'ai pensé que j'étais un peu confus et j'ai décidé d'étudier à nouveau les opérateurs.

Il y en a beaucoup, j'ai donc décidé de les diviser, donc je prévois de les diviser en 5 fois au total.

Maintenant, pour la première fois, nous allons examiner deux choses, Créer des observables et Transformer des observables, qui sont décrites dans Introduction à ReactiveX.

Creating Principalement les opérateurs qui créent de nouveaux ʻObservables`

Create Un opérateur qui rend «Observable» en grattant. Sur Android, c'est celui que vous voyez souvent dans les communications asynchrones.

L'utilisation est la suivante.

public class Create {
    public static void main(String[] args) {
        Observable.create(e -> {
            Person person = new Person();
            person.age = 100;
            person.name = "nshiba";
            e.onNext(person);
            e.onComplete();
        }).subscribe(System.out::println);
    }

    private static class Person {
        int age;
        String name;

        @Override
        public String toString() {
            return name + ":" + String.valueOf(age);
        }
    }
}

production

nshiba:100

C'est comme passer une valeur avec ʻonNext et appeler ʻonComplete à la fin.

Aussi, en cas d'erreur, appelez ʻonError`.

Defer defer est l'opérateur créé lorsque vous vous abonnez pour exécuter ʻObservable`.

Un create normal crée un ʻObservable à exécuter à la volée, mais différer retarde la création de ʻObservable lui-même.

Observable observable = Observable.defer(() -> observer -> {
    observer.onNext("test");
    observer.onComplete();
});

//À ce moment, vous pouvez créer un nouvel observable en différé
observable.subscribe(System.out::println);

Empty/Never/Throw Je pense que ces opérateurs seront principalement utilisés pour des tests dans des applications limitées.

Empty Créez un «Observable» qui n'a pas de valeur mais se termine normalement. Autrement dit, seul ʻonComplete` est appelé.

Never Créez un «Observable» qui n'a aucune valeur et ne se termine jamais.

Throw Crée un ʻObservable` qui n'a pas de valeur mais se termine avec l'erreur spécifiée.

From Convertit divers objets en observable. Je pense que je convertis souvent des listes, donc j'ai fait un échantillon avec fromArray.

int[] nums = new int[] {1, 2, 3, 4, 5};
Observable
        .fromArray(nums)
        .subscribe(ints -> {
            System.out.println("onNext");
            System.out.println(Arrays.toString(ints));
        },
        throwable -> {
            System.out.println("onError");
        },
        () -> {
            System.out.println("onComplete");
        });

production

onNext
[1, 2, 3, 4, 5]
onComplete

Interval Génère ʻObservable` qui produit des valeurs entières à intervalles réguliers spécifiés. Vous pouvez également spécifier le délai à retarder en premier.

Observable
        .interval(1, TimeUnit.SECONDS)
        .subscribe(System.out::print);

production

01234567789...

Just Génère ʻObservable avec l'objet passé directement à l'argument. De plus, si vous passez plus d'un, ʻonNext sera appelé en conséquence, et si vous passez plus d'un, aucune erreur ne se produira même si les types ne sont pas unifiés.

Observable.just(3, 1, 5, 4, "test")
        .subscribe(num -> {
            System.out.println("onNext: " + num);
        }, throwable -> {
            System.out.println("onError");
        }, () -> {
            System.out.println("onComplete");
        });

production

onNext: 3
onNext: 1
onNext: 5
onNext: 4
onNext: test
onComplete

Range Génère ʻObservable` qui produit des entiers dans la plage spécifiée.

Observable.range(0, 10)
        .subscribe(i -> {
            System.out.println("onNext: " + i);
        }, throwable -> {
            System.out.println("onError");
        }, () -> {
            System.out.println("onComplete");
        });

production

onNext: 0
onNext: 1
onNext: 2
onNext: 3
onNext: 4
onNext: 5
onNext: 6
onNext: 7
onNext: 8
onNext: 9
onComplete

Repeat Génère ʻObservable` qui se répète le nombre de fois spécifié.

Observable.just(1, 2, 3, 4, 5)
        .repeat(3)
        .subscribe(i -> {
            System.out.println("onNext: " + i);
        }, throwable -> {
            System.out.println("onError");
        }, () -> {
            System.out.println("onComplete");
        });

production

onNext: 1
onNext: 2
onNext: 3
onNext: 1
onNext: 2
onNext: 3
onNext: 1
onNext: 2
onNext: 3
onComplete

Start Créez ʻObservablepour afficher la valeur de retour de la méthode qui peut renvoyer la valeur calculée. Il y a quelque chose de similaire àCreate, mais celui-ci a une valeur de retour arbitraire et n'appelle pas ʻonNext, ʻonComplete`.

Observable.fromCallable(() -> {
    String str = "java";
    str += ":" + "RxJava";
    return str;
}).subscribe(System.out::println);

production

java:RxJava

Timer Crée ʻObservable` qui renvoie la valeur après un délai du temps spécifié.

System.out.println(System.currentTimeMillis());
Observable.timer(3, TimeUnit.SECONDS)
        .subscribe(aLong -> {
            System.out.println(System.currentTimeMillis());
        });

production

1480975677330
1480975680651

Transforming Buffer Un opérateur qui crée une liste en fractionnant un flux à des intervalles spécifiés.

Observable.range(1, 5)
        .buffer(3)
        .subscribe(System.out::println);

production

[1, 2, 3]
[4, 5]

FlatMap Un opérateur qui traite ce qui entre dans le flux et le synthétise ensuite dans un nouvel «Observable».

Observable.just(1, 2, 3)
        .flatMap(i -> Observable.range(i, i * 2))
        .subscribe(System.out::print);

production

122345345678

GroupBy Un opérateur qui divise les flux en groupes selon les conditions. Si vous renvoyez la même valeur pour ce que vous voulez faire partie du même groupe, ce sera dans le même groupe.

Observable.range(1, 10)
        .groupBy(integer -> integer % 3)
        .subscribe(integerIntegerGroupedObservable -> {
            integerIntegerGroupedObservable.toList().subscribe(System.out::println);
        });

production

[3, 6, 9]
[1, 4, 7, 10]
[2, 5, 8]

Map Un opérateur qui peut modifier la valeur qui s'écoule dans le flux. La différence avec FlatMap ci-dessus est que FlatMap renvoie ʻObservable et Map` renvoie la valeur elle-même.

Observable.just(1,2,3)
        .map(i -> i * 10)
        .subscribe(System.out::println);

production

10
20
30

Scan Opérateur qui accède à la liste de manière séquentielle. Accès deux par deux. Au début, les première et deuxième valeurs sont transmises aux arguments, puis la valeur transmise à la valeur de retour dans le processus précédent est transmise au premier argument, et la valeur suivante est transmise au deuxième argument. La valeur passée au moment de subscribe est la valeur passée au premier élément + valeur de retour.

Observable.range(1, 5)
        .scan((sum, item) -> sum + item)
        .subscribe(System.out::println);

production

1
3
6
10
15

Window Un opérateur qui divise un flux à des intervalles spécifiés et crée un nouvel «Observable» avec le flux fractionné. Similaire à Buffer ci-dessus, mais Buffer produitList <Integer>, tandis que Window produit ʻObservable `.

Observable.range(1,5)
        .window(3)
        .subscribe(integerObservable -> {
            integerObservable.toList().subscribe(System.out::println);
        });

production

[1, 2, 3]
[4, 5]

finalement

J'espère pouvoir faire d'autres choses comme ça. Le code source est ouvert au public-> nshiba / rx-samples

De plus, si vous avez des erreurs, je vous serais reconnaissant de bien vouloir les écrire dans les commentaires ou les problèmes sur github.