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