版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/fengluoye2012/article/details/79193861
简介
之前一篇文章讲解了RxJava2.0-操作符-Transforming和内部转换逻辑及原理，现在来看下Filtering(过滤操作符 ),
主要有以下几个方法：
filter（）：只发射满足特定条件的项；
distinct（）：过滤重复项；
skip（）：从0开始，跳过前count项；也就是说从count+1项开始发送；
skipLast（）:从count+1项开始跳过；也就是说发送前count项；和skip（）用法相反；
take（）：只发送前count项；如果总项数小于count,全部发送；
takeLast（）：发射后count项；如果总项数小于count,全部发送
elementAt（）：发射第几项
first（）：发送第一项，默认值不能为空；
last（）：最后项，默认值不能为空 ；
用法
filter（）：只发射满足特定条件的项；
List<Integer> list = new ArrayList<>();
list.add(1);
list.add(2);
list.add(3);
list.add(4);
Observable.fromIterable(list)
//Predicate接口返回boolean类型；返回true,该项执行发送;false过滤掉该项；
.filter(new Predicate<Integer>() {
@Override
public boolean test(@NonNull Integer integer) throws Exception {
return integer % 2 == 0;
}
}).subscribe(new Consumer<Integer>() {
@Override
public void accept(Integer integer) throws Exception {
Log.e(tag, "filter:" + String.valueOf(integer));
}
});
运行结果
distinct（）：过滤重复项；
Observable.just("1", "2", "4", "2", "1")
.distinct()
.subscribe(new Consumer<String>() {
@Override
public void accept(String s) throws Exception {
Log.e(tag, "distinct:" + s);
}
});
运行结果
skip（）：从0开始，跳过前count项；也就是说从count+1项开始发送；
Observable.just("1", "2", "4")
.skip(2)
.subscribe(new Consumer<String>() {
@Override
public void accept(String s) throws Exception {
Log.e(tag, "skip:" + s);
}
});
运行结果
skipLast（）:从count+1项开始跳过；也就是说发送前count项；和skip（）用法相反；
Observable.just("1", "2", "4")
.skipLast(2)
.subscribe(new Consumer<String>() {
@Override
public void accept(String s) throws Exception {
Log.e(tag, "skipLast:" + s);
}
});
运行结果
take（）：只发送前count项；如果总项数小于count,全部发送；
Observable.just("1", "2", "4")
.take(2)
.subscribe(new Consumer<String>() {
@Override
public void accept(String s) throws Exception {
Log.e(tag, "take:" + s);
}
});
运行结果
takeLast（）：发射后count项；如果总项数小于count,全部发送
Observable.just("1", "2", "4")
.takeLast(2)
.subscribe(new Consumer<String>() {
@Override
public void accept(String s) throws Exception {
Log.e(tag, "takeLast:" + s);
}
});
运行结果
elementAt（）：发射第几项
Observable.just("1", "2", "4")
.elementAt(2)//第几项
.subscribe(new Consumer<String>() {
@Override
public void accept(String s) throws Exception {
Log.e(tag, "elementAt:" + s);
}
});
运行结果
first（）：发送第一项，默认值不能为空；
Observable.just("1", "2", "4")
.first("0")//默认项
.subscribe(new Consumer<String>() {
@Override
public void accept(String s) throws Exception {
Log.e(tag, "first:" + s);
}
});
运行结果
last（）：最后项，默认值不能为空 ；
Observable.just("1", "2", "4")
.last("0")//默认项
.subscribe(new Consumer<String>() {
@Override
public void accept(String s) throws Exception {
Log.e(tag, "last:" + s);
}
});
运行结果
原理
以上就是Filtering的用法；其内部原理可参考RxJava2.0-操作符-Transforming和内部转换逻辑及原理，逻辑基本一致；
List<Integer> list = new ArrayList<>();
list.add(1);
list.add(2);
list.add(3);
list.add(4);
Observable.fromIterable(list)
//Predicate接口返回boolean类型；返回true,该项执行发送;false过滤掉该项；
.filter(new Predicate<Integer>() {
@Override
public boolean test(@NonNull Integer integer) throws Exception {
return integer % 2 == 0;
}
}).subscribe(new Consumer<Integer>() {
@Override
public void accept(Integer integer) throws Exception {
Log.e(tag, "filter:" + String.valueOf(integer));
}
});
以上面的demo为例
通过fromIterable发射的事件，ObservableFilter类中的内部类FilterObserver订阅该Observable；在ObservableFromIterable类中调用actual.onNext(v)发送事件之后；FilterObserver 接收事件，执行onNext（）方法，在onNext()方法中，调用filter.test(t)，返回值为true,actual.onNext(t)将事件发送出去。
其实Transforming，Filtering等操作符都是通过多层的发送事件-订阅-接收事件-发送事件-订阅-接收循环，实现各种转换，过滤，转化等操作；
Combining操作符用来组合多个Observable发送的事件；
主要方法：
1）zipWith（）：将两个Observable发送的数据，根据一定的规则组合在一起，然后返回组合的结果；
2）startWith（）：startWith在前面加的事件前面，添加若干项事件；
3）merge（）：将两个Observable发送的事件，按照时间先后顺序排序
用法
1)zipWith（）：将两个Observable发送的数据，根据一定的规则组合在一起，然后返回组合的结果；
Observable.just("1", "2", "4", "2", "1")
.zipWith(new Observable<String>() {
@Override
protected void subscribeActual(Observer<? super String> observer) {
observer.onNext("Hello");
}
}, new BiFunction<String, String, String>() {
@Override
public String apply(@NonNull String s, @NonNull String o) throws Exception {
Log.e(tag, "s::" + s + "::o:" + o);
return s + o;
}
}).subscribe(new Consumer<String>() {
@Override
public void accept(String s) throws Exception {
Log.e(tag, "zipWith" + s);
}
});
运行结果
2）startWith（）：startWith在前面加的事件前面，添加若干项事件；
//startWith 在前面加。。
List<String> list = new ArrayList<>();
list.add("start01");
list.add("start02");
Observable.just("1", "2").startWith(Observable.fromIterable(list)).subscribe(new Consumer<String>() {
@Override
public void accept(String s) throws Exception {
Log.e(tag, "startWith：" + s);
}
});
运行结果
3）merge（）：将两个Observable发送的事件，按照时间先后顺序排序
//merge 按照发送事件 将两个Observable发送的事件，排序
Observable.merge(Observable.intervalRange(0, 2, 2, 2, TimeUnit.SECONDS),
Observable.intervalRange(4, 2, 2, 2, TimeUnit.SECONDS))
.subscribe(new Consumer<Long>() {
@Override
public void accept(Long aLong) throws Exception {
Log.e(tag, "merge::" + String.valueOf(aLong));
}
});
运行结果
以上是Filtering和Combining操作符的主要用法，如有问题，请多指教！