用来创建一个新的可观察对象,下面介绍一些常用创建操作符
- create 直接创建一个可观察对象
- just 将一个对象或一组对象转换为发出该对象或那些对象的可观察对象
- fromArray/fromIterable 一组对象转换为发出该对象或那些对象的可观察对象
- defer 在观察者订阅之前不会创建可观察对象，订阅行为发生时才为每个观察者创建一个新的可观对象
- interval 创建一个可观察对象，该可观察对象发出一个以指定时间间隔分隔的整数序列
- timer 创建一个在给定延迟后发出单个项目的可观察对象
- rang 创建一个发出一系列连续整数范围的可观察对象
- empty 创建一个不发射任何项目但正常终止的可观察对象
- error 创建一个不发出任何项目并终止并显示错误的可观察对象
- never 创建不发出任何项目且不终止的可观察对象
//create 操作符 使用
private void createOperator(){
Observable.create(new ObservableOnSubscribe() {
@Override
public void subscribe(@NonNull ObservableEmitter emitter) throws Throwable {
//emitter 发射器用来发射 事件
emitter.onNext("hello");
emitter.onNext("RxJava");
// onComplete 事件发发射后,可以继续onNext事件,但下面观察者不会再接收事件
// onComplete 事件与onError 事件互斥
// onComplete 后再发射onError 会出异常.崩溃
// onError 后再发射 onComplete 接收error后 不再接收任何事件
emitter.onError(new Throwable("出错了"));
emitter.onComplete();
}
}).subscribe(new Observer() {
@Override
public void onSubscribe(@NonNull Disposable d) {
//onSubscribe 一旦订阅,会立马回调此方法
Log.i("operator create", "onSubscribe: ");
}
@Override
public void onNext(@NonNull String s) {
//上面发射 onNext 事件 ,此处就可以收到
Log.i("operator create", "onNext");
}
@Override
public void onError(@NonNull Throwable e) {
//上面发射 onError 事件,此处可以收到
Log.i("operator create", "onError");
}
@Override
public void onComplete() {
//上面发射 onComplete 事件,此处可以收到
Log.i("operator create", "onComplete");
}
});
}
just 操作符的使用
just 操作符创建一个可观察者对象,再订阅后,自动将一个或多个对象使用onNext发射出去,最后再发射onComplete事件.
//just操作符
private void justOperator(){
//自动发射一个onNext事件
Observable just = Observable.just(1);
//自动发射多个onNext事件,内部实际使用fromArray 操作符创建可观察对象
Observable just1 = Observable.just("hello", "world");
//Consumer 消费者,如果只想关注onNext 事件,不关注其他事件的接收,可以只传递一个Consumer对象
//当然此方法也有重载方法,可观察一个或多个事件 传递两个就是关注 next error 三个就是 next error complete
just.subscribe(new Consumer() {
@Override
public void accept(Integer integer) throws Throwable {
Log.i("operator ", "accept: " + integer);
}
});
just1.subscribe(new Consumer() {
@Override
public void accept(String s) throws Throwable {
Log.i("operator just", "accept: " + s);
}
});
}
fromArray/fromIterable操作符的使用
fromArray 传递一组同类型的对象.返回一个可观察者对象,订阅后,将这组数据对象依次发出.
fromIterable 传递 Iterable<@NonNull ? extends T> 将集合中对象 依次发出
//fromArray/fromIterable
private void fromOperator() {
//fromArray
Observable integerObservable = Observable.fromArray(1, 2, 3);
Observable stringObservable = Observable.fromArray("a", "b", "c");
integerObservable.subscribe(integer -> {
Log.i("operator fromArray", " " + integer);
});
stringObservable.subscribe(s -> {
Log.i("operator fromArray", " " + s);
});
//fromIterable
List list = new ArrayList<>();
list.add("hello");
list.add("RxJava");
list.add("RxAndroid");
Observable.fromIterable(list).subscribe(s -> {
Log.i("operator fromIterable", " " + s);
});
}
defer 操作符的使用
defer 操作符会延迟创建可观察者对象,只有当调用subscribe时,才会调用get() 方法去自己创建一个可观察对象,每次订阅都会创建一个新的可观察对象
private void deferOperator() {
Observable defer = Observable.defer(new Supplier>() {
@Override
public ObservableSource get() throws Throwable {
//下面定于代码被注释掉时,此处方法不会被调用,也就是说下面return 的可观察者对象不会被创建,
//放开注释,当订阅代码调用时,再观察者 onSubscribe之前 就会调用get()方法来创建可观察者对象
Log.i("operator defer", " defer get ");
return Observable.just("a", "b", "c");
}
});
// defer. subscribe(new Observer() {
// @Override
// public void onSubscribe(@NonNull Disposable d) {
// Log.i("operator defer","defer onSubscribe");
//
// }
//
// @Override
// public void onNext(@NonNull String s) {
// Log.i("operator defer","defer onNext : " +s);
//
// }
//
// @Override
// public void onError(@NonNull Throwable e) {
// Log.i("operator defer","defer onError");
//
// }
//
// @Override
// public void onComplete() {
// Log.i("operator defer","defer onComplete");
//
// }
// });
}
interval 操作符的使用
以指定间隔时间 发送从0开始的整数序列
//interval
private void intervalOperator() {
//arg1 : 延迟几秒发射
//arg2 : 发射间隔时间
//arg3 : 时间单位
Observable interval= Observable.interval(2L, 2L, TimeUnit.SECONDS);
// 开始每隔两秒发送从0开始的整数序列
interval.subscribe(aLong -> Log.i("operator interval", "interval onNext : " + aLong));
}
rang操作符的使用
private void rangOperator() {
// 发送 3-9 的连续整数
Observable.range(3, 9).subscribe(new Consumer() {
@Override
public void accept(Integer integer) throws Throwable {
Log.i("operator range", "range onNext : " + integer);
}
});
}
timer 操作符的使用
private void timerOperator() {
//延迟一秒 开始发射事件(只发射一次)
Observable timer = Observable.timer(1000L, TimeUnit.MILLISECONDS);
timer.subscribe(aLong -> Log.i("operator timer", "timer onNext : " + aLong));
}
empty / error /never
此三个操作符使用特别简单,就不上代码了
empty 操作符创建一个不发射任何项目单正常终止的可观察对象, 观察者处会回调 onSubscribe 及onComplete
error操作符 创建一个不发射任何项目并显示错误的可观察对象.会回调onSubscribe 及onError
never操作符 创建不发出任何项目且不终止的可观察对象,今会回调onSubscribe
end还有其他一些不常使用的,实际用到了再去研究…
