Rxjava转换函数

（1）map函数

通过对每个项目应用函数来转换Observable发出的项目

 

package rxjava.map;

import io.reactivex.Observable;

public class RxjavaMap {

    public static void main(String[] args) {
        Observable.range(1,5).map(m->{
            return m*10;
        }).subscribe(xx->System.out.println(xx));
    }
}

10
20
30
40
50

 2、flatmap

将可观察对象发出的项目转换为可观察项目，然后将这些项目的排放展平为单个可观察项目

 

 

将多个集合的Observable转换成多个Observable 然后合并成一个Observable并发送。 说白了就是将多个集合打平成一个集合，然后执行过滤

package rxjava.map;

import io.reactivex.Observable;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class RxjavaFlatMap {

    public static void main(String[] args) {
        List<PersonModel> list=new ArrayList<>();
        PersonModel personModel=new PersonModel();
        personModel.setName("zhangsan");
        personModel.setScores(new ArrayList<>(Arrays.asList(11,22,33)));
        list.add(personModel);
        PersonModel personModel1=new PersonModel();
        personModel1.setName("lisi");
        personModel1.setScores(new ArrayList<>(Arrays.asList(22,33,44)));
        list.add(personModel1);

        Observable.fromIterable(list).flatMap(m->Observable.fromIterable(m.getScores())).subscribe(System.out::println);
        System.out.println("------------");

        Observable.fromIterable(list).flatMapIterable(m->m.getScores()).subscribe(System.out::println);
    }
}



package rxjava.map;

import java.util.List;

public class PersonModel {
    private String name;
    private List<Integer> scores;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public List<Integer> getScores() {
        return scores;
    }

    public void setScores(List<Integer> scores) {
        this.scores = scores;
    }
}

11
22
33
22
33
44
------------
11
22
33
22
33
44

3、groupBy  类似与sql的groupBy 根据条件分组 生成多个Observable被观察者

将一个Observable划分为一组Observable，它们各自发出与原始Observable不同的项子集

 

package rxjava.map;


import io.reactivex.Observable;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class RxjavaGroupBy {

    public static void main(String[] args) {
        Observable.range(1,10).groupBy(i->i+1).subscribe(x->System.out.println(x.getKey()));

        System.out.println("--------------------");
        List<PersonModel> list=new ArrayList<>();
        PersonModel personModel=new PersonModel();
        personModel.setName("zhangsan");
        personModel.setScores(new ArrayList<>(Arrays.asList(11,22,33)));
        list.add(personModel);
        PersonModel personModel1=new PersonModel();
        personModel1.setName("lisi");
        personModel1.setScores(new ArrayList<>(Arrays.asList(22,33,44)));
        list.add(personModel1);

        Observable.fromIterable(list).flatMapIterable(m->m.getScores()).groupBy(g->g).subscribe(x->System.out.println(x.getKey()));
    }
}

2
3
4
5
6
7
8
9
10
11
--------------------
11
22
33
44

4、buffer  定期收集Observable 封装一个数据包进行发送，而不是一次发出一个数据项

定期将Observable发出的项目收集成束，然后发出这些束，而不是一次发出一个

package rxjava.map;

import io.reactivex.Observable;

public class RxjavaBuffer {

    public static void main(String[] args) {
        //一共10个 按照buffer2，分成5个Observable 每一个Observable 包含2个数据
        Observable.range(1,10).buffer(2).subscribe(x->System.out.println(x));
    }
}

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

5、window 不是从Observable的元素发出数据包，而是发出Observable，每个Observable都从源Observable的元素发出一个子集 然后以onComplete 通知结束 通过window生成的就是Observable

package rxjava.map;

import io.reactivex.Observable;

public class RxjavaWindow {

    public static void main(String[] args) {
        Observable.range(1,10).window(3).subscribe(x->System.out.println(x));

        System.out.println("===============");
        Observable.range(1,10).window(3).flatMap(m->m).subscribe(x->System.out.println(x));

    }
}

io.reactivex.subjects.UnicastSubject@50f8360d
io.reactivex.subjects.UnicastSubject@2cb4c3ab
io.reactivex.subjects.UnicastSubject@13c78c0b
io.reactivex.subjects.UnicastSubject@12843fce
===============
1
2
3
4
5
6
7
8
9
10

6 scan  将函数返回的值 与下一个发送的数据项 进行函数操作  输出多个Observable

package rxjava.map;

import io.reactivex.Observable;

public class RxjavaScan {

    public static void main(String[] args) {
        Observable.range(1,10).scan((x,y)->x+y).subscribe(x->System.out.println(x));
    }
}

1
3
6
10
15
21
28
36
45
55

7 sorted 将数据项进行排序

package rxjava.map;

import io.reactivex.Observable;

import java.util.Comparator;

public class RxjavaSorted {

    public static void main(String[] args) {
        Observable.just(1,6,3,10,222,44).sorted().subscribe(x->System.out.println(x));

        System.out.println("===============");
        Observable.just(1,6,3,10,222,44).sorted(Comparator.reverseOrder()).subscribe(x->System.out.println(x));

    }
}

1
3
6
10
44
222
===============
222
44
10
6
3
1