RxJava（二）

前言

本篇文章是根据给 Android 开发者的 RxJava 详解做的笔记
本篇文章主要介绍的是 RxJava 变换 map 和 flatMap 的使用，以及 throttleFirst

正文

一、变换

RxJava 提供了对事件序列进行变换的支持，这是它的核心功能之一，也是大多数人说『RxJava 真是太好用了』的最大原因。所谓变换，就是将事件序列中的对象或整个序列进行加工处理，转换成不同的事件或事件序列。

1.1 先介绍下 FunX 系列的方法，因为要用到

它和 ActionX 非常相似，也是 RxJava 的一个接口，用于包装含有一个参数的方法。另外，和 ActionX 一样， FuncX 也有多个，用于不同参数个数的方法。FuncX 和 ActionX 的区别在 FuncX 包装的是有返回值的方法。

image

Fun1 接口如下

/**
 * Represents a function with one argument.
 * @param  the first argument type
 * @param  the result type
 */
public interface Func1 extends Function {
    R call(T t);
}

1.2 变换之 map() ，看例子

Student student1 = new Student("张三",20);
Student student2 = new Student("李四",30);
Student student3 = new Student("王五",40);
//// 输入类型 Student
Observable.just(student1,student2,student3)
        .map(new Func1() {
               @Override
                public String call(Student student) {// 参数类型 Student

                    String name = student.getName();
                    return name;//返回类型 String
                }
            })
            .subscribe(new Action1() {//参数类型 String
                @Override
                public void call(String s) {
                    Log.i("map",s);
                }
            });

student 类如下：

public class Student {

    private String name;
    private int age;

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }
    
}

可以看到 Observable 中原来的参数是 Student 对象，而最后我们需要的是String类型的 name，这里使用了 map 来实现这一转换的过程。

1.3 变换之 flatMap()

我把 Student 类加个属性---课程的集合

public class Student {

    private String name;
    private int age;
    //课程
    private ArrayList courseList;
    
    ...
}

课程类如下：

public class Couser {

    private String couserName;
    private int couserId;
    
    ...
}

需求：打印出每个学生所需要修的所有课程的名称跟上一个 map 的例子的区别在于--- 每个学生只有一个名字，但却有多个课程。
当然也能使用 map 来实现，将课程集合看成一个类型就行了，就像学生名字的 String 类型一样，然后遍历打印课程名称，如下：

        ArrayList list = new ArrayList<>();
        list.add(new Couser("语文",1));
        list.add(new Couser("数学",2));
        list.add(new Couser("英语",3));
        Student student1 = new Student("张三",20,list);
ArrayList list1 = new ArrayList<>();
        list1.add(new Couser("政治",4));
        list1.add(new Couser("历史",5));
        list1.add(new Couser("地理",6));
        Student student2 = new Student("张三",20,list1);
        
        
 Observable.just(student1,student2)
                .map(new Func1>() {
                    @Override
                    public ArrayList call(Student student) {
                        return student.getCourseList();
                    }
                })
                .subscribe(new Action1>() {
                    @Override
                    public void call(ArrayList cousers) {
                        for (Couser couser : cousers) {
                            Log.i("map",couser.getCouserName());
                        }
                    }
                });

注意此处观察者 Action1 的参数类型为 ArrayList cousers 。

使用 flatMap() 来实现如下：

        Observable.just(student1,student2)
                .flatMap(new Func1>() {
                    @Override
                    public Observable call(Student student) {

                        return Observable.from(student.getCourseList());
                    }
                })
                .subscribe(new Action1() {
                    @Override
                    public void call(Couser couser) {
                        Log.i("map",couser.getCouserName());
                    }
                });

从上面的代码可以看出， flatMap() 和 map() 有一个相同点：它也是把传入的参数转化之后返回另一个对象。但需要注意，和 map() 不同的是， flatMap() 中返回的是个 Observable 对象

flatMap() 的原理：

第一步，使用传入的事件对象创建一个 Observable 对象；
第二步，并不发送这个 Observable, 而是将它激活，于是它开始发送事件；
第三步，每一个创建出来的 Observable 发送的事件，都被汇入同一个 Observable ，而这个 Observable 负责将这些事件统一交给 Subscriber 的回调方法。
这三个步骤，把事件拆成了两级，通过一组新创建的 Observable 将初始的对象『铺平』之后通过统一路径分发了下去。而这个『铺平』就是 flatMap() 所谓的 flat。

flatMap() 的优点：

由于可以在嵌套的 Observable 中添加异步代码， flatMap() 也常用于嵌套的异步操作，例如嵌套的网络请求。这样可以把嵌套的请求写在一条链中，从而保持程序逻辑的清晰。也就是说在 return Observable.from(student.getCourseList()); 中做进一步的网络请求封装。

1.4 变换还有其他的方式，比如 lift 和 compose ，自行研究。。。

二、防抖动效果 throttleFirst()

作用：在每次事件触发后的一定时间间隔内丢弃新的事件。常用作去抖动过滤
比如在 onNext() 方法中有打开一个新页面的逻辑，添加这个方法之后，就不用担心因为手抖打开两个重复的界面，或者重复的操作

//设置防抖间隔为 500ms
throttleFirst(500, TimeUnit.MILLISECONDS)

用法如下：

  Observable.just(student1,student2)
                .flatMap(new Func1>() {
                    @Override
                    public Observable call(Student student) {

                        return Observable.from(student.getCourseList());
                    }
                })
                //防抖动
                .throttleFirst(500, TimeUnit.MILLISECONDS)
                
                .subscribe(new Action1() {
                    @Override
                    public void call(Couser couser) {
                        Log.i("map",couser.getCouserName());
                    }
                });