RxJava中的创建操作符

/**
 * @author ：houde
 *         时间：2018/1/23
 *         Des：Rxjava 创建操作符
 */

public class RxCreateActivity extends AppCompatActivity {
    private final String TAG = getClass().getName();
    private int i = 10;
    private Observer<Long> longObserver = new Observer<Long>() {
        @Override
        public void onSubscribe(Disposable d) {
            Log.e(TAG, "开始采用subscribe连接");
        }

        @Override
        public void onNext(Long aLong) {
            Log.e(TAG, "接收到了事件"+ aLong  );
        }

        @Override
        public void onError(Throwable e) {
            Log.e(TAG, "对Error事件作出响应");
        }

        @Override
        public void onComplete() {
            Log.e(TAG, "对Complete事件作出响应");
        }
    };
    private Observer<Integer> intObserver = new Observer<Integer>() {
        @Override
        public void onSubscribe(Disposable d) {
            Log.e(TAG,"onSubscribe");
        }

        @Override
        public void onNext(Integer integer) {
            Log.e(TAG,"接收到事件" + integer);
        }

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

        @Override
        public void onComplete() {
            Log.e(TAG,"事件完成");
        }
    };
    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_image);
        // rxjava 创建
        /**
         * 作用
         *  完整创建1个被观察者对象（Observable）
         */
        create();
        /**
         * 作用
         *  快速创建1个被观察者对象（Observable）
         *  发送事件的特点：直接发送 传入的事件
         *  注：最多只能发送10个参数
         * 应用场景
         *  快速创建 被观察者对象（Observable） & 发送10个以下事件
         *
         *  RxJava 中创建被观察者对象最基本的操作符
         */
        just();
        /**
         * 作用
         *  快速创建1个被观察者对象（Observable）
         *  发送事件的特点：直接发送 传入的数组数据
         *  会将数组中的数据转换为Observable对象
         * 应用场
         *  快速创建 被观察者对象（Observable） & 发送10个以上事件（数组形式）
         *  数组元素遍历
         *  会将数组中的数据转换为Observable对象
         */
        fromArray();
        /**
         * 作用
         *   快速创建1个被观察者对象（Observable）
         *   发送事件的特点：直接发送 传入的集合List数据
         * 应用场景
         *   快速创建 被观察者对象（Observable） & 发送10个以上事件（集合形式）
         *   集合元素遍历
         *   会将集合中的数据转换为Observable对象
         */
        fromIterable();
        //rxjava 延时创建
        /**
         * 作用
         *   直到有观察者（Observer ）订阅时，才动态创建被观察者对象（Observable） & 发送事件
         * 应用场景
         *   动态创建被观察者对象（Observable） & 获取最新的Observable对象数据
         *
         *
         */
        defer();
        /**
         * 作用
         *  快速创建1个被观察者对象（Observable）
         *  发送事件的特点：延迟指定时间后，发送1个数值0（Long类型）
         * 应用场景
         *  延迟指定事件，发送一个0，一般用于检测
         *
         *  本质 = 延迟指定时间后，调用一次 onNext(0)
         */
        timer();
        /**
         * 作用
         *  快速创建1个被观察者对象（Observable）
         *  发送事件的特点：每隔指定时间 就发送 事件
         */
        interval();
        /**
         * 作用
         *  快速创建1个被观察者对象（Observable）
         *  发送事件的特点：每隔指定时间 就发送 事件，可指定发送的数据的数量
         * a. 发送的事件序列 = 从0开始、无限递增1的的整数序列
         * b. 作用类似于interval（），但可指定发送的数据的数量
         */
        intervalRange();
        /**
         * 快速创建1个被观察者对象（Observable）
         * 发送事件的特点：连续发送 1个事件序列，可指定范围
         * a. 发送的事件序列 = 从0开始、无限递增1的的整数序列
         * b. 作用类似于intervalRange（），但区别在于：无延迟发送事件
         */
        range();
        /**
         * 作用：
         *      类似于range（），区别在于该方法支持数据类型 = Long
         * 具体使用
         *      与range（）类似，此处不作过多描述
         */
        rangeLong();
    }

    private void rangeLong() {
        Log.e(TAG,"--------------------rangeLong-----------------------------");
        Observable.rangeLong(3,6).subscribe(longObserver);
    }

    private void range() {
        // 参数说明：
        // 参数1 = 事件序列起始点；
        // 参数2 = 事件数量；
        // 注：若设置为负数，则会抛出异常
        Log.e(TAG,"--------------------range-----------------------------");

        Observable.range(1,6).subscribe(intObserver);
    }

    private void intervalRange() {
        // 参数说明：
        // 参数1 = 事件序列起始点；
        // 参数2 = 事件数量；
        // 参数3 = 第1次事件延迟发送时间；
        // 参数4 = 间隔时间数字；
        // 参数5 = 时间单位
        Log.e(TAG,"--------------------intervalRange-----------------------------");

        Observable.intervalRange(1,3,1,1,TimeUnit.SECONDS).subscribe(longObserver);
    }

    private void interval() {
        Log.e(TAG,"--------------------interval-----------------------------");
        // 参数说明：
        // 参数1 = 第1次延迟时间；
        // 参数2 = 间隔时间数字；
        // 参数3 = 时间单位；
        Observable.interval(3,1,TimeUnit.SECONDS).subscribe(longObserver);
    }

    private void timer() {
        Log.e(TAG,"--------------------timer-----------------------------");

        Observable.timer(3, TimeUnit.SECONDS).subscribe(longObserver);
    }

    private void defer() {
        Log.e(TAG,"--------------------defer-----------------------------");

        i = 19;
        Observable<Integer> observable = Observable.defer(new ObservableFromCallable<>(new Callable<ObservableSource<? extends Integer>>() {
            @Override
            public ObservableSource<? extends Integer> call() throws Exception {
                return Observable.just(i);
            }
        }));
        i = 20;
        observable.subscribe(intObserver);

    }

    private void fromIterable() {
        Log.e(TAG,"--------------------fromIterable-----------------------------");

        List<Integer> values = new ArrayList<>(5);
        for(int i = 6 ; i < 11 ; i++){
            values.add(i);
        }
        Observable.fromIterable(values).subscribe(intObserver);

    }

    private void fromArray() {
        Log.e(TAG,"--------------------fromArray-----------------------------");

        Observable.fromArray(new Integer[]{1,2,3,4}).subscribe(intObserver);
    }

    private void just() {
        Log.e(TAG,"--------------------just-----------------------------");

        Observable.just(1,2,3,4).subscribe(intObserver);
    }

    private void create() {
        Log.e(TAG,"--------------------create-----------------------------");

        Observable<Integer> observable = Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> e) throws Exception {
                e.onNext(1);
                e.onNext(2);
                e.onNext(3);
                e.onNext(4);
                e.onComplete();
            }
        });
        observable.subscribe(intObserver);
        Log.e(TAG,"-----------------------分割线-----------------------------");
        //链式调用
        Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> e) throws Exception {
                e.onNext(1);
                e.onNext(2);
                e.onNext(3);
                e.onNext(4);
                e.onComplete();
            }
        }).subscribe(new Consumer<Integer>() {
            @Override
            public void accept(Integer integer) throws Exception {
                Log.e(TAG,"观察者正在处理事件" + integer);
            }
        }, new Consumer<Throwable>() {
            @Override
            public void accept(Throwable throwable) throws Exception {
                Log.e(TAG,"观察者正在处理事件,但是报错了");
            }
        }, new Action() {
            @Override
            public void run() throws Exception {
                Log.e(TAG,"事件处理完成");
            }
        });

    }
}