RxJava2.0（转载）

零、来源

一、基础知识

角色	作用	类比
被观察者（Observable）	产生事件	顾客
观察者（Observer）	接收事件，并给出响应动作	厨房
订阅（Subscribe）	连接被观察者 & 观察者	服务员
事件（Event）	被观察者 & 观察者沟通的载体	菜式

二、基础使用

1.导入连接

implementation 'io.reactivex.rxjava2:rxjava:2.2.19'
implementation 'io.reactivex.rxjava2:rxandroid:2.1.1'

2.创建被观察者

   //创建被观察者，产生事件
    public Observable<Integer> createObservable() {
        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.onComplete();
            }
        });
        return observable;
    }

3.创建观察者

	//创建观察者
    public Observer<Integer> createObserver() {
        Observer<Integer> observer = new Observer<Integer>() {
            @Override
            public void onSubscribe(Disposable d) {
                Log.v("lanjiabinRx", "onSubscribe 连接");
            }

            @Override
            public void onNext(Integer value) {
                Log.v("lanjiabinRx", "onNext " + value + " 事件");
            }

            @Override
            public void onError(Throwable e) {
                Log.v("lanjiabinRx", "onError 事件");
            }

            @Override
            public void onComplete() {
                Log.v("lanjiabinRx", "onComplete 事件");
            }
        };
        return observer;
    }

4.建立subscribe()连接

 	//观察者订阅被观察者
    public void createSubscribe() {
        createObservable().subscribe(createObserver());
    }

5.调用和结果

 createSubscribe();

6.链式调用

 	//链式调用
    public void chainCall() {
        Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> e) throws Exception {
                e.onNext(1);
                e.onNext(2);
                e.onNext(3);
                e.onComplete();
            }
        }).subscribe(new Observer<Integer>() {
            @Override
            public void onSubscribe(Disposable d) {
                Log.v("lanjiabinRx", "onSubscribe 连接");
            }

            @Override
            public void onNext(Integer value) {
                Log.v("lanjiabinRx", "onNext " + value + " 事件");
            }

            @Override
            public void onError(Throwable e) {
                Log.v("lanjiabinRx", "onError 事件");
            }

            @Override
            public void onComplete() {
                Log.v("lanjiabinRx", "onComplete 事件");
            }
        });
    }

6.切断连接

即观察者无法继续接收被观察者的事件，但被观察者还是可以继续发送事件

Disposable mDisposable; //1.定义

@Override
public void onSubscribe(Disposable d) {
       mDisposable=d; //2.赋值
       Log.v("lanjiabinRx", "onSubscribe 连接");
}

@Override
public void onNext(Integer value) {
      if (value==2) mDisposable.dispose(); //3.在第二个next事件断开连接
      Log.v("lanjiabinRx", "onNext " + value + " 事件");
}

三、创建操作符

0.总图

1. create （基础发送）

最基础的创建


    //1.create
    public void chainCall() {
        Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> e) throws Exception {
                e.onNext(1);
                e.onNext(2);
                e.onNext(3);
                e.onComplete();
            }
        }).subscribe(new Observer<Integer>() {
            @Override
            public void onSubscribe(Disposable d) {
                Log.v("lanjiabinRx", "onSubscribe 连接");
            }

            @Override
            public void onNext(Integer value) {
                Log.v("lanjiabinRx", "onNext " + value + " 事件");
            }

            @Override
            public void onError(Throwable e) {
                Log.v("lanjiabinRx", "onError 事件");
            }

            @Override
            public void onComplete() {
                Log.v("lanjiabinRx", "onComplete 事件");
            }
        });
    }

2. just （立刻发送10以下）

快速创建1个被观察者对象（Observable）
发送事件的特点：直接发送传入的事件
最多只能发送十个参数
应用场景：快速创建被观察者对象（Observable） & 发送10个以下事件


    //2.just
    public void justDo() {
        Observable.just(1, 2, 3, 4, 5, 6, 7, 8, 9, 10).subscribe(new Observer<Integer>() {
            @Override
            public void onSubscribe(Disposable d) {
                Log.d("lanjiabinRx", "开始采用subscribe连接");
            }

            @Override
            public void onNext(Integer integer) {
                Log.d("lanjiabinRx", "接受的事件 onNext =" + integer);
            }

            @Override
            public void onError(Throwable e) {
                Log.d("lanjiabinRx", "接受的事件 onError =" + e.getMessage());
            }

            @Override
            public void onComplete() {
                Log.d("lanjiabinRx", "接受的事件 onComplete");
            }
        });
    }

结果：

3. fromArray （数组发送）

快速创建1个被观察者对象（Observable）
发送事件的特点：直接发送传入的数组数据
会将数组中的数据转换为Observable对象

应用场景：
1.快速创建被观察者对象（Observable） & 发送10个以上事件（数组形式）
2.数组元素遍历


    //3.fromArray
    public void fromArrayDo() {
        Integer[] items = {0, 1, 2, 3, 4};
        Observable.fromArray(items).subscribe(new Observer<Integer>() {
            @Override
            public void onSubscribe(Disposable d) {
                Log.v("lanjiabinRx", "开始采用subscribe连接");
            }

            @Override
            public void onNext(Integer integer) {
                Log.v("lanjiabinRx", "接受的事件 onNext =" + integer);
            }

            @Override
            public void onError(Throwable e) {
                Log.v("lanjiabinRx", "接受的事件 onError =" + e.getMessage());
            }

            @Override
            public void onComplete() {
                Log.v("lanjiabinRx", "接受的事件 onComplete");
            }
        });
    }

结果：

4. fromIterable （集合发送）

快速创建1个被观察者对象（Observable）
发送事件的特点：直接发送传入的集合List数据
会将数组中的数据转换为Observable对象

应用场景：
1.快速创建被观察者对象（Observable） & 发送10个以上事件（集合形式）
2.集合元素遍历


    //4.fromIterable
    public void fromIterableDo(){
        List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        Observable.fromIterable(list).subscribe(new Observer<Integer>() {
            @Override
            public void onSubscribe(Disposable d) {
                Log.v("lanjiabinRx", "开始采用subscribe连接");
            }

            @Override
            public void onNext(Integer integer) {
                Log.v("lanjiabinRx", "接受的事件 onNext =" + integer);
            }

            @Override
            public void onError(Throwable e) {
                Log.v("lanjiabinRx", "接受的事件 onError =" + e.getMessage());
            }

            @Override
            public void onComplete() {
                Log.v("lanjiabinRx", "接受的事件 onComplete");
            }
        });
    }

结果：

// 下列方法一般用于测试使用

<-- empty()  -->
// 该方法创建的被观察者对象发送事件的特点：仅发送Complete事件，直接通知完成
Observable observable1=Observable.empty(); 
// 即观察者接收后会直接调用onCompleted（）

<-- error()  -->
// 该方法创建的被观察者对象发送事件的特点：仅发送Error事件，直接通知异常
// 可自定义异常
Observable observable2=Observable.error(new RuntimeException())
// 即观察者接收后会直接调用onError（）

<-- never()  -->
// 该方法创建的被观察者对象发送事件的特点：不发送任何事件
Observable observable3=Observable.never();
// 即观察者接收后什么都不调用

5. defer （获取最新数据）

直到有观察者（Observer ）订阅时，才动态创建被观察者对象（Observable） & 发送事件
通过 Observable工厂方法创建被观察者对象（Observable）
每次订阅后，都会得到一个刚创建的最新的Observable对象，这可以确保Observable对象里的数据是最新的

应用场景：
动态创建被观察者对象（Observable） & 获取最新的Observable对象数据

   //5.defer
    Integer i = 10; //第一次赋值

    public void deferDo() {
        Observable<Integer> observable = Observable.defer(new Callable<ObservableSource<? extends Integer>>() {

            @Override
            public ObservableSource<? extends Integer> call() throws Exception {
                return Observable.just(i);
            }
        });

        i = 15; //第二次赋值
        observable.subscribe(new Observer<Integer>() {
            @Override
            public void onSubscribe(Disposable d) {
                Log.v("lanjiabinRx", "开始采用subscribe连接");
            }

            @Override
            public void onNext(Integer integer) {
                Log.v("lanjiabinRx", "接受的事件 onNext =" + integer);
            }

            @Override
            public void onError(Throwable e) {
                Log.v("lanjiabinRx", "接受的事件 onError =" + e.getMessage());
            }

            @Override
            public void onComplete() {
                Log.v("lanjiabinRx", "接受的事件 onComplete");
            }
        });
    }

结果：得到最新赋值的数字，说明取到了最新的数据

6. timer （延迟发送）

快速创建1个被观察者对象（Observable）
发送事件的特点：延迟指定时间后，发送1个数值0（Long类型）
本质 = 延迟指定时间后，调用一次 onNext(0)

应用场景：
延迟指定事件，发送一个0，一般用于检测


    //6.timer
    public void timerDo() {
        // 注：timer操作符默认运行在一个新线程上
        // 也可自定义线程调度器（第3个参数）：timer(long,TimeUnit,Scheduler)
        //TimeUnit.SECONDS延迟2s后，发送一个0
     
        /**
         * timer(long delay, TimeUnit unit)
         * delay 数值
         * unit 单位
         * 下面就是 2数值，单位为秒，所以是2秒
         * */
        Observable.timer(2, TimeUnit.SECONDS).subscribe(new Observer<Long>() {
            @Override
            public void onSubscribe(Disposable d) {
                Log.v("lanjiabinRx", "开始采用subscribe连接");
            }

            @Override
            public void onNext(Long aLong) {
                /*
                * 得到的结果为0 一般用于检测
                * */
                Log.v("lanjiabinRx", "接受的事件 onNext =" + aLong);
            }

            @Override
            public void onError(Throwable e) {
                Log.v("lanjiabinRx", "接受的事件 onError =" + e.getMessage());
            }

            @Override
            public void onComplete() {
                Log.v("lanjiabinRx", "接受的事件 onComplete");
            }
        });
    }

结果：

7. interval （周期发送，无限）

快速创建1个被观察者对象（Observable）
发送事件的特点：每隔指定时间就发送事件
发送的事件序列 = 从0开始、无限递增1的的整数序列


    //7.interval
    public void intervalDo() {
        /**
         * 从0开始递增
         *
         * @param initialDelay （Long）
         *          初始延迟时间（第一次延迟时间）
         * @param period （Long）
         *          后续数字发射之间的时间间隔（一个周期时间）
         * @param unit
         *          时间单位
         * */
        Observable.interval(3, 2, TimeUnit.SECONDS).subscribe(new Observer<Long>() {
            @Override
            public void onSubscribe(Disposable d) {
                Log.v("lanjiabinRx", "开始采用subscribe连接");
            }

            @Override
            public void onNext(Long aLong) {
                Log.v("lanjiabinRx", "接受的事件 onNext =" + aLong);
            }

            @Override
            public void onError(Throwable e) {
                Log.v("lanjiabinRx", "接受的事件 onError =" + e.getMessage());
            }

            @Override
            public void onComplete() {
                Log.v("lanjiabinRx", "接受的事件 onComplete");
            }
        });
    }

结果：

8. intervalRange （周期发送，有限，指定数据）

作用类似于interval（），但可指定发送的数据的数量

 	//8.intervalRange
    public void intervalRangeDo() {
        /**
         *
         * @param start 起始值
         * @param count 总共要发送的值的数量，如果为零，则运算符将在初始延迟后发出onComplete
         * @param initialDelay 发出第一个值（开始）之前的初始延迟
         * @param period 后续值之间的时间段
         * @param unit 时间单位
         * */
        Observable.intervalRange(3, 10, 2, 1, TimeUnit.SECONDS)
                .subscribe(new Observer<Long>() {
            @Override
            public void onSubscribe(Disposable d) {
                Log.v("lanjiabinRx", "开始采用subscribe连接");
            }

            @Override
            public void onNext(Long aLong) {
                Log.v("lanjiabinRx", "接受的事件 onNext =" + aLong);
            }

            @Override
            public void onError(Throwable e) {
                Log.v("lanjiabinRx", "接受的事件 onError =" + e.getMessage());
            }

            @Override
            public void onComplete() {
                Log.v("lanjiabinRx", "接受的事件 onComplete");
            }
        });
    }

结果：3-12 经历10个数

9. range (无延迟，Integer类型指定数据)

作用类似于intervalRange（），但区别在于：无延迟发送事件

	//9.range
    public void rangeDo(){
        /**
         * @param start
         *            序列中第一个Integer的值
         * @param count
         *           要生成的顺序整数的数量
         * */
        Observable.range(3,5).subscribe(new Observer<Integer>() {
            @Override
            public void onSubscribe(Disposable d) {
                Log.v("lanjiabinRx", "开始采用subscribe连接");
            }

            @Override
            public void onNext(Integer integer) {
                Log.v("lanjiabinRx", "接受的事件 onNext =" + integer);
            }

            @Override
            public void onError(Throwable e) {
                Log.v("lanjiabinRx", "接受的事件 onError =" + e.getMessage());
            }

            @Override
            public void onComplete() {
                Log.v("lanjiabinRx", "接受的事件 onComplete");
            }
        });
    }

结果：

10. rangeLong （无延迟，Long类型指定数据）


    //10.rangeLong
    public void rangeLongDo(){
        /**
         * @param start
         *            Long类型，序列中第一个Integer的值
         * @param count
         *           Long类型，要生成的顺序整数的数量
         * */
        Observable.rangeLong(3,8).subscribe(new Observer<Long>() {
            @Override
            public void onSubscribe(Disposable d) {
                Log.v("lanjiabinRx", "开始采用subscribe连接");
            }

            @Override
            public void onNext(Long aLong) {
                Log.v("lanjiabinRx", "接受的事件 onNext =" + aLong);
            }

            @Override
            public void onError(Throwable e) {
                Log.v("lanjiabinRx", "接受的事件 onError =" + e.getMessage());
            }

            @Override
            public void onComplete() {
                Log.v("lanjiabinRx", "接受的事件 onComplete");
            }
        });
    }

结果：

编程中我们会遇到多少挫折？表放弃，沙漠尽头必是绿洲。

相关阅读:
CSS颜色代码大全（自用）
Redis学习——redis.conf 配置文件介绍
 职场生存法则
 你绝对想不到的是，照片还可以这么折腾！
scene类和platform类javafx
员工辞职申请表.docx
Group容器的使用与点击事件javafx
7种join连接查询
 面试非技术问题
 加入新公司，怎样快速熟悉业务和项目？
原文地址：https://www.cnblogs.com/lanjiabin/p/13261608.html