1、特點:
時間換空間, 操作容器花費更多時間, 但是會減少內存;
這篇博客重點分析:
1. SparseArray;
2. SparseIntArray;
3. ArrayMap;
2、以SparseIntArray為例:
1、構造函數:
private int[] mKeys;
private int[] mValues;
private int mSize;
public SparseIntArray() {
this(10);
}
public SparseIntArray(int initialCapacity) {
if (initialCapacity == 0) {
mKeys = EmptyArray.INT;
mValues = EmptyArray.INT;
} else {
mKeys = ArrayUtils.newUnpaddedIntArray(initialCapacity);
mValues = new int[mKeys.length];
}
mSize = 0;
}
libcore/luni/src/main/java/libcore/util/EmptyArray.java--->
public final class EmptyArray {
private EmptyArray() {}
public static final boolean[] BOOLEAN = new boolean[0];
public static final byte[] BYTE = new byte[0];
public static final char[] CHAR = new char[0];
public static final double[] DOUBLE = new double[0];
public static final float[] FLOAT = new float[0];
public static final int[] INT = new int[0];
public static final long[] LONG = new long[0];
public static final Class<?>[] CLASS = new Class[0];
public static final Object[] OBJECT = new Object[0];
public static final String[] STRING = new String[0];
public static final Throwable[] THROWABLE = new Throwable[0];
}
上面代碼主要做了一件事:
- 1、創建兩個數組, 分別存儲key和value;
2、put():
class SparseIntArray--->
public void put(int key, int value) {
int i = ContainerHelpers.binarySearch(mKeys, mSize, key);
if (i >= 0) {
mValues[i] = value;
} else {
i = ~i;
mKeys = GrowingArrayUtils.insert(mKeys, mSize, i, key);
mValues = GrowingArrayUtils.insert(mValues, mSize, i, value);
mSize++;
}
}
class ContainerHelpers--->
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;
}
}
return ~lo;
}
class GrowingArrayUtils --->
public static int[] insert(int[] array, int currentSize, int index, int element) {
assert currentSize <= array.length;
if (currentSize + 1 <= array.length) {
System.arraycopy(array, index, array, index + 1, currentSize - index);
array[index] = element;
return array;
}
int[] newArray = new int[growSize(currentSize)];
System.arraycopy(array, 0, newArray, 0, index);
newArray[index] = element;
System.arraycopy(array, index, newArray, index + 1, array.length - index);
return newArray;
}
public static int growSize(int currentSize) {
return currentSize <= 4 ? 8 : currentSize * 2;
}
put主要做了下面幾件事:
- 1、插入操作先通過二分查找, 找出key. 二分查找時間復雜度為O(logN); 而HashMap內部維護的是一個數組, 查找時間復雜度為O(1); 所以就插入操作來說, HashMap會更快一些;
- 2、這個二分查找進行的挺巧妙的, 插入失敗返回~lo; 對返回值再繼續進行取反操作;
- 3、然后依次將key和value插入到數組中去, 我們看看他的插入操作;
- 4、假設我們插入操作一直是亂序的, 并且很頻繁, 會出現什么問題? 二分查找頻繁執行. 每次都是O(logN), 如果數據量過大, 與HashMap O(1)比起來時間差距就會越來越明顯;
- 5、System.arraycopy(array, index, array, index + 1, currentSize - index)與array[index] = element;這兩步操作就是將我們要插入的元素插入到指定位置. 畫個圖
調用arraycopy以后.png
2、get():
public int get(int key, int valueIfKeyNotFound) {
int i = ContainerHelpers.binarySearch(mKeys, mSize, key);
if (i < 0) {
return valueIfKeyNotFound;
} else {
return mValues[i];
}
}
**查找就很簡單了, 因為在put方法執行時的一系列操作可以保證數組是有序的, 所以查找的時間復雜度也是O(logN). ** 所以如果涉及到大數據量或者查找特別頻繁的操作, SparseArray系列并不適用;
3、delete():
public void delete(int key) {
int i = ContainerHelpers.binarySearch(mKeys, mSize, key);
if (i >= 0) {
removeAt(i);
}
}
public void removeAt(int index) {
System.arraycopy(mKeys, index + 1, mKeys, index, mSize - (index + 1));
System.arraycopy(mValues, index + 1, mValues, index, mSize - (index + 1));
mSize--;
}
刪除操作也是挺簡單的, 時間復雜度也是為O(logN). 因為他進行的數組元素的整體拷貝. 與get方法一樣, 當刪除操作特別頻繁或者數據量很大時, 也是沒必要使用的;
綜上所述:
當涉及到數據量不是特別大時, 官方給出的建議是千以下, 并且操作不是特別頻繁時, 使用SparseArray系列. 因為它可以節省內存空間, APP與Windows不一樣, 虛擬機為每個APP分配的內存空間很有限, SparseArray主要從以下幾個方面節省內存空間:
- 1、沒有自動裝箱的操作;
- 2、沒有Entry對象;及其Hash映射關系;
