轉載自https://github.com/Snailclimb/JavaGuide/blob/master/docs/java/collection/Java%E9%9B%86%E5%90%88%E6%A1%86%E6%9E%B6%E5%B8%B8%E8%A7%81%E9%9D%A2%E8%AF%95%E9%A2%98.md

Java 集合框架

• 1.1. 集合概述
• • 1.1.1. Java 集合概覽
  • 1.1.2. 說說 List,Set,Map 三者的區別？
  • 1.1.3. 集合框架底層數據結構總結
  • • 1.1.3.1. List
    • 1.1.3.2. Set
    • 1.1.3.3. Map
  • 1.1.4. 如何選用集合?
  • 1.1.5. 為什么要使用集合？
  • 1.1.6. Iterator 迭代器
  • • 1.1.6.1. 迭代器 Iterator 是什么？
    • 1.1.6.2. 迭代器 Iterator 有啥用？
    • 1.1.6.3. 如何使用？
  • 1.1.7. 有哪些集合是線程不安全的？怎么解決呢？
• 1.2. Collection 子接口之 List
• • 1.2.1. Arraylist 和 Vector 的區別?
  • 1.2.2. Arraylist 與 LinkedList 區別?
  • • 1.2.2.1. 補充內容:雙向鏈表和雙向循環鏈表
    • 1.2.2.2. 補充內容:RandomAccess 接口
  • 1.2.3. 說一說 ArrayList 的擴容機制吧
• 1.3. Collection 子接口之 Set
• • 1.3.1. comparable 和 Comparator 的區別
  • • 1.3.1.1. Comparator 定制排序
  • 1.3.2. 無序性和不可重復性的含義是什么
  • 1.3.3. 比較 HashSet、LinkedHashSet 和 TreeSet 三者的異同
• 1.4. Map 接口
• • 1.4.1. HashMap 和 Hashtable 的區別
  • 1.4.2. HashMap 和 HashSet 區別
  • 1.4.3. HashMap 和 TreeMap 區別
  • 1.4.4. HashSet 如何檢查重復
  • 1.4.5. HashMap 的底層實現
  • • 1.4.5.1. JDK1.8 之前
    • 1.4.5.2. JDK1.8 之后
  • 1.4.6. HashMap 的長度為什么是 2 的冪次方
  • 1.4.7. HashMap 多線程操作導致死循環問題
  • 1.4.8. HashMap 有哪幾種常見的遍歷方式?
  • 1.4.9. ConcurrentHashMap 和 Hashtable 的區別
  • 1.4.10. ConcurrentHashMap 線程安全的具體實現方式/底層具體實現
  • • 1.4.10.1. JDK1.7（上面有示意圖）
    • 1.4.10.2. JDK1.8 （上面有示意圖）
• 1.5. Collections 工具類
• • 1.5.1. 排序操作
  • 1.5.2. 查找,替換操作
  • 1.5.3. 同步控制
• 1.6. 其他重要問題
• • 1.6.1. 什么是快速失敗(fail-fast)？
  • 1.6.2. 什么是安全失敗(fail-safe)呢？
  • 1.6.3. Arrays.asList()避坑指南
  • • 1.6.3.1. 簡介
    • 1.6.3.2. 《阿里巴巴 Java 開發手冊》對其的描述
    • 1.6.3.3. 使用時的注意事項總結

1.1. 集合概述

1.1.1. Java 集合概覽

從下圖可以看出，在 Java 中除了以 Map 結尾的類之外， 其他類都實現了 Collection 接口。

并且，以 Map 結尾的類都實現了 Map 接口。

1.1.2. 說說 List,Set,Map 三者的區別？

• List(對付順序的好幫手)： 存儲的元素是有序的、可重復的。
• Set(注重獨一無二的性質): 存儲的元素是無序的、不可重復的。
• Map(用 Key 來搜索的專家): 使用鍵值對（kye-value）存儲，類似于數學上的函數 y=f(x)，“x”代表 key，"y"代表 value，Key 是無序的、不可重復的，value 是無序的、可重復的，每個鍵最多映射到一個值。

1.1.3. 集合框架底層數據結構總結

先來看一下 Collection 接口下面的集合。

1.1.3.1. List

• Arraylist： Object[]數組
• Vector：Object[]數組
• LinkedList： 雙向鏈表(JDK1.6 之前為循環鏈表，JDK1.7 取消了循環)

1.1.3.2. Set

• HashSet（無序，唯一）: 基于 HashMap 實現的，底層采用 HashMap 來保存元素
• LinkedHashSet：LinkedHashSet 是 HashSet 的子類，并且其內部是通過 LinkedHashMap 來實現的。有點類似于我們之前說的 LinkedHashMap 其內部是基于 HashMap 實現一樣，不過還是有一點點區別的
• TreeSet（有序，唯一）： 紅黑樹(自平衡的排序二叉樹)
  再來看看 Map 接口下面的集合。

1.1.3.3. Map

• HashMap： JDK1.8 之前 HashMap 由數組+鏈表組成的，數組是 HashMap 的主體，鏈表則是主要為了解決哈希沖突而存在的（“拉鏈法”解決沖突）。JDK1.8 以后在解決哈希沖突時有了較大的變化，當鏈表長度大于閾值（默認為 8）（將鏈表轉換成紅黑樹前會判斷，如果當前數組的長度小于 64，那么會選擇先進行數組擴容，而不是轉換為紅黑樹）時，將鏈表轉化為紅黑樹，以減少搜索時間
• LinkedHashMap： LinkedHashMap 繼承自 HashMap，所以它的底層仍然是基于拉鏈式散列結構即由數組和鏈表或紅黑樹組成。另外，
• LinkedHashMap 在上面結構的基礎上，增加了一條雙向鏈表，使得上面的結構可以保持鍵值對的插入順序。同時通過對鏈表進行相應的操作，實現了訪問順序相關邏輯。詳細可以查看：《LinkedHashMap 源碼詳細分析（JDK1.8）》
• Hashtable： 數組+鏈表組成的，數組是 HashMap 的主體，鏈表則是主要為了解決哈希沖突而存在的
• TreeMap： 紅黑樹（自平衡的排序二叉樹）

1.1.4. 如何選用集合?

主要根據集合的特點來選用，比如我們需要根據鍵值獲取到元素值時就選用 Map 接口下的集合，需要排序時選擇 TreeMap,不需要排序時就選擇 HashMap,需要保證線程安全就選用 ConcurrentHashMap。

當我們只需要存放元素值時，就選擇實現Collection 接口的集合，需要保證元素唯一時選擇實現 Set 接口的集合比如 TreeSet 或 HashSet，不需要就選擇實現 List 接口的比如 ArrayList 或 LinkedList，然后再根據實現這些接口的集合的特點來選用。

1.1.5. 為什么要使用集合？

當我們需要保存一組類型相同的數據的時候，我們應該是用一個容器來保存，這個容器就是數組，但是，使用數組存儲對象具有一定的弊端， 因為我們在實際開發中，存儲的數據的類型是多種多樣的，于是，就出現了“集合”，集合同樣也是用來存儲多個數據的。

數組的缺點是一旦聲明之后，長度就不可變了；同時，聲明數組時的數據類型也決定了該數組存儲的數據的類型；而且，數組存儲的數據是有序的、可重復的，特點單一。 但是集合提高了數據存儲的靈活性，Java 集合不僅可以用來存儲不同類型不同數量的對象，還可以保存具有映射關系的數據

1.1.6. Iterator 迭代器

1.1.6.1. 迭代器 Iterator 是什么？

public interface Iterator<E> {//集合中是否還有元素boolean hasNext();//獲得集合中的下一個元素E next();...... }

Iterator 對象稱為迭代器（設計模式的一種），迭代器可以對集合進行遍歷，但每一個集合內部的數據結構可能是不盡相同的，所以每一個集合存和取都很可能是不一樣的，雖然我們可以人為地在每一個類中定義 hasNext() 和 next() 方法，但這樣做會讓整個集合體系過于臃腫。于是就有了迭代器。

迭代器是將這樣的方法抽取出接口，然后在每個類的內部，定義自己迭代方式，這樣做就規定了整個集合體系的遍歷方式都是 hasNext()和next()方法，使用者不用管怎么實現的，會用即可。迭代器的定義為：提供一種方法訪問一個容器對象中各個元素，而又不需要暴露該對象的內部細節。

1.1.6.2. 迭代器 Iterator 有啥用？

Iterator 主要是用來遍歷集合用的，它的特點是更加安全，因為它可以確保，在當前遍歷的集合元素被更改的時候，就會拋出 ConcurrentModificationException 異常。

1.1.6.3. 如何使用？

我們通過使用迭代器來遍歷 HashMap，演示一下 迭代器 Iterator 的使用。

Map<Integer, String> map = new HashMap(); map.put(1, "Java"); map.put(2, "C++"); map.put(3, "PHP"); Iterator<Map.Entry<Integer, String>> iterator = map.entrySet().iterator(); while (iterator.hasNext()) {Map.Entry<Integer, String> entry = iterator.next();System.out.println(entry.getKey() + entry.getValue()); }

1.1.7. 有哪些集合是線程不安全的？怎么解決呢？

我們常用的 Arraylist ,LinkedList,Hashmap,HashSet,TreeSet,TreeMap，PriorityQueue 都不是線程安全的。解決辦法很簡單，可以使用線程安全的集合來代替。

如果你要使用線程安全的集合的話， java.util.concurrent 包中提供了很多并發容器供你使用：

• ConcurrentHashMap: 可以看作是線程安全的 HashMap
• CopyOnWriteArrayList:可以看作是線程安全的 ArrayList，在讀多寫少的場合性能非常好，遠遠好于 Vector.
• ConcurrentLinkedQueue:高效的并發隊列，使用鏈表實現。可以看做一個線程安全的 LinkedList，這是一個非阻塞隊列。
• BlockingQueue: 這是一個接口，JDK 內部通過鏈表、數組等方式實現了這個接口。表示阻塞隊列，非常適合用于作為數據共享的通道。
• ConcurrentSkipListMap :跳表的實現。這是一個Map，使用跳表的數據結構進行快速查找。

1.2. Collection 子接口之 List

1.2.1. Arraylist 和 Vector 的區別?

ArrayList 是 List 的主要實現類，底層使用 Object[ ]存儲，適用于頻繁的查找工作，線程不安全 ；
Vector 是 List 的古老實現類，底層使用 Object[ ]存儲，線程安全的。

1.2.2. Arraylist 與 LinkedList 區別?

• 是否保證線程安全： ArrayList 和 LinkedList 都是不同步的，也就是不保證線程安全；
• 底層數據結構： Arraylist 底層使用的是 Object 數組；LinkedList 底層使用的是 雙向鏈表 數據結構（JDK1.6 之前為循環鏈表，JDK1.7 取消了循環。注意雙向鏈表和雙向循環鏈表的區別，下面有介紹到！）
• 插入和刪除是否受元素位置的影響： ① ArrayList 采用數組存儲，所以插入和刪除元素的時間復雜度受元素位置的影響。 比如：執行add(E e)方法的時候， ArrayList 會默認在將指定的元素追加到此列表的末尾，這種情況時間復雜度就是 O(1)。但是如果要在指定位置 i 插入和刪除元素的話（add(int index, E element)）時間復雜度就為 O(n-i)。因為在進行上述操作的時候集合中第 i 和第 i 個元素之后的(n-i)個元素都要執行向后位/向前移一位的操作。 ② LinkedList 采用鏈表存儲，所以對于add(E e)方法的插入，刪除元素時間復雜度不受元素位置的影響，近似 O(1)，如果是要在指定位置i插入和刪除元素的話（(add(int index, E element)） 時間復雜度近似為o(n))因為需要先移動到指定位置再插入。
• 是否支持快速隨機訪問： LinkedList 不支持高效的隨機元素訪問，而 ArrayList 支持。快速隨機訪問就是通過元素的序號快速獲取元素對象(對應于get(int index)方法)。
• 內存空間占用： ArrayList 的空 間浪費主要體現在在 list 列表的結尾會預留一定的容量空間，而 LinkedList 的空間花費則體現在它的每一個元素都需要消耗比 ArrayList 更多的空間（因為要存放直接后繼和直接前驅以及數據）。

1.2.2.1. 補充內容:雙向鏈表和雙向循環鏈表

雙向鏈表： 包含兩個指針，一個 prev 指向前一個節點，一個 next 指向后一個節點。

另外推薦一篇把雙向鏈表講清楚的文章：https://juejin.im/post/5b5d1a9af265da0f47352f14

雙向鏈表

雙向循環鏈表： 最后一個節點的 next 指向 head，而 head 的 prev 指向最后一個節點，構成一個環。

雙向循環鏈表

1.2.2.2. 補充內容:RandomAccess 接口

public interface RandomAccess { }

查看源碼我們發現實際上 RandomAccess 接口中什么都沒有定義。所以，在我看來 RandomAccess 接口不過是一個標識罷了。標識什么？ 標識實現這個接口的類具有隨機訪問功能。

在 binarySearch（) 方法中，它要判斷傳入的 list 是否 RamdomAccess 的實例，如果是，調用indexedBinarySearch()方法，如果不是，那么調用iteratorBinarySearch()方法

public static <T>int binarySearch(List<? extends Comparable<? super T>> list, T key) {if (list instanceof RandomAccess || list.size()<BINARYSEARCH_THRESHOLD)return Collections.indexedBinarySearch(list, key);elsereturn Collections.iteratorBinarySearch(list, key);}

ArrayList 實現了 RandomAccess 接口， 而 LinkedList 沒有實現。為什么呢？我覺得還是和底層數據結構有關！ArrayList 底層是數組，而 LinkedList 底層是鏈表。數組天然支持隨機訪問，時間復雜度為 O(1)，所以稱為快速隨機訪問。鏈表需要遍歷到特定位置才能訪問特定位置的元素，時間復雜度為 O(n)，所以不支持快速隨機訪問。，ArrayList 實現了 RandomAccess 接口，就表明了他具有快速隨機訪問功能。 RandomAccess 接口只是標識，并不是說 ArrayList 實現 RandomAccess 接口才具有快速隨機訪問功能的！

1.2.3. 說一說 ArrayList 的擴容機制吧

詳見筆主的這篇文章:通過源碼一步一步分析 ArrayList 擴容機制

1.3. Collection 子接口之 Set

1.3.1. comparable 和 Comparator 的區別

• comparable 接口實際上是出自java.lang包 它有一個 compareTo(Object obj)方法用來排序
• comparator接口實際上是出自 java.util 包它有一個compare(Object obj1, Object obj2)方法用來排序
  一般我們需要對一個集合使用自定義排序時，我們就要重寫compareTo()方法或compare()方法，當我們需要對某一個集合實現兩種排序方式，比如一個 song 對象中的歌名和歌手名分別采用一種排序方法的話，我們可以重寫compareTo()方法和使用自制的Comparator方法或者以兩個 Comparator 來實現歌名排序和歌星名排序，第二種代表我們只能使用兩個參數版的 Collections.sort().

1.3.1.1. Comparator 定制排序

ArrayList<Integer> arrayList = new ArrayList<Integer>(); arrayList.add(-1); arrayList.add(3); arrayList.add(3); arrayList.add(-5); arrayList.add(7); arrayList.add(4); arrayList.add(-9); arrayList.add(-7); System.out.println("原始數組:"); System.out.println(arrayList); // void reverse(List list)：反轉 Collections.reverse(arrayList); System.out.println("Collections.reverse(arrayList):"); System.out.println(arrayList);// void sort(List list),按自然排序的升序排序 Collections.sort(arrayList); System.out.println("Collections.sort(arrayList):"); System.out.println(arrayList); // 定制排序的用法 Collections.sort(arrayList, new Comparator<Integer>() {@Overridepublic int compare(Integer o1, Integer o2) {return o2.compareTo(o1);} }); System.out.println("定制排序后："); System.out.println(arrayList);

Output:

原始數組: [-1, 3, 3, -5, 7, 4, -9, -7] Collections.reverse(arrayList): [-7, -9, 4, 7, -5, 3, 3, -1] Collections.sort(arrayList): [-9, -7, -5, -1, 3, 3, 4, 7] 定制排序后： [7, 4, 3, 3, -1, -5, -7, -9] 1.3.1.2. 重寫 compareTo 方法實現按年齡來排序 // person對象沒有實現Comparable接口，所以必須實現，這樣才不會出錯，才可以使treemap中的數據按順序排列 // 前面一個例子的String類已經默認實現了Comparable接口，詳細可以查看String類的API文檔，另外其他 // 像Integer類等都已經實現了Comparable接口，所以不需要另外實現了 public class Person implements Comparable<Person> {private String name;private int age;public Person(String name, int age) {super();this.name = name;this.age = age;}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}/*** T重寫compareTo方法實現按年齡來排序*/@Overridepublic int compareTo(Person o) {if (this.age > o.getAge()) {return 1;}if (this.age < o.getAge()) {return -1;}return 0;} }public static void main(String[] args) {TreeMap<Person, String> pdata = new TreeMap<Person, String>();pdata.put(new Person("張三", 30), "zhangsan");pdata.put(new Person("李四", 20), "lisi");pdata.put(new Person("王五", 10), "wangwu");pdata.put(new Person("小紅", 5), "xiaohong");// 得到key的值的同時得到key所對應的值Set<Person> keys = pdata.keySet();for (Person key : keys) {System.out.println(key.getAge() + "-" + key.getName());}}

Output：

5-小紅 10-王五 20-李四 30-張三

1.3.2. 無序性和不可重復性的含義是什么

什么是無序性？無序性不等于隨機性 ，無序性是指存儲的數據在底層數組中并非按照數組索引的順序添加 ，而是根據數據的哈希值決定的。

什么是不可重復性？不可重復性是指添加的元素按照 equals()判斷時 ，返回 false，需要同時重寫 equals()方法和 HashCode()方法。

1.3.3. 比較 HashSet、LinkedHashSet 和 TreeSet 三者的異同

HashSet 是 Set 接口的主要實現類 ，HashSet 的底層是 HashMap，線程不安全的，可以存儲 null 值；

LinkedHashSet 是 HashSet 的子類，能夠按照添加的順序遍歷；

TreeSet 底層使用紅黑樹，能夠按照添加元素的順序進行遍歷，排序的方式有自然排序和定制排序。

1.4. Map 接口

1.4.1. HashMap 和 Hashtable 的區別

• 線程是否安全： HashMap 是非線程安全的，HashTable 是線程安全的,因為 HashTable 內部的方法基本都經過synchronized 修飾。（如果你要保證線程安全的話就使用 ConcurrentHashMap 吧！）；
• 效率： 因為線程安全的問題，HashMap 要比 HashTable 效率高一點。另外，HashTable 基本被淘汰，不要在代碼中使用它；
• 對 Null key 和 Null value 的支持： HashMap 可以存儲 null 的 key 和 value，但 null 作為鍵只能有一個，null 作為值可以有多個；HashTable 不允許有 null 鍵和 null 值，否則會拋出 NullPointerException。
• 初始容量大小和每次擴充容量大小的不同 ： ① 創建時如果不指定容量初始值，Hashtable 默認的初始大小為 11，之后每次擴充，容量變為原來的 2n+1。HashMap 默認的初始化大小為 16。之后每次擴充，容量變為原來的 2 倍。② 創建時如果給定了容量初始值，那么 Hashtable 會直接使用你給定的大小，而 HashMap 會將其擴充為 2 的冪次方大小（HashMap 中的tableSizeFor()方法保證，下面給出了源代碼）。也就是說 HashMap 總是使用 2 的冪作為哈希表的大小,后面會介紹到為什么是 2 的冪次方。
• 底層數據結構： JDK1.8 以后的 HashMap 在解決哈希沖突時有了較大的變化，當鏈表長度大于閾值（默認為 8）（將鏈表轉換成紅黑樹前會判斷，如果當前數組的長度小于 64，那么會選擇先進行數組擴容，而不是轉換為紅黑樹）時，將鏈表轉化為紅黑樹，以減少搜索時間。Hashtable 沒有這樣的機制。
• 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); }public HashMap(int initialCapacity) {this(initialCapacity, DEFAULT_LOAD_FACTOR); }

下面這個方法保證了 HashMap 總是使用 2 的冪作為哈希表的大小。

/*** Returns a power of two size for the given target capacity.*/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.4.2. HashMap 和 HashSet 區別

如果你看過 HashSet 源碼的話就應該知道：HashSet 底層就是基于 HashMap 實現的。（HashSet 的源碼非常非常少，因為除了 **clone()、writeObject()、readObject()**是 HashSet 自己不得不實現之外，其他方法都是直接調用 HashMap 中的方法。

1.4.3. HashMap 和 TreeMap 區別

TreeMap 和HashMap 都繼承自AbstractMap ，但是需要注意的是TreeMap它還實現了NavigableMap接口和SortedMap 接口。

實現 NavigableMap 接口讓 TreeMap 有了對集合內元素的搜索的能力。

實現SortMap接口讓 TreeMap 有了對集合中的元素根據鍵排序的能力。默認是按 key 的升序排序，不過我們也可以指定排序的比較器。示例代碼如下：

/*** @author shuang.kou* @createTime 2020年06月15日 17:02:00*/ public class Person {private Integer age;public Person(Integer age) {this.age = age;}public Integer getAge() {return age;}public static void main(String[] args) {TreeMap<Person, String> treeMap = new TreeMap<>(new Comparator<Person>() {@Overridepublic int compare(Person person1, Person person2) {int num = person1.getAge() - person2.getAge();return Integer.compare(num, 0);}});treeMap.put(new Person(3), "person1");treeMap.put(new Person(18), "person2");treeMap.put(new Person(35), "person3");treeMap.put(new Person(16), "person4");treeMap.entrySet().stream().forEach(personStringEntry -> {System.out.println(personStringEntry.getValue());});} }

輸出:

person1 person4 person2 person3

可以看出，TreeMap 中的元素已經是按照 Person 的 age 字段的升序來排列了。

上面，我們是通過傳入匿名內部類的方式實現的，你可以將代碼替換成 Lambda 表達式實現的方式：

TreeMap<Person, String> treeMap = new TreeMap<>((person1, person2) -> {int num = person1.getAge() - person2.getAge();return Integer.compare(num, 0); });

綜上，相比于HashMap來說 TreeMap 主要多了對集合中的元素根據鍵排序的能力以及對集合內元素的搜索的能力。

1.4.4. HashSet 如何檢查重復

當你把對象加入HashSet時，HashSet 會先計算對象的hashcode值來判斷對象加入的位置，同時也會與其他加入的對象的 hashcode 值作比較，如果沒有相符的 hashcode，HashSet 會假設對象沒有重復出現。但是如果發現有相同 hashcode 值的對象，這時會調用equals()方法來檢查 hashcode 相等的對象是否真的相同。如果兩者相同，HashSet 就不會讓加入操作成功。（摘自我的 Java 啟蒙書《Head fist java》第二版）

hashCode()與 equals()的相關規定：

如果兩個對象相等，則 hashcode 一定也是相同的

兩個對象相等,對兩個 equals 方法返回 true

兩個對象有相同的 hashcode 值，它們也不一定是相等的

綜上，equals 方法被覆蓋過，則 hashCode 方法也必須被覆蓋

hashCode()的默認行為是對堆上的對象產生獨特值。如果沒有重寫 hashCode()，則該 class 的兩個對象無論如何都不會相等（即使這兩個對象指向相同的數據）。
==與 equals 的區別

對于基本類型來說，== 比較的是值是否相等；

對于引用類型來說，== 比較的是兩個引用是否指向同一個對象地址（兩者在內存中存放的地址（堆內存地址）是否指向同一個地方）；

對于引用類型（包括包裝類型）來說，equals 如果沒有被重寫，對比它們的地址是否相等；如果 equals()方法被重寫（例如 String），則比較的是地址里的內容。

1.4.5. HashMap 的底層實現

1.4.5.1. JDK1.8 之前

JDK1.8 之前 HashMap 底層是 數組和鏈表 結合在一起使用也就是 鏈表散列。HashMap 通過 key 的 hashCode 經過擾動函數處理過后得到 hash 值，然后通過 (n - 1) & hash 判斷當前元素存放的位置（這里的 n 指的是數組的長度），如果當前位置存在元素的話，就判斷該元素與要存入的元素的 hash 值以及 key 是否相同，如果相同的話，直接覆蓋，不相同就通過拉鏈法解決沖突。

所謂擾動函數指的就是 HashMap 的 hash 方法。使用 hash 方法也就是擾動函數是為了防止一些實現比較差的 hashCode() 方法 換句話說使用擾動函數之后可以減少碰撞。

JDK 1.8 HashMap 的 hash 方法源碼:

JDK 1.8 的 hash 方法 相比于 JDK 1.7 hash 方法更加簡化，但是原理不變。

static final int hash(Object key) {int h;// key.hashCode()：返回散列值也就是hashcode// ^ ：按位異或// >>>:無符號右移，忽略符號位，空位都以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); }

相比于 JDK1.8 的 hash 方法 ，JDK 1.7 的 hash 方法的性能會稍差一點點，因為畢竟擾動了 4 次。

所謂 “拉鏈法” 就是：將鏈表和數組相結合。也就是說創建一個鏈表數組，數組中每一格就是一個鏈表。若遇到哈希沖突，則將沖突的值加到鏈表中即可。

jdk1.8之前的內部結構-HashMap

1.4.5.2. JDK1.8 之后

相比于之前的版本， JDK1.8 之后在解決哈希沖突時有了較大的變化，當鏈表長度大于閾值（默認為 8）（將鏈表轉換成紅黑樹前會判斷，如果當前數組的長度小于 64，那么會選擇先進行數組擴容，而不是轉換為紅黑樹）時，將鏈表轉化為紅黑樹，以減少搜索時間。

jdk1.8之后的內部結構-HashMap

TreeMap、TreeSet 以及 JDK1.8 之后的 HashMap 底層都用到了紅黑樹。紅黑樹就是為了解決二叉查找樹的缺陷，因為二叉查找樹在某些情況下會退化成一個線性結構。

1.4.6. HashMap 的長度為什么是 2 的冪次方

為了能讓 HashMap 存取高效，盡量較少碰撞，也就是要盡量把數據分配均勻。我們上面也講到了過了，Hash 值的范圍值-2147483648 到 2147483647，前后加起來大概 40 億的映射空間，只要哈希函數映射得比較均勻松散，一般應用是很難出現碰撞的。但問題是一個 40 億長度的數組，內存是放不下的。所以這個散列值是不能直接拿來用的。用之前還要先做對數組的長度取模運算，得到的余數才能用來要存放的位置也就是對應的數組下標。這個數組下標的計算方法是(n - 1) & hash。（n 代表數組長度）。這也就解釋了 HashMap 的長度為什么是 2 的冪次方。

這個算法應該如何設計呢？

我們首先可能會想到采用%取余的操作來實現。但是，重點來了：“取余(%)操作中如果除數是 2 的冪次則等價于與其除數減一的與(&)操作（也就是說 hash%length==hash&(length-1)的前提是 length 是 2 的 n 次方；）。” 并且 采用二進制位操作 &，相對于%能夠提高運算效率，這就解釋了 HashMap 的長度為什么是 2 的冪次方。

1.4.7. HashMap 多線程操作導致死循環問題

主要原因在于并發下的 Rehash(resize()) 會造成元素之間會形成一個循環鏈表。不過，jdk 1.8 后解決了這個問題，但是還是不建議在多線程下使用 HashMap,因為多線程下使用 HashMap 還是會存在其他問題比如數據丟失。并發環境下推薦使用 ConcurrentHashMap 。

詳情請查看：https://coolshell.cn/articles/9606.html

1.4.8. HashMap 有哪幾種常見的遍歷方式?

HashMap 的 7 種遍歷方式與性能分析！

1.4.9. ConcurrentHashMap 和 Hashtable 的區別

ConcurrentHashMap 和 Hashtable 的區別主要體現在實現線程安全的方式上不同。

• 底層數據結構： JDK1.7 的 ConcurrentHashMap 底層采用 分段的數組+鏈表 實現，JDK1.8 采用的數據結構跟 HashMap1.8 的結構一樣，數組+鏈表/紅黑二叉樹。Hashtable 和 JDK1.8 之前的 HashMap 的底層數據結構類似都是采用 數組+鏈表 的形式，數組是 HashMap 的主體，鏈表則是主要為了解決哈希沖突而存在的；
• 實現線程安全的方式（重要）： ① 在 JDK1.7 的時候，ConcurrentHashMap（分段鎖） 對整個桶數組進行了分割分段**(Segment)，每一把鎖只鎖容器其中一部分數據，多線程訪問容器里不同數據段的數據，就不會存在鎖競爭，提高并發訪問率。 到了 JDK1.8 的時候已經摒棄了 Segment 的概念，而是直接用 Node 數組+鏈表+紅黑樹的數據結構來實現，并發控制使用 synchronized 和 CAS 來操作。（JDK1.6 以后 對 synchronized 鎖做了很多優化） 整個看起來就像是優化過且線程安全的 HashMap，雖然在 JDK1.8 中還能看到 Segment 的數據結構，但是已經簡化了屬性，只是為了兼容舊版本；② Hashtable(同一把鎖) :使用 synchronized 來保證線程安全，效率非常低下。當一個線程訪問同步方法時，其他線程也訪問同步方法，可能會進入阻塞或輪詢狀態**，如使用 put 添加元素，另一個線程不能使用 put 添加元素，也不能使用 get，競爭會越來越激烈效率越低。
  兩者的對比圖：

HashTable:

http://www.cnblogs.com/chengxiao/p/6842045.html>

JDK1.7 的 ConcurrentHashMap：

http://www.cnblogs.com/chengxiao/p/6842045.html>

JDK1.8 的 ConcurrentHashMap：

Java8 ConcurrentHashMap 存儲結構（圖片來自 javadoop）

JDK1.8 的 ConcurrentHashMap 不在是 Segment 數組 + HashEntry 數組 + 鏈表，而是 Node 數組 + 鏈表 / 紅黑樹。不過，Node 只能用于鏈表的情況，紅黑樹的情況需要使用 TreeNode。當沖突鏈表達到一定長度時，鏈表會轉換成紅黑樹。

1.4.10. ConcurrentHashMap 線程安全的具體實現方式/底層具體實現

1.4.10.1. JDK1.7（上面有示意圖）

首先將數據分為一段一段的存儲，然后給每一段數據配一把鎖，當一個線程占用鎖訪問其中一個段數據時，其他段的數據也能被其他線程訪問。

ConcurrentHashMap 是由 Segment 數組結構和 HashEntry 數組結構組成。

Segment 實現了 ReentrantLock,所以 Segment 是一種可重入鎖，扮演鎖的角色。HashEntry 用于存儲鍵值對數據。

static class Segment<K,V> extends ReentrantLock implements Serializable { }

一個 ConcurrentHashMap 里包含一個 Segment 數組。Segment 的結構和 HashMap 類似，是一種數組和鏈表結構，一個 Segment 包含一個 HashEntry 數組，每個 HashEntry 是一個鏈表結構的元素，每個 Segment 守護著一個 HashEntry 數組里的元素，當對 HashEntry 數組的數據進行修改時，必須首先獲得對應的 Segment 的鎖。

1.4.10.2. JDK1.8 （上面有示意圖）

ConcurrentHashMap 取消了 Segment 分段鎖，采用 CAS 和 synchronized 來保證并發安全。數據結構跟 HashMap1.8 的結構類似，數組+鏈表/紅黑二叉樹。Java 8 在鏈表長度超過一定**閾值（8）**時將鏈表（尋址時間復雜度為 O(N)）轉換為紅黑樹（尋址時間復雜度為 O(log(N))）

synchronized 只鎖定當前鏈表或紅黑二叉樹的首節點，這樣只要 hash 不沖突，就不會產生并發，效率又提升 N 倍。

1.5. Collections 工具類

Collections 工具類常用方法:

排序

查找,替換操作

同步控制(不推薦，需要線程安全的集合類型時請考慮使用 JUC 包下的并發集合)

1.5.1. 排序操作

void reverse(List list)//反轉 void shuffle(List list)//隨機排序 void sort(List list)//按自然排序的升序排序 void sort(List list, Comparator c)//定制排序，由Comparator控制排序邏輯 void swap(List list, int i , int j)//交換兩個索引位置的元素 void rotate(List list, int distance)//旋轉。當distance為正數時，將list后distance個元素整體移到前面。當distance為負數時，將 list的前distance個元素整體移到后面

1.5.2. 查找,替換操作

i

nt binarySearch(List list, Object key)//對List進行二分查找，返回索引，注意List必須是有序的 int max(Collection coll)//根據元素的自然順序，返回最大的元素。 類比int min(Collection coll) int max(Collection coll, Comparator c)//根據定制排序，返回最大元素，排序規則由Comparatator類控制。類比int min(Collection coll, Comparator c) void fill(List list, Object obj)//用指定的元素代替指定list中的所有元素。 int frequency(Collection c, Object o)//統計元素出現次數 int indexOfSubList(List list, List target)//統計target在list中第一次出現的索引，找不到則返回-1，類比int lastIndexOfSubList(List source, list target). boolean replaceAll(List list, Object oldVal, Object newVal), 用新元素替換舊元素

1.5.3. 同步控制

Collections 提供了多個synchronizedXxx()方法·，該方法可以將指定集合包裝成線程同步的集合，從而解決多線程并發訪問集合時的線程安全問題。

我們知道 HashSet，TreeSet，ArrayList,LinkedList,HashMap,TreeMap 都是線程不安全的。Collections 提供了多個靜態方法可以把他們包裝成線程同步的集合。

最好不要用下面這些方法，效率非常低，需要線程安全的集合類型時請考慮使用 JUC 包下的并發集合。

方法如下：

synchronizedCollection(Collection<T> c) //返回指定 collection 支持的同步（線程安全的）collection。 synchronizedList(List<T> list)//返回指定列表支持的同步（線程安全的）List。 synchronizedMap(Map<K,V> m) //返回由指定映射支持的同步（線程安全的）Map。 synchronizedSet(Set<T> s) //返回指定 set 支持的同步（線程安全的）set。

1.6. 其他重要問題

1.6.1. 什么是快速失敗(fail-fast)？

快速失敗(fail-fast) 是 Java 集合的一種錯誤檢測機制。在使用迭代器對集合進行遍歷的時候，我們在多線程下操作非安全失敗(fail-safe)的集合類可能就會觸發 fail-fast 機制，導致拋出 ConcurrentModificationException 異常。 另外，在單線程下，如果在遍歷過程中對集合對象的內容進行了修改的話也會觸發 fail-fast 機制。

注：增強 for 循環也是借助迭代器進行遍歷。

舉個例子：多線程下，如果線程 1 正在對集合進行遍歷，此時線程 2 對集合進行修改（增加、刪除、修改），或者線程 1 在遍歷過程中對集合進行修改，都會導致線程 1 拋出 ConcurrentModificationException 異常。

為什么呢？

每當迭代器使用 hashNext()/next()遍歷下一個元素之前，都會檢測 modCount 變量是否為 expectedModCount 值，是的話就返回遍歷；否則拋出異常，終止遍歷。

如果我們在集合被遍歷期間對其進行修改的話，就會改變 modCount 的值，進而導致 modCount != expectedModCount ，進而拋出 ConcurrentModificationException 異常。

注：通過 Iterator 的方法修改集合的話會修改到 expectedModCount 的值，所以不會拋出異常。

final void checkForComodification() {if (modCount != expectedModCount)throw new ConcurrentModificationException(); }

好吧！相信大家已經搞懂了快速失敗(fail-fast)機制以及它的原理。

我們再來趁熱打鐵，看一個阿里巴巴手冊相關的規定：

有了前面講的基礎，我們應該知道：使用 Iterator 提供的 remove 方法，可以修改到 expectedModCount 的值。所以，才不會再拋出ConcurrentModificationException 異常。

1.6.2. 什么是安全失敗(fail-safe)呢？

明白了快速失敗(fail-fast)之后，安全失敗(fail-safe)我們就很好理解了。

采用安全失敗機制的集合容器，在遍歷時不是直接在集合內容上訪問的，而是先復制原有集合內容，在拷貝的集合上進行遍歷。所以，在遍歷過程中對原集合所作的修改并不能被迭代器檢測到，故不會拋 ConcurrentModificationException 異常。

1.6.3. Arrays.asList()避坑指南

最近使用Arrays.asList()遇到了一些坑，然后在網上看到這篇文章：Java Array to List Examples 感覺挺不錯的，但是還不是特別全面。所以，自己對于這塊小知識點進行了簡單的總結。

1.6.3.1. 簡介

**Arrays.asList()**在平時開發中還是比較常見的，我們可以使用它將一個數組轉換為一個 List 集合。

String[] myArray = { "Apple", "Banana", "Orange" }； List<String> myList = Arrays.asList(myArray); //上面兩個語句等價于下面一條語句 List<String> myList = Arrays.asList("Apple","Banana", "Orange");

JDK 源碼對于這個方法的說明：

/***返回由指定數組支持的固定大小的列表。此方法作為基于數組和基于集合的API之間的橋梁，與 Collection.toArray()結合使用。返回的List是可序列化并實現RandomAccess接口。*/ public static <T> List<T> asList(T... a) {return new ArrayList<>(a); }

1.6.3.2. 《阿里巴巴 Java 開發手冊》對其的描述

Arrays.asList()將數組轉換為集合后,底層其實還是數組，《阿里巴巴 Java 開發手冊》對于這個方法有如下描述：

阿里巴巴Java開發手冊-Arrays.asList()方法

1.6.3.3. 使用時的注意事項總結

傳遞的數組必須是對象數組，而不是基本類型。

Arrays.asList()是泛型方法，傳入的對象必須是對象數組。

int[] myArray = { 1, 2, 3 }; List myList = Arrays.asList(myArray); System.out.println(myList.size());//1 System.out.println(myList.get(0));//數組地址值 System.out.println(myList.get(1));//報錯：ArrayIndexOutOfBoundsException int [] array=(int[]) myList.get(0); System.out.println(array[0]);//1

當傳入一個原生數據類型數組時，Arrays.asList() 的真正得到的參數就不是數組中的元素，而是數組對象本身！此時 List 的唯一元素就是這個數組，這也就解釋了上面的代碼。

我們使用包裝類型數組就可以解決這個問題。

Integer[] myArray = { 1, 2, 3 };

使用集合的修改方法:**add()、remove()、clear()**會拋出異常。

List myList = Arrays.asList(1, 2, 3); myList.add(4);//運行時報錯：UnsupportedOperationException myList.remove(1);//運行時報錯：UnsupportedOperationException myList.clear();//運行時報錯：UnsupportedOperationException

Arrays.asList() 方法返回的并不是 java.util.ArrayList ，而是 java.util.Arrays 的一個內部類,這個內部類并沒有實現集合的修改方法或者說并沒有重寫這些方法。

List myList = Arrays.asList(1, 2, 3); System.out.println(myList.getClass());//class java.util.Arrays$ArrayList

下圖是java.util.Arrays$ArrayList的簡易源碼，我們可以看到這個類重寫的方法有哪些。

private static class ArrayList<E> extends AbstractList<E>implements RandomAccess, java.io.Serializable{...@Overridepublic E get(int index) {...}@Overridepublic E set(int index, E element) {...}@Overridepublic int indexOf(Object o) {...}@Overridepublic boolean contains(Object o) {...}@Overridepublic void forEach(Consumer<? super E> action) {...}@Overridepublic void replaceAll(UnaryOperator<E> operator) {...}@Overridepublic void sort(Comparator<? super E> c) {...}}

我們再看一下java.util.AbstractList的remove()方法，這樣我們就明白為啥會拋出UnsupportedOperationException。

public E remove(int index) {throw new UnsupportedOperationException(); }

總結

以上是生活随笔為你收集整理的容器（一）剖析面试最常见问题之 Java 集合框架的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。