Java集合大全

扁豆一號 發表於 2020-09-13

集合也是一種容器,在開發過程中的應用數不勝數,除了常見的HashMap、ArrayList、LinkedList和HashSet等等,瞭解這些集合API的同時,也應該瞭解這些集合內部發生了什麼事情,這樣就不再是集合提供了什麼功能給我們用,而是我們選擇了它的什麼功能。

一、Java集合架構圖

Java集合大全

1.集合框架提供兩個遍歷介面:Iterator和ListIterator,後者是前者的優化版,支援在集合任意一個位置進行前後雙向遍歷;
2.整個集合框架分為兩個型別:Collection和Map,前者是一個容器,儲存一系列的物件;後者是鍵值對<key, value>,儲存一系列的鍵值對;
3.在現有的集合框架體系下,衍生出四種具體集合型別:Map、Set、List、Queue;
4.Map儲存<key,value>鍵值對,查詢元素時通過key查詢value;
5.Set內部儲存一系列不可重複的物件,且是一個無序集合,物件排列順序不一;
6.List內部儲存一系列可重複的物件,是一個有序集合,物件按插入順序排列;
7.Queue是一個佇列容器,其特性與List相同,但只能從隊頭和隊尾操作元素;
8.JDK 為集合的各種操作提供了兩個工具類Collections和Arrays;

9.四種具體型別的集合,內部會再衍生許多不同特性的集合子類,根據不通的應用場景選擇使用的集合;

二、集合的迭代器

目前Java裡有三個迭代器:Iterator Iterable ListIterator。

1. 首先看Iterator介面:

public interface Iterator<E> {
    boolean hasNext();
    E next();
    void remove();
}

提供的API介面含義如下:
hasNext():判斷集合中是否還有下一個物件。
next():返回集合中的下一個物件,並將訪問指標移動一位。
remove():刪除集合中呼叫next()方法返回的物件。
在JDK早期版本里,遍歷集合的方式只有一種,那就是通過Iterator迭代器操作,具體例項如下:

List<Integer> list = new ArrayList<>();
list.add(10);
list.add(20);
list.add(30);
Iterator iter = list.iterator();
while (iter.hasNext()) {
    Integer next = iter.next();
    System.out.println(next);
    if (next == 20) {
      iter.remove(); 
    }
}

2. Iterable介面

public interface Iterable<T> {
    Iterator<T> iterator();
    // since JDK 1.8
    default void forEach(Consumer<? super T> action) {
        Objects.requireNonNull(action);
        for (T t : this) {
            action.accept(t);
        }
    }
    // since JDK 1.8
    default Spliterator<T> spliterator() {
       return Spliterators.spliteratorUnknownSize(iterator(), 0);
    }
}

 Iterable介面裡面提供了一個Iterator()方法返回迭代器,因此實現了Iterable介面的集合依舊可以使用迭代器遍歷和操作集合中的物件。在 JDK 1.8中,Iterable介面新增了一個方法forEach(),它允許使用增強 for 迴圈遍歷物件。

    為什麼要設計兩個介面Iterable和Iterator?Iterator介面的保留可以讓子類去實現自己的迭代器,而Iterable介面更加關注於for-each的增強語法。

3. ListIterator

  ListIterator繼承 Iterator 介面,僅存在於 List 集合之中,通過呼叫方法可以返回起始下標為 index的迭代器。ListIterator 中有幾個重要方法,大多數方法與 Iterator 中定義的含義相同,此外根據返回的迭代器,且可以實現雙向遍歷。

public interface ListIterator<E> extends Iterator<E> {
    boolean hasNext();
    E next();
    boolean hasPrevious();
    E previous();
    int nextIndex();
    int previousIndex();
    void remove();
    // 替換當前下標的元素,即訪問過的最後一個元素
    void set(E e);
    void add(E e);
}

三、Map和Collection介面

  Map介面和Collection介面是Java的集合框架中的兩個重要門派,Collection儲存的是集合元素本身,Map儲存的是<key,value>鍵值對,但是部分Collection子類使用了Map來實現的。例如:HashSet底層使用了HashMap,TreeSet底層使用了TreeMap,LinkedHashSet底層使用了LinkedHashMap

Java集合大全

Map介面的資料結構是<key, value>形式,key 對映value,一個key對應一個value,key不可重複,value可重複。Map介面細分為不同的種類:

    SortedMap介面:該類對映可以對<key, value>按照自己的規則進行排序,具體實現有 TreeMap
    AbsractMap抽象類:它為子類提供好一些通用的API實現,所有的具體Map如HashMap都會繼承它


Collection介面提供了所有集合的通用方法(注意這裡不包括Map):
    新增方法:add(E e) / addAll(Collection<? extends E> var1)/ addAll(int index, Collection<? extends E> var1)  
    查詢方法:contains(Object var1) / containsAll(Collection<?> var1)/
    查詢集合自身資訊:size() / isEmpty()
    刪除方法:remove(O o)/removeAll(Collection<?> var1)/求交集:retainAll(Collection c)

    ... ...

Collection介面將集合細分為不同的種類:

    Set介面:一個不允許儲存重複元素的無序集合,具體實現有HashSet / TreeSet···
    List介面:一個可儲存重複元素的有序集合,具體實現有ArrayList / LinkedList···
    Queue介面:一個可儲存重複元素的佇列,具體實現有PriorityQueue / ArrayDeque···

1. Map介面詳解

Map 體系下主要分為 AbstractMap 和 SortedMap兩類集合
        AbstractMap是對Map介面的擴充套件,定義了普通Map集合具有的通用方法,可避免子類重複編寫大量相同程式碼,子類繼承 AbstractMap 後可重寫它的方法,並實現額外邏輯,對外可提供更多的功能。
        SortedMap介面定義了Map具有排序行為,當子類實現它時,必須重寫所有方法,對外提供排序功能。

1.1 HashMap

        HashMap 是一個最通用的利用雜湊表儲存元素的集合,有元素加入HashMap時,會將key的雜湊值轉換為陣列的索引下標確定存放位置,在查詢元素時,根據key的雜湊地址轉換成陣列的索引下標確定查詢位置。
    HashMap 底層是用陣列 + 連結串列 + 紅黑樹這三種資料結構實現,是非執行緒安全的集合。

Java集合大全

加入元素髮生雜湊衝突時,HashMap會將相同地址的元素連成一條連結串列,若連結串列長度大於8,且陣列長度大於64會轉換成紅黑樹資料結構。

關於 HashMap 的簡要總結:
    1. 它是集合中最常用的Map集合型別,底層由陣列 + 連結串列 + 紅黑樹組成;
    2. HashMap不是執行緒安全的;
    3. 插入元素時,通過計算元素雜湊值,通過雜湊對映函式轉換為陣列下標;查詢元素時,通過雜湊對映函式得到陣列下標定位元素的位置。

1.2 LinkedHashMap

LinkedHashMap可以看作是 HashMap 和 LinkedList 的結合:它是在 HashMap 的基礎上新增了一條雙向連結串列,預設儲存各個元素的插入順序,但由於這條雙向連結串列,使得 LinkedHashMap 可以實現 LRU快取淘汰策略,因為我們可以設定這條雙向連結串列按照元素的訪問次序進行排序

// 頭節點
transient LinkedHashMap.Entry<K, V> head;
// 尾結點
transient LinkedHashMap.Entry<K, V> tail;

利用 LinkedHashMap 可以實現 LRU 快取淘汰策略,因為它提供了一個方法:

protected boolean removeEldestEntry(java.util.Map.Entry<K, V> eldest) {
    return false;
}

該方法可以移除最靠近連結串列頭部的一個節點,而在get(key)方法原始碼如下,其作用是挪動結點的位置:

public V get(Object key) {
   Node<K,V> e;
   if ((e = getNode(hash(key), key)) == null)
      return null;
   if (accessOrder)
      afterNodeAccess(e);
   return e.value;
}

只要呼叫了get(key)且accessOrder = true,則會將該節點更新到連結串列尾部,具體的邏輯在afterNodeAccess()中,原始碼如下:

void afterNodeAccess(Node<K,V> e) { // move node to last
  LinkedHashMap.Entry<K,V> last;
  if (accessOrder && (last = tail) != e) {
    LinkedHashMap.Entry<K,V> p = (LinkedHashMap.Entry<K,V>)e, b = p.before, a = p.after;
    p.after = null;
    if (b == null) head = a;
      else b.after = a;
    if (a != null) a.before = b;
    else last = b;
    if (last == null) head = p;
    else {
      p.before = last;
      last.after = p;
     }
    tail = p;
    ++modCount;
  }
}

指定accessOrder = true,可以設定連結串列按照訪問順序排列,通過提供的構造器可以設定accessOrder。

public LinkedHashMap(int initialCapacity, float loadFactor, boolean accessOrder) {
    super(initialCapacity, loadFactor);
    this.accessOrder = accessOrder;
}

重寫removeEldestEntry()方法,內部定義邏輯,通常是判斷容量是否達到上限,若是則執行淘汰。

關於 LinkedHashMap 總結兩點:
    1. 底層維護了一條雙向連結串列,繼承了 HashMap,所以不是執行緒安全的
    2. LinkedHashMap 可實現LRU快取淘汰策略,其原理是通過設定accessOrder為true並重寫removeEldestEntry方法定義淘汰元素時需滿足的條件。

1.3 TreeMap

TreeMap 是 SortedMap 的子類,所以它具有排序功能,是基於紅黑樹資料實現的,每個鍵值對<key, value>都是一個結點,預設情況下按照key自然排序,另一種是可以通過傳入定製的Comparator進行自定義規則排序。

// 按照 key 自然排序,Integer 的自然排序是升序
TreeMap<Integer, Object> naturalSort = new TreeMap<>();
// 定製排序,按照 key 降序排序
TreeMap<Integer, Object> customSort = new TreeMap<>((o1, o2) -> Integer.compare(o2, o1));

Java集合大全

圖中紅黑樹的每一個節點都是一個Entry,在這裡不標明 key 和 value 了,這些元素都是已按照key排好序了,整個資料結構都是保持著有序狀態!
關於自然排序與定製排序:
自然排序:要求key必須實現Comparable介面。
由於Integer類實現了Comparable 介面,按照自然排序規則是按照key從小到大排序。

TreeMap<Integer, String> treeMap = new TreeMap<>();
treeMap.put(2, "貳");
treeMap.put(1, "壹");
System.out.print(treeMap);
// {1=壹, 2=貳}

定製排序:在初始化 TreeMap 時傳入新的Comparator,不要求key實現 Comparable 介面

TreeMap<Integer, String> treeMap = new TreeMap<>((o1, o2) -> Integer.compare(o2, o1));
treeMap.put(1, "壹");
treeMap.put(2, "貳");
treeMap.put(4, "肆");
treeMap.put(3, "叄");
System.out.println(treeMap);
// {4=肆, 3=叄, 2=貳, 1=壹}

關於 TreeMap 主要介紹了三點:
        1. 它底層是由紅黑樹實現的,操作的時間複雜度為O(logN);
        2. TreeMap 可以對key進行自然排序或者自定義排序,自定義排序時需要傳入Comparator,而自然排序要求key實現了Comparable介面;
        3. TreeMap 不是執行緒安全的。

1.4 WeakHashMap

        WeakHashMap底層儲存的元素的資料結構是陣列 + 連結串列,沒有紅黑樹。日常開發中用的很少,是基於Map實現,Entry中鍵在每一次垃圾回收都會被清除,適合用於短暫訪問或訪問一次的元素,快取在WeakHashMap中,並儘早地把它回收掉。

public class WeakHashMap<K, V> extends AbstractMap<K, V> implements Map<K, V> {
}

  當Entry被GC時,WeakHashMap 是如何感知到某個元素被回收的呢?

        在 WeakHashMap 內部維護了一個引用佇列queue:

private final ReferenceQueue<Object> queue = new ReferenceQueue<>();

queue裡包含了所有被GC掉的key,當JVM開啟GC後,如果回收掉WeakHashMap中的key,會將key放入queue 中,在expungeStaleEntries()中遍歷 queue,把queue中的所有key拿出來,並在WeakHashMap中刪除掉,以達到同步。

Java集合大全

圖中被虛線標識的元素將會在下一次訪問 WeakHashMap 時被刪除,WeakHashMap 內部會做好一系列的調整工作,所以佇列的作用是標誌已經被GC掉的元素。
關於 WeakHashMap 需要注意三點:
        1. 它的鍵是一種弱鍵,放入 WeakHashMap 時,隨時會被回收掉,所以不能確保某次訪問元素一定存在;
        2. 它依賴普通的Map進行實現,是一個非執行緒安全的集合;
        3. WeakHashMap 通常作為快取使用,適合儲存那些只需訪問一次、或只需儲存短暫時間的鍵值對。

1.5 HashTable

Hashtable底層儲存結構是陣列+連結串列,是一個執行緒安全的集合。當連結串列過長時,查詢效率過低,會長時間鎖住Hashtable,所以在併發環境下,效能很差,現在基本上被淘汰了,也很少用了。執行緒安全,它所有的方法都被加上了 synchronized 關鍵字。HashTable 預設長度為 11,負載因子為 0.75F,即元素個數達到陣列長度的 75% 時,會進行一次擴容,每次擴容為原來陣列長度的 2 倍

2. Collection 集合體系詳解

Collection 集合體系的頂層介面就是Collection,它規定了該集合下的一系列方法。
該集合下可以分為三大類集合:List,Set和Queue
    Set介面:不可儲存重複的元素,且任何操作均需要通過雜湊函式對映到集合內部定位元素,集合內部元素預設無序。
    List介面:可儲存重複的元素,且集合內部的元素按照元素插入的順序有序排列,可以通過索引訪問元素。
    Queue介面:是以佇列作為儲存結構,集合內部的元素有序排列,僅可以操作頭結點元素,無法訪問佇列中間的元素。
上面三個介面是最普通,最抽象的實現,而在各個集合介面內部,還會有更加具體的表現,衍生出各種不同的額外功能,使開發者能夠對比各個集合的優勢,擇優使用。

Java集合大全

2.1 Set介面

Set介面繼承了Collection介面,是一個不包括重複元素的集合,更確切地說,Set 中任意兩個元素不會出現 o1.equals(o2),而且 Set 至多隻能儲存一個 NULL 值元素。

Java集合大全

在Set集合體系中,我們需要著重關注兩點:
    存入可變元素時,必須非常小心,因為任意時候元素狀態的改變都有不可能使得 Set 內部出現兩個相等的元素,即 o1.equals(o2) = true,所以一般不要更改存入 Set 中的元素,否則將會破壞了 equals() 的作用!
    Set 的最大作用就是判重,在專案中最大的作用也是判重!

HashSet

HashSet 底層藉助 HashMap 實現,我們可以觀察它的多個構造方法,本質上都是 new 一個 HashMap

public class HashSet<E> extends AbstractSet<E> implements Set<E>, Cloneable, Serializable {
    public HashSet() {
        this.map = new HashMap();
    }
    public HashSet(int initialCapacity, float loadFactor) {
        this.map = new HashMap(initialCapacity, loadFactor);
    }
    public HashSet(int initialCapacity) {
        this.map = new HashMap(initialCapacity);
    }
}

我們可以觀察add()方法和remove()方法是如何將 HashSet 的操作嫁接到 HashMap 的。

private static final Object PRESENT = new Object(); 
public boolean add(E e) { 
   return this.map.put(e, PRESENT) == null; 
} 
public boolean remove(Object o) { 
   return this.map.remove(o) == PRESENT; 
}

HashMap 的 value 值,使用HashSet的開發者只需關注於需要插入的 key,遮蔽了 HashMap 的 value

HashSet 在 HashMap 基礎上實現,所以很多地方可以聯絡到 HashMap:
    底層資料結構:HashSet 也是採用陣列 + 連結串列 + 紅黑樹實現
    執行緒安全性:由於採用 HashMap 實現,而 HashMap 本身執行緒不安全,在HashSet 中沒有新增額外的同步策略,所以 HashSet 也執行緒不安全
    存入 HashSet 的物件的狀態最好不要發生變化,因為有可能改變狀態後,在集合內部出現兩個元素o1.equals(o2),破壞了 equals()的語義。

LinkedHashSet

LinkedHashSet 的程式碼少的可憐,如下:  

public class LinkedHashSet<E>
    extends HashSet<E>
    implements Set<E>, Cloneable, java.io.Serializable {

    private static final long serialVersionUID = -2851667679971038690L;
    public LinkedHashSet(int initialCapacity, float loadFactor) {
        super(initialCapacity, loadFactor, true);
    }
    public LinkedHashSet(int initialCapacity) {
        super(initialCapacity, .75f, true);
    }
    public LinkedHashSet() {
        super(16, .75f, true);
    }
    public LinkedHashSet(Collection<? extends E> c) {
        super(Math.max(2*c.size(), 11), .75f, true);
        addAll(c);
    }
    @Override
    public Spliterator<E> spliterator() {
        return Spliterators.spliterator(this, Spliterator.DISTINCT | Spliterator.ORDERED);
    }
}

關於 LinkedHashSet 需要注意幾個地方:
        它繼承了 HashSet,而 HashSet 預設是採用 HashMap 儲存資料的,但是 LinkedHashSet 呼叫父類構造方法初始化 map 時是 LinkedHashMap 而不是 HashMap,這個要額外注意一下;
        由於 LinkedHashMap 不是執行緒安全的,且在 LinkedHashSet 中沒有新增額外的同步策略,所以 LinkedHashSet 集合也不是執行緒安全的。

TreeMap

TreeSet 是基於 TreeMap 的實現,所以儲存的元素是有序的,底層的資料結構是陣列 + 紅黑樹。

Java集合大全

而元素的排列順序有2種,和 TreeMap 相同:自然排序和定製排序,常用的構造方法已經在下面展示出來了,TreeSet 預設按照自然排序,如果需要定製排序,需要傳入Comparator。

public TreeSet() { 
    this(new TreeMap<E,Object>());
}
public TreeSet(Comparator<? super E> comparator) {
    this(new TreeMap<>(comparator));
}

對 TreeSet 介紹了它的主要實現方式和應用場景,有幾個值得注意的點。
    TreeSet 的所有操作都會轉換為對 TreeMap 的操作,TreeMap 採用紅黑樹實現,任意操作的平均時間複雜度為 O(logN);
    TreeSet 是一個執行緒不安全的集合;
    TreeSet 常應用於對不重複的元素定製排序,例如玩家戰力排行榜。

2.2 List

List 介面直接繼承 Collection 介面,它定義為可以儲存重複元素的集合,並且元素按照插入順序有序排列,且可以通過索引訪問指定位置的元素。常見的實現有:ArrayList、LinkedList、Vector和Stack。

AbstractList 和 AbstractSequentialList

AbstractList 抽象類實現了 List 介面,其內部實現了所有的 List 都需具備的功能,子類可以專注於實現自己具體的操作邏輯。

AbstractSequentialList 抽象類繼承了 AbstractList,在原基礎上限制了訪問元素的順序只能夠按照順序訪問,而不支援隨機訪問,如果需要滿足隨機訪問的特性,則繼承 AbstractList。子類 LinkedList 使用連結串列實現,所以僅能支援順序訪問,顧繼承了 AbstractSequentialList而不是 AbstractList。

// 查詢元素 o 第一次出現的索引位置
public int indexOf(Object o)
// 查詢元素 o 最後一次出現的索引位置
public int lastIndexOf(Object o)
//···

Vector 和 Stack

Vector 在現在已經是一種過時的集合了,包括繼承它的 Stack 集合也如此,它們被淘汰的原因都是因為效能低下。

JDK 1.0 時代,ArrayList 還沒誕生,大家都是使用 Vector 集合,但由於 Vector 的每個操作都被 synchronized 關鍵字修飾,即使線上程安全的情況下,仍然進行無意義的加鎖與釋放鎖,造成額外的效能開銷,做了無用功。

在 JDK 1.2 時,Collection 家族出現了,它提供了大量高效能、適用於不同場合的集合,而 Vector 也是其中一員,但由於 Vector 在每個方法上都加了鎖,由於需要相容許多老的專案,很難在此基礎上優化Vector了,所以漸漸地也就被歷史淘汰了。
現在,線上程安全的情況下,不需要選用 Vector 集合,取而代之的是 ArrayList 集合;在併發環境下,出現了 CopyOnWriteArrayList,Vector 完全被棄用了。

Stack是一種後入先出(LIFO)型的集合容器,如圖中所示,大雄是最後一個進入容器的,top指標指向大雄,那麼彈出元素時,大雄也是第一個被彈出去的。
Stack 繼承了 Vector 類,提供了棧頂的壓入元素操作(push)和彈出元素操作(pop),以及檢視棧頂元素的方法(peek)等等,但由於繼承了 Vector,正所謂跟錯老大沒福報,Stack 也漸漸被淘汰了。
取而代之的是後起之秀 Deque介面,其實現有 ArrayDeque,該資料結構更加完善、可靠性更好,依靠佇列也可以實現LIFO的棧操作,所以優先選擇 ArrayDeque 實現棧。

ArrayList

ArrayList 以陣列作為儲存結構,它是執行緒不安全的集合;具有查詢快、在陣列中間或頭部增刪慢的特點,所以它除了執行緒不安全這一點,其餘可以替代Vector,而且執行緒安全的 ArrayList 可以使用 CopyOnWriteArrayList代替 Vector。

Java集合大全

關於 ArrayList 有幾個重要的點需要注意的:
    具備隨機訪問特點,訪問元素的效率較高,ArrayList 在頻繁插入、刪除集合元素的場景下效率較低。
    底層資料結構:ArrayList 底層使用陣列作為儲存結構,具備查詢快、增刪慢的特點
    執行緒安全性:ArrayList 是執行緒不安全的集合
    ArrayList 首次擴容後的長度為 10,呼叫 add() 時需要計算容器的最小容量。可以看到如果陣列elementData為空陣列,會將最小容量設定為10,之後會將陣列長度完成首次擴容到 10。

// new ArrayList 時的預設空陣列
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
// 預設容量
private static final int DEFAULT_CAPACITY = 10;
// 計算該容器應該滿足的最小容量
private static int calculateCapacity(Object[] elementData, int minCapacity) {
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        return Math.max(DEFAULT_CAPACITY, minCapacity);
    }
    return minCapacity;
}

集合從第二次擴容開始,陣列長度將擴容為原來的 1.5 倍,即:newLength = oldLength * 1.5

private void grow(int minCapacity) {
    // overflow-conscious code
    int oldCapacity = elementData.length;
    int newCapacity = oldCapacity + (oldCapacity >> 1);
    if (newCapacity - minCapacity < 0)
        newCapacity = minCapacity;
    if (newCapacity - MAX_ARRAY_SIZE > 0)
        newCapacity = hugeCapacity(minCapacity);
    // minCapacity is usually close to size, so this is a win:
    elementData = Arrays.copyOf(elementData, newCapacity);
}

LinkedList

LinkedList 底層採用雙向連結串列資料結構儲存元素,由於連結串列的記憶體地址非連續,所以它不具備隨機訪問的特點,但由於它利用指標連線各個元素,所以插入、刪除元素只需要操作指標,不需要移動元素,故具有增刪快、查詢慢的特點。它也是一個非執行緒安全的集合。

Java集合大全

由於以雙向連結串列作為資料結構,它是執行緒不安全的集合;儲存的每個節點稱為一個Node,下圖可以看到 Node 中儲存了next和prev指標,item是該節點的值。在插入和刪除時,時間複雜度都保持為 O(1)

關於 LinkedList,除了它是以連結串列實現的集合外,還有一些特殊的特性需要注意的。
    優勢:LinkedList 底層沒有擴容機制,使用雙向連結串列儲存元素,所以插入和刪除元素效率較高,適用於頻繁操作元素的場景
    劣勢:LinkedList 不具備隨機訪問的特點,查詢某個元素只能從 head 或 tail 指標一個一個比較,所以查詢中間的元素時效率很低
    查詢優化:LinkedList 查詢某個下標 index 的元素時做了優化,若 index > (size / 2),則從 head 往後查詢,否則從 tail 開始往前查詢,程式碼如下所示:

LinkedList.Node<E> node(int index) {
    LinkedList.Node x;
    int i;
    if (index < this.size >> 1) { // 查詢的下標處於連結串列前半部分則從頭找
        x = this.first;
        for(i = 0; i < index; ++i) { x = x.next; }
        return x;
    } else { // 查詢的下標處於陣列的後半部分則從尾開始找
        x = this.last;
        for(i = this.size - 1; i > index; --i) { x = x.prev; }
        return x;
    }
}

雙端佇列:使用雙端連結串列實現,並且實現了 Deque 介面,使得 LinkedList 可以用作雙端佇列。下圖可以看到 Node 是集合中的元素,提供了前驅指標和後繼指標,還提供了一系列操作頭結點和尾結點的方法,具有雙端佇列的特性。

LinkedList 集合最讓人樹枝的是它的連結串列結構,但是我們同時也要注意它是一個雙端佇列型的集合。

Deque<Object> deque = new LinkedList<>();

Queue

Queue佇列,在 JDK 中有兩種不同型別的集合實現:單向佇列(AbstractQueue) 和 雙端佇列(Deque)。

Java集合大全

Queue 中提供了兩套增加、刪除元素的 API,當插入或刪除元素失敗時,會有兩種不同的失敗處理策略。

方法及失敗策略 插入方法 刪除方法  查詢方法
 丟擲異常  add()  remove()  get()
 返回預設值  offer()  poll()  peek()

選取哪種方法的決定因素:插入和刪除元素失敗時,希望丟擲異常還是返回布林值,

add() 和 offer() 對比:
在佇列長度大小確定的場景下,佇列放滿元素後,新增下一個元素時,add() 會丟擲 IllegalStateException異常,而 offer() 會返回 false 。
remove() 和 poll() 對比:
在佇列為空的場景下, remove() 會丟擲 NoSuchElementException異常,而 poll() 則返回 null 。
get()和peek()對比:
在佇列為空的情況下,get()會丟擲NoSuchElementException異常,而peek()則返回null。

Deque

Deque 介面的實現非常好理解:從單向佇列演變為雙向佇列,內部額外提供雙向佇列的操作方法即可:

Deque介面額外提供了針對佇列的頭結點和尾結點操作的方法,而插入、刪除方法同樣也提供了兩套不同的失敗策略。除了add()和offer(),remove()和poll()以外,還有get()和peek()出現了不同的策略

ArrayDeque

使用陣列實現的雙端佇列,它是無界的雙端佇列,最小的容量是8(JDK 1.8)。在 JDK 11 看到它預設容量已經是 16了。ArrayDeque 在日常使用得不多,值得注意的是它與 LinkedList 的對比:LinkedList 採用連結串列實現雙端佇列,而 ArrayDeque 使用陣列實現雙端佇列。

/**
 * The minimum capacity that we\'ll use for a newly created deque.
 * Must be a power of 2.
 */
private static final int MIN_INITIAL_CAPACITY = 8;

由於雙端佇列只能在頭部和尾部操作元素,所以刪除元素和插入元素的時間複雜度大部分都穩定在 O(1) ,除非在擴容時會涉及到元素的批量複製操作。但是在大多數情況下,使用它時應該指定一個大概的陣列長度,避免頻繁的擴容。

個人觀點:連結串列的插入、刪除操作涉及到指標的操作,我個人認為作者是覺得陣列下標的移動要比指標的操作要廉價,而且陣列採用連續的記憶體地址空間,而連結串列元素的記憶體地址是不連續的,所以陣列操作元素的效率在定址上會比連結串列要快。請批判看待觀點。

PriorityQueue

PriorityQueue 基於優先順序堆實現的優先順序佇列,而堆是採用陣列實現:

/**
 * Priority queue represented as a balanced binary heap: the two
 * children of queue[n] are queue[2*n+1] and queue[2*(n+1)].  The
 * priority queue is ordered by comparator, or by the elements\'
 * natural ordering, if comparator is null: For each node n in the
 * heap and each descendant d of n, n <= d.  The element with the
 * lowest value is in queue[0], assuming the queue is nonempty.
 */
transient Object[] queue; // non-private to simplify nested class access

文件中的描述告訴我們:該陣列中的元素通過傳入 Comparator 進行定製排序,如果不傳入Comparator時,則按照元素本身自然排序,但要求元素實現了Comparable介面,所以 PriorityQueue 不允許儲存 NULL 元素。
PriorityQueue 應用場景:元素本身具有優先順序,需要按照優先順序處理元素

        例如VIP玩家與普通玩家,VIP 等級越高的玩家越優先安排玩耍,減少VIP玩家流失。

public static void main(String[] args) {
    Player vip1 = new Player("范仲淹", 1);
    Player vip3 = new Player("竇憲", 2);
    Player vip4 = new Player("弘曆", 4);
    Player vip2 = new Player("蘇定方", 1);
    Player p1 = new Player("王陽明", 0);
    Player p2 = new Player("趙孟頫", 0);
    // 根據VIP等級降序
    PriorityQueue<Player> queue = new PriorityQueue<>((o1, o2) ->  o2.getScore().compareTo(o1.getScore()));
    queue.add(vip1);queue.add(vip4);queue.add(vip3);
    queue.add(p1);queue.add(p2);queue.add(vip2);
    while (!queue.isEmpty()) {
        Player s1 = queue.poll();
        System.out.println(s1.getName() + "進入遊戲; " + "VIP等級: " + s1.getScore());
    }
}
 public static class Player implements Comparable<Player> {
     private String name;
     private Integer score;
     public Player(String name, Integer score) {
         this.name = name;
         this.score = score;
     }
     @Override
     public int compareTo(Player o) {
         return this.score.compareTo(o.getScore());
     }
 }

結果如下:

弘曆進入遊戲; VIP等級: 4
竇憲進入遊戲; VIP等級: 2
范仲淹進入遊戲; VIP等級: 1
蘇定方進入遊戲; VIP等級: 1
王陽明進入遊戲; VIP等級: 0
趙孟頫進入遊戲; VIP等級: 0

VIP 等級越高(優先順序越高)就越優先安排玩(優先處理),類似這種有優先順序的場景還有非常多,各位可以發揮自己的想象力。

PriorityQueue 總結:
       PriorityQueue 是基於優先順序堆實現的優先順序佇列,而堆是用陣列維護的
       PriorityQueue 適用於元素按優先順序處理的業務場景,例如使用者在請求人工客服需要排隊時,根據使用者的VIP等級進行 插隊 處理,等級越高,越先安排客服。

四、下面來個大總結:

資料型別 插入刪除的時間複雜度 查詢時間複雜度 底層資料結構 是否執行緒安全 
 Vector  O(N)  O(1)  陣列  是
 ArrayList  O(N)  O(1)  陣列  否
 LinkedList  O(1)    O(N)  雙向連結串列  否
 HashSet  O(1)    O(1)  陣列+連結串列+紅黑樹  否
 TreeSet  O(LogN)  O(LogN)  紅黑樹  否
 LingkedHashSet  O(1)  O(1)~ O(N)  陣列+連結串列+紅黑樹  否
 ArrayDeque  O(N)  O(1)  陣列  否
 PriorityQueue  O(LogN)  O(LogN)  堆(陣列)  否
 HashMap  O(1)~ O(N)  O(1)~ O(N)  陣列+連結串列+紅黑樹  否
 TreeMap  O(LogN)  O(LogN)   陣列+紅黑樹  否
 HashTable  O(1) / O(N)  O(1) / O(N)    陣列+連結串列  是