前言
遲到一年的HashMap解讀 文章中講述了常用Java編程的數據結合HashMap的一些知識點。但如果在Android編程中出現HashMap<Interget, Object>的時候,編譯器就會提示用SparseArray代替HashMap。為什么呢?眾所周知在Android手機中應用的內存占比是衡量一個APP新能的非常重要的指標。而SparseArray就是通過時間換空間的辦法降低HashMap的內存占用。
- HashMap是通過數據加鏈表的方式存儲數據的;
- SparseArray是使用純數據的方式實現對數據的存儲的;
SparseArray主要是通過將Interger類型的key,以升序方式存儲在mKeys中,無論在插入或是查找的時候都可以使用二分查找法進行index的查找,當然其中還有一些細節方面的優化。
SparseArray的構造
//刪除了的數據
private static final Object DELETED = new Object();
//是否進行過刪除
private boolean mGarbage = false;
private int[] mKeys;
private Object[] mValues;
//數組中創建的對象(實際存在的數據個數和DELETED個數)
private int mSize;
public SparseArray() {
this(10);
}
public SparseArray(int initialCapacity) {
if (initialCapacity == 0) {
mKeys = ContainerHelpers.EMPTY_INTS;
mValues = ContainerHelpers.EMPTY_OBJECTS;
} else {
initialCapacity = ArrayUtils.idealIntArraySize(initialCapacity);
mKeys = new int[initialCapacity];
mValues = new Object[initialCapacity];
}
mSize = 0;
}
SparseArray的put方法
public void put(int key, E value) {
//找到key在mKeys中的索引位置
int i = ContainerHelpers.binarySearch(mKeys, mSize, key);
//index>0,表示已經存在,value直接覆蓋
if (i >= 0) {
mValues[i] = value;
} else {
//index的反碼載取反,表示key應該存在的索引位置
i = ~i;
//索引位置在已經被刪除了的位置,直接復制key,value
if (i < mSize && mValues[i] == DELETED) {
mKeys[i] = key;
mValues[i] = value;
return;
}
//mGarbage=true,表示有刪除元素。且數組容量已經滿了,觸發gc:回收數組中為DELETED的節點,向前補位
//eg:{1,4,0,5,6,0,7} => {1,4,5,6,7,null,null}
if (mGarbage && mSize >= mKeys.length) {
gc();
//重新進行索引
// Search again because indices may have changed.
i = ~ContainerHelpers.binarySearch(mKeys, mSize, key);
}
//數組容量已滿(沒有觸發gc),進行擴容。
if (mSize >= mKeys.length) {
//計算將要擴容的數組長度,n為2的指數冪且n >= (mSize + 1)
int n = ArrayUtils.idealIntArraySize(mSize + 1);
//創建新的數組
int[] nkeys = new int[n];
Object[] nvalues = new Object[n];
//將原來數組的內容,copy到新的數組
// Log.e("SparseArray", "grow " + mKeys.length + " to " + n);
System.arraycopy(mKeys, 0, nkeys, 0, mKeys.length);
System.arraycopy(mValues, 0, nvalues, 0, mValues.length);
//替換引用
mKeys = nkeys;
mValues = nvalues;
}
//重新排序,保持數組的升序特性
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中index查找
class ContainerHelpers {
static final int[] EMPTY_INTS = new int[0];
/********************部分代碼省略******************/
//使用二分查找發查找當前value在數組中的索引位置,找到返回該位置,找不到返回value應該處于的位置的反碼
// This is Arrays.binarySearch(), but doesn't do any argument validation.
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中數據擴容
//實現數組的內容復制
public static void arraycopy(int[] src, //src:源數組;
int srcPos, //srcPos:源數組要復制的起始位置;
int[] dst, //dst:目的數組;
int dstPos, //dstPos:目的數組放置的起始位置;
int length) { //length:復制的長度。
if (src == null) {
throw new NullPointerException("src == null");
}
if (dst == null) {
throw new NullPointerException("dst == null");
}
if (srcPos < 0 || dstPos < 0 || length < 0 ||
srcPos > src.length - length || dstPos > dst.length - length) {
throw new ArrayIndexOutOfBoundsException(
"src.length=" + src.length + " scrPos=" + srcPos +
" dst.length=" + dst.length + " desPos=" + dstPos + " length=" + length);
}
if (length <= ARRAYCOPY_SHORT_INT_ARRAY_SHRESHOLD) {
if (src == dst && srcPos < dstPos && dstPos < srcPos + length) {
for (int i = length - 1; i >= 0; --i) {
dst[dstPos + i] = src[srcPos + i];
}
} else {
for (int i = 0; i < length; ++i) {
dst[dstPos + i] = src[srcPos + i];
}
}
} else {
arraycopyIntUnchcked(src, srcPos, dst, dstPos, length);
}
}
//result = (2^n - 3) >= need
public static int idealIntArraySize(int need) {
return idealByteArraySize(need * 4) / 4;
}
public static int idealByteArraySize(int need) {
for (int i = 4; i < 32; i++) {
if (need <= (1 << i) - 12)
return (1 << i) - 12;
}
return need;
}
SparseArray內部GC
//回收數組mValues中的DELETED數據
private void gc() {
// Log.e("SparseArray", "gc start with " + mSize);
int n = mSize;
int o = 0;
int[] keys = mKeys;
Object[] values = mValues;
for (int i = 0; i < n; i++) {
Object val = values[i];
//將數據中的DELETED數據全部剔除,但是依舊保持數據的升序特性
if (val != DELETED) {
if (i != o) {
keys[o] = keys[i];
values[o] = val;
values[i] = null;
}
o++;
}
}
//重置mGarbage標志
mGarbage = false;
//mSize恢復數組中的數據真實數量
mSize = o;
// Log.e("SparseArray", "gc end with " + mSize);
}
SparseArray的get
public E get(int key) {
return get(key, null);
}
@SuppressWarnings("unchecked")
public E get(int key, E valueIfKeyNotFound) {
////找到key在mKeys中的索引位置
int i = ContainerHelpers.binarySearch(mKeys, mSize, key);
//找不到或者索引處的value=DELETE,則返回默認值
if (i < 0 || mValues[i] == DELETED) {
return valueIfKeyNotFound;
} else {
return (E) mValues[i];
}
}
SparseArray的優化
想要在數據中存放一個key-value鍵值對,當這個key值比當前數組中的任何一個key值都大的時候,那么使用這個方法更優。
/**
* Puts a key/value pair into the array, optimizing for the case where
* the key is greater than all existing keys in the array.
*/
public void append(int key, E value) {
//因為數據的key是升序存放的,所以只需要比較最后一個key值就可以。
//如果比最后一個key值都大,那么該key值存儲的index=mSize。
//否則,調用put方法
if (mSize != 0 && key <= mKeys[mSize - 1]) {
put(key, value);
return;
}
if (mGarbage && mSize >= mKeys.length) {
gc();
}
int pos = mSize;
if (pos >= mKeys.length) {
int n = ArrayUtils.idealIntArraySize(pos + 1);
int[] nkeys = new int[n];
Object[] nvalues = new Object[n];
// Log.e("SparseArray", "grow " + mKeys.length + " to " + n);
System.arraycopy(mKeys, 0, nkeys, 0, mKeys.length);
System.arraycopy(mValues, 0, nvalues, 0, mValues.length);
mKeys = nkeys;
mValues = nvalues;
}
mKeys[pos] = key;
mValues[pos] = value;
mSize = pos + 1;
}
在網絡上看到一些對HashMap和SparseArray內存的分析來看,數據量在100000條時SparseArray要比HashMap要節約27%的內存,因此官方才推薦去使用SparseArray<E>去替換HashMap<Integer,E>.官方也確實聲明這種差異性不會超過50%.所以犧牲了部分效率換來內存其實在Android中也算是一種很好的選擇。
看完整篇文章是不是迫不及待的就像使用SparseArray呢~!~!
文章到這里就全部講述完啦,若有其他需要交流的可以留言哦~!~!