前往小程序，Get更优阅读体验！
立即前往
文档建议反馈控制台
首页
学习
活动
专区
工具
TVP
最新优惠活动
文章/答案/技术大牛
发布
首页
学习
活动
专区
工具
TVP最新优惠活动
返回腾讯云官网
社区首页 >专栏 >RxJava 1.x 笔记：过滤型操作符

RxJava 1.x 笔记：过滤型操作符

作者头像
张拭心 shixinzhang
发布于 2018-01-05 16:51:17
1.4K0
发布于 2018-01-05 16:51:17
举报
文章被收录于专栏：拭心的安卓进阶之路拭心的安卓进阶之路

我真的是奇怪，上下班的路上看书、看文章学习的劲头特别大，到了周末有大把的学习时间，反而不珍惜，总想打游戏，睡前才踏踏实实地写了篇文章，真是服了自己！

本文内容为 RxJava 官方文档 学习笔记 作者：shixinzhang

过滤型操作符

过滤型操作符即对 Observable 的数据进行过滤，选择性地发射出去。

Debounce

Debounce 的作用是：控制发射速率。

每产生一个数据后，如果在规定的间隔时间内没有别的数据产生，就会发射这个数据，否则忽略该数据。

这里写图片描述
这里写图片描述

RxJava 的实现有两种：debounce 和 throttleWithTimeout。

debounce

这里写图片描述
这里写图片描述

debounce 接收两个参数，第一个指定过滤的时间间隔，第二个参数指定单位。

代码语言：javascript
复制
public final Observable<T> debounce(long timeout, TimeUnit unit) {
    return debounce(timeout, unit, Schedulers.computation());
}
public final Observable<T> debounce(long timeout, TimeUnit unit, Scheduler scheduler) {
    return lift(new OperatorDebounceWithTime<T>(timeout, unit, scheduler));
}

使用例子：

代码语言：javascript
复制
private void filteringWithDebounce() {
    Observable
            .unsafeCreate(new Observable.OnSubscribe<Integer>() {
                @Override
                public void call(Subscriber<? super Integer> subscriber) {
                    for (int i = 0; i < 10; i++) {
                        SystemClock.sleep(i % 5 * 1000);
                        subscriber.onNext(i);
                    }
                    subscriber.onCompleted();
                }
            })
            .subscribeOn(Schedulers.computation())
            .debounce(2, TimeUnit.SECONDS)
            .subscribe(this.<Integer>getPrintSubscriber());

}

在上面的例子中，我们发射 0 到 9 共 10 个数据，每个延迟 i % 5 秒，也就是延迟 0 到 4 秒，过滤时间为 2 秒，所以最终发射结果：

这里写图片描述
这里写图片描述

throttleWithTimeout

这里写图片描述
这里写图片描述

throttleWithTimeout 和 debounce 作用一样，通过源码可以看到，它也是调用的 debounce:

代码语言：javascript
复制
public final Observable<T> throttleWithTimeout(long timeout, TimeUnit unit) {
    return debounce(timeout, unit);
}

例子就不演示了。

Distinct

这里写图片描述
这里写图片描述

Distinct 即“去重”，很好理解。

RxJava 中的实现有 4 种。

distinct()

这里写图片描述
这里写图片描述

第一种就是最简单的无参数 distinct():

代码语言：javascript
复制
public final Observable<T> distinct() {
    return lift(OperatorDistinct.<T> instance());
}

使用也很简单：

代码语言：javascript
复制
private void filteringWithDistinct() {
    Observable.from(Arrays.asList(1,3,1,3,4))
            .distinct()
            .subscribe(this.<Integer>getPrintSubscriber());
}

结果就和我们期望的一样：

这里写图片描述
这里写图片描述

distinct(keySelector)

这里写图片描述
这里写图片描述

第二种，distinct(keySelector) 允许我们传入一个函数作为参数，这个函数返回了决定是否重复的 Key。

代码语言：javascript
复制
public final <U> Observable<T> distinct(Func1<? super T, ? extends U> keySelector) {
    return lift(new OperatorDistinct<T, U>(keySelector));
}

使用例子：

代码语言：javascript
复制
private void filteringWithDistinct2() {

    Observable.from(Arrays.asList(1,3,1,3,4))
            .distinct(new Func1<Integer, Integer>() {
                @Override
                public Integer call(Integer item) {
                    return item % 2;
                }
            })
            .subscribe(this.<Integer>getPrintSubscriber());
}

在函数中我们以 item % 2 的结果作为判断是否重复的依据，源 Observable 发射的数据中，对二求余的结果只有 1 和 0，因此输出结果为：

这里写图片描述
这里写图片描述

distinctUntilChanged()

这里写图片描述
这里写图片描述

distinctUntilChanged() 也是去重，不过每个元素只跟前面一个元素比较，如果和前面的一样就去除，否则就发射，不会和其他位置的比较。

代码语言：javascript
复制
public final Observable<T> distinctUntilChanged() {
    return lift(OperatorDistinctUntilChanged.<T> instance());
}

使用例子：

代码语言：javascript
复制
private void filteringWithDistinctUntilChanged() {
    Observable.from(Arrays.asList(1,1,3,1,3,4,4))
            .distinctUntilChanged()
            .subscribe(this.<Integer>getPrintSubscriber());
}

运行结果：

这里写图片描述
这里写图片描述

可以看到，输出的结果还是有重复，去掉的是和前一个元素重复的元素。

distinctUntilChanged(keySelector)

这里写图片描述
这里写图片描述

distinctUntilChanged(keySelector) 就是 distinct(keySelector) 和 distinctUntilChanged() 的结合体，传入的参数决定是否重复，并且只和前一个元素比较。

就不写例子了。

ElementAt

这里写图片描述
这里写图片描述

ElementAt 和名字一样，只发射指定位置的元素（从 0 开始）。

RxJava 对应的实现有 2 种。

elementAt

这里写图片描述
这里写图片描述

elementAt 和规范一样，只发射指定位置的元素，

代码语言：javascript
复制
public final Observable<T> elementAt(int index) {
    return lift(new OperatorElementAt<T>(index));
}
private OperatorElementAt(int index, T defaultValue, boolean hasDefault) {
    if (index < 0) {
        throw new IndexOutOfBoundsException(index + " is out of bounds");
    }
    this.index = index;
    this.defaultValue = defaultValue;
    this.hasDefault = hasDefault;
}

从 OperatorElementAt 的构造函数我们可以看到当指定的位置小于 0 时，会抛出 java.lang.IndexOutOfBoundsException 异常。 当 index > 数据总数时，会发射　onError 事件：

代码语言：javascript
复制
private void filteringWithElementAt() {
    Observable.range(0, 10)
            .elementAt(12)
            .subscribe(this.<Integer>getPrintSubscriber());
}

运行结果：

代码语言：javascript
复制
07-15 22:00:52.425 11596-11596/top.shixinzhang.rxjavademo I/System.out: onError: 12 is out of bounds

elementAtOrDefault

这里写图片描述
这里写图片描述

elementAtOrDefault 和 elementAt 的区别在于，当指定的 index 大于源 Observable 发射的数据长度时，不会发射 onError 事件，而是发射预备的默认值；不过 index < 0 时还是会抛出异常。

代码语言：javascript
复制
public final Observable<T> elementAtOrDefault(int index, T defaultValue) {
    return lift(new OperatorElementAt<T>(index, defaultValue));
}
private OperatorElementAt(int index, T defaultValue, boolean hasDefault) {
    if (index < 0) {
        throw new IndexOutOfBoundsException(index + " is out of bounds");
    }
    this.index = index;
    this.defaultValue = defaultValue;
    this.hasDefault = hasDefault;
}

使用例子：

代码语言：javascript
复制
private void filteringWithElementAtDefault() {
    Observable.range(0, 10)
            .elementAtOrDefault(12, 222)
            .subscribe(this.<Integer>getPrintSubscriber());

}

运行结果：

代码语言：javascript
复制
07-15 22:06:27.882 16870-16870/top.shixinzhang.rxjavademo I/System.out: onNext: 222
07-15 22:06:27.882 16870-16870/top.shixinzhang.rxjavademo I/System.out: onCompleted

Filter

这里写图片描述
这里写图片描述

Filter 只发射符合要求的元素。

RxJava 中的实现有 2 种。

filter

这里写图片描述
这里写图片描述

filter(predicate) 的参数指定了要发射的元素需要满足的条件，不满足就不会发射。

代码语言：javascript
复制
public final Observable<T> filter(Func1<? super T, Boolean> predicate) {
    return unsafeCreate(new OnSubscribeFilter<T>(this, predicate));
}

使用例子：

代码语言：javascript
复制
private void filteringWithFilter() {
    Observable.range(0, 10)
            .filter(new Func1<Integer, Boolean>() {
                @Override
                public Boolean call(Integer item) {
                    return item > 5;
                }
            })
            .subscribe(this.<Integer>getPrintSubscriber());
}

例子中，我们只允许大于 5 的数据发射。运行结果：

代码语言：javascript
复制
07-15 22:09:38.773 19765-19765/top.shixinzhang.rxjavademo I/System.out: onNext: 6
07-15 22:09:38.773 19765-19765/top.shixinzhang.rxjavademo I/System.out: onNext: 7
07-15 22:09:38.773 19765-19765/top.shixinzhang.rxjavademo I/System.out: onNext: 8
07-15 22:09:38.773 19765-19765/top.shixinzhang.rxjavademo I/System.out: onNext: 9
07-15 22:09:38.773 19765-19765/top.shixinzhang.rxjavademo I/System.out: onCompleted

ofType

这里写图片描述
这里写图片描述

ofType(klass) 的参数指定符合要求的数据类型，最终还是调用的 filter：

代码语言：javascript
复制
public final <R> Observable<R> ofType(final Class<R> klass) {
    return filter(InternalObservableUtils.isInstanceOf(klass)).cast(klass);
}

使用例子：

代码语言：javascript
复制
private void filteringWithOfType() {
    Observable.range(0, 10)
            .ofType(String.class)
            .subscribe(this.<String>getPrintSubscriber());
}

可以看到 ofType 返回的 Observable 的数据类型就是参数的类型。运行结果：

代码语言：javascript
复制
07-15 22:14:38.979 24199-24199/top.shixinzhang.rxjavademo I/System.out: onCompleted

First

这里写图片描述
这里写图片描述

First 的作用的就是只发射第一个元素（或者是第一个满足要求的元素）。

在RxJava中，这个操作符被实现为 first，firstOrDefault 和 takeFirst。

first

这里写图片描述
这里写图片描述

first() 只发射第一个数据，如果源 Observable是空的话，会抛出 NoSuchElementException 异常。

代码语言：javascript
复制
public final Observable<T> first() {
    return take(1).single();
}

可以看到它调用的是 take(1).single()，这两个操作符我们这篇文章后面介绍。

运行结果很简单，这里就暂不演示了。

first(predicate)

这里写图片描述
这里写图片描述

first(predicate) 只发射符合要求的第一个元素。

代码语言：javascript
复制
public final Observable<T> first(Func1<? super T, Boolean> predicate) {
    return takeFirst(predicate).single();
}

使用例子：

代码语言：javascript
复制
private void filteringWithFirst() {
    Observable.range(4, 10)
            .first(new Func1<Integer, Boolean>() {
                @Override
                public Boolean call(Integer integer) {
                    return integer > 5;
                }
            })
            .subscribe(this.<Integer>getPrintSubscriber());
}

我们只发射第一个大于 5 的数字，也就是 6 喽。运行结果：

代码语言：javascript
复制
07-15 22:23:02.228 31262-31262/top.shixinzhang.rxjavademo I/System.out: onNext: 6
07-15 22:23:02.228 31262-31262/top.shixinzhang.rxjavademo I/System.out: onCompleted

firstOrDefault

这里写图片描述
这里写图片描述

firstOrDefault 和名字一样，如果没有第一个元素就发射默认的。

代码语言：javascript
复制
public final Observable<T> firstOrDefault(T defaultValue) {
    return take(1).singleOrDefault(defaultValue);
}

使用例子：

代码语言：javascript
复制
private void filteringWithFirstOrDefault() {
    Observable.empty()
            .firstOrDefault(33)
            .subscribe(getPrintSubscriber());
}

运行结果：

代码语言：javascript
复制
07-15 22:26:28.375 2910-2910/top.shixinzhang.rxjavademo I/System.out: onNext: 33
07-15 22:26:28.375 2910-2910/top.shixinzhang.rxjavademo I/System.out: onCompleted

firstOrDefault(predicate)

这里写图片描述
这里写图片描述

firstOrDefault(predicate) 返回第一个符合要求的，没有的话就返回默认的，也很好理解。

代码语言：javascript
复制
public final Observable<T> firstOrDefault(T defaultValue, Func1<? super T, Boolean> predicate) {
    return takeFirst(predicate).singleOrDefault(defaultValue);
}

使用例子：

代码语言：javascript
复制
private void filteringWithFirstOrDefault() {
    Observable.range(0 , 4)
            .firstOrDefault(33, new Func1<Integer, Boolean>() {
                @Override
                public Boolean call(Integer integer) {
                    return integer > 5;
                }
            })
            .subscribe(getPrintSubscriber());
}

运行结果：

代码语言：javascript
复制
07-15 22:26:28.375 2910-2910/top.shixinzhang.rxjavademo I/System.out: onNext: 33
07-15 22:26:28.375 2910-2910/top.shixinzhang.rxjavademo I/System.out: onCompleted

takeFirst

这里写图片描述
这里写图片描述

takeFirst 与 first 基本一致，除了这一点：如果原始 Observable 没有发射任何满足条件的数据，first 会抛出一个 NoSuchElementException，takeFist 会返回一个空的 Observable（不调用 onNext() 但是会调用 onCompleted）。

也就是说 takeFirst 比 first 温柔一点，不会抛异常。

single

这里写图片描述
这里写图片描述

single 也是只发射一个数据，但是如果源 Observable 发射多个数据，就会发射 onError 事件：

代码语言：javascript
复制
07-15 22:37:15.774 12609-12609/top.shixinzhang.rxjavademo I/System.out: onError: Sequence contains too many elements

如果源 Observable 没有数据，也会发射 onError 事件：

代码语言：javascript
复制
07-15 22:38:30.700 13779-13779/top.shixinzhang.rxjavademo I/System.out: onError: Sequence contains no elements

也就是说，single 是用来检验并获取只有一个元素的 Observable 发射的数据。

single 也有传递符合要求函数、默认值的变体，这里就暂不赘述了。

Last

有 First 当然就有 Last。

这里写图片描述
这里写图片描述

Last 只发射最后一项（或者满足某个条件的最后一项）数据。

Last 的变体和 First 差不多，这里就不赘述了。

Take

这里写图片描述
这里写图片描述

first 很多都是使用 take 实现的。

Take 操作符的作用是：只保留前面的若干项数据。

RxJava 对应的实现为 take。

take(count)

这里写图片描述
这里写图片描述

take(count) 的参数指定要保留的数据项。

代码语言：javascript
复制
public final Observable<T> take(final int count) {
    return lift(new OperatorTake<T>(count));
}

另外 limit 也只是 take 的别名：

代码语言：javascript
复制
public final Observable<T> limit(int count) {
    return take(count);
}

使用例子：

代码语言：javascript
复制
private void filteringWithTake() {
    Observable.range(0 , 10)
            .limit(3)
            .subscribe(this.<Integer>getPrintSubscriber());
}

运行结果：

代码语言：javascript
复制
07-15 22:51:49.895 25751-25751/top.shixinzhang.rxjavademo I/System.out: onNext: 0
07-15 22:51:49.895 25751-25751/top.shixinzhang.rxjavademo I/System.out: onNext: 1
07-15 22:51:49.895 25751-25751/top.shixinzhang.rxjavademo I/System.out: onNext: 2
07-15 22:51:49.895 25751-25751/top.shixinzhang.rxjavademo I/System.out: onCompleted

take(time, unit)

这里写图片描述
这里写图片描述

另一种变体是 take(long time, TimeUnit unit)，参数为时间，即只发射指定时间之内（小于该时间）发射的数据，超时的数据都不会发射。

代码语言：javascript
复制
public final Observable<T> take(long time, TimeUnit unit) {
    return take(time, unit, Schedulers.computation());
}
public final Observable<T> take(long time, TimeUnit unit, Scheduler scheduler) {
    return lift(new OperatorTakeTimed<T>(time, unit, scheduler));
}

使用例子：

代码语言：javascript
复制
private void filteringWithTake() {
    Observable
            .unsafeCreate(new Observable.OnSubscribe<Integer>() {
                @Override
                public void call(Subscriber<? super Integer> subscriber) {
                    for (int i = 0; i < 10; i++) {
                        SystemClock.sleep(1_000);
                        subscriber.onNext(i);
                    }
                    subscriber.onCompleted();
                }
            })
            .subscribeOn(Schedulers.computation())
            .take(3, TimeUnit.SECONDS)
            .subscribe(this.<Integer>getPrintSubscriber());
}

每隔一秒发射一个数据，然后指定只要 3 秒内发射的数据。运行结果：

代码语言：javascript
复制
07-15 22:56:01.304 29363-29388/top.shixinzhang.rxjavademo I/System.out: onNext: 0
07-15 22:56:02.306 29363-29388/top.shixinzhang.rxjavademo I/System.out: onNext: 1
07-15 22:56:03.302 29363-29387/top.shixinzhang.rxjavademo I/System.out: onCompleted

TakeLast

这里写图片描述
这里写图片描述

有从前开始拿，自然就有从后开始拿，TakeLast 就是这个作用。

使用 TakeLast 操作符可以只发射 Observable 发射的后 N 项数据，忽略前面的数据。

RxJava 中的实现有 takeLast，它的参数可以是个数也可以是时间。

还有一种实现是 takeLastBuffer：

这里写图片描述
这里写图片描述

takeLastBuffer 和 takeLast 类似，不同是它把所有的数据项收集到一个 List 再发射，而不是依次发射。

IgnoreElements

这里写图片描述
这里写图片描述

IgnoreElements 的作用是不发射任何数据，只发射结束事件（ onError or onCompleted）。

当你不在乎发射的内容，只希望在它完成时或遇到错误终止时收到通知，可以使用这个操作符。

ignoreElements 会确保永远不会调用观察者的onNext()方法

RxJava 的实现是 ignoreElements：

代码语言：javascript
复制
public final Observable<T> ignoreElements() {
    return lift(OperatorIgnoreElements.<T> instance());
}
@Override
public Subscriber<? super T> call(final Subscriber<? super T> child) {
    Subscriber<T> parent = new Subscriber<T>() {

        @Override
        public void onCompleted() {
            child.onCompleted();
        }

        @Override
        public void onError(Throwable e) {
            child.onError(e);
        }

        @Override
        public void onNext(T t) {
            // ignore element
        }

    };
    child.add(parent);
    return parent;
}

可以看到，它的 onNext() 方法没有传递事件。

Sample

Sample 的作用是：定时发射 Observable 最新发射的数据。

这里写图片描述
这里写图片描述

Sample 操作符会周期性地查看源 Observable，发射自出上次查看以来，最新发射的数据。

RxJava 中有三种实现：sample, throttleFirst, throttleLast。

sample

这里写图片描述
这里写图片描述

sample() 的参数指定定期查看的时间间隔：

代码语言：javascript
复制
public final Observable<T> sample(long period, TimeUnit unit) {
    return sample(period, unit, Schedulers.computation());
}
public final Observable<T> sample(long period, TimeUnit unit, Scheduler scheduler) {
    return lift(new OperatorSampleWithTime<T>(period, unit, scheduler));
}

throttleLast 和 sample 一样，只不过名称不同：

代码语言：javascript
复制
public final Observable<T> throttleLast(long intervalDuration, TimeUnit unit) {
    return sample(intervalDuration, unit);
}

使用例子：

代码语言：javascript
复制
private void filteringWithSample() {
    Observable
            .unsafeCreate(new Observable.OnSubscribe<Integer>() {
                @Override
                public void call(Subscriber<? super Integer> subscriber) {
                    for (int i = 0; i < 10; i++) {
                        SystemClock.sleep( i % 5 * 1000);
                        subscriber.onNext(i);
                    }
                    subscriber.onCompleted();
                }
            })
            .subscribeOn(Schedulers.computation())
            .sample(3, TimeUnit.SECONDS)
            .subscribe(this.<Integer>getPrintSubscriber());
}

例子中，我们每隔 i % 5 秒发射 10 个数据，然后每隔 3 秒去查看一次，发射距离上次查看，最新发射的元素。运行结果：

代码语言：javascript
复制
07-15 23:12:55.915 12800-12815/top.shixinzhang.rxjavademo I/System.out: onNext: 0
07-15 23:12:58.915 12800-12815/top.shixinzhang.rxjavademo I/System.out: onNext: 2
07-15 23:13:01.916 12800-12815/top.shixinzhang.rxjavademo I/System.out: onNext: 3
07-15 23:13:07.916 12800-12815/top.shixinzhang.rxjavademo I/System.out: onNext: 6
07-15 23:13:10.916 12800-12815/top.shixinzhang.rxjavademo I/System.out: onNext: 7
07-15 23:13:13.916 12800-12815/top.shixinzhang.rxjavademo I/System.out: onNext: 8
07-15 23:13:15.499 12800-12816/top.shixinzhang.rxjavademo I/System.out: onNext: 9
07-15 23:13:15.499 12800-12816/top.shixinzhang.rxjavademo I/System.out: onCompleted

throttleFirst

这里写图片描述
这里写图片描述

throttleFirst 也是隔一段时间去查看一次，不同的是它发射的是这段时间里第一个发射的数据，而不是最新的。

代码语言：javascript
复制
public final Observable<T> throttleFirst(long windowDuration, TimeUnit unit) {
    return throttleFirst(windowDuration, unit, Schedulers.computation());
}
public final Observable<T> throttleFirst(long skipDuration, TimeUnit unit, Scheduler scheduler) {
    return lift(new OperatorThrottleFirst<T>(skipDuration, unit, scheduler));
}

例子：

代码语言：javascript
复制
private void filteringWithThrottleFirst() {
    Observable
            .unsafeCreate(new Observable.OnSubscribe<Integer>() {
                @Override
                public void call(Subscriber<? super Integer> subscriber) {
                    for (int i = 0; i < 10; i++) {
                        SystemClock.sleep( i % 5 * 1000);
                        subscriber.onNext(i);
                    }
                    subscriber.onCompleted();
                }
            })
            .subscribeOn(Schedulers.computation())
            .throttleFirst(3, TimeUnit.SECONDS)
            .subscribe(this.<Integer>getPrintSubscriber());
}

运行结果：

代码语言：javascript
复制
07-15 23:18:00.798 17008-17648/top.shixinzhang.rxjavademo I/System.out: onNext: 0
07-15 23:18:03.813 17008-17648/top.shixinzhang.rxjavademo I/System.out: onNext: 2
07-15 23:18:06.815 17008-17648/top.shixinzhang.rxjavademo I/System.out: onNext: 3
07-15 23:18:10.816 17008-17648/top.shixinzhang.rxjavademo I/System.out: onNext: 4
07-15 23:18:13.818 17008-17648/top.shixinzhang.rxjavademo I/System.out: onNext: 7
07-15 23:18:16.820 17008-17648/top.shixinzhang.rxjavademo I/System.out: onNext: 8
07-15 23:18:20.822 17008-17648/top.shixinzhang.rxjavademo I/System.out: onNext: 9
07-15 23:18:20.822 17008-17648/top.shixinzhang.rxjavademo I/System.out: onCompleted

Skip

Skip 的作用是，跳过指定数量的数据，发射后面的数据。

这里写图片描述
这里写图片描述

RxJava 中的实现有两种，都叫 skip，不同的是一个是按个数算，一个是按时间算。

skip(count)

这里写图片描述
这里写图片描述
代码语言：javascript
复制
public final Observable<T> skip(int count) {
    return lift(new OperatorSkip<T>(count));
}

使用例子：

代码语言：javascript
复制
private void filteringWithSkip() {
    Observable.range(0 , 10)
            .skip(3)
            .subscribe(this.<Integer>getPrintSubscriber());
}

运行结果：

代码语言：javascript
复制
07-15 23:22:14.472 21075-21075/top.shixinzhang.rxjavademo I/System.out: onNext: 3
07-15 23:22:14.472 21075-21075/top.shixinzhang.rxjavademo I/System.out: onNext: 4
07-15 23:22:14.472 21075-21075/top.shixinzhang.rxjavademo I/System.out: onNext: 5
07-15 23:22:14.472 21075-21075/top.shixinzhang.rxjavademo I/System.out: onNext: 6
07-15 23:22:14.472 21075-21075/top.shixinzhang.rxjavademo I/System.out: onNext: 7
07-15 23:22:14.472 21075-21075/top.shixinzhang.rxjavademo I/System.out: onNext: 8
07-15 23:22:14.472 21075-21075/top.shixinzhang.rxjavademo I/System.out: onNext: 9
07-15 23:22:14.473 21075-21075/top.shixinzhang.rxjavademo I/System.out: onCompleted

skip(time, unit)

这里写图片描述
这里写图片描述

skip(time, unit) 的参数指定要跳过前指定时间内发射的数据。

代码语言：javascript
复制
public final Observable<T> skip(long time, TimeUnit unit) {
    return skip(time, unit, Schedulers.computation());
}
public final Observable<T> skip(long time, TimeUnit unit, Scheduler scheduler) {
    return unsafeCreate(new OnSubscribeSkipTimed<T>(this, time, unit, scheduler));
}

SkipLast

既然有跳过从头开始的数据，自然也有跳过从后开始的数据，这就是 SkipLast 的作用。

这里写图片描述
这里写图片描述

RxJava 中的实现也有两种，按时间和按个数，这里就暂不赘述了。

代码地址

Thanks

http://reactivex.io/documentation/operators.html https://github.com/mcxiaoke/RxDocs/blob/master/Operators.md http://blog.csdn.net/job_hesc/article/details/46495281

本文参与 腾讯云自媒体分享计划，分享自作者个人站点/博客。
原始发表：2017-07-15 ，如有侵权请联系 cloudcommunity@tencent.com 删除
android

本文分享自 作者个人站点/博客 前往查看

如有侵权，请联系 cloudcommunity@tencent.com 删除。

本文参与 腾讯云自媒体分享计划  ，欢迎热爱写作的你一起参与！

android
评论
登录后参与评论
0 条评论
热度
最新
登录 后参与评论
推荐阅读
LV.
文章
0
获赞
0
目录
  • 过滤型操作符
    • Debounce
      • debounce
      • throttleWithTimeout
    • Distinct
      • distinct()
      • distinct(keySelector)
      • distinctUntilChanged()
      • distinctUntilChanged(keySelector)
    • ElementAt
      • elementAt
      • elementAtOrDefault
    • Filter
      • filter
      • ofType
    • First
      • first
      • first(predicate)
      • firstOrDefault
      • firstOrDefault(predicate)
      • takeFirst
      • single
    • Last
      • Take
        • take(count)
        • take(time, unit)
      • TakeLast
        • IgnoreElements
          • Sample
            • sample
            • throttleFirst
          • Skip
            • skip(count)
            • skip(time, unit)
          • SkipLast
          • 代码地址
          • Thanks
          领券

          腾讯云开发者

          扫码关注腾讯云开发者

          扫码关注腾讯云开发者

          领取腾讯云代金券

          热门产品

          热门推荐

          更多推荐

          Copyright © 2013 - 2024 Tencent Cloud. All Rights Reserved. 腾讯云 版权所有 

          深圳市腾讯计算机系统有限公司 ICP备案/许可证号：粤B2-20090059 深公网安备号 44030502008569

          腾讯云计算（北京）有限责任公司 京ICP证150476号 |  京ICP备11018762号 | 京公网安备号11010802020287

          问题归档专栏文章快讯文章归档关键词归档开发者手册归档开发者手册 Section 归档

          Copyright © 2013 - 2024 Tencent Cloud.

          All Rights Reserved. 腾讯云 版权所有

          登录 后参与评论