7，HashMap
阿新 • • 發佈：2018-03-06
map alt eth after 拉鏈法 等於 -- dex print
一，HashMap簡介
1，HashMap 是一個散列表，它存儲的內容是鍵值對(key-value)映射。
2，HashMap 繼承於AbstractMap，實現了Map、Cloneable、java.io.Serializable接口。
3，HashMap 的實現不是同步的。它的key、value都可以為null。此外，HashMap中的映射不是有序的。
4，HashMap 實現了Cloneable接口，即覆蓋了函數clone()（不覆蓋該方法會報CloneNotSupportedException），能被克隆。
5，HashMap 實現Serializable接口，說明HashMap支持序列化 。
二，數據結構
HashMap的數據結構如下：
上圖展示了在JDK1.8中HashMap的數據結構（數組+鏈表+紅黑樹），桶中的結構可能是鏈表，也可能是紅黑樹，紅黑樹的引入是為了提高效率。
三，HashMap源碼
1，HashMap結構
public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable { // 序列號 private static finallong serialVersionUID = 362498820763181265L; // 默認的初始容量是16 static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // 最大容量 static final int MAXIMUM_CAPACITY = 1 << 30; // 默認的填充因子 static final float DEFAULT_LOAD_FACTOR = 0.75f; // 當桶(bucket)上的結點數大於這個值時會轉成紅黑樹 staticfinal int TREEIFY_THRESHOLD = 8; // 當桶(bucket)上的結點數小於這個值時樹轉鏈表 static final int UNTREEIFY_THRESHOLD = 6; // 桶中結構轉化為紅黑樹對應的table的最小大小 static final int MIN_TREEIFY_CAPACITY = 64; // 存儲元素的數組，總是2的冪次倍 transient Node<k,v>[] table; // 存放具體元素的集 transient Set<map.entry<k,v>> entrySet; // 存放元素的個數，註意這個不等於數組的長度。 transient int size; // 每次擴容和更改map結構的計數器 transient int modCount; // 臨界值 當實際大小(容量*填充因子)超過臨界值時，會進行擴容 int threshold; // 填充因子 final float loadFactor; 省略...... }
2，構造函數
HashMap提供了四種方式的構造器，如下
構造器一：
public HashMap(int initialCapacity, float loadFactor) { // 初始容量不能小於0，否則報錯 if (initialCapacity < 0) throw new IllegalArgumentException("Illegal initial capacity: " + initialCapacity); // 初始容量不能大於最大值，否則為最大值 if (initialCapacity > MAXIMUM_CAPACITY) initialCapacity = MAXIMUM_CAPACITY; // 填充因子不能小於或等於0，不能為非數字 if (loadFactor <= 0 || Float.isNaN(loadFactor)) throw new IllegalArgumentException("Illegal load factor: " + loadFactor); // 初始化填充因子 this.loadFactor = loadFactor; // 初始化threshold大小 this.threshold = tableSizeFor(initialCapacity); }
tableSizeFor(initialCapacity)方法返回大於等於initialCapacity的最小的二次冪數值。具體代碼如下：
static final int tableSizeFor(int cap) { int n = cap - 1; n |= n >>> 1; n |= n >>> 2; n |= n >>> 4; n |= n >>> 8; n |= n >>> 16; return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1; }
構造器二：
public HashMap(int initialCapacity) { // 調用HashMap(int, float)型構造函數 this(initialCapacity, DEFAULT_LOAD_FACTOR); }
構造器三：
public HashMap() { // 初始化填充因子 this.loadFactor = DEFAULT_LOAD_FACTOR; }
構造器四：
public HashMap(Map<? extends K, ? extends V> m) { // 初始化填充因子 this.loadFactor = DEFAULT_LOAD_FACTOR; // 將m中的所有元素添加至HashMap中 putMapEntries(m, false); }
putMapEntries(Map<? extends K, ? extends V> m, boolean evict)方法將m的所有元素存入本HashMap實例中。具體代碼如下：
final void putMapEntries(Map<? extends K, ? extends V> m, boolean evict) { int s = m.size(); if (s > 0) { // 判斷table是否已經初始化 if (table == null) { // pre-size // 未初始化，s為m的實際元素個數 float ft = ((float)s / loadFactor) + 1.0F; int t = ((ft < (float)MAXIMUM_CAPACITY) ? (int)ft : MAXIMUM_CAPACITY); // 計算得到的t大於閾值，則初始化閾值 if (t > threshold) threshold = tableSizeFor(t); } // 已初始化，並且m元素個數大於閾值，進行擴容處理 else if (s > threshold) resize(); // 將m中的所有元素添加至HashMap中 for (Map.Entry<? extends K, ? extends V> e : m.entrySet()) { K key = e.getKey(); V value = e.getValue(); putVal(hash(key), key, value, false, evict); } } }
3，HashMap數據存儲數組table，節點Node的數據結構
static class Node<K,V> implements Map.Entry<K,V> { final int hash; final K key; V value; // 指向下一個節點 Node<K,V> next; // 構造函數。 // 輸入參數包括"哈希值(hash)", "鍵(key)", "值(value)", "下一節點(next)" Node(int hash, K key, V value, Node<K,V> next) { this.hash = hash; this.key = key; this.value = value; this.next = next; } public final K getKey() { return key; } public final V getValue() { return value; } public final String toString() { return key + "=" + value; } public final int hashCode() { return Objects.hashCode(key) ^ Objects.hashCode(value); } public final V setValue(V newValue) { V oldValue = value; value = newValue; return oldValue; } // 判斷兩個Entry是否相等，若兩個Entry的“key”和“value”都相等，則返回true,否則，返回false public final boolean equals(Object o) { if (o == this) return true; if (o instanceof Map.Entry) { Map.Entry<?,?> e = (Map.Entry<?,?>)o; if (Objects.equals(key, e.getKey()) && Objects.equals(value, e.getValue())) return true; } return false; } }
從中，可以看出Node實際上就是一個單向鏈表。這也是為什麽說HashMap是通過拉鏈法解決哈希沖突的。
Node實現了Map.Entry 接口，即實現getKey(), getValue(), setValue(V value), equals(Object o), hashCode()這些函數。這些都是基本的讀取/修改key、value值的函數。
4，部分函數
4.1，put()函數
//指定節點key,value，向hashMap中插入節點 public V put(K key, V value) { //註意待插入節點hash值的計算，調用了hash(key)函數 //實際調用 putVal（）進行節點的插入 eturn putVal(hash(key), key, value, false, true); } static final int hash(Object key) { int h; /*key 的hash值的計算是通過hashCode()的高16位異或低16位實現的：(h = k.hashCode()) ^ (h >>> 16)， 主要是從速度、功效、質量來考慮的，這麽做可以在bat數組table的length比較小的時候， 也能保證考慮到高低Bit都參與到Hash的計算中，同時不會有太大的開銷*/ return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16); } public void putAll(Map<? extends K, ? extends V> m) { putMapEntries(m, true); } /*把Map<? extends K, ? extends V> m 中的元素插入到hashMap 中, 若evict為false,代表是在創建hashMap時調用了這個函數， 例如利用上述構造函數３創建hashMap;若evict為true,代表是在創建hashMap後才調用這個函數，例如上述的putAll函數。*/ final void putMapEntries(Map<? extends K, ? extends V> m, boolean evict) { int s = m.size(); if (s > 0) { /*如果是在創建hashMap時調用的這個函數則table一定為空*/ if (table == null) { //根據待插入的map的size計算要創建的hashMap的容量。 float ft = ((float)s / loadFactor) + 1.0F; int t = ((ft < (float)MAXIMUM_CAPACITY) ? (int)ft : MAXIMUM_CAPACITY); //把要創建的hashMap的容量存在threshold中 if (t > threshold) threshold = tableSizeFor(t); } //判斷待插入的map的size,若size大於threshold，則先進行resize() else if (s > threshold) resize(); for (Map.Entry<? extends K, ? extends V> e : m.entrySet()) { K key = e.getKey(); V value = e.getValue(); //實際也是調用putVal函數進行元素的插入 putVal(hash(key), key, value, false, evict); } } } final V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict) { Node<K,V>[] tab; Node<K,V> p; int n, i; if ((tab = table) == null || (n = tab.length) == 0) n = (tab = resize()).length; /*根據hash值確定節點在數組中的插入位置，若此位置沒有元素則進行插入， 註意確定插入位置所用的計算方法為(n - 1) & hash,由於n一定是２的冪次，這個操作相當於hash%n */ if ((p = tab[i = (n - 1) & hash]) == null) tab[i] = newNode(hash, key, value, null); else {//說明待插入位置存在元素 Node<K,V> e; K k; //比較原來元素與待插入元素的hash值和key值. if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k)))) e = p; //若原來元素是紅黑樹節點，調用紅黑樹的插入方法:putTreeVal else if (p instanceof TreeNode) e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value); else {//證明原來的元素是鏈表的頭結點，從此節點開始向後尋找合適插入位置 for (int binCount = 0; ; ++binCount) { if ((e = p.next) == null) { //找到插入位置後，新建節點插入 p.next = newNode(hash, key, value, null); //若鏈表上節點超過TREEIFY_THRESHOLD-1，將鏈表變為紅黑樹 if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st treeifyBin(tab, hash); break; } if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k)))) break; p = e; } } if (e != null) { //待插入元素在hashMap中已存在 V oldValue = e.value; if (!onlyIfAbsent || oldValue == null) e.value = value; //鉤子函數，用於給LinkedHashMap繼承後使用，在HashMap裏是空的 afterNodeAccess(e); return oldValue; } } //修改次數+1 ++modCount; //實際大小+1，如果大於閾值，重新計算並擴容 if (++size > threshold) resize(); //鉤子函數，用於給LinkedHashMap繼承後使用，在HashMap裏是空的 afterNodeInsertion(evict); return null; }
4.2，get()函數
HashMap並沒有直接提供getNode接口給用戶調用，而是提供的get函數，而get函數就是通過getNode來取得元素的。
public V get(Object key) { Node<K,V> e; //根據輸入節點的hash值和key值利用getNode方法進行查找。 return (e = getNode(hash(key), key)) == null ? null : e.value; } final Node<K,V> getNode(int hash, Object key) { Node<K,V>[] tab; Node<K,V> first, e; int n; K k; // 判斷table是否已經初始化，並且長度大於0，並且根據hash尋找table中的項也不為空 if ((tab = table) != null && (n = tab.length) > 0 && (first = tab[(n - 1) & hash]) != null) { // 桶中第一項(數組元素)相等時 if (first.hash == hash && // always check first node ((k = first.key) == key || (key != null && key.equals(k)))) return first; // 桶中不止一個結點時 if ((e = first.next) != null) { // 如果為紅黑樹結點 if (first instanceof TreeNode) // 在紅黑樹中查找 return ((TreeNode<K,V>)first).getTreeNode(hash, key); do { // 否則，在鏈表中查找 if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k)))) return e; } while ((e = e.next) != null); } } return null; }
4.3，remove()函數
@Override public V remove(Object key) { Node<K,V> e; return (e = removeNode(hash(key), key, null, false, true)) == null ? null : e.value; } @Override public boolean remove(Object key, Object value) { return removeNode(hash(key), key, value, true, true) != null; } /** * @param hash key的hash值 * @param key * @param value 與下面的matchValue結合，如果matchValue為false，則忽略value。 * @param matchValue 為true，則判斷是否與value相等。 * @param movable 主要跟樹節點的remove有關，為false，則不移動其他的樹節點。 */ final Node<K,V> removeNode(int hash, Object key, Object value, boolean matchValue, boolean movable) { Node<K,V>[] tab; Node<K,V> p; int n, index; // 判斷table是否已經初始化，並且長度大於0，並且根據hash尋找table中的項也不為空 if ((tab = table) != null && (n = tab.length) > 0 && (p = tab[index = (n - 1) & hash]) != null) { Node<K,V> node = null, e; K k; V v; //對下標節點進行判斷，如果相同，則賦給臨時節點 if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k)))) node = p; else if ((e = p.next) != null) { //為樹節點，則按照樹節點的操作來進行查找並返回 if (p instanceof TreeNode) node = ((TreeNode<K,V>)p).getTreeNode(hash, key); else { do { if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k)))) { node = e; break; } p = e; } while ((e = e.next) != null); } } //如果找到了key對應的node，則進行刪除操作 if (node != null && (!matchValue || (v = node.value) == value || (value != null && value.equals(v)))) { //為樹節點，則進行樹節點的刪除操作 if (node instanceof TreeNode) ((TreeNode<K,V>)node).removeTreeNode(this, tab, movable); //如果node == p，說明該key所在的位置為數組的下標位置，所以下標位置指向下一個節點即可 else if (node == p) tab[index] = node.next; //否則的話，key在桶中，p為node的上一個節點，p.next指向node.next即可 else p.next = node.next; //修改次數+1 ++modCount; --size; //鉤子函數，用於給LinkedHashMap繼承後使用，在HashMap裏是空的 afterNodeRemoval(node); return node; } } return null; }
4.4，resize()函數
resize()函數用於進行擴容，會伴隨著一次重新hash分配，並且會遍歷hash表中所有的元素，是非常耗時的。在編寫程序中，要盡量避免resize，在明確知道map要用的容量的時候，使用指定初始化容量的構造函數。
final Node<K,V>[] resize() { // 獲取當前table保存 Node<K,V>[] oldTab = table; // 獲得table大小 int oldCap = (oldTab == null) ? 0 : oldTab.length; // 獲得當前閾值 int oldThr = threshold; int newCap, newThr = 0; // 之前table值大小大於0時 if (oldCap > 0) { // 之前table值大於最大容量 if (oldCap >= MAXIMUM_CAPACITY) { // 閾值為最大整形 threshold = Integer.MAX_VALUE; return oldTab; } // 容量翻倍，使用左移，效率更高 else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY && oldCap >= DEFAULT_INITIAL_CAPACITY) // 閾值翻倍 newThr = oldThr << 1; // double threshold } // 之前閾值大於0 else if (oldThr > 0) // initial capacity was placed in threshold newCap = oldThr; else { // oldCap = 0並且oldThr = 0，使用缺省值（如使用HashMap()構造函數，之後再插入一個元素會調用resize函數，會進入這一步） newCap = DEFAULT_INITIAL_CAPACITY; newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY); } // 新閾值為0時 if (newThr == 0) { float ft = (float)newCap * loadFactor; newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ? (int)ft : Integer.MAX_VALUE); } threshold = newThr; @SuppressWarnings({"rawtypes","unchecked"}) // 初始化table Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap]; table = newTab; // 之前的table已經初始化過，不為null時 if (oldTab != null) { // 復制元素,把oldTab中的節點reHash到newTab中去 for (int j = 0; j < oldCap; ++j) { Node<K,V> e; if ((e = oldTab[j]) != null) { oldTab[j] = null; //若節點是單個節點，直接在newTab中進行重定位 if (e.next == null) newTab[e.hash & (newCap - 1)] = e; //若節點是TreeNode節點，要進行紅黑樹的rehash操作 else if (e instanceof TreeNode) ((TreeNode<K,V>)e).split(this, newTab, j, oldCap); //若是鏈表，進行鏈表的rehash操作 else { // preserve order Node<K,V> loHead = null, loTail = null; Node<K,V> hiHead = null, hiTail = null; Node<K,V> next; // 將同一桶中的元素根據(e.hash & oldCap)是否為0進行分割，分成兩個不同的鏈表，完成rehash do { next = e.next; //根據算法e.hash & oldCap判斷節點位置rehash後是否發生改變 if ((e.hash & oldCap) == 0) { if (loTail == null) loHead = e; else loTail.next = e; loTail = e; } else { if (hiTail == null) hiHead = e; else hiTail.next = e; hiTail = e; } } while ((e = next) != null); if (loTail != null) { loTail.next = null; newTab[j] = loHead; } if (hiTail != null) { hiTail.next = null; newTab[j + oldCap] = hiHead; } } } } } return newTab; }
在resize前和resize後的元素布局如下：
下圖只是針對了數組下標為2的桶中的各個元素在擴容後的分配布局，其他各個桶中的元素布局可以以此類推。
四，HashMap遍歷方式
import java.util.Collection; import java.util.HashMap; import java.util.Iterator; import java.util.Map; public class TestHashMap { public static void main(String[] args) { HashMap<String, String> hashMap = new HashMap<String, String>(); hashMap.put("MapKey1", "MapValue1"); hashMap.put("MapKey2", "MapValue2"); hashMap.put("MapKey3", "MapValue3"); hashMap.put("MapKey4", "MapValue4"); hashMap.put("MapKey5", "MapValue5"); hashMap.put("MapKey6", "MapValue6"); TestHashMap.getHashMap_Values(hashMap); System.out.println("---------------------------"); TestHashMap.getHashMap_Entry_KeyValues(hashMap); System.out.println("---------------------------"); TestHashMap.getHashMap_Keyset_KeyValues(hashMap); } //遍歷HashMap的values public static void getHashMap_Values(HashMap<?, ?> hashMap){ if(hashMap == null) return; Collection<?> c = hashMap.values(); Iterator<?> iter= c.iterator(); while (iter.hasNext()) { System.out.println(iter.next()); } } //通過entry set遍歷HashMap(效率高) public static void getHashMap_Entry_KeyValues(HashMap<?, ?> hashMap){ if(hashMap == null) return; Iterator<?> iterator = hashMap.entrySet().iterator(); while (iterator.hasNext()) { Map.Entry entry = (Map.Entry)iterator.next(); System.out.print(entry.getKey()); System.out.println("---------" + entry.getValue()); } } //通過keyset來遍歷HashMap(效率低) public static void getHashMap_Keyset_KeyValues(HashMap<?, ?> hashMap){ if(hashMap == null) return; Iterator<?> iterator = hashMap.keySet().iterator(); while(iterator.hasNext()){ String key = (String) iterator.next(); System.out.print(key); System.out.println("---------" + hashMap.get(key)); } } }
五，JDK1.8與JDK1.7的性能對比
詳情跳轉：JDK1.8與JDK1.7的性能對比
7，HashMap