Rxjava条件操作符

Rxjava操作符索引

这篇章主要介绍Rxjava的条件操作符

目录

All

Amb

Contains

DefaultIfEmpty

SequenceEqual

SkipUntil

SkipWhile

TakeUntil

TakeWhile

---

All

判定是否Observable发射的所有数据都满足某个条件，是就发射一个true，否就发射一个false

Observable.just(1, 2, 3, 4).all(new Predicate<Integer>() {
            @Override
            public boolean test(Integer integer) throws Throwable {
                return integer > 0;
            }
        }).subscribe(num -> System.out.println(num+"*"));

结果：

true*

Amb

给定两个或多个Observables，它只发射首先发射数据或通知的那个Observable的所有数据。这是官方的描述，根据下图其实描述也说得挺明白，就是第二个observable最先发射数据，所有后面就相当于只订阅它，发射它的所有数据。但我暂时写不出demo。

Contains

判断发射的数据中是否含有指定的数据，有就发射一个true，没就发射一个false

Observable.just(1, 2, 3, 4).contains(2).subscribe(num -> System.out.println(num+"*"));

结果：

true*

DefaultIfEmpty

非常简单就是你的observable为空的时候发射一个默认值

Observable.empty().defaultIfEmpty(10).subscribe(num -> System.out.println(num+"*"));

结果：

10*

SequenceEqual

判断两个observable发射的序列是否一样，所指的一样不管时间间隔，只要发射的数据顺序和值一样那就算一样，一样的时候发射true，否则发射false

Observable observable1 = Observable.intervalRange(1, 4, 0,1, TimeUnit.SECONDS, Schedulers.trampoline());
        Observable observable2 = Observable.intervalRange(1, 4, 2,1, TimeUnit.SECONDS, Schedulers.trampoline());
        Observable.sequenceEqual(observable1, observable2).subscribe(num -> System.out.println(num+"*"));

结果：

true*

上面的两个observable发射的序列都是1，2,3,4，只是第二个observable延迟了两秒才发射。结果就是发射了true

SkipUntil

丢弃原始Observable发射的数据，直到第二个Observable发射了一项数据

Observable observable1 = Observable.intervalRange(1, 4, 0,1, TimeUnit.SECONDS, Schedulers.trampoline());
        Observable observable2 = Observable.intervalRange(10, 4, 2,1, TimeUnit.SECONDS, Schedulers.newThread());
        observable1.skipUntil(observable2).subscribe(num -> System.out.println(num+"*"));

结果：

3*
4*

由上面可以看到第一个observable是每隔1秒发射一次数据，序列为1,2,3,4，第二个observable是每隔1秒发射一次数据，序列为10,11,12,13，但它是延迟2秒才发射。所以最终结果就是第一个observable从第二秒开始的数据3,4才会被发射，前面的就丢弃了。由此最终就只会发射observable1的数据，observable2的数据就不进行发射的。

SkipWhile

丢弃Observable发射的数据，直到一个指定的条件不成立

Observable.just(1, 2, 3, 4, 5).skipWhile(new Predicate<Integer>() {
            @Override
            public boolean test(Integer integer) throws Throwable {
                return integer != 3;
            }
        }).subscribe(num -> System.out.println(num +"*"));

结果：

3*
4*
5*

看上面，简单一句就是所有发射的数据都会先进入skipWhile里面放的函数，当那个函数返回false的时候，才会处理onNext，进行开始发射数据。

TakeUntil

当第二个Observable发射了一项数据或者终止时，丢弃原始Observable发射的任何数据

Observable observable1 = Observable.intervalRange(1, 4, 0,1, TimeUnit.SECONDS, Schedulers.trampoline());
        Observable observable2 = Observable.intervalRange(10, 4, 2,1, TimeUnit.SECONDS, Schedulers.newThread());
        observable1.takeUntil(observable2).subscribe(num -> System.out.println(num+"*"));

结果：

1*
2*
3*

很简单，其实就是跟上面SkipUntil大概相反。takeUntil就是第二个observable2开始发射的时候，不是跳过observable1前面的数据，而是要发射前面的数据跳过后面，并且也会发射刚刚和observable2第一个发射时间相等的数据，故结果输出1,2,3

Observable.just(1,2,3,4).takeUntil(new Predicate<Integer>() {
            @Override
            public boolean test(Integer integer) throws Throwable {
                return integer == 3;
            }
        }).subscribe(num -> System.out.println(num+"*"));

结果：

1*
2*
3*

takeUntil里面还可以放一个函数，说白这个takeUntil也跟SkipWhile有点类似。就是所有发射的数据都会先进过takeUntil里面的函数，当里面返回true的时候，就停止发射数据

TakeWhile

发射Observable发射的数据，直到一个指定的条件不成立

Observable.just(1,2,3,4).takeWhile(new Predicate<Integer>() {
            @Override
            public boolean test(Integer integer) throws Throwable {
                return integer != 3;
            }
        }).subscribe(num -> System.out.println(num+"*"));


        Observable.just(1,2,3,4).publish();

结果：

1*
2*

也是跟上面skipWhile有点类似，函数里面返回false是时候，就停止发射数据，且不会发射刚刚返回false那个数据。