2. 程式人生 > >HashMap原始碼解析(jdk1.8)

HashMap原始碼解析(jdk1.8)

阿新 • • 發佈：2019-01-22

寫在篇頭

其實這是在我寫完下邊所有方法解析後寫的。每次看原始碼，有些時候都不知道每一步的意義在哪裡，缺少了自己的思考，直接看會枯燥，甚至不知所云。今天突然想換種說明方式。為什麼會有HashMap這種結構，為了實現什麼目的？為什麼用這種結構？比其他結構的好在哪裡？
例項：我知道了一個人的姓名，我想找他所有資訊。怎麼儲存，怎麼查詢。
簡單的鍵值對結構被設計出來Node<”姓名”,”資訊”>；
如果很多這種Node<”姓名”,”資訊”>都存放在一個集合裡，用什麼儲存結構好呢？
試一下順序儲存結構，陣列，ArrayList都是這種。放在數組裡，看一下如何獲取元素。由於不知道index（陣列中的第幾個元素），無法直接get（index），通過地址查詢元素，只能遍歷比較。時間複雜度為O（n）。由於這種Key不能重複，每次增刪改都要先遍歷，遍歷一遍（O（n）），增刪要移動一遍（O（n）），增加時，可能還要重新建立陣列。
試一下鏈式儲存結構，連結串列，看一下如何獲取元素。遍歷是不可少的，時間複雜度為O（n），增刪改只需改一下前邊元素的指向就可以了。
好了，自己都想法試完了，是不是看著簡單，但操作起來耗費時間，一個O（n）的時間複雜度應該不能讓人滿意。看大神怎麼建立的。
HashMap構造是由陣列加連結串列組成。也就是順序結構與鏈式結構的組合。每個元素為

Node(int hash, K key, V value, Node<K,V> next)

對key的hashCode與陣列長度（桶的數量）-1 進行位運算。存到對應桶的的連結串列上，結果一樣的話，再對key進行equals比較，一樣的，覆蓋，不一樣的增加。
優點
- 直接使Key的Hashcode值經過處理變為了陣列的（index），在順序儲存結構查詢時間複雜度變為了O（1）+該桶連結串列長度，當然，如果Hash值演算法好的話（極限，一個桶只對應一個），這個查詢的時間複雜度無線接近於O（1）。
- 在增刪改不超出門限值時，即不用重新構造陣列時，時間複雜同樣為O（1）+該桶的連結串列長度，且之後增加了紅黑樹，比連結串列的速度更快。
- 任何可變容量的資料結構，順序結構一定要開闢新空間複製(排除初始化分配記憶體特別大的情況)，連結串列一定要增刪指向。關於hashMap擴容，在擴容時，一個桶上的連結串列上的直接通過hash判段可以分成兩個桶上的連結串列，這種複製方式，依賴於一開始元素分配給桶時的運算，也可以說是呼應。

概述

父類關係java.lang.Object
java.util.AbstractMap<K,V>
java.util.HashMap<K,V>

實現介面
Serializable
Cloneable
Map<K,V>

非線性安全，底層陣列，連結串列儲存結構，允許使用 null 值和 null 鍵。

解決問題

1.為什麼預設初始容量為16，或者建議為2的冪。
2.put,remove，get方法原理。
3.java8的優化在什麼地方（紅黑樹）。
上述問題會在說明基本結構後，開始解答。

基本概念

對於hashMap中的每個鍵值對物件，在內部將其封裝為Entry<Key
 
,Value>;
HashMap內部維護一個Entry[] table陣列，EntryTable的長度又被稱為HashMap的容量（capacity）;
Entry[] table陣列中的每一個元素都是一個連結串列（也可以為null），這樣的每個元素為桶（bucket）。
所有的Entry<Key,Value>的數目被稱為HashMap的大小(size);
根據鍵值對中key的hashcode的值得某些運算，使結果一致的儲存在同一個桶；

成員變數

// 初始化容量，必須是2的冪(預設為16)
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
// 最大容量 2的30次方
static final int MAXIMUM_CAPACITY = 1 << 30;
// 預設載入因子
static final float DEFAULT_LOAD_FACTOR = 0.75f;
// 一般情況下，元素的hash值如果相同，那麼就依次存在一個連結串列裡，
// 如果連結串列裡的元素數目超過TREEIFY_THRESHOLD，就要把連結串列轉化成一棵紅黑樹
static final int TREEIFY_THRESHOLD = 8;
// 與TREEIFY_THRESHOLD相對應，如果紅黑樹裡的元素數目小於UNTREEIFY_THRESHOLD，紅黑樹就退化成一個連結串列
static final int UNTREEIFY_THRESHOLD = 6;
// 這個成員變數的定義是: 如果
// 1. 一個桶裡的元素個數大於TREEIFY_THRESHOLD
// 2. HashTable的桶的個數大於MIN_TREEIFY_CAPACITY
// 那麼，就對桶裡的元素進行"樹化"，否則僅僅resize整個HashTable
static final int MIN_TREEIFY_CAPACITY = 64;
// hash表，長度總是2的冪次
transient Node<K,V>[] table;
// key-value的集合
transient Set<Map.Entry<K,V>> entrySet;
// map裡的key-value數目
transient int size;
// 結構更改次數
transient int modCount;
// resize的門限值，超過值，就要resize了，值為(capacity * load factor)
int threshold;
final float loadFactor;

構造方法

有三個構造方法：分別是不傳參，傳容量，傳容量和載入因子。
構造方法中傳容量這一點，非常關鍵，如果你提前可以估算HashMap的大致大小，有可能之後新增元素時可以省去複製陣列，拆分連結串列，連結串列轉數這一系列複雜操作，而且，無論你傳的容量如何最終，陣列的大小（桶的數量）一定是2的整數次冪。你傳9到16間的任何數，他的桶數量就是16個。大於等於你傳參的整數次冪，如果想要完美，直接估算出你的集合需要多少個桶傳參吧，需要211個元素，100/0.75 = 133，new HashMap（138），或者直接new HashMap（256）。桶的數量是256，這個傳容量，傳的是桶的數目。不是元素的數目。

// 構造一個帶指定初始容量和載入因子的 空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);
        this.loadFactor = loadFactor;
        this.threshold = tableSizeFor(initialCapacity);
    }
// 構造一個帶指定初始容量和預設載入因子 (0.75) 的空 HashMap
public HashMap(int initialCapacity) {
        this(initialCapacity, DEFAULT_LOAD_FACTOR);
    }
//  構造一個具有預設初始容量 (16) 和預設載入因子 (0.75) 的空 HashMap。
public HashMap() {
        this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
    }
//  構造一個對映關係與指定 Map 相同的新 HashMap。
public HashMap(Map<? extends K, ? extends V> m) {
        this.loadFactor = DEFAULT_LOAD_FACTOR;
        putMapEntries(m, false);
    }
// 計算出比cap大的最小的2的整數次冪
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;
    }

問題

問題1 為什麼預設初始容量為16，或者建議為2的冪。

這個容量實際上是桶的數目。
對於HashMap中的Key對映到HahMap中對應的位置，會用到Hash函式
index = Hash(key);
這個Hash函式是如何實現的
對key的HashCode值與HashMao的長度length-1進行位運算。
index = HashCode(Key)&(length-1)
當length為2的冪時，length-1的2進位制全為1
例
2的4次冪-1 15 1111
2的5次冪-1 31 11111
這樣位運算的結果只和Key的Hashcode值的最後幾位有關。
這樣的HashCode本身分佈均勻，Hash演算法結果均勻，

問題2 什麼是閾值和載入因子

先描述一下根據Key的hashCode值, 如何得到Value。
HashMap是由陣列+連結串列組成，在獲取元素時，根據key的Hash運算.找出Entry[] table 中的陣列位置(桶)，找到桶裡的連結串列，找到最終value。
找到桶的時間複雜度為O(1)
在桶中直到物件節點的時間複雜度為O（n）
這個時候是不是桶中的連結串列越短，查詢速率越快。那最好的方法就是增加桶的數量（即Entry [] table 陣列的長度）
但是我們的HashMap初始的時候不能就直接建立很大陣列長度，且根據HashMap的元素增加，還要動態的增加桶的數量。
策略：if
HashMap.size > HashMap的容量（Entry [] table 的大小）*載入因子
HashMap的Entry[] table 的容量擴充為當前的一倍，然後將以前桶中的Entry

內部類Node

// 每個Node都包含了指向下個Node的next
static class Node<K,V> implements Map.Entry<K,V> {
        // hash值
        final int hash;
        // key
        final K key;
        // value
        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;
        }
        // 如果key與vlaue分別相等，即認為相等
        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;
        }
    }

成員方法

V put(K key, V value) 新增元素方法

// 新增Key-Value鍵值對
public V put(K key, V value) {
        return putVal(hash(key), key, value, false, true);
    }
/**
 * 新增Key-Value鍵值對
 * @param hash hash for key
 * @param key the key
 * @param value the value to put
 * @param onlyIfAbsent 如果為true，不替換已存在的值
 * @param evict 如果為false 桶處於創造中
 * @return previous value或者null
 */
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值與陣列長度-1進行位運算
        // p就是桶的連結串列的頭結點或者樹根
        // 如果為空，直接放進桶裡
        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);
        // 連結串列裡有元素，判斷是鏈還是樹
        else {
            Node<K,V> e; K k;
            // 就是連結串列頭
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                e = p;
            // 是樹
            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);
                        // 判斷是否轉換為紅黑樹
                        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) { // existing mapping for key
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                afterNodeAccess(e);
                return oldValue;
            }
        }
        ++modCount;
        // 如果新增成功，需要判斷一下size是超出門限值
        if (++size > threshold)
            resize();
        afterNodeInsertion(evict);
        return null;
    }
// 擴容 要保持元素順序不變，或者以2的整數次冪移動
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) {
            // 舊的HashMap已經超出最大容量，沒法擴容
            if (oldCap >= MAXIMUM_CAPACITY) {
                threshold = Integer.MAX_VALUE;
                return oldTab;
            }
            // capacity擴大為兩倍 threshold擴大為兩倍
            else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                     oldCap >= DEFAULT_INITIAL_CAPACITY)
                newThr = oldThr << 1; 
        }
        // 舊的HashMap的capacity為0
        else if (oldThr > 0) 
            newCap = oldThr;
        // 舊的capcity為0，舊的threshold也為0，用預設的構造
        else {              
            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
        threshold = newThr;
        @SuppressWarnings({"rawtypes","unchecked"})
            Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
        table = newTab;
        // 判斷舊的HashMap是否為空
        if (oldTab != null) {
            for (int j = 0; j < oldCap; ++j) {
                // e是桶中連結串列的的首元素
                Node<K,V> e;
                if ((e = oldTab[j]) != null) {
                    // 原先的置空了
                    oldTab[j] = null;
                    // 桶中連結串列就一個節點 e.hash是hash值，與新的陣列長度做位運算，形成新的首元素
                    if (e.next == null)
                        newTab[e.hash & (newCap - 1)] = e;
                    // 桶裡的元素構成了樹，即必然不止一個元素 對紅黑樹進行操作。
                    else if (e instanceof TreeNode)
                        ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
                    // 桶裡的節點構成了連結串列，記得要保證元素順序
                   /**
                    * 因為擴容時桶的個數變為之前的兩倍，（key的hash值與陣列長度 與運算，判斷結果是否為0）
                    * 直接分出去屬於hi（不為0）的部分即可，
                    * 舉例說明一下即可，對於capacity為16的HashMap
                    * hash值為7和23的元素是放在一個桶裡的，假設index為0和1
                    * 擴容後，長度變成了32，那麼此時7和23就不在一個桶裡了
                    * 7在編號為7的桶裡，index為0
                    * 23在編號為23的桶裡，index也為0
                    * loHead = 7[0], loTail = 7[0]
                    * hiHead = 23[0], hiTail = 23[0]
                    * 判斷是Hi還是Low，拿hash值與原先的capacity(16)10000與一下即可
                    * 原來的hash後五位為0XXXX，位運算結果為00000，即為lo
                    * 後五位為1xxxx，運算結果為10000，即為hi，把元素Node放到新桶裡
                    */
                    else {
                        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;
    }

V remove(Object key) 刪除元素

// 如果存在，則從該對映移除指定鍵的對映。
public V remove(Object key) {
        Node<K,V> e;
        return (e = removeNode(hash(key), key, null, false, true)) == null ?
            null : e.value;
    }

    /**
     * 方法概要說明：想要移除元素，在連結串列層面，分為三種情況
     * 紅黑樹，參照紅黑樹結構，不詳細說明
     * 桶中的首元素，即連結串列頭元素，直接是頭元素的next變成頭元素即可
     * 桶中的中間元素，讓元素前的元素的next的指向變成元素後的一個元素即可
     * 此方法前邊在確定需要移除的元素屬於上述那種情況，找到後分別處理
     * @param hash hash for key
     * @param key the key
     * @param value the value to match if matchValue, else ignored
     * @param matchValue  如果為true 僅僅刪除值等於
     * @param movable 如果為FALSE 在刪除時不移動其他節點 為true移動
     * @return the node, or null if none
     */
    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) {
            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) {
                // 對應桶有數，判斷樹還是連結串列 先找出來node<>
                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;
                // 如果是連結串列中間元素 p為元素前的一個元素
                else
                    p.next = node.next;
                ++modCount;
                --size;
                afterNodeRemoval(node);
                return node;
            }
        }
        return null;
    }

V get(Object key) 獲取元素

// 找到key對應的value
public V get(Object key) {
       Node<K,V> e;
       return (e = getNode(hash(key), key)) == null ? null : e.value;
   }
// 找到key對應的value
final Node<K,V> getNode(int hash, Object key) {
      // first為桶首元素
      Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
      // 陣列不為空且長度大於0（有桶），且傳進來的key對應的桶（連結串列）部位空
      if ((tab = table) != null && (n = tab.length) > 0 &&
          (first = tab[(n - 1) & hash]) != null) {
          // 和桶首比較
          if (first.hash == hash && 
              ((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);
              // 連結串列 依次判斷key是否與傳進來的key完全相等
              do {
                  if (e.hash == hash &&
                      ((k = e.key) == key || (key != null && key.equals(k))))
                      return e;
              } while ((e = e.next) != null);
          }
      }
      return null;
  }

相關推薦

HashMap原始碼解析jdk1.8：初始化resize,新增put,獲取get

原始碼解析有參考以下部落格： http://www.cnblogs.com/jzb-blog/p/6637823.html HashMap：   以k-v鍵值對儲存格式的容器，key,value都可以為空，key不重複，非執行緒安全(執行緒安全請使用Concur

HashMap原始碼解析(jdk1.8)

寫在篇頭 其實這是在我寫完下邊所有方法解析後寫的。每次看原始碼，有些時候都不知道每一步的意義在哪裡，缺少了自己的思考，直接看會枯燥，甚至不知所云。今天突然想換種說明方式。為什麼會有HashMap這種結構，為了實現什麼目的？為什麼用這種結構？比其他結構的好在哪裡

原始碼解析JDK1.8-HashMap連結串列成環的問題解決方案

前言 　　上篇文章詳解介紹了HashMap在JDK1.7版本中連結串列成環的原因，今天介紹下JDK1.8針對HashMap執行緒安全問題的解決方案。 jdk1.8 擴容原始碼解析 public class HashMap<K,V> extends AbstractMap<K,V>&n

HashMap原始碼分析(JDK1.8)

一、HashMap簡介  基於雜湊表的 Map 介面的實現。此實現提供所有可選的對映操作，並允許key和value為null(但是隻能有一個key為null，且key不能重複，value可以重複)。(除了非同步和允許使用 null 之外，HashMap 類與 Hashtab

HashMap原始碼解讀(jdk1.8)

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

HashMap 原始碼分析(JDK1.8)

0 概述 HashMap是Java程式設計師使用頻率最高的容器之一，主要原因它的查詢效率比較高，本文基於JDK1.8，深入探討HashMap的結構實現和功能原理。 1 HashMap底層資料結構 首先看下HashMap底層資料結構，本質上就是一個數組+連結

Java執行緒池實現原理與原始碼解析(jdk1.8)

為什麼需要執行緒池？ 執行緒池能夠對執行緒進行統一分配，調優和監控： - 降低資源消耗（執行緒無限制地建立，然後使用完畢後銷燬） - 提高響應速度（無須建立執行緒） - 提高執行緒的可管理性 Java是如何實現和管理執行緒池的? 從JDK 5開始，把

HashMap原始碼解析(java1.8.0)

1.1 背景知識 1.1.1 紅黑樹 　　二叉查詢樹可能因為多次插入新節點導致失去平衡，使得查詢效率低，查詢的複雜度甚至可能會出現線性的，為了解決因為新節點的插入而導致查詢樹不平衡，此時就出現了紅黑樹。 紅黑樹它一種特殊的二叉查詢樹。紅黑樹的每個節點上都有儲存位表示節點的顏色，可以是紅(Red)或黑(Bl

JDK1.8 HashMap原始碼解析（不分析紅黑樹部分）

一、HashMap資料結構        HashMap由 陣列+連結串列+紅黑樹實現，桶中元素可能為連結串列，也可能為紅黑樹。為了提高綜合（查詢、新增、修改）效率，當桶中元素數量超過TREEIFY_THRESHOLD（預設為8）時，連結串列儲存改為紅黑樹儲存，當桶中元素數量

jdk1.8原始碼解析（1）：HashMap原始碼解析

jdk1.8 HashMap資料結構 　　　　　　　　　　　　　　圖1-HashMap類圖　　　　　　　　　　　　　　　　　　　　圖2-TreeNode類圖　　　　 由圖1-HashMap類圖可知HashMap底層資料結構是由一個Node<K,V>的陣列構成。具體Node<

Jdk1.8集合框架之HashMap原始碼解析（詳細解析紅黑樹）

HashMap特點 不同步，支援null的鍵和值，put或get操作通常是常數時間。 Map介面的實現。 去掉了Hashtable的contains(Object value)方法，保留containsKey和containsValue方法。 使用

HashMap原始碼解析（基於JDK1.8）

雜湊是一種用於以常數平均時間執行插入、刪除和查詢的技術。HashMap是基於雜湊表的Map介面實現，該實現提供了所有可選的對映操作，並允許使用 空值和空鍵。（HashMap 類大致等同於Hashtable，除了它是不同步的並且允許為空值。）這個類不能保證M

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

概要 HashMap 最早出現在 JDK 1.2 中，底層基於雜湊演算法實現。HashMap 允許 null 鍵和 null 值，在計算哈鍵的雜湊值時，null 鍵雜湊值為 0。HashMap 並不保證鍵值對的順序，這意味著在進行某些操作後，鍵值對的順序可能會發生變化。另外，需要注意的是，HashMap 是

超詳細的HashMap解析(jdk1.8)

有關 過程 註解 rem tcl 性能 log 詳細 內容 目錄 一、預備知識 時間復雜度 基本數據結構 基本位運算 二、HashMap實現原理 結構 速度 三、源碼分析 基本常量 基本成員變量 構造方法 put方法 remove 四、日常使用註意事項 五、總結

HashMap 原始碼解析(jdk 1.8)

　　 在程式設計師的日常工作中，面試中常常涉及。對於大部分程式猿來說可能還僅僅停留於會用的一個層面，很少會去摸索它底層是如何實現的，實現的原理是什麼，面對這些的時候都是滿頭霧水。工作中的一次偶然讓作者本人也逐步跨進了原始碼的大門，逐漸發現其中趣味，一點點摸索原始碼創作者的奇思妙想，在不知覺中提升了自

HashMap原始碼分析-jdk1.6和jdk1.8的區別

在java集合中，HashMap是用來存放一組鍵值對的數，也就是key-value形式的資料，而在jdk1.6和jdk1.8的實現有所不同。 JDK1.6的原始碼實現： 首先來看一下HashMap的類的定義： HashMap繼承了AbstractHashMap，實現

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

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

HashMap原始碼解析、ConcurrentHashMap、ConcurrentSkipListMap 初步熟悉 （JDK1.7之一）

    兜兜轉轉開發java有些時間，可是每次都是用到採取學習，用過又回到原點，反反覆覆，究其緣由還是沒有合理的整理總結，只是個不斷重複搬磚、運磚的中高階工種，沒有不可替代的核心競爭力。    why？因為你30min——1h能完成的東西，不熟悉的人多花點時間也是可以完成的，

HashMap原始碼解析（基於JDK1.7）

一、HashMap簡介 雜湊表（hash table）也叫散列表，是一種非常重要的資料結構，應用場景及其豐富，許多快取技術（比如memcached）的核心其實就是在記憶體中維護一張大的雜湊表，而HashMap的實現原理就是基於此。那麼什麼是雜湊表呢？ 在討論

HashMap原始碼解析、jdk7和8之後的區別、相關問題分析（多執行緒擴容帶來的死迴圈）

# 一、概覽 ```java HashMap map = new HashMap(); ``` 這個語句執行起來，在 jdk1.8 之前，會建立一個長度是 16 的 `Entry[]` 陣列，叫 `table`，用來儲存鍵值對。 在 jdk 1.8 後，不在這裡建立陣列了，而是在第一次 `pu