In the last section we learned about thread switching in RxJava. Today we will start to learn its powerful operators. Some people may ask, what are the operators used for? In my opinion, the operator is like the soul of rxjava, which runs through the entire life cycle of the observed and the observer, from creation, to subscription, to data transmission, to unsubscription and other links. Okay, let's start our study next.
Create operator
create () operator
- Method preview:
public static <T> Observable<T> create(ObservableOnSubscribe<T> source) {
- effect:
Create an observer
- how to use
Observable<String> mObservable = Observable.create(new ObservableOnSubscribe<String>() {
emitter.onNext(" 1");
emitter.onNext("2");
emitter.onNext("3");
emitter.onNext("4");
emitter.onComplete();
emitter.onNext(" 1");
emitter.onNext(" 2");
}
});
- Actual combat
Observable<String> mObservable = Observable.create(new ObservableOnSubscribe<String>() { // 1.创建 Observable对象
@Override
public void subscribe(ObservableEmitter<String> emitter) throws Exception {
emitter.onNext(" 1");
emitter.onNext("2");
emitter.onNext("3");
emitter.onNext("4");
emitter.onComplete();
emitter.onNext(" 1");
emitter.onNext(" 2");
}
});
Observer<String> mObserver = new Observer<String>() { // 2.创建observer
@Override
public void onSubscribe(Disposable d) {
Log.d(TAG, "onSubscribe: ");
}
@Override
public void onNext(String s) {
Log.d(TAG, "onNext: " + s);
}
@Override
public void onError(Throwable e) {
Log.d(TAG, "onError: " + e);
}
@Override
public void onComplete() {
Log.d(TAG, "onComplete: ");
}
};
mObservable.subscribe(mObserver);// 3.开始调用
As you can see, through the create () operator, we created an Observable observer, rewriting the subscribe () method to emit data through the ObservableEmitter.
just () operator
- Method preview
public static <T> Observable<T> just(T item1, T item2, T item3, T item4, T item5, T item6) { }
- Function and characteristics
Create an observed person and send events. The number of sent events cannot exceed 10.
- how to use
Observable.just(1,2,3,4,5,6).subscribe(new Observer<Integer>() {
private Disposable mDisposable;
@Override
public void onSubscribe(Disposable d) {
mDisposable=d;
Log.d(TAG, "onSubscribe: " + d.isDisposed());
}
@Override
public void onNext(Integer s) {
Log.d(TAG, "onNext: 接收到的数据是:"+s);
if (s>3){
mDisposable.dispose();
}
}
@Override
public void onError(Throwable e) {
}
@Override
public void onComplete() {
}
});
from operator
The RxJava2 from operator mainly operates the following four. It can create Observables that send arrays, Iterables, and asynchronous tasks.
//数组
public static <T> Observable<T> fromArray(T... items)
//集合
public static <T> Observable<T> fromIterable(Iterable<? extends T> source)
//异步任务
public static <T> Observable<T> fromFuture(Future<? extends T> future)
//异步任务+超时时间
public static <T> Observable<T> fromFuture(Future<? extends T> future, long timeout, TimeUnit unit)
//异步任务+超时时间+线程调度器
public static <T> Observable<T> fromFuture(Future<? extends T> future, long timeout, TimeUnit unit, Scheduler scheduler)
//异步任务+线程调度器
public static <T> Observable<T> fromFuture(Future<? extends T> future, Scheduler scheduler)
//Reactive Streams中的发布者，使用方式类似create操作符，事件的发送由发布者(被观察者)自行决定
public static <T> Observable<T> fromPublisher(Publisher<? extends T> publisher)
fromArray () operator
- Method preview
public static <T> Observable<T> fromArray(T... items) { ...}
-
Function and characteristics:
- Just like just, you can send data, load the data in the form of an array, and then send, you can send more than 10 data.
- By looking at the source code of just (), we can see that the data sent by just () is actually loading the data in an array and sending it from fromArray (). Lite version in case.
@CheckReturnValue @NonNull @SchedulerSupport(SchedulerSupport.NONE) public static <T> Observable<T> just(T item1, T item2, T item3, T item4) { ObjectHelper.requireNonNull(item1, "item1 is null"); ObjectHelper.requireNonNull(item2, "item2 is null"); ObjectHelper.requireNonNull(item3, "item3 is null"); ObjectHelper.requireNonNull(item4, "item4 is null"); return fromArray(item1, item2, item3, item4); } -
how to use
String[] strArray = {"kotlin","java","python","C++"};
Observable<String>observable1=Observable.fromArray(strArray);
fromIterable () operator
- Method preview
public static <T> Observable<T> fromIterable(Iterable<? extends T> source) {...}
- effect
Create an observer and send the collection directly to the observer. We know that since the data sent can be single or multiple sub-developed, or it can be sent in the form of an array, can we send the collection directly, of course, through the formIterable () operator achieve.
- how to use
List<String> list = new ArrayList<>();
list.add("kotlin");
list.add("java");
list.add("C++");
list.add("python");
Observable.fromIterable(list);
fromCallable () operator
- Method preview
public static <T> Observable<T> fromCallable(Callable<? extends T> supplier) { }
- effect
Callable is located under the java.util.concurrent package, similar to Runnable, but with a return value. The event emitted from fromCallable is sent from the main thread. To receive the emission value of Observable, use observeOn to switch to the Main thread.
- how to use
Observable.fromCallable(new Callable<String>() {
@Override
public String call() throws Exception {
return "测试一下";
}
}).subscribe(new Observer<String>() {
@Override
public void onSubscribe(Disposable d) {
}
@Override
public void onNext(String s) {
System.out.println("onNext():"+"接收到的数据为"+s+"\n所在线程为:"+Thread.currentThread().getName());
}
@Override
public void onError(Throwable e) {
}
@Override
public void onComplete() {
}
});
fromFuture () operator
public static <T> Observable<T> fromFuture(Future<? extends T> future) {...}
When we introduced the from operator, fromFuture () has four overloaded methods, namely:
//异步任务
public static <T> Observable<T> fromFuture(Future<? extends T> future)
//异步任务+超时时间
public static <T> Observable<T> fromFuture(Future<? extends T> future, long timeout, TimeUnit unit)
//异步任务+超时时间+线程调度器
public static <T> Observable<T> fromFuture(Future<? extends T> future, long timeout, TimeUnit unit, Scheduler scheduler)
//异步任务+线程调度器
public static <T> Observable<T> fromFuture(Future<? extends T> future, Scheduler scheduler)
For fromFuture (), it is similar to Runnable, but the difference is that Runnable will not return the result after execution, and fromFuture () will return the execution result to the observer.
// 异步任务
FutureTask<Integer> mFutureTask = new FutureTask<>(new Callable<Integer>() {
@Override
public Integer call() throws Exception {
System.out.println("---------开始执行任务------"+Thread.currentThread().getName());
Thread.sleep(3000); // 延时3秒以计算1+2+3+4+...并将结果返回
int sum = 0;
for (int i = 0; i <= 10; i++) {
sum += i;
}
return sum;
}
});
Observable.
fromFuture(mFutureTask)
.doOnSubscribe(new Consumer<Disposable>() {
@Override
public void accept(Disposable disposable) throws Exception {
mFutureTask.run();
}
})
.subscribe(new Observer<Integer>() {
@Override
public void onSubscribe(Disposable d) {
}
@Override
public void onNext(Integer integer) {
System.out.println("---------处理完毕并接收数据为:------"+integer+" "+Thread.currentThread().getName());
}
@Override
public void onError(Throwable e) {
System.out.println("---------处理失败了:------"+e+Thread.currentThread().getName());
}
@Override
public void onComplete() {
}
} );
}
In the above program, we delayed the calculation by 3 seconds and then returned the result to the subscribed observer.
Well, today I will mainly introduce so much. The next article will continue to learn other powerful operators of Rxjava.
