Rxjava之旅-初级篇

前言

• 在上篇文章中讲了最基本的Rxjava用法，其实还有很多知识没有讲。这次来补充一下上文中一些内容和继续深入去了解Rxjava。

补充

• 先来看看两个接口

Action1<String> Action1 = new Action1<String>() {
    // 可以用来实现onNext()
    @Override
    public void call(String s) {
        Log.d(tag, s);
    }
};
Action1<Throwable> Action1 = new Action1<Throwable>() {
    // 可以用来实现onError()
    @Override
    public void call(Throwable throwable) {
        // 处理错误信息
    }
};
Action0 Action0 = new Action0() {
    // 可以用来实现onCompleted()
    @Override
    public void call() {
        Log.d(tag, "completed");
    }
};

• 当中的Action0和Action1都是Rxjava中的接口，Action0只有call一个无参无返回值的函数，又因为onCompleted()也是无参无返回值的，因此可以通过Action0来实现onCompleted()。Action1只有一个call一个有参无返回值的函数，与onNext()和onError()一样，因此可以通过它来实现。有了这样两个接口，我们可以去实现不完整的定义回调，也就是不是三个函数都必须去实现，可以根据自己的情况去打包这两个接口去实现自己需要的方法。那么如何去使用呢？

// 使用 Action1 来定义 onNext()
observable.subscribe(Action1);
// 使用 Action1 和 Action1 来定义 onNext() 和 onError()
observable.subscribe(Action1, Action1);
// 使用 Action1、 Action1 和 Action0 来定义 onNext()、 onError() 和 onCompleted()
observable.subscribe(Action1, Action1, Action0);

• 需要注意的是，它们虽然都是直接传入了实例化的接口，但是本质上还是会创建出Subscriber。其实Rxjava中还不止Action0和Action1这两个接口，还有Action2,3等接口。使用方法也同样类似，在这里就不说了。

过滤与变换

• 补充完上文的内容，那么接下来就学习一下Rxjava中的一些新知识–那就是过滤与变换。

过滤

• 顾名思义，就是对内容进行筛选，把需要的内容留下

Observable.just("abc","adr","fgg","jst").filter(new Func1<String, Boolean>() {
          @Override
          public Boolean call(String s) {
              // 条件筛选以“a”开始的内容
              return s.startsWith("a");
          }
      }).subscribe(new Action1<String>() {
          @Override
          public void call(String s) {
              // 打印结果
              System.out.println("filter s = " + s);
          }
});

• 输出结果毫无疑问是，abc和adr。filter是最常用的过滤方法之一，还有take

Observable.just("1","2","3","4","5").take(3).subscribe(new Action1<String>() {
          @Override
          public void call(String s) {
              // 打印结果
              System.out.println("ddddddddddddddd take s = " + s);
          }
      });

• take（x）方法就是把前面x个内容值取出来，那么这次的打印结果也毫无疑问是1,2,3.

• 类似的还有takelast，与take不同的是，它是从后面开始算的。

• distinct是无参的，作用是去掉相同的值，也就是说不会打印出来一样相同的值。

• skip也是接受一个整型参数的，作用是跳过前面x个数据进行打印。skiplast是从后面开始跳过

• timeout接受两个参数，和timer接受的参数类型一样。作用是在指定的时间间隔内Observable不发射值的话,监听的Observable时就会触发onError(）

变换

• 从概念上来说，就是将事件序列中的对象或整个序列进行加工处理，转换成不同的事件或事件序列。 看概念不懂的话，那就看看demo吧

Observable.just(1) // 输入类型 Integer
    .map(new Func1<Integer, String>() {
        @Override
        public Bitmap call(Integer number) { // 参数类型 Integer
            return String.valueOf(number); // 返回类型 String
        }
    })
    .subscribe(new Action1<String>() {
        @Override
        public void call(String str) { // 参数类型 String
            Log.d(tag, "str:" + str);
        }
});

通过以上的map方法就能进行变换，变换之后事件的参数类型就由Integer变成了String，那么它具体可以用在什么地方呢？比如我们可以通过字符串url，来获取Bitmap，那么就能在just中填写url在map中获取Bitmap，最后再Action1中去使用Bitmap了。不过更多的使用场景就需要自己去打代码去摸索了。在这里说说，map中那个Fun1，这是Rxjava中的一个接口，有一个有参有返回值的函数call。

• map只能用于一对一的变换，那么可不可以一对多的变换呢？答案是可以的，Rxjava中提供了flatmap的方法，可以支持一对多的事件序列变换。

List<People> peoples;
Subscriber<Hobby> subscriber = new Subscriber<Hobby>() {
    @Override
    public void onNext(Hobby hobby) {
        Log.d(tag, hobby.getstr());
    }
    ...
};
Observable.from(peoples)
    .flatMap(new Func1<People, Observable<Hobby>>() {
        @Override
        public Observable<Hobby> call(People people) {
            return Observable.from(people.getHobby());
        }
    })
    .subscribe(subscriber);

与map有所不同的是flatmap返回值的类型是Observable，然而这个对象并不会直接发送到subscriber的回调方法当中，而是汇入了同一个Observable（在这里是上面那个Observable）。最后这个Observable再统一将事件分发到subscriber的回调方法当中。flatmap里面的原理在这里先不讲，在后续的文章当中再结合源码去分析。ps:在这里先提一下留个印象，RxJava 的内部，它们是基于同一个基础的变换方法：lift(Operator)。这些原理最后会结合源码去分析，比较容易理解。

总结

• 上面讲的这些是比较基本Rxjava用法，需要多打代码熟悉才能继续深入下去学习它。在后面将会讲一下Rxjava的线程控制，毕竟Rxjava是用来处理异步问题的，没有线程控制怎么算是Rxjava呢？