Une introduction détaillée au code de RxJava_05 [Opérations de conversion et opérations mathématiques]

Ce tutoriel est basé sur le RxJava1 >Entre l'observateur et l'observé, certaines données transmises doivent être converties avant de pouvoir être utilisées. Par exemple : parfois on obtient une liste de. élèves d'une certaine classe de l'école, mais nous avons besoin de connaître le classement de leurs résultats en chinois. Cela nécessite de convertir ArrayList en file d'attente ArrayList. Ce qui suit fournit une série d'opérateurs de commutation de données :

Buffer - convertit plusieurs données envoyées en données envoyées à n files d'attente, chaque file d'attente La longueur maximale est la taille du paramètre spécifié par la fonction buffer().

Fenêtre - divise périodiquement les données de l'Observable d'origine dans une fenêtre Observable
2. Carte - divise les données envoyées par un. certain Convertir en une autre donnée

3. flatMap - convertit en fait un type de données envoyé en un objet d'un autre type de données

4. GroupBy - Stocke le même type de données envoyées dans n sous-Observables selon la clé spécifiée.

Scan - Exécutez une certaine fonction sur toutes les données envoyées, calculez le nième et le nième 1 élément, puis exécutez les résultats calculés avec les n 2 éléments, et ainsi de suite.
1.Buffer

6. Par exemple, dans les données suivantes, trois chaînes sont envoyées respectivement

Si on ajoute après le tampon de l'observateur opérateur, et spécifiez le cache 2 éléments, le code est le suivant :

Ensuite, il enverra 2 données de liste pour la première fois, respectivement :

Observable.just("Hello Android !", "Hello Java", "Hello C");

L'exemple complet ci-dessous Le code est le suivant :

final Observable observable = Observable.just("Hello Android !", "Hello Java", "Hello C");
Observable> bufferObservable = observable.buffer(2);

Output

List<String>(){"Hello Android !", "Hello Java"}
List<String>(){"Hello C"}

buffer() convertit en fait n éléments de données envoyés en x files d'attente pour l'envoi

//这里模拟正常发送三个单一值的被观察者
final Observable observable = Observable.just("Hello Android !", "Hello Java", "Hello C");
//定义一个缓存的被观察者 每次缓存2个 缓存的数据自上面observable对象获取
Observable> bufferObservable = observable.buffer(2);
//订阅对象并获取缓存被观察者发送出来的数据
bufferObservable.subscribe(new Action1>() {
    @Override
    public void call(List strings) {
        Log.i(TAG, "call:--------");
        for (int i = 0; i < strings.size(); i++) {
            Log.i(TAG, "call: "+strings.get(i));
        }
    }
});

2.Window

call:--------
call: Hello Android !
call: Hello Java
call:--------
call: Hello C

décompose périodiquement les données de l'Observable d'origine en une fenêtre Observable et émet ces fenêtres au lieu d'émettre une donnée à chaque fois Window est similaire à Buffer, mais n'émet pas Un paquet de données de l'Observable d'origine, qui émet des Observables. Chacun de ces Observables émet un sous-ensemble des données de l'Observable d'origine et émet finalement une notification onCompleted.

Sortie :

3.Map

Observable.just(1, 2, 3, 4, 5)
//将一个Observable发射出去的数据分解为多个Observable对象 每个Observable发射2个数据
            .window(2)
            .subscribe(new Action1<Observable<Integer>>() {
                @Override
                public void call(Observable<Integer> innerObservable) {
                    Log.i(TAG, "call: ---------");
                    innerObservable.subscribe(new Action1<Integer>() {
                        @Override
                        public void call(Integer value) {
                            Log.i(TAG, "call: "+value);
                        }
                    });
                }
            });

Enregistrement d'un nouvel étudiant. Lors de la saisie des données, il a été découvert que le nom de Zhang San avait été mal saisi et devait être remplacé par Zhang Sanfeng. Nous devons maintenant saisir à nouveau les informations pour lui. Le code est le suivant :

 call: ---------
 call: 1
 call: 2
 call: ---------
 call: 3
 call: 4
 call: ---------
 call: 5

RxJava le convertit comme ceci :

map() convertit en fait certaines données envoyées en une autre donnée

private ArrayList initPersons() {
    ArrayList<Student> persons = new ArrayList<>();
    persons.add(new Student("张三", 16));
    persons.add(new Student("李四", 17));
    persons.add(new Student("王二麻子", 18));
    return persons;
}

ArrayList<Student> students = initPersons();
for (int i = 0; i < students.size(); i++) {
    Student student = students.get(i);
    if (student.name.equals("张三")){
        student.name="张三丰";
    }
}

4.FlatMap

Observable.from(initPersons())
            //将张三的名字改为张三丰
            .map(new Func1<Student, Student>() {
                @Override
                public Student call(Student student) {
                     //循环检查每个学生的名字，如果找到张三 则改为张三丰
                    if (student.name.equals("张三")){
                        student.name="张三丰";
                    }
                    return student;
                }
            })
            .subscribe(new Action1<Student>() {
                @Override
                public void call(Student student) {
                    Log.i(TAG, "call: "+student);
                }
            });

Aujourd'hui, l'école a formé une équipe de gymnastique. L'école a recruté quelques élèves supplémentaires. Le code est le suivant :

Les supérieurs exigent que l'apprentissage de la gymnastique commence dès l'enfance, recherchons des élèves de moins de 15 ans, formons une équipe de gymnastique, et créer une équipe de gymnastique pour les élèves du primaire. Une classe spécifique d'élèves du primaire.

Le code est donc le suivant :

private ArrayList<Student> initStudents() {
    ArrayList<Student> persons = new ArrayList<>();
    persons.add(new Student("张三", 11));
    persons.add(new Student("李四", 12));
    persons.add(new Student("王二麻子", 13));
    persons.add(new Student("李雷", 19));
    persons.add(new Student("韩梅梅", 18));
    persons.add(new Student("韩红", 17));
    return persons;
}

RxJava le convertit comme ceci :

public static class LittleStudent extends Student{

    public LittleStudent(String name, int age) {
        super(name, age);
    }
}

flatMap() est en fait un type qui sera envoyé Convertir les données en un objet d'un autre type de données

ArrayList<Student> students = initStudents();

//封装小学生集合
ArrayList<LittleStudent> littleStudents=new ArrayList<>();
for (int i = 0; i < students.size(); i++) {
    Student student = students.get(i);
    if (student.age<15){
        littleStudents.add(new LittleStudent(student.name,student.age));
    }
}

5.GroupBy

Observable.from(initStudents())
            .flatMap(new Func1<Student, Observable<LittleStudent>>() {
                @Override
                public Observable<LittleStudent> call(Student student) {
                    if (student.age<15){
                        return Observable.just(new LittleStudent(student.name,student.age));
                    }
                    return null;
                }
            })
            .subscribe(new Action1<LittleStudent>() {
                @Override
                public void call(LittleStudent littleStudent) {
                    Log.i(TAG, "call: "+littleStudent);
                }
            });

divise un Observable en une collection d'Observables, dont chacun émet une sous-séquence de l'original Observable. Quel élément de données est émis par quel Observable est déterminé par la fonction à l'intérieur de groupBy. Cette fonction attribue une clé à chaque élément. Les données avec la même clé seront émises par le même observable. Il renvoie une sous-classe spéciale d'Observable, GroupedObservable. Les objets qui implémentent l'interface GroupedObservable ont une méthode supplémentaire getKey. Cette clé est utilisée pour regrouper les données dans l'Observable spécifié.

Implémenter l'appel de classification

Enregistrer le même type de données envoyées dans n sous-observables selon la clé spécifiée

//模拟学校录入的一系列的同名学生信息
private Observable<Person> getPersons(){
    return Observable.from(new Person[]{
            new Person("zhangsan",18),
            new Person("zhangsan",20),
            new Person("lisi",19),
            new Person("lisi",33),
            new Person("wangwu",20),
            new Person("wangwu",22),
            new Person("wangwu",21)
    });
}

6.Scan

final Observable<GroupedObservable<String, Person>> observable = getPersons()
        //根据用户的名称来归类
        .groupBy(new Func1<Person, String>() {
            @Override
            public String call(Person person) {
                return person.name;
            }
        });
observable.subscribe(new Action1<GroupedObservable<String, Person>>() {
    //每归一类 则调用一次该方法
    @Override
    public void call(GroupedObservable<String, Person> observablelist) {
        Log.i(TAG, "call: ----"+observablelist.getKey());
        //打印队列中的每个元素
        observablelist.subscribe(new Action1<Person>() {
            @Override
            public void call(Person person) {
                Log.i(TAG, "call: "+person.name+"  "+person.age);
            }
        });

    }
});

L'opérateur Scan applique une fonction au premier élément de données émis par l'Observable d'origine, puis émet le résultat de cette fonction comme son propre premier élément de données. Il remplit le résultat de la fonction avec les secondes données dans la fonction pour produire ses propres secondes données. Il poursuit ce processus pour générer la séquence de données restante. Cet opérateur est appelé accumulateur dans certains cas. Par exemple, si on veut ajouter de 1 à 5, l'idée est la suivante :

RxJava le convertit comme ceci :

Sortie

 1+2=3;
 3+3=6;
 6+4=10;
10+5=15;

Exécutez une certaine fonction sur toutes les données envoyées, calculez les n-ème et n-ème éléments, puis exécutez les résultats calculés avec les n 2 éléments, et ainsi de suite

//实现从1加到5的总数
Observable.just(1, 2, 3, 4, 5)
    .scan(new Func2<Integer, Integer, Integer>() {
        //定义每个子项的合并规则
        @Override
        public Integer call(Integer sum, Integer item) {
            return sum + item;
        }
    })
    .subscribe(new Action1<Integer>() {
        @Override
        public void call(Integer result) {
            Log.i(TAG, "call: " + result);
        }
    });

Next: 1
Next: 3
Next: 6
Next: 10
Next: 15
Sequence complete.

Pendant le processus de développement, il est inévitable d'utiliser certains calculs mathématiques courants, tels que le calcul de la moyenne/la somme/les valeurs maximales et minimales/l'obtention du numéro d'une file d'attente, etc.

À propos des calculs mathématiques, RxJava fournit ici un package de dépendances. L'adresse de téléchargement est RxJavaMath

Le package de développement fournit une classe d'assistance principale :

---

MathObservable

7.Average

Trouver la moyenne d'un certain numéro de file d'attente , cette file d'attente peut être de type int ou de type double, etc. L'exemple suivant calcule la moyenne de 1 à 6

8.Max/Min

L'opérateur Min opère sur un Observable qui émet des valeurs numériques et émet une valeur unique : le la plus petite valeur.

L'opérateur Max opère sur un Observable qui émet des valeurs et émet une seule valeur : la plus grande valeur.

以下例子列出1到6的最小值：

Observable<Integer> o1 =
            MathObservable.min(Observable.just(1,2,3,4,5,6));

o1.subscribe(new Action1<Integer>() {
    @Override
    public void call(Integer integer) {
        Log.i(TAG, "call: "+integer);
    }
});

以下例子列出1到6的最大值：

Observable<Integer> o1 =
            MathObservable.max(Observable.just(1,2,3,4,5,6));

o1.subscribe(new Action1<Integer>() {
    @Override
    public void call(Integer integer) {
        Log.i(TAG, "call: "+integer);
    }
});

9.Count

count函数主要列出发送队列的个数。

Observable<Integer> o1 =Observable.just(1,2,3,4,5,4);
Observable<Integer> count = o1.count();

count.subscribe(new Action1<Integer>() {
    @Override
    public void call(Integer integer) {
            //打印出6
        Log.i(TAG, "call: "+integer);
    }
});

10.Sum

计算Observable发射的数值的和并发射这个和.

RxJava的实现是sumDouble, sumFloat, sumInteger, sumLong，它们不是RxJava核心模块的一部分，属于rxjava-math模块。你可以使用一个函数，计算Observable每一项数据的函数返回值的和。

Observable<Integer> o1 =
            MathObservable.sumInteger(Observable.just(1,2,3,4,5,4));

o1.subscribe(new Action1<Integer>() {
    @Override
    public void call(Integer integer) {
        Log.i(TAG, "call: "+integer);
    }
});

 以上就是深入浅出RxJava_05[转换操作&数学运算]的代码详细介绍的内容，更多相关内容请关注PHP中文网（www.php.cn）！