RxJava2极速入门——Rxjava操作符详解之条件布尔操作符

RxJava操作符——条件布尔操作符

最近公司人事变动太大，工作比较忙，会尽量保持一周一更，以下正文开始：
Conditional and Boolean Operators:Operators that evaluate one or more Observables or items emitted by Observables
条件布尔操作常用用于对Observable的一些条件判断，或者对Observable元数据进行一些过滤操作；
常见分类如下：

All

all:determine whether all items emitted by an Observable meet some criteria
all作用判断Observable是否所有的发射都满足某一个条件
原理图如下:

示例代码以及源码如下

    private fun operatorsAll() =
            Observable.range(1, 4).all { it < 5 }.subscribe(getBaseSingleObserver("operatorsAll"))
    /**
     * 运行结果如下:
     * com.ypz.rxjavademo I/operatorsAll: onSubscribe
     * com.ypz.rxjavademo I/operatorsAll: onNext:value-true
     * 相关源码如下
     * */
   
    /**
     * Returns a Single that emits a Boolean that indicates whether all of the items emitted by the source
     * ObservableSource satisfy a condition.
     *
     * @param predicate
     *            a function that evaluates an item and returns a Boolean
     * @return a Single that emits {@code true} if all items emitted by the source ObservableSource satisfy the
     *         predicate; otherwise, {@code false}
     */
    @CheckReturnValue
    @SchedulerSupport(SchedulerSupport.NONE)
    public final Single<Boolean> all(Predicate<? super T> predicate) {
        ObjectHelper.requireNonNull(predicate, "predicate is null");
        return RxJavaPlugins.onAssembly(new ObservableAllSingle<T>(this, predicate));
    }

/**
 * A functional interface (callback) that returns true or false for the given input value.
 * @param  the first value
 */
public interface Predicate<T> {
    /**
     * Test the given input value and return a boolean.
     * @param t the value
     * @return the boolean result
     * @throws Exception on error
     */
    boolean test(@NonNull T t) throws Exception;
}

public final class ObservableAllSingle<T> extends Single<Boolean> implements FuseToObservable<Boolean> {
//省略部分源码。。。。。。。
    @Override
    public Observable<Boolean> fuseToObservable() {
        return RxJavaPlugins.onAssembly(new ObservableAll<T>(source, predicate));
    }
    static final class AllObserver<T> implements Observer<T>, Disposable {
        @Override
        public void onNext(T t) {
            if (done) {
                return;
            }
            boolean b;
            try {
                b = predicate.test(t);
            } catch (Throwable e) {
                Exceptions.throwIfFatal(e);
                upstream.dispose();
                onError(e);
                return;
            }
            if (!b) {
                done = true;
                upstream.dispose();
                downstream.onSuccess(false);
            }
        }
    }
}

结合代码可以得到：

• all 结束运算的时候会返回 Boolean
• 当然当运行异常的时候还是会产生Error事件，建议使用SingleObsever< Boolean >避免一些不必要的运行异常
• all的核心接口是Predicate的实现，通过AllObserver中onNext的实现反复调用Predicate然后返回运算结果

---

Amb

Amb:given two or more source Observables, emit all of the items from only the first of these Observables to emit an item or notification
Amb作用判断两个或多个Observable的发射问题：当有一个Observable最先开始发射事件时，则取该Observable其余Observable则丢弃。
原理图如下:

示例代码以及源码如下

    private fun operatorsAmb() {
        Observable.amb(mutableListOf(
                Observable.just(1).delay(1, TimeUnit.SECONDS),
                Observable.just(5)
        )).subscribe(getBaseObsever("operatorsAmb"))
    }
    /**
     * 运行结果如下:
     * com.ypz.rxjavademo I/operatorsAmb: onSubscribe
     * com.ypz.rxjavademo I/operatorsAmb: onNextValue:5
     * 相关源码:
     * */
   /**
     * Mirrors the one ObservableSource in an Iterable of several ObservableSources that first either emits an item or sends
     * a termination notification.
     *
     * @param  the common element type
     * @param sources
     *            an Iterable of ObservableSource sources competing to react first. A subscription to each source will
     *            occur in the same order as in the Iterable.
     * @return an Observable that emits the same sequence as whichever of the source ObservableSources first
     *         emitted an item or sent a termination notification
     */
    @CheckReturnValue
    @NonNull
    @SchedulerSupport(SchedulerSupport.NONE)
    public static <T> Observable<T> amb(Iterable<? extends ObservableSource<? extends T>> sources) {
        ObjectHelper.requireNonNull(sources, "sources is null");
        return RxJavaPlugins.onAssembly(new ObservableAmb<T>(null, sources));
    }
public final class ObservableAmb<T> extends Observable<T> {
    final ObservableSource<? extends T>[] sources;
    final Iterable<? extends ObservableSource<? extends T>> sourcesIterable;

    public ObservableAmb(ObservableSource<? extends T>[] sources, Iterable<? extends ObservableSource<? extends T>> sourcesIterable) {
        this.sources = sources;
        this.sourcesIterable = sourcesIterable;
    }

    @Override
    @SuppressWarnings("unchecked")
    public void subscribeActual(Observer<? super T> observer) {
        ObservableSource<? extends T>[] sources = this.sources;
        int count = 0;
        if (sources == null) {
            sources = new Observable[8];
            try {
                for (ObservableSource<? extends T> p : sourcesIterable) {
                    if (p == null) {
                        EmptyDisposable.error(new NullPointerException("One of the sources is null"), observer);
                        return;
                    }
                    if (count == sources.length) {
                        ObservableSource<? extends T>[] b = new ObservableSource[count + (count >> 2)];
                        System.arraycopy(sources, 0, b, 0, count);
                        sources = b;
                    }
                    sources[count++] = p;
                }
            } catch (Throwable e) {
                Exceptions.throwIfFatal(e);
                EmptyDisposable.error(e, observer);
                return;
            }
        } else {
            count = sources.length;
        }

        if (count == 0) {
            EmptyDisposable.complete(observer);
            return;
        } else
        if (count == 1) {
            sources[0].subscribe(observer);
            return;
        }

        AmbCoordinator<T> ac = new AmbCoordinator<T>(observer, count);
        ac.subscribe(sources);
    }
 }

结合代码可以得到：

• Amb 的核心在于 ObservableAmb 的实现
• ObservableAmb 中的 subscribeActual 实现了中转 订阅
• AmbCoordinator 负责真正的事件发送 其中其 win 决定了哪个Observable是真正被发射的而其余则被舍弃
• AmbInnerObserver 负责在真正需要发射的 Observable 发射事件时及时调用 AmbCoordinator 中 win 方法用来通知 AmbCoordinator 舍弃其余Observables

Contains

Contains:determine whether an Observable emits a particular item or not
Contains作用判断Observable是否所有的发射元素是否包含某一个元素
原理图如下:

示例代码以及源码如下

    private fun operatorsContains() =
            Observable.range(1, 6).contains(3).subscribe(getBaseSingleObserver("operatorsContains"))
    /**
     * 运行结果如下:
     * com.ypz.rxjavademo I/operatorsContains: onSubscribe
     * com.ypz.rxjavademo I/operatorsContains: onNext:value-true
     * 相关源码如下
     * */
    /**
     * Returns a Single that emits a Boolean that indicates whether the source ObservableSource emitted a
     * specified item.
     * @param element
     *            the item to search for in the emissions from the source ObservableSource
     * @return a Single that emits {@code true} if the specified item is emitted by the source ObservableSource,
     *         or {@code false} if the source ObservableSource completes without emitting that item
     */
    @CheckReturnValue
    @SchedulerSupport(SchedulerSupport.NONE)
    public final Single<Boolean> contains(final Object element) {
        ObjectHelper.requireNonNull(element, "element is null");
        return any(Functions.equalsWith(element));
    }

    public static <T> Predicate<T> equalsWith(T value) {
        return new EqualsPredicate<T>(value);
    }

    static final class EqualsPredicate<T> implements Predicate<T> {
        final T value;

        EqualsPredicate(T value) {
            this.value = value;
        }

        @Override
        public boolean test(T t) throws Exception {
            return ObjectHelper.equals(t, value);
        }
    }

    @CheckReturnValue
    @SchedulerSupport(SchedulerSupport.NONE)
    public final Single<Boolean> any(Predicate<? super T> predicate) {
        ObjectHelper.requireNonNull(predicate, "predicate is null");
        return RxJavaPlugins.onAssembly(new ObservableAnySingle<T>(this, predicate));
    }

结合代码可以得到：

• Contains 基于 any 的实现
• 是否包含的核心是基于 EqualsPredicate 的实现
• EqualsPredicate 是 Predicate的一种实现

---

DefaultIfEmpty

DefaultIfEmpty:emit items from the source Observable, or a default item if the source Observable emits nothing
DefaultIfEmpty作用当Observable是一个Empty的Observable的时候会发射出一个默认的数据出去
原理图如下:

示例代码以及源码如下

    /**
     * Returns an Observable that emits the items emitted by the source ObservableSource or a specified default item
     * if the source ObservableSource is empty.
     *
     * @param defaultItem
     *            the item to emit if the source ObservableSource emits no items
     * @return an Observable that emits either the specified default item if the source ObservableSource emits no
     *         items, or the items emitted by the source ObservableSource
     */
    @CheckReturnValue
    @SchedulerSupport(SchedulerSupport.NONE)
    public final Observable<T> defaultIfEmpty(T defaultItem) {
        ObjectHelper.requireNonNull(defaultItem, "defaultItem is null");
        return switchIfEmpty(just(defaultItem));
    }

    @CheckReturnValue
    @SchedulerSupport(SchedulerSupport.NONE)
    public final Observable<T> switchIfEmpty(ObservableSource<? extends T> other) {
        ObjectHelper.requireNonNull(other, "other is null");
        return RxJavaPlugins.onAssembly(new ObservableSwitchIfEmpty<T>(this, other));
    }

结合代码可以得到：

• DefaultIfEmpty基于 ObservableSwitchIfEmpty 以及 just 的实现
• ObservableSwitchIfEmpty 的核心实现对原来的Observable进行判断是否为 Empty 是则调用 just

---

SequenceEqual

SequenceEqual:determine whether two Observables emit the same sequence of items
SequenceEqual作用判断两个Observable是否一致
原理图如下:

直接对比法

示例代码以及源码如下

    private fun operatorsSequenceEqual() {
        Observable.sequenceEqual(
                Observable.range(1, 5),
                Observable.range(1, 5)
        ).subscribe(getBaseSingleObserver<Boolean>("operatorsSequenceEqual-直接比较"))
    }
    /**
     * 运行结果如下:
     * com.ypz.rxjavademo I/operatorsSequenceEqual-直接比较: onSubscribe
     * com.ypz.rxjavademo I/operatorsSequenceEqual-直接比较: onNext:value-true
     * 相关源码如下
     * */
    /**
     * Returns a Single that emits a Boolean value that indicates whether two ObservableSource sequences are the
     * same by comparing the items emitted by each ObservableSource pairwise.
     *
     * @param source1
     *            the first ObservableSource to compare
     * @param source2
     *            the second ObservableSource to compare
     * @param 
     *            the type of items emitted by each ObservableSource
     * @return a Single that emits a Boolean value that indicates whether the two sequences are the same
     */
    @CheckReturnValue
    @SchedulerSupport(SchedulerSupport.NONE)
    public static <T> Single<Boolean> sequenceEqual(ObservableSource<? extends T> source1, ObservableSource<? extends T> source2) {
        return sequenceEqual(source1, source2, ObjectHelper.equalsPredicate(), bufferSize());
    }

    @CheckReturnValue
    @SchedulerSupport(SchedulerSupport.NONE)
    public static <T> Single<Boolean> sequenceEqual(ObservableSource<? extends T> source1, ObservableSource<? extends T> source2,
            BiPredicate<? super T, ? super T> isEqual, int bufferSize) {
        ObjectHelper.requireNonNull(source1, "source1 is null");
        ObjectHelper.requireNonNull(source2, "source2 is null");
        ObjectHelper.requireNonNull(isEqual, "isEqual is null");
        ObjectHelper.verifyPositive(bufferSize, "bufferSize");
        return RxJavaPlugins.onAssembly(new ObservableSequenceEqualSingle<T>(source1, source2, isEqual, bufferSize));
    }

public final class ObservableSequenceEqualSingle<T> extends Single<Boolean> implements FuseToObservable<Boolean> {
    static final class EqualCoordinator<T> extends AtomicInteger implements Disposable {

        void drain() {
            if (getAndIncrement() != 0) {
                return;
            }

            int missed = 1;
            EqualObserver<T>[] as = observers;

            final EqualObserver<T> observer1 = as[0];
            final SpscLinkedArrayQueue<T> q1 = observer1.queue;
            final EqualObserver<T> observer2 = as[1];
            final SpscLinkedArrayQueue<T> q2 = observer2.queue;

            for (;;) {

                for (;;) {
                    if (cancelled) {
                        q1.clear();
                        q2.clear();
                        return;
                    }

                    boolean d1 = observer1.done;

                    if (d1) {
                        Throwable e = observer1.error;
                        if (e != null) {
                            cancel(q1, q2);

                            downstream.onError(e);
                            return;
                        }
                    }

                    boolean d2 = observer2.done;
                    if (d2) {
                        Throwable e = observer2.error;
                        if (e != null) {
                            cancel(q1, q2);

                            downstream.onError(e);
                            return;
                        }
                    }

                    if (v1 == null) {
                        v1 = q1.poll();
                    }
                    boolean e1 = v1 == null;

                    if (v2 == null) {
                        v2 = q2.poll();
                    }
                    boolean e2 = v2 == null;

                    if (d1 && d2 && e1 && e2) {
                        downstream.onSuccess(true);
                        return;
                    }
                    if ((d1 && d2) && (e1 != e2)) {
                        cancel(q1, q2);

                        downstream.onSuccess(false);
                        return;
                    }

                    if (!e1 && !e2) {
                        boolean c;

                        try {
                            c = comparer.test(v1, v2);
                        } catch (Throwable ex) {
                            Exceptions.throwIfFatal(ex);
                            cancel(q1, q2);

                            downstream.onError(ex);
                            return;
                        }

                        if (!c) {
                            cancel(q1, q2);

                            downstream.onSuccess(false);
                            return;
                        }

                        v1 = null;
                        v2 = null;
                    }

                    if (e1 || e2) {
                        break;
                    }
                }

                missed = addAndGet(-missed);
                if (missed == 0) {
                    break;
                }
            }
        }
    }
    static final class EqualObserver<T> implements Observer<T> {
        @Override
        public void onNext(T t) {
            queue.offer(t);
            parent.drain();
        }
    }
}

结合代码可以得到：

• 直接对比法核心是 ObservableSequenceEqualSingle 以及 ObjectHelper.equalsPredicate()
• ObservableSequenceEqualSingle 的核心在于 EqualCoordinator 以及 EqualObserver 的实现
• EqualCoordinator 专注于数据的对比
• EqualObserver 专注于事件的发送
• 注意ObjectHelper.equalsPredicate() 是 BiPredicate 一种实现

---

自定义对比法

示例代码以及源码如下

    private fun operatorsSequenceEqual() {
        Observable.sequenceEqual(
                Observable.range(1, 5),
                Observable.range(1, 5),
                object : BiPredicate<Int, Int> {
                    override fun test(t1: Int, t2: Int): Boolean {
                        return (t1) == (t2 - 1)
                    }
                }
        ).subscribe(getBaseSingleObserver<Boolean>("operatorsSequenceEqual-BiPredicate"))
    }
    /**
     * 运行结果如下:
     * com.ypz.rxjavademo I/operatorsSequenceEqual-BiPredicate: onSubscribe
     * com.ypz.rxjavademo I/operatorsSequenceEqual-BiPredicate: onNext:value-false
     * 相关源码如下
     * */
    /**
     * Returns a Single that emits a Boolean value that indicates whether two ObservableSource sequences are the
     * same by comparing the items emitted by each ObservableSource pairwise based on the results of a specified
     * equality function.
     *
     * @param source1
     *            the first ObservableSource to compare
     * @param source2
     *            the second ObservableSource to compare
     * @param isEqual
     *            a function used to compare items emitted by each ObservableSource
     * @param 
     *            the type of items emitted by each ObservableSource
     * @return a Single that emits a Boolean value that indicates whether the two ObservableSource two sequences
     *         are the same according to the specified function
     */
    @CheckReturnValue
    @SchedulerSupport(SchedulerSupport.NONE)
    public static <T> Single<Boolean> sequenceEqual(ObservableSource<? extends T> source1, ObservableSource<? extends T> source2,
            BiPredicate<? super T, ? super T> isEqual) {
        return sequenceEqual(source1, source2, isEqual, bufferSize());
    }
    @CheckReturnValue
    @SchedulerSupport(SchedulerSupport.NONE)
    public static <T> Single<Boolean> sequenceEqual(ObservableSource<? extends T> source1, ObservableSource<? extends T> source2,
            BiPredicate<? super T, ? super T> isEqual, int bufferSize) {
        ObjectHelper.requireNonNull(source1, "source1 is null");
        ObjectHelper.requireNonNull(source2, "source2 is null");
        ObjectHelper.requireNonNull(isEqual, "isEqual is null");
        ObjectHelper.verifyPositive(bufferSize, "bufferSize");
        return RxJavaPlugins.onAssembly(new ObservableSequenceEqualSingle<T>(source1, source2, isEqual, bufferSize));
    }

结合代码可以得到：

• 自定义比较的核心也是 ObservableSequenceEqualSingle 以及 ObjectHelper.equalsPredicate()
• 自定义数据对比的核心在于 BiPredicate 的实现

---

SkipUntil

SkipUntil:discard items emitted by an Observable until a second Observable emits an item
SkipUntil作用到达某一个条件前丢弃需要发射的数据
原理图如下:

示例代码以及源码如下

    private fun operatorsSikpUnitl() {
        Observable.intervalRange(1, 9, 0, 1, TimeUnit.SECONDS).skipUntil(Observable.timer(4, TimeUnit.SECONDS)).subscribe(getBaseObsever("operatorsSikpUnitl"))
    }
    /**
     * 运行结果如下:
     * com.ypz.rxjavademo I/operatorsSikpUnitl: onSubscribe
     * com.ypz.rxjavademo I/operatorsSikpUnitl: onNextValue:5
     * com.ypz.rxjavademo I/operatorsSikpUnitl: onNextValue:6
     * com.ypz.rxjavademo I/operatorsSikpUnitl: onNextValue:7
     * com.ypz.rxjavademo I/operatorsSikpUnitl: onNextValue:8
     * com.ypz.rxjavademo I/operatorsSikpUnitl: onNextValue:9
     * 相关源码如下:
     * */
    /**
     * Returns an Observable that skips items emitted by the source ObservableSource until a second ObservableSource emits
     * an item.
     *
     * @param  the element type of the other ObservableSource
     * @param other
     *            the second ObservableSource that has to emit an item before the source ObservableSource's elements begin
     *            to be mirrored by the resulting ObservableSource
     * @return an Observable that skips items from the source ObservableSource until the second ObservableSource emits an
     *         item, then emits the remaining items
     */
    @CheckReturnValue
    @SchedulerSupport(SchedulerSupport.NONE)
    public final <U> Observable<T> skipUntil(ObservableSource<U> other) {
        ObjectHelper.requireNonNull(other, "other is null");
        return RxJavaPlugins.onAssembly(new ObservableSkipUntil<T, U>(this, other));
    }
public final class ObservableSkipUntil<T, U> extends AbstractObservableWithUpstream<T, T> {
    final ObservableSource<U> other;
    public ObservableSkipUntil(ObservableSource<T> source, ObservableSource<U> other) {
        super(source);
        this.other = other;
    }

    @Override
    public void subscribeActual(Observer<? super T> child) {

        final SerializedObserver<T> serial = new SerializedObserver<T>(child);

        final ArrayCompositeDisposable frc = new ArrayCompositeDisposable(2);

        serial.onSubscribe(frc);

        final SkipUntilObserver<T> sus = new SkipUntilObserver<T>(serial, frc);

        other.subscribe(new SkipUntil(frc, sus, serial));

        source.subscribe(sus);
    }
    final class SkipUntil implements Observer<U> {
        @Override
        public void onNext(U t) {
            upstream.dispose();
            sus.notSkipping = true;
        }
    }
    static final class SkipUntilObserver<T> implements Observer<T> {
        @Override
        public void onNext(T t) {
            if (notSkippingLocal) {
                downstream.onNext(t);
            } else
            if (notSkipping) {
                notSkippingLocal = true;
                downstream.onNext(t);
            }
        }
    }
}

结合代码可以得到：

• SikpUnitl的核心在于 ObservableSkipUntil 的实现
• ObservableSkipUntil 的核心在于 SkipUntilObserver 以及 SkipUntil 两个类的实现
  – SkipUntil 类在于控制是否终止跳过数据，当它开始发射则视为终止跳过数据
  – SkipUntilObserver 实现决定了事件的发射，当他接收到终止跳过数据发射的条件的时候才会发射数据

---

SkipWhile

SkipWhile:discard items emitted by an Observable until a specified condition becomes false
SkipWhile作用判断Observable发射的数据直到满足某个条件前都会将数据跳过
原理图如下:

示例代码以及源码如下

    private fun operatorsSikpWhile() {
        Observable.range(1, 9).skipWhile(object : Predicate<Int> {
            override fun test(t: Int): Boolean = (t <= 3)
        }).subscribe(getBaseObsever("operatorsSikpWhile"))
    }
    /**
     * 运行结果如下:
     * com.ypz.rxjavademo I/operatorsSikpWhile: onSubscribe
     * com.ypz.rxjavademo I/operatorsSikpWhile: onNextValue:4
     * com.ypz.rxjavademo I/operatorsSikpWhile: onNextValue:5
     * com.ypz.rxjavademo I/operatorsSikpWhile: onNextValue:6
     * com.ypz.rxjavademo I/operatorsSikpWhile: onNextValue:7
     * com.ypz.rxjavademo I/operatorsSikpWhile: onNextValue:8
     * com.ypz.rxjavademo I/operatorsSikpWhile: onNextValue:9
     * 相关源码如下：
     * */
    /**
     * Returns an Observable that skips all items emitted by the source ObservableSource as long as a specified
     * condition holds true, but emits all further source items as soon as the condition becomes false.
     *
     * @param predicate
     *            a function to test each item emitted from the source ObservableSource
     * @return an Observable that begins emitting items emitted by the source ObservableSource when the specified
     *         predicate becomes false
     */
    @CheckReturnValue
    @SchedulerSupport(SchedulerSupport.NONE)
    public final Observable<T> skipWhile(Predicate<? super T> predicate) {
        ObjectHelper.requireNonNull(predicate, "predicate is null");
        return RxJavaPlugins.onAssembly(new ObservableSkipWhile<T>(this, predicate));
    }
    
public final class ObservableSkipWhile<T> extends AbstractObservableWithUpstream<T, T> {
    final Predicate<? super T> predicate;
    public ObservableSkipWhile(ObservableSource<T> source, Predicate<? super T> predicate) {
        super(source);
        this.predicate = predicate;
    }
    static final class SkipWhileObserver<T> implements Observer<T>, Disposable {
        final Observer<? super T> downstream;
        final Predicate<? super T> predicate;
        Disposable upstream;
        boolean notSkipping;
        SkipWhileObserver(Observer<? super T> actual, Predicate<? super T> predicate) {
            this.downstream = actual;
            this.predicate = predicate;
        }
        @Override
        public void onNext(T t) {
            if (notSkipping) {
                downstream.onNext(t);
            } else {
                boolean b;
                try {
                    b = predicate.test(t);
                } catch (Throwable e) {
                    Exceptions.throwIfFatal(e);
                    upstream.dispose();
                    downstream.onError(e);
                    return;
                }
                if (!b) {
                    notSkipping = true;
                    downstream.onNext(t);
                }
            }
        }
    }
}

结合代码可以得到：

• SkipWhile的核心在于 ObservableSkipWhile 以及 Predicate 的实现
• Predicate 的核心判断是否条件是否满足
• ObservableSkipWhile 的核心在于 SkipWhileObserver 的实现
• 跳过数据发射核心在于 SkipWhileObserver 中的 onNext 对 Predicate 反复调用

---

TakeUntil

TakeUntil:discard any items emitted by an Observable after a second Observable emits an item or terminates
TakeUntil作用与SkipUntil类似不过区别在于它是直到某个条件成立时则不在发射数据
原理图如下:

示例代码以及源码如下

    private fun operatorsTakeUntil() {
        Observable.range(1, 9).takeUntil(object : Predicate<Int> {
            override fun test(t: Int): Boolean = t == 3
        }).subscribe(getBaseObsever("operatorsTakeUntil"))
    }

    /**
     * 运行结果如下:
     * com.ypz.rxjavademo I/operatorsTakeUntil: onSubscribe
     * com.ypz.rxjavademo I/operatorsTakeUntil: onNextValue:1
     * com.ypz.rxjavademo I/operatorsTakeUntil: onNextValue:2
     * com.ypz.rxjavademo I/operatorsTakeUntil: onNextValue:3
     * */

    /**
     * Returns an Observable that emits items emitted by the source Observable, checks the specified predicate
     * for each item, and then completes when the condition is satisfied.
     *
     * @param stopPredicate
     *            a function that evaluates an item emitted by the source Observable and returns a Boolean
     * @return an Observable that first emits items emitted by the source Observable, checks the specified
     *         condition after each item, and then completes when the condition is satisfied.
     * @see Observable#takeWhile(Predicate)
     * @since 1.1.0
     */
    @CheckReturnValue
    @SchedulerSupport(SchedulerSupport.NONE)
    public final Observable<T> takeUntil(Predicate<? super T> stopPredicate) {
        ObjectHelper.requireNonNull(stopPredicate, "stopPredicate is null");
        return RxJavaPlugins.onAssembly(new ObservableTakeUntilPredicate<T>(this, stopPredicate));
    }
public final class ObservableTakeUntilPredicate<T> extends AbstractObservableWithUpstream<T, T> {
    final Predicate<? super T> predicate;
    public ObservableTakeUntilPredicate(ObservableSource<T> source, Predicate<? super T> predicate) {
        super(source);
        this.predicate = predicate;
    }

    @Override
    public void subscribeActual(Observer<? super T> observer) {
        source.subscribe(new TakeUntilPredicateObserver<T>(observer, predicate));
    }

    static final class TakeUntilPredicateObserver<T> implements Observer<T>, Disposable {
        final Observer<? super T> downstream;
        final Predicate<? super T> predicate;
        Disposable upstream;
        boolean done;
        TakeUntilPredicateObserver(Observer<? super T> downstream, Predicate<? super T> predicate) {
            this.downstream = downstream;
            this.predicate = predicate;
        }
        @Override
        public void onNext(T t) {
            if (!done) {
                downstream.onNext(t);
                boolean b;
                try {
                    b = predicate.test(t);
                } catch (Throwable e) {
                    Exceptions.throwIfFatal(e);
                    upstream.dispose();
                    onError(e);
                    return;
                }
                if (b) {
                    done = true;
                    upstream.dispose();
                    downstream.onComplete();
                }
            }
        }
    }
}

结合代码可以得到：

• TakeUntil 的核心是 ObservableTakeUntilPredicate 以及 Predicate 的实现
• ObservableTakeUntilPredicate 核心在于 TakeUntilPredicateObserver 的实现
• TakeUntilPredicateObserver 在 onNext 中也是反复调用 Predicate 以此判断是否取消事件的订阅

---

TakeWhile

TakeWhile:mirror items emitted by an Observable until a specified condition becomes false
TakeWhile作用当条件不成立的时候不在发射数据
原理图如下:

示例代码以及源码如下

    private fun operatorsTakeWhen() {
        Observable.range(1, 9).takeWhile(object : Predicate<Int> {
            override fun test(t: Int): Boolean = t <= 3
        }).subscribe(getBaseObsever("operatorsTakeUntil"))
    }
    /**
     * 运行结果如下:
     * com.ypz.rxjavademo I/operatorsTakeUntil: onSubscribe
     * com.ypz.rxjavademo I/operatorsTakeUntil: onNextValue:1
     * com.ypz.rxjavademo I/operatorsTakeUntil: onNextValue:2
     * com.ypz.rxjavademo I/operatorsTakeUntil: onNextValue:3
     * */
    /**
     * Returns an Observable that emits items emitted by the source ObservableSource so long as each item satisfied a
     * specified condition, and then completes as soon as this condition is not satisfied.
     *
     * @param predicate
     *            a function that evaluates an item emitted by the source ObservableSource and returns a Boolean
     * @return an Observable that emits the items from the source ObservableSource so long as each item satisfies the
     *         condition defined by {@code predicate}, then completes
     * @see Observable#takeUntil(Predicate)
     */
    @CheckReturnValue
    @SchedulerSupport(SchedulerSupport.NONE)
    public final Observable<T> takeWhile(Predicate<? super T> predicate) {
        ObjectHelper.requireNonNull(predicate, "predicate is null");
        return RxJavaPlugins.onAssembly(new ObservableTakeWhile<T>(this, predicate));
    }
public final class ObservableTakeWhile<T> extends AbstractObservableWithUpstream<T, T> {
    final Predicate<? super T> predicate;
    public ObservableTakeWhile(ObservableSource<T> source, Predicate<? super T> predicate) {
        super(source);
        this.predicate = predicate;
    }

    @Override
    public void subscribeActual(Observer<? super T> t) {
        source.subscribe(new TakeWhileObserver<T>(t, predicate));
    }

    static final class TakeWhileObserver<T> implements Observer<T>, Disposable {
        final Observer<? super T> downstream;
        final Predicate<? super T> predicate;

        Disposable upstream;

        boolean done;

        TakeWhileObserver(Observer<? super T> actual, Predicate<? super T> predicate) {
            this.downstream = actual;
            this.predicate = predicate;
        }

        @Override
        public void onSubscribe(Disposable d) {
            if (DisposableHelper.validate(this.upstream, d)) {
                this.upstream = d;
                downstream.onSubscribe(this);
            }
        }
        @Override
        public void onNext(T t) {
            if (done) {
                return;
            }
            boolean b;
            try {
                b = predicate.test(t);
            } catch (Throwable e) {
                Exceptions.throwIfFatal(e);
                upstream.dispose();
                onError(e);
                return;
            }

            if (!b) {
                done = true;
                upstream.dispose();
                downstream.onComplete();
                return;
            }

            downstream.onNext(t);
        }
    }
}

结合代码可以得到：

• takeWhile 的核心在于 ObservableTakeWhile 以及 Predicate 的实现
• 不在发射数据条件的核心在于 Predicate 的实现
• ObservableTakeWhile 的核心在于TakeWhileObserver 的实现
• TakeWhileObserver 在 onNext 中不断调用 Predicate 直到满足条件终止发射

---

总结

• All 作用判断Observable是否所有的发射都满足某一个条件
  – All 结束运算的时候会返回 Boolean
  – 当然当运行异常的时候还是会产生Error事件，建议使用 SingleObsever< Boolean > 避免一些不必要的运行异常
  – All 的核心接口是Predicate的实现，通过 AllObserve r中onNext 的实现反复调用 Predicate 然后返回运算结果
• Amb 作用将多个Observables发射时进行取舍只发射运算速度最快的Observable其余被舍弃
  – ObservableAmb 中的 subscribeActual 实现了中转 订阅
  – AmbCoordinator 负责真正的事件发送 其中其 win 决定了哪个Observable是真正被发射的而其余则被舍弃
  – AmbInnerObserver 负责在真正需要发射的 Observable 发射事件时
  – 及时调用 AmbCoordinator 中 win 方法用来通知AmbCoordinator 舍弃其余Observables
• Contains作用判断Observable是否所有的发射元素是否包含某一个元素
  – contains 基于 any 的实现
  – 是否包含的核心是基于 EqualsPredicate 的实现
  – EqualsPredicate 是 Predicate的一种实现
• DefaultIfEmpty 作用当Observable是一个Empty的Observable的时候会发射出一个默认的数据出去
  –DefaultIfEmpty基于 ObservableSwitchIfEmpty 以及 just 的实现
  – ObservableSwitchIfEmpty 的核心实现对原来的Observable进行判断是否为 Empty 是则调用 just
  –要区分出什么时候才会调用 just
• SequenceEqual 作用判断两个Observable是否一致
  –两种对比方式，对比方式区别在于ObjectHelper.equalsPredicate() 以及自定义 BiPredicate 的实现
  – 对比法核心是 ObservableSequenceEqualSingle 以及 Predicate 的实现
  – ObservableSequenceEqualSingle 的核心在于 EqualCoordinator 以及 EqualObserver 的实现
  – EqualCoordinator 专注于数据的对比
  – EqualObserver 专注于事件的发送
  – 注意ObjectHelper.equalsPredicate() 是 BiPredicate 一种实现
• SkipUntil 作用到达某一个条件前丢弃需要发射的数据
  – SikpUnitl的核心在于 ObservableSkipUntil 的实现
  – ObservableSkipUntil 的核心在于 SkipUntilObserver 以及 SkipUntil 两个类的实现
  ---- SkipUntil 类在于控制是否终止跳过数据，当它开始发射则视为终止跳过数据
  ---- SkipUntilObserver 实现决定了事件的发射，当他接收到终止跳过数据发射的条件的时候才会发射数据
• SkipWhile作用判断Observable发射的数据直到满足某个条件前都会将数据跳过
  – SkipWhile的核心在于 ObservableSkipWhile 以及 Predicate 的实现
  – Predicate 的核心判断是否条件是否满足
  – ObservableSkipWhile 的核心在于 SkipWhileObserver 的实现
  – 跳过数据发射核心在于 SkipWhileObserver 中的 onNext 对 Predicate 反复调用
• TakeUntil 作用某个条件成立时则不在发射数据
  – TakeUntil 的核心是 ObservableTakeUntilPredicate 以及 Predicate 的实现
  – ObservableTakeUntilPredicate 核心在于 TakeUntilPredicateObserver 的实现
  – TakeUntilPredicateObserver 在 onNext 中也是反复调用 Predicate 以此判断是否取消事件的订阅
• TakeWhile 作用当条件不成立的时候不在发射数据
  – takeWhile 的核心在于 ObservableTakeWhile 以及 Predicate 的实现
  – 不在发射数据条件的核心在于 Predicate 的实现
  – ObservableTakeWhile 的核心在于TakeWhileObserver 的实现
  – TakeWhileObserver 在 onNext 中不断调用 Predicate 直到满足条件终止发射
• Predicate
  – 在RxJava中十分常见作为条件实现器，用它作为一种条件准则当它满足或者不满足的时候则会根据其结果做相应的条件或者一些逻辑上的操作
• BiPredicate
  –在RxJava中十分常见作为条件实现器，用它作为对比是否相等一种条件准则当它满足或者不满足的时候则会根据其结果做相应的条件或者一些逻辑上的操作
  最后附上项目github地址