RxJava's self-introduction on the GitHub home page is "a library for composing asynchronous and event-based programs using observable sequences for the Java VM" (a library for composing asynchronous, event-based programs using observable sequences on the Java VM ).
Easiest to use:
Observable.create(new ObservableOnSubscribe<String>() {
@Override
public void subscribe(ObservableEmitter<String> emitter) throws Exception {
emitter.onNext("The first");
emitter.onNext("Second Article");
emitter.onComplete();
// emitter.onError(new Exception("ssfas"));
}
}).subscribe(new Observer<String>() {
@Override
public void onSubscribe(Disposable d) {
Log.i(TAG,"--------onSubscribe------");
}
@Override
public void onNext(String s) {
Log.i(TAG,"--------onNext------："+s);
}
@Override
public void onError(Throwable e) {
Log.i(TAG,"--------onError------");
}
@Override
public void onComplete() {
Log.i(TAG,"--------onComplete------");
}
});
Flowable：
/**
* BackpressureStrategy.ERROR----128
* BackpressureStrategy.BUFFE----unlimited
* BackpressureStrategy.DROP-----discard the unsaved--128
* BackpressureStrategy.LATEST---keep the latest -----128
* Corresponding method:
* onBackpressureBuffer()
* onBackpressureDrop()
* onBackpressureLatest()
*
*/
Flowable<String> flowable=Flowable.create(new FlowableOnSubscribe<String>() {
@Override
public void subscribe(FlowableEmitter<String> emitter) throws Exception {
emitter.onNext("111111111111");
emitter.onNext("2222222222222");
emitter.onNext("3333333333333");
emitter.onNext("4444444444444");
emitter.onComplete();
}
}, BackpressureStrategy.ERROR);
Subscriber<String> subscriber=new Subscriber<String>() {
@Override
public void onSubscribe(Subscription s) {
Log.i(TAG,"---onSubscribe---");
s.request(Long.MAX_VALUE);
}
@Override
public void onNext(String s) {
Log.i(TAG,s);
}
@Override
public void onError(Throwable t) {
Log.i(TAG,"---onError---");
}
@Override
public void onComplete() {
Log.i(TAG,"---onComplete---");
}
};
flowable.subscribe(subscriber);
Thread switch:
Observer<String> observer=new Observer<String>() {
@Override
public void onSubscribe(Disposable d) {
Log.i(TAG,"--------onSubscribe------："+Thread.currentThread().getName());
compositeDisposable.add(d);
}
@Override
public void onNext(String s) {
Log.i(TAG,"--------onNext------："+Thread.currentThread().getName());
}
@Override
public void onError(Throwable e) {
Log.i(TAG,"--------onError------");
}
@Override
public void onComplete() {
Log.i(TAG,"--------onComplete------"+Thread.currentThread().getName());
}
};
Observable<String> observable=Observable.create(new ObservableOnSubscribe<String>() {
@Override
public void subscribe(ObservableEmitter<String> emitter) throws Exception {
Log.i(TAG,"--------Observable------"+Thread.currentThread().getName());
emitter.onNext("The first");
emitter.onComplete();
}
});
observable.subscribeOn(Schedulers.computation())//1、Schedulers.newThread()2、Schedulers.io()3、Schedulers.computation()
.observeOn(AndroidSchedulers.mainThread())//The main thread that comes with android
.subscribe(observer);
map operator:
Conversion operators, such as in this example, convert int to String and print
Observable.create(new ObservableOnSubscribe<Integer>() {
@Override
public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
emitter.onNext(1);
emitter.onNext(2);
emitter.onNext(3);
}
}).map(new Function<Integer, String>() {
@Override
public String apply(Integer integer) throws Exception {
return "This is the first: "+integer+" instruction";
}
}).subscribe(new Observer<String>() {
@Override
public void onSubscribe(Disposable d) {
}
@Override
public void onNext(String s) {
Log.i(TAG,s);
}
@Override
public void onError(Throwable e) {
}
@Override
public void onComplete() {
}
});
flatMap operator:
This operator is actually to send another Observable. For example, if you need to log in after registration, you can use this operator
final String[][] name={{"111","1111","11111"},
{"222","2222","22222"},
{"333","3333","33333"}};
Observable.fromArray(name).flatMap(new Function<String[], ObservableSource<?>>() {
@Override
public ObservableSource<?> apply(String[] str) throws Exception {
return Observable.fromArray(str);
};
}).subscribe(new Observer<Object>() {
@Override
public void onSubscribe(Disposable d) {
}
@Override
public void onNext(Object o) {
Log.i(TAG,(String)o);
}
@Override
public void onError(Throwable e) {
}
@Override
public void onComplete() {
}
});
filter operator:
Filter events, Observer only processes events that return true in filter
Observable.create(new ObservableOnSubscribe<Integer>() {
@Override
public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
for (int i=0;i<100;i++){
emitter.onNext(i);
}
}
}).filter(new Predicate<Integer>() {
@Override
public boolean test(Integer integer) throws Exception {
return integer%10==0;
}
}).subscribe(new Observer<Integer>() {
@Override
public void onSubscribe(Disposable d) {
}
@Override
public void onNext(Integer integer) {
Log.i(TAG, "The filtered data is: "+integer);
}
@Override
public void onError(Throwable e) {
}
@Override
public void onComplete() {
}
});
zip operator:
Combining two sent events
Observable<String> observable1=Observable.create(new ObservableOnSubscribe<String>() {
@Override
public void subscribe(ObservableEmitter<String> emitter) throws Exception {
emitter.onNext("111");
emitter.onNext("222");
emitter.onNext("333");
emitter.onComplete();
}
}).subscribeOn(Schedulers.newThread());
Observable<String> observable2=Observable.create(new ObservableOnSubscribe<String>() {
@Override
public void subscribe(ObservableEmitter<String> emitter) throws Exception {
emitter.onNext("AAA");
emitter.onNext("BBB");
emitter.onNext("CCC");
emitter.onNext("DDD");
emitter.onComplete();
}
}).subscribeOn(Schedulers.newThread());
Observable.zip(observable1, observable2, new BiFunction<String, String, String>() {
@Override
public String apply(String s, String s2) throws Exception {
return s+s2;
}
}).subscribe(new Observer<String>() {
@Override
public void onSubscribe(Disposable d) {
}
@Override
public void onNext(String s) {
Log.i(TAG,s);
}
@Override
public void onError(Throwable e) {
}
@Override
public void onComplete() {
Log.i(TAG,"-------complete---------");
}
});
Other brief introductions:
concat: It is also a combination of sending observables, but it is different from zip. For example, when event 1 is sent, 1, 2, and 3 are sent, and event 2 is sent, and a, b, and c are sent, then the result of zip is 1a, 2b, 3c , and the result of concat is 1,2,3,a,b,c
concatMap: The same function as flatMap, but concatMap is ordered, while flatMap is unordered
distinct: filter out identical events
timer: indicates how long it will be executed, only once
interval: timed task, indicating that it will be executed once soon