作用
过滤 / 筛选 被观察者（Observable）发送的事件 & 观察者 （Observer）接收的事件
类型
| 类型 | 含义 | 用途分类 |
|---|---|---|
| filter() | 过滤 特定条件的事件 | 指定条件 |
| ofType() | 过滤 特定数据类型的数据 | |
| skip() | 跳过某个事件 前N项 | |
| skipLast() | 跳过某个事件 后N项 | |
| distinct() | 过滤事件序列中重复的事件 | |
| distinctUntilChanged() | 过滤事件序列中连续重复的事件 | |
| take() | 指定观察者最多能接收到的事件数量 | 指定事件数量 |
| takeLast() | 指定观察者只能接收到被观察者发送的最后几个事件 | |
| throttleFirst() | 在某段时间内，只发送该段时间内第1次事件 | 指定时间 |
| throttleLast() | 同sample，本质就是调用sample方法 | |
| sample() | 在某段时间内，只发送该段时间内最后1次事件 | |
| throttleWithTimeout() | 同debounce，本质就是调用debounce方法 | |
| debounce() | 发送数据事件时，若2次发送事件的间隔＜指定时间， 就会丢弃前一次的数据，直到指定时间内都没有新数据 发射时才会发送后一次的数据 |
|
| firstElement() | 仅选取第1个元素 | 指定事件位置 |
| lastElement() | 仅选取最后1个元素 | |
| elementAt() | 指定接收某个元素（通过 索引值 确定），越界给默认值 | |
| elementAtOrError() | 当出现越界情况（即获取的位置索引 ＞ 发送事件序列 长度）时，即抛出异常 |
filter()：过滤出特定条件的事件
对 Observable 发送的每一个事件都通过 指定的函数 的过滤 ，复合条件的事件才发射出去
Observable.range(1, 10)
.filter(new Predicate<Integer>() {
@Override
public boolean test(Integer integer) throws Exception {
// 过滤出奇数
return integer % 2 == 1;
}
})
.subscribe(new Consumer<Integer>() {
@Override
public void accept(Integer integer) throws Exception {
Log.d(TAG, "过滤后接收到的数据：" + integer);
}
});
>>>>>>
过滤后接收到的数据：1
过滤后接收到的数据：3
过滤后接收到的数据：5
过滤后接收到的数据：7
过滤后接收到的数据：9
>>>>>>
ofType()：只发射指定类型的事件
Observable.just(1, 2, "3")
.ofType(Integer.class)
.subscribe(new Consumer<Integer>() {
@Override
public void accept(Integer integer) throws Exception {
Log.d(TAG, "过滤后接收到的数据：" + integer);
}
});
>>>>>>
过滤后接收到的数据：1
过滤后接收到的数据：2
>>>>>>
skip()：跳过事件的前N项，只发射它之后的事件
Observable.range(1, 5)
.skip(2)
.subscribe(new Consumer<Integer>() {
@Override
public void accept(Integer integer) throws Exception {
Log.d(TAG, "过滤后接收到的数据：" + integer);
}
});
>>>>>>
过滤后接收到的数据：3
过滤后接收到的数据：4
过滤后接收到的数据：5
>>>>>>
skip()：跳过事件的最后N项，只发射它之前的事件
Observable.range(1, 5)
.skip(2)
.subscribe(new Consumer<Integer>() {
@Override
public void accept(Integer integer) throws Exception {
Log.d(TAG, "过滤后接收到的数据：" + integer);
}
});
>>>>>>
过滤后接收到的数据：1
过滤后接收到的数据：2
过滤后接收到的数据：3
>>>>>>
distinct()：过滤掉重复的事件
Observable.just(1, 2, 1, 2, 2)
.distinct()
.subscribe(new Consumer<Integer>() {
@Override
public void accept(Integer integer) throws Exception {
Log.d(TAG, "过滤后接收到的数据：" + integer);
}
});
>>>>>>
过滤后接收到的数据：1
过滤后接收到的数据：2
>>>>>>
distinctUntilChanged()：过滤掉连续重复的事件
Observable.just(1, 2, 1, 2, 2)
.distinctUntilChanged()
.subscribe(new Consumer<Integer>() {
@Override
public void accept(Integer integer) throws Exception {
Log.d(TAG, "过滤后接收到的数据：" + integer);
}
});
>>>>>>
过滤后接收到的数据：1
过滤后接收到的数据：2
过滤后接收到的数据：1
过滤后接收到的数据：2
>>>>>>
take()：只发射它前N项的事件
Observable.range(1, 5)
.take(2)
.subscribe(new Consumer<Integer>() {
@Override
public void accept(Integer integer) throws Exception {
Log.d(TAG, "过滤后接收到的数据：" + integer);
}
});
>>>>>>
过滤后接收到的数据：1
过滤后接收到的数据：2
>>>>>>
takeLast()：只发射它最后N项的事件
Observable.range(1, 5)
.takeLast(2)
.subscribe(new Consumer<Integer>() {
@Override
public void accept(Integer integer) throws Exception {
Log.d(TAG, "过滤后接收到的数据：" + integer);
}
});
>>>>>>
过滤后接收到的数据：4
过滤后接收到的数据：5
>>>>>>
firstElement()：仅发射第一个的事件
Observable.range(1, 5)
.firstElement()
.subscribe(new Consumer<Integer>() {
@Override
public void accept(Integer integer) throws Exception {
Log.d(TAG, "过滤后接收到的数据：" + integer);
}
});
>>>>>>
过滤后接收到的数据：1
>>>>>>
lastElement()：仅发射最后一个的事件
Observable.range(1, 5)
.lastElement()
.subscribe(new Consumer<Integer>() {
@Override
public void accept(Integer integer) throws Exception {
Log.d(TAG, "过滤后接收到的数据：" + integer);
}
});
>>>>>>
过滤后接收到的数据：5
>>>>>>
elementAt()：指定接收某个元素（通过 索引值 确定），越界给默认值
Observable.range(1, 5)
.elementAt(6, 99)
.subscribe(new Consumer<Integer>() {
@Override
public void accept(Integer integer) throws Exception {
Log.d(TAG, "过滤后接收到的数据：" + integer);
}
});
>>>>>>
过滤后接收到的数据：99
>>>>>>
elementAtOrError()：指定接收某个元素（通过 索引值 确定），越界抛出异常
Observable.range(1, 5)
.elementAtOrError(6)
.subscribe(new Consumer<Integer>() {
@Override
public void accept(Integer integer) throws Exception {
Log.d(TAG, "过滤后接收到的数据：" + integer);
}
});
>>>>>>
越界抛出了error
>>>>>>
