Android學習筆記之性能優化SparseArray

PS：終於考完試了.來一發.微機原理充滿了危機.不過好在數據庫89分,仍是很是欣慰的.

 

學習內容：

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中也算是一種很好的選擇吧.