RxJava2基础教程2-操作符1

上一节学习了最基本的RxJava用法，这一节学习RxJava的操作符。

1. create。 create是RxJava最基本的操作符了，作用是创建一个被观察者Observable，不用多解释上一节用的就是他，需要注意的一点是当你调用了onComplete or onError之后虽然仍旧可以调用onNext发射事件，但是实际上下游观察者不在接受事件了
2. fromArray: 这个也是操作符也是创建一个观察者，但他要比create简单的多，他接受的是一个数组，或任意多个同类型的参数，依次发送给下游的观察者

       String[] str  = new String[]{"one", "two"};
       Observable.fromArray(str)
                .subscribe(new Consumer<String>() {
                    @Override
                    public void accept(String s) throws Exception {
                        Log.i(TAG, "accept: s =" + s);
                    }
                });

    //or
        Observable.fromArray("three", "four")
                .subscribe(new Consumer<String>() {
                    @Override
                    public void accept(String s) throws Exception {
                        Log.i(TAG, "accept: s =" + s);
                    }
                });
    打印结果：
     accept: s =one
     accept: s =two
     accept: s =three
     accept: s =four

3. interval： 定时器。 这个东西很好用，他可以开启一个定时器，就是没多长时间发射一次。 例如

        Disposable disposable = Observable.interval(1, TimeUnit.SECONDS)
                .subscribe(new Consumer<Long>() {
                    @Override
                    public void accept(Long aLong) throws Exception {
                        Log.i(TAG, "accept: long = " + aLong);
                    }
                });

上面代码的意思是每隔一秒钟发射一次，相信很多项目中都有轮询的功能，比如隔多久向后台取一次数据或者上送一次数据等，轻轻松松代替你的Timer。
打印结果如下：

accept: long = 0
accept: long = 1
accept: long = 2
accept: long = 3
accept: long = 4
accept: long = 5
accept: long = 6
。。。。。
accept: long = 312
accept: long = 313
accept: long = 314

当然他还有其他的重载方法，比如延迟多少时间之后在轮询等。 但是总不能让他一直跑下去吧，想结束的时候怎么办呢，系统提供了相应的方法：

disposable.dispose();

很简单

4. interValRange: 这个方法也很实用，和interVal类似，不过它可以自己停下来因为可以设置范围，比如说我们的APP一般欢迎页面都会有一个倒计时的操作，用他再好不过：

           Observable.intervalRange(0, 5, 0, 1, TimeUnit.SECONDS)
                .subscribe(new Consumer<Long>() {
                    @Override
                    public void accept(Long aLong) throws Exception {
                        Log.i(TAG, "accept: long = " + aLong);
                    }
                });
    结果：
    : long = 0
    : long = 1
    : long = 2
    : long = 3
    : long = 4

上面有几个参数，

intervalRange(long start, long count, long initialDelay, long period, TimeUnit unit)

第一个0表示从0开始，第二个5是count表示轮询多少次，第3个延迟的时间，第4个时间间隔，第5个时间单位

5. Range 表示的是一个范围，比如说从0到100连续发射，就跟for循环一样循环一百次。
6. just： just和fromArray类似，可以接受多个参数，甚至可以接受null作为参数，然后顺序发射：

           Observable.just(1)
                .subscribe(new Consumer<Integer>() {
                    @Override
                    public void accept(Integer integer) throws Exception {
                        Log.i(TAG, "accept: integer = " + integer);
                    }
                });

          Observable.just(1, 2, 3)
                .subscribe(new Consumer<Integer>() {
                    @Override
                    public void accept(Integer integer) throws Exception {
                        Log.i(TAG, "accept: integer = " + integer);
                    }
                });

但是他和formArray是有区别的，他们的实现方式不一样，just有10个重载方法，所以只能最多只能接受10个参数。
这个在实际的应用中我看到同事在一个子线程中为了更新UI，使用这个just只是单纯的创建了一个observable，参数其实没啥用 如下：只是为了创建Observable，避免了使用Handler

            Observable.just(1)
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Consumer<Integer>() {
                    @Override
                    public void accept(Integer integer) throws Exception {
                       
                    }
                });

今天先到这，明天接着写！