2. 程式人生 > >JDK1.8原始碼解讀——HashMap原始碼

JDK1.8原始碼解讀——HashMap原始碼

阿新 • • 發佈：2018-11-28

從類的Doc文件註釋中，我們可以得出HashMap的一些特性：
　　1 無序 允許為null 非同步
　　2 底層由雜湊表實現
　　3 初始容量和負載因子對HashMap的影響很大
成員變數：

   /**預設初始值，必須是二的倍數 */
   static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; 
   /** 最大容量 */
   static final int MAXIMUM_CAPACITY = 1 << 30;
   /**預設的負載因子 */
   static final float DEFAULT_LOAD_FACTOR =
 
 0.75f;
   /**閾值，一個雜湊桶被新增到TREEIFY_THRESHOLD個節點的時候，桶中的連結串列會被轉化為紅黑二叉樹 */
   static final int TREEIFY_THRESHOLD = 8;
   /** 閾值，將紅黑二叉樹轉化成連結串列（紅黑二叉樹為了保持平衡，要進行左旋，右旋，換色，消耗資源）*/
   static final int UNTREEIFY_THRESHOLD = 6;
   /**桶可能被樹化為樹形結構的最小容量*/
   static final int MIN_TREEIFY_CAPACITY = 64;

儲存結構：
HashMap內部包含了一個Node型別的陣列table，Node即為 JDK1.8之前的Entry

transient Node<K,V>[] table;

/**
* Basic hash bin node, used for most entries.  (See below for
* TreeNode subclass, and in LinkedHashMap for its Entry subclass.)
*/
static class Node<K,V> implements Map.Entry<K,V> {
 final int hash;
 final K key;
 V value;
 Node<K,V> 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;
 }

 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裡儲存的是鍵值對。包含四個欄位，從next欄位我們可以看出Node是一個連結串列。
即table陣列中每個位置被當成一個桶，一個桶用來存放一個連結串列Node。
　　HashMap使用拉鍊法來解決衝突（ThreadLocalMap則是採用線性探測法），同一個連結串列存放key的雜湊值相同的Node
1 put方法（HashMap的核心）：

public V put(K key, V value) {
  return putVal(hash(key), key, value, false, true);
}

hash後的key，key Value ，兩個引數

首先，看一下hash方法

static final int hash(Object key) {
  int h;
  return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}

結論：
　　int 一共32位，這裡作者將其分成前16位和後16位。取key的hashcode，與keyhashCode的高16位做異或。這裡是將低16位與高16位做運算，得到的值實際上是高位和低位的結合，這就增加了隨機性。在一定程度上減少了雜湊衝突的發生。這裡hashCode是呼叫的Object中的hashCode，即引用物件的hashcode與其記憶體地址有關

/**
* Implements Map.put and related methods
*
* @param key的雜湊值
* @param key 鍵
* @param value 要放入的值
* @param onlyIfAbsent true 則不改變現有值，預設是false
* @param evict 如果是false，則表處於建立模式，預設是true
* @return previous value, or null if none
*/
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;
　//如果散列表為null，則初始化散列表
  if ((p = tab[i = (n - 1) & hash]) == null)
      tab[i] = newNode(hash, key, value, null);
　　//將物件放入散列表的時，預設初始容量是16，也就是說，要放到table陣列的0-15的位置上，所以通過tab[i = (n - 1) & hash]來確定陣列下標位置，n如果為奇數，則n-1為偶數，0與任何數的&運算都是0，會造成一部分的記憶體浪費（下標最後一位為0的位置存不會存值）
　　//如果沒有發生雜湊衝突，則直接將新建的Entry物件放入table陣列中
  else {
      Node<K,V> e; K k;
      if (p.hash == hash &&
          ((k = p.key) == key || (key != null && key.equals(k))))
          e = p;
//如果發生了雜湊衝突，就先記錄下發生衝突的Node
      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) {
　　　　　　　　　　//如果遍歷連結串列沒有發現該此節點，就插入連結串列的尾部（尾插法，1.8之前都是頭插法）
                  p.next = newNode(hash, key, value, null);
　　　　　　　　　　//如果插入後連結串列長度大於8，則轉換為紅黑樹
                  if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                      treeifyBin(tab, hash);
                  break;
              }
    　　　　　//如果key在連結串列中已經存在，則退出迴圈
              if (e.hash == hash &&
                  ((k = e.key) == key || (key != null && key.equals(k))))
                  break;
              p = e;
          }
      }
　　　//如果key在連結串列中已經存在，則修改其原先的key值，並且返回老的值
      if (e != null) { // existing mapping for key
          V oldValue = e.value;
          if (!onlyIfAbsent || oldValue == null)
              e.value = value;
          afterNodeAccess(e);
          return oldValue;
      }
  }
  ++modCount;
  if (++size > threshold)
      resize();
  afterNodeInsertion(evict);
  return null;
}

2 resize()方法：是HashMap的擴容方法，新的容量是舊的容量的兩倍，需要注意的是，擴容操作同樣需要把 oldTable 的所有鍵值對重新插入 newTable 中，因此這一步是很費時的。

final Node<K,V>[] resize() {
        Node<K,V>[] oldTab = table;
        int oldCap = (oldTab == null) ? 0 : oldTab.length;
        int oldThr = threshold;
        int newCap, newThr = 0;
        if (oldCap > 0) {
            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
        }
        else if (oldThr > 0) // initial capacity was placed in threshold
            newCap = oldThr;
        else {               // zero initial threshold signifies using defaults
            newCap = DEFAULT_INITIAL_CAPACITY;
            newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
        }
        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"})
            Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
        table = newTab;
        if (oldTab != null) {
            for (int j = 0; j < oldCap; ++j) {
                Node<K,V> e;
                if ((e = oldTab[j]) != null) {
                    oldTab[j] = null;
                    if (e.next == null)
                        newTab[e.hash & (newCap - 1)] = e;
                    else if (e instanceof TreeNode)
                        ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
                    else { // preserve order
                        Node<K,V> loHead = null, loTail = null;
                        Node<K,V> hiHead = null, hiTail = null;
                        Node<K,V> next;
                        do {
                            next = e.next;
                            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;
    }

3 get方法

public V get(Object key) {
    Node<K,V> e;
    return (e = getNode(hash(key), key)) == null ? null : e.value;
}

通過key計算雜湊值，呼叫getNode()來獲取對應的value

/**
 * Implements Map.get and related methods
 *
 * @param hash hash for key
 * @param key the key
 * @return the node, or null if none
 */
final Node<K,V> getNode(int hash, Object key) {
    Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
    if ((tab = table) != null && (n = tab.length) > 0 &&
        (first = tab[(n - 1) & hash]) != null) {
　　　　//判斷計算出來的hash值是否在散列表上
 
        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 remove方法：從此對映中刪除指定鍵的對映（如果存在）

public V remove(Object key) {
   Node<K,V> e;
   return (e = removeNode(hash(key), key, null, false, true)) == null ?
       null : e.value;
}
通過key計算雜湊值，呼叫removeNode()來刪除節點

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;
   if ((tab = table) != null && (n = tab.length) > 0 &&
       (p = tab[index = (n - 1) & hash]) != null) {
　　　　//同get，判斷計算出來的hash值是否在散列表上
       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);
           }
       }
　　　//不是在首位，就去紅黑樹或者連結串列中查詢，如果可以找到就記錄下來

       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);
           else if (node == p)
               tab[index] = node.next;
           else
               p.next = node.next;
           ++modCount;
           --size;
           afterNodeRemoval(node);
           return node;
　　　　　　//找到了對應的節點，並且value值對應上了，那麼就可以刪除了，這裡也分三種情況，在連結串列，在紅黑樹，在桶的首位
       }
   }
   return null;
}

參考資料：
jdk1.8原始碼
https://github.com/CyC2018/CS-Notes/blob/master/notes/Java 容器.md#hashmap
大牛部落格
https://blog.csdn.net/qq_33256688/article/details/79938886
HashMap到底是插入連結串列頭部還是尾部

相關推薦

JDK1.8原始碼解讀——HashMap原始碼

從類的Doc文件註釋中，我們可以得出HashMap的一些特性： 　　1 無序 允許為null 非同步 　　2 底層由雜湊表實現 　　3 初始容量和負載因子對HashMap的影響很大 成員變數： /**預設初始值，必須是二的倍數 */ static final int DEFA

Jdk1.8下的HashMap原始碼分析

**目錄結構** 一、面試常見問題 二、基本常量屬性 三、構造方法 四、節點結構        4.1 Node類        4.2.TreeNode 五、put方法

JDK1.7中HashMap死環問題及JDK1.8中對HashMap的優化原始碼詳解

一、JDK1.7中HashMap擴容死鎖問題 我們首先來看一下JDK1.7中put方法的原始碼 我們開啟addEntry方法如下，它會判斷陣列當前容量是否已經超過的閾值，例如假設當前的陣列容量是16，載入因子為0.75，即超過了12，並且剛好要插入的索引處有元素，這時候就需要進行擴容操作，可以看到resi

jdk1.7原始碼之-hashMap原始碼解析

背景： 筆者最近這幾天在思考，為什麼要學習設計模式，學些設計模式無非是提高自己的開發技能，但是通過這一段時間來看，其實我也學習了一些設計模式，但是都是一些demo，沒有具體的例子，學習起來不深刻，所以我感覺我可能要換一條路走，所以我現在想法是看一些原始碼的東西，一方面是因為自己大部分的原始碼其實沒有看過，另

Jdk1.8 之 Integer類原始碼淺析

        Class前的註釋就不翻譯了，對原始碼的設計說明有限。直接上程式碼： 先看一下它的繼承、實現關係： public final class Integer extends Number implements Comparable<Integer>

Jdk1.7下的HashMap原始碼分析

本文主要討論jdk1.7下hashMap的原始碼實現，其中主要是在擴容時容易出現死迴圈的問題，以及put元素的整個過程。 #### 1、陣列結構 ```java 陣列+連結串列 ``` 示例圖如下： **常量屬性** ```java /** * The default initi

Redux 原始碼解讀 —— 從原始碼開始學 Redux

已經快一年沒有碰過 React 全家桶了，最近換了個專案組要用到 React 技術棧，所以最近又複習了一下；撿起舊知識的同時又有了一些新的收穫，在這裡作文以記之。 在閱讀文章之前，最好已經知道如何使用 Redux(不是 React-Redux)。 一、準備環境 為了更好的解讀原始碼，我們可以把

【原始碼】HashMap原始碼剖析

//----------------------------------------------------------------------------------- 轉載需註明出處：http://blog.csdn.net/chdjj //--------------

JDK1.8 中的hashmap和concurrentHashMap

hashmap 在JDK1.6中，HashMap採用Node陣列+連結串列實現，即使用連結串列處理衝突，同一hash值的連結串列都儲存在一個連結串列裡。但是當位於一個桶中的元素較多，即hash值相等的元素較多時，通過key值依次查詢的效率較低。而JDK1.8中

JDK1.8後的HashMap底層結構變化

JDK1.8以後 HashMap的資料結構發生了一些改變,從單純的陣列加連結串列結構變成陣列+連結串列+紅黑樹. 其中Node是HashMap的一個內部類,實現Map.Entry介面,本質是一個KV對映,上圖中每個元素都是一個Node物件.  HashMap顧名思義是通

關於jdk1.8的容器hashmap中的entrySet()函式實現。

因為沒使用過這個函式就直接看hashmap的原始碼，所以我以為entrySet()函式返回的應該是個陣列之類的東西。但是研究了半天也看不出來是這樣實現的，下面貼出程式碼：public Set<Map.Entry<K,V>> entrySet() {

HashMap原始碼解讀(jdk1.8)

本文基於jdk1.8解讀HashMap關鍵程式碼 HashMap是非執行緒安全的，在多執行緒環境下要使用ConcurrentHashMap 儲存結構 HashMap的儲存結構是陣列 + 連結串列 + 紅黑樹，當連結串列的長度大於等於8時，連結轉成紅黑樹 初始化 HashM

HashMap原始碼之建構函式--JDK1.8

建構函式 變數解釋 capacity，表示的是hashmap中桶的數量，初始化容量initCapacity為16，第一次擴容會擴到64，之後每次擴容都是之前容量的2倍，所以容量每次都是2的次冪 loadFactor，負載因子，衡量hashmap一個滿的程度，初始預設為0.75 thresho

Java集合類原始碼解析：HashMap (基於JDK1.8)

目錄 前言 HashMap的資料結構 深入原始碼 兩個引數 成員變數 四個構造方法 插入資料的方法：put() 雜湊函式：hash() 動態擴容：resize() 節點樹化、紅黑樹的拆分 節點樹化

HashMap 原始碼詳細分析(JDK1.8)

本篇文章我們來聊聊大家日常開發中常用的一個集合類 - HashMap。HashMap 最早出現在 JDK 1.2中，底層基於雜湊演算法實現。HashMap 允許 null 鍵和 null 值，在計算哈鍵的雜湊值時，null 鍵雜湊值為 0。HashMap 並不保證鍵值對的順序，這意味著在進行某些操作

java集合之----HashMap原始碼分析（基於JDK1.7與1.8）

一、什麼是HashMap 百度百科這樣解釋： 簡而言之，HashMap儲存的是鍵值對（key和value），通過key對映到value，具有很快的訪問速度。HashMap是非執行緒安全的，也就是說在多執行緒併發環境下會出現問題（死迴圈） 二、內部實現 （1）結構 HashM

JDK1.8原始碼(三)——java.util.HashMap

什麼是雜湊表？ 在討論雜湊表之前，我們先大概瞭解下其他資料結構在新增，查詢等基礎操作執行效能 　　陣列：採用一段連續的儲存單元來儲存資料。對於指定下標的查詢，時間複雜度為O(1)；通過給定值進行查詢，需要遍歷陣列，逐一比對給定關鍵字和陣列元素，時間複雜度為O(n)，當然，對於有序陣列，則可採用二分查詢

jdk1.8 hashmap.treeifyBin原始碼

final void treeifyBin(Node<K,V>[] tab, int hash) { int n, index; Node<K,V> e;//n是陣列長度，e是hash值和陣列長度計算後，得到連結串列的首節

通俗易懂的JDK1.8中HashMap原始碼分析（歡迎探討指正）+ 典型面試題

面試題在最下面 說到HashMap之前，閱讀ArrayList與LinkedList的原始碼後做個總結 ArrayList 底層是陣列，查詢效率高，增刪效率低 LinkedList底層是雙鏈表，查詢效率低，增刪效率高   這裡只是總結看完原始碼後對hashm

JDK1.8集合框架原始碼分析三-------------HashMap

1.HashMap的一些重要成員屬性       1.1) 預設的初始容量 DEFAULT_INITIAL_CAPACITY = 1 << 4，官方建議必須時2的次方數       1.2) 負載因子