之前学习了一些Rxjava2的操作符在此记录一下,以后用到了方便查询
import android.os.Bundle;
import android.support.annotation.NonNull;
import android.support.v7.app.AppCompatActivity;
import android.text.TextUtils;
import android.util.Log;
import android.widget.TextView;
import com.example.administrator.myapplication.R;
import org.reactivestreams.Subscriber;
import org.reactivestreams.Subscription;
import java.util.List;
import java.util.concurrent.TimeUnit;
import io.reactivex.BackpressureStrategy;
import io.reactivex.Flowable;
import io.reactivex.FlowableEmitter;
import io.reactivex.FlowableOnSubscribe;
import io.reactivex.Observable;
import io.reactivex.ObservableEmitter;
import io.reactivex.ObservableOnSubscribe;
import io.reactivex.ObservableSource;
import io.reactivex.Observer;
import io.reactivex.Single;
import io.reactivex.SingleObserver;
import io.reactivex.android.schedulers.AndroidSchedulers;
import io.reactivex.disposables.CompositeDisposable;
import io.reactivex.disposables.Disposable;
import io.reactivex.functions.Action;
import io.reactivex.functions.BiFunction;
import io.reactivex.functions.Consumer;
import io.reactivex.functions.Function;
import io.reactivex.functions.Function3;
import io.reactivex.functions.Predicate;
import io.reactivex.schedulers.Schedulers;
public class RxStudyMainActivity extends AppCompatActivity {
public static final String TAG = RxStudyMainActivity.class.getSimpleName();
private CompositeDisposable compositeDisposable;
private Disposable mDisposable;
private TextView search_src_text;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_rx_study_main);
search_src_text = findViewById(R.id.search_src_text);
compositeDisposable = new CompositeDisposable();
//test1(); //flatMap、map操作符 区别在于 flatMap返回的是一个 Observable对象,map则不是
//test2(); //zip操作符
//test3(); //create操作符
//test4(); //interval操作符
//test5(); //BackpressureStrategy
//test6(); //concat操作符
//test7(); //distinct操作符
//test8(); //filter操作符
//test9(); //buffer操作符
//test10(); //interval操作符
//test11(); //skip操作符
//test12(); //Single操作符
//test13(); //debounce操作符
//test14(); //defer操作符
//test15(); //last操作符
//test16(); //concat、merge操作符
//test17(); //reduce操作符
//test18(); //scan操作符
//test19(); //window操作符
//test20(); //retryWhen操作符
//test21(); //repeatWhen操作符
//test22(); //switchMap操作符
//test23(); //switchIfEmpty操作符
//test24(); //combineLatest操作符
//test25(); //takeWhile操作符
}
int totalCount = 5;
private void test25() {//takeWhile 判断条件与filter操作符类似
Observable.interval(1, 1, TimeUnit.SECONDS).takeWhile(new Predicate() {
@Override
public boolean test(Long aLong) throws Exception {
return aLong <= totalCount;
}
}).flatMap(new Function>() {
@Override
public ObservableSource apply(Long aLong) throws Exception {
long l = totalCount - aLong;
if (l == 0) {
return Observable.just(true); //
} else {
Log.e(TAG, "takeWhile 没倒完,还剩" + l + "秒");
return Observable.just(false);
}
}
}).subscribe(new Consumer() {
@Override
public void accept(Boolean aBoolean) throws Exception {
if (aBoolean)
Log.e(TAG, "takeWhile 已经倒完了");
}
});
}
private void test24() {//combineLatest 合并最新的事件,(不是最后一个事件的都只会发射当前事件源中最近最新的事件,该事件会联合最后的事件源的所有事件分别进行发送)
//与zip不同之处 :zip每个事件源都会发射所有的事件,combineLatest则不会
//zip属于一一对应,combineLatest 属于一对多的关系
Observable observable1 = Observable.create(new ObservableOnSubscribe() {
@Override
public void subscribe(ObservableEmitter e) throws Exception {
e.onNext("1");
e.onNext("2");
e.onNext("3");
}
});
Observable observable2 = Observable.create(new ObservableOnSubscribe() {
@Override
public void subscribe(ObservableEmitter e) throws Exception {
e.onNext("4");
e.onNext("5");
e.onNext("6");
}
});
Observable observable3 = Observable.create(new ObservableOnSubscribe() {
@Override
public void subscribe(ObservableEmitter e) throws Exception {
e.onNext("7");
e.onNext("8");
e.onNext("9");
}
});
Observable.combineLatest(observable1, observable2, observable3, new Function3() {
@Override
public Integer apply(String s, String s2, String s3) throws Exception {
Log.e(TAG, "apply s==" + s + ",,,, s2==" + s2 + ",,,, s3==" + s3);
return Integer.parseInt(s) + Integer.parseInt(s2) + Integer.parseInt(s3);
}
}).subscribe(new Consumer() {
@Override
public void accept(Integer integer) throws Exception {
Log.e(TAG, "combineLatest执行了 " + integer);
}
});
}
private void test23() {//switchIfEmpty 也可以用来实现缓存策略
//如果原来的Observable没有发射任何数据,则使用switchIfEmpty里的Observable代替原来的Observable。
Observable.create(new ObservableOnSubscribe() {
@Override
public void subscribe(ObservableEmitter e) throws Exception {
e.onNext("");
e.onComplete();
}
}).filter(new Predicate() {
@Override
public boolean test(String s) throws Exception {
return !TextUtils.isEmpty(s);
}
}).switchIfEmpty(new ObservableSource() {
@Override
public void subscribe(Observer observer) {
Log.e(TAG, "switchIfEmpty执行了 ");
}
}).subscribe(new Consumer() {
@Override
public void accept(String s) throws Exception {
Log.e(TAG, "switchIfEmpty s== " + s);
}
});
}
private void test22() {//switchMap 只会发射最近最新的这一次请求(可用来优化搜索功能)
Observable.create(new ObservableOnSubscribe() {
@Override
public void subscribe(ObservableEmitter e) throws Exception {
e.onNext("23");
e.onNext("24");
e.onNext("");
e.onNext("25");
// e.onNext(""); //会执行,但条件不允许,会被拦截,不会发射请求
}
}).debounce(2, TimeUnit.MILLISECONDS)
.filter(new Predicate() { //2秒之后发射
@Override
public boolean test(String s) throws Exception {
return !TextUtils.isEmpty(s);//不能为空或空字符串
}
}).switchMap(new Function>() { //发射最近的这一次
@Override
public ObservableSource apply(String s) throws Exception {
return Observable.fromArray(s);
}
}).subscribe(new Consumer() {
@Override
public void accept(String s) throws Exception {
Log.e(TAG, "switchMap " + s);
}
}, new Consumer() {
@Override
public void accept(Throwable throwable) throws Exception {
Log.e(TAG, "switchMap 异常了" + throwable.getMessage());
}
});
}
private void test21() {//repeatWhen 只会在onComplete执行之后才会触发repeatWhen
Observable.create(new ObservableOnSubscribe() {
@Override
public void subscribe(ObservableEmitter e) throws Exception {
e.onNext("ss");
e.onComplete();
}
}).repeatWhen(new Function, ObservableSource>() {
@Override
public ObservableSource apply(Observable objectObservable) throws Exception {
return objectObservable.delay(3, TimeUnit.SECONDS);//定期轮询执行
}
}).subscribe(new Consumer() {
@Override
public void accept(String s) throws Exception {
}
}, new Consumer() {
@Override
public void accept(Throwable throwable) throws Exception {
}
}, new Action() {
int repeatCount;
@Override
public void run() throws Exception {
Log.e(TAG, "repeatWhen 重试次数 repeatCount " + (++repeatCount));
}
});
}
private void test20() { //retryWhen 重新请求 有异常就会触发
Observable.create(new ObservableOnSubscribe() {
@Override
public void subscribe(ObservableEmitter e) throws Exception {
e.onNext("");
}
}).doOnNext(new Consumer() {
@Override
public void accept(String s) throws Exception {
Log.e(TAG, null);
}
}).retryWhen(new Function, ObservableSource>() {
int retryTotalCount = 5;
int retryCount;
@Override
public ObservableSource apply(Observable throwableObservable) throws Exception {
return throwableObservable.flatMap(new Function>() {
@Override
public ObservableSource apply(Throwable throwable) throws Exception {
if (++retryCount < retryTotalCount) {
Log.e(TAG, "retryWhen 重试第 " + retryCount + "次");
return Observable.timer(3000, TimeUnit.MILLISECONDS);
}
return Observable.error(throwable);
}
});
}
}).subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.subscribe(new Consumer() {
@Override
public void accept(String s) throws Exception {
Log.e(TAG, "retryWhen 已完成 ");
}
}, new Consumer() {
@Override
public void accept(Throwable throwable) throws Exception {
Log.e(TAG, "Throwable 异常了 ");
}
});
}
private void test19() {
Observable.interval(1, TimeUnit.SECONDS) // 间隔一秒发一次
.take(15) // 最多接收15个
.window(3, 3)
.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.subscribe(new Consumer>() {
@Override
public void accept(@NonNull Observable longObservable) throws Exception {
Log.e(TAG, "Sub Divide begin...\n");
longObservable.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.subscribe(new Consumer() {
@Override
public void accept(@NonNull Long aLong) throws Exception {
Log.e(TAG, "Next:" + aLong + "\n");
}
});
}
});
}
private void test18() { //scan 与reduce用法一样,区别在于scan会把每步的结果输出,reduce只是把最终结果输出
Observable.just(1, 2, 3, 4).scan(0, new BiFunction() {
@Override
public Integer apply(Integer integer, Integer integer2) throws Exception {
Log.e(TAG, "integer === " + integer);
Log.e(TAG, "integer2 === " + integer2);
return integer + integer2;
}
}).subscribe(new Consumer() {
@Override
public void accept(Integer integer) throws Exception {
Log.e(TAG, "scan === " + integer);
}
});
}
private void test17() {//reduce 可以设置初始值,不设置默认为数据中的第一个 integer是每次操作返回的新值,integer2为数据中的值
Observable.just(1, 2, 3, 4).reduce(0, new BiFunction() {
@Override
public Integer apply(Integer integer, Integer integer2) throws Exception {
Log.e(TAG, "integer === " + integer);
Log.e(TAG, "integer2 === " + integer2);
return integer + integer2;
}
}).subscribe(new Consumer() {
@Override
public void accept(Integer integer) throws Exception {
Log.e(TAG, "reduce === " + integer);
}
});
}
private void test16() { //merge是无序合并(cacheObservable不执行onComplete,netObservable也会执行)
// concat是有序合并 (cacheObservable不执行onComplete,netObservable不会执行)
Observable cacheObservable = Observable.create(new ObservableOnSubscribe() {
@Override
public void subscribe(ObservableEmitter e) throws Exception {
Log.d(TAG, "cacheObservable 执行了");
e.onNext(1);
}
});
Observable netObservable = Observable.create(new ObservableOnSubscribe() {
@Override
public void subscribe(ObservableEmitter e) throws Exception {
Log.d(TAG, "netObservable 执行了");
e.onNext(0);
}
});
Observable.merge(cacheObservable, netObservable).subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread()).subscribe(new Consumer() {
@Override
public void accept(Integer integer) throws Exception {
Log.e(TAG, "concat === " + integer);
}
});
}
private void test15() {
Observable.just(1).last(10000).subscribe(new Consumer() {
@Override
public void accept(Integer integer) throws Exception {
Log.e(TAG, "last == " + integer);
}
});
}
int a = 10;
private void test14() {//defer 直到有订阅,才会创建Observable ,具有延时的效果。 代码一和代码二的区别
// 在a=10时,虽然定义了一个Observable,但是并没有创建这个示例(这是重点),当a=12时,这时候订阅这个Observable,则开始创建,所以对象中的a为12.
//对比代码一
Observable observable = Observable.just("just result: " + a);//订阅之前就会执行
a = 12;
observable.subscribe(new Consumer() {
@Override
public void accept(String s) throws Exception { //后执行
Log.e(TAG, "just result == " + s);
}
});
//对比代码二
/*Observable o2 =
Observable.defer(new Callable>() { //call方法订阅之后才会执行
@Override
public ObservableSource call() throws Exception {
return Observable.just("call == " + a);
}
});
a = 12;
o2.subscribe(new Consumer() {
@Override
public void accept(String s) throws Exception {
Log.e(TAG, "defer result:" + s);
}
});*/
}
private void test13() {//debounce 去除少于参数时长的事件(排除)
Observable.create(new ObservableOnSubscribe() {
@Override
public void subscribe(ObservableEmitter emitter) throws Exception {
emitter.onNext(1); // skip
Thread.sleep(400);
emitter.onNext(2); // deliver
Thread.sleep(505);
emitter.onNext(3); // skip
Thread.sleep(100);
emitter.onNext(4); // deliver
Thread.sleep(605);
emitter.onNext(5); // deliver
Thread.sleep(510);
emitter.onComplete();
}
}).debounce(500, TimeUnit.MILLISECONDS).subscribeOn(Schedulers.io()).observeOn(AndroidSchedulers.mainThread()).subscribe(new Consumer() {
@Override
public void accept(Integer integer) throws Exception {
Log.e(TAG, "debounce accept == " + integer);
}
});
}
private void test12() {// Single 单一执行,只允许一个参数
Single.just(5).subscribe(new SingleObserver() {
@Override
public void onSubscribe(Disposable d) {
Log.e(TAG, "Single onSubscribe == " + d.isDisposed());
}
@Override
public void onSuccess(Integer value) {
Log.e(TAG, "Single onSuccess == " + value);
}
@Override
public void onError(Throwable e) {
Log.e(TAG, "Single onError == " + e.getMessage());
}
});
}
private void test11() {
Observable.just(1, 2, 3, 4, 5, 6, 7, 8).skip(2) //跳过几个
.take(2)//获取几个
.subscribe(new Consumer() {
@Override
public void accept(Integer integer) throws Exception {
Log.e(TAG, "skip take == " + integer);//输出3,4
}
});
}
private void test10() {//interval是运行在新的线程当中
Observable.interval(0, 1, TimeUnit.SECONDS).subscribeOn(Schedulers.io()).doOnNext(new Consumer() {
@Override
public void accept(Long aLong) throws Exception {
Log.e(TAG, "aLong== " + aLong);//aLong为累加之后的数值
Log.e(TAG, "Thread Name == " + Thread.currentThread().getName());
}
}).observeOn(AndroidSchedulers.mainThread()).subscribe(new Consumer() {
@Override
public void accept(Long aLong) throws Exception {
Log.e(TAG, "Thread Name == " + Thread.currentThread().getName());
}
});
}
private void test9() { //buffer 参数意义:count从第一位取到第几位,skip 从第一位跳过多少位之后的位置开始算起
Observable.just(1, 2, 3, 4, 5, 6, 7, 8).buffer(6, 5).subscribe(new Consumer>() {
@Override
public void accept(List integers) throws Exception {
Log.e(TAG, "buffer size : " + integers.size());
Log.e(TAG, "buffer value : ");
for (Integer i : integers) {
Log.e(TAG, "buffer == " + i);
}
}
});
}
private void test8() {//distinct 去重 filter过滤
Observable.just(1, 2, 3, 10, 18, 2, 3, 6, 3).distinct().filter(new Predicate() {
@Override
public boolean test(Integer integer) throws Exception {
Log.e(TAG, "test " + integer);
return integer > 10;
}
}).subscribe(new Consumer() {
@Override
public void accept(Integer integer) throws Exception {
Log.e(TAG, "accept " + integer);
}
});
}
private void test7() {
Observable.just(1, 2, 2, 2, 2, 2, 3, 4).distinct(new Function() {
@Override
public String apply(Integer integer) throws Exception {
Log.e(TAG, "apply " + integer);
return integer + "";
}
}).subscribe(new Consumer() {
@Override
public void accept(Integer integer) throws Exception {
Log.e(TAG, "accept " + integer);
}
});
}
private void test6() {//concat 连接 事件是顺序的 (如果最开始的事件的onNext执行了的话,配合first操作符,可实现缓存策略)
//concat会三个数据源都会请求的。如何使得哪层有数据就用哪层的,之后就不走后面的逻辑了。
//可以配合first()操作符来实现这样的效果。
Observable cacheObservable = Observable.create(new ObservableOnSubscribe() {
@Override
public void subscribe(ObservableEmitter e) throws Exception {
Log.d(TAG, "cacheObservable 执行了");
if (1 == 0) {
e.onNext(1);
}
e.onComplete();
}
});
Observable diskObservable = Observable.create(new ObservableOnSubscribe() {
@Override
public void subscribe(ObservableEmitter e) throws Exception {
Log.d(TAG, "netObservable 执行了");
e.onNext(2);
e.onComplete();
}
});
Observable netObservable = Observable.create(new ObservableOnSubscribe() {
@Override
public void subscribe(ObservableEmitter e) throws Exception {
Log.d(TAG, "netObservable 执行了");
e.onNext(3);
e.onComplete();
}
});
Observable.concat(cacheObservable, diskObservable, netObservable).first(2).subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread()).subscribe(new Consumer() {
@Override
public void accept(Integer integer) throws Exception {
Log.e(TAG, "concat === " + integer);
}
});
}
private void test5() {
Flowable
.create(new FlowableOnSubscribe() {
@Override
public void subscribe(final FlowableEmitter emitter) throws Exception {
Log.d(TAG, "before emit, requested = " + emitter.requested());
Log.d(TAG, "emit 1");
emitter.onNext(1);
Log.d(TAG, "after emit 1, requested = " + emitter.requested());
Log.d(TAG, "emit 2");
emitter.onNext(2);
Log.d(TAG, "after emit 2, requested = " + emitter.requested());
Log.d(TAG, "emit 3");
emitter.onNext(3);
Log.d(TAG, "after emit 3, requested = " + emitter.requested());
Log.d(TAG, "emit complete");
emitter.onComplete();
Log.d(TAG, "after emit complete, requested = " + emitter.requested());
}
}, BackpressureStrategy.ERROR)
.subscribe(new Subscriber() {
@Override
public void onSubscribe(Subscription s) {
Log.d(TAG, "onSubscribe");
s.request(2); //request 2
}
@Override
public void onNext(Integer integer) {
Log.d(TAG, "onNext: " + integer);
}
@Override
public void onError(Throwable t) {
Log.w(TAG, "onError: ", t);
}
@Override
public void onComplete() {
Log.d(TAG, "onComplete");
}
});
}
private void test4() {
Flowable.interval(1, TimeUnit.MICROSECONDS).onBackpressureDrop()
.observeOn(AndroidSchedulers.mainThread())
.subscribe(new Subscriber() {
@Override
public void onSubscribe(Subscription s) {
s.request(Long.MAX_VALUE);
}
@Override
public void onNext(Long aLong) {
}
@Override
public void onError(Throwable t) {
}
@Override
public void onComplete() {
}
});
}
private void test3() {
Flowable.create(new FlowableOnSubscribe() {
@Override
public void subscribe(FlowableEmitter e) throws Exception {
Log.e(TAG, "上游1 -- 哈哈哈");
e.onNext("哈哈哈");
Log.e(TAG, "上游1 -- 嘿嘿嘿");
e.onNext("嘿嘿嘿");
Log.e(TAG, "上游1 -- 啦啦啦");
e.onNext("啦啦啦");
e.onComplete();
}
}, BackpressureStrategy.ERROR)/*.subscribeOn(Schedulers.io()).observeOn(AndroidSchedulers.mainThread())*/.subscribe(new Subscriber() {
@Override
public void onSubscribe(Subscription s) {
Log.e(TAG, "onSubscribe");
s.request(3);
}
@Override
public void onNext(String string) {
Log.e(TAG, "onNext: " + string);
}
@Override
public void onError(Throwable t) {
Log.e(TAG, "onError: ", t);
}
@Override
public void onComplete() {
Log.e(TAG, "onComplete");
}
});
}
public void test2() {//zip 可以将多个 Observable 的数据结合为一个数据源再发射出去
// 例如一个页面多个接口时可使用zip操作符。以最少的事件数量为准,多余的将舍弃掉
Observable stringObservable = Observable.create(new ObservableOnSubscribe() {
@Override
public void subscribe(ObservableEmitter e) throws Exception {
Log.e(TAG, "上游1 -- 哈哈哈");
e.onNext("哈哈哈");
//e.onComplete();
}
}).subscribeOn(Schedulers.io());
Observable booleanObservable = Observable.create(new ObservableOnSubscribe() {
@Override
public void subscribe(ObservableEmitter e) throws Exception {
Log.e(TAG, "上游2 -- true");
e.onNext(true);
Log.e(TAG, "上游2 -- false");
e.onNext(false);
Log.e(TAG, "上游2 -- false");
e.onNext(false);
//e.onComplete();
}
}).subscribeOn(Schedulers.io());
Observable.zip(stringObservable, booleanObservable, new BiFunction() {
@Override
public String apply(String s, Boolean aBoolean) throws Exception {
Log.e(TAG, "apply " + s + aBoolean);
return s + aBoolean;
}
}).subscribe(new Consumer() {
@Override
public void accept(String s) throws Exception {
Log.e(TAG, "下游Consumer" + s);
}
});
}
public void test1() {
Observable integerObservable = Observable.create(new ObservableOnSubscribe() {
@Override
public void subscribe(ObservableEmitter e) throws Exception {
Log.e(TAG, "上游 Thread Name==" + Thread.currentThread().getName());
e.onNext(1);
}
});
integerObservable
.subscribeOn(Schedulers.io())
.map(new Function() {
@Override
public String apply(Integer integer) throws Exception {
return "map转换之后的数据";
}
})
.flatMap(new Function>() {
@Override
public ObservableSource apply(String string) throws Exception {
Log.e(TAG, "flatMap ---- " + string);
return Observable.fromArray("sdf").delay(10, TimeUnit.SECONDS);
}
})
.observeOn(AndroidSchedulers.mainThread())
.doOnNext(new Consumer() {
@Override
public void accept(String s) throws Exception {
Log.e(TAG, "doOnNext ---- " + s);
}
})
.subscribe(new Observer() {
@Override
public void onSubscribe(Disposable d) {
mDisposable = d;
}
@Override
public void onNext(String value) {
search_src_text.setText(value);
}
@Override
public void onError(Throwable e) {
}
@Override
public void onComplete() {
}
});
}
public void test() {
Observable.create(new ObservableOnSubscribe() {
@Override
public void subscribe(ObservableEmitter e) throws Exception {
e.onNext(1);
e.onNext(2);
e.onError(new Exception());
}
}).subscribe(new Consumer() {
@Override
public void accept(Integer integer) throws Exception {
Log.e(TAG, "Consumer");
}
}, new Consumer() {
@Override
public void accept(Throwable throwable) throws Exception {
Log.e(TAG, "Throwable");
}
}, new Action() {
@Override
public void run() throws Exception {
Log.e(TAG, "Action");
}
}, new Consumer() {
@Override
public void accept(Disposable disposable) throws Exception {
Log.e(TAG, "Disposable");
}
});
}
@Override
protected void onResume() {
super.onResume();
if (compositeDisposable.size() <= 0 && null != mDisposable) {
compositeDisposable.add(mDisposable);
}
}
@Override
protected void onStop() {
super.onStop();
if (compositeDisposable.size() > 0 && !compositeDisposable.isDisposed()) {
compositeDisposable.dispose();
compositeDisposable.clear();
}
}
}