java集合框架（二）

阿新 • • 發佈：2018-12-21

本文是“最最最常見Java面試題總結”系列第三週的文章。
主要內容：

Arraylist 與 LinkedList 異同

ArrayList 與 Vector 區別

HashMap的底層實現

HashMap 和 Hashtable 的區別

HashMap 的長度為什麼是2的冪次方

HashMap 多執行緒操作導致死迴圈問題

HashSet 和 HashMap 區別

ConcurrentHashMap 和 Hashtable 的區別

ConcurrentHashMap執行緒安全的具體實現方式/底層具體實現

集合框架底層資料結構總結

Arraylist 與 LinkedList 異同

1. 是否保證執行緒安全：

ArrayList 和 LinkedList 都是不同步的，也就是不保證執行緒安全；
2. 底層資料結構： Arraylist 底層使用的是Object陣列；LinkedList 底層使用的是雙向連結串列資料結構（注意雙向連結串列和雙向迴圈連結串列的區別：）；
3. 插入和刪除是否受元素位置的影響： ① ArrayList 採用陣列儲存，所以插入和刪除元素的時間複雜度受元素位置的影響。 比如：執行add(E e)方法的時候， ArrayList 會預設在將指定的元素追加到此列表的末尾，這種情況時間複雜度就是O(1)。但是如果要在指定位置 i 插入和刪除元素的話（add(int index, E element)

）時間複雜度就為 O(n-i)。因為在進行上述操作的時候集合中第 i 和第 i 個元素之後的(n-i)個元素都要執行向後位/向前移一位的操作。 ② LinkedList 採用連結串列儲存，所以插入，刪除元素時間複雜度不受元素位置的影響，都是近似 O（1）而陣列為近似 O（n）。
4. 是否支援快速隨機訪問： LinkedList 不支援高效的隨機元素訪問，而 ArrayList 支援。快速隨機訪問就是通過元素的序號快速獲取元素物件(對應於get(int index)方法)。
5. 記憶體空間佔用： ArrayList的空間浪費主要體現在在list列表的結尾會預留一定的容量空間，而LinkedList的空間花費則體現在它的每一個元素都需要消耗比ArrayList更多的空間（因為要存放直接後繼和直接前驅以及資料）。

補充內容: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);
        else
            return Collections.iteratorBinarySearch(list, key);
    }

ArraysList 實現了 RandomAccess 介面，而 LinkedList 沒有實現。為什麼呢？我覺得還是和底層資料結構有關！ArraysList 底層是陣列，而 LinkedList 底層是連結串列。陣列天然支援隨機訪問，時間複雜度為 O（1），所以稱為快速隨機訪問。連結串列需要遍歷到特定位置才能訪問特定位置的元素，時間複雜度為 O（n），所以不支援快速隨機訪問。，ArraysList 實現了 RandomAccess 介面，就表明了他具有快速隨機訪問功能。 RandomAccess 介面只是標識，並不是說 ArraysList 實現 RandomAccess 接口才具有快速隨機訪問功能的！

下面再總結一下 list 的遍歷方式選擇：

實現了RadmoAcces介面的list，優先選擇普通for迴圈，其次foreach,
未實現RadmoAcces介面的ist，優先選擇iterator遍歷（foreach遍歷底層也是通過iterator實現的），大size的資料，千萬不要使用普通for迴圈

補充：資料結構基礎之雙向連結串列

雙向連結串列也叫雙鏈表，是連結串列的一種，它的每個資料結點中都有兩個指標，分別指向直接後繼和直接前驅。所以，從雙向連結串列中的任意一個結點開始，都可以很方便地訪問它的前驅結點和後繼結點。一般我們都構造雙向迴圈連結串列，如下圖所示，同時下圖也是LinkedList 底層使用的是雙向迴圈連結串列資料結構。

ArrayList 與 Vector 區別

Vector類的所有方法都是同步的。可以由兩個執行緒安全地訪問一個Vector物件、但是一個執行緒訪問Vector的話程式碼要在同步操作上耗費大量的時間。

Arraylist不是同步的，所以在不需要保證執行緒安全時時建議使用Arraylist。

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

    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之前的內部結構

JDK1.8之後

相比於之前的版本， JDK1.8之後在解決雜湊衝突時有了較大的變化，當連結串列長度大於閾值（預設為8）時，將連結串列轉化為紅黑樹，以減少搜尋時間。

JDK1.8之後的HashMap底層資料結構

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

推薦閱讀：

HashMap 和 Hashtable 的區別

執行緒是否安全： HashMap 是非執行緒安全的，HashTable 是執行緒安全的；HashTable 內部的方法基本都經過 synchronized 修飾。（如果你要保證執行緒安全的話就使用 ConcurrentHashMap 吧！）；
效率： 因為執行緒安全的問題，HashMap 要比 HashTable 效率高一點。另外，HashTable 基本被淘汰，不要在程式碼中使用它；
對Null key 和Null value的支援： HashMap 中，null 可以作為鍵，這樣的鍵只有一個，可以有一個或多個鍵所對應的值為 null。。但是在 HashTable 中 put 進的鍵值只要有一個 null，直接丟擲 NullPointerException。
初始容量大小和每次擴充容量大小的不同： ①建立時如果不指定容量初始值，Hashtable 預設的初始大小為11，之後每次擴充，容量變為原來的2n+1。HashMap 預設的初始化大小為16。之後每次擴充，容量變為原來的2倍。②建立時如果給定了容量初始值，那麼 Hashtable 會直接使用你給定的大小，而 HashMap 會將其擴充為2的冪次方大小（HashMap 中的tableSizeFor()方法保證，下面給出了原始碼）。也就是說 HashMap 總是使用2的冪作為雜湊表的大小,後面會介紹到為什麼是2的冪次方。
底層資料結構： JDK1.8 以後的 HashMap 在解決雜湊衝突時有了較大的變化，當連結串列長度大於閾值（預設為8）時，將連結串列轉化為紅黑樹，以減少搜尋時間。Hashtable 沒有這樣的機制。

HasMap 中帶有初始容量的建構函式：

    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;
    }

HashMap 的長度為什麼是2的冪次方

為了能讓 HashMap 存取高效，儘量較少碰撞，也就是要儘量把資料分配均勻。我們上面也講到了過了，Hash 值的範圍值-2147483648到2147483648，前後加起來大概40億的對映空間，只要雜湊函式對映得比較均勻鬆散，一般應用是很難出現碰撞的。但問題是一個40億長度的陣列，記憶體是放不下的。所以這個雜湊值是不能直接拿來用的。用之前還要先做對陣列的長度取模運算，得到的餘數才能用來要存放的位置也就是對應的陣列下標。這個陣列下標的計算方法是“ (n - 1) & hash ”。（n代表陣列長度）。這也就解釋了 HashMap 的長度為什麼是2的冪次方。

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

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

HashMap 多執行緒操作導致死迴圈問題

在多執行緒下，進行 put 操作會導致 HashMap 死迴圈，原因在於 HashMap 的擴容 resize()方法。由於擴容是新建一個數組，複製原資料到陣列。由於陣列下標掛有連結串列，所以需要複製連結串列，但是多執行緒操作有可能導致環形連結串列。複製連結串列過程如下:
以下模擬2個執行緒同時擴容。假設，當前 HashMap 的空間為2（臨界值為1），hashcode 分別為 0 和 1，在雜湊地址 0 處有元素 A 和 B，這時候要新增元素 C，C 經過 hash 運算，得到雜湊地址為 1，這時候由於超過了臨界值，空間不夠，需要呼叫 resize 方法進行擴容，那麼在多執行緒條件下，會出現條件競爭，模擬過程如下：

執行緒一：讀取到當前的 HashMap 情況，在準備擴容時，執行緒二介入

執行緒二：讀取 HashMap，進行擴容

執行緒一：繼續執行

這個過程為，先將 A 複製到新的 hash 表中，然後接著複製 B 到鏈頭（A 的前邊：B.next=A），本來 B.next=null，到此也就結束了（跟執行緒二一樣的過程），但是，由於執行緒二擴容的原因，將 B.next=A，所以，這裡繼續複製A，讓 A.next=B，由此，環形連結串列出現：B.next=A; A.next=B

注意：jdk1.8已經解決了死迴圈的問題。

HashSet 和 HashMap 區別

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

HashSet 和 HashMap 區別

ConcurrentHashMap 和 Hashtable 的區別

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

底層資料結構： JDK1.7的 ConcurrentHashMap 底層採用 分段的陣列+連結串列 實現，JDK1.8 採用的資料結構跟HashMap1.8的結構一樣，陣列+連結串列/紅黑二叉樹。Hashtable 和 JDK1.8 之前的 HashMap 的底層資料結構類似都是採用 陣列+連結串列 的形式，陣列是 HashMap 的主體，連結串列則是主要為了解決雜湊衝突而存在的；
實現執行緒安全的方式（重要）： ① 在JDK1.7的時候，ConcurrentHashMap（分段鎖） 對整個桶陣列進行了分割分段(Segment)，每一把鎖只鎖容器其中一部分資料，多執行緒訪問容器裡不同資料段的資料，就不會存在鎖競爭，提高併發訪問率。（預設分配16個Segment，比Hashtable效率提高16倍。）到了 JDK1.8 的時候已經摒棄了Segment的概念，而是直接用 Node 陣列+連結串列+紅黑樹的資料結構來實現，併發控制使用 synchronized 和 CAS 來操作。（JDK1.6以後對 synchronized鎖做了很多優化）整個看起來就像是優化過且執行緒安全的 HashMap，雖然在JDK1.8中還能看到 Segment 的資料結構，但是已經簡化了屬性，只是為了相容舊版本；② Hashtable(同一把鎖) :使用 synchronized 來保證執行緒安全，效率非常低下。當一個執行緒訪問同步方法時，其他執行緒也訪問同步方法，可能會進入阻塞或輪詢狀態，如使用 put 新增元素，另一個執行緒不能使用 put 新增元素，也不能使用 get，競爭會越來越激烈效率越低。

兩者的對比圖：

HashTable:

JDK1.7的ConcurrentHashMap：

JDK1.8的ConcurrentHashMap（TreeBin: 紅黑二叉樹節點
Node: 連結串列節點）：

ConcurrentHashMap執行緒安全的具體實現方式/底層具體實現

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的鎖。

JDK1.8 （上面有示意圖）

ConcurrentHashMap取消了Segment分段鎖，採用CAS和synchronized來保證併發安全。資料結構跟HashMap1.8的結構類似，陣列+連結串列/紅黑二叉樹。

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

集合框架底層資料結構總結

Collection

1. List

Arraylist： Object陣列
Vector： Object陣列
LinkedList： 雙向迴圈連結串列

2. Set

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

Map

HashMap： JDK1.8之前HashMap由陣列+連結串列組成的，陣列是HashMap的主體，連結串列則是主要為了解決雜湊衝突而存在的（“拉鍊法”解決衝突）.JDK1.8以後在解決雜湊衝突時有了較大的變化，當連結串列長度大於閾值（預設為8）時，將連結串列轉化為紅黑樹，以減少搜尋時間
LinkedHashMap: LinkedHashMap 繼承自 HashMap，所以它的底層仍然是基於拉鍊式雜湊結構即由陣列和連結串列或紅黑樹組成。另外，LinkedHashMap 在上面結構的基礎上，增加了一條雙向連結串列，使得上面的結構可以保持鍵值對的插入順序。同時通過對連結串列進行相應的操作，實現了訪問順序相關邏輯。詳細可以檢視：《LinkedHashMap 原始碼詳細分析（JDK1.8）》
HashTable: 陣列+連結串列組成的，陣列是 HashMap 的主體，連結串列則是主要為了解決雜湊衝突而存在的
TreeMap: 紅黑樹（自平衡的排序二叉樹）

java集合框架（二）

Arraylist 與 LinkedList 異同

補充：資料結構基礎之雙向連結串列

ArrayList 與 Vector 區別

HashMap的底層實現

JDK1.8之前

JDK1.8之後

HashMap 和 Hashtable 的區別

HashMap 的長度為什麼是2的冪次方

HashMap 多執行緒操作導致死迴圈問題

HashSet 和 HashMap 區別

ConcurrentHashMap 和 Hashtable 的區別

ConcurrentHashMap執行緒安全的具體實現方式/底層具體實現

JDK1.7（上面有示意圖）

JDK1.8 （上面有示意圖）

集合框架底層資料結構總結

Collection

1. List

2. Set

Map

推薦閱讀：

相關推薦