文章目錄
- 簡介
- 內部結構
- 原始碼分析
- 1. 構造方法
- 2. put方法
- 3. get方法
- 4. resize方法
簡介
- HashMap 主要用來存放鍵值對，它基于哈希表的 Map 介面實作，是常用的 Java 集合之一，
- JDK1.8 之前 HashMap 由 陣列+鏈表 組成的，陣列是 HashMap 的主體，鏈表則是主要為了解決哈希沖突而存在的（“拉鏈法”解決沖突），
- JDK1.8 之后 HashMap 的組成多了紅黑樹，在滿足下面兩個條件之后，會執行鏈表轉紅黑樹操作，以此來加快搜索速度，
- HashMap是執行緒不安全的，
- HashMap保存資料的時候通過計算key的hash值來去決定存盤的位置，
public class HashMap<K,V> extends AbstractMap<K,V>
implements Map<K,V>, Cloneable, Serializable
- 實作了 Cloneable 介面，即克隆
- AbstractMap 提供Map實作介面
- 實作java.io.Serializable介面，這意味著HashMap支持序列化，能通過序列化去傳輸，
在閱讀原始碼的時候一直有個問題很困惑就是HashMap已經繼承了AbstractMap而AbstractMap類實作了Map介面，那為什么HashMap還要在實作Map介面呢？同樣在ArrayList中LinkedList中都是這種結構，
據 java 集合框架的創始人Josh Bloch描述，這樣的寫法是一個失誤，在java集合框架中，類似這樣的寫法很多，最開始寫java集合框架的時候，他認為這樣寫，在某些地方可能是有價值的，直到他意識到錯了，顯然的，JDK的維護者，后來不認為這個小小的失誤值得去修改，所以就這樣存在下來了，
內部結構
-
JDK 1.8 之前 HashMap 底層是 陣列和鏈表 結合在一起使用也就是 鏈表散列
-
HashMap 通過 key 的 hashCode 經過 擾動函式處理過后得到 hash 值，然后通過 （n - 1）& hash 判斷當前元素存放的位置 （這里的 n 指陣列的長度），如果當前位置存在元素的話，就判斷該元素與要存入的元素的 hash 值以及 key 是否相同，如果相同的話，直接覆寫，不相同就通過拉鏈法解決沖突
-
所謂的擾動函式是指 HashMap 的 hash 方法，使用 hash 方法也就是擾動函式是為了防止一些實作比較差的 hashcode() 方法 ，使用擾動函式之后可以減少碰撞
擾動函式
-
JDK 1.8 的 hash 方法 相比于 JDK 1.7 hash 方法更加簡化，但是原理不變，JDK 1.7 的 hash 方法的性能會稍差一點點，因為畢竟擾動了 4 次
-
在 HashMap 存放元素時候有這樣一段代碼來處理哈希值，這是 java 8 的散列值擾動函式，用于優化散列效果：
JDK 1.8 的 HashMap 的 hash 原始碼
static final int hash(Object key) {
int h;
// ^ ：按位異或
// >>>:無符號右移，忽略符號位，空位都以0補齊
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
** JDK1.7 的 HashMap 的 hash 原始碼**
static int hash(int h) {
// This function ensures that hashCodes that differ only by
// constant multiples at each bit position have a bounded
// number of collisions (approximately 8 at default load factor).
h ^= (h >>> 20) ^ (h >>> 12);
return h ^ (h >>> 7) ^ (h >>> 4);
}
為什么使用擾動函式
-
理論上來說字串的 hashCode是一個 int 型別值，那可以直接作為陣列下標了，且不會出現碰撞，但是這個hashCode 的取值范圍是[-2147483648, 2147483647]，有將近 40 億的長度，誰也不能把陣列初始化的這么大，記憶體也是放不下的，
-
我們默認初始化的 Map 大小是 16 個長度 DEFAULT_INITIAL_CAPACITY = 1 << 4，所以獲取的 Hash 值并不能直接作為下標使用，需要與陣列長度進行取模運算得到一個下標值
-
hashMap 原始碼這里不只是直接獲取哈希值，還進行了一次擾動計算，(h = key.hashCode()) ^ (h >>> 16)，把哈希值右移 16 位，也就正好是自己長度的一半，之后與原哈希值做異或運算，這樣就混合了原哈希值中的高位和低位，增大
了隨機性
Demo ：
public class test {
public static void main(String[] args) {
for (int i = 0; i < 10; i++) {
int hash = hash(new Random().nextInt());
System.out.println(hash);
}
}
static int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
}
- 使用擾動函式就是為了增加隨機性，讓資料元素更加均衡的散列，減少碰撞，
- 使資料分配均勻，也就是散列的效果更好，減少了 hash 的碰撞，讓資料存放和獲取的效率更佳，
拉鏈法
所謂 “拉鏈法” 就是：將鏈表和陣列相結合，也就是說創建一個鏈表陣列，陣列中每一格就是一個鏈表，若遇到哈希沖突，則將沖突的值加到鏈表中即可，
-
在JDK1.8 之后，解決 hash 沖突就有了較大的變化
-
當鏈表長度閥值 （默認為8）時，會先呼叫 **treeifyBin()**方法，這個方法會根據 HashMap 陣列來決定是否轉換為紅黑樹，只有當陣列長度大于或等于 64 情況，才會執行裝歡紅黑樹操作，以減少搜索時間，否則就執行擴容機制
public class HashMap<K,V> extends AbstractMap<K,V>
implements Map<K,V>, Cloneable, Serializable {
private static final long serialVersionUID = 362498820763181265L;
/**
* 默認初始值16
*/
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
/**
* 最大容量
*/
static final int MAXIMUM_CAPACITY = 1 << 30;
/**
* 擴容因子
*/
static final float DEFAULT_LOAD_FACTOR = 0.75f;
/**
* 當桶(bucket)上的結點數大于這個值時會轉成紅黑樹
*/
static final int TREEIFY_THRESHOLD = 8;
/**
* 當桶(bucket)上的結點數小于這個值時樹轉鏈表
*/
static final int UNTREEIFY_THRESHOLD = 6;
/**
* // 桶中結構轉化為紅黑樹對應的table的最小大小
*/
static final int MIN_TREEIFY_CAPACITY = 64;
/**
* 存盤元素的陣列
*/
transient Node<K,V>[] table;
/**
* 存放具體元素的集
*/
transient Set<Map.Entry<K,V>> entrySet;
/**
* 存放元素的個數
*/
transient int size;
/**
* 每次擴容和更改map結構的計數器
*/
transient int modCount;
/**
* 臨界值 當實際大小(容量*填充因子)超過臨界值時，會進行擴容
*/
int threshold;
/**
* 加載因子
*/
final float loadFactor;
loadFactor 加載因子
-
給定的默認容量為 16，負載因子為 0.75，Map 在使用程序中不斷的往里面存放資料，當數量達到了 16 * 0.75 = 12 就需要將當前 16 的容量進行擴容，而擴容這個程序涉及到 rehash、復制資料等操作，所以非常消耗性能，
-
在 HashMap 中，負載因子決定了資料量多少了以后進行擴容，這里要提到上面做的 HashMap 例子，我們準備了 7 個元素，但是最后還有 3 個位置空余，2 個位置存放了 2 個元素， 所以可能即使你資料比陣列容量大時也是不一定能正正好好的把陣列占滿的，而是在某些小標位置出現了大量的碰撞，只能在同一個位置用鏈表存放，那么這樣就失去了 Map 陣列的性能，所以，要選擇一個合理的大小下進行擴容，默認值 0.75 就是說當閥值容量占了3/4 時趕緊擴容，減少 Hash 碰撞，
threshold
- threshold = capacity * loadFactor，當 Size>=threshold的時候，那么就要考慮對陣列的擴增了，也就是說，這個的意思就是 衡量陣列是否需要擴增的一個標準，
Node 節點類原始碼:
/**
* Node是單向鏈表，它實作了Map.Entry介面
*/
static class Node<K,V> implements Map.Entry<K,V> {
final int hash; //哈希值，存放元素到 hashMap 中用來與其他元素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; }
//重寫hashcode方法
public final int hashCode() {
return Objects.hashCode(key) ^ Objects.hashCode(value);
}
public final V setValue(V newValue) {
V oldValue = value;
value = newValue;
return oldValue;
}
//重寫equals() 方法
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 節點類原始碼:
static final class TreeNode<K,V> extends LinkedHashMap.Entry<K,V> {
TreeNode<K,V> parent; // 父
TreeNode<K,V> left; // 左
TreeNode<K,V> right; // 右
TreeNode<K,V> prev;
boolean red; // 判斷顏色
TreeNode(int hash, K key, V val, Node<K,V> next) {
super(hash, key, val, next);
}
// 回傳根節點
final TreeNode<K,V> root() {
for (TreeNode<K,V> r = this, p;;) {
if ((p = r.parent) == null)
return r;
r = p;
}
原始碼分析
1. 構造方法
4種構造：
//默認構造
public HashMap() {
this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}
//指定容量大小
public HashMap(int initialCapacity) {
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
//包含另一個“Map”
public HashMap(Map<? extends K, ? extends V> m) {
this.loadFactor = DEFAULT_LOAD_FACTOR;
putMapEntries(m, false);
}
//指定“容量大小”和“加載因子”
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);
}
putMapEntries 方法：
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);
}
//table 已經初始化，并且m元素個數大于閥值，進行擴容處理
else if (s > threshold)
resize();
// 將所有元素添加到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);
}
}
}
2. put方法
HashMap 只提供了 put 用于添加元素，putVal方法 只是給put方法呼叫到一個方法，并沒有提供給用戶使用
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
putVal 方法添加元素分析：
- 如果定位到陣列位置沒有元素就直接插入
- 如果定位到的陣列位置有元素就要和插入的 key 比較 ，如果 key 相同就直接覆寫，如果key不同 ，就判斷 p 是否是一個樹節點，如果是就呼叫 e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value)將元素添加進入 ，如果不是就遍歷鏈表插入 （插入鏈表尾部）
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
Node<K,V>[] tab; Node<K,V> p; int n, i;
// table未初始化或者長度0 就進行擴容
if ((tab = table) == null || (n = tab.length) == 0)
//擴容操作
n = (tab = resize()).length;
//根據哈希值計算下標，確定元素存放到那個桶，桶為空，新生成節點放到桶中 （這個節點是放在陣列中），
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
//否則同種存在元素
else {
Node<K,V> e; K k;
//比較桶中第一個元素 的hash 是否相等，也是key相等 ，key存在 直接覆寫value
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
//將元素賦值給 e 用e來標識
e = p;
//判斷該列是否為紅黑樹 hash值不相等，即key不想等；為紅黑樹結點
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方法，這個方法根據 Hashmap 陣列決定是否裝換為紅黑樹，只有當陣列大于等于 64 情況下才會轉換成紅黑樹，以減少時間搜索，否則就是對陣列
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
//跳出回圈
break;
}
//判斷鏈表中結點的key值與插入的元素的key值是否相等
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
// 相等，跳出回圈
break;
p = e;
}
}
// 表示在桶中找到key值、hash值與插入元素相等的結點
if (e != null) { // existing mapping for key
//記錄e的value
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
//新值替換舊值
e.value = value;
//訪問后回呼
afterNodeAccess(e);
return oldValue;
}
}
++modCount;
//超過最大容量就擴容
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}
總結 ：
-
當呼叫 put 方法的時候，使用擾動函式 (h = k.hashCode()) ^ (h >>> 16) 得到最后hash值，
-
根據 key.hash 計算 桶陣列的索引 tab[i = (n - 1) & hash]) 得到key的位置
2.1 如果該位置沒有資料，用該資料新生成一個節點保存新資料，回傳null
2.2 如果該位置有資料是紅黑樹，那么執行相應的 插入/ 更新操作2.3 如果該位置有資料是鏈表,回圈,如果鏈表下一個元素為null ,采用尾插法新增節點保存新資料 ,如果大于等于 8 就進行擴容（ treeifyBin(tab, hash); 方法決定 擴容陣列 還是轉成紅黑樹），判斷鏈表中 key 與插入元素key 是 否相等，如果該鏈表已經有這個節點了，那么找到該節點并更新新資料，回傳老資料，
為什么使用尾插法？
關于HashMap鏈表插入問題,java8之前之前是頭插法，
- 頭插法:就是說新來的值會取代原有的值，原有的值就順推到鏈表中去
- 多執行緒中會出現死回圈的情況
hashmap的擴容機制
- 創建一個新的Node空陣列，長度是原陣列的2倍，
- 遍歷原Node陣列，把所有的Node重新Hash到新陣列，
為什么重新計算Hash
Node<K,V>[] tab; Node<K,V> p; int n, i;
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
計算Node陣列下標的時候用到了（ length -1）原來長度（Length）是8你位運算出來的值是2 ，新的長度是16你位運算出來的值明顯不一樣了,之前的所有資料的hash值得到的位置都需要變化，
單鏈表的頭插入方式，同一位置上新元素總會被放在鏈表的頭部位置 在舊陣列中同一條Node鏈上的元素，通過重新計算索引位置后，有可能被放到了新陣列的不同位置上，
一旦幾個執行緒都調整完成，就可能出現環形鏈表，如果這個時候去取值，就出現了無限回圈的狀態…
- 使用頭插會改變鏈表的上的順序，但是如果使用尾插，在擴容時會保持鏈表元素原本的順序，就不會出現鏈表成環的問題了
3. get方法
public V get(Object key) {
Node<K,V> e;
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;
//判斷是否為null
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. resize方法
- 進行擴容，會伴隨著一次重新 hash 分配，并且會遍歷 hash 表中所有的元素，是非常耗時的，在撰寫程式中，要盡量避免 resize，
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) {
// 原陣列長度大于最大容量(1073741824) 則將threshold設為Integer.MAX_VALUE=2147483647
threshold = Integer.MAX_VALUE;
return oldTab;
}
//沒有超過最大值，就擴容為原來的2倍
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);
}
// 計算新的resize上限
if (newThr == 0) {
// 如果新 的容量 ==0
// loadFactor 哈希加載因子 默認0.75,可在初始化時傳入,16*0.75=12 可以放12個鍵值對
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;
// 如果原來的table有資料，則將資料復制到新的table中
if (oldTab != null) {
// 把每個bucket都移動到新的buckets中
for (int j = 0; j < oldCap; ++j) {
Node<K,V> e;
// 獲取陣列的第j個元素
if ((e = oldTab[j]) != null) {
oldTab[j] = null; //將舊的hash桶陣列在j結點處設定為空，方便gc
// 如果鏈表只有一個，則進行直接賦值
if (e.next == null)
newTab[e.hash & (newCap - 1)] = e;
//是否是紅黑樹擴容
else if (e instanceof TreeNode)
//如果是紅黑樹節點 split 方法擴容
((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
else { // preserve order
// 鏈表優化重hash的代碼塊
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;
}
擴容時如果Node為TreeNode（紅黑樹的節點）原始碼如下 ： 作者原文鏈接
//紅黑樹轉回鏈表的閾值
static final int UNTREEIFY_THRESHOLD = 6;
/** 這個方法在HashMap進行擴容時會呼叫到: ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
* @param map 代表要擴容的HashMap
* @param tab 代表新創建的陣列，用來存放舊陣列遷移的資料
* @param index 代表舊陣列的索引
* @param bit 代表舊陣列的長度，需要配合使用來做按位與運算
*/
final void split(HashMap<K,V> map, Node<K,V>[] tab, int index, int bit) {
//做個賦值，因為這里是((TreeNode<K,V>)e)這個物件呼叫split()方法，所以this就是指(TreeNode<K,V>)e物件，所以才能型別對應賦值
TreeNode<K,V> b = this;
//設定低位首節點和低位尾節點
TreeNode<K,V> loHead = null, loTail = null;
//設定高位首節點和高位尾節點
TreeNode<K,V> hiHead = null, hiTail = null;
//定義兩個變數lc和hc，初始值為0，后面比較要用，他們的大小決定了紅黑樹是否要轉回鏈表
int lc = 0, hc = 0;
//這個for回圈就是對從e節點開始對整個紅黑樹做遍歷，如果對這回圈賦值略有不懂，可以參考這篇模仿的博客@1
for (TreeNode<K,V> e = b, next; e != null; e = next) {
//取e的下一節點賦值給next遍歷
next = (TreeNode<K,V>)e.next;
//取好e的下一節點后，把它賦值為空，方便GC回收
e.next = null;
//以下的操作就是做個按位與運算，按照結果拉出兩條鏈表，具體的操作可以參考這篇博客@2
if ((e.hash & bit) == 0) {
if ((e.prev = loTail) == null)
loHead = e;
else
loTail.next = e;
loTail = e;
//做個計數，看下拉出低位鏈表下會有幾個元素
++lc;
}
else {
if ((e.prev = hiTail) == null)
hiHead = e;
else
hiTail.next = e;
hiTail = e;
//做個計數，看下拉出高位鏈表下會有幾個元素
++hc;
}
}
//如果低位鏈表首節點不為null，說明有這個鏈表存在
if (loHead != null) {
//如果鏈表下的元素小于等于6
if (lc <= UNTREEIFY_THRESHOLD)
//那就從紅黑樹轉鏈表了，低位鏈表，遷移到新陣列中下標不變，還是等于原陣列到下標
tab[index] = loHead.untreeify(map);
else {
//低位鏈表，遷移到新陣列中下標不變，還是等于原陣列到下標，把低位鏈表整個拉到這個下標下，做個賦值
tab[index] = loHead;
//如果高位首節點不為空，說明原來的紅黑樹已經被拆分成兩個鏈表了
if (hiHead != null)
//那么就需要構建新的紅黑樹了
loHead.treeify(tab);
}
}
//如果高位鏈表首節點不為null，說明有這個鏈表存在
if (hiHead != null) {
//如果鏈表下的元素小于等于6
if (hc <= UNTREEIFY_THRESHOLD)
//那就從紅黑樹轉鏈表了，高位鏈表，遷移到新陣列中的下標=【舊陣列+舊陣列長度】
tab[index + bit] = hiHead.untreeify(map);
else {
//高位鏈表，遷移到新陣列中的下標=【舊陣列+舊陣列長度】，把高位鏈表整個拉到這個新下標下，做賦值
tab[index + bit] = hiHead;
如果低位首節點不為空，說明原來的紅黑樹已經被拆分成兩個鏈表了
if (loHead != null)
//那么就需要構建新的紅黑樹了
hiHead.treeify(tab);
}
}
}
個人博客地址：http://blog.yanxiaolong.cn/
轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/271318.html
標籤：java
上一篇：幾道簡單的藍橋真題（2）
下一篇：JDK原始碼JVM類加載機制