Eine detaillierte Einführung in den Code von RxJava_05 [Konvertierungsoperationen und mathematische Operationen]

Dieses Tutorial basiert auf RxJava1.>Zwischen dem Beobachter und dem Beobachteten müssen einige übertragene Daten konvertiert werden, bevor sie verwendet werden können. Manchmal erhalten wir eine Liste von Schüler einer bestimmten Klasse in der Schule, aber wir müssen die Rangfolge ihrer Chinesisch-Ergebnisse kennen. Dies erfordert die Konvertierung der ArrayList in eine ArrayList-Warteschlange. Im Folgenden wird eine Reihe von Datenumschaltoperatoren bereitgestellt:

Puffer – Konvertieren Sie mehrere gesendete Daten in an n Warteschlangen gesendete Daten. Die maximale Länge jeder Warteschlange ist die Parametergröße wird durch die Funktion buffer() angegeben.

Fenster – teilt die Daten vom ursprünglichen Observable regelmäßig in ein Observable-Fenster auf.
2. Map – teilt die von a gesendeten Daten auf bestimmte In andere Daten konvertieren

3. flatMap – konvertiert tatsächlich einen gesendeten Datentyp in ein Objekt eines anderen Datentyps

4. GroupBy – Speichern Sie den gleichen Typ gesendeter Daten gemäß dem angegebenen Schlüssel in n Unterobservablen.

Scannen – Führen Sie eine Funktion für alle gesendeten Daten aus, berechnen Sie die n-ten und n+1 Elemente und führen Sie dann die berechneten Ergebnisse mit den n+2 Elementen aus. Eine Analogie.
1.Puffer

6. In den folgenden Daten werden beispielsweise jeweils drei Zeichenfolgen gesendet

Wenn wir nach dem Beobachterpuffer hinzufügen Operator und geben Sie Cache 2 Elemente an. Der Code lautet wie folgt:

Dann werden zum ersten Mal 2 Listendaten gesendet, nämlich:

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

Das vollständige Beispiel unten Der Code lautet wie folgt:

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

Ausgabe

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

buffer() konvertiert tatsächlich n gesendete Daten in x Warteschlangen zum Senden

//这里模拟正常发送三个单一值的被观察者
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

zerlegt die Daten vom ursprünglichen Observable regelmäßig in ein Observable-Fenster und gibt diese Fenster aus, anstatt jedes Mal ein Datenelement auszugeben Window ähnelt Buffer, gibt aber kein Datenpaket vom ursprünglichen Observable aus, das Observables ausgibt. Jedes dieser Observables gibt eine Teilmenge der Daten des ursprünglichen Observables aus und gibt schließlich eine onCompleted-Benachrichtigung aus.

Ausgabe:

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

Check-in für Schulanfänger. Bei der Dateneingabe wurde festgestellt, dass der Name von Zhang San falsch eingegeben wurde und in Zhang Sanfeng geändert werden sollte. Jetzt müssen wir die Informationen für ihn erneut eingeben. Der Code lautet wie folgt:

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

RxJava konvertiert ihn wie folgt:

map() wandelt tatsächlich bestimmte gesendete Daten in andere Daten um

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

Heute hat die Schule eine Turnmannschaft gebildet. Die Schule hat einige weitere Schüler rekrutiert:

Die Vorgesetzten fordern, dass das Erlernen des Turnens von Kindesbeinen an beginnen soll, um eine Turnmannschaft zu bilden. und stellen Sie eine Turnmannschaft für Grundschüler zusammen. Eine bestimmte Klasse von Grundschülern.

Der Code lautet also wie folgt:

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 konvertiert ihn wie folgt:

public static class LittleStudent extends Student{

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

flatMap() ist eigentlich ein Typ das gesendet wird Konvertieren Sie die Daten in ein Objekt eines anderen Datentyps

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

teilt ein Observable in eine Sammlung von Observablen auf, von denen jedes eine Teilsequenz des Originals ausgibt Beobachtbar. Welches Datenelement von welchem ​​Observable ausgegeben wird, wird durch die Funktion in groupBy bestimmt. Diese Funktion weist jedem Element einen Schlüssel zu. Daten mit demselben Schlüssel werden von demselben Observable ausgegeben. Es gibt eine spezielle Unterklasse von Observable zurück, GroupedObservable. Objekte, die die GroupedObservable-Schnittstelle implementieren, verfügen über eine zusätzliche Methode getKey. Dieser Schlüssel wird zum Gruppieren von Daten in das angegebene Observable verwendet.

Klassifizierungsaufruf implementieren

Speichern Sie den gleichen Typ gesendeter Daten gemäß dem angegebenen Schlüssel in n Unterobservablen

//模拟学校录入的一系列的同名学生信息
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);
            }
        });

    }
});

Der Scan-Operator wendet eine Funktion auf das erste vom ursprünglichen Observable ausgegebene Datenelement an und gibt dann das Ergebnis dieser Funktion als sein eigenes erstes Datenelement aus. Es speist das Ergebnis der Funktion zusammen mit den zweiten Daten in die Funktion ein, um ihre eigenen zweiten Daten zu erzeugen. Dieser Prozess wird fortgesetzt, um die verbleibende Datensequenz zu generieren. Dieser Operator wird in einigen Fällen als Akkumulator bezeichnet. Wenn wir beispielsweise von 1 bis 5 addieren möchten, ist die Idee wie folgt:

RxJava konvertiert es wie folgt:

Ausgabe

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

Führen Sie eine bestimmte Funktion für alle gesendeten Daten aus, berechnen Sie die n-ten und n+1 Elemente und führen Sie dann die berechneten Ergebnisse mit den n+2 Elementen aus und so weiter

//实现从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.

Während des Entwicklungsprozesses ist es unvermeidlich, einige gängige mathematische Berechnungen zu verwenden, wie z. B. die Berechnung des Durchschnitts einer Warteschlange/Summierung/Maximal- und Minimalwerte/Ermitteln der Zahl usw.

Über Mathematik Für Berechnungen stellt RxJava ein Abhängigkeitspaket bereit. Die Download-Adresse lautet RxJavaMath

Das Entwicklungspaket stellt eine Kernhilfsklasse bereit:

---

MathObservable

7.Average

Ermitteln Sie den Durchschnitt einer bestimmten Warteschlangennummer , diese Warteschlange kann vom Typ int oder double usw. sein. Das folgende Beispiel berechnet den Durchschnitt von 1 bis 6

8.Max/Min

Der Min-Operator arbeitet mit einem Observable, das numerische Werte ausgibt und einen einzelnen Wert ausgibt: the kleinster Wert.

Der Max-Operator arbeitet mit einem Observable, das Werte ausgibt, und gibt einen einzelnen Wert aus: den größten Wert.

以下例子列出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）！