RxJava_05 [변환 연산 및 수학적 연산] 코드에 대한 자세한 소개

이 튜토리얼은 RxJava1을 기반으로 합니다. > 관찰자와 관찰자 사이에서 일부 전송된 데이터를 사용하려면 먼저 변환해야 합니다. 학교의 특정 학급에 있는 학생들의 중국어 점수 순위를 알아야 합니다. 이를 위해서는 ArrayList를 ArrayList 대기열로 변환해야 합니다. 다음은 일련의 데이터 전환 연산자를 제공합니다.

버퍼 - 전송된 여러 데이터를 n개의 대기열로 전송된 데이터로 변환합니다. 각 대기열의 최대 길이는 매개변수 크기입니다. buffer() 함수에 의해 지정됩니다.

Window - 주기적으로 원본 Observable의 데이터를 Observable 창으로 나눕니다.
2. Map - 전송된 데이터를 분할합니다. 특정 다른 데이터로 변환

3. flatMap - 실제로 전송된 한 유형의 데이터를 다른 데이터 유형의 객체로 변환합니다

4. GroupBy - 지정된 키에 따라 동일한 유형의 전송된 데이터를 n개의 하위 Observable에 저장합니다.

Scan - 전송된 모든 데이터에 대해 함수를 실행하고 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);

그러면 처음으로 2개의 목록 데이터가 전송됩니다.

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

아래 전체 샘플 코드는 다음과 같습니다. 다음:

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

Output

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

buffer()는 실제로 전송된 n 데이터를 x 대기열로 변환합니다

2.Window

주기적으로 원본 Observable의 데이터를 Observable 창으로 나누고 한 번에 한 조각의 데이터를 내보내는 대신 이러한 창을 내보냅니다. Window는 Buffer와 유사하지만 원본 Observable에서 데이터 패킷을 내보내는 대신 Emit은 Observable이며, 각 Observable은 원래 Observable 데이터의 하위 집합을 내보내고 마지막으로 onCompleted 알림을 내보냅니다.

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

출력:

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

3.Map

신입생 체크인. 데이터 입력 중 Zhang San의 이름이 잘못 입력된 것으로 확인되어 Zhang Sanfeng으로 변경해야 합니다. 이제 그에 대한 정보를 다시 입력해야 합니다. 코드는 다음과 같습니다.

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

RxJava는 이를 다음과 같이 변환합니다.

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

map()은 실제로 전송된 특정 데이터를 다른 데이터로 변환합니다.

4.FlatMap

오늘 학교에서 체조팀을 결성했습니다. 학교에서는 몇 명의 학생을 더 모집했는데 코드는 다음과 같습니다. rree 상사는 체조를 어릴 때부터 배워야 한다고 요구했습니다. 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

유형의 객체는 Observable을 Observable 컬렉션으로 분할하며, 각 Observable은 원래 Observable의 하위 시퀀스를 방출합니다. Observable이 어떤 데이터 항목을 내보낼지는 groupBy 내부 함수에 의해 결정됩니다. 이 함수는 각 항목에 Key를 할당하며 동일한 Observable에서 내보내집니다. 이는 Observable의 특수 하위 클래스인 GroupedObservable을 반환합니다. GroupedObservable 인터페이스를 구현하는 객체에는 getKey라는 추가 메서드가 있습니다. 이 키는 데이터를 지정된 Observable로 그룹화하는 데 사용됩니다.

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이 내보낸 첫 번째 항목에 함수를 적용한 다음 해당 함수의 결과를 자체 첫 번째 항목으로 내보냅니다. 두 번째 데이터와 함께 함수의 결과를 함수에 공급하여 자체 두 번째 데이터를 생성합니다. 이 프로세스를 계속하여 나머지 데이터 시퀀스를 생성합니다. 어떤 경우에는 이 연산자를 누산기라고 합니다. 예를 들어 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;

출력

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

Min 연산자는 숫자 값을 내보내고 단일 값: 가장 작은 값을 내보내는 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）！