Android學習筆記之效能優化SparseArray
學習內容：
1.Android中SparseArray的使用..
昨天研究完橫向二級選單，發現其中使用了SparseArray去替換HashMap的使用.於是乎自己查了一些相關資料,自己同時對效能進行了一些測試。首先先說一下SparseArray的原理.
SparseArray(稀疏陣列).他是Android內部特有的api,標準的jdk是沒有這個類的.在Android內部用來替代HashMap<Integer,E>這種形式,使用SparseArray更加節省記憶體空間的使用,SparseArray也是以key和value對資料進行儲存的.使用的時候只需要指定value的型別即可.並且key不需要封裝成物件型別.
樓主根據親測,SparseArray儲存資料佔用的記憶體空間確實比HashMap要小一些.一會放出測試的資料在進行分析。我們首先看一下二者的結構特性.
HashMap是陣列和連結串列的結合體,被稱為連結串列雜湊.
SparseArray是單純陣列的結合.被稱為稀疏陣列,對資料儲存的時候,不會有額外的開銷.結構如下：
這就是二者的結構,我們需要看一下二者到底有什麼差異...
首先是插入：
HashMap的正序插入：
HashMap<Integer, String>map = new HashMap<Integer, String>();
long start_map = System.currentTimeMillis();
for(int i=0;i<MAX;i++){
map.put(i, String.valueOf(i));
}
long map_memory = Runtime.getRuntime().totalMemory();
long end_map = System.currentTimeMillis()-start_map;
System.out.println("<---Map的插入時間--->"+end_map+"<---Map佔用的記憶體--->"+map_memory);
執行後的結果:
<---Map的插入時間--->914
<---Map佔用的記憶體--->28598272
SparseArray的正序插入：
SparseArray<String>sparse = new SparseArray<String>();
long start_sparse = System.currentTimeMillis();
for(int i=0;i<MAX;i++){
sparse.put(i, String.valueOf(i));
}
long sparse_memory = Runtime.getRuntime().totalMemory();
long end_sparse = System.currentTimeMillis()-start_sparse;
System.out.println("<---Sparse的插入時間--->"+end_sparse+"<---Sparse佔用的記憶體--->"+sparse_memory);
//執行後的結果：
<---Sparse的插入時間--->611
<---Sparse佔用的記憶體--->23281664
我們可以看到100000條資料量正序插入時SparseArray的效率要比HashMap的效率要高.並且佔用的記憶體也比HashMap要小一些..這裡的正序插入表示的是i的值是從小到大進行的一個遞增..序列取決於i的值，而不是for迴圈內部如何執行...
通過執行後的結果我們可以發現，SparseArray在正序插入的時候，效率要比HashMap要快得多，並且還節省了一部分記憶體。網上有很多的說法關於二者的效率問題，很多人都會誤認為SparseArray要比HashMap的插入和查詢的效率要快，還有人則是認為Hash查詢當然要比SparseArray中的二分查詢要快得多.
其實我認為Android中在儲存<Integer,Value>的時候推薦使用SparseArray的本質目的不是由於效率的原因，而是記憶體的原因.我們確實看到了插入的時候SparseArray要比HashMap要快.但是這僅僅是正序插入.我們來看看倒序插入的情況.
HashMap倒序插入：
System.out.println("<------------- 資料量100000 雜湊程度小 Map 倒序插入--------------->");
HashMap<Integer, String>map_2 = new HashMap<Integer, String>();
long start_map_2 = System.currentTimeMillis();
for(int i=MAX-1;i>=0;i--){
map_2.put(MAX-i-1, String.valueOf(MAX-i-1));
}
long map_memory_2 = Runtime.getRuntime().totalMemory();
long end_map_2 = System.currentTimeMillis()-start_map_2;
System.out.println("<---Map的插入時間--->"+end_map_2+"<---Map佔用的記憶體--->"+map_memory_2);
//執行後的結果：
<------------- 資料量100000 Map 倒序插入--------------->
<---Map的插入時間--->836<---Map佔用的記憶體--->28598272
SparseArray倒序插入：
System.out.println("<------------- 資料量100000 雜湊程度小 SparseArray 倒序插入--------------->");
SparseArray<String>sparse_2 = new SparseArray<String>();
long start_sparse_2 = System.currentTimeMillis();
for(int i=MAX-1;i>=0;i--){
sparse_2.put(i, String.valueOf(MAX-i-1));
}
long sparse_memory_2 = Runtime.getRuntime().totalMemory();
long end_sparse_2 = System.currentTimeMillis()-start_sparse_2;
System.out.println("<---Sparse的插入時間--->"+end_sparse_2+"<---Sparse佔用的記憶體--->"+sparse_memory_2);
//執行後的結果
<------------- 資料量100000 SparseArray 倒序插入--------------->
<---Sparse的插入時間--->20222<---Sparse佔用的記憶體--->23281664
通過上面的執行結果,我們仍然可以看到,SparseArray與HashMap無論是怎樣進行插入,資料量相同時,前者都要比後者要省下一部分記憶體,但是效率呢？我們可以看到,在倒序插入的時候,SparseArray的插入時間和HashMap的插入時間遠遠不是一個數量級.由於SparseArray每次在插入的時候都要使用二分查詢判斷是否有相同的值被插入.因此這種倒序的情況是SparseArray效率最差的時候.
SparseArray的插入原始碼我們簡單的看一下..
public void put(int key, E value) {
int i = ContainerHelpers.binarySearch(mKeys, mSize, key); //二分查詢.
if (i >= 0) { //如果當前這個i在陣列中存在,那麼表示插入了相同的key值,只需要將value的值進行覆蓋..
mValues[i] = value;
} else { //如果陣列內部不存在的話,那麼返回的數值必然是負數.
i = ~i; //因此需要取i的相反數.
//i值小於mSize表示在這之前. mKey和mValue陣列已經被申請了空間.只是鍵值被刪除了.那麼當再次儲存新的值的時候.不需要額外的開闢新的記憶體空間.直接對陣列進行賦值即可.
if (i < mSize && mValues[i] == DELETED) {
mKeys[i] = key;
mValues[i] = value;
return;
}
//當需要的空間要超出,但是mKey中存在無用的數值,那麼需要呼叫gc()函式.
if (mGarbage && mSize >= mKeys.length) {
gc();
// Search again because indices may have changed.
i = ~ContainerHelpers.binarySearch(mKeys, mSize, key);
}
//如果需要的空間大於了原來申請的控制元件,那麼需要為key和value陣列開闢新的空間.
if (mSize >= mKeys.length) {
int n = ArrayUtils.idealIntArraySize(mSize + 1);
//定義了一個新的key和value陣列.需要大於mSize
int[] nkeys = new int[n];
Object[] nvalues = new Object[n];
// Log.e("SparseArray", "grow " + mKeys.length + " to " + n);
//對陣列進行賦值也就是copy操作.將原來的mKey陣列和mValue陣列的值賦給新開闢的空間的陣列.目的是為了新增新的鍵值對.
System.arraycopy(mKeys, 0, nkeys, 0, mKeys.length);
System.arraycopy(mValues, 0, nvalues, 0, mValues.length);
//將陣列賦值..這裡只是將陣列的大小進行擴大..放入鍵值對的操作不在這裡完成.
mKeys = nkeys;
mValues = nvalues;
}
//如果i的值沒有超過mSize的值.只需要擴大mKey的長度即可.
if (mSize - i != 0) {
// Log.e("SparseArray", "move " + (mSize - i));
System.arraycopy(mKeys, i, mKeys, i + 1, mSize - i);
System.arraycopy(mValues, i, mValues, i + 1, mSize - i);
}
//這裡是用來完成放入操作的過程.
mKeys[i] = key;
mValues[i] = value;
mSize++;
}
}
這就是SparseArray插入函式的原始碼.每次的插入方式都需要呼叫二分查詢.因此這樣在倒序插入的時候會導致情況非常的糟糕,效率上絕對輸給了HashMap學過資料結構的大家都知道.Map在插入的時候會對衝突因子做出相應的決策.有非常好的處理衝突的方式.不需要遍歷每一個值.因此無論是倒序還是正序插入的效率取決於處理衝突的方式,因此插入時犧牲的時間基本是相同的.
通過插入.我們還是可以看出二者的差異的.
我們再來看一下查詢首先是HashMap的查詢.
System.out.println("<------------- 資料量100000 Map查詢--------------->");
HashMap<Integer, String>map = new HashMap<Integer, String>();
for(int i=0;i<MAX;i++){
map.put(i, String.valueOf(i));
}
long start_time =System.currentTimeMillis();
for(int i=0;i<MAX;i+=100){
map.get(i);
}
long end_time =System.currentTimeMillis()-start_time;
System.out.println(end_time);
//執行後的結果
<!---------查詢的時間:175------------>
SparseArray的查詢:
System.out.println("<------------- 資料量100000 SparseArray 查詢--------------->");
SparseArray<String>sparse = new SparseArray<String>();
for(int i=0;i<10000;i++){
sparse.put(i, String.valueOf(i));
}
long start_time =System.currentTimeMillis();
for(int i=0;i<MAX;i+=10){
sparse.get(i);
}
long end_time =System.currentTimeMillis()-start_time;
System.out.println(end_time);
//執行後的結果
<!-----------查詢的時間:239---------------->
我這裡也簡單的對查詢的效率進行了測試.對一個數據或者是幾個資料的查詢.二者的差異還是非常小的.當資料量是100000條.查100000條的效率還是Map要快一點.資料量為10000的時候.這就差異性就更小.但是Map的查詢的效率確實還是贏了一籌.
其實在我看來.在儲存<Integer,E>時使用SparseArray去替換HashMap的主要原因還是因為記憶體的關係.我們可以看到.儲存的資料量無論是大還是小,Map所佔用的記憶體始終是大於SparseArray的.資料量100000條時SparseArray要比HashMap要節約27%的記憶體.也就是以犧牲效率的代價去節約記憶體空間.我們知道Android對記憶體的使用是極為苛刻的.堆區允許使用的最大記憶體僅僅16M.很容易出現OOM現象的發生.因此在Android中記憶體的使用是非常的重要的.因此官方才推薦去使用SparseArray<E>去替換HashMap<Integer,E>.官方也確實宣告這種差異性不會超過50%.所以犧牲了部分效率換來記憶體其實在Android中也算是一種很好的選擇吧.