RxJava Sample

public class RxSample {

    /**
     * RxJava基本使用 创建+订阅
     */
    public void baseSubscribe(){
        /**
         * Observable的创建之基本方式
         */
        Observable<String> observable1 = Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(@NonNull ObservableEmitter<String> e) throws Exception {
                //执行一些其他操作
                //.............
                //执行完毕，触发回调，通知观察者
                e.onNext("我来发射数据");
            }
        });


        /**
         * Observable的创建之 just()
         * 使用just( )，将为你创建一个Observable并自动为你调用onNext( )发射数据。
         * 通过just( )方式 直接触发onNext()，just中传递的参数将直接在Observer的onNext()方法中接收到。
         */
        Observable<String> observable2 = Observable.just("我来发射数据");

        /**
         * Observable的创建之 fromIterable()
         * 使用fromIterable()，遍历集合，发送每个item。相当于多次回调onNext()方法，每次传入一个item
         * Collection接口是Iterable接口的子接口，所以所有Collection接口的实现类都可以作为Iterable对象直接传入fromIterable()方法
         */
        List<String> list = new ArrayList<String>();
        for(int i =0;i<10;i++){
            list.add("Hello"+i);
        }
        Observable<String> observable3 = Observable.fromIterable(list);

        /**
         * Observable的创建之 defer()
         * 当观察者订阅时，才创建Observable，并且针对每个观察者创建都是一个新的Observable。以何种方式创建这个Observable对象，当满足回调条件后，就会进行相应的回调。
         */
        Observable<String> observable4 = Observable.defer(new Callable<ObservableSource<? extends String>>() {
            @Override
            public ObservableSource<? extends String> call() throws Exception {
                return Observable.just("hello");
            }
        });

        /**
         * Observable的创建之  interval( )方式
         * 创建一个按固定时间间隔发射整数序列的Observable，可用作定时器。即按照固定2秒一次调用onNext()方法。
         * 从0开始 间隔2秒发送一次 +1递增  如何停止？
         */
        Observable<Long> observable5= Observable.interval(2, TimeUnit.SECONDS);

        /**
         * Observable的创建之 range( )方式
         * 创建一个发射特定整数序列的Observable，第一个参数为起始值，第二个为发送的个数，如果为0则不发送，负数则抛异常。
         * 上述表示发射1到20的数。即调用20次nNext()方法，依次传入1-20数字
         */
        Observable<Integer> observable6 = Observable.range(1,20);

        /**
         * Observable的创建之 timer( )方式
         * 创建一个Observable，它在一个给定的延迟后发射一个特殊的值，即表示延迟2秒后，调用onNext()方法。
         */
        Observable<Long> observable7 = Observable.timer(2, TimeUnit.SECONDS);

        /**
         * Observable的创建之 repeat( )方式
         * 创建一个Observable，该Observable的事件会重复调用。
         */
        Observable<Integer> observable8 = Observable.just(123).repeat(100);



        Observer<String> observer = new Observer<String>() {
            @Override
            public void onSubscribe(@NonNull Disposable d) {
            }
            @Override
            public void onNext(@NonNull String s) {
                System.out.println("我接收到数据了=="+s);
            }
            @Override
            public void onError(@NonNull Throwable e) {
            }
            @Override
            public void onComplete() {

            }
        };
        observable1.subscribe(observer);

        observable8.subscribe(new Consumer<Integer>() {
            @Override
            public void accept(@NonNull Integer i) throws Exception {
                System.out.println("我接收到数据了=="+i);
            }
        });

    }


    /**
     * RxJava 转换
     */
    public void change(){

        /**
         * map()操作符，就是把原来的Observable对象转换成另一个Observable对象，
         * 同时将传输的数据进行一些灵活的操作，方便Observer获得想要的数据形式。
         */
        Observable.just("hello").map(new Function<String, Integer>() {
            @Override
            public Integer apply(@NonNull String s) throws Exception {
                return 1;
            }
        }).subscribe(new Consumer<Integer>() {
            @Override
            public void accept(@NonNull Integer i) throws Exception {
                System.out.println("map hello change to=="+i);
            }
        });


        /**
         * flatMap()对于数据的转换比map()更加彻底，如果发送的数据是集合，flatmap()重新生成一个Observable对象，
         * 并把数据转换成Observer想要的数据形式。它可以返回任何它想返回的Observable对象。
         */
        List<String> list = new ArrayList<String>();
        for(int i =0;i<10;i++){
            list.add("Hello"+i);
        }
        Observable.just(list).flatMap(new Function<List<String>, ObservableSource<?>>() {
            @Override
            public ObservableSource<?> apply(List<String> strings) throws Exception {
                return Observable.fromIterable(strings);
            }
        }).subscribe(new Consumer<Object>() {
            @Override
            public void accept(@NonNull Object ob) throws Exception {
                System.out.println("flatMap hello change to=="+ob);
            }
        });

        /**
         * filter()操作符根据test()方法中，根据自己想过滤的数据加入相应的逻辑判断，返回true则表示数据满足条件，返回false则表示数据需要被过滤。
         * 最后过滤出的数据将加入到新的Observable对象中，方便传递给Observer想要的数据形式。
         */
        Observable.just(list).flatMap(new Function<List<String>, ObservableSource<?>>() {
            @Override
            public ObservableSource<?> apply(List<String> strings) throws Exception {
                return Observable.fromIterable(strings);
            }
        }).filter(new Predicate<Object>() {
            @Override
            public boolean test(Object s) throws Exception {
                String newStr = (String) s;
                if (newStr.charAt(5) - '0' > 5) {
                    return true;
                }
                return false;
            }
        }).subscribe(new Consumer<Object>() {
            @Override
            public void accept(Object o) throws Exception {
                System.out.println("flatMap filter to "+(String)o);
            }
        });

        /**
         * take()操作符：输出最多指定数量的结果。
         */
        Observable.just(list).flatMap(new Function<List<String>, ObservableSource<?>>() {
            @Override
            public ObservableSource<?> apply(List<String> strings) throws Exception {
                return Observable.fromIterable(strings);
            }
        }).take(5).subscribe(new Consumer<Object>() {
            @Override
            public void accept(Object s) throws Exception {
                System.out.println((String)s);
            }
        });


        /**
         * doOnNext()允许我们在每次输出一个元素之前做一些额外的事情。
         */
        Observable.just(list).flatMap(new Function<List<String>, ObservableSource<?>>() {
            @Override
            public ObservableSource<?> apply(List<String> strings) throws Exception {
                return Observable.fromIterable(strings);
            }
        }).take(5).filter(new Predicate<Object>() {
            @Override
            public boolean test(Object s) throws Exception {
                String newStr = (String) s;
                if (newStr.charAt(5) - '0' > 2) {
                    return true;
                }
                return false;
            }
        }).doOnNext(new Consumer<Object>() {
            @Override
            public void accept(Object o) throws Exception {
                System.out.println("准备工作"+o);
            }
        }).subscribe(new Consumer<Object>() {
            @Override
            public void accept(Object s) throws Exception {
                System.out.println("doOnNext+"+(String)s);
            }
        });

    }


    /**
     * RxJave 线程调度
     */
    public void schedulers(){
        /**
         * ● Schedulers.immediate(): 直接在当前线程运行，相当于不指定线程。这是默认的 Scheduler。

         ●Schedulers.newThread(): 总是启用新线程，并在新线程执行操作。

         ●Schedulers.io(): I/O 操作（读写文件、读写数据库、网络信息交互等）所使用的 Scheduler。行为模式和 newThread() 差不多，
         区别在于 io() 的内部实现是用一个无数量上限的线程池，可以重用空闲的线程，因此多数情况下 io() 比 newThread() 更有效率。
         不要把计算工作放在 io() 中，可以避免创建不必要的线程。

         ●Schedulers.computation(): 计算所使用的 Scheduler。这个计算指的是 CPU 密集型计算，即不会被 I/O 等操作限制性能的操作，
         例如图形的计算。这个 Scheduler 使用的固定的线程池，大小为 CPU 核数。不要把 I/O 操作放在 computation() 中，否则 I/O 操作的等待时间会浪费 CPU。

         ● Android 还有一个专用的 AndroidSchedulers.mainThread()，它指定的操作将在 Android 主线程运行。
         */


        Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(@NonNull ObservableEmitter<String> e) throws Exception {
                System.out.println("ObservableEmitter 所在的线程："+Thread.currentThread().getName());
                e.onNext("~~~");
            }
        })
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Consumer<String>() {
                    @Override
                    public void accept(@NonNull String s) throws Exception {
                        System.out.println("Consumer 所在的线程："+Thread.currentThread().getName());
                        System.out.println("接收到的数据:" + s);
                    }
                });
    }
}