RxJava的目的就是一個異步操作，在使用中不需要我們去開線程，不需要我們去管理線程，通過rxjava簡單的鏈式調用就能完成複雜的功能，代碼邏輯簡單，結構清晰，閱讀性極強。
要應用RxJava，需要在項目中引入依賴：
io.reactivex.rxjava2:rxjava:2.0.4
io.reactivex.rxjava2:rxjava:2.0.4rxjava是基於觀察者模式，下面是觀察者模式各個角色：
Observable：在觀察者模式中稱爲“被觀察者”；
Observer：觀察者模式中的“觀察者”，接受數據；
subscribe：訂閱，觀察者與被觀察者建立聯繫；
Single 和SingleObserver ，Subscriber與 Flowable ，Maybe 與 MaybeObserveOn，Completable和CompletableObserver等，這些都是rxjava提供的觀察者和被觀察者使用類。
創建型操作符
create 操作符是所有創建型操作符的根,也就是說其他創建型的操作符最後都是通過create操作符來創建Observable
Observable.create(new ObservableOnSubscribe<String>() {
@Override
public void subscribe(ObservableEmitter<String> e) throws Exception {
Log.e(TAG, "subscribe: " + Thread.currentThread().getName());
e.onNext(100 + "");
}
}).subscribeOn(Schedulers.io()).observeOn(AndroidSchedulers.mainThread()).
subscribe(new Observer<String>() {
@Override
public void onSubscribe(Disposable d) {
Log.e(TAG, "onSubscribe: " + Thread.currentThread().getName());
}
@Override
public void onNext(String value) {
Log.e(TAG, value + " onNext: " + Thread.currentThread().getName());
}
@Override
public void onError(Throwable e) {
Log.e(TAG, "onError: " + Thread.currentThread().getName());
}
@Override
public void onComplete() {
Log.e(TAG, "onComplete: " + Thread.currentThread().getName());
}
});07-23 12:27:53.341 2809-2809/com.example E/RXActivity: onSubscribe: main
07-23 12:27:53.351 2809-3899/com.example E/RXActivity: subscribe: RxCachedThreadScheduler-1
07-23 12:27:53.381 2809-2809/com.example E/RXActivity: 100 onNext: mainjust操作符
Observable.just(3, 6, 7).subscribeOn(Schedulers.io()).observeOn(AndroidSchedulers.mainThread())
.subscribe(new Consumer<Integer>() {
@Override
public void accept(Integer integer) throws Exception {
Log.e(TAG, integer + " accept: " + Thread.currentThread().getName());
}
});07-23 12:31:30.041 2809-2809/com.example E/RXActivity: 3 accept: main
07-23 12:31:30.041 2809-2809/com.example E/RXActivity: 6 accept: main
07-23 12:31:30.041 2809-2809/com.example E/RXActivity: 7 accept: mainfrom 操作符
Observable.fromArray(3, 6, 7).subscribeOn(Schedulers.io()).observeOn(AndroidSchedulers.mainThread())
.subscribe(new Consumer<Integer>() {
@Override
public void accept(Integer integer) throws Exception {
Log.e(TAG, integer + " accept: " + Thread.currentThread().getName());
}
});07-23 12:33:06.721 2809-2809/com.example E/RXActivity: 3 accept: main
07-23 12:33:06.721 2809-2809/com.example E/RXActivity: 6 accept: main
07-23 12:33:06.721 2809-2809/com.example E/RXActivity: 7 accept: mainrepeat操作符 重複執行
Observable.just(1,3).repeat(3)
.subscribe(new Consumer<Integer>() {
@Override
public void accept(Integer integer) throws Exception {
Log.e(TAG, "accept: " + integer );
}
});07-23 12:39:45.031 18092-18092/com.example E/RXActivity: accept: 1
07-23 12:39:45.031 18092-18092/com.example E/RXActivity: accept: 3
07-23 12:39:45.031 18092-18092/com.example E/RXActivity: accept: 1
07-23 12:39:45.031 18092-18092/com.example E/RXActivity: accept: 3
07-23 12:39:45.031 18092-18092/com.example E/RXActivity: accept: 1
07-23 12:39:45.031 18092-18092/com.example E/RXActivity: accept: 3defer 使用defer可以延遲被訂閱者的生成，也就是被訂閱者是在訂閱發生時才生成
Observable mObservable =
Observable.defer(new Callable<ObservableSource<? extends String>>() {
@Override
public ObservableSource<? extends String> call() throws Exception {
return Observable.just(s);
}
});
s = "bbbb";
mObservable.subscribe(new Consumer<String>() {
@Override
public void accept(String s) throws Exception {
Log.e(TAG, s + " accept: " + Thread.currentThread().getName());
}
});07-23 12:47:30.251 18092-18092/com.example E/RXActivity: bbbb accept: mainrange 創建一個發射指定範圍的整數序列的Observable，第一個參數是從哪個數開始，第二個參數是連續的n個值
Observable.range(2,4)
.subscribe(new Consumer<Integer>() {
@Override
public void accept(Integer integer) throws Exception {
Log.e(TAG, "accept: " + integer );
}
});07-23 12:51:31.671 29485-29485/com.example E/RXActivity: accept: 2
07-23 12:51:31.671 29485-29485/com.example E/RXActivity: accept: 3
07-23 12:51:31.671 29485-29485/com.example E/RXActivity: accept: 4
07-23 12:51:31.671 29485-29485/com.example E/RXActivity: accept: 5interval 操作符既可以延遲執行一段邏輯，也可以間隔執行一段邏輯，timer也可以只是過時了
Observable.interval(2, 1, TimeUnit.SECONDS)
.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.subscribe(new Consumer<Long>() {
@Override
public void accept(Long aLong) throws Exception {
Log.e(TAG, aLong + " accept: " + Thread.currentThread().getName());
}
});07-23 12:58:59.121 5924-5924/com.example E/RXActivity: 0 accept: main
07-23 12:59:00.121 5924-5924/com.example E/RXActivity: 1 accept: main
07-23 12:59:01.121 5924-5924/com.example E/RXActivity: 2 accept: maindelay 延時執行
Observable.create(new ObservableOnSubscribe<Integer>() {
@Override
public void subscribe(ObservableEmitter<Integer> e) throws Exception {
e.onNext(1000);
}
}).delay(1000, TimeUnit.MILLISECONDS).subscribe(new Consumer<Integer>() {
@Override
public void accept(Integer integer) throws Exception {
Log.e(TAG, integer + " accept: " + Thread.currentThread().getName());
}
});如果您還想了解更多，可以添加公衆號：
