> 作者：幻好
> 
> 來源：[恆生LIGHT雲社群](https://developer.hs.net/thread/1334 "恆生LIGHT雲社群")

## 1 集合容器介紹

### 1.1 Java 集合概覽

Java 中的**集合**， 也叫作**容器**，主要是由兩大介面派生而來：一個是 `Collecton` 介面，主要用於存放單一元素；另一個是 `Map` 介面，主要用於存放鍵值對。

對於 `Collection` 介面，下面又有三個主要的子介面：`List`、`Set` 和 `Queue`。`Collection` **是高度抽象出來的集合，它包含了集合的基本操作：新增、刪除、清空、遍歷(讀取)、是否為空、獲取大小、是否保護某元素等等。**

![08172429-1ecddb7a87e347369ffc7c1c30f18396.jpg](https://developer.hs.net/storage/attachments/2021/08/28/35r5LVps5G5AKSc7WijVhNDSouJ2VE2tjusHvuFC_thumb.jpg "3015")

Java 集合框架派生關係如下圖所示：

![image-20210828113631126.png](https://developer.hs.net/storage/attachments/2021/08/28/Ef1r6cRsiF22vq23ry88fR2xmGxPcOb0lHHLaqPw_thumb.png "3016")

### 1.2 List, Set, Queue, Map 四者的區別？

- `List` (對付順序的好幫手): 儲存的元素是有序的、可重複的。
- `Set` (注重獨一無二的性質): 儲存的元素是無序的、不可重複的。
- `Queue` (實現排隊功能的叫號機): 按特定的排隊規則來確定先後順序，儲存的元素是有序的、可重複的。
- `Map` (用 key 來搜尋的專家): 使用鍵值對(key-value)儲存，類似於數學上的函式 y=f(x)，"x" 代表 key，"y" 代表 value，key 是無序的、不可重複的，value 是無序的、可重複的，每個鍵最多對映到一個值。

### 1.3 集合框架底層資料結構

#### List

- `Arraylist`：`Object[]` 陣列
- `Vector`：`Object[]` 陣列
- `LinkedList`： 雙向連結串列(JDK1.6 之前為迴圈連結串列，JDK1.7 取消了迴圈)

#### Set

- `HashSet` (無序，唯一): 基於`HashMap` 實現的，底層採用`HashMap` 來儲存元素
- `LinkedHashSet` :`LinkedHashSet` 是`HashSet` 的子類，並且其內部是透過`LinkedHashMap` 來實現的。有點類似於我們之前說的`LinkedHashMap` 其內部是基於`HashMap` 實現一樣，不過還是有一點點區別的
- `TreeSet` (有序，唯一): 紅黑樹(自平衡的排序二叉樹)

#### Queue

- `PriorityQueue` :`Object[]` 陣列來實現二叉堆
- `ArrayQueue` :`Object[]` 陣列 + 雙指標

#### Map

- `HashMap` ： JDK1.8 之前`HashMap` 由陣列+連結串列組成的，陣列是`HashMap` 的主體，連結串列則是主要為了解決雜湊衝突而存在的（“拉鍊法”解決衝突）。JDK1.8 以後在解決雜湊衝突時有了較大的變化，當連結串列長度大於閾值（預設為 8）（將連結串列轉換成紅黑樹前會判斷，如果當前陣列的長度小於 64，那麼會選擇先進行陣列擴容，而不是轉換為紅黑樹）時，將連結串列轉化為紅黑樹，以減少搜尋時間
- `LinkedHashMap` ：`LinkedHashMap` 繼承自`HashMap`，所以它的底層仍然是基於拉鍊式雜湊結構即由陣列和連結串列或紅黑樹組成。另外，`LinkedHashMap` 在上面結構的基礎上，增加了一條雙向連結串列，使得上面的結構可以保持鍵值對的插入順序。同時透過對連結串列進行相應的操作，實現了訪問順序相關邏輯
- `Hashtable` ： 陣列+連結串列組成的，陣列是`Hashtable` 的主體，連結串列則是主要為了解決雜湊衝突而存在的
- `TreeMap` ： 紅黑樹（自平衡的排序二叉樹）

### 1.4  為什麼要使用集合

當需要儲存一組型別相同的資料的時候，我們應該是用一個容器來儲存，這個容器就是陣列，但是，使用陣列儲存物件具有一定的弊端， 因為我們在實際開發中，儲存的資料的型別是多種多樣的，於是，就出現了“集合”，集合同樣也是用來儲存多個資料的。

陣列的缺點是一旦宣告之後，長度就不可變了；同時，宣告陣列時的資料型別也決定了該陣列儲存的資料的型別；而且，陣列儲存的資料是有序的、可重複的，特點單一。 但是集合提高了資料儲存的靈活性，Java 集合不僅可以用來儲存不同型別不同數量的物件，還可以儲存具有對映關係的資料。

### 1.5如何選用集合

主要根據集合的特點來選用，例如需要根據鍵值獲取到元素值時就選用 `Map` 介面下的集合，需要排序時選擇 `TreeMap` ，不需要排序時就選擇 `HashMap` ，需要保證執行緒安全就選用 `ConcurrentHashMap`。

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

## 2 List介面

### 2.1 Arraylist 和 Vector 的區別

- `ArrayList` 是`List` 的主要實現類，底層使用`Object[ ]`儲存，適用於頻繁的查詢工作，執行緒不安全 ；
- `Vector` 是`List` 的古老實現類，底層使用`Object[ ]` 儲存，執行緒安全。

### 2.2 Arraylist 與 LinkedList 區別

1. **是否保證執行緒安全：**`ArrayList` 和`LinkedList` 都是不同步的，也就是不保證執行緒安全；
2. **底層資料結構：**`Arraylist` 底層使用的是**`Object` 陣列**；`LinkedList` 底層使用的是**雙向連結串列** 資料結構（JDK1.6 之前為迴圈連結串列，JDK1.7 取消了迴圈。注意雙向連結串列和雙向迴圈連結串列的區別，後面會介紹。）
3. 插入和刪除是否受元素位置的影響：
   - `ArrayList` 採用陣列儲存，所以插入和刪除元素的時間複雜度受元素位置的影響。 比如：執行`add(E e)`方法的時候，`ArrayList` 會預設在將指定的元素追加到此列表的末尾，這種情況時間複雜度就是 O(1)。但是如果要在指定位置 i 插入和刪除元素的話（`add(int index, E element)`）時間複雜度就為 O(n-i)。因為在進行上述操作的時候集合中第 i 和第 i 個元素之後的(n-i)個元素都要執行向後位/向前移一位的操作。
   - `LinkedList` 採用連結串列儲存，所以，如果是在頭尾插入或者刪除元素不受元素位置的影響（`add(E e)`、`addFirst(E e)`、`addLast(E e)`、`removeFirst()` 、`removeLast()`），近似 O(1)，如果是要在指定位置`i` 插入和刪除元素的話（`add(int index, E element)`，`remove(Object o)`） 時間複雜度近似為 O(n) ，因為需要先移動到指定位置再插入。
4. **是否支援快速隨機訪問：**`LinkedList` 不支援高效的隨機元素訪問，而`ArrayList` 支援。快速隨機訪問就是透過元素的索引快速獲取元素物件(對應於`get(int index)`方法)。
5. **記憶體空間佔用：** ArrayList 的空間浪費主要體現在在 list 列表的結尾會預留一定的容量空間，而 LinkedList 的空間花費則體現在它的每一個元素都需要消耗比 ArrayList 更多的空間（因為要存放直接後繼和直接前驅以及資料）。

## 3 Set 介面

### 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()`.

### 3.2. 無序性和不可重複性的含義

1. 無序性不等於隨機性 ，無序性是指儲存的資料在底層陣列中並非按照陣列索引的順序新增 ，而是根據資料的雜湊值決定的。
2. 不可重複性是指新增的元素按照`equals()` 判斷時 ，返回`false`，需要同時重寫`equals()` 方法和`HashCode()` 方法。

### 3.3 HashSet、LinkedHashSet 和 TreeSet 三者的異同

- `HashSet` 是`Set` 介面的主要實現類 ，`HashSet` 的底層是`HashMap`，執行緒不安全的，可以儲存 null 值；
- `LinkedHashSet` 是`HashSet` 的子類，能夠按照新增的順序遍歷；
- `TreeSet` 底層使用紅黑樹，能夠按照新增元素的順序進行遍歷，排序的方式有自然排序和定製排序。

## 4 Queue介面

### 4.1 Queue 與 Deque 的區別

- `Queue` 是單端佇列，只能從一端插入元素，另一端刪除元素，實現上一般遵循**先進先出（FIFO）** 規則。
- `Queue` 擴充套件了`Collection` 的介面，根據**因為容量問題而導致操作失敗後處理方式的不同** 可以分為兩類方法: 一種在操作失敗後會丟擲異常，另一種則會返回特殊值。

| `Queue` 介面 | 丟擲異常  | 返回特殊值 |
| -------------- | --------- | ---------- |
| 插入隊尾       | add(E e)  | offer(E e) |
| 刪除隊首       | remove()  | poll()     |
| 查詢隊首元素   | element() | peek()     |

- `Deque` 是雙端佇列，在佇列的兩端均可以插入或刪除元素。
- `Deque` 擴充套件了`Queue` 的介面, 增加了在隊首和隊尾進行插入和刪除的方法，同樣根據失敗後處理方式的不同分為兩類：

| `Deque` 介面 | 丟擲異常      | 返回特殊值      |
| -------------- | ------------- | --------------- |
| 插入隊首       | addFirst(E e) | offerFirst(E e) |
| 插入隊尾       | addLast(E e)  | offerLast(E e)  |
| 刪除隊首       | removeFirst() | pollFirst()     |
| 刪除隊尾       | removeLast()  | pollLast()      |
| 查詢隊首元素   | getFirst()    | peekFirst()     |
| 查詢隊尾元素   | getLast()     | peekLast()      |

### 4.2 ArrayDeque 與 LinkedList 的區別

`ArrayDeque` 和 `LinkedList` 都實現了 `Deque` 介面，兩者都具有佇列的功能，但兩者有什麼區別呢？

- `ArrayDeque` 是基於可變長的陣列和雙指標來實現，而`LinkedList` 則透過連結串列來實現。
- `ArrayDeque` 不支援儲存`NULL` 資料，但`LinkedList` 支援。
- `ArrayDeque` 是在 JDK1.6 才被引入的，而`LinkedList` 早在 JDK1.2 時就已經存在。
- `ArrayDeque` 插入時可能存在擴容過程, 不過均攤後的插入操作依然為 O(1)。雖然`LinkedList` 不需要擴容，但是每次插入資料時均需要申請新的堆空間，均攤效能相比更慢。

從效能的角度上，選用 `ArrayDeque` 來實現佇列要比 `LinkedList` 更好。此外，`ArrayDeque` 也可以用於實現棧。

### 4.3 PriorityQueue

`PriorityQueue` 是在 JDK1.5 中被引入的，其與 `Queue` 的區別在於元素出隊順序是與優先順序相關的，即總是優先順序最高的元素先出隊。

這裡列舉其相關的一些要點：

- `PriorityQueue` 利用了二叉堆的資料結構來實現的，底層使用可變長的陣列來儲存資料
- `PriorityQueue` 透過堆元素的上浮和下沉，實現了在 O(logn) 的時間複雜度內插入元素和刪除堆頂元素。
- `PriorityQueue` 是非執行緒安全的，且不支援儲存`NULL` 和`non-comparable` 的物件。
- `PriorityQueue` 預設是小頂堆，但可以接收一個`Comparator` 作為構造引數，從而來自定義元素優先順序的先後。

`PriorityQueue` 在面試中可能更多的會出現在手撕演算法的時候，典型例題包括堆排序、求第K大的數、帶權圖的遍歷等，所以需要會熟練使用才行。

## 5 Map介面

### 5.1 HashMap 和 Hashtable 的區別

1. **執行緒是否安全：**`HashMap` 是非執行緒安全的，`HashTable` 是執行緒安全的，因為`HashTable` 內部的方法基本都經過，`synchronized` 修飾。
2. **效率：** 因為執行緒安全的問題，`HashMap` 要比`HashTable` 效率高一點。另外，`HashTable` 基本被淘汰，不要在程式碼中使用它；
3. **對 Null key 和 Null value 的支援：**`HashMap` 可以儲存 null 的 key 和 value，但 null 作為鍵只能有一個，null 作為值可以有多個；HashTable 不允許有 null 鍵和 null 值，否則會丟擲`NullPointerException`。
4. **初始容量大小和每次擴充容量大小的不同 ：** ① 建立時如果不指定容量初始值，`Hashtable` 預設的初始大小為 11，之後每次擴充，容量變為原來的 2n+1。`HashMap` 預設的初始化大小為 16。之後每次擴充，容量變為原來的 2 倍。② 建立時如果給定了容量初始值，那麼 Hashtable 會直接使用你給定的大小，而`HashMap` 會將其擴充為 2 的冪次方大小（`HashMap` 中的`tableSizeFor()` 方法保證）。
5. **底層資料結構：** JDK1.8 以後的`HashMap` 在解決雜湊衝突時有了較大的變化，當連結串列長度大於閾值（預設為 8）（將連結串列轉換成紅黑樹前會判斷，如果當前陣列的長度小於 64，那麼會選擇先進行陣列擴容，而不是轉換為紅黑樹）時，將連結串列轉化為紅黑樹，以減少搜尋時間。Hashtable 沒有這樣的機制。

**`HashMap` 中帶有初始容量的建構函式：**

```java
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 的冪作為雜湊表的大小。

```java
/**
 * 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;
}
```

### 5.2. HashMap 和 HashSet 區別

在 `HashSet` 原始碼的中：`HashSet` 底層就是基於 `HashMap` 實現的。（`HashSet` 的原始碼非常非常少，因為除了 `clone()`、`writeObject()`、`readObject()`是 `HashSet` 自己不得不實現之外，其他方法都是直接呼叫 `HashMap` 中的方法。

| HashMap                                    | HashSet                                                                                                                           |
| ------------------------------------------ | --------------------------------------------------------------------------------------------------------------------------------- |
| 實現了 `Map` 介面                        | 實現 `Set` 介面                                                                                                                 |
| 儲存鍵值對                                 | 僅儲存物件                                                                                                                        |
| 呼叫 `put()`向 map 中新增元素            | 呼叫 `add()`方法向 `Set` 中新增元素                                                                                           |
| `HashMap` 使用鍵（Key）計算 `hashcode` | `HashSet` 使用成員物件來計算 `hashcode` 值，對於兩個物件來說 `hashcode` 可能相同，所以 `equals()`方法用來判斷物件的相等性 |

### 5.3 HashMap 和 TreeMap 區別

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

![img](F:\01mynotes\0827-Java 集合框架\Java 集合框架.assets\5621908-9e7544ea7dd5670c.png)

實現 `NavigableMap` 介面讓 `TreeMap` 有了對集合內元素的搜尋的能力。

實現 `SortMap` 介面讓 `TreeMap` 有了對集合中的元素根據鍵排序的能力。

### 5.4 HashSet 如何檢查重複

當把物件加入 `HashSet`時，`HashSet` 會先計算物件的 `hashcode` 值來判斷物件加入的位置，同時也會與其他加入的物件的 `hashcode` 值作比較，如果沒有相符的 `hashcode` ，`HashSet` 會假設物件沒有重複出現。但是如果發現有相同 `hashcode` 值的物件，這時會呼叫 `equals()` 方法來檢查 `hashcode` 相等的物件是否真的相同。如果兩者相同，`HashSet` 就不會讓加入操作成功。

在openjdk8中，`HashSet` 的 `add()` 方法只是簡單的呼叫了 `HashMap` 的 `put()` 方法，並且判斷了一下返回值以確保是否有重複元素。直接看一下 `HashSet` 中的原始碼：

```java
// 返回值：當set中沒有包含add的元素時返回真
public boolean add(E e) {
        return map.put(e, PRESENT)==null;
}
```

在 `HashMap` 的 `putVal()` 方法中也能看到如下說明：

```java
// 返回值：如果插入位置沒有元素返回null，否則返回上一個元素
final V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict) {
...
}
```

在openjdk8中，實際上無論 `HashSet` 中是否已經存在了某元素，`HashSet` 都會直接插入，只是會在 `add()` 方法的返回值處告訴我們插入前是否存在相同元素。

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

1. 如果兩個物件相等，則`hashcode` 一定也是相同的
2. 兩個物件相等,對兩個`equals()` 方法返回 true
3. 兩個物件有相同的`hashcode` 值，它們也不一定是相等的
4. 綜上，`equals()` 方法被覆蓋過，則`hashCode()` 方法也必須被覆蓋
5. `hashCode()` 的預設行為是對堆上的物件產生獨特值。如果沒有重寫`hashCode()`，則該 class 的兩個物件無論如何都不會相等（即使這兩個物件指向相同的資料）。

### 5.5 HashMap 的底層實現

#### 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 方法更加簡化，但是原理不變。

```java
static final int hash(Object key) {
    int h;
    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
```

對比一下 JDK1.7 的 HashMap 的 hash 方法原始碼.

```java
static int hash(int h) {
    h ^= (h >>> 20) ^ (h >>> 12);
    return h ^ (h >>> 7) ^ (h >>> 4);
}
```

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

所謂 **“拉鍊法”** 就是：將連結串列和陣列相結合。也就是說建立一個連結串列陣列，陣列中每一格就是一個連結串列。若遇到雜湊衝突，則將衝突的值加到連結串列中即可。

![jdk1.8之前的內部結構-HashMap.png](https://developer.hs.net/storage/attachments/2021/08/28/ii4B2X3kTr055qYmk4sCA9JlOzgxILgRwxZcIbow_thumb.png "3018")

#### JDK1.8 以後

相比於之前的版本， JDK1.8 之後在解決雜湊衝突時有了較大的變化，當連結串列長度大於閾值（預設為 8）（將連結串列轉換成紅黑樹前會判斷，如果當前陣列的長度小於 64，那麼會選擇先進行陣列擴容，而不是轉換為紅黑樹）時，將連結串列轉化為紅黑樹，以減少搜尋時間。

![jdk1.8之後的內部結構-HashMap.png](https://developer.hs.net/storage/attachments/2021/08/28/P7DW2jhXvFiyCn1HpOonD9kNZIinY9z6T7miwzAE_thumb.png "3019")

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

### 5.6 HashMap 的遍歷方式

`HashMap` **遍歷從大的方向來說，可分為以下 4 類**：

1. 迭代器（Iterator）方式遍歷；
2. For Each 方式遍歷；
3. Lambda 表示式遍歷（JDK 1.8+）;
4. Streams API 遍歷（JDK 1.8+）。

但每種型別下又有不同的實現方式，因此具體的遍歷方式又可以分為以下 7 種：

1. 使用迭代器（Iterator）EntrySet 的方式進行遍歷；
2. 使用迭代器（Iterator）KeySet 的方式進行遍歷；
3. 使用 For Each EntrySet 的方式進行遍歷；
4. 使用 For Each KeySet 的方式進行遍歷；
5. 使用 Lambda 表示式的方式進行遍歷；
6. 使用 Streams API 單執行緒的方式進行遍歷；
7. 使用 Streams API 多執行緒的方式進行遍歷。

**推薦**：推薦**儘量使用迭代器（Iterator）來遍歷 `EntrySet` 的遍歷方式來操作 Map 集合**，這樣就會既安全又高效了。

```java
Iterator<map.entry string="">> iterator = map.entrySet().iterator();
while (iterator.hasNext()) {
    Map.Entry<integer string=""> entry = iterator.next();
    if (entry.getKey() == 1) {
        // 刪除
        System.out.println("del:" + entry.getKey());
        iterator.remove();
    } else {
        System.out.println("show:" + entry.getKey());
    }
}
```

### 5.7 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:**

![1303036-20180702154120320-370170947.jpg](https://developer.hs.net/storage/attachments/2021/08/28/GT5V95FVoaMxP1u0mwObpig3AMmaozZruCzQKb2a_thumb.jpg "3017")

**JDK1.7 的 ConcurrentHashMap：**

![1630130707(1).jpg](https://developer.hs.net/storage/attachments/2021/08/28/F3LQRnCmYjt0AtuHmNQKwok6RLNgcqYyOSxUe4kF_thumb.jpg "3021")

**JDK1.8 的 ConcurrentHashMap：**

![java8_concurrenthashmap.png](https://developer.hs.net/storage/attachments/2021/08/28/Yn1PotPd01Oi2d9CoebzpRxPphTyzhwzznnvvaUM_thumb.png "3020")

JDK1.8 的 `ConcurrentHashMap` 不在是 **Segment 陣列 + HashEntry 陣列 + 連結串列**，而是 **Node 陣列 + 連結串列 / 紅黑樹**。不過，Node 只能用於連結串列的情況，紅黑樹的情況需要使用 **`TreeNode`**。當衝突連結串列達到一定長度時，連結串列會轉換成紅黑樹。

### 5.8 ConcurrentHashMap 執行緒安全的底層實現

#### JDK1.7

首先將資料分為一段一段的儲存，然後給每一段資料配一把鎖，當一個執行緒佔用鎖訪問其中一個段資料時，其他段的資料也能被其他執行緒訪問。

**`ConcurrentHashMap` 是由 `Segment` 陣列結構和 `HashEntry` 陣列結構組成**。

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

```java
static class Segment<k> extends ReentrantLock implements Serializable {
}
```

一個 `ConcurrentHashMap` 裡包含一個 `Segment` 陣列。`Segment` 的結構和 `HashMap` 類似，是一種陣列和連結串列結構，一個 `Segment` 包含一個 `HashEntry` 陣列，每個 `HashEntry` 是一個連結串列結構的元素，每個 `Segment` 守護著一個 `HashEntry` 陣列裡的元素，當對 `HashEntry` 陣列的資料進行修改時，必須首先獲得對應的 `Segment` 的鎖。

#### JDK1.8

`ConcurrentHashMap` 取消了 `Segment` 分段鎖，採用 CAS 和 `synchronized` 來保證併發安全。資料結構跟 HashMap1.8 的結構類似，陣列+連結串列/紅黑二叉樹。Java 8 在連結串列長度超過一定閾值（8）時將連結串列（定址時間複雜度為 O(N)）轉換為紅黑樹（定址時間複雜度為 O(log(N))）

`synchronized` 只鎖定當前連結串列或紅黑二叉樹的首節點，這樣只要 hash 不衝突，就不會產生併發，效率又提升 N 倍。

## 6 Iterator介面

### 6.1 Iterator 的基本概念

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

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

## 7 Collections 工具類

Collections 工具類常用方法:

1. 排序
2. 查詢/替換操作
3. 同步控制(不推薦，需要執行緒安全的集合型別時請考慮使用 JUC 包下的併發集合)

### 7.1 排序操作

```java
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個元素整體移到後面
```

### 7.2 查詢/替換操作

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

### 7.3 同步控制

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

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

**最好不要用下面這些方法，效率非常低，需要執行緒安全的集合型別時請考慮使用 JUC 包下的併發集合。**

方法如下：

```java
synchronizedCollection(Collection<t>  c)       // 返回指定 collection 支援的同步（執行緒安全的）collection。
synchronizedList(List<t> list)                 // 返回指定列表支援的同步（執行緒安全的）List。
synchronizedMap(Map<k> m)                    // 返回由指定對映支援的同步（執行緒安全的）Map。
synchronizedSet(Set<t> s)                      // 返回指定 set 支援的同步（執行緒安全的）set。
```</t></k></t></t></k></integer></map.entry>

Java開發工程師進階篇——深入淺出Java集合框架

相關文章