分析SafeIterableMap在livedata的作用：
监听livedata数据的类都会存储到SafeIterableMap中，当livedata数据变化，即调用setvalue会遍历SafeIterableMap，并进行通知。
for (Iterator<Map.Entry<Observer<T>, ObserverWrapper>> iterator =
mObservers.iteratorWithAdditions(); iterator.hasNext(); ) {
considerNotify(iterator.next().getValue());
if (mDispatchInvalidated) {
break;
}
}
其中considerNotify会在生命周期内调用observer.mObserver.onChanged((T) mData);从而更新各个observer的数据。
SafeIterableMap的数据结构
SafeIterable，同其名：迭代的时候，修改map结构是安全的。 下面来看下他的设计思路。
注意：不是线程安全的
// LinkedList, which pretends to be a map and supports modifications during iterations.
private SafeIterableMap<Observer<T>, ObserverWrapper> mObservers =
new SafeIterableMap<>();
1.构造函数: 默认构造函数
public class SafeIterableMap<K, V> implements Iterable<Map.Entry<K, V>>
2. 增
注：livedata实际调用的是putIfAbsent，如果key相同，且就不用再添加。
/**
* If the specified key is not already associated
* with a value, associates it with the given value.
*
* @param key key with which the specified value is to be associated
* @param v value to be associated with the specified key
* @return the previous value associated with the specified key,
* or {@code null} if there was no mapping for the key
*/
public V putIfAbsent(@NonNull K key, @NonNull V v) {
Entry<K, V> entry = get(key);
if (entry != null) {
return entry.mValue;
}
put(key, v);
return null;
}
protected Entry<K, V> put(@NonNull K key, @NonNull V v) {
Entry<K, V> newEntry = new Entry<>(key, v);
mSize++;
if (mEnd == null) {
mStart = newEntry;
mEnd = mStart;
return newEntry;
}
mEnd.mNext = newEntry;
newEntry.mPrevious = mEnd;
mEnd = newEntry;
return newEntry;
}
private Entry<K, V> mStart;
private Entry<K, V> mEnd;
由上面添加方式知道，每次新增数据都将Entry添加到map的尾部mEnd
3.查
/**
* @return an ascending iterator, which doesn't include new elements added during an
* iteration.
*/
@NonNull
@Override
public Iterator<Map.Entry<K, V>> iterator() {
ListIterator<K, V> iterator = new AscendingIterator<>(mStart, mEnd);
mIterators.put(iterator, false);
return iterator;
}
/**
* @return an descending iterator, which doesn't include new elements added during an
* iteration.
*/
public Iterator<Map.Entry<K, V>> descendingIterator() {
DescendingIterator<K, V> iterator = new DescendingIterator<>(mEnd, mStart);
mIterators.put(iterator, false);
return iterator;
}
/**
* return an iterator with additions.
*/
public IteratorWithAdditions iteratorWithAdditions() {
@SuppressWarnings("unchecked")
IteratorWithAdditions iterator = new IteratorWithAdditions();
mIterators.put(iterator, false);
return iterator;
}
上面方法有两步：
a)将iterator添加到mIterators（WeakHashMap）集合中。
b)创建各自的iterator。
三种实现iterator：iterator，descendingIterator，iteratorWithAdditions。
注：iterator，descendingIterator遍历的时候不包含后面新添加的元素。 iteratorWithAdditions包含所有的元素，且从头到尾遍历。
static class AscendingIterator<K, V> extends ListIterator<K, V> {
AscendingIterator(Entry<K, V> start, Entry<K, V> expectedEnd) {
super(start, expectedEnd);
}
@Override
Entry<K, V> forward(Entry<K, V> entry) {
return entry.mNext;
}
@Override
Entry<K, V> backward(Entry<K, V> entry) {
return entry.mPrevious;
}
}
private static class DescendingIterator<K, V> extends ListIterator<K, V> {
DescendingIterator(Entry<K, V> start, Entry<K, V> expectedEnd) {
super(start, expectedEnd);
}
@Override
Entry<K, V> forward(Entry<K, V> entry) {
return entry.mPrevious;
}
@Override
Entry<K, V> backward(Entry<K, V> entry) {
return entry.mNext;
}
}
private class IteratorWithAdditions implements Iterator<Map.Entry<K, V>>, SupportRemove<K, V> {
private Entry<K, V> mCurrent;
private boolean mBeforeStart = true;
@Override
public void supportRemove(@NonNull Entry<K, V> entry) {
if (entry == mCurrent) {
mCurrent = mCurrent.mPrevious;
mBeforeStart = mCurrent == null;
}
}
@Override
public boolean hasNext() {
if (mBeforeStart) {
return mStart != null;
}
return mCurrent != null && mCurrent.mNext != null;
}
@Override
public Map.Entry<K, V> next() {
if (mBeforeStart) {
mBeforeStart = false;
mCurrent = mStart;
} else {
mCurrent = mCurrent != null ? mCurrent.mNext : null;
}
return mCurrent;
}
}
看下他们公共的父类：ListIterator代码
private abstract static class ListIterator<K, V> implements Iterator<Map.Entry<K, V>>,
SupportRemove<K, V> {
Entry<K, V> mExpectedEnd;
Entry<K, V> mNext;
ListIterator(Entry<K, V> start, Entry<K, V> expectedEnd) {
this.mExpectedEnd = expectedEnd;
this.mNext = start;
}
@Override
public boolean hasNext() {
return mNext != null;
}
@Override
public void supportRemove(@NonNull Entry<K, V> entry) {
if (mExpectedEnd == entry && entry == mNext) {
mNext = null;
mExpectedEnd = null;
}
if (mExpectedEnd == entry) {
mExpectedEnd = backward(mExpectedEnd);
}
if (mNext == entry) {
mNext = nextNode();
}
}
private Entry<K, V> nextNode() {
if (mNext == mExpectedEnd || mExpectedEnd == null) {
return null;
}
return forward(mNext);
}
@Override
public Map.Entry<K, V> next() {
Map.Entry<K, V> result = mNext;
mNext = nextNode();
return result;
}
abstract Entry<K, V> forward(Entry<K, V> entry);
abstract Entry<K, V> backward(Entry<K, V> entry);
}
AscendingIterator中mNext为SafeIterableMap头部 DescendingIterator中mNext为SafeIterableMap尾部
重点看下next（）方法，遍历map的核心方法。
由各自的forward方法。知道 AscendingIterator为顺序，DescendingIterator为倒序。
4.删除
/**
* Removes the mapping for a key from this map if it is present.
*
* @param key key whose mapping is to be removed from the map
* @return the previous value associated with the specified key,
* or {@code null} if there was no mapping for the key
*/
public V remove(@NonNull K key) {
Entry<K, V> toRemove = get(key);
if (toRemove == null) {
return null;
}
mSize--;
if (!mIterators.isEmpty()) {
for (SupportRemove<K, V> iter : mIterators.keySet()) {
iter.supportRemove(toRemove);
}
}
if (toRemove.mPrevious != null) {
toRemove.mPrevious.mNext = toRemove.mNext;
} else {
mStart = toRemove.mNext;
}
if (toRemove.mNext != null) {
toRemove.mNext.mPrevious = toRemove.mPrevious;
} else {
mEnd = toRemove.mPrevious;
}
toRemove.mNext = null;
toRemove.mPrevious = null;
return toRemove.mValue;
}
```
上面执行的步骤：
1.获取要删除的Entry（toRemove）
2.size--
3.遍历所有的迭代器，并将所有的迭代器中的next位置重置。
4.将toRemove，头链和尾链都断开，然后重置
5.清空toRemove头尾连接的数据。
6.返回toRemove的值
#### 主要关注下面的代码：
重点：遍历删除是安全的。
```
@Override
public void supportRemove(@NonNull Entry<K, V> entry) {
if (mExpectedEnd == entry && entry == mNext) {
mNext = null;
mExpectedEnd = null;
}
if (mExpectedEnd == entry) {
mExpectedEnd = backward(mExpectedEnd);
}
if (mNext == entry) {
mNext = nextNode();
}
}
