一、前言
前面已經分析了HashMap與LinkedHashMap，現在我們來分析不太常用的IdentityHashMap，從它的名字上也可以看出來用於表示唯一的HashMap，仔細分析了其原始碼，發現其資料結構與HashMap使用的資料結構完全不同，因為在繼承關係上面，他們兩沒有任何關係。下面，進入我們的分析階段。
二、IdentityHashMap示例
import java.util.Map; import java.util.HashMap; import java.util.IdentityHashMap; public class IdentityHashMapTest { public static void main(String[] args) { Map<String, String> hashMaps = new HashMap<String, String>(); Map<String, String> identityMaps = new IdentityHashMap<String, String>(); hashMaps.put(new String("aa"), "aa"); hashMaps.put(new String("aa"), "bb"); identityMaps.put(new String("aa"), "aa"); identityMaps.put(new String("aa"), "bb"); System.out.println(hashMaps.size() + " : " + hashMaps); System.out.println(identityMaps.size() + " : " + identityMaps); } }
執行結果：
1 : {aa=bb}
2 : {aa=bb, aa=aa}
說明：IdentityHashMap只有在key完全相等（同一個引用），才會覆蓋，而HashMap則不會。
三、IdentityHashMap資料結構
說明：IdentityHashMap的資料很簡單，底層實際就是一個Object陣列，在邏輯上需要看成是一個環形的陣列，解決衝突的辦法是：根據計算得到雜湊位置，如果發現該位置上已經有元素，則往後查詢，直到找到空位置，進行存放，如果沒有，直接進行存放。當元素個數達到一定閾值時，Object陣列會自動進行擴容處理。
四、IdentityHashMap原始碼分析
4.1 類的繼承關係
public class IdentityHashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, java.io.Serializable, Cloneable
說明：繼承了AbstractMap抽象類，實現了Map介面，可序列化介面，可克隆介面。
4.2 類的屬性
public class IdentityHashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, java.io.Serializable, Cloneable { // 預設容量大小 private static final int DEFAULT_CAPACITY = 32; // 最小容量 private static final int MINIMUM_CAPACITY = 4; // 最大容量 private static final int MAXIMUM_CAPACITY = 1 << 29; // 用於儲存實際元素的表 transient Object[] table; // 大小 int size; // 對Map進行結構性修改的次數 transient int modCount; // null key所對應的值 static final Object NULL_KEY = new Object(); }
說明：可以看到類的底層就是使用了一個Object陣列來存放元素。
4.3 類的建構函式
1. IdentityHashMap()型建構函式
public IdentityHashMap() { init(DEFAULT_CAPACITY); }
2. IdentityHashMap(int)型建構函式
public IdentityHashMap(int expectedMaxSize) { if (expectedMaxSize < 0) throw new IllegalArgumentException("expectedMaxSize is negative: " + expectedMaxSize); init(capacity(expectedMaxSize)); }
3. IdentityHashMap(Map<? extends K, ? extends V>)型建構函式
public IdentityHashMap(Map<? extends K, ? extends V> m) { // 呼叫其他建構函式 this((int) ((1 + m.size()) * 1.1)); putAll(m); }
4.4 重要函式分析
1. capacity函式
// 此函式返回的值是最小大於expectedMaxSize的2次冪 private static int capacity(int expectedMaxSize) { // assert expectedMaxSize >= 0; return (expectedMaxSize > MAXIMUM_CAPACITY / 3) ? MAXIMUM_CAPACITY : (expectedMaxSize <= 2 * MINIMUM_CAPACITY / 3) ? MINIMUM_CAPACITY : Integer.highestOneBit(expectedMaxSize + (expectedMaxSize << 1)); }
說明： 此函式返回的值是最小的且大於expectedMaxSize的2次冪的值。
2. hash函式
// hash函式，由於length總是為2的n次冪，所以 & (length - 1)相當於對length取模 private static int hash(Object x, int length) { int h = System.identityHashCode(x); // Multiply by -127, and left-shift to use least bit as part of hash return ((h << 1) - (h << 8)) & (length - 1); }
說明：hash函式用於雜湊，並且保證元素的雜湊值會在陣列偶次索引。
3. get函式
public V get(Object key) { // 保證null的key會轉化為Object(NULL_KEY) Object k = maskNull(key); // 儲存table Object[] tab = table; int len = tab.length; // 得到key的雜湊位置 int i = hash(k, len); // 遍歷table，解決雜湊衝突的辦法是若衝突，則往後尋找空閒區域 while (true) { Object item = tab[i]; // 判斷是否相等(地址是否相等) if (item == k) // 地址相等，即完全相等的兩個物件 return (V) tab[i + 1]; // 對應雜湊位置的元素為空，則返回空 if (item == null) return null; // 取下一個Key索引 i = nextKeyIndex(i, len); } }
說明：該函式比較key值是否完全相同（物件型別則是否為同一個引用，基本型別則是否內容相等）
4. nextKeyIndex函式
// 下一個Key索引 private static int nextKeyIndex(int i, int len) { // 往後移兩個單位 return (i + 2 < len ? i + 2 : 0); }
說明：此函式用於發生衝突時，取下一個位置進行判斷。
5. put函式
public V put(K key, V value) { // 保證null的key會轉化為Object(NULL_KEY) final Object k = maskNull(key); retryAfterResize: for (;;) { final Object[] tab = table; final int len = tab.length; int i = hash(k, len); for (Object item; (item = tab[i]) != null; i = nextKeyIndex(i, len)) { if (item == k) { // 經過hash計算的項與key相等 @SuppressWarnings("unchecked") // 取得值 V oldValue = (V) tab[i + 1]; // 將value存入 tab[i + 1] = value; // 返回舊值 return oldValue; } } // 大小加1 final int s = size + 1; // Use optimized form of 3 * s. // Next capacity is len, 2 * current capacity. // 如果3 * size大於length，則會進行擴容操作 if (s + (s << 1) > len && resize(len)) // 擴容後重新計算元素的值，尋找合適的位置進行存放 continue retryAfterResize; // 結構性修改加1 modCount++; // 存放key與value tab[i] = k; tab[i + 1] = value; // 更新size size = s; return null; } }
說明：若傳入的key在表中已經存在了（強調：是同一個引用），則會用新值代替舊值並返回舊值；如果元素個數達到閾值，則擴容，然後再尋找合適的位置存放key和value。
6. resize函式
private boolean resize(int newCapacity) { // assert (newCapacity & -newCapacity) == newCapacity; // power of 2 int newLength = newCapacity * 2; // 儲存原來的table Object[] oldTable = table; int oldLength = oldTable.length; // 舊錶是否為最大容量的2倍 if (oldLength == 2 * MAXIMUM_CAPACITY) { // can't expand any further // 之前元素個數為最大容量，丟擲異常 if (size == MAXIMUM_CAPACITY - 1) throw new IllegalStateException("Capacity exhausted."); return false; } // 舊錶長度大於新表長度，返回false if (oldLength >= newLength) return false; // 生成新表 Object[] newTable = new Object[newLength]; // 將舊錶中的所有元素重新hash到新表中 for (int j = 0; j < oldLength; j += 2) { Object key = oldTable[j]; if (key != null) { Object value = oldTable[j+1]; oldTable[j] = null; oldTable[j+1] = null; int i = hash(key, newLength); while (newTable[i] != null) i = nextKeyIndex(i, newLength); newTable[i] = key; newTable[i + 1] = value; } } // 新表賦值給table table = newTable; return true; }
說明：當表中元素達到閾值時，會進行擴容處理，擴容後會舊錶中的元素重新hash到新表中。
7. remove函式
public V remove(Object key) { // 保證null的key會轉化為Object(NULL_KEY) Object k = maskNull(key); Object[] tab = table; int len = tab.length; // 計算hash值 int i = hash(k, len); while (true) { Object item = tab[i]; // 找到key相等的項 if (item == k) { modCount++; size--; @SuppressWarnings("unchecked") V oldValue = (V) tab[i + 1]; tab[i + 1] = null; tab[i] = null; // 刪除後需要進行後續處理，把之前由於衝突往後挪的元素移到前面來 closeDeletion(i); return oldValue; } // 該項為空 if (item == null) return null; // 下一項 i = nextKeyIndex(i, len); } }
8. closeDeletion函式
private void closeDeletion(int d) { // Adapted from Knuth Section 6.4 Algorithm R Object[] tab = table; int len = tab.length; // Look for items to swap into newly vacated slot // starting at index immediately following deletion, // and continuing until a null slot is seen, indicating // the end of a run of possibly-colliding keys. Object item; // 把該元素後面符合移動規定的元素往前面移動 for (int i = nextKeyIndex(d, len); (item = tab[i]) != null; i = nextKeyIndex(i, len) ) { // The following test triggers if the item at slot i (which // hashes to be at slot r) should take the spot vacated by d. // If so, we swap it in, and then continue with d now at the // newly vacated i. This process will terminate when we hit // the null slot at the end of this run. // The test is messy because we are using a circular table. int r = hash(item, len); if ((i < r && (r <= d || d <= i)) || (r <= d && d <= i)) { tab[d] = item; tab[d + 1] = tab[i + 1]; tab[i] = null; tab[i + 1] = null; d = i; } } }
說明：在刪除一個元素後會進行一次closeDeletion處理，重新分配元素的位置。
下圖表示在closeDeletion前和closeDeletion後的示意圖
說明：假設：其中，（"aa" -> "aa"）經過hash後在第0項，("bb" -> "bb")經過hash後也應該在0項，發生衝突，往後移到第2項，("cc" -> "cc")經過hash後在第2項，發生衝突，往後面移動到第4項，("gg" -> "gg")經過hash在第2項，發生衝突，往後移動到第6項，("dd" -> "dd")在第8項，("ee" -> "ee")在第12項。當刪除("bb" -> "bb")後，進行處理後的元素佈局如右圖所示。
五、總結
IdentityHashMap與HashMap在資料結構上很不相同，並且處理hash衝突的方法也不相同。其中，IdentityHashMap只有當key為同一個引用時才認為是相同的，而HashMap還包括equals相等，即內容相同。