RXJava快速入门

(一)RxJava 到底是什么: 它就是一个实现 异步操作的库

as依赖：

compile 'io.reactivex:rxjava:1.0.14'

compile 'io.reactivex:rxandroid:1.0.1'
（1）通过from创建被观察者

private void createObserveableByfrom() {//通过from创建被观察者
    /**
     * 该操作符是将其它种类的对象和数据类型转换为Observable，
     * 如果当你发射的的数据是同一种类型，
     * 而不是混合使用Observables和其它类型的数据，会非常方便。
     * */

    Integer[] integers={1,2,3,4,5,6};

    //1.创建被观察者
    /**
     *from操作符可以转换Future、Iterable和数组。
     * 对于Iterable和数组，产生的Observable会发射Iterable或数组的每一项数据。
     * 对于Future，它会发射Future.get()方法返回的单个数据，
     * 并且还可以增加通过: from(Future,timeout, timeUnit)指定超时时间，
     * 如果执行的时候Future超时会回调onError（）方法。
     *
     * */
    Observable<Integer> observable=Observable.from(integers);
    //2。创建观察者
    Subscriber<Integer> subscriber=new Subscriber<Integer>() {
        @Override
        public void onCompleted() {
            Log.e(TAG, "onCompleted");
        }

        @Override
        public void onError(Throwable e) {
            Log.e(TAG, e.getMessage());
        }

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

    };

    //3.订阅
    observable.subscribe(subscriber);

}

（2）通过create创建被观察者

private void createObserveableByCreate() { //通过create创建被观察者

    Observable<String> observable=Observable.create(new Observable.OnSubscribe<String>() {

        //给create操作符传递一个观察者作为函数的参数
        @Override
        public void call(Subscriber<? super String> subscriber) {
            /**观察者发送数据的时候，需要在回调方法中调用subscriber的onNext()
             * 注意：onNext(T)发送的参数需要和Observable.OnSubscribe()中参数类型相同
             * */

            subscriber.onNext("大家好");
            subscriber.onNext("开始使用RxJava");
            subscriber.onCompleted();
        }
    });


    /**
     * (1)数据成功发送后，会回调Subscriber的onNext()的方法
     * (2)接收数据完毕后会执行onCompleted（）
     * (3)如果中途有环节出现错误异常，会执行onError()。
     * */
    Subscriber<String> subscriber=new Subscriber<String>() {
        @Override
        public void onCompleted() {
            Log.e(TAG, "onCompleted");
        }

        @Override
        public void onError(Throwable e) {
            Log.e(TAG, e.getMessage());
        }

        @Override
        public void onNext(String s) {
            Log.e(TAG, "onNext："+s);
        }
    };



    /**
     * 观察者和被观察者都创建完毕了，他们执行还需要一个前提就是订阅
     * 如果不订阅，observable并不会发射数据，subscribe也不会接收数据
     *
     * */

    observable.subscribe(subscriber);
}

（3）通过just创建被观察者

private void createObserveableByJust() {//通过just创建被观察者
    //对于just参数类型可以是多种，如下，传入两个类型数据
    Observable.just("张三", 0, 1, 2, 3, "王五", 4, 5, "赵四").subscribe(new Subscriber<Serializable>() {
        @Override
        public void onCompleted() {
            Log.e(TAG, "onCompleted: ");
        }

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

        @Override
        public void onNext(Serializable serializable) {
            Log.e(TAG, "onNext: " + serializable.toString());
        }
    });

}

（4）Range操作符

private void Range() {
    /**
     * Returns an Observable that emits a sequence of Integers within a specified range.
     * 通过发射特定范围内的连续的整数返回一个observable
     *
     * */
    Observable.range(1,4).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, "onNext: " + integer);
        }
    });
}

（5）Timer关键字

private void Timer() {
        /**
         * Returns an Observable that emits one item after a specified delay, and then completes.
         * Timer操作符创建一个在给定的时间段之后返回一个特殊值的Observable。它在延迟一段给定的时间后发射一个简单的数字0
         *
         *
         * 对于该操作符默认在computation调度器上执行的，如果你想在onNext（）回调方法更新UI,
         * 需要通过observeOn(AndroidSchedulers.mainThread())设置，
         * 否则会调用onError()方法。当然Time人提供的有一个
         * 三个参数的方法timer(long,TimeUnit,Scheduler)可以指定 Scheduler 。
         *
         * */
        Observable.timer(1, 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, "onNext: "+aLong);
            }
        });
    }

（6）Interval关键字

 private void interval() {

        //每隔1秒在tv上追加一个数字，并且会永远执行。
        Subscription subscription=Observable.interval(1,TimeUnit.SECONDS)
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Action1<Long>() {
                    @Override
                    public void call(Long aLong) {
                        Log.e(TAG,aLong+"");
                        i=aLong;

                    }
                });
//        //。如果在某个时刻不想继续输出，就需要要解除订阅。
//        if (subscription != null && !subscription.isUnsubscribed()) {
//            subscription.unsubscribe();
//        }

    }

（7）Repeat关键字

private void repeat() {

    String[] strs = {"也许当初忙着微笑和哭泣", "忙着追逐天空中的流星"};
    /**
     * Returns an Observable that repeats the sequence of items emitted by the source Observable at most
     * {@code count} times.
     * */
    Observable.from(strs).repeat(2).subscribe(new Subscriber<String>() {
        @Override
        public void onCompleted() {
            Log.e(TAG, "onCompleted: " );
        }

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

        @Override
        public void onNext(String s) {
            Log.e(TAG, "onNext: "+s );
        }
    });
}

（8）Defer关键字

private void defer() {
    /**
     * 直到有观察者订阅时才创建Observable，并且为每个观察者创建一个新的Observable，
     * 该操作符能保证订阅执行时数据源是最新的数据
     *
     * */

     test="旧数据";
    Observable<String> observable=Observable.defer(new Func0<Observable<String>>() {
        @Override
        public Observable<String> call() {
            return Observable.just(test);
        }
    });
    Subscriber subscriber=new Subscriber() {
        public String TAG="RXJAVA";

        @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: "+o );
        }
    };
     test="新数据";
    observable.subscribe(subscriber);
    
}