03.Java數據結構問題

時間 2020-01-24

標籤 03.java java 數據結構問題欄目 Java 简体版

原文原文鏈接

目錄介紹

3.0.0.1 在arrayList中System.arraycopy()和Arrays.copyOf()方法區別聯繫？System.arraycopy()和Arrays.copyOf()代碼說明？
3.0.0.2 SparseArray基本介紹，相比HashMap爲何性能會好？
3.0.0.3 Arrays和Collections 對於sort的不一樣實現原理？說一說它們的區別……
3.0.0.4 Java集合框架中有哪些類？都有什麼特色？Java集合的快速失敗機制「fail-fast」？
3.0.0.5 ArrayList，Vector和LinkList的區別，底層分別是怎麼實現的，存儲空間是如何擴容的？什麼是加載因子？
3.0.0.6 如何理解ArrayList的擴容消耗？Arrays.asList方法後的List能夠擴容嗎？ArrayList如何序列化？
3.0.0.7 如何理解list集合讀寫機制和讀寫效率？什麼是CopyOnWriteArrayList，它與ArrayList有何不一樣？
3.0.1.0 HashSet和TreeSet的區別？是如何保證惟一值的，底層怎麼作到的？
3.0.1.5 HashMap和Hashtable的區別？HashMap在put、get元素的過程？體現了什麼數據結構？
3.0.1.6 如何保證HashMap線程安全？底層怎麼實現的？HashMap是有序的嗎？如何實現有序？
3.0.1.7 HashMap存儲兩個對象的hashcode相同會發生什麼？若是兩個鍵的hashcode相同，你如何獲取值對象？
3.0.1.8 HashMap爲何不直接使用hashCode()處理後的哈希值直接做爲table的下標？
3.0.1.9 爲何HashMap中String、Integer這樣的包裝類適合做爲K？爲啥不用其餘做key值？
3.0.2.0 HashMap是如何擴容的？如何理解HashMap的大小超過了負載因子定義的容量？從新調整HashMap大小存在什麼問題嗎？

好消息

博客筆記大彙總【15年10月到至今】，包括Java基礎及深刻知識點，Android技術博客，Python學習筆記等等，還包括平時開發中遇到的bug彙總，固然也在工做之餘收集了大量的面試題，長期更新維護而且修正，持續完善……開源的文件是markdown格式的！同時也開源了生活博客，從12年起，積累共計500篇[近100萬字]，將會陸續發表到網上，轉載請註明出處，謝謝！
連接地址：https://github.com/yangchong211/YCBlogs
若是以爲好，能夠star一下，謝謝！固然也歡迎提出建議，萬事起於忽微，量變引發質變！全部博客將陸續開源到GitHub！

3.0.0.1 在arrayList中System.arraycopy()和Arrays.copyOf()方法區別聯繫？System.arraycopy()和Arrays.copyOf()代碼說明？

System.arraycopy()和Arrays.copyOf()方法區別？

好比下面<font color="red">add(int index, E element)</font>方法就很巧妙的用到了<font color="red">arraycopy()方法</font>讓數組本身複製本身實現讓index開始以後的全部成員後移一個位置:

/**
 * 在此列表中的指定位置插入指定的元素。 
 * 先調用 rangeCheckForAdd 對index進行界限檢查；而後調用 ensureCapacityInternal 方法保證capacity足夠大；
 * 再將從index開始以後的全部成員後移一個位置；將element插入index位置；最後size加1。
 */
public void add(int index, E element) {
    rangeCheckForAdd(index);
    ensureCapacityInternal(size + 1); 
    //arraycopy()方法實現數組本身複製本身
    //elementData:源數組;index:源數組中的起始位置;elementData：目標數組；index + 1：目標數組中的起始位置； size - index：要複製的數組元素的數量；
    System.arraycopy(elementData, index, elementData, index + 1, size - index);
    elementData[index] = element;
    size++;
}

如toArray()方法中用到了copyOf()方法

/**
 *以正確的順序（從第一個到最後一個元素）返回一個包含此列表中全部元素的數組。 
 *返回的數組將是「安全的」，由於該列表不保留對它的引用。 （換句話說，這個方法必須分配一個新的數組）。
 *所以，調用者能夠自由地修改返回的數組。 此方法充當基於陣列和基於集合的API之間的橋樑。
 */
public Object[] toArray() {
//elementData：要複製的數組；size：要複製的長度
    return Arrays.copyOf(elementData, size);
}

二者聯繫與區別
- 看了上面的二者源代碼能夠發現copyOf()內部調用了System.arraycopy()方法
- 技術博客大總結
- 區別：
  - 1.arraycopy()須要目標數組，將原數組拷貝到你本身定義的數組裏，並且能夠選擇拷貝的起點和長度以及放入新數組中的位置
  - 2.copyOf()是系統自動在內部新建一個數組，並返回該數組。

System.arraycopy()和Arrays.copyOf()代碼說明？php

使用System.arraycopy()方法java

public static void main(String[] args) {
    // TODO Auto-generated method stub
    int[] a = new int[10];
    a[0] = 0;
    a[1] = 1;
    a[2] = 2;
    a[3] = 3;
    System.arraycopy(a, 2, a, 3, 3);
    a[2]=99;
    for (int i = 0; i < a.length; i++) {
        System.out.println(a[i]);
    }
}

//結果：
//0 1 99 2 3 0 0 0 0 0

使用Arrays.copyOf()方法。技術博客大總結

public static void main(String[] args) {
    int[] a = new int[3];
    a[0] = 0;
    a[1] = 1;
    a[2] = 2;
    int[] b = Arrays.copyOf(a, 10);
    System.out.println("b.length"+b.length);
    //結果：
    //10
}

得出結論
- arraycopy() 須要目標數組，將原數組拷貝到你本身定義的數組裏或者原數組，並且能夠選擇拷貝的起點和長度以及放入新數組中的位置 copyOf() 是系統自動在內部新建一個數組，並返回該數組。

3.0.0.2 SparseArray基本介紹，相比HashMap爲何性能會好？

位於android.util，Android 中的數據結構，針對移動端作了優化，在數據量比較少的狀況下，性能會好過 HashMap，相似於 HashMap，key:int ,value:object 。
1.key 和 value 採用數組進行存儲。存儲 key 的數組是 int 類型，不須要進行裝箱操做。提供了速度。
2.採用二分查找法，在插入進行了排序，因此兩個數組是按照從小到大進行排序的。
3.在查找的時候，進行二分查找，數據量少的狀況下，速度比較快。

3.0.0.3 Arrays和Collections 對於sort的不一樣實現原理？說一說它們的區別……

一、Arrays.sort()
- 該算法是一個通過調優的快速排序，此算法在不少數據集上提供N*log(N)的性能，這致使其餘快速排序會下降二次型性能。
二、Collections.sort()
- 該算法是一個通過修改的合併排序算法（其中，若是低子列表中的最高元素效益高子列表中的最低元素，則忽略合併）。此算法可提供保證的N*log(N)的性能，此實現將指定列表轉儲到一個數組中，而後再對數組進行排序，在重置數組中相應位置處每一個元素的列表上進行迭代。
它們的區別
- 技術博客大總結

3.0.0.4 Java集合框架中有哪些類？都有什麼特色？Java集合的快速失敗機制「fail-fast」？

可將Java集合框架大體可分爲Set、List、Queue 和Map四種體系
- Set：表明無序、不可重複的集合，常見的類如HashSet、TreeSet
- List：表明有序、可重複的集合，常見的類如動態數組ArrayList、雙向鏈表LinkedList、可變數組Vector
- Map：表明具備映射關係的集合，常見的類如HashMap、LinkedHashMap、TreeMap
- Queue：表明一種隊列集合
Java集合的快速失敗機制「fail-fast」
- 技術博客大總結
- java集合的一種錯誤檢測機制，當多個線程對集合進行結構上的改變的操做時，有可能會產生 fail-fast 機制。
  - 例如：假設存在兩個線程（線程一、線程2），線程1經過Iterator在遍歷集合A中的元素，在某個時候線程2修改了集合A的結構（是結構上面的修改，而不是簡單的修改集合元素的內容），那麼這個時候程序就會拋出 ConcurrentModificationException 異常，從而產生fail-fast機制。
- 緣由：
  - 迭代器在遍歷時直接訪問集合中的內容，而且在遍歷過程當中使用一個 modCount 變量。集合在被遍歷期間若是內容發生變化，就會改變modCount的值。每當迭代器使用hashNext()/next()遍歷下一個元素以前，都會檢測modCount變量是否爲expectedmodCount值，是的話就返回遍歷；不然拋出異常，終止遍歷。
- 解決辦法：
  - 1.在遍歷過程當中，全部涉及到改變modCount值得地方所有加上synchronized。
  - 2.使用CopyOnWriteArrayList來替換ArrayList

3.0.0.5 ArrayList，Vector和LinkList的區別，底層分別是怎麼實現的？存儲空間是如何擴容的？什麼是加載因子？

ArrayList
- ArrayList的底層結構是數組，可用索引實現快速查找；是動態數組，相比於數組容量可實現動態增加。
- ArrayList非線程安全，建議在單線程中才使用ArrayList，而在多線程中能夠選擇Vector或者CopyOnWriteArrayList；默認初始容量爲10，每次擴容爲原來的1.5倍
Vector
- 和ArrayList幾乎是同樣的，Vector使用了synchronized關鍵字，是線程安全的，比ArrayList開銷更大，訪問更慢；默認初始容量爲10，默認每次擴容爲原來的2倍，可經過capacityIncrement屬性設置
LinkList
- LinkedList底層結構是鏈表，增刪速度快；是一個雙向循環鏈表，也能夠被看成堆棧、隊列或雙端隊列

3.0.0.6 如何理解ArrayList的擴容消耗？Arrays.asList方法後的List能夠擴容嗎？ArrayList如何序列化？

如何理解ArrayList的擴容消耗

因爲ArrayList使用elementData = Arrays.copyOf(elementData, newCapacity);進行擴容，而每次都會從新建立一個newLength長度的數組，因此擴容的空間複雜度爲O(n),時間複雜度爲O(n)

public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) {
T[] copy = ((Object)newType == (Object)Object[].class)
    ? (T[]) new Object[newLength]
    : (T[]) Array.newInstance(newType.getComponentType(), newLength);
System.arraycopy(original, 0, copy, 0,
                 Math.min(original.length, newLength));
return copy;
}

Arrays.asList方法後的List能夠擴容嗎？
- 不能，asList返回的List爲只讀的。其緣由爲：asList方法返回的ArrayList是Arrays的一個內部類，而且沒有實現add，remove等操做
List怎麼實現排序？
- 實現排序，可使用自定義排序：list.sort(new Comparator(){...})
- 或者使用Collections進行快速排序：Collections.sort(list)
ArrayList如何序列化？android
- ArrayList 基於數組實現，而且具備動態擴容特性，所以保存元素的數組不必定都會被使用，那麼就不必所有進行序列化。
- 技術博客大總結
- 保存元素的數組 elementData 使用 transient 修飾，該關鍵字聲明數組默認不會被序列化。
```
transient Object[] elementData; // non-private to simplify nested class access
```
- ArrayList 實現了 writeObject() 和 readObject() 來控制只序列化數組中有元素填充那部份內容。
```
private void readObject(java.io.ObjectInputStream s)
throws java.io.IOException, ClassNotFoundException {
elementData = EMPTY_ELEMENTDATA;
s.defaultReadObject();
s.readInt(); // ignored
if (size > 0) {
    ensureCapacityInternal(size);
    Object[] a = elementData;
    for (int i=0; i<size; i++) {
        a[i] = s.readObject();
    }
}
}
```
private void writeObject(java.io.ObjectOutputStream s)
throws java.io.IOException{
int expectedModCount = modCount;
s.defaultWriteObject();
s.writeInt(size);
for (int i=0; i<size; i++) {
s.writeObject(elementData[i]);
}
if (modCount != expectedModCount) {
throw new ConcurrentModificationException();
}
}git
```
- 序列化時須要使用 ObjectOutputStream 的 writeObject() 將對象轉換爲字節流並輸出。而 writeObject() 方法在傳入的對象存在 writeObject() 的時候會去反射調用該對象的 writeObject() 來實現序列化。反序列化使用的是 ObjectInputStream 的 readObject() 方法，原理相似。
```
ArrayList list = new ArrayList();
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(file));
oos.writeObject(list);github

3.0.0.7 如何理解list集合讀寫機制和讀寫效率？什麼是CopyOnWriteArrayList，它與ArrayList有何不一樣？

讀寫機制
- ArrayList在執行插入元素是超過當前數組預約義的最大值時，數組須要擴容，擴容過程須要調用底層System.arraycopy()方法進行大量的數組複製操做；在刪除元素時並不會減小數組的容量（若是須要縮小數組容量，能夠調用trimToSize()方法）；在查找元素時要遍歷數組，對於非null的元素採起equals的方式尋找。
- LinkedList在插入元素時，須建立一個新的Entry對象，並更新相應元素的先後元素的引用；在查找元素時，需遍歷鏈表；在刪除元素時，要遍歷鏈表，找到要刪除的元素，而後從鏈表上將此元素刪除便可。
- Vector與ArrayList僅在插入元素時容量擴充機制不一致。對於Vector，默認建立一個大小爲10的Object數組，並將capacityIncrement設置爲0；當插入元素數組大小不夠時，若是capacityIncrement大於0，則將Object數組的大小擴大爲現有size+capacityIncrement；若是capacityIncrement<=0,則將Object數組的大小擴大爲現有大小的2倍。
讀寫效率
- ArrayList對元素的增長和刪除都會引發數組的內存分配空間動態發生變化。所以，對其進行插入和刪除速度較慢，但檢索速度很快。
- LinkedList因爲基於鏈表方式存放數據，增長和刪除元素的速度較快，可是檢索速度較慢。
什麼是CopyOnWriteArrayList，它與ArrayList有何不一樣？
- CopyOnWriteArrayList是ArrayList的一個線程安全的變體，其中全部可變操做（add、set等等）都是經過對底層數組進行一次新的複製來實現的。相比較於ArrayList它的寫操做要慢一些，由於它須要實例的快照。
- CopyOnWriteArrayList中寫操做須要大面積複製數組，因此性能確定不好，可是讀操做由於操做的對象和寫操做不是同一個對象，讀之間也不須要加鎖，讀和寫之間的同步處理只是在寫完後經過一個簡單的"="將引用指向新的數組對象上來，這個幾乎不須要時間，這樣讀操做就很快很安全，適合在多線程裏使用，絕對不會發生ConcurrentModificationException ，所以CopyOnWriteArrayList適合使用在讀操做遠遠大於寫操做的場景裏，好比緩存。
- 技術博客大總結

3.0.1.0 HashSet和TreeSet的區別？是如何保證惟一值的，底層怎麼作到的？

HashSet
- 不能保證元素的排列順序；使用Hash算法來存儲集合中的元素，有良好的存取和查找性能；經過equal()判斷兩個元素是否相等，並兩個元素的hashCode()返回值也相等
TreeSet
- 是SortedSet接口的實現類，根據元素實際值的大小進行排序；採用紅黑樹的數據結構來存儲集合元素；支持兩種排序方法：天然排序（默認狀況）和定製排序。前者經過實現Comparable接口中的compareTo()比較兩個元素之間大小關係，而後按升序排列；後者經過實現Comparator接口中的compare()比較兩個元素之間大小關係，實現定製排列

3.0.1.5 HashMap和Hashtable的區別？HashMap在put、get元素的過程？體現了什麼數據結構？

HashMap
- 基於AbstractMap類，實現了Map、Cloneable（能被克隆）、Serializable（支持序列化）接口；非線程安全；容許存在一個爲null的key和任意個爲null的value；採用鏈表散列的數據結構，即數組和鏈表的結合；初始容量爲16，填充因子默認爲0.75，擴容時是當前容量翻倍，即2capacity
Hashtable
- 基於Map接口和Dictionary類；線程安全，開銷比HashMap大，若是多線程訪問一個Map對象，使用Hashtable更好；不容許使用null做爲key和value；底層基於哈希表結構；初始容量爲11，填充因子默認爲0.75，擴容時是容量翻倍+1，即2capacity+1
- HashTable裏使用的是synchronized關鍵字，這實際上是對對象加鎖，鎖住的都是對象總體，當Hashtable的大小增長到必定的時候，性能會急劇降低，由於迭代時須要被鎖定很長的時間。
HashMap在put、get元素的過程
- 向Hashmap中put元素時，首先判斷key是否爲空，爲空則直接調用putForNullKey()，不爲空則計算key的hash值獲得該元素在數組中的下標值；若是數組在該位置處沒有元素，就直接保存；若是有，還要比較是否存在相同的key，存在的話就覆蓋原來key的value，不然將該元素保存在鏈頭，先保存的在鏈尾。
- 從Hashmap中get元素時，計算key的hash值找到在數組中的對應的下標值，返回該key對應的value便可，若是有衝突就遍歷該位置鏈表尋找key相同的元素並返回對應的value
體現了什麼數據結構
- HashMap採用鏈表散列的數據結構，即數組和鏈表的結合，在Java8後又結合了紅黑樹，當鏈表元素超過8個將鏈表轉換爲紅黑樹
- 技術博客大總結

3.0.1.6 如何保證HashMap線程安全？底層怎麼實現的？HashMap是有序的嗎？如何實現有序？

使用ConcurrentHashMap可保證線程安全
- ConcurrentHashMap是線程安全的HashMap，它採起鎖分段技術，將數據分紅一段一段的存儲，而後給每一段數據配一把鎖，當一個線程佔用鎖訪問其中一個段數據的時候，其餘段的數據也能被其餘線程訪問。在JDK1.8中對ConcurrentHashmap作了兩個改進：
  - 取消segments字段，直接採用transient volatile HashEntry<K,V>[] table保存數據，將數組元素做爲鎖，對每一行數據進行加鎖，可減小併發衝突的機率
  - 數據結構由「數組＋單向鏈表」變爲「數組＋單向鏈表＋紅黑樹」，使得查詢的時間複雜度能夠下降到O(logN)，改進必定的性能。
- 通俗一點解釋：ConcurrentHashMap引入了分割(Segment)，能夠理解爲把一個大的Map拆分紅N個小的HashTable，在put方法中，會根據hash(paramK.hashCode())來決定具體存放進哪一個Segment，若是查看Segment的put操做，咱們會發現內部使用的同步機制是基於lock操做的，這樣就能夠對Map的一部分（Segment）進行上鎖，這樣影響的只是將要放入同一個Segment的元素的put操做，保證同步的時候，鎖住的不是整個Map（HashTable就是這麼作的），相對於HashTable提升了多線程環境下的性能，所以HashTable已經被淘汰了。技術博客大總結
使用LinkedHashMap可實現有序
- HashMap是無序的，而LinkedHashMap是有序的HashMap，默認爲插入順序，還能夠是訪問順序，基本原理是其內部經過Entry維護了一個雙向鏈表，負責維護Map的迭代順序

3.0.1.7 HashMap存儲兩個對象的hashcode相同會發生什麼？若是兩個鍵的hashcode相同，你如何獲取值對象？

HashMap存儲兩個對象的hashcode相同會發生什麼？
- 錯誤回答：由於hashcode相同，因此兩個對象是相等的，HashMap將會拋出異常，或者不會存儲它們。
- 正確回答：兩個對象就算hashcode相同，可是它們可能並不相等。若是不明白，能夠先看看個人這篇博客：Hash和HashCode深刻理解。回答「由於hashcode相同，因此它們的bucket位置相同，‘碰撞’會發生。由於HashMap使用鏈表存儲對象，這個Entry(包含有鍵值對的Map.Entry對象)會存儲在鏈表中。
HashMap1.7和1.8的區別
- 在JDK1.6，JDK1.7中，HashMap採用數組+鏈表實現，即便用鏈表處理衝突，同一hash值的鏈表都存儲在一個鏈表裏。可是當位於一個鏈表中的元素較多，即hash值相等的元素較多時，經過key值依次查找的效率較低。
- JDK1.8中，HashMap採用位數組+鏈表+紅黑樹實現，當鏈表長度超過閾值（8）時，將鏈表轉換爲紅黑樹，這樣大大減小了查找時間。
若是兩個鍵的hashcode相同，你如何獲取值對象？
- 當調用get()方法，HashMap會使用鍵對象的hashcode找到bucket位置，而後獲取值對象。固然若是有兩個值對象儲存在同一個bucket，將會遍歷鏈表直到找到值對象。
- 在沒有值對象去比較，如何肯定肯定找到值對象的？由於HashMap在鏈表中存儲的是鍵值對，找到bucket位置以後，會調用keys.equals()方法去找到鏈表中正確的節點，最終找到要找的值對象。
- 技術博客大總結

3.0.1.8 HashMap爲何不直接使用hashCode()處理後的哈希值直接做爲table的下標？

不直接使用hashCode()處理後的哈希值
- hashCode()方法返回的是int整數類型，其範圍爲-(2^31)~(2^31-1)，約有40億個映射空間，而HashMap的容量範圍是在16（初始化默認值）~2 ^ 30，HashMap一般狀況下是取不到最大值的，而且設備上也難以提供這麼多的存儲空間，從而致使經過hashCode()計算出的哈希值可能不在數組大小範圍內，進而沒法匹配存儲位置；
HashMap是使用了哪些方法來有效解決哈希衝突的
- 1.使用鏈地址法（使用散列表）來連接擁有相同hash值的數據；
- 2.使用2次擾動函數（hash函數）來下降哈希衝突的機率，使得數據分佈更平均；
- 3.引入紅黑樹進一步下降遍歷的時間複雜度，使得遍歷更快；
如何解決匹配存儲位置問題
- HashMap本身實現了本身的hash()方法，經過兩次擾動使得它本身的哈希值高低位自行進行異或運算，下降哈希碰撞機率也使得數據分佈更平均；
- 在保證數組長度爲2的冪次方的時候，使用hash()運算以後的值與運算（&）（數組長度 - 1）來獲取數組下標的方式進行存儲，這樣一來是比取餘操做更加有效率，二來也是由於只有當數組長度爲2的冪次方時，h&(length-1)纔等價於h%length，三來解決了「哈希值與數組大小範圍不匹配」的問題；
爲何數組長度要保證爲2的冪次方呢？
- 只有當數組長度爲2的冪次方時，h&(length-1)纔等價於h%length，即實現了key的定位，2的冪次方也能夠減小衝突次數，提升HashMap的查詢效率；
- 技術博客大總結
- 若是 length 爲 2 的次冪則 length-1 轉化爲二進制一定是 11111……的形式，在於 h 的二進制與操做效率會很是的快，並且空間不浪費；若是 length 不是 2 的次冪，好比 length 爲 15，則 length - 1 爲 14，對應的二進制爲 1110，在於 h 與操做，最後一位都爲 0 ，而 0001，0011，0101，1001，1011，0111，1101 這幾個位置永遠都不能存放元素了，空間浪費至關大，更糟的是這種狀況中，數組可使用的位置比數組長度小了不少，這意味着進一步增長了碰撞的概率，減慢了查詢的效率！這樣就會形成空間的浪費。

3.0.1.9 爲何HashMap中String、Integer這樣的包裝類適合做爲K？爲啥不用其餘做key值？

爲何HashMap中String、Integer這樣的包裝類適合做爲K？
- String、Integer等包裝類的特性可以保證Hash值的不可更改性和計算準確性，可以有效的減小Hash碰撞的概率
  - 都是final類型，即不可變性，保證key的不可更改性，不會存在獲取hash值不一樣的狀況
  - 內部已重寫了equals()、hashCode()等方法，遵照了HashMap內部的規範（不清楚能夠去上面看看putValue的過程），不容易出現Hash值計算錯誤的狀況；
想要讓本身的Object做爲K應該怎麼辦呢？
- 重寫hashCode()和equals()方法
  - 重寫hashCode()是由於須要計算存儲數據的存儲位置，須要注意不要試圖從散列碼計算中排除掉一個對象的關鍵部分來提升性能，這樣雖然能更快但可能會致使更多的Hash碰撞；
  - 重寫equals()方法，須要遵照自反性、對稱性、傳遞性、一致性以及對於任何非null的引用值x，x.equals(null)必須返回false的這幾個特性，目的是爲了保證key在哈希表中的惟一性；
總結
- 採用合適的equals()和hashCode()方法的話，將會減小碰撞的發生，提升效率。不可變性使得可以緩存不一樣鍵的hashcode，這將提升整個獲取對象的速度，使用String，Interger這樣的wrapper類做爲鍵是很是好的選擇。
- 技術博客大總結

3.0.2.0 HashMap是如何擴容的？如何理解HashMap的大小超過了負載因子定義的容量？從新調整HashMap大小存在什麼問題嗎？

HashMap是爲啥要擴容
- 當鏈表數組的容量超過初始容量*加載因子（默認0.75）時，再散列將鏈表數組擴大2倍，把原鏈表數組的搬移到新的數組中。爲何須要使用加載因子？爲何須要擴容呢？由於若是填充比很大，說明利用的空間不少，若是一直不進行擴容的話，鏈表就會愈來愈長，這樣查找的效率很低，擴容以後，將原來鏈表數組的每個鏈表分紅奇偶兩個子鏈表分別掛在新鏈表數組的散列位置，這樣就減小了每一個鏈表的長度，增長查找效率。
如何理解HashMap的大小超過了負載因子(load factor)定義的容量？
- 默認的負載因子大小爲0.75，也就是說，當一個map填滿了75%的bucket時候，和其它集合類(如ArrayList等)同樣，將會建立原來HashMap大小的兩倍的bucket數組，來從新調整map的大小，並將原來的對象放入新的bucket數組中。這個過程叫做rehashing，由於它調用hash方法找到新的bucket位置。
從新調整HashMap大小存在什麼問題嗎？技術博客大總結
- 當多線程的狀況下，可能產生條件競爭。當從新調整HashMap大小的時候，確實存在條件競爭，由於若是兩個線程都發現HashMap須要從新調整大小了，它們會同時試着調整大小。在調整大小的過程當中，存儲在鏈表中的元素的次序會反過來，由於移動到新的bucket位置的時候，HashMap並不會將元素放在鏈表的尾部，而是放在頭部，這是爲了不尾部遍歷(tail traversing)。若是條件競爭發生了，那麼就死循環了。