Android面試之HashMap的實現原理
1、HashMap與HashTable的區別
-
HashMap允許key和value為null；
-
HashMap是非同步的，線程不安全，也可以通過Collections.synchronizedMap()方法來得到一個同步的HashMap
-
HashMap存取速度更快，效率高
-
HashMap去掉了HashTable中的contains方法，加上了containsValue和containsKey方法
2、HashMap的實現原理
一句話理解HashMap：HashMap就是Hash表的Map實現。 Hash表就是Hash數組，Map實現是指實現了Map接口。
-
HashMap的數據結構
HashMap的底層是基於數組和鏈表實現的，存儲速度快的原因是因為它是通過計算散列碼來決定存儲的位置。HashMap中主要是通過key的hashCode來計算hash值的，只要hashCode相同，計算出來的hash值就一樣。如果存儲的對象對多了，就有可能不同的對象所算出來的hash值是相同的，這就出現了所謂的hash沖突。解決hash沖突的方法有很多，HashMap底層是通過鏈表來解決hash沖突的。
HashMap中Entry類源碼
static class Entry<K,V> implements Map.Entry<K,V> {
final K key;
V value;
Entry<K,V> next;
final int hash;
Entry(int h, K k, V v, Entry<K,V> n) {
value = v;
next = n;
key = k;
hash = h;
}
public final K getKey() {
return key;
}
public final V getValue() {
return value;
}
public final V setValue(V newValue) {
V oldValue = value;
value = newValue;
return oldValue;
}
public final boolean equals(Object o) {
if (!(o instanceof Map.Entry))
return false;
Map.Entry e = (Map.Entry)o;
Object k1 = getKey();
Object k2 = e.getKey();
if (k1 == k2 || (k1 != null && k1.equals(k2))) {
Object v1 = getValue();
Object v2 = e.getValue();
if (v1 == v2 || (v1 != null && v1.equals(v2)))
return true;
}
return false;
}
public final int hashCode() {
return (key==null ? 0 : key.hashCode()) ^
(value==null ? 0 : value.hashCode());
}
public final String toString() {
return getKey() + "=" + getValue();
}
void recordAccess(HashMap<K,V> m) {
}
void recordRemoval(HashMap<K,V> m) {
}
}
HashMap其實就是一個Entry數組，Entry對象中包含了鍵和值，其中next也是一個Entry對象，它就是用來處理hash沖突的，形成一個鏈表。
2. HashMap的幾個變量
transient Entry[] table;//存儲Entry的數組
transient int size;//存放entry的個數
int threshold;//下限，臨界值，數組長度超過這個值會擴容，threshold = loadFactor*容量；
final float loadFactory；//加載因子，加載因子越大表示當前數組填滿的元素越多，空間利用率高，不方便查詢；加載因子越小，表示填滿元素越少，空間利用率低，方便速度快。默認值是0.75；
transient int modCount；//被修改的次數
3. HashMap的構造方法
public HashMap(int initialCapacity, float loadFactor) {
if (initialCapacity < 0) throw new IllegalArgumentException("Illegal initial capacity: " +
initialCapacity); if (initialCapacity > MAXIMUM_CAPACITY)
initialCapacity = MAXIMUM_CAPACITY; if (loadFactor <= 0 || Float.isNaN(loadFactor)) throw new IllegalArgumentException("Illegal load factor: " +
loadFactor); // Find a power of 2 >= initialCapacity
int capacity = 1;
while (capacity < initialCapacity)
capacity <<= 1; this.loadFactor = loadFactor;
threshold = (int)(capacity * loadFactor);
table = new Entry[capacity];
init();
}
允許我們自己指定初始容量和加載因子
public HashMap(int initialCapacity) { this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
只指定初始容量，加載因子使用默認的0.75；
public HashMap() { this.loadFactor = DEFAULT_LOAD_FACTOR;
threshold = (int)(DEFAULT_INITIAL_CAPACITY * DEFAULT_LOAD_FACTOR);
table = new Entry[DEFAULT_INITIAL_CAPACITY];
init();
}
初始容量和加載因子全部使用默認的值，默認初始的加載容量是16，加載因子是0.75；
4. 存儲數據put方法
public V put(K key, V value) {
if (key == null)
return putForNullKey(value);
int hash = hash(key.hashCode());
int i = indexFor(hash, table.length);
for (Entry<K,V> e = table[i]; e != null; e = e.next) {
Object k; if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
V oldValue = e.value;
e.value = value;
e.recordAccess(this); return oldValue;
}
}
modCount++;
addEntry(hash, key, value, i); return null;
}
可以看出，HashMap存放數據的時候，會先拿到key的hashCode值，對其進行hash運算，得到具體的hash值，然後根據hash值查找存放的位置，找到存放的位置後，然後遍歷table數組找到對應位置的entry，如果當前的key已經存在，且對比entry的hash值和key相同的話，那麽就更新value值；否則就將key和value值加到數組中；
這裏需要註意：判斷是否2個Entry相同，需要從2方面判斷：1、2個Entry的key必須相同（k = e.key||key.equals(k)）；2、2個Entry的hashCode，也就是hash值必須相同（這裏說的hash是經過hash（hashCode）換算後的值）；上述2個條件都滿足的話，才可以認定當前Entry已經存在，新的Entry才會替換舊的Entry。
下面給出put過程中，涉及到的2個方法
- 根據hashCode求hash碼的實現
static int hash(int h) {
h ^= (h >>> 20) ^ (h >>> 12); return h ^ (h >>> 7) ^ (h >>> 4);
}
- 根據hash碼求存儲在數組中的索引
static int indexFor(int h, int length) { //根據hash值和數組長度算出索引值2 return h & (length-1); //這裏不能隨便算取，用hash&(length-1)是有原因的，這樣可以確保算出來的索引是在數組大小範圍內，不會超出3 }
這裏有些同學會好奇，為什麽索引值是h & (length-1)？ 其實，這裏面的故事還是挺多的。 一般對哈希表求散列我們會使用hash值對length取模，HashTable就是這樣實現的，這種方法可以保證元素在哈希表中散列均勻，但取模會用到除法運算，效率非常低，HashMap是對HashTable進行改進後的實現，為了提高效率，使用h&（length-1）取代除法運算，在保證散列均勻的基礎上還保持了效率的提升。
5. resize方法
用於重新擴大縮小數組的大小
void resize(int newCapacity) {
Entry[] oldTable = table;
int oldCapacity = oldTable.length;
if (oldCapacity == MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return;
}
Entry[] newTable = new Entry[newCapacity];
transfer(newTable);
table = newTable;
threshold = (int)(newCapacity * loadFactor);
}
其實就是新建一個大的數組，把原來的數據重新添加進去。什麽時候才會觸發resize方法呢？當當前元素的數量達到數組總size的loadFactor（默認0.75）時候，會調用resize方法，將數組擴大為原來大小的2倍；
6. HashMap的get方法
public V get(Object key) {
if (key == null)
return getForNullKey();
int hash = hash(key.hashCode());
for (Entry<K,V> e = table[indexFor(hash, table.length)];
e != null;
e = e.next) {
Object k;
if (e.hash == hash && ((k = e.key) == key || key.equals(k)))
return e.value;
}
return null;
}
可以看出，首先拿到key的hashcode，求出hash碼，根據hash碼找到索引的位置，然後去數組中獲取對應索引的元素，如果key的hash相同，key相同的話，那麽這就是我們要找的entry，把entry的值返回出去就Ok了。
如果大家覺得好，大家轉載的同時，也點點文章最下面“AndroidDeveloper”的訂閱按鈕，關註“AndroidDeveloper”
Android面試之HashMap的實現原理