RxJava学习笔记（变换Observables）

转换Observables

转换Observables，顾名思义就是变换可观测序列，来创建一个能够更好的满足我们需求的序列。

map家族

RxJava提供了几个mapping函数： map() , flatMap() , concatMap() , flatMapIterable() 以及 switchMap() .所有这些函数都作用于一个可观测序列，然后变换它发射的值，最后用一种新的形式返回它们。

Map

Rxjava的map函数接收一个指定的Func1对象，然后将它应用到每一个由Observable发射的值上。Func1是一个接口，两个泛型，内部只有一个call方法，一个泛型是参数类型，一个泛型是返回值类型，在这里就可以理解这个call方法就是将可观测序列元素转换的转换方法。so，意思就是我们可以自己定制自己需要的转换方法。

• 比如下面的代码，我们让可观测序列元素的值乘以5发射。

    public static void main(String... args) {
        Observable.create(new Observable.OnSubscribe() {
            @Override
            public void call(Subscriber subscriber) {
                subscriber.onNext(1);
                subscriber.onNext(2);
                subscriber.onNext(3);
            }
        }).map(new Func1() {
            @Override
            public Integer call(Integer integer) {
                return integer * 5;
            }
        }).subscribe(new Observer() {
            @Override
            public void onCompleted() {
                System.out.println("completed");
            }
  
            @Override
            public void onError(Throwable e) {
                System.out.println("something is error");
            }
  
            @Override
            public void onNext(Integer integer) {
                System.out.println("i = " + integer);
            }
        });
    }
  

打印结果：

i = 5

i = 10

i = 15

FlatMap

flatMap同样也是转换元素的，不过和map不同的是，flatMap转换的返回的是Observable对象。要对其进行理解做一个对比比较容易理解。已知：两个javabean类，School和Student：

public class School {
    private List mStudents = new ArrayList<>();

    public List getStudents() {
        return mStudents;
    }

    public void setStudents(List students) {
        mStudents = students;
    }
}

就School特殊一点，只写了一个Student的集合，当然，当中还可以包含其他数据，这里只是体现其中有一个数据集合，Student类就是一个普通bean类，包含name,age两个成员变量及其get/set方法。然后假设我们获取到一个School变量，需要从中得到所有的Student的具体数据，用map我们可以这样干：

public static void main(String... args) {
    School school = new School();
    school.getStudents().add(new Student("张三" , 23));
    school.getStudents().add(new Student("李四" , 24));
    school.getStudents().add(new Student("王五" , 25));

    Observable.just(school)
            .map(new Func1>() {
                @Override
                public List call(School school) {
                    return school.getStudents();
                }
            })
            .subscribe(new Observer>() {
                @Override
                public void onCompleted() {
                
                }

                @Override
                public void onError(Throwable e) {

                }

                @Override
                public void onNext(List students) {
                    for (Student student : students) {
                        System.out.println("name = " + student.getName());
                    }
                }
            });
}

接收一个Student数据集合遍历获取当中的数据，但是如果我们不想在代码中使用for循环遍历，而是希望在Subscriber中直接传入单个的Student对象呢，用map显然是行不通的，因为map仅仅是一对一的转化，而现在要求的是一对多的转换，那么如何实现呢，我们用flatMap:

public static void main(String... args) {
    School school = new School();
    school.getStudents().add(new Student("张三" , 23));
    school.getStudents().add(new Student("李四" , 24));
    school.getStudents().add(new Student("王五" , 25));

    Observable.just(school)
            .flatMap(new Func1>() {
                @Override
                public Observable call(School school) {
                    return Observable.from(school.getStudents());
                }
            })
            .subscribe(new Observer() {
                @Override
                public void onCompleted() {

                }

                @Override
                public void onError(Throwable e) {

                }

                @Override
                public void onNext(Student student) {
                    System.out.println("name = " + student.getName());
                }
            });
}

打印的结果都是：

name = 张三

name = 李四

name = 王五

我们有一个数据序列，它发射一个数据序列，这些数据本身自己也可以发射Observable，flatMap就可以合并这些Observable发射的数据，然后将合并后的结果作为最终的Observable。但是它的合并允许交叉，也就意味着flatMap()不能够保证在最终生成的Observable中源Observables确切的发射顺序。

ConcatMap

RxJava的concatMap()函数解决了flatMap()的交叉问题，提供了一种能够把发射的值连续在一起的铺平函数，而不是合并它们。

public static void main(String... args) {
    School school = new School();
    school.setAddress("China");
    school.getStudents().add(new Student("张三" , 23));
    school.getStudents().add(new Student("李四" , 24));
    school.getStudents().add(new Student("王五" , 25));

    Observable observable = Observable.just(school);
    observable.subscribe(new Action1() {
        @Override
        public void call(School school) {
            System.out.println("school address = " + school.getAddress());
        }
    });
    observable.concatMap(new Func1>() {
        @Override
        public Observable call(School school) {
            return Observable.from(school.getStudents());
        }
    }).subscribe(new Observer() {
        @Override
        public void onCompleted() {

        }

        @Override
        public void onError(Throwable e) {

        }

        @Override
        public void onNext(Student student) {
            System.out.println("student name = " + student.getName());
        }
    });
}

这里给School类添加一个属性地址，打印结果：

school address = China

student name = 张三

student name = 李四

student name = 王五

FlatMapIterable

flatMapIterable()可以将数据包装成Iterable,在Iterable中我们可以随意对数据进行加工。

public static void main(String... args) {
    Observable.just(1,2,3,4)
            .flatMapIterable(new Func1>() {
                @Override
                public Iterable call(Integer integer) {
                    List list = new ArrayList();
                    list.add(integer);
                    list.add(5);
                    return list;
                }
            }).subscribe(new Action1() {
        @Override
        public void call(Integer integer) {
            System.out.println("i = " + integer);
        }
    });
}

这里在每个数据创建的Iterable中都加入了一个元素"5",打印结果如下：

i = 1

i = 5

i = 2

i = 5

i = 3

i = 5

i = 4

i = 5

SwitchMap

每当源Observable发射一个新的数据项（ Observable） 时，它将取消订阅并停止监视之前那个数据项产生的Observable，并开始监视当前发射的这一个。

Scan

RxJava的scan()函数可以看做是一个累积函数。scan()函数对原始Observable发射的每一项数据都应用一个函数，计算出函数的结果值，并将该值填充回可观测序列，等待和下一次发射的数据一起使用。

public static void main(String... args) {
    Observable.just(1,2,3,4,5)
            .scan(new Func2() {
                @Override
                public Integer call(Integer integer, Integer integer2) {
                    return integer + integer2;
                }
            })
            .subscribe(new Observer() {
                @Override
                public void onCompleted() {
                    System.out.println("rxjava onCompleted");
                }

                @Override
                public void onError(Throwable e) {
                    System.out.println("rxjava onError");
                }

                @Override
                public void onNext(Integer integer) {
                    System.out.println("result = " + integer);
                }
            });
}

这里对每一个数据元素都进行了相加的操作，看结果更明了：

result = 1

result = 3

result = 6

result = 10

result = 15

rxjava onCompleted

还有一个scan()函数的变体scan(R initialValue, Func2 accumulator)，它可以设置一个初始值作为第一个发射的元素值，

public static void main(String... args) {
    Observable.just(1,2,3,4,5)
            .scan(10, new Func2() {
                @Override
                public Integer call(Integer integer, Integer integer2) {
                    return integer + integer2;
                }
            })
            .subscribe(new Observer() {
                @Override
                public void onCompleted() {
                    System.out.println("rxjava onCompleted");
                }

                @Override
                public void onError(Throwable e) {
                    System.out.println("rxjava onError");
                }

                @Override
                public void onNext(Integer integer) {
                    System.out.println("result = " + integer);
                }
            });
}

这里我们为scan()设置了一个初始值10，那么发射的第一个元素就是这个10，之后又与其相加，打印结果如下：

result = 10

result = 11

result = 13

result = 16

result = 20

result = 25

rxjava onCompleted

GroupBy

groupBy()将源Observable变换成一个发射Observables的新的Observable。它们中的每一个新的Observable都发射一组指定的数据。实际使用中，我们需要提供一个生成key的规则（也就是Func1中的call方法），所有key相同的数据会包含在同一个小的Observable中。

public static void main(String... args) {
    Student lisi = new Student("李四", 24);
    Student wangwu = new Student("王五", 25);
    Student zhangsan = new Student("张三", 23);
    Student jianjian = new Student("jianjian", 24);
    Student wenwen = new Student("wenwen", 25);

    Observable> GroupedObservable = Observable.just(lisi, wangwu, zhangsan, jianjian, wenwen)
            .groupBy(new Func1() {
                @Override
                public Integer call(Student student) {
                    return student.getAge();
                }
            });
    Observable.concat(GroupedObservable)
            .subscribe(new Action1() {
                @Override
                public void call(Student student) {
                    System.out.println("student = " + student.getName() + ", age = " + student.getAge());
                }
            });
}

这里我们首先创建了一个新的Observable:GroupedObservable,它将会发送一个带有GroupedObservable的序列（也就是指发送的数据项的类型为GroupedObservable）。GroupedObservable是一个特殊的Observable，它基于一个分组的key，在这个例子中，key就是student的年龄age,代表的意思就是年龄相同的数据会包含在一起。打印结果：

student = 李四, age = 24

student = jianjian, age = 24

student = 王五, age = 25

student = wenwen, age = 25

student = 张三, age = 23

Buffer

RxJava中的 buffer() 函数将源Observable变换一个新的Observable，这个新的Observable每次发射一组列表值而不是一个一个发射。

public static void main(String... args) {
    Observable.just(1,2,3,4,5,6)
            .buffer(2)
            .subscribe(new Action1>() {
                @Override
                public void call(List integers) {
                    for (Integer i : integers) {
                        System.out.println("i = " + i);
                    }
                    System.out.println("-------------------");
                }
            });
}

这里的buffer(2)指定了缓冲容量的大小为2，打印结果：

i = 1

i = 2

-------------------

i = 3

i = 4

-------------------

i = 5

i = 6

-------------------

实际上，buffer()函数还有几种重载方法，其中一个允许你指定一个skip值，此后每 skip 项数据，然后又用count项数据填充缓冲区。

public static void main(String... args) {
    Observable.just(1,2,3,4,5,6)
            .buffer(2, 3)
            .subscribe(new Action1>() {
                @Override
                public void call(List integers) {
                    for (Integer i : integers) {
                        System.out.println("i = " + i);
                    }
                    System.out.println("-------------------");
                }
            });
}

这里buffer(2, 3)设置了每3个元素中用两个元素填充缓冲区，打印结果：

i = 1

i = 2

-------------------

i = 4

i = 5

-------------------

buffer() 还可以带一个 timespan 的参数，会创建一个每隔timespan时间段就会发射一个列表的Observable。

Window

Rxjava的window()和buffer()很像，但是它发射的是Observable而不是数据列表，发射的这些Observables都是源Observable数据的一个子集，数量由参数count来定，最后发送一个onCompleted()结束。

public static void main(String... args) {
    Observable.just(1,2,3,4,5)
            .window(3)
            .subscribe(new Observer>() {
                @Override
                public void onCompleted() {
                    System.out.println("window onCompleted");
                }

                @Override
                public void onError(Throwable e) {

                }

                @Override
                public void onNext(Observable integerObservable) {
                    integerObservable.subscribe(new Observer() {
                        @Override
                        public void onCompleted() {
                            System.out.println("onCompleted");
                        }

                        @Override
                        public void onError(Throwable e) {

                        }

                        @Override
                        public void onNext(Integer integer) {
                            System.out.println("i = " + integer);
                        }
                    });
                }
            });
}

这里的window(3)设置了子集的大小为3，打印结果：

i = 1

i = 2

i = 3

onCompleted

i = 4

i = 5

onCompleted

window onCompleted

同样的，window()也有带skip参数的重载方法。

Cast

Rxjava的cast()可以将源Observable中的每一项数据都转换为新的类型，把它变成了不同的Class。第一次看到这个，我还以为可以随便转,就用一个Integer转成String试试咯，好吧原谅我的天真，java.lang.ClassCastException立马打我脸，接着我创建了一个父类一个子类，里面很简单。
父类：

public class Father {
    public void eat(){
        System.out.println("father was eat");
    }
}

子类：

public class Son extends Father {
    public void eat(){
        System.out.println("son was eat");
    }
}

接着：

public static void main(String... args) {
    Observable.just(new Son())
            .cast(Father.class)
            .subscribe(new Action1() {
                @Override
                public void call(Father f) {
                    f.eat();
                }
            });
}

注意这里只能向上转型，也就是说子类转成父类，构成这样：Father f = new Son()，要记住一点，"编译看左边，运行看右边"，打印结果：

son was eat