Observable.create(new ObservableOnSubscribe() {

// 1. 被观察者发送事件 = 参数为整型 = 1、2、3

@Override

public void subscribe(ObservableEmitter emitter) throws Exception {

emitter.onNext(1);

emitter.onNext(2);

emitter.onNext(3);

}

// 2. 使用Map变换操作符中的Function函数对被观察者发送的事件进行统一变换：整型变换成字符串类型

}).map(new Function<Integer, String>() {

@Override

public String apply(Integer integer) throws Exception {

return “使用 Map变换操作符 将事件” + integer +“的参数从 整型”+integer + " 变换成 字符串类型" + integer ;

}

// 3. 观察者接收事件时，是接收到变换后的事件 = 字符串类型

}).subscribe(new Observer() {

@Override

public void onSubscribe(Disposable d) {

}

@Override

public void onNext(String s) {

Log.d(TAG, s);

}

@Override

public void onError(Throwable e) {

}

@Override

public void onComplete() {

}

});

输出结果

使用 Map变换操作符 将事件1的参数从 整型1 变换成 字符串类型1

使用 Map变换操作符 将事件2的参数从 整型2 变换成 字符串类型2

使用 Map变换操作符 将事件3的参数从 整型3 变换成 字符串类型3

map 源码分析

---

• 借鉴前面几篇博客的分析，我们先来看一下 Observable 的 map 方法，它的套路跟 create 方法的套路也是相似的，判空是否为 null，为 null 抛出异常。

• 接着，用一个包装类包装当前的 Observable 实例，只不过这个包装类是 ObservableMap。在 ObsevableMap 里面持有上游 observable 实例的引用，这个是典型的装饰者模式. 关于装饰者模式，可以参考我的这一篇博客。装饰者模式及其应用

public final Observable map(Function<? super T, ? extends R> mapper) {

ObjectHelper.requireNonNull(mapper, “mapper is null”);

return RxJavaPlugins.onAssembly(new ObservableMap<T, R>(this, mapper));

}

接下来，我们一起来看一下 ObservableMap。

public final class ObservableMap<T, U> extends AbstractObservableWithUpstream<T, U> {

final Function<? super T, ? extends U> function;

public ObservableMap(ObservableSource source, Function<? super T, ? extends U> function) {

super(source);

this.function = function;

}

@Override

public void subscribeActual(Observer<? super U> t) {

source.subscribe(new MapObserver<T, U>(t, function));

}

}

在前面博客中，我们已经说到，当我们调用 observable.subscribe(observer) 的时候，代码调用逻辑是这样的。

在 observable 的 subscribeActual 方法中

• 如果有上游的话，会调用上游的 subscribe 方法（即 source.subscribe() 方法)，而在 subscribe 方法中，又会调用当前 observable 的 subcribeActual 方法

• 如果没有上游的话，会直接调用当前 Observable 的 subscirbe 方法，并调用 observable 的 onSuscribe 方法

在 ObservableMap 的 subscribeActual 方法里面，MapObserver 类对 Observer 进行包装，又是这样的套路，装饰者模式。

static final class MapObserver<T, U> extends BasicFuseableObserver<T, U> {

final Function<? super T, ? extends U> mapper;

MapObserver(Observer<? super U> actual, Function<? super T, ? extends U> mapper) {

super(actual);

this.mapper = mapper;

}

@Override

public void onNext(T t) {

// 1 判断是否 done，如果已经 done ，直接返回

if (done) {

return;

}

if (sourceMode != NONE) {

actual.onNext(null);

return;

}

U v;

try {

// 2 调用 mapper.apply(t) ，进行相应的转化

v = ObjectHelper.requireNonNull(mapper.apply(t), “The mapper function returned a null value.”);

} catch (Throwable ex) {

fail(ex);
de != NONE) {

actual.onNext(null);

return;

}

U v;

try {

// 2 调用 mapper.apply(t) ，进行相应的转化

v = ObjectHelper.requireNonNull(mapper.apply(t), “The mapper function returned a null value.”);

} catch (Throwable ex) {

fail(ex);