HashMap原始碼解析(基於JDK11)
概念
- HashMap是基於雜湊表的Map介面的非同步實現,允許使用null值和null鍵。當即key為null的鍵值對，hash值為0，hashmap儲存的就是0。所以一個hashmap物件只會儲存一個key為null的鍵值對，因為它們的hash值都相同。
- HashMap的key為null時,是在talbe[0]連結串列中查詢key為null的元素，如果找到，則將value重新賦值給這個元素的value，並返回原來的value。 如果上面for迴圈沒找到則將這個元素新增到talbe[0]連結串列的表頭。
- HashMap儲存的是鍵值對，所以很快。但不保證對映的順序。底層是通過連結串列和陣列進行儲存的。
- 由於HashMap不是執行緒安全的，如果想要執行緒安全，可以使用ConcurrentHashMap代替。
以下是Java11中HashMap的put方法底層原始碼:
/**
* Implements Map.put and related methods.
*
* @param hash hash for key
* @param key the key
* @param value the value to put
* @param onlyIfAbsent if true, don't change existing value
* @param evict if false, the table is in creation mode.
* @return previous value, or null if none
*/ jdk1.8在解決雜湊衝突時有了較大的變化，當連結串列長度大於閾值（預設為8）時，將連結串列轉化為紅黑樹，以減少搜尋時間。原本Map.Entry介面的實現類Entry改名為了Node。轉化為紅黑樹時改用另一種實現TreeNode。
Node類
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;
}
}
TreeNode類
static final class TreeNode<K,V> extends LinkedHashMap.Entry<K,V> {
TreeNode<K,V> parent; // red-black tree links
TreeNode<K,V> left;
TreeNode<K,V> right;
TreeNode<K,V> prev; // needed to unlink next upon deletion
boolean red;
TreeNode(int hash, K key, V val, Node<K,V> next) {
super(hash, key, val, next);
}
}
HashMap就是這樣一個Entry（包括Node和TreeNode）陣列，Node物件中包含鍵、值和hash值，next指向下一個Entry，用來處理雜湊衝突。TreeNode物件包含指向父節點、子節點和前一個節點（移除物件時使用）的指標，以及表示紅黑節點的boolean標識。
主要屬性
transient Node<K,V>[] table;//雜湊陣列
transient Set<Map.Entry<K,V>> entrySet; // entry快取Set
transient int size; // 元素個數
transient int modCount; // 修改次數
int threshold; // 閾值，等於容量*載入因子，當實際大小超過閾值則進行擴容
final float loadFactor; // 載入因子，預設值為0.75,可以修改.關於為什麼預設值為0.75,我在另外的部落格裡進行說明吧.
構造方法
/**
* 根據初始化容量和載入因子構建一個空的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).
*/
public HashMap(int initialCapacity) {
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
/**
* 使用預設初始化大小(16)和預設載入因子(0.75).
*/
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);
}
資料存取
public void putAll(Map<? extends K, ? extends V> m) {
putMapEntries(m, true);
}
/**
* Implements Map.putAll and Map constructor
*
* @param m the map
* @param evict false when initially constructing this map, else
* true (relayed to method afterNodeInsertion).
*/
final void putMapEntries(Map<? extends K, ? extends V> m, boolean evict) {
int s = m.size();
if (s > 0) {
if (table == null) { // pre-size
float ft = ((float)s / loadFactor) + 1.0F;
int t = ((ft < (float)MAXIMUM_CAPACITY) ?
(int)ft : MAXIMUM_CAPACITY);
if (t > threshold)
threshold = tableSizeFor(t);
}
else if (s > threshold)
resize();
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); // put核心方法
}
}
}
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
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) // table為空或length為0
n = (tab = resize()).length; // 初始化
if ((p = tab[i = (n - 1) & hash]) == null) // 如果hash所在位置為null，直接put
tab[i] = newNode(hash, key, value, null);
else { // tab[i]有元素，遍歷節點後新增
Node<K,V> e; K k;
// 如果hash、key都相等，直接覆蓋
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);
// 連結串列節點大於閾值8，呼叫treeifyBin方法，當tab.length大於64將連結串列改為紅黑樹
// 如果tab.length < 64或tab為null，則呼叫resize方法重構連結串列.
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
break;
}
// hash、key都相等，此時節點即要更新節點
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
// 當前節點e = p.next不為null，表示連結串列中原本存在相同的key，則返回oldValue
if (e != null) { // existing mapping for key
V oldValue = e.value;
// onlyIfAbsent值為false，引數主要決定存在相同key時是否執行替換
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
++modCount;
if (++size > threshold) // 檢查是否超過閾值
resize();
afterNodeInsertion(evict);
return null; // 原HashMap中不存在相同的key，插入鍵值對後返回null
}
get方法
public V get(Object key) {
Node<K,V> e;
return (e = getNode(hash(key), key)) == null ? null : e.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) {
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;
}
// 遍歷紅黑樹搜尋節點
/**
* Calls find for root node.
*/
final TreeNode<K,V> getTreeNode(int h, Object k) {
return ((parent != null) ? root() : this).find(h, k, null);
}
/**
* Returns root of tree containing this node.
*/
final TreeNode<K,V> root() {
for (TreeNode<K,V> r = this, p;;) {
if ((p = r.parent) == null)
return r;
r = p;
}
}
/**
* Finds the node starting at root p with the given hash and key.
* The kc argument caches comparableClassFor(key) upon first use
* comparing keys.
*/
final TreeNode<K,V> find(int h, Object k, Class<?> kc) {
TreeNode<K,V> p = this;
do {
int ph, dir; K pk;
TreeNode<K,V> pl = p.left, pr = p.right, q;
if (
相關推薦
HashMap原始碼解析——基於jdk11
HashMap原始碼解析——基於jdk11
插入流程
獲取流程
插入流程
首先我們從put方法說起：
public V put(K key, V value) {
return putVal(h
HashMap原始碼解析(基於JDK11)
概念
HashMap是基於雜湊表的Map介面的非同步實現,允許使用null值和null鍵。當即key為null的鍵值對，hash值為0，hashmap儲存的就是0。所以一個hashmap物件只會儲存一個key為null的鍵值對，因為它們的hash值都相同。
HashMap的
HashMap原始碼解析（基於JDK1.7）
一、HashMap簡介
雜湊表（hash table）也叫散列表，是一種非常重要的資料結構，應用場景及其豐富，許多快取技術（比如memcached）的核心其實就是在記憶體中維護一張大的雜湊表，而HashMap的實現原理就是基於此。那麼什麼是雜湊表呢？
在討論
HashMap原始碼解析（基於JDK1.8）
雜湊是一種用於以常數平均時間執行插入、刪除和查詢的技術。HashMap是基於雜湊表的Map介面實現，該實現提供了所有可選的對映操作，並允許使用 空值和空鍵。（HashMap 類大致等同於Hashtable，除了它是不同步的並且允許為空值。）這個類不能保證M
HashMap原始碼解析（JDK8）
前言
這段時間有空，專門填補了下基礎，把常用的ArrayList、LinkedList、HashMap、LinkedHashMap、LruCache原始碼看了一遍，List相對比較簡單就不單獨介紹了，Map準備用兩篇的篇幅，分別介紹HashMap和（LruCache+LinkedHa
Java——HashMap原始碼解析
以下針對JDK 1.8版本中的HashMap進行分析。
概述
雜湊表基於Map介面的實現。此實現提供了所有可選的對映操作，並且允許鍵為null，值也為null。HashMap 除了不支援同步操作以及支援null的鍵值外，其功能大致等同於 Hashtable。
一篇文章徹底讀懂HashMap之HashMap原始碼解析(下)
put函式原始碼解析
//put函式入口,兩個引數：key和value
public V put(K key, V value) {
/*下面分析這個函式，注意前3個引數，後面
2個引數這裡不太重要，因為所有的put
操作後面的2個引數預設值都一樣 */
一篇文章徹底讀懂HashMap之HashMap原始碼解析（上）
就身邊同學的經歷來看，HashMap是求職面試中名副其實的“明星”，基本上每一加公司的面試多多少少都有問到HashMap的底層實現原理、原始碼等相關問題。
在秋招面試準備過程中，博主閱讀過很多關於HashMap原始碼分析的文章，漫長的拼湊式閱讀之後，博主沒有看到過
Java集合框架之三：HashMap原始碼解析 Java集合框架之三：HashMap原始碼解析
Java集合框架之三：HashMap原始碼解析
版權宣告：本文為博主原創文章，轉載請註明出處，歡迎交流學習！
HashMap在我們的工作中應用的非常廣泛，在工作面試中也經常會被問到，對於這樣一個重要的集合
Java8 HashMap原始碼解析
前言
Java7中的HashMap和Java8中的HashMap不太一樣，Java7中的HashMap主要是由陣列+連結串列組成的，而Java8中的
HashMap是由陣列+連結串列+紅黑樹組成的，當連結串列的長度超過8個時，就會轉為紅黑樹，降低查詢時的時間複
hashmap原始碼解析
以jdk1.8為例，HashMap是一個用於儲存Key-Value鍵值對的集合，每一個鍵值是一個Node（jdk1.7叫做Entry）。後臺是用一個Node陣列來存放資料，這個陣列就是HashMap的主幹。
這裡我們主要來分析HashMap的get和put方法。
put
LinkedList原始碼解析 基於Node結構
先來看看LinkedList的定義
public class LinkedList<E>
extends AbstractSequentialList<E>
implements List<E>, Deque&
HashMap 原始碼解析(jdk 1.8)
在程式設計師的日常工作中，面試中常常涉及。對於大部分程式猿來說可能還僅僅停留於會用的一個層面，很少會去摸索它底層是如何實現的，實現的原理是什麼，面對這些的時候都是滿頭霧水。工作中的一次偶然讓作者本人也逐步跨進了原始碼的大門，逐漸發現其中趣味，一點點摸索原始碼創作者的奇思妙想，在不知覺中提升了自
JDK8 HashMap原始碼解析，一篇文章徹底讀懂HashMap
在秋招面試準備中博主找過很多關於HashMap的部落格，但是秋招結束後回過頭來看，感覺沒有一篇全面、通俗易懂的講解HashMap文章（可能是博主沒有找到），所以在秋招結束後，寫下了這篇文章，盡最大的努力把HashMap原始碼講解的通俗易懂，並且儘量涵蓋面試中HashM
JDK8-HashMap原始碼解析(一)
注：HashMap的建構函式較多，就不一一解讀了，這裡以無參建構函式為例
/**
* Constructs an empty <tt>HashMap</tt> with the default initial capa
JDK8-HashMap原始碼解析之put(一)
由上節的擴容函式resize()繼續講解
接下來就看看哪裡使用到了resize(）函式
/**
* Implements Map.put and related methods
*
* @param hash hash for ke
hashMap 原始碼解析
這幾天跳槽 被人問得最多的問題就是基礎方面的知識..當時學習的時候有點囫圇吞棗..現在回頭把這些基本的集合類原始碼都仔細閱讀下
hashMap 用的是最頻繁的.. 所以問得也最多了.
hashMap 的內部結構是一個node陣列.. 元素是node。 node是一個連結串
jdk1.7原始碼之-hashMap原始碼解析
背景：
筆者最近這幾天在思考，為什麼要學習設計模式，學些設計模式無非是提高自己的開發技能，但是通過這一段時間來看，其實我也學習了一些設計模式，但是都是一些demo，沒有具體的例子，學習起來不深刻，所以我感覺我可能要換一條路走，所以我現在想法是看一些原始碼的東西，一方面是因為自己大部分的原始碼其實沒有看過，另
20java hashmap原始碼解析（自己解析）
1類的定義
程式碼
public class HashMap<K,V> extends AbstractMap<K,V>
implements Map<K,V>, Cloneable, Serializable
說明
JDK1.8 HashMap原始碼解析（不分析紅黑樹部分）
一、HashMap資料結構 HashMap由 陣列+連結串列+紅黑樹實現，桶中元素可能為連結串列，也可能為紅黑樹。為了提高綜合（查詢、新增、修改）效率，當桶中元素數量超過TREEIFY_THRESHOLD（預設為8）時，連結串列儲存改為紅黑樹儲存，當桶中元素數量