RxJava基础操作符 lift 与 compose区别

public interface Operator<R, T> extends Func1<Subscriber<? super R>, Subscriber<? super T>> {
	// cover for generics insanity
}
lift(Operator<? extends R, ? super T> operator)//用来转换Subscriber

public interface Transformer<T, R> extends Func1<Observable<T>, Observable<R>> {
	// cover for generics insanity
}
compose(Transformer<? super T, ? extends R> transformer)//用来转换Observable，如bindUtilEvent


.compose(this.<Integer>getCompose5())
.lift(this.toList())

 private Operator<List<String>, ? super Integer> toList() {
        return new Operator<List<String>, Integer>() {
            @Override
            public Subscriber<Integer> call(final Subscriber<? super List<String>> oldSubscriber) {//参数是被转换前的Subscriber，经过以下装饰包装转换，变成新的Subscriber
                return new Subscriber<Integer>() {//中间新插入的Subscriber，会被上一层级的Subscriber调用，再调用参数Subscriber，像链表一样，上下衔接上了
                    ArrayList<String> list = new ArrayList<>();
                    boolean isComplete;

                    @Override
                    public void onCompleted() {
                        Log.e("CacheManager", "toList  onCompleted  ---- test  ");
                        if (!isComplete) {
                            isComplete = true;
                            oldSubscriber.onNext(list);
                        }
                        oldSubscriber.onCompleted();
                    }

                    @Override
                    public void onError(Throwable e) {
                        Log.e("CacheManager", "toList  onError  ---- test  " + e.getMessage());
                        oldSubscriber.onError(e);
                    }

                    @Override
                    public void onNext(Integer integer) {
                        Log.e("CacheManager", "toList onNext  ----   " + integer);
                        if (!isComplete) {
                            list.add("list " + integer);
                        }
                    }
                };
            }
        };
    }

    private <T> Transformer<T, String> getCompose5() {
        return new Transformer<T, String>() {
            @Override
            public Observable<String> call(Observable<T> OldObservable) {//参数是之前的转换前的Observable，通过以下的装饰包装，变成带有新特性的Observable
                Log.e("CacheManager", "compose : getCompose5  ---- call  " + OldObservable);
                return OldObservable.map(new Func1<T, String>() {
                    @Override
                    public String call(T t) {
                        return t.toString() + "  __nimei";
                    }
                });
            }
        };
    }