Rxjava(过滤类)-Last

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

bservable.range(1, 10).last().subscribe(new Action1<Integer>() {          @Override          public void call(Integer integer) {              System.out.println(integer);          }        });

输出：

10

我们看一下last函数

 public final Observable<T> last() {        return takeLast(1).single();    }

先看takeLast

 public final Observable<T> takeLast(final int count) {        if (count == 0) {            return ignoreElements();        } else if (count == 1) {            return create(new OnSubscribeTakeLastOne<T>(this));        } else {            return lift(new OperatorTakeLast<T>(count));        }    }

这里创建一个OnSubscribeTakeLastOne

然后调用sngle

    public final Observable<T> single() {        return lift(OperatorSingle.<T> instance());    }

创建了一个OnSubscribeLift，operator是OperatorSingle

然后subscribe,subscribeOnSubscribeLift的call首先调用operator的call

    public Subscriber<? super T> call(final Subscriber<? super T> child) {        final ParentSubscriber<T> parent = new ParentSubscriber<T>(child, hasDefaultValue,                defaultValue);        child.add(parent);        return parent;    }

返回ParentSubscriber

回到OnSubscribeLift的call，接着调用

parent.call(st);

parent是OnSubscribeTakeLastOn

public void call(Subscriber<? super T> t) {        new TakeLastOneSubscriber<T>(t).subscribeTo(source);    }

  public final void subscribeTo(Observable<? extends T> source) {        setupDownstream();        source.unsafeSubscribe(this);    }

这里source的onSubscribe是OnSubscribeRange，最终调用到fastPath

void fastPath() {            final long endIndex = this.endOfRange + 1L;            final Subscriber<? super Integer> childSubscriber = this.childSubscriber;            for (long index = currentIndex; index != endIndex; index++) {                if (childSubscriber.isUnsubscribed()) {                    return;                }                childSubscriber.onNext((int) index);            }            if (!childSubscriber.isUnsubscribed()) {                childSubscriber.onCompleted();            }        }

这里的childSubscriber是TakeLastOneSubscriber

 public void onNext(T t) {            value = t;        }

它的onNext仅仅是把值保存到了value

最终会调用它的onComplete

public void onCompleted() {            Object o = value;            if (o == EMPTY) {                complete();            } else {                complete((T)o);            }        }

走else分支

protected final void complete(R value) {        Subscriber<? super R> a = actual;        for (;;) {            int s = state.get();            if (s == NO_REQUEST_HAS_VALUE || s == HAS_REQUEST_HAS_VALUE || a.isUnsubscribed()) {                return;            }            if (s == HAS_REQUEST_NO_VALUE) {                a.onNext(value);                if (!a.isUnsubscribed()) {                    a.onCompleted();                }                state.lazySet(HAS_REQUEST_HAS_VALUE);                return;            }            this.value = value;            if (state.compareAndSet(NO_REQUEST_NO_VALUE, NO_REQUEST_HAS_VALUE)) {                return;            }        }    }

这里s为HAS_REQUEST_NO_VALUE 最终先调用onNext，然后调用onCompleted