常用的RxJava操作符实例

1. from

作用:from操作符是把其他类型的对象和数据类型转化成Observable,
转换集合为一个每次发射集合中一个元素的 Observable 对象。
场景: 遍历集合

public static void from(){
    Observable observable = Observable.from(new String[] {"C++", "Java", "C#", "Python"});
    observable.subscribe(new Action1<String>() {
                             @Override
                             public void call(String name) {
                                 Log.d("jl", "from-----> name = " + name);
                             }
                         });

//或者可以使用下面这种可以监听错误和结束的订阅方式
//        observable.subscribe(new Action1<String>() {
//            @Override
//            public void call(String name) {
//                Log.d("jl", "from-----> name = " + name);
//            }
//        }, new Action1<Throwable>() {
//            @Override
//            public void call(Throwable throwable) {
//                Log.d("jl", "from-----> error");
//            }
//        }, new Action0() {
//            @Override
//            public void call() {
//                Log.d("jl", "from-----> finish");
//            }
//        });
}

2. from

使用FutrueTask来创建异步执行的任务,然后通过from将结果输出出去

public static void fromFutureTask(){
    final FutureTask<String> task = new FutureTask<String>(new Callable<String>() {
        @Override
        public String call() throws Exception {
            String [] names = new String[] {"C++", "Java", "C#", "Python"};
            for (String name : names) {
                if (name != null && name.equals("Python")) {
                    return name;
                }
            }
            return "";
        }
 });

    Scheduler.Worker work = Schedulers.io().createWorker();
    work.schedule(new Action0() {
        @Override
        public void call() {
            task.run();
        }
    });

    Observable observable = Observable.from(task);
    observable.subscribe(new Action1<String>() {
        @Override
        public void call(String name) {
            Log.d("jl", "fromFutureTask-----> name = " + name);
        }
    }, new Action1<Throwable>() {
        @Override
        public void call(Throwable throwable) {}
    }, new Action0() {
        @Override
        public void call() {}
    });
}

1. 异步加载数据
   
   • 使用Observable.fromCallable()方法有两点好处：
   • 1.获取要发送的数据的代码只会在有Observer订阅之后执行。
   • 2.获取数据的代码可以在子线程中执行。
     *
   • 注意:
   • 1.Observable.fromCallable()方法可以拖延Observable获取数据的操作，这一点在数据需要在其他线程获取时尤其重要。
   • 2.subscribeOn()让我们在指定线程中运行获取数据的代码，只要不是UI线程就行。
   • 3.observeOn()让我们在合适的线程中接收Observable发送的数据，在这里是UI主线程。
   • 4.记住要让Observer取消订阅以免Observable异步加载数据时发生意外。

    public static void fromCallable(){
        Observable observable = Observable.fromCallable(new Callable() {
            @Override
            public Object call() throws Exception {
                List<String> list = new ArrayList<String>();
                for (int i = 0; i < 10000; i++) {
                    list.add(String.valueOf(i));
                }
                return list;
            }
        });

        //subscription 对象为的是在必要的时候取消订阅
        Subscription subscription = observable
                .observeOn(AndroidSchedulers.mainThread())
                .subscribeOn(Schedulers.io())
                .subscribe(new Observer<List<String>>() {
                    @Override
                    public void onCompleted() {}

                    @Override
                    public void onError(Throwable e) {}

                    @Override
                    public void onNext(List<String> list) {
                        Log.e("jl","observable list.size() = "+list.size());
                    }
                });
    }

/**
 * Observable还有一个精简版，叫做Single。Single几乎和Observable一模一样，
 * 但其回调方法不是onComplete()/onNext()/onError()，而是onSuccess()/onError()。
 */
public static void single(){
    Single obserSingle = Single.fromCallable(new Callable() {
        @Override
        public Object call() throws Exception {
            List<String> list = new ArrayList<String>();
            for (int i = 0; i < 10000; i++) {
                list.add(String.valueOf(i));
            }
            return list;
        }
    });

    //subscription 对象为的是在必要的时候取消订阅
    Subscription subscription = obserSingle.
            observeOn(AndroidSchedulers.mainThread())
            .subscribeOn(Schedulers.io())
            .subscribe(new SingleSubscriber<List<String>>() {
                @Override
                public void onSuccess(List<String> list) {
                    Log.e("jl","single  list.size() = "+list.size());
                }

                @Override
                public void onError(Throwable error) {}
            });

}


/**
 * just
 * 作用:just操作符也是把其他类型的对象和数据类型转化成Observable，
 *     它和from操作符很像，只是方法的参数有所差别
 *     转换一个或多个 Object 为依次发射这些 Object 的 Observable 对象。
 * 场景：转换一个或多个普通 Object 为 Observable 对象，如转换数据库查询结果、网络查询结果等。
 * 特点：所有Observer一旦订阅这个Observable就会立即调用onNext()方法并传入Observable.just()的参数，
 *     而后因为Observable没有数据可以发送了，onComplete()方法会被调用。
 *     使用just( )，将为你创建一个Observable并自动为你调用onNext( )发射数据
 * 注意: just() 方法可传入 1~10 个参数，也就说当元素个数小于等于 10 的时候既可以使用just() 也可以使用 from()，否则只能用 from() 方法。
 */
public static void just() {
    String[] names = {"a", "b", "c", "d", "e"};
    Observable observable = (Observable) Observable.just(names);

    observable.subscribe(new Observer<String []>() {
        @Override
        public void onCompleted() {}

        @Override
        public void onError(Throwable e) {}

        @Override
        public void onNext(String [] names) {
            for (String str: names) {
                Log.d("jl", "str = "+str);
            }
        }
    });
}

/**
 * create
 * 作用: 返回一个在被 OnSubscribe 订阅时执行特定方法的 Observable 对象，
 * 场景: 不推荐使用，可使用其他操作符替代，如使用 from()操作符完成遍历。
 */
public static void create(){
    Observable.OnSubscribe<String> onSubscribe = new Observable.OnSubscribe<String>(){
        @Override
        public void call(Subscriber<? super String> subscriber) {
            subscriber.onNext("Java is very good");
            subscriber.onCompleted();
        }
    };

    Observable observable = Observable.create(onSubscribe);
    observable.subscribe(new Observer<String>() {
        @Override
        public void onCompleted() {}

        @Override
        public void onError(Throwable e) {}

        @Override
        public void onNext(String name) {
            Log.d("jl", "create------> name = "+name);
        }
    });
}

/**
 * interval
 * 作用: 返回一个每隔指定的时间间隔就发射一个序列号的 Observable 对象。
 *      interval操作符是每隔一段时间就产生一个数字，这些数字从0开始，一次递增1直至无穷大；
 * 场景: 可使用该操作符完成定时、倒计时等功能。
 */
public static void interval(){
    Observable.interval(3, TimeUnit.SECONDS)
            .subscribe(new Observer<Long>() {
                @Override
                public void onCompleted() {}

                @Override
                public void onError(Throwable e) {}

                @Override
                public void onNext(Long time) {
                     Log.d("jl", "create------> time = "+time);
                }
            });
}

/**
 * timer
 * 作用: 创建一个在指定延迟时间后发射一条数据（固定值：0）的 Observable 对象。
 *      timer操作符是创建一串连续的数字，产生这些数字的时间间隔是一定的；这里有两种情况：
 *      一种是隔一段时间产生一个数字，然后就结束，可以理解为延迟产生数字;
 *      一种是每隔一段时间就产生一个数字，没有结束符，也就是是可以产生无限个连续的数字
 * 场景: 可用来完成定时功能。
 * timer操作符默认情况下是运行在一个新线程上的，当然你可以通过传入参数来修改其运行的线程。
 */
public static void timer(){
    Observable.timer(3, TimeUnit.SECONDS)
            .subscribe(new Observer<Long>() {
                @Override
                public void onCompleted() {}

                @Override
                public void onError(Throwable e) {}

                @Override
                public void onNext(Long aLong) {
                    Log.d("jl", "timer------> timer = "+aLong);
                }
            });
}

/**
 * range
 * 作用: 创建一个发射指定范围内的连续整数的 Observable 对象。
 * 场景: 可使用该操作符完成一个 for 的循环，如 for(int i=5;i<=7;i++) -> Observable.range(5, 3)。
 */
public static void range(){
    Observable.range(3,10)
            .subscribe(new Observer<Integer>() {
                @Override
                public void onCompleted() {
                }

                @Override
                public void onError(Throwable e) {}

                @Override
                public void onNext(Integer integer) {
                    Log.d("jl", "range------> integer = "+integer);
                }
            });
}

/**
 * defer
 * 作用: 在订阅的时候才会创建 Observable 对象；每一次订阅都创建一个新的 Observable 对象。
 * 场景: 可以使用该操作符封装需要被多次执行的函数。
 */
public static void defer(){
    Observable<String> observable = Observable.defer(new Func0<Observable<String>>() {
        @Override
        public Observable<String> call() {
            return Observable.just("Java");
        }
    });
    //subscription 对象为的是在必要的时候取消订阅
    Subscription subscription = observable.
            observeOn(AndroidSchedulers.mainThread())
            .subscribeOn(Schedulers.io())
            .subscribe(new Observer<String>() {
                @Override
                public void onCompleted() {}

                @Override
                public void onError(Throwable e) {}

                @Override
                public void onNext(String s) {
                    Log.d("jl", "defer------> String = "+s);
                }
            });
}

/**
 * repeat
 * 作用: 使Observable 对象在发出 onNext() 通知之后重复发射数据。重做结束才会发出 onComplete() 通知，
 *      若重做过程中出现异常则会中断并发出 onError() 通知。
 * 场景: 可使用该操作符指定一次任务执行完成后立即重复执行上一次的任务，如发送多次网络请求等。
 */
public static void repeat(){
    String[] names = {"java", "c++", "lisp", "python"};
    Observable observable = (Observable) Observable.just(names).repeat(5);

// observable.repeat(5); 不起作用,….
observable.subscribe(new Observer