1、HashMap的數據結構
HashMap的數據結構為：數組+鏈表/紅黑樹
我們都知道HashMap中處理hash沖突的方法是鏈地址法，也就是說，如果有多個元素key的hash值相同的話，后一個元素并不會覆蓋上一個元素，而是采取鏈表的方式，把之后加進來的元素加入鏈表末尾。
這里要注意的是，鏈表是單鏈表。
而至于紅黑樹是jdk1.8加進去的一個優化，也就是說桶中的結構可能是鏈表，也可能是紅黑樹，采用紅黑樹是為了提高效率，下面我們看一個HashMap的數據結構示意圖（來源網上，侵刪）：
然后我們簡單來看看HashMap中的幾個常量，有助于我們對其進行理解：
//默認初始容量（16）
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;
//最大容量（2^30）
static final int MAXIMUM_CAPACITY = 1 << 30;
//默認加載因子
static final float DEFAULT_LOAD_FACTOR = 0.75f;
//鏈表轉換成樹的閾值
static final int TREEIFY_THRESHOLD = 8;
//樹轉換成鏈表的閾值（執行resize操作時，當桶中bin的數量少于UNTREEIFY_THRESHOLD時使用鏈表來代替樹）
static final int UNTREEIFY_THRESHOLD = 6;
//在轉變成樹之前，還會有一次判斷，只有鍵值對數量大于 64 才會發生轉換。
//這是為了避免在哈希表建立初期，多個鍵值對恰 好被放入了同一個鏈表中而導致不必要的轉化。
static final int MIN_TREEIFY_CAPACITY = 64;
其中，加載因子做一下說明，意思就是：當HashMap中的數據量>容量x加載因子時，就會進行空間的擴大，而且擴大后新的空間一定是原來的2倍，所以，當數據量很大的情況下，將對內存空間造成很大消耗和浪費，而在Android中，我們對內存的控制會更加嚴格，所以，在某些特定場景下我們可以使用SparseArray和ArrayMap來代替HashMap。
2、初識ArrayMap、SparseArray
首先我們來看看HashMap、ArrayMap、SparseArray這三個類的全路徑：
●HashMap：java.util.HashMap
●ArrayMap：android.util.ArrayMap
●SparseArray：android.util.SparseArray
看到區別了沒？也就是說HashMap是jdk里面的類，而ArrayMap和SparseArray為Android獨有的類
而且ArrayMap和SparseArray只能在API19以上的系統里面才有這個類，也就是Android4.4以上
當然，我們都知道Android碎片化嚴重，所以才有了support包，故而在一般情況下，為了兼容性，我們使用ArrayMap和SparseArray時會使用其兼容包，所以導包的時候請注意一點，以下為兼容包的類名：
●android.support.v4.util.ArrayMap
●android.support.v4.util.SparseArrayCompat
接著，我們來看看官方是如何說ArrayMap和SparseArray的：
ArrayMap is a generic key->value mapping data structure that is designed to be more memory efficient than a traditional HashMap, this implementation is a version of the platform's ArrayMap that can be used on older versions of the platform.
SparseArrays map integers to Objects. Unlike a normal array of Objects, there can be gaps in the indices. It is intended to be more memory efficient than using a HashMap to map Integers to Objects, both because it avoids auto-boxing keys and its data structure doesn't rely on an extra entry object for each mapping.
Note that for containers holding up to hundreds of items, the performance difference is not significant, less than 50%.
從官方的說明中，我們知道兩點：
A：ArrayMap和SparseArray會比HashMap更加節省內存空間
B：當數據量達到千級以上的時候，ArrayMap與SparseArray都要比HashMap效率更低50%
3、ArrayMap、SparseArray異同點
1）ArrayMap和SparseArray內部都是用兩個數組來進行數據存儲的
ArrayMap中的兩個數組為：int[] mHashes和Object[] mArray，所以它的一個數組記錄key的hash值，另外一個數組記錄Value值
SparseArray的key值為int型的，所以它的兩個數組為：int[] mKeys和Object[] mValues，很明顯一個存key值，一個存value值
2）ArrayMap與SparseArray內部都使用了二分法進行從小到大的排序（數據量很大時，效率至少會低50%）
我們直接來看一下SparseArray中使用的二分法算法，很贊的算法（我居然看懂了），需要注意的一點，按源碼我們知道，找不到key時返回小于0的數值，而不是返回-1。
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
}
4、HashMap、ArrayMap與SparseArray使用場景
直接上結論：
1）谷歌推薦數據量在千級以內時使用ArrayMap與SparseArray，數據量非常大時使用HashMap
2）如果數據量在千級以內，若key的類型已確定為int型，那么使用SparseArray，因為它避免了自動裝箱的過程，效率會高些
3）如果數據量在千級以內，若key的類型已確定為int型，且value值確定為boolean或int或long，我們還可以直接使用SparseBooleanArray或SparseIntArray或SparseLongArray
4）如果數據量在千級以內，若key的類型已確定為long型，我們還可以使用LongSparseArray
5）如果數據量在千級以內，若key為其他類型，那么使用ArrayMap
5、實踐
紙上得來終覺淺，理論說了一大堆，還是得上demo啊：
public static void main(String[] args) {
zhengMap();
//zhengSparseArray();
//zhengArrayMap();
//fanMap();
//fanSparseArray();
//fanArrayMap();
}
private static int MAX=100000;
private static void zhengMap(){
HashMap<Integer, String>map = new HashMap<>();
long start_map = System.currentTimeMillis();
for(int i=0;i<MAX;i++){
map.put(i, String.valueOf(i));
}
long map_memory = Runtime.getRuntime().totalMemory()-Runtime.getRuntime().freeMemory();
long end_map = System.currentTimeMillis()-start_map;
System.out.println("<---Map的插入時間--->"+end_map+"<---Map占用的內存--->"+map_memory);
/*<---Map的插入時間--->18<---Map占用的內存--->17553296*/
}
private static void fanMap(){
HashMap<Integer, String>map = new HashMap<>();
long start_map = System.currentTimeMillis();
for(int i=MAX-1;i>=0;i--){
map.put(i, String.valueOf(i));
}
long map_memory = Runtime.getRuntime().totalMemory()-Runtime.getRuntime().freeMemory();
long end_map = System.currentTimeMillis()-start_map;
System.out.println("<---Map的插入時間--->"+end_map+"<---Map占用的內存--->"+map_memory);
/*<---Map的插入時間--->18<---Map占用的內存--->17553272*/
}
private static void zhengSparseArray(){
SparseArrayCompat<String> sparse = new SparseArrayCompat<>();
long start_sparse = System.currentTimeMillis();
for(int i=0;i<MAX;i++){
sparse.put(i, String.valueOf(i));
}
long sparse_memory = Runtime.getRuntime().totalMemory()-Runtime.getRuntime().freeMemory();
long end_sparse = System.currentTimeMillis()-start_sparse;
System.out.println("<---Sparse的插入時間--->"+end_sparse+"<---Sparse占用的內存--->"+sparse_memory);
/*<---Sparse的插入時間--->15<---Sparse占用的內存--->13841288*/
}
private static void fanSparseArray(){
SparseArrayCompat<String> sparse = new SparseArrayCompat<>();
long start_sparse = System.currentTimeMillis();
for(int i=MAX-1;i>=0;i--){
sparse.put(i, String.valueOf(i));
}
long sparse_memory = Runtime.getRuntime().totalMemory()-Runtime.getRuntime().freeMemory();
long end_sparse = System.currentTimeMillis()-start_sparse;
System.out.println("<---Sparse的插入時間--->"+end_sparse+"<---Sparse占用的內存--->"+sparse_memory);
/*<---Sparse的插入時間--->2040<---Sparse占用的內存--->13841376*/
}
private static void zhengArrayMap(){
ArrayMap<Integer,String> arrayMap=new ArrayMap<>();
long start_map = System.currentTimeMillis();
for(int i=0;i<MAX;i++){
arrayMap.put(i, String.valueOf(i));
}
long map_memory = Runtime.getRuntime().totalMemory()-Runtime.getRuntime().freeMemory();
long end_map = System.currentTimeMillis()-start_map;
System.out.println("<---ArrayMap的插入時間--->"+end_map+"<---ArrayMap占用的內存--->"+map_memory);
/*<---ArrayMap的插入時間--->16<---ArrayMap占用的內存--->17885040*/
}
private static void fanArrayMap(){
ArrayMap<Integer,String> arrayMap=new ArrayMap<>();
long start_map = System.currentTimeMillis();
for(int i=MAX-1;i>=0;i--){
arrayMap.put(i, String.valueOf(i));
}
long map_memory = Runtime.getRuntime().totalMemory()-Runtime.getRuntime().freeMemory();
long end_map = System.currentTimeMillis()-start_map;
System.out.println("<---ArrayMap的插入時間--->"+end_map+"<---ArrayMap占用的內存--->"+map_memory);
/*<---ArrayMap的插入時間--->2909<---ArrayMap占用的內存--->18168432*/
}
說起這個demo，還花了我不少時間，由于我們要對比的是HashMap、ArrayMap、SparseArray三者的執行效率及內存占用情況，時間計算這個簡單得很，難的是內存的計算，筆者找了不少方案：
1）網上很多都推薦用Instrumentation，我表示搞不定
2）轉byte[]，算大小，HashMap還行，但其他兩個因為沒法序列化而無法進行
3）使用Android Profiler，這個理論上應該是可以的，畢竟工具很強大，可以具體看到某個對象在堆中占的大小，就是有點麻煩，你必須運行到Android系統上，而且得逐個分析找到那個對象
4）筆者一開始用的就是：Runtime.getRuntime().totalMemory()，結果怎么全部都一個樣啊，后來才明白，這個是申請到的全部內存大小（單位字節），還需減去剩余的內存大小得到的才是已使用的，如上面demo所示。
需要注意一點就是，為了計算使用的內存大小，上面6個方法不能同時運行，得逐一運行，否則內存大小肯定算不準的。
各個方法的運行結果已在代碼中注釋出來了，為了更好的顯示結果，我們列一個表格對比一下：
好啦，這個表已經很清楚了，我們可以得出：
1）HashMap無論正序插入還是倒序插入，它的效率幾乎沒什么影響，這得益于它有非常好的處理沖突的方式，不需要遍歷每一個值
2）ArrayMap、SparseArray在正序插入時效率挺好的，但倒序插入就非常糟糕了，這是因為每次插入都需要調用二分查找
3）比較HashMap和SparseArray，很明顯，無論怎么插入，SparseArray占用內存確實小了，優勢很明顯
4）再看ArrayMap的占用內存的情況，好吧，這····好像有點打臉，跟理論還是存在一定的差距的（若有朋友知道原因還請告知，不勝感激！）
5）這個例子有100000數據量，其實并不適合使用ArrayMap和SparseArray
