HashMap不得不知道的那些事兒
一、簡介
主要是根據Hashmap的源碼來近距離了解廬山真面目；node
爲何要寫，由於面試常常問啊，並且99%的程序員都知道也用過；並且它涉及的知識遠遠不止put和get那麼簡單，有必要知曉，也有利於對數據進行靈活的存儲引用；程序員
二、知識鋪墊
涉及知識點：hash算法，單鏈表、雙鏈表、紅黑樹、二叉搜索樹面試
2.1 單鏈表
單鏈表是一種鏈式存取的數據結構，用一組地址任意的存儲單元存放線性表中的數據元素。鏈表中的數據是以結點來表示的，每一個結點的構成：元素(數據元素的映象) + 指針(指示後繼元素存儲位置)，元素就是存儲數據的存儲單元，指針就是鏈接每一個結點的地址數據。算法
單鏈表的實際使用場景並很少，好比只是頻繁對頭/尾結點進行操做，單鏈表最佳數組
2.2 雙鏈表
雙向鏈表也叫雙鏈表，是鏈表的一種，它的每一個數據結點中都有兩個指針，分別指向直接後繼和直接前驅。因此，從雙向鏈表中的任意一個結點開始，均可以很方便地訪問它的前驅結點和後繼結點。通常咱們都構造雙向循環鏈表。bash
雙鏈表的主要優勢是對於任意給的結點，均可以很輕易的獲取其前驅結點或者後繼結點，而主要缺點是每一個結點須要添加額外的next域，所以須要更多的空間開銷，同時結點的插入與刪除操做也將更加耗時，由於須要更多的指針指向操做。數據結構
2.3 二叉搜索樹
二叉排序樹，又稱二叉查找樹，亦稱二叉搜索樹,知足下面性質app
- 若左子樹不空，則左子樹上全部結點的值均小於它的根結點的值；
- 若右子樹不空，則右子樹上全部結點的值均大於它的根結點的值；
- 左、右子樹也分別爲二叉排序樹；
- 沒有鍵值相等的結點。
2.4 紅黑樹
紅黑樹是每一個節點都帶有顏色屬性的二叉查找樹，顏色或紅色或黑色。 在二叉查找樹強制通常要求之外，對於任何有效的紅黑樹咱們增長了以下的額外要求:函數
- 性質1. 節點是紅色或黑色。
- 性質2. 根節點是黑色。
- 性質3.全部葉子都是黑色。（葉子是NUIL節點）
- 性質4. 每一個紅色節點的兩個子節點都是黑色。（從每一個葉子到根的全部路徑上不能有兩個連續的紅色節點）
- 性質5. 從任一節點到其每一個葉子的全部路徑都包含相同數目的黑色節點。
這些約束強制了紅黑樹的關鍵性質: 從根到葉子的最長的可能路徑很少於最短的可能路徑的兩倍長。結果是這個樹大體上是平衡的。由於操做好比插入、刪除和查找某個值的最壞狀況時間都要求與樹的高度成比例，這個在高度上的理論上限容許紅黑樹在最壞狀況下都是高效的，而不一樣於普通的二叉查找樹。源碼分析
性質4致使路徑上不能有兩個連續的紅色節點。最短的可能路徑都是黑色節點，最長的可能路徑有交替的紅色和黑色節點。由於根據性質5全部最長的路徑都有相同數目的黑色節點，這就代表了沒有路徑能多於任何其餘路徑的兩倍長
2.5 Hash算法
希算法並非一個特定的算法而是一類算法的統稱。哈希算法也叫散列算法，通常來講知足這樣的關係：f(data)=key，輸入任意長度的data數據，通過哈希算法處理後輸出一個定長的數據key。同時這個過程是不可逆的，沒法由key逆推出data。
若是是一個data數據集，通過哈希算法處理後獲得key的數據集，而後將keys與原始數據進行一一映射就獲得了一個哈希表。通常來講哈希表M符合M[key]=data這種形式。 哈希表的好處是當原始數據較大時，咱們能夠用哈希算法處理獲得定長的哈希值key，那麼這個key相對原始數據要小得多。咱們就能夠用這個較小的數據集來作索引，達到快速查找的目的。
稍微想一下就能夠發現，既然輸入數據不定長，而輸出的哈希值倒是固定長度的，這意味着哈希值是一個有限集合，而輸入數據則能夠是無窮多個。那麼創建一對一關係明顯是不現實的。因此"碰撞"(不一樣的輸入數據對應了相同的哈希值)是必然會發生的，因此一個成熟的哈希算法會有較好的抗衝突性。同時在實現哈希表的結構時也要考慮到哈希衝突的問題。
三、源碼分析
主要包括數據結構、擴容、刪除、添加、獲取過程
3.1 數據結構
數組+單鏈表+雙鏈表-黑紅樹
3.1.1 數組
transient Node<K,V>[] table;
複製代碼
總體來講採用數組存儲，以hash值和數組大小獲得數組位置
3.1.2 單鏈表
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，當根據hash計算數組中的索引值位置已經有值且不是同一個，則以索引位置節點爲頭節點，後來節點爲尾節點
3.1.3 雙鏈表-紅黑樹
static class LinkedHashMapEntry<K,V> extends HashMap.Node<K,V> {
LinkedHashMapEntry<K,V> before, after; // 在hashMap中並無使用這兩個節點信息
LinkedHashMapEntry(int hash, K key, V value, Node<K,V> next) {
super(hash, key, value, next);
}
}
複製代碼
static final class TreeNode<K,V> extends LinkedHashMap.LinkedHashMapEntry<K,V> {
TreeNode<K,V> parent;
TreeNode<K,V> left;
TreeNode<K,V> right;
TreeNode<K,V> prev;
boolean red;
............ // 省略方法代碼
}
複製代碼
紅黑樹-雙鏈表結構，繼承自LinkedHashMapEntry，LinkedHashMapEntry又繼承了Node節點；紅黑樹節點是單鏈表節點的子子類；含有前/後驅節點，左右孩子節點，父節點，以及顏色信息；前/後驅節點做爲雙鏈表結構，左右孩子節點-父節點-顏色做爲紅黑樹結構
主要方法有：
- root() 查找紅黑樹根節點，經過根節點的父節點爲空，其它節點的父節點不空特性來查找
- moveRootToFront() 把指定節點爲根節點；若是當前hash所對應的索引節點爲指定節點，則不須要任何處理，不然，指定節點爲根節點，放在數組中hash對應索引位置，當前根節點爲指定節點下個節點，指定節點前/後驅節點相互鏈接
- find() 根據搜索樹特性，來進行查找（搜索樹，節點左樹的值 <= 節點的值 < 節點右樹的值）
- getTreeNode() 從根節點，以key值來查找
- tieBreakOrder() 比較物理地址，物理地址小於等於 算做小於，其它算大於
- treeify() 單鏈表結構轉換雙鏈表-紅黑樹結構；首先按照搜索樹，進行插入，每插入一個節點後均進行紅黑樹規則處理，使其成爲一個紅黑樹
- untreeify() 雙鏈表-紅黑樹退化爲單鏈表結構；以雙鏈表先後驅動節點來鏈接爲一個單鏈表
- putTreeVal() 插入一個幾點：根據搜索樹特性插入，進行紅黑樹規則調整，並從新設置調整後的hash對應索引位置的節點值；父節點後驅爲當前加入子節點，子節點後驅爲父節點以前的後驅節點，保證了雙鏈錶鏈接整個紅黑樹
- removeTreeNode() 刪除當前節點
- 在雙鏈表中去除當前節點，並鏈接先後驅動節點
- 若是刪除點擊是根節點，則結束流程；
- 從新計算根節點；並根據根節點的孩子節點狀況判斷是否要退化爲單鏈表結構，則結束流程，知足a,b任意一條即退化：a) 樹結構不超過兩層，b）樹的層深爲3層，根節點的左孩子爲空，或者根節點的左孩子的作孩子爲空
- 若是刪除節點沒有孩子節點，則斷了和父節點索引，返回
- 若是左右孩子存在空節點，則其不空節點替換當前刪除節點，紅黑樹中去掉刪除節點
- 若果左右孩子均不爲空，以右孩子的最左節點替換當前節點，並調換紅黑樹中的位置信息，也就是左右孩子，父孩子信息,顏色；這時，刪除節點無左孩子，則使其右子節點替換當前刪除節點；也就是，先找到大於刪除節點的最小值，互相替換位置信息，而後在使用替換後位置（其無左孩子節點）的右孩子節點替換互換後刪除節點的位置
- 刪除後調整紅黑樹；a) 若是互換位置信息後的刪除節點爲紅色，由於其無左孩子或者有孩子，因此其沒有任何孩子節點，無需調整;b) 若是爲黑色節點，那麼其存在左孩子或者右還在，其爲紅色節點
- split() 擴容後，對當前樹分紅兩個單鏈表：按照節點個數，小於等於6退化爲單鏈表，不然從新樹化；原理：hashmap的大小爲2的n次方，每次擴容擴大2倍；因此以前hash對應同一個索引，如今也就在當前大小最高位存在0或者1的區別；也就是假設以前容器大小爲n，索引爲index，那麼擴容後，index全部的鏈表數據/紅黑樹-雙鏈表數據，所有都會對應到index 、index+n的位置
- rotateLeft() 左旋方法，指定節點爲p，則p的右孩子作p的父節點，p做爲p的右孩子節點的左孩子節點，p的右孩子的左節點做爲p的右節點
- rotateRight() 右旋方法，指定節點爲p，則p的左孩子節點作p的父節點，p做爲p的左孩子的右孩子節點，p的左孩子的右孩子節點做爲p的左節點
- balanceDeletion() 刪除數據後調整；此時刪除的節點是黑色節點；第二個參數爲已替換節點；執行for循環
- 若爲紅色或者根節點，直接染黑，返回;不然按照替換節點是左孩子或者右孩子來處理
- 爲左孩子節點：此時是黑色，右孩子爲空，則替換節點的父節點重置爲替換節點，從新循環
- 爲左孩子節點：右孩子是紅色節點，則右孩子置爲黑色，父節點置爲紅色，進行右旋
- 爲左孩子節點：右孩子爲黑色 a) 右孩子的左右孩子都是黑色節點或者空節點，則父節點重置爲已替換節點，從新循環 b) 右孩子的左孩子爲紅色，則右孩子置爲紅色，右孩子的左孩子置爲灰色，右旋，而後父節點置爲黑色，左旋 c）右孩子的左孩子爲黑色，父節點置爲黑色，左旋
【5.爲右孩子 和左孩子旋轉相反相似】
- balanceInsertion() 插入數據調整，插入節點，for循環處理
- 默認插入顏色爲紅色
- 若爲根節點，染黑結束
- 若父節點爲黑色，或者父節點的父節點爲空，則返回
- 父節點爲紅色，且爲父父節點的左節點 a) 父節點的兄弟節點也爲紅色，父節點，父節點兄弟節點均燃黑色，父父節點燃紅色，以父父節點爲插入節點從新循環 b) 若是父節點兄弟節點爲黑色，插入節點爲父節點的右孩子，則以父節點左旋，調整節點（以前父節點變爲左孩子，併成爲插入節點，以前插入節點變爲父節點）；父節點置爲黑色，父父節點置爲紅色，以父父節點右旋 【5. 父父節點爲右節點，相反相似】
3.2 擴容原理
容器大小爲2的n次方，擴容因子爲m；默認n = 16， m = 0.75：存在3種狀況下會擴容
- 容器內數組未初始化或者大小爲0
- 此時已存儲元素個數大於n * m 會擴容
- 容器個數小於64，某個位置的單鏈表長度大於等於7時，這時不直接轉換爲樹結構，而是進行擴容
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;
}
複製代碼
- 首先計算擴容後容器大小：a) 已經存儲過元素：以前容器大小不爲0，則擴大2倍，threshold也擴大2倍，若是容器大小是 1 << 30 則直接設置爲 1 << 31 -1; b）第一次加入元素：經過構造器已經傳入的了大小，這時還未給數組尺寸定值，直接使用threshold， c) 第一次加入元素：初始化未提供大小，則賦值默認16，threshold 爲16 * 擴容因子
- 檢查threshold是否被重置，也就是1中b的狀況，threshold = 新的容器大小 * 擴容因子
- for 循環從第0個位置（i）開始，根據hash值從新計算位置： a) 索引位置元素爲空，則不處理， b) 索引位置不爲空，其沒有後驅節點，則計算新位置，直接賦值當前值，c) 索引位置不爲空，其存在後驅節點，若後驅節點爲單鏈表結構，則分紅兩個單鏈表，一個放在當前位置，一個放在i, 一個放在i + 原有容器處， d) 索引位置不爲空，其存在後驅節點，若後驅節點爲雙鏈表-紅黑樹，則分紅兩個雙鏈表，並依據其尺寸是否小於等於6來進行處理，> 6 從新樹化，不然退化爲單鏈表
爲何能夠分紅兩個鏈表呢
緣由很簡單，容器爲2的倍數增長，則在同一個索引位置的節點 hash值在容器大小二進制數據1的位置以及左邊不一樣，也就是擴容後，獲得新的索引，只有和舊容器大小二進制僅有1的位置有0和1的區別，也就是舊的索引位置 或者舊的索引位置+舊的容器大小
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);
}
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) {
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
public HashMap() {
this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}
複製代碼
從構造函數，能夠看出，構造時，進行了延時處理，也就是未進行數據存儲內存申請，只是計算了存儲因子，或者使用threshold暫時記錄了數組大小；tableSizeFor方法，經過把cap的第一爲1的後面所有置爲1，而後加1，達到大小爲cap的最小的2的n次方數
3.3 插入
直接上源碼和分析
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)
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;
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;
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}
複製代碼
- 是否爲第一次加入新元素，初始化容器（也是調用擴容方法）
- 若是加入key的hash值對應索引位置無數據，直接插入
- 若是key的hash值對應索引位置有數據，且節點爲紅黑樹結構，則查看2節中關於紅黑樹插入的內容
- 若是key的hash值對應索引位置有數據，且節點爲單鏈表結構，則進行for循環處理： a）鏈表存在數據，其key與當前物理地址相同或者key的equal比較相同，則重置數據返回， b) 如果已經到鏈表尾部，則新增節點，加入到尾部；若是加入後數據大小>= 7 則進行樹化，查看2節中樹化方法
- 尺寸+1，判斷是否達到閾值，達到則進行擴容
3.4 獲取元素
獲取元素比較簡單，以key的hash值找到索引位置，而後根據位置的節點特色來查找元素
- 節點爲空，則無此元素
- 節點爲紅黑樹節點，查看2章節中getTreeNode方法分析
- 節點爲單鏈表，從頭至尾進行比對，若是比對成功，則退出，不然返回null；比對依據：hash值相同且物理地址相同或者equal方法相同
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;
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;
}
複製代碼
3.5 刪除方法
直接上分析，分析以下
public V remove(Object key) {
Node<K,V> e;
return (e = removeNode(hash(key), key, null, false, true)) == null ?
null : e.value;
}
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) {
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;
}
}
return null;
}
複製代碼
- 若是未加入過元素，則不處理
- 若是刪除key的hash對應索引位置元素爲空，則不處理
- 若是索引節點的key和要刪除的key比對相同，則刪除節點即爲索引節點
- 索引節點後驅爲空，則不須要處理
- 索引節點後驅不爲空，則在鏈表或者紅黑樹中查找此節點
- 紅黑樹結構使用removeTreeNode刪除元素，單鏈表，刪除元素後，其前驅的後繼爲其後繼；並大小減1
3.6 清空方法
全部索引位置置空，也即斷開單鏈表或者雙鏈表-紅黑樹的根節點，進而刪除全部元素
public void clear() {
Node<K,V>[] tab;
modCount++;
if ((tab = table) != null && size > 0) {
size = 0;
for (int i = 0; i < tab.length; ++i)
tab[i] = null;
}
}
複製代碼
4 原理總結
- 數據結構採用 數組+單鏈表+雙鏈表-紅黑樹結構；hash值對應索引位置爲鏈表根節點
- hash尋址機制，衝突採用單鏈表或者雙鏈表-紅黑樹結構解決
- 2倍擴容機制，擴容後索引節點對應鏈表進行分爲兩個鏈表再進行處理，有點巧妙
- 擴容時機有三個：a）因爲使用延時申請存儲內存，因此在第一次加入元素時，b）大小小於64且須要樹化時，c) 元素個數超過閾值時
- 樹化依據：鏈表數據個數>= 7且容器大小小於64，場景：插入數據，擴容時從新樹化；退化依據： 鏈表數據 <= 6，場景：刪除數據，擴容時
- 比較大小，按照hash值相等且 物理地址相等或者equal方法相等
技術變化都很快，但基礎技術、理論知識永遠都是那些；做者但願在餘後的生活中，對經常使用技術點進行基礎知識分享；若是你以爲文章寫的不錯，請給與關注和點贊；若是文章存在錯誤，也請多多指教！
相關文章
- 1. VScode 不得不說的那些事兒
- 2. 關於代碼中寫註釋，你不得不知道的那些事兒
- 3. MySQL中關於JSON你不得不知道的那些事！
- 4. 那些程序員不得不知道的事！
- 5. http你不得不知道的那些事（二）--CSRF
- 6. 80%的人不知道,聊天氣泡框的那些事兒。
- 7. 程序員！多的是你不知道的那些事兒......
- 8. Webpack那些你不知道的事
- 9. Java 10你不知道的那些事
- 10. SpringApplication你不知道的那些事！
- 更多相關文章...
- • C# 不安全代碼 - C#教程
- • 僞造目標不可達的ICMP數據包 - TCP/IP教程
- • SpringBoot中properties文件不能自動提示解決方法
- • IntelliJ IDEA中SpringBoot properties文件不能自動提示問題解決
相關標籤/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
最新文章
- 1. Window下Ribbit MQ安裝
- 2. Linux下Redis安裝及集羣搭建
- 3. shiny搭建網站填坑戰略
- 4. Mysql8.0.22安裝與配置詳細教程
- 5. Hadoop安裝及配置
- 6. Python爬蟲初學筆記
- 7. 部署LVS-Keepalived高可用集羣
- 8. keepalived+mysql高可用集羣
- 9. jenkins 公鑰配置
- 10. HA實用詳解
歡迎關注本站公眾號,獲取更多信息
