本章节讲述RxJava基于2.X版本的过滤操作符
1.Filter()
<1> 作用
过滤 特定条件的事件。
<2> 代码
package com.example.rxjava20;
import android.os.Bundle;
import android.util.Log;
import androidx.appcompat.app.AppCompatActivity;
import io.reactivex.Observable;
import io.reactivex.ObservableEmitter;
import io.reactivex.ObservableOnSubscribe;
import io.reactivex.Observer;
import io.reactivex.disposables.Disposable;
import io.reactivex.functions.Predicate;
public class MainActivity extends AppCompatActivity {
private Disposable disposable;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
method();
}
/**
* 创建 RxJava Filter()过滤操作符
*/
public void method() {
Observable.create(new ObservableOnSubscribe<Object>() {
@Override
public void subscribe(ObservableEmitter<Object> e) throws Exception {
if (e == null) {
return;
}
//没有切断与观察者的关联 发送Int类型的数据
if (!e.isDisposed()) {
e.onNext(1);
e.onNext(2);
e.onNext(3);
e.onNext(4);
e.onNext(5);
e.onNext(6);
e.onComplete();
}
}
}).filter(new Predicate<Object>() {
@Override
public boolean test(Object o) throws Exception {
if (null == o) {
return false;
}
int num = (int) o;
if (num == 4) {//过滤4
return false;//过滤 返回 false
}
return true;
}
}).subscribe(new Observer<Object>() {
@Override
public void onSubscribe(Disposable d) {
if (null == d) {
return;
}
disposable = d;
Log.d("TAG", "观察者 onSubscribe方法 是否断开连接:" + disposable.isDisposed());
}
@Override
public void onNext(Object value) {
Log.d("TAG", "观察者 onNext方法 结果:" + value.toString());
}
@Override
public void onError(Throwable e) {
}
@Override
public void onComplete() {
}
});
}
/**
* onDestroy方法
*/
@Override
protected void onDestroy() {
super.onDestroy();
if (null != disposable) {
Log.d("TAG", "onDestroy方法 执行时是否断开----:" + disposable.isDisposed());
if (!disposable.isDisposed()) {//没有断开
disposable.dispose();//断开
Log.d("TAG", "onDestroy方法 断开订阅");
}
}
}
}
<3> 结果
D/TAG: 观察者 onSubscribe方法 是否断开连接:false
D/TAG: 观察者 onNext方法 结果:1
D/TAG: 观察者 onNext方法 结果:2
D/TAG: 观察者 onNext方法 结果:3
D/TAG: 观察者 onNext方法 结果:5
D/TAG: 观察者 onNext方法 结果:6
<4> 关闭页面
D/TAG: onDestroy方法 执行时是否断开----:true
2.ofType()
<1> 作用
过滤 保留 特定数据类型的数据。
<2> 代码
package com.example.rxjava20;
import android.os.Bundle;
import android.util.Log;
import androidx.appcompat.app.AppCompatActivity;
import io.reactivex.Observable;
import io.reactivex.ObservableEmitter;
import io.reactivex.ObservableOnSubscribe;
import io.reactivex.Observer;
import io.reactivex.disposables.Disposable;
public class MainActivity extends AppCompatActivity {
private Disposable disposable;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
method();
}
/**
* 创建 RxJava ofType()过滤操作符
*/
public void method() {
Observable.create(new ObservableOnSubscribe<Object>() {
@Override
public void subscribe(ObservableEmitter<Object> e) throws Exception {
if (e == null) {
return;
}
//没有切断与观察者的关联 发送Int类型的数据
if (!e.isDisposed()) {
e.onNext(1);
e.onNext(2);
e.onNext("张三");
e.onNext("326");
e.onNext(5);
e.onNext("过滤");
e.onComplete();
}
}
}).ofType(String.class)//过滤 只保留 字符串类型
.subscribe(new Observer<Object>() {
@Override
public void onSubscribe(Disposable d) {
if (null == d) {
return;
}
disposable = d;
Log.d("TAG", "观察者 onSubscribe方法 是否断开连接:" + disposable.isDisposed());
}
@Override
public void onNext(Object value) {
Log.d("TAG", "观察者 onNext方法 结果:" + value.toString());
}
@Override
public void onError(Throwable e) {
}
@Override
public void onComplete() {
}
});
}
/**
* onDestroy方法
*/
@Override
protected void onDestroy() {
super.onDestroy();
if (null != disposable) {
Log.d("TAG", "onDestroy方法 执行时是否断开----:" + disposable.isDisposed());
if (!disposable.isDisposed()) {//没有断开
disposable.dispose();//断开
Log.d("TAG", "onDestroy方法 断开订阅");
}
}
}
}
<3> 结果
D/TAG: 观察者 onSubscribe方法 是否断开连接:false
D/TAG: 观察者 onNext方法 结果:张三
D/TAG: 观察者 onNext方法 结果:326
D/TAG: 观察者 onNext方法 结果:过滤
<4> 关闭页面
D/TAG: onDestroy方法 执行时是否断开----:true
3.skip() &skipLast()
<1> 作用
跳过某个事件。
skip():过滤掉 正序第N个。
skipLast():过滤掉 倒叙后N个。
<2> 代码
package com.example.rxjava20;
import android.os.Bundle;
import android.util.Log;
import androidx.appcompat.app.AppCompatActivity;
import io.reactivex.Observable;
import io.reactivex.ObservableEmitter;
import io.reactivex.ObservableOnSubscribe;
import io.reactivex.Observer;
import io.reactivex.disposables.Disposable;
public class MainActivity extends AppCompatActivity {
private Disposable disposable;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
method();
}
/**
* 创建 RxJava skip()&skipLast()过滤操作符
*/
public void method() {
Observable.create(new ObservableOnSubscribe<Object>() {
@Override
public void subscribe(ObservableEmitter<Object> e) throws Exception {
if (e == null) {
return;
}
//没有切断与观察者的关联 发送Int类型的数据
if (!e.isDisposed()) {
e.onNext(1);
e.onNext(2);
e.onNext("张三");
e.onNext("326");
e.onNext(5);
e.onNext("过滤");
e.onComplete();
}
}
}).skip(1)//过滤掉 正序第一个
.skipLast(4)//过滤掉 倒叙后四个
.subscribe(new Observer<Object>() {
@Override
public void onSubscribe(Disposable d) {
if (null == d) {
return;
}
disposable = d;
Log.d("TAG", "观察者 onSubscribe方法 是否断开连接:" + disposable.isDisposed());
}
@Override
public void onNext(Object value) {
Log.d("TAG", "观察者 onNext方法 结果:" + value.toString());
}
@Override
public void onError(Throwable e) {
}
@Override
public void onComplete() {
}
});
}
/**
* onDestroy方法
*/
@Override
protected void onDestroy() {
super.onDestroy();
if (null != disposable) {
Log.d("TAG", "onDestroy方法 执行时是否断开----:" + disposable.isDisposed());
if (!disposable.isDisposed()) {//没有断开
disposable.dispose();//断开
Log.d("TAG", "onDestroy方法 断开订阅");
}
}
}
}
<3> 结果
D/TAG: 观察者 onSubscribe方法 是否断开连接:false
D/TAG: 观察者 onNext方法 结果:2
<4> 关闭页面
D/TAG: onDestroy方法 执行时是否断开----:true
4. distinct()&distinctUntilChanged()
<1> 作用
过滤事件序列中重复的事件 / 连续重复的事件。
distinct():过滤 重复数据。
distinctUntilChanged():过滤 连续数据。
<2> 代码
package com.example.rxjava20;
import android.os.Bundle;
import android.util.Log;
import androidx.appcompat.app.AppCompatActivity;
import io.reactivex.Observable;
import io.reactivex.ObservableEmitter;
import io.reactivex.ObservableOnSubscribe;
import io.reactivex.Observer;
import io.reactivex.disposables.Disposable;
public class MainActivity extends AppCompatActivity {
private Disposable disposable;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
method();
}
/**
* 创建 RxJava distinct()过滤操作符
*/
public void method() {
Observable.create(new ObservableOnSubscribe<Object>() {
@Override
public void subscribe(ObservableEmitter<Object> e) throws Exception {
if (e == null) {
return;
}
//没有切断与观察者的关联 发送Int类型的数据
if (!e.isDisposed()) {
e.onNext(1);
e.onNext(5);
e.onNext("张三");
e.onNext("张三");
e.onNext(4);
e.onNext(5);
e.onComplete();
}
}
}).distinct()//过滤 重复数据
.subscribe(new Observer<Object>() {
@Override
public void onSubscribe(Disposable d) {
if (null == d) {
return;
}
disposable = d;
Log.d("TAG", "观察者 onSubscribe方法 是否断开连接:" + disposable.isDisposed());
}
@Override
public void onNext(Object value) {
Log.d("TAG", "观察者 onNext方法 结果:" + value.toString());
}
@Override
public void onError(Throwable e) {
}
@Override
public void onComplete() {
}
});
}
/**
* onDestroy方法
*/
@Override
protected void onDestroy() {
super.onDestroy();
if (null != disposable) {
Log.d("TAG", "onDestroy方法 执行时是否断开----:" + disposable.isDisposed());
if (!disposable.isDisposed()) {//没有断开
disposable.dispose();//断开
Log.d("TAG", "onDestroy方法 断开订阅");
}
}
}
}
<3> 结果
D/TAG: 观察者 onSubscribe方法 是否断开连接:false
D/TAG: 观察者 onNext方法 结果:1
D/TAG: 观察者 onNext方法 结果:5
D/TAG: 观察者 onNext方法 结果:张三
D/TAG: 观察者 onNext方法 结果:4
<4> 关闭页面
D/TAG: onDestroy方法 执行时是否断开----:true
<5> 代码
.distinctUntilChanged()//过滤 连续数据
<6> 结果
D/TAG: 观察者 onSubscribe方法 是否断开连接:false
D/TAG: 观察者 onNext方法 结果:1
D/TAG: 观察者 onNext方法 结果:5
D/TAG: 观察者 onNext方法 结果:张三
D/TAG: 观察者 onNext方法 结果:4
D/TAG: 观察者 onNext方法 结果:5
<7>关闭页面
D/TAG: onDestroy方法 执行时是否断开----:true
5.take()&takeLast()
<1> 作用
take():指定观察者最多能接收到的事件数量。
takeLast():指定观察者只能接收到被观察者发送的最后几个事件。
<2> 代码
package com.example.rxjava20;
import android.os.Bundle;
import android.util.Log;
import androidx.appcompat.app.AppCompatActivity;
import io.reactivex.Observable;
import io.reactivex.ObservableEmitter;
import io.reactivex.ObservableOnSubscribe;
import io.reactivex.Observer;
import io.reactivex.disposables.Disposable;
public class MainActivity extends AppCompatActivity {
private Disposable disposable;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
method();
}
/**
* 创建 RxJava take()过滤操作符
*/
public void method() {
Observable.create(new ObservableOnSubscribe<Object>() {
@Override
public void subscribe(ObservableEmitter<Object> e) throws Exception {
if (e == null) {
return;
}
//没有切断与观察者的关联 发送Int类型的数据
if (!e.isDisposed()) {
e.onNext(1);
e.onNext(5);
e.onNext("张三");
e.onNext("张三");
e.onNext(4);
e.onNext(5);
e.onComplete();
}
}
}).take(2)//最多能接收 2个数据
.subscribe(new Observer<Object>() {
@Override
public void onSubscribe(Disposable d) {
if (null == d) {
return;
}
disposable = d;
Log.d("TAG", "观察者 onSubscribe方法 是否断开连接:" + disposable.isDisposed());
}
@Override
public void onNext(Object value) {
Log.d("TAG", "观察者 onNext方法 结果:" + value.toString());
}
@Override
public void onError(Throwable e) {
}
@Override
public void onComplete() {
}
});
}
/**
* onDestroy方法
*/
@Override
protected void onDestroy() {
super.onDestroy();
if (null != disposable) {
Log.d("TAG", "onDestroy方法 执行时是否断开----:" + disposable.isDisposed());
if (!disposable.isDisposed()) {//没有断开
disposable.dispose();//断开
Log.d("TAG", "onDestroy方法 断开订阅");
}
}
}
}
<3> 结果
D/TAG: 观察者 onSubscribe方法 是否断开连接:false
D/TAG: 观察者 onNext方法 结果:1
D/TAG: 观察者 onNext方法 结果:5
<4> 关闭页面
D/TAG: onDestroy方法 执行时是否断开----:true
<5> 代码
.takeLast(3)//只能接收到被观察者发送的最后 3 个事件
<6> 结果
D/TAG: 观察者 onSubscribe方法 是否断开连接:false
D/TAG: 观察者 onNext方法 结果:张三
D/TAG: 观察者 onNext方法 结果:4
D/TAG: 观察者 onNext方法 结果:5
<7>关闭页面
D/TAG: onDestroy方法 执行时是否断开----:false
D/TAG: onDestroy方法 断开订阅
6.throttleFirst()&throttleLast()
<1> 作用
在某段时间内,只发送该段时间内第1次事件&最后1次事件。
throttleFirst():第1次事件。
throttleLast():最后1次事件。
throttleFirst(long windowDuration, TimeUnit unit):参数1:每XX时间第一次出现 参数2:时间单位。
throttleFirst(long skipDuration, TimeUnit unit, Scheduler scheduler):参数1:每XX时间第一次出现 参数2:时间单位 参数3:线程调度类。
<2> 代码
package com.example.rxjava20;
import android.os.Bundle;
import android.util.Log;
import androidx.appcompat.app.AppCompatActivity;
import java.util.concurrent.TimeUnit;
import io.reactivex.Observable;
import io.reactivex.ObservableEmitter;
import io.reactivex.ObservableOnSubscribe;
import io.reactivex.Observer;
import io.reactivex.disposables.Disposable;
public class MainActivity extends AppCompatActivity {
private Disposable disposable;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
method();
}
/**
* 创建 RxJava throttleFirst()过滤操作符
*/
public void method() {
Observable.create(new ObservableOnSubscribe<Object>() {
@Override
public void subscribe(ObservableEmitter<Object> e) throws Exception {
if (null == e) {
return;
}
/**
* 为了测试 模拟 0.5秒执行一次onNext方法发送一次数据
* */
if (!e.isDisposed()) {
e.onNext(1);
e.onNext(2);
Thread.sleep(500);
e.onNext(3);
Thread.sleep(500);
e.onNext(4);
Thread.sleep(500);
e.onNext(5);
Thread.sleep(500);
e.onComplete();
}
}
}).throttleFirst(1, TimeUnit.SECONDS)//每1秒内的第一次
.subscribe(new Observer<Object>() {
@Override
public void onSubscribe(Disposable d) {
if (null == d) {
return;
}
disposable = d;
Log.d("TAG", "观察者 onSubscribe 方法 是否断开连接----:" + disposable.isDisposed());
}
@Override
public void onNext(Object value) {
Log.d("TAG", "观察者 onNext 方法 value.toString()----:" + value.toString());
}
@Override
public void onError(Throwable e) {
}
@Override
public void onComplete() {
}
});
}
/**
* onDestroy方法
*/
@Override
protected void onDestroy() {
super.onDestroy();
if (null != disposable) {
Log.d("TAG", "onDestroy方法 执行时是否断开----:" + disposable.isDisposed());
if (!disposable.isDisposed()) {//没有断开
disposable.dispose();//断开
Log.d("TAG", "onDestroy方法 断开订阅");
}
}
}
}
<3> 结果
D/TAG: 观察者 onSubscribe 方法 是否断开连接----:false
D/TAG: 观察者 onNext 方法 value.toString()----:1
D/TAG: 观察者 onNext 方法 value.toString()----:4
<4> 关闭页面
D/TAG: onDestroy方法 执行时是否断开----:true
<5> 代码
throttleLast(long windowDuration, TimeUnit unit):参数1:每XX时间最后出现 参数2:时间单位。
throttleLast(long skipDuration, TimeUnit unit, Scheduler scheduler):参数1:每XX时间最后出现 参数2:时间单位 参数3:线程调度类。
.throttleLast(1, TimeUnit.SECONDS)//每1秒内的最后一次
<3> 结果
D/TAG: 观察者 onSubscribe 方法 是否断开连接----:false
D/TAG: 观察者 onNext 方法 value.toString()----:3
D/TAG: 观察者 onNext 方法 value.toString()----:5
<4> 关闭页面
D/TAG: onDestroy方法 执行时是否断开----:true
8.Sample()
<1> 作用
在某段时间内,只发送该段时间内最后1次事件。和throttleFirst方法作用相当。
sample(long period, TimeUnit unit):参数1:每XX时间最后出现 参数2:时间单位。
sample(long period, TimeUnit unit, Scheduler scheduler):每XX时间最后出现 参数2:时间单位 参数3:线程调度类。
<2> 代码
package com.example.rxjava20;
import android.os.Bundle;
import android.util.Log;
import androidx.appcompat.app.AppCompatActivity;
import java.util.concurrent.TimeUnit;
import io.reactivex.Observable;
import io.reactivex.ObservableEmitter;
import io.reactivex.ObservableOnSubscribe;
import io.reactivex.Observer;
import io.reactivex.disposables.Disposable;
public class MainActivity extends AppCompatActivity {
private Disposable disposable;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
method();
}
/**
* 创建 RxJava Sample()过滤操作符
*/
public void method() {
Observable.create(new ObservableOnSubscribe<Object>() {
@Override
public void subscribe(ObservableEmitter<Object> e) throws Exception {
if (null == e) {
return;
}
/**
* 为了测试 模拟 0.5秒执行一次onNext方法发送一次数据
* */
if (!e.isDisposed()) {
e.onNext(1);
e.onNext(2);
Thread.sleep(500);
e.onNext(3);
Thread.sleep(500);
e.onNext(4);
Thread.sleep(500);
e.onNext(5);
Thread.sleep(500);
e.onComplete();
}
}
}).sample(1, TimeUnit.SECONDS)//每1秒内的最后一次
.subscribe(new Observer<Object>() {
@Override
public void onSubscribe(Disposable d) {
if (null == d) {
return;
}
disposable = d;
Log.d("TAG", "观察者 onSubscribe 方法 是否断开连接----:" + disposable.isDisposed());
}
@Override
public void onNext(Object value) {
Log.d("TAG", "观察者 onNext 方法 value.toString()----:" + value.toString());
}
@Override
public void onError(Throwable e) {
}
@Override
public void onComplete() {
}
});
}
/**
* onDestroy方法
*/
@Override
protected void onDestroy() {
super.onDestroy();
if (null != disposable) {
Log.d("TAG", "onDestroy方法 执行时是否断开----:" + disposable.isDisposed());
if (!disposable.isDisposed()) {//没有断开
disposable.dispose();//断开
Log.d("TAG", "onDestroy方法 断开订阅");
}
}
}
}
<3> 结果
D/TAG: 观察者 onSubscribe 方法 是否断开连接----:false
D/TAG: 观察者 onNext 方法 value.toString()----:3
D/TAG: 观察者 onNext 方法 value.toString()----:5
<4> 关闭页面
D/TAG: onDestroy方法 执行时是否断开----:true
8. throttleWithTimeout()
<1> 作用
若2次发送事件的间隔 小于 指定时间。不发送前一次的数据。直到指定时间内都没有新数据发射时才会发送后一次的数据。
throttleWithTimeout(long timeout, TimeUnit unit):参数1:两次事件时间间隔小于XX 参数2:时间单位
throttleWithTimeout(long timeout, TimeUnit unit, Scheduler scheduler):参数1:两次事件时间间隔小于XX 参数2:时间单位 参数3:线程调度类
<2> 代码
package com.example.rxjava20;
import android.os.Bundle;
import android.util.Log;
import androidx.appcompat.app.AppCompatActivity;
import java.util.concurrent.TimeUnit;
import io.reactivex.Observable;
import io.reactivex.ObservableEmitter;
import io.reactivex.ObservableOnSubscribe;
import io.reactivex.Observer;
import io.reactivex.disposables.Disposable;
public class MainActivity extends AppCompatActivity {
private Disposable disposable;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
method();
}
/**
* 创建 RxJava throttleWithTimeout()过滤操作符
*/
public void method() {
Observable.create(new ObservableOnSubscribe<Object>() {
@Override
public void subscribe(ObservableEmitter<Object> e) throws Exception {
if (null == e) {
return;
}
/**
* 为了测试 模拟 0.5秒执行一次onNext方法发送一次数据
* */
if (!e.isDisposed()) {
e.onNext(1);
e.onNext(2);
Thread.sleep(500);
e.onNext(3);
Thread.sleep(500);
e.onNext(4);
Thread.sleep(500);
e.onNext(5);
Thread.sleep(500);
e.onComplete();
}
}
}).throttleWithTimeout(1, TimeUnit.SECONDS)//若2次发送事件的间隔 小于1秒 则不发送数据 知道最后一次
.subscribe(new Observer<Object>() {
@Override
public void onSubscribe(Disposable d) {
if (null == d) {
return;
}
disposable = d;
Log.d("TAG", "观察者 onSubscribe 方法 是否断开连接----:" + disposable.isDisposed());
}
@Override
public void onNext(Object value) {
Log.d("TAG", "观察者 onNext 方法 value.toString()----:" + value.toString());
}
@Override
public void onError(Throwable e) {
}
@Override
public void onComplete() {
}
});
}
/**
* onDestroy方法
*/
@Override
protected void onDestroy() {
super.onDestroy();
if (null != disposable) {
Log.d("TAG", "onDestroy方法 执行时是否断开----:" + disposable.isDisposed());
if (!disposable.isDisposed()) {//没有断开
disposable.dispose();//断开
Log.d("TAG", "onDestroy方法 断开订阅");
}
}
}
}
<3> 结果
D/TAG: 观察者 onSubscribe 方法 是否断开连接----:false
D/TAG: 观察者 onNext 方法 value.toString()----:5
<4> 关闭页面
D/TAG: onDestroy方法 执行时是否断开----:true
9.firstElement()&lastElement()
<1> 作用
仅选取第1条数据&最后一条数据。
<2> 代码
package com.example.rxjava20;
import android.os.Bundle;
import android.util.Log;
import androidx.appcompat.app.AppCompatActivity;
import io.reactivex.Observable;
import io.reactivex.ObservableEmitter;
import io.reactivex.ObservableOnSubscribe;
import io.reactivex.functions.Consumer;
public class MainActivity extends AppCompatActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
method();
}
/**
* 创建 RxJava firstElement()过滤操作符
*/
public void method() {
Observable.create(new ObservableOnSubscribe<Object>() {
@Override
public void subscribe(ObservableEmitter<Object> e) throws Exception {
if (null == e) {
return;
}
if (!e.isDisposed()) {
e.onNext(1);
e.onNext(2);
e.onNext(3);
e.onNext(4);
e.onNext(5);
e.onComplete();
}
}
}).firstElement()//只取第一条数据
.subscribe(new Consumer<Object>() {
@Override
public void accept(Object o) throws Exception {
if (null == o) {
return;
}
Log.d("TAG", "观察者 accept 方法 o.toString()----:" + o.toString());
}
});
}
}
<3> 结果
D/TAG: 观察者 accept 方法 o.toString()----:1
<4> 代码
.lastElement()//只取最后一条数据
<5> 结果
D/TAG: 观察者 accept 方法 o.toString()----:5
10.elementAt()&elementAtOrError()
<1> 作用
通过 索引值 确定 接收指定消息。
elementAt():通过 索引值 确定 接收指定消息。
elementAtOrError():通过 索引值 确定 接收指定消息。 错误时有区别。当出现越界情况(即获取的位置索引 > 发送事件序列长度)时,即抛出异常。
elementAt(long index):参数1:索引index
elementAt(long index, T defaultItem) 参数1:索引index 参数2:默认值 当前索引取不到值时使用
<2> 代码
package com.example.rxjava20;
import android.os.Bundle;
import android.util.Log;
import androidx.appcompat.app.AppCompatActivity;
import io.reactivex.Observable;
import io.reactivex.ObservableEmitter;
import io.reactivex.ObservableOnSubscribe;
import io.reactivex.functions.Consumer;
public class MainActivity extends AppCompatActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
method();
}
/**
* 创建 RxJava elementAt()过滤操作符
*/
public void method() {
Observable.create(new ObservableOnSubscribe<Object>() {
@Override
public void subscribe(ObservableEmitter<Object> e) throws Exception {
if (null == e) {
return;
}
if (!e.isDisposed()) {
e.onNext(1);
e.onNext(2);
e.onNext(3);
e.onNext(4);
e.onNext(5);
e.onComplete();
}
}
}).elementAt(4)//接收索引为4的消息
.subscribe(new Consumer<Object>() {
@Override
public void accept(Object o) throws Exception {
if (null == o) {
return;
}
Log.d("TAG", "观察者 accept 方法 o.toString()----:" + o.toString());
}
});
}
}
<3> 结果
D/TAG: 观察者 accept 方法 o.toString()----:5
如果
.elementAt(10)//接收索引为10的消息
结果
无接收内容。即索引值可以越界。越界不会报错,但是会出现无消息可接收的问题。
如果 即 索引值越界 但设置默认值
.elementAt(10, 3)//接收索引为10的消息 默认值3
结果 显示默认值
D/TAG: 观察者 accept 方法 o.toString()----:3
如果 即 索引值正常 但也设置默认值
.elementAt(4, 3)//接收索引为4的消息 默认值3
结果 显示正确的值
D/TAG: 观察者 accept 方法 o.toString()----:5