摘要：也是我們使用非常多的，它是基于哈希表的接口的實(shí)現(xiàn)，以的形式存在。源碼分析三個(gè)構(gòu)造函數(shù)默認(rèn)初始容量，默認(rèn)加載因子構(gòu)造一個(gè)帶指定初始容量和默認(rèn)加載因子的空。該臨界點(diǎn)在當(dāng)中元素的數(shù)量等于數(shù)組長(zhǎng)度加載因子。
HashMap也是我們使用非常多的Collection，它是基于哈希表的 Map 接口的實(shí)現(xiàn)，以key-value的形式存在。在HashMap中，key-value總是會(huì)當(dāng)做一個(gè)整體來(lái)處理，系統(tǒng)會(huì)根據(jù)hash算法來(lái)來(lái)計(jì)算key-value的存儲(chǔ)位置，我們總是可以通過(guò)key快速地存、取value。
HashMap
HashMap.java源碼分析：?
三個(gè)構(gòu)造函數(shù)：?
HashMap():默認(rèn)初始容量capacity（16），默認(rèn)加載因子factor（0.75）?
HashMap(int initialCapacity)：構(gòu)造一個(gè)帶指定初始容量和默認(rèn)加載因子 (0.75) 的空 HashMap。?
HashMap(int initialCapacity, float loadFactor)：構(gòu)造一個(gè)帶指定初始容量和加載因子的空 HashMap。
/**
* Constructs an empty HashMap with the default initial capacity
* (16) and the default load factor (0.75).
*/
public HashMap() {
this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR);
}
//構(gòu)建自定義初始容量的構(gòu)造函數(shù),默認(rèn)加載因子0.75的HashMap
public HashMap(int initialCapacity) {
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
//構(gòu)造一個(gè)帶指定初始容量和加載因子的空 HashMap
public HashMap(int initialCapacity, float loadFactor) {
...
...
}
HashMap內(nèi)部是使用一個(gè)默認(rèn)容量為16的數(shù)組來(lái)存儲(chǔ)數(shù)據(jù)的，而數(shù)組中每一個(gè)元素卻又是一個(gè)鏈表的頭結(jié)點(diǎn)，所以，更準(zhǔn)確的來(lái)說(shuō)，HashMap內(nèi)部存儲(chǔ)結(jié)構(gòu)是使用哈希表的拉鏈結(jié)構(gòu)（數(shù)組+鏈表），如圖：?
這種存儲(chǔ)數(shù)據(jù)的方法叫做拉鏈法?
且每一個(gè)結(jié)點(diǎn)都是Entry類(lèi)型，那么Entry是什么呢？我們來(lái)看看HashMap中Entry的屬性：
final K key; //key值
V value; //value值
HashMapEntry next;//next下一個(gè)Entry
int hash;//key的hash值
快速存取
put(key,value);
public V put(K key, V value) {
if (table == EMPTY_TABLE) {//判斷table空數(shù)組，
inflateTable(threshold);//創(chuàng)建數(shù)組容量為threshold大小的數(shù)組，threshold在HashMap構(gòu)造函數(shù)中賦值initialCapacity（指定初始容量）;
}
//當(dāng)key為null，調(diào)用putForNullKey方法，保存null與table第一個(gè)位置中，這是HashMap允許key為null的原因
if (key == null)
return putForNullKey(value);
int hash = sun.misc.Hashing.singleWordWangJenkinsHash(key); //計(jì)算key的hash值
int i = indexFor(hash, table.length); //計(jì)算key hash 值在 table 數(shù)組中的位置
//從i出開(kāi)始迭代 e,找到 key 保存的位置
for (HashMapEntry e = table[i]; e != null; e = e.next) {
Object k;
//判斷該條鏈上是否有hash值相同的(key相同)
//若存在相同，則直接覆蓋value，返回舊value
if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
V oldValue = e.value;//舊值 = 新值
e.value = value;
e.recordAccess(this);
return oldValue;//返回覆蓋后的舊值
}
}
//修改次數(shù)增加1
modCount++;
//將key、value添加至i位置處
addEntry(hash, key, value, i);
return null;
}
put過(guò)程分析：這篇文章http://www.cnblogs.com/chenssy/p/3521565.html總結(jié)的可以。
put過(guò)程結(jié)論：?
當(dāng)我們想一個(gè)HashMap中添加一對(duì)key-value時(shí)，系統(tǒng)首先會(huì)計(jì)算key的hash值，然后根據(jù)hash值確認(rèn)在table中存儲(chǔ)的位置。若該位置沒(méi)有元素，則直接插入。否則迭代該處元素鏈表并依此比較其key的hash值。如果兩個(gè)hash值相等且key值相等(e.hash == hash && ((k = e.key) == key || key.equals(k))),則用新的Entry的value覆蓋原來(lái)節(jié)點(diǎn)的value。如果兩個(gè)hash值相等但key值不等 ，則將該節(jié)點(diǎn)插入該鏈表的鏈頭。
void addEntry(int hash, K key, V value, int bucketIndex) {
//獲取bucketIndex處的Entry
Entry e = table[bucketIndex];
//將新創(chuàng)建的 Entry 放入 bucketIndex 索引處，并讓新的 Entry 指向原來(lái)的 Entry
table[bucketIndex] = new Entry(hash, key, value, e);
//若HashMap中元素的個(gè)數(shù)超過(guò)極限了，則容量擴(kuò)大兩倍
if (size++ >= threshold)
resize(2 * table.length);
}
這個(gè)方法中有兩點(diǎn)需要注意：
一是鏈的產(chǎn)生。這是一個(gè)非常優(yōu)雅的設(shè)計(jì)。系統(tǒng)總是將新的Entry對(duì)象添加到bucketIndex處。如果bucketIndex處已經(jīng)有了對(duì)象，那么新添加的Entry對(duì)象將
指向原有的Entry對(duì)象，形成一條Entry鏈，但是若bucketIndex處沒(méi)有Entry對(duì)象，也就是e==null,那么新添加的Entry對(duì)象指向null，也就不會(huì)產(chǎn)生Entry鏈了。
二、擴(kuò)容問(wèn)題。
隨著HashMap中元素的數(shù)量越來(lái)越多，發(fā)生碰撞的概率就越來(lái)越大，所產(chǎn)生的鏈表長(zhǎng)度就會(huì)越來(lái)越長(zhǎng)，這樣勢(shì)必會(huì)影響HashMap的速度，為了保證HashMap的效率，系統(tǒng)必須要在某個(gè)臨界點(diǎn)進(jìn)行擴(kuò)容處理。該臨界點(diǎn)在當(dāng)HashMap中元素的數(shù)量等于table數(shù)組長(zhǎng)度*加載因子。但是擴(kuò)容是一個(gè)非常耗時(shí)的過(guò)程，因?yàn)樗枰匦掠?jì)算這些數(shù)據(jù)在新table數(shù)組中的位置并進(jìn)行復(fù)制處理。所以如果我們已經(jīng)預(yù)知HashMap中元素的個(gè)數(shù)，那么預(yù)設(shè)元素的個(gè)數(shù)能夠有效的提高HashMap的性能。
讀取實(shí)現(xiàn)：get(key)?
相對(duì)于HashMap的存而言，取就顯得比較簡(jiǎn)單了。通過(guò)key的hash值找到在table數(shù)組中的索引處的Entry，然后返回該key對(duì)應(yīng)的value即可。
public V get(Object key) {
// 若為null，調(diào)用getForNullKey方法返回相對(duì)應(yīng)的value
if (key == null)
return getForNullKey();
// 根據(jù)該 key 的 hashCode 值計(jì)算它的 hash 碼
int hash = hash(key.hashCode());
// 取出 table 數(shù)組中指定索引處的值
for (Entry e = table[indexFor(hash, table.length)]; e != null; e = e.next) {
Object k;
//若搜索的key與查找的key相同，則返回相對(duì)應(yīng)的value
if (e.hash == hash && ((k = e.key) == key || key.equals(k)))
return e.value;
}
return null;
}
在不斷的向HashMap里put數(shù)據(jù)時(shí)，當(dāng)達(dá)到一定的容量限制時(shí)（這個(gè)容量滿足這樣的一個(gè)關(guān)系時(shí)候?qū)?huì)擴(kuò)容：HashMap中的數(shù)據(jù)量>容量*加載因子，而HashMap中默認(rèn)的加載因子是0.75），HashMap的空間將會(huì)擴(kuò)大；擴(kuò)大之前容量的2倍 ：resize（newCapacity）
int newCapacity = table.length;//賦值數(shù)組長(zhǎng)度
newCapacity <<= 1;//x2
if (newCapacity > table.length)
resize(newCapacity);//調(diào)整HashMap大小容量為之前table的2倍
這也就是重點(diǎn)所在，為什么在Android上需要使用SparseArray和ArrayMap代替HashMap，主要原因就是Hashmap隨著數(shù)據(jù)不斷增多，達(dá)到最大值時(shí)，需要擴(kuò)容，而且擴(kuò)容的大小是之前的2倍.
SparseArray
SparseArray.java 源碼?
SparseArray比HashMap更省內(nèi)存，在某些條件下性能更好，主要是因?yàn)樗苊饬藢?duì)key的自動(dòng)裝箱（int轉(zhuǎn)為Integer類(lèi)型），它內(nèi)部則是通過(guò)兩個(gè)數(shù)組來(lái)進(jìn)行數(shù)據(jù)存儲(chǔ)的，一個(gè)存儲(chǔ)key，另外一個(gè)存儲(chǔ)value，為了優(yōu)化性能，它內(nèi)部對(duì)數(shù)據(jù)還采取了壓縮的方式來(lái)表示稀疏數(shù)組的數(shù)據(jù)，從而節(jié)約內(nèi)存空間，我們從源碼中可以看到key和value分別是用數(shù)組表示：
private int[] mKeys;//int 類(lèi)型key數(shù)組
private Object[] mValues;//value數(shù)組
構(gòu)造函數(shù)：?
SparseArray():默認(rèn)容量10；?
SparseArray(int initialCapacity):指定特定容量的SparseArray
public SparseArray() {
this(10);
}
public SparseArray(int initialCapacity) {
if (initialCapacity == 0) {//判斷傳入容量值
mKeys = EmptyArray.INT;
mValues = EmptyArray.OBJECT;
} else {//不為0初始化key value數(shù)組
mValues = ArrayUtils.newUnpaddedObjectArray(initialCapacity);
mKeys = new int[mValues.length];
}
mSize = 0;//mSize賦值0
}
從上面創(chuàng)建的key數(shù)組：SparseArray只能存儲(chǔ)key為int類(lèi)型的數(shù)據(jù)，同時(shí)，SparseArray在存儲(chǔ)和讀取數(shù)據(jù)時(shí)候，使用的是二分查找法；
/**
* 二分查找，中間位置的值與需要查找的值循環(huán)比對(duì)
* 小于：范圍從mid+1 ~ h1
* 大于：范圍從0~mid-1
* 等于：找到值返回位置mid
*/
static int binarySearch(int[] array, int size, int value) {
int lo = 0;
int hi = size - 1;
while (lo <= hi) {
final int mid = (lo + hi) >>> 1;
final int midVal = array[mid];
if (midVal < value) {
lo = mid + 1;
} else if (midVal > value) {
hi = mid - 1;
} else {
return mid; // value found
}
}
return ~lo; // value not present
}
SparseArray存取數(shù)據(jù)
SparseArray的put方法：
public void put(int key, E value) {
int i = ContainerHelpers.binarySearch(mKeys, mSize, key);//二分查找數(shù)組mKeys中key存放位置，返回值是否大于等于0來(lái)判斷查找成功
if (i >= 0) {//找到直接替換對(duì)應(yīng)值
mValues[i] = value;
} else {//沒(méi)有找到
i = ~i;//i按位取反得到非負(fù)數(shù)
if (i < mSize && mValues[i] == DELETED) {//對(duì)應(yīng)值是否已刪除，是則替換對(duì)應(yīng)鍵值
mKeys[i] = key;
mValues[i] = value;
return;
}
if (mGarbage && mSize >= mKeys.length) {//當(dāng)mGarbage == true 并且mSize 大于等于key數(shù)組的長(zhǎng)度
gc(); //調(diào)用gc回收
// Search again because indices may have changed.
i = ~ContainerHelpers.binarySearch(mKeys, mSize, key);
}
//最后將新鍵值插入數(shù)組，調(diào)用 GrowingArrayUtils的insert方法：
mKeys = GrowingArrayUtils.insert(mKeys, mSize, i, key);
mValues = GrowingArrayUtils.insert(mValues, mSize, i, value);
mSize++;
}
}
下面進(jìn)去看看 GrowingArrayUtils的insert方法有什么擴(kuò)容的；
public static T[] insert(T[] array, int currentSize, int index, T element) {
assert currentSize <= array.length;
if (currentSize + 1 <= array.length) {//小于數(shù)組長(zhǎng)度
System.arraycopy(array, index, array, index + 1, currentSize - index);
array[index] = element;
return array;
}
//大于數(shù)組長(zhǎng)度需要進(jìn)行擴(kuò)容
T[] newArray = (T[]) Array.newInstance(array.getClass().getComponentType(),
growSize(currentSize));//擴(kuò)容規(guī)則里面就一句三目運(yùn)算：currentSize <= 4 ? 8 : currentSize * 2;（擴(kuò)容2倍）
System.arraycopy(array, 0, newArray, 0, index);
newArray[index] = element;
System.arraycopy(array, index, newArray, index + 1, array.length - index);
return newArray;
}
SparseArray的get（key）方法：
public E get(int key) {
return get(key, null);//調(diào)用get(key,null)方法
}
public E get(int key, E valueIfKeyNotFound) {
int i = ContainerHelpers.binarySearch(mKeys, mSize, key);//二分查找key
if (i < 0 || mValues[i] == DELETED) {//沒(méi)有找到，或者已經(jīng)刪除返回null
return valueIfKeyNotFound;
} else {//找到直接返回i位置的value值
return (E) mValues[i];
}
}
SparseArray在put添加數(shù)據(jù)的時(shí)候，會(huì)使用二分查找法和之前的key比較當(dāng)前我們添加的元素的key的大小，然后按照從小到大的順序排列好，所以，SparseArray存儲(chǔ)的元素都是按元素的key值從小到大排列好的。?
而在獲取數(shù)據(jù)的時(shí)候，也是使用二分查找法判斷元素的位置，所以，在獲取數(shù)據(jù)的時(shí)候非?？?，比HashMap快的多，因?yàn)镠ashMap獲取數(shù)據(jù)是通過(guò)遍歷Entry[]數(shù)組來(lái)得到對(duì)應(yīng)的元素。
SparseArray應(yīng)用場(chǎng)景：
雖說(shuō)SparseArray性能比較好，但是由于其添加、查找、刪除數(shù)據(jù)都需要先進(jìn)行一次二分查找，所以在數(shù)據(jù)量大的情況下性能并不明顯，將降低至少50%。
滿足下面兩個(gè)條件我們可以使用SparseArray代替HashMap：
數(shù)據(jù)量不大，最好在千級(jí)以內(nèi)
key必須為int類(lèi)型，這中情況下的HashMap可以用SparseArray代替：
ArrayMap
ArrayMap是一個(gè)
public class ArrayMap extends SimpleArrayMap implements Map {}
構(gòu)造函數(shù)由父類(lèi)實(shí)現(xiàn)：
public ArrayMap() {
super();
}
public ArrayMap(int capacity) {
super(capacity);
}
public ArrayMap(SimpleArrayMap map) {
super(map);
}
HashMap內(nèi)部有一個(gè)HashMapEntry[]對(duì)象，每一個(gè)鍵值對(duì)都存儲(chǔ)在這個(gè)對(duì)象里，當(dāng)使用put方法添加鍵值對(duì)時(shí)，就會(huì)new一個(gè)HashMapEntry對(duì)象，而ArrayMap的存儲(chǔ)中沒(méi)有Entry這個(gè)東西，他是由兩個(gè)數(shù)組來(lái)維護(hù)的，mHashes數(shù)組中保存的是每一項(xiàng)的HashCode值，mArray中就是鍵值對(duì)，每?jī)蓚€(gè)元素代表一個(gè)鍵值對(duì)，前面保存key，后面的保存value。
int[] mHashes;//key的hashcode值
Object[] mArray;//key value數(shù)組
SimpleArrayMap（）：創(chuàng)建一個(gè)空的ArrayMap，默認(rèn)容量為0，它會(huì)跟隨添加的item增加容量。?
SimpleArrayMap(int capacity)：指定特定容量ArrayMap；?
SimpleArrayMap(SimpleArrayMap map)：指定特定的map；
public SimpleArrayMap() {
mHashes = ContainerHelpers.EMPTY_INTS;
mArray = ContainerHelpers.EMPTY_OBJECTS;
mSize = 0;
}
...
ArrayMap 存取
ArrayMap 的put(K key, V value)：key 不為null
/**
* Add a new value to the array map.
* @param key The key under which to store the value. Must not be null. If
* this key already exists in the array, its value will be replaced.
* @param value The value to store for the given key.
* @return Returns the old value that was stored for the given key, or null if there
* was no such key.
*/
public V put(K key, V value) {
final int hash;
int index;
//key 不能為null
if (key == null) { //key == null，hash為0
hash = 0;
index = indexOfNull();
} else {//獲取key的hash值
hash = key.hashCode();
index = indexOf(key, hash);//獲取位置
}
//返回index位置的old值
if (index >= 0) {
index = (index<<1) + 1;
final V old = (V)mArray[index];//old 賦值 value
mArray[index] = value;
return old;
}
//否則按位取反
index = ~index;
//擴(kuò)容 System.arrayCopy數(shù)據(jù)
if (mSize >= mHashes.length) {
final int n = mSize >= (BASE_SIZE*2) ? (mSize+(mSize>>1))
: (mSize >= BASE_SIZE ? (BASE_SIZE*2) : BASE_SIZE);
if (DEBUG) Log.d(TAG, "put: grow from " + mHashes.length + " to " + n);
final int[] ohashes = mHashes;
final Object[] oarray = mArray;
allocArrays(n);//申請(qǐng)數(shù)組
if (mHashes.length > 0) {
if (DEBUG) Log.d(TAG, "put: copy 0-" + mSize + " to 0");
System.arraycopy(ohashes, 0, mHashes, 0, ohashes.length);
System.arraycopy(oarray, 0, mArray, 0, oarray.length);
}
freeArrays(ohashes, oarray, mSize);//重新收縮數(shù)組，釋放空間
}
if (index < mSize) {
if (DEBUG) Log.d(TAG, "put: move " + index + "-" + (mSize-index)
+ " to " + (index+1));
System.arraycopy(mHashes, index, mHashes, index + 1, mSize - index);
System.arraycopy(mArray, index << 1, mArray, (index + 1) << 1, (mSize - index) << 1);
}
//最后 mHashs數(shù)組存儲(chǔ)key的hash值
mHashes[index] = hash;
mArray[index<<1] = key;//mArray數(shù)組相鄰位置存儲(chǔ)key 和value值
mArray[(index<<1)+1] = value;
mSize++;
return null;
}
從最后可以看出：ArrayMap的存儲(chǔ)中沒(méi)有Entry這個(gè)東西，他是由兩個(gè)數(shù)組來(lái)維護(hù)的，mHashes數(shù)組中保存的是每一項(xiàng)的HashCode值，mArray中就是鍵值對(duì)，每?jī)蓚€(gè)元素代表一個(gè)鍵值對(duì)，前面保存key，后面的保存value。
ArrayMap 的get(Object key)：從Array數(shù)組獲得value
/**
* Retrieve a value from the array.
* @param key The key of the value to retrieve.
* @return Returns the value associated with the given key,
* or null if there is no such key.
*/
public V get(Object key) {
final int index = indexOfKey(key);//獲得key在Array的存儲(chǔ)位置
return index >= 0 ? (V)mArray[(index<<1)+1] : null;//如果index>=0 ?。╥ndex+1）上的value值，否則返回null（從上面put知道array存儲(chǔ)是key（index） value（index+1）存儲(chǔ)的）
}
ArrayMap 和 HashMap區(qū)別：
1.存儲(chǔ)方式不同
HashMap內(nèi)部有一個(gè)HashMapEntry[]對(duì)象，每一個(gè)鍵值對(duì)都存儲(chǔ)在這個(gè)對(duì)象里，當(dāng)使用put方法添加鍵值對(duì)時(shí)，就會(huì)new一個(gè)HashMapEntry對(duì)象
ArrayMap的存儲(chǔ)中沒(méi)有Entry這個(gè)東西，他是由兩個(gè)數(shù)組來(lái)維護(hù)的
mHashes數(shù)組中保存的是每一項(xiàng)的HashCode值，
mArray中就是鍵值對(duì)，每?jī)蓚€(gè)元素代表一個(gè)鍵值對(duì)，前面保存key，后面的保存value。
2.添加數(shù)據(jù)時(shí)擴(kuò)容時(shí)的處理不一樣
HashMap使用New的方式申請(qǐng)空間，并返回一個(gè)新的對(duì)象，開(kāi)銷(xiāo)會(huì)比較大
ArrayMap用的是System.arrayCopy數(shù)據(jù)，所以效率相對(duì)要高。
3、ArrayMap提供了數(shù)組收縮的功能，只要判斷過(guò)判斷容量尺寸，例如clear，put，remove等方法，只要通過(guò)判斷size大小觸發(fā)到freeArrays或者allocArrays方法，會(huì)重新收縮數(shù)組，釋放空間。
4、ArrayMap相比傳統(tǒng)的HashMap速度要慢，因?yàn)椴檎曳椒ㄊ嵌址?，并且?dāng)你刪除或者添加數(shù)據(jù)時(shí)，會(huì)對(duì)空間重新調(diào)整，在使用大量數(shù)據(jù)時(shí)，效率低于50%。可以說(shuō)ArrayMap是犧牲了時(shí)間換區(qū)空間。但在寫(xiě)手機(jī)app時(shí)，適時(shí)的使用ArrayMap，會(huì)給內(nèi)存使用帶來(lái)可觀的提升。ArrayMap內(nèi)部還是按照正序排列的，這時(shí)因?yàn)锳rrayMap在檢索數(shù)據(jù)的時(shí)候使用的是二分查找，所以每次插入新數(shù)據(jù)的時(shí)候ArrayMap都需要重新排序，逆序是最差情況；
HashMap ArrayMap SparseArray性能測(cè)試對(duì)比（轉(zhuǎn)載 ）
直接看：http://www.jianshu.com/p/7b9a1b386265測(cè)試對(duì)比
1.插入性能時(shí)間對(duì)比?
數(shù)據(jù)量小的時(shí)候，差異并不大（當(dāng)然了，數(shù)據(jù)量小，時(shí)間基準(zhǔn)小，確實(shí)差異不大），當(dāng)數(shù)據(jù)量大于5000左右，SparseArray，最快，HashMap最慢，乍一看，好像SparseArray是最快的，但是要注意，這是順序插入的。也就是SparseArray和Arraymap最理想的情況。
倒序插入：數(shù)據(jù)量大的時(shí)候HashMap遠(yuǎn)超Arraymap和SparseArray，也前面分析一致。?
當(dāng)然了，數(shù)據(jù)量小的時(shí)候，例如1000以下，這點(diǎn)時(shí)間差異也是可以忽略的。
SparseArray在內(nèi)存占用方面的確要優(yōu)于HashMap和ArrayMap不少，通過(guò)數(shù)據(jù)觀察，大致節(jié)省30%左右，而ArrayMap的表現(xiàn)正如前面說(shuō)的，優(yōu)化作用有限，幾乎和HashMap相同。
2.查找性能對(duì)比
如何選擇使用
1.在數(shù)據(jù)量小的時(shí)候一般認(rèn)為1000以下，當(dāng)你的key為int的時(shí)候，使用SparseArray確實(shí)是一個(gè)很不錯(cuò)的選擇，內(nèi)存大概能節(jié)省30%，相比用HashMap，因?yàn)樗黭ey值不需要裝箱，所以時(shí)間性能平均來(lái)看也優(yōu)于HashMap,建議使用！
2.ArrayMap相對(duì)于SparseArray，特點(diǎn)就是key值類(lèi)型不受限，任何情況下都可以取代HashMap,但是通過(guò)研究和測(cè)試發(fā)現(xiàn)，ArrayMap的內(nèi)存節(jié)省并不明顯，也就在10%左右，但是時(shí)間性能確是最差的，當(dāng)然了，1000以內(nèi)的如果key不是int 可以選擇ArrayMap。
參考：?
MVC，MVP 和 MVVM 模式如何選擇？
?一招教你讀懂JVM和Dalvik之間的區(qū)別
我的Android重構(gòu)之旅：框架篇
NDK項(xiàng)目實(shí)戰(zhàn)—高仿360手機(jī)助手之卸載監(jiān)聽(tīng)
（Android）面試題級(jí)答案（精選版）
