RxJava_05 コードの詳細な紹介 [変換演算と数学的演算]

このチュートリアルは、RxJava1 に基づいた包括的な説明です。たとえば、学校の特定のクラスの生徒のリストを取得することがありますが、その生徒の中国語のスコアのランキングを知る必要があります。これには、ArrayList を ArrayList キューに変換する必要があります。 以下は一連のデータ切り替え演算子を提供します:

Buffer - 送信された複数のデータを n 個のキューに送信されるデータに変換します。各キューの最大長は、buffer() 関数で指定されたパラメーター サイズです。

Window - 元の Observable のデータを定期的に Observable ウィンドウに分割します
2. Map - 送信されたデータを別のデータに変換します

3. flatMap - 実際には、1 つのタイプの変換データを送信します。別のデータ型のオブジェクトに変換します

4. GroupBy - 指定されたキーに従って、同じ型の送信データを n 個のサブ Observable に格納します。

スキャン - 送信されたすべてのデータに対して特定の関数を実行し、n 番目と n+1 番目の項目を計算し、その計算結果を n+2 番目の項目で実行する、というように続きます。
1.Buffer

6. たとえば、次のデータでは、3つの文字列がそれぞれ送信されます

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

オブザーバーの後にバッファ演算子を追加し、2つのキャッシュ項目を指定すると、コードは次のようになります。

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

以下の完全なサンプル コードは次のとおりです:

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

Output

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

buffer() は、送信された n 個のデータを実際に x 個のキューに変換します

2.Window

は、元のObservableからのデータを定期的にObservableウィンドウに分解し、毎回1つのデータを出力するのではなく、これらのウィンドウを出力します

Windowはバッファに似ていますが、元のObservableからデータパケットを出力する代わりにObservable、それ 発行されるのは Observable であり、これらの Observable のそれぞれが元の Observable データのサブセットを発行し、最後に onCompleted 通知を発行します。

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

出力:

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

3.地図

学校の新入生がチェックインします。データ入力中に、Zhang San の名前が間違って入力されていることが判明したため、Zhang Sanfeng に変更する必要があります。ここで、彼の情報を再入力する必要があります。コードは次のとおりです:

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

RxJava は次のように変換されます:

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="张三丰";
    }
}

map() は実際に特定の送信データを別のデータに変換します

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

上司は体操を幼少期から始めることを要求しています。15 歳未満の生徒を見つけて、体操チームを結成し、特定の小学校を作りましょう。小学生向けの学生クラス。

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

そのコードは次のとおりです:

public static class LittleStudent extends Student{

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

RxJavaは次のように変換します:

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

flatMap() は実際に、あるタイプの送信データを別のデータタイプのオブジェクトに変換します

5.GroupBy

Convert Observable Observable のコレクションに分割され、それぞれが元の Observable のサブシーケンスを出力します。どのデータ項目がどの Observable によって出力されるかは、groupBy 内の関数によって決定され、同じ Key を持つデータが同じ Observable によって出力されます。これは、Observable の特別なサブクラスである GroupedObservable を返します。GroupedObservable インターフェイスを実装するオブジェクトには、データを指定された Observable にグループ化するために使用される追加のメソッド getKey があります。

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

分類呼び出しを実装します

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

指定されたキーに従って、同じタイプの送信データをn個のサブObservableに格納します

6.Scan

Scanオペレータは、元のObservableによって発行されたデータの最初の項目に を適用します関数を作成し、その関数の結果を最初のデータ項目として出力します。関数の結果を 2 番目のデータで関数に埋め込み、独自の 2 番目のデータを生成します。このプロセスを継続して、残りのデータ シーケンスを生成します。この演算子はアキュムレータと呼ばれることもあります。

たとえば、1から5までを追加したい場合、アイデアは次のようになります:

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

    }
});

RxJavaは次のように変換します:

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

Output

//实现从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);
        }
    });

送信されたすべてのデータに対して特定の関数を実行し、 n 番目と n+1 個の項目が計算され、その計算結果が n+2 個の項目で実行される、というように続きます

開発プロセスでは、平均/合計の計算など、いくつかの一般的な数学的計算を使用することが避けられません。キューの/最大値と最小値/数値の取得など

数学的な計算に関しては、RxJava が依存関係パッケージを提供しています。ダウンロード アドレスは RxJavaMath です

開発パッケージはコア ヘルパー クラスを提供します: MathObservable

---

7.Average

は特定のキューの平均を見つけます。このキューは int 型または double 型などにすることができます。次の例では、1 から 6 までの平均数値を計算します

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

8.Max/MinMin 演算子は、数値を出力する Observable を操作し、単一の値 (最小値) を出力します。

Max オペレーターは、値を発行する Observable を操作し、単一の値 (最大値) を発行します。

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