首先看一段Map函數的使用代碼：

Observable.create(new Observable.OnSubscribe<Integer>() {@Overridepublic void call(Subscriber<? super Integer> subscriber) {subscriber.onNext(123);}}).map(new Func1<Integer, String>() {@Overridepublic String call(Integer integer) {return integer.toString();}}).subscribe(new Subscriber<String>() {public static final String TAG ="Test" ;@Overridepublic void onCompleted() {}@Overridepublic void onError(Throwable e) {}@Overridepublic void onNext(String s) {Log.d(TAG, "onNext: "+s);}});

Observable<Integer>Observable1=Observable.create(new Observable.OnSubscribe<Integer>() {
? ? @Override

? ? public void call(Subscriber<? super Integer> subscriber) { subscriber.onNext(123); }

? })；

create函數構建了一個新的Observable 在Observable的構造函數中將Observable.onSubscribe屬性賦值為 Observable.OnSubscribe<Integer>;
Observable<String> Observable2= Observable1.map(new Func1<Integer, String>() {
? ? ?@Override
? ? ?public String call(Integer integer) {
? ? ?return null;
? ?}});
通過 map函數構建了一個新的Observable
map函數源碼：
public final <R> Observable<R> map(Func1<? super T, ? extends R> func) {
? ? ?return lift(new OperatorMap<T, R>(func));
}
在map源碼中首先通過func(這里的func指的就是Func1<Integer, String>())參數構建一個OperatorMap類；
public OperatorMap(Func1<? super T, ? extends R> transformer) {
? ?this.transformer = transformer;
}
OperatorMap.transformer 也指向了Func1<Integer, String>()；

lift函數里面創建了一個新的Observable，而上邊的Observable<String> Observable2也就是lift函數創建的；
public final <R> Observable<R> lift(final Operator<? extends R, ? super T> operator) {
return new Observable<R>(new OnSubscribeLift<T, R>(onSubscribe, operator));
}
public final class OnSubscribeLift<T, R> implements OnSubscribe<R>

在構造函數中傳了一個OnSubscribeLift對象，因此Observable2.onSubscribe 也就指向了OnSubscribeLift；

public OnSubscribeLift(OnSubscribe<T> parent, Operator<? extends R, ? super T> operator) {
this.parent = parent;
this.operator = operator;
}
在OnSubscribeLift的構造函數中parent 被指向為Observable1中的OnSubscribe（Observable.OnSubscribe<Integer>()）
operator指向OperatorMap；
通過Map函數就創建了一個新的Observable，所有開頭的例子的代碼就變成了
Observable2 .subscribe(new Subscriber<String>() {
public static final String TAG ="125" ;

@Override
public void onCompleted() {

}

@Override
public void onError(Throwable e) {

}

@Override
public void onNext(String s) {
Log.d(TAG, "onNext: "+s);
}
});
然后在分析下subscribe函數：
public final Subscription subscribe(Subscriber<? super T> subscriber) {
return Observable.subscribe(subscriber, this);
}
在Observable.subscribe(subscriber, this); 中的this 指向的是Observable2；

static <T> Subscription subscribe(Subscriber<? super T> subscriber, Observable<T> observable) {
.................
subscriber.onStart();
hook.onSubscribeStart(observable, observable.onSubscribe).call(subscriber);
return hook.onSubscribeReturn(subscriber);
.................
}
從subscribe函數代碼可以看出，最終調用的是onSubscribe的call函數；
此時的onSubscribe指向的是Observable2.onSubscribe 也就是早lift函數中創建的OnSubscribeLift；
在OnSubscribeLift.java 代碼中:
public void call(Subscriber<? super R> o) {
.............
Subscriber<? super T> st = hook.onLift(operator).call(o);

st.onStart();
parent.call(st);
............
}
在call函數中參數 Subscriber<? super R> o指向的是subscribe函數中的Subscriber<String>()；
call函數的內部首先創建了一個新的 Subscriber<? super T> st;
此時的operator指向的是OperatorMap類
新的Subcriber（MapSubscriber對象）放入訂閱列表中，以便最后一起把訂閱對象釋放。同時返回新的Subcriber。
public Subscriber<? super T> call(final Subscriber<? super R> o) {
? ?MapSubscriber<T, R> parent = new MapSubscriber<T, R>(o, transformer);
? ?o.add(parent);
? ?return parent;
}
static final class MapSubscriber<T, R> extends Subscriber<T> {
? public MapSubscriber(Subscriber<? super R> actual, Func1<? super T, ? extends R> mapper) {
? ?this.actual = actual;
? ?this.mapper = mapper;
? }
}
在OperatorMap類的call方法中創建了一個新的MapSubscriber對象；
在創建的MapSubscriber對象的構造函數中對字段進行賦值
actual 指向 o 也就是subscribe函數中的Subscriber<String>()；
mapper 指向OperatorMap.transformer (指向了map函數的中參數Func1<Integer, String>())

回到在OnSubscribeLift.call 代碼中，當創建好新的Subscriber對象后，將執行
parent.call(st)；
此時的parent 指向的是Observable1中的OnSubscribe，因此調用的call方法相當于是
public void call(Subscriber<? super Integer> subscriber) {
? subscriber.onNext(123);
}
此時的subscriber 就是新建的st(MapSubscriber) 跳轉到onNext函數中；
static final class MapSubscriber<T, R> extends Subscriber<T> {
public void onNext(T t) {
? R result;

? ? try {
? ? ?result = mapper.call(t);
? ?} catch (Throwable ex) {
? ?Exceptions.throwIfFatal(ex);
? ?unsubscribe();
? ?onError(OnErrorThrowable.addValueAsLastCause(ex, t));
? ?return;
? }

? ?actual.onNext(result);
}
}
此時的參數t為123；執行mapper.call(t);
mapper此時執行的是
public String call(Integer integer) {
return integer.toString();
}
result 就變為了"123";
然后在執行actual.onNext("123");
actual此時就是：
public void onNext(String s) {
Log.d(TAG, "onNext: "+s);
}

到現在為止，整個流程代碼就分析完成了

轉載于:https://www.cnblogs.com/h20064528/p/6543071.html

總結

以上是生活随笔為你收集整理的RxJava 中的Map函数原理分析的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。