面試必備：SparseArray源碼解析

時間  2019-11-24
標籤 面試 必備 sparsearray 源碼 解析 欄目 快樂工作 简体版
原文   原文鏈接

想看我更多文章:【張旭童的博客】blog.csdn.net/zxt0601
想來gayhub和我gaygayup:【mcxtzhang的Github主頁】github.com/mcxtzhangandroid

1 概述

在前文中，咱們已經聊過了HashMap和LinkedHashMap ArrayMap.因此若是沒看過，能夠先閱讀
面試必備：HashMap源碼解析（JDK8） ,
面試必備：LinkedHashMap源碼解析（JDK8 ，
面試必備：ArrayMap源碼解析
今天依舊是看看android sdk的源碼。git

本文將從幾個經常使用方法下手，來閱讀SparseArray的源碼。
按照從構造方法->經常使用API（增、刪、改、查）的順序來閱讀源碼，並會講解閱讀方法中涉及的一些變量的意義。瞭解SparseArray的特色、適用場景。github

若是本文中有不正確的結論、說法，請你們提出和我討論，共同進步，謝謝。面試

2 概要

歸納的說，SparseArray<E>是用於在Android平臺上替代HashMap的數據結構,更具體的說，
是用於替代key爲int類型，value爲Object類型的HashMap。
和ArrayMap相似，它的實現相比於HashMap更加節省空間，並且因爲key指定爲int類型，也能夠節省int-Integer的裝箱拆箱操做帶來的性能消耗。算法

它僅僅實現了implements Cloneable接口，因此使用時不能用Map做爲聲明類型來使用。數組

它也是線程不安全的，容許value爲null。安全

從原理上說，
它的內部實現也是基於兩個數組。
一個int[]數組mKeys，用於保存每一個item的key，key自己就是int類型，因此能夠理解hashCode值就是key的值.
一個Object[]數組mValues，保存value。容量和key數組的同樣。bash

相似ArrayMap,
它擴容的更合適，擴容時只須要數組拷貝工做，不須要重建哈希表。數據結構

一樣它不適合大容量的數據存儲。存儲大量數據時，它的性能將退化至少50%。函數

比傳統的HashMap時間效率低。
由於其會對key從小到大排序，使用二分法查詢key對應在數組中的下標。
在添加、刪除、查找數據的時候都是先使用二分查找法獲得相應的index，而後經過index來進行添加、查找、刪除等操做。

因此其是按照key的大小排序存儲的。

另外，SparseArray爲了提高性能，在刪除操做時作了一些優化：
當刪除一個元素時，並非當即從value數組中刪除它，並壓縮數組，
而是將其在value數組中標記爲已刪除。這樣當存儲相同的key的value時，能夠重用這個空間。
若是該空間沒有被重用，隨後將在合適的時機裏執行gc（垃圾收集）操做，將數組壓縮，以避免浪費空間。

適用場景：

  • 數據量不大（千之內）
  • 空間比時間重要
  • 須要使用Map，且key爲int類型。

示例代碼：

SparseArray<String> stringSparseArray = new SparseArray<>();
        stringSparseArray.put(1,"a");
        stringSparseArray.put(5,"e");
        stringSparseArray.put(4,"d");
        stringSparseArray.put(10,"h");
        stringSparseArray.put(2,null);

        Log.d(TAG, "onCreate() called with: stringSparseArray = [" + stringSparseArray + "]");複製代碼

輸出：

//能夠看出是按照key排序的
onCreate() called with: stringSparseArray = [{1=a, 2=null, 4=d, 5=e, 10=h}]複製代碼

3 構造函數

//用於標記value數組，做爲已經刪除的標記
    private static final Object DELETED = new Object();
    //是否須要GC 
    private boolean mGarbage = false;

    //存儲key 的數組
    private int[] mKeys;
    //存儲value 的數組
    private Object[] mValues;
    //集合大小
    private int mSize;

    //默認構造函數，初始化容量爲10
    public SparseArray() {
        this(10);
    }
    //指定初始容量
    public SparseArray(int initialCapacity) {
        //初始容量爲0的話，就賦值兩個輕量級的引用
        if (initialCapacity == 0) {
            mKeys = EmptyArray.INT;
            mValues = EmptyArray.OBJECT;
        } else {
        //初始化對應長度的數組
            mValues = ArrayUtils.newUnpaddedObjectArray(initialCapacity);
            mKeys = new int[mValues.length];
        }
        //集合大小爲0
        mSize = 0;
    }複製代碼

構造函數 無亮點，路過。
關注一下幾個變量：

  • 底層數據結構爲int[]和Object[]類型數組。
  • mGarbage: 是否須要GC
  • DELETED: 用於標記value數組，做爲已經刪除的標記

4 增 、改

4.1 單個增、改：

public void put(int key, E value) {
        //利用二分查找，找到 待插入key 的 下標index
        int i = ContainerHelpers.binarySearch(mKeys, mSize, key);
        //若是返回的index是正數，說明以前這個key存在，直接覆蓋value便可
        if (i >= 0) {
            mValues[i] = value;
        } else {
            //若返回的index是負數，說明 key不存在.

            //先對返回的i取反，獲得應該插入的位置i
            i = ~i;
            //若是i沒有越界，且對應位置是已刪除的標記，則複用這個空間
            if (i < mSize && mValues[i] == DELETED) {
            //賦值後，返回
                mKeys[i] = key;
                mValues[i] = value;
                return;
            }

            //若是須要GC，且須要擴容
            if (mGarbage && mSize >= mKeys.length) {
                //先觸發GC
                gc();
                //gc後，下標i可能發生變化，因此再次用二分查找找到應該插入的位置i
                // Search again because indices may have changed.
                i = ~ContainerHelpers.binarySearch(mKeys, mSize, key);
            }
            //插入key（可能須要擴容）
            mKeys = GrowingArrayUtils.insert(mKeys, mSize, i, key);
            //插入value（可能須要擴容）
            mValues = GrowingArrayUtils.insert(mValues, mSize, i, value);
            //集合大小遞增
            mSize++;
        }
    }
    //二分查找 基礎知識再也不詳解
    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
            }
        }
        //若沒找到，則lo是value應該插入的位置，是一個正數。對這個正數去反，返回負數回去
        return ~lo;  // value not present
    }

    //垃圾回收函數,壓縮數組
    private void gc() {
        //保存GC前的集合大小
        int n = mSize;
        //既是下標index，又是GC後的集合大小
        int o = 0;
        int[] keys = mKeys;
        Object[] values = mValues;
        //遍歷values集合，如下算法 意義爲 從values數組中，刪除全部值爲DELETED的元素
        for (int i = 0; i < n; i++) {
            Object val = values[i];
            //若是當前value 沒有被標記爲已刪除
            if (val != DELETED) {
                //壓縮keys、values數組
                if (i != o) {
                    keys[o] = keys[i];
                    values[o] = val;
                    //並將當前元素置空，防止內存泄漏
                    values[i] = null;
                }
                //遞增o
                o++;
            }
        }
        //修改 標識，不須要GC
        mGarbage = false;
        //更新集合大小
        mSize = o;
    }複製代碼

GrowingArrayUtils.insert:

    //
    public static int[] insert(int[] array, int currentSize, int index, int element) {
        //斷言 確認 當前集合長度 小於等於 array數組長度
        assert currentSize <= array.length;
        //若是不須要擴容
        if (currentSize + 1 <= array.length) {
            //將array數組內元素，從index開始 後移一位
            System.arraycopy(array, index, array, index + 1, currentSize - index);
            //在index處賦值
            array[index] = element;
            //返回
            return array;
        }
        //須要擴容
        //構建新的數組
        int[] newArray = new int[growSize(currentSize)];
        //將原數組中index以前的數據複製到新數組中
        System.arraycopy(array, 0, newArray, 0, index);
        //在index處賦值
        newArray[index] = element;
        //將原數組中index及其以後的數據賦值到新數組中
        System.arraycopy(array, index, newArray, index + 1, array.length - index);
        //返回
        return newArray;
    }
    //根據如今的size 返回合適的擴容後的容量
    public static int growSize(int currentSize) {
        //若是當前size 小於等於4，則返回8， 不然返回當前size的兩倍
        return currentSize <= 4 ? 8 : currentSize * 2;
    }複製代碼

  • 二分查找，若未找到返回下標時，與JDK裏的實現不一樣，JDK是返回return -(low + 1); // key not found.,而這裏是對 低位去反 返回。
    這樣在函數調用處，根據返回值的正負，能夠判斷是否找到index。對負index取反，便可獲得應該插入的位置。

  • 擴容時，當前容量小於等於4，則擴容後容量爲8.不然爲當前容量的兩倍。和ArrayList,ArrayMap不一樣(擴容一半)，和Vector相同(擴容一倍)。

  • 擴容操做依然是用數組的複製、覆蓋完成。相似ArrayList.

5 刪

5.1 按照key刪除

//按照key刪除
    public void remove(int key) {
        delete(key);
    }

    public void delete(int key) {
        //二分查找獲得要刪除的key所在index
        int i = ContainerHelpers.binarySearch(mKeys, mSize, key);
        //若是>=0,表示存在
        if (i >= 0) {
            //修改values數組對應位置爲已刪除的標誌DELETED
            if (mValues[i] != DELETED) {
                mValues[i] = DELETED; 
                //並修改 mGarbage ,表示稍後須要GC
                mGarbage = true;
            }
        }
    }複製代碼

5.2 按照index刪除

public void removeAt(int index) {
        //根據index直接索引到對應位置 執行刪除操做
        if (mValues[index] != DELETED) {
            mValues[index] = DELETED;
            mGarbage = true;
        }
    }複製代碼

5.3 批量刪除

public void removeAtRange(int index, int size) {
    //越界修正
        final int end = Math.min(mSize, index + size);
        //for循環 執行單個刪除操做
        for (int i = index; i < end; i++) {
            removeAt(i);
        }
    }複製代碼

6 查

6.1 按照key查詢

//按照key查詢，若是key不存在，返回null
    public E get(int key) {
        return get(key, null);
    }

    //按照key查詢，若是key不存在，返回valueIfKeyNotFound
    public E get(int key, E valueIfKeyNotFound) {
        //二分查找到 key 所在的index
        int i = ContainerHelpers.binarySearch(mKeys, mSize, key);
        //不存在
        if (i < 0 || mValues[i] == DELETED) {
            return valueIfKeyNotFound;
        } else {//存在
            return (E) mValues[i];
        }
    }複製代碼

6.2 按照下標查詢

public int keyAt(int index) {
    //按照下標查詢時，須要考慮是否先GC
        if (mGarbage) {
            gc();
        }

        return mKeys[index];
    }

    public E valueAt(int index) {
     //按照下標查詢時，須要考慮是否先GC
        if (mGarbage) {
            gc();
        }

        return (E) mValues[index];
    }複製代碼

6.3查詢下標：

public int indexOfKey(int key) {
     //查詢下標時，也須要考慮是否先GC
        if (mGarbage) {
            gc();
        }
        //二分查找返回 對應的下標 ,多是負數
        return ContainerHelpers.binarySearch(mKeys, mSize, key);
    }
    public int indexOfValue(E value) {
     //查詢下標時，也須要考慮是否先GC
        if (mGarbage) {
            gc();
        }
        //不像key同樣使用的二分查找。是直接線性遍歷去比較，並且不像其餘集合類使用equals比較，這裏直接使用的 ==
        //若是有多個key 對應同一個value，則這裏只會返回一個更靠前的index
        for (int i = 0; i < mSize; i++)
            if (mValues[i] == value)
                return i;

        return -1;
    }複製代碼
  • 按照value查詢下標時，不像key同樣使用的二分查找。是直接線性遍歷去比較，並且不像其餘集合類使用equals比較，這裏直接使用的 ==
  • 若是有多個key 對應同一個value，則這裏只會返回一個更靠前的index

總結

SparseArray的源碼相對來講比較簡單，通過以前幾個集合的源碼洗禮，很輕鬆就能夠掌握大致流程和關鍵思想：時間換空間。

Android sdk中，還提供了三個相似思想的集合：

  • SparseBooleanArray,value爲boolean
  • SparseIntArray,value爲int
  • SparseLongArray,value爲long

他們和SparseArray惟一的區別在於value的類型，SparseArray的value能夠是任意類型。而它們是三個常使用的拆箱後的基本類型。

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程