变换

Rxjava可以将传入的参数操作修改之后继续往下传，即可以把数据进行变换之后再做操作。

map

Observable.just(R.mipmap.ic_launcher).
            map(new Func1<Integer, Bitmap>() {
                @Override
                public Bitmap call(Integer id) {
                    return BitmapFactory.decodeResource(getResources(), id);
                }
            })
            .subscribe(new Action1<Bitmap>() {
                @Override
                public void call(Bitmap bitmap) {
                    iv.setImageBitmap(bitmap);
                }
            });

上述例子可以把资源文件转换成bitmap图片之后再做操作。

//Observable的map方法
public final <R> Observable<R> map(Func1<? super T, ? extends R> func) {
    return lift(new OperatorMap<T, R>(func));
}
//OperatorMap类
public final class OperatorMap<T, R> implements Operator<R, T> {
      private final Func1<? super T, ? extends R> transformer;
      public OperatorMap(Func1<? super T, ? extends R> transformer) {
          this.transformer = transformer;
      }
}
//Observable的lift方法 
public final <R> Observable<R> lift(final Operator<? extends R, ? super T> operator) {
    return new Observable<R>(new OnSubscribe<R>() {
        @Override
        public void call(Subscriber<? super R> o) {
            try {
                Subscriber<? super T> st = hook.onLift(operator).call(o); //调用operator的call方法，并把subscriber当做参数传入，并把function封装成一个subscriber返回
                try {
                    st.onStart();
                    onSubscribe.call(st);将封装function的当参数传入
                } catch (Throwable e) {
                    Exceptions.throwIfFatal(e);
                    st.onError(e);
                }
            } catch (Throwable e) {
                Exceptions.throwIfFatal(e);
                o.onError(e);
            }
        }
    });
}
//Operator的call方法
public Subscriber<? super T> call(final Subscriber<? super R> o) {
    return new Subscriber<T>(o) {
        @Override
        public void onCompleted() {
            o.onCompleted();
        }
        @Override
        public void onError(Throwable e) {
            o.onError(e);
        }
        @Override
        public void onNext(T t) {
            try {
                o.onNext(transformer.call(t));  //查看构造函数 transformer就是map方法里的function1
            } catch (Throwable e) {
                Exceptions.throwOrReport(e, this, t);
            }
        }
    };
   }

lift方法里创建一个新的Observable方法，所以subscribe方法会调用新建的Observable.onObserve.call。这个call里作了两件事：

• 调用operator的call方法返回一个subscriber对象。
• 调用原Observable.onObserve.call方法，并把上一步subscriber对象当作参数传入。

原Observabel.onObserve.call方法是我们自己实现的会调用operator.call返回的subscriber的onnext方法，该onnext方法调用了原subscriber对象的onNext方法，并把function1的call方法的返回值作为参数。

flatmap