RxJava创建类型操作符

首先扯点别的：周六去参加了一个“Android开发高效之道”技术沙龙，见到了csdn上的博客专家徐医生，也是感觉不错。
今天想分类整理一下RxJava的操作符，参考文章链接会在文章末尾给出。

一：Creating Observables（创建被观察者）

1：create

Observable observable = Observable.create(new Observable.OnSubscribe<String>() {
    @Override
    public void call(Subscriber<? super String> subscriber) {
        subscriber.onNext("Hello");
        subscriber.onNext("Hi");
        subscriber.onNext("Aloha");
        subscriber.onCompleted();
    }
});

这里传入了一个 OnSubscribe 对象作为参数。OnSubscribe 会被存储在返回的 Observable 对象中，它的作用相当于一个计划表，当 Observable 被订阅的时候，OnSubscribe 的 call() 方法会自动被调用，事件序列就会依照设定依次触发（对于上面的代码，就是观察者Subscriber 将会被调用三次 onNext() 和一次 onCompleted()）。这样，由被观察者调用了观察者的回调方法，就实现了由被观察者向观察者的事件传递，即观察者模式。

2：just

 //just(T...): 将传入的参数依次发送出来。
        Observable observable1 = Observable.just("hello", "hi", "world");
        /**
         将会依次调用：
         onNext("Hello");
         onNext("Hi");
         onNext("world");
         onCompleted();
         */

3: from

   //from(T[]) / from(Iterable<? extends T>) : 将传入的数组或 Iterable 拆分成具体对象后，依次发送出来。
        String[] words = {"Hello", "Hi", "Aloha"};
        Observable observable2 = Observable.from(words);
        ArrayList<String> list = new ArrayList<>();
        list.add("hello");
        list.add("Hi");
        list.add("Aloha");
        Observable observable3 = Observable.from(list);
        /**
         * 将会依次调用：
         onNext("Hello");
         onNext("Hi");
         onNext("Aloha");
         onCompleted();
         */

4:defer 可以用来实现延迟订阅的效果

看一个例子

public class Course {
    private String lesson;
    public Course(String lesson) {
        this.lesson = lesson;
    }
    public Course() {
    }
    public void setLesson(String lesson) {
        this.lesson = lesson;
    }
    public String getLesson() {
        return lesson;
    }

//使用just方式创建一个Observable
    public Observable<String> getLessonObservable() {
        return Observable.just(lesson);
    }

//使用defer方式创建一个Observable
    public Observable<String> valueObservable() {
        return Observable.defer(new Func0<Observable<String>>() {
            @Override
            public Observable<String> call() {
                return Observable.just(lesson);
            }
        });
    }
}

调用下面这段代码，会报错，字符串yuwen不能打印出来，因为在调用Observable.just()的时候，observable 已经初始化了。

 Course course = new Course();
        Observable<String> observable = course.getLessonObservable();
        course.setLesson("yuwen");
        observable.subscribe(new Action1<String>() {
            @Override
            public void call(String s) {
                //输出为空
                Log.e("defer", s);
            }
        });

使用defer的方式：defer()中的代码直到被订阅才会执行。

 Course course = new Course();
        Observable<String> observable = course.valueObservable();
        course.setLesson("yuwen");
        observable.subscribe(new Action1<String>() {
            @Override
            public void call(String s) {
                //输出yuwen
                Log.e("defer", s);
            }
        });

5：empty 创建一个被观察者不发出事件，正常结束。

 Observable.empty().subscribe(new Subscriber<Object>() {
            @Override
            public void onCompleted() {
                Log.e(tag, "onCompleted");
            }

            @Override
            public void onError(Throwable e) {
                Log.e(tag, "onError");
            }

            @Override
            public void onNext(Object o) {
                Log.e(tag, "onNext");
            }
        });

输出结果是：onCompleted
6：never 创建一个被观察者不发出事件，也不结束。不知道有什么用

 Observable.never().subscribe(new Subscriber<Object>() {
            @Override
            public void onCompleted() {
                Log.e(tag, "onCompleted");
            }

            @Override
            public void onError(Throwable e) {
                Log.e(tag, "onError");
            }

            @Override
            public void onNext(Object o) {
                Log.e(tag, "onNext");
            }
        });

上面的代码什么也不输出

7：error 创建一个被观察者不发出事件，抛出错误结束。

 Observable.error(new Throwable("使用error")).subscribe(new Subscriber<Object>() {
            @Override
            public void onCompleted() {
                Log.e(tag, "onCompleted");
            }

            @Override
            public void onError(Throwable e) {
                Log.e(tag, "onError");
            }

            @Override
            public void onNext(Object o) {
                Log.e(tag, "onNext");
            }
        });

输出结果：onError
8: interval 创建一个观察者一段时间就产生一个数字，这些数字从0开始，一次递增1直至无穷大

 Observable.interval(2, TimeUnit.SECONDS, Schedulers.io())
                .take(5)//最多输出5个
                .subscribe(new Action1<Long>() {
                    @Override
                    public void call(Long aLong) {
                        Log.e(tag, aLong + "");
                    }
                });

每隔两秒输出一个数字，结果0,1,2,3,4

9 range：创建一个被观察者，发出指定范围内的一串整数

  Observable.range(3, 6).subscribe(new Subscriber<Integer>() {
            @Override
            public void onCompleted() {
                Log.e(tag, "onCompleted");
            }

            @Override
            public void onError(Throwable e) {
                Log.e(tag, "onError");
            }

            @Override
            public void onNext(Integer integer) {
                Log.e(tag, integer + "");
            }
        });

上面的代码输出结果是3,4,5,6,7,8，然后输出onCompleted

10:repeat： create an Observable that emits a particular item multiple times

 Observable.range(3, 2).repeat(2).subscribe(new Subscriber<Integer>() {
            @Override
            public void onCompleted() {
                Log.e(tag, "onCompleted");
            }

            @Override
            public void onError(Throwable e) {
                Log.e(tag, "onError");
            }

            @Override
            public void onNext(Integer integer) {
                Log.e(tag, integer + "");
            }
        });

上面的代码输出3,4,3，4 onCompleted

11:startWith 在被观察者发出事件之前，做一些操作（说的有瑕疵，看下面的代码）

 Observable.just(1, 2, 4).startWith(Observable.just(9, 8, 7))
                .subscribe(new Subscriber<Integer>() {
                    @Override
                    public void onCompleted() {
                        Log.e(tag, "onCompleted");
                    }

                    @Override
                    public void onError(Throwable e) {
                        Log.e(tag, "onError");
                    }

                    @Override
                    public void onNext(Integer integer) {
                        Log.e(tag, integer + "");
                    }
                });

上面的输出结果是：9,8,7,1,2,4onCompleted

12：timer: create an Observable that emits a particular item after a given delay

Observable.timer(2, TimeUnit.SECONDS)
                .subscribe(new Subscriber<Long>() {
                    @Override
                    public void onCompleted() {
                        Log.e(tag, "onCompleted");
                    }

                    @Override
                    public void onError(Throwable e) {
                        Log.e(tag, "onError");
                    }

                    @Override
                    public void onNext(Long aLong) {
                        Log.e(tag, aLong + "");
                    }
                });

延迟两秒输出 0，onCompleted
参考网址：
【1】http://reactivex.io/documentation/operators.html
【2】http://blog.csdn.net/job_hesc/article/details/46242117