java.util.concurrent
類別 LinkedBlockingDeque<E>

java.lang.Object
  java.util.AbstractCollection<E>
      java.util.AbstractQueue<E>
          java.util.concurrent.LinkedBlockingDeque<E>

型別參數：

E - 保存在此 collection 中的元素型別

所有已實作的介面：

Serializable, Iterable<E>, Collection<E>, BlockingDeque<E>, BlockingQueue<E>, Deque<E>, Queue<E>

public class LinkedBlockingDeque<E>
extends AbstractQueue<E>
implements BlockingDeque<E>, Serializable

一個基於已連接節點的、任選範圍的阻塞雙端佇列。

可選的容量範圍建構子參數是一種防止過度膨脹的方式。如果未指定容量，那麼容量將等於 Integer.MAX_VALUE。只要插入元素不會使雙端佇列超出容量，每次插入後都將動態地創建連接節點。

大多數操作都以固定時間運行（不計阻塞消耗的時間）。異常包括 remove、removeFirstOccurrence、removeLastOccurrence、contains、iterator.remove() 以及批量操作，它們均以線性時間運行。

此類別及其迭代器實作 Collection 和 Iterator 介面的所有可選 方法。

此類別是 Java Collections Framework 的成員。

從以下版本開始：

1.6

另請參見：

序列化表格

建構子摘要

LinkedBlockingDeque()
創建一個容量為 Integer.MAX_VALUE 的 LinkedBlockingDeque。

LinkedBlockingDeque(Collection<? extends E> c)
創建一個容量為 Integer.MAX_VALUE 的 LinkedBlockingDeque，最初包含給定 collection 的元素，以該 collection 迭代器的遍歷順序添加。

LinkedBlockingDeque(int capacity)
創建一個具有給定（固定）容量的 LinkedBlockingDeque。

方法摘要

boolean	add(E e) 在不違反容量限制的情況下，將指定的元素插入此雙端佇列的末尾。
void	addFirst(E e) 如果立即可行且不違反容量限制，則將指定的元素插入此雙端佇列的開頭；如果當前沒有空間可用，則拋出 IllegalStateException。
void	addLast(E e) 如果立即可行且不違反容量限制，則將指定的元素插入此雙端佇列的末尾；如果當前沒有空間可用，則拋出 IllegalStateException。
void	clear() 以原子方式 (atomically) 從此雙端佇列移除所有元素。
boolean	contains(Object o) 如果此雙端佇列包含指定的元素，則返回 true。
Iterator<E>	descendingIterator() 返回在此雙端佇列的元素上以逆向連續順序進行迭代的迭代器。
int	drainTo(Collection<? super E> c) 移除此佇列中所有可用的元素，並將它們添加到給定 collection 中。
int	drainTo(Collection<? super E> c, int maxElements) 最多從此佇列中移除給定數量的可用元素，並將這些元素添加到給定 collection 中。
E	element() 獲取但不移除此雙端佇列表示的佇列的頭部。
E	getFirst() 獲取，但不移除此雙端佇列的第一個元素。
E	getLast() 獲取，但不移除此雙端佇列的最後一個元素。
Iterator<E>	iterator() 返回在此雙端佇列元素上以恰當順序進行迭代的迭代器。
boolean	offer(E e) 如果立即可行且不違反容量限制，則將指定的元素插入此雙端佇列表示的佇列中（即此雙端佇列的尾部），並在成功時返回 true；如果當前沒有空間可用，則返回 false。
boolean	offer(E e, long timeout, TimeUnit unit) 將指定的元素插入此雙端佇列表示的佇列中（即此雙端佇列的尾部），必要時將在指定的等待時間內一直等待可用空間。
boolean	offerFirst(E e) 如果立即可行且不違反容量限制，則將指定的元素插入此雙端佇列的開頭，並在成功時返回 true；如果當前沒有空間可用，則返回 false。
boolean	offerFirst(E e, long timeout, TimeUnit unit) 將指定的元素插入此雙端佇列的開頭，必要時將在指定的等待時間內等待可用空間。
boolean	offerLast(E e) 如果立即可行且不違反容量限制，則將指定的元素插入此雙端佇列的末尾，並在成功時返回 true；如果當前沒有空間可用，則返回 false。
boolean	offerLast(E e, long timeout, TimeUnit unit) 將指定的元素插入此雙端佇列的末尾，必要時將在指定的等待時間內等待可用空間。
E	peek() 獲取但不移除此雙端佇列表示的佇列的頭部（即此雙端佇列的第一個元素）；如果此雙端佇列為空，則返回 null。
E	peekFirst() 獲取，但不移除此雙端佇列的第一個元素；如果此雙端佇列為空，則返回 null。
E	peekLast() 獲取，但不移除此雙端佇列的最後一個元素；如果此雙端佇列為空，則返回 null。
E	poll() 獲取並移除此雙端佇列表示的佇列的頭部（即此雙端佇列的第一個元素）；如果此雙端佇列為空，則返回 null。
E	poll(long timeout, TimeUnit unit) 獲取並移除此雙端佇列表示的佇列的頭部（即此雙端佇列的第一個元素），如有必要將在指定的等待時間內等待可用元素。
E	pollFirst() 獲取並移除此雙端佇列的第一個元素；如果此雙端佇列為空，則返回 null。
E	pollFirst(long timeout, TimeUnit unit) 獲取並移除此雙端佇列的第一個元素，必要時將在指定的等待時間等待可用元素。
E	pollLast() 獲取並移除此雙端佇列的最後一個元素；如果此雙端佇列為空，則返回 null。
E	pollLast(long timeout, TimeUnit unit) 獲取並移除此雙端佇列的最後一個元素，必要時將在指定的等待時間內等待可用元素。
E	pop() 從此雙端佇列所表示的堆疊(stack)空間中彈出一個元素。
void	push(E e) 將元素推入此雙端佇列表示的堆疊(stack)空間。
void	put(E e) 將指定的元素插入此雙端佇列表示的佇列中（即此雙端佇列的尾部），必要時將一直等待可用空間。
void	putFirst(E e) 將指定的元素插入此雙端佇列的開頭，必要時將一直等待可用空間。
void	putLast(E e) 將指定的元素插入此雙端佇列的末尾，必要時將一直等待可用空間。
int	remainingCapacity() 返回理想情況下（沒有記憶體和資源約束）此雙端佇列可不受阻塞地接受的額外元素數。
E	remove() 獲取並移除此雙端佇列表示的佇列的頭部。
boolean	remove(Object o) 從此雙端佇列移除第一次出現的指定元素。
E	removeFirst() 獲取並移除此雙端佇列第一個元素。
boolean	removeFirstOccurrence(Object o) 從此雙端佇列移除第一次出現的指定元素。
E	removeLast() 獲取並移除此雙端佇列的最後一個元素。
boolean	removeLastOccurrence(Object o) 從此雙端佇列移除最後一次出現的指定元素。
int	size() 返回此雙端佇列中的元素數。
E	take() 獲取並移除此雙端佇列表示的佇列的頭部（即此雙端佇列的第一個元素），必要時將一直等待可用元素。
E	takeFirst() 獲取並移除此雙端佇列的第一個元素，必要時將一直等待可用元素。
E	takeLast() 獲取並移除此雙端佇列的最後一個元素，必要時將一直等待可用元素。
Object[]	toArray() 返回以恰當順序（從第一個元素到最後一個元素）包含此雙端佇列所有元素的陣列。
<T> T[]	toArray(T[] a) 返回以恰當順序包含此雙端佇列所有元素的陣列；返回陣列的運行時型別是指定陣列的運行時型別。
String	toString() 返回此 collection 的字元串表示形式。

從類別 java.util.AbstractQueue 繼承的方法

addAll

從類別 java.util.AbstractCollection 繼承的方法

containsAll, isEmpty, removeAll, retainAll

從類別 java.lang.Object 繼承的方法

clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

從介面 java.util.Collection 繼承的方法

addAll, containsAll, equals, hashCode, isEmpty, removeAll, retainAll

建構子詳細資訊

LinkedBlockingDeque

public LinkedBlockingDeque()

創建一個容量為 Integer.MAX_VALUE 的 LinkedBlockingDeque。

LinkedBlockingDeque

public LinkedBlockingDeque(int capacity)

創建一個具有給定（固定）容量的 LinkedBlockingDeque。

參數：

capacity - 此雙端佇列的容量

拋出：

IllegalArgumentException - 如果 capacity 小於 1

LinkedBlockingDeque

public LinkedBlockingDeque(Collection<? extends E> c)

創建一個容量為 Integer.MAX_VALUE 的 LinkedBlockingDeque，最初包含給定 collection 的元素，以該 collection 迭代器的遍歷順序添加。

參數：

c - 最初所包含元素所屬的 collection

拋出：

NullPointerException - 如果指定 collection 或其任意元素為 null

方法詳細資訊

addFirst

public void addFirst(E e)

從介面 BlockingDeque 複製的描述

如果立即可行且不違反容量限制，則將指定的元素插入此雙端佇列的開頭；如果當前沒有空間可用，則拋出 IllegalStateException。當使用有容量限制的雙端佇列時，通常首選 offerFirst。

指定者：

介面 BlockingDeque<E> 中的 addFirst

指定者：

介面 Deque<E> 中的 addFirst

參數：

e - 要添加的元素

拋出：

IllegalStateException - 如果此時由於容量限制而無法添加元素

NullPointerException - 如果指定的元素為 null

addLast

public void addLast(E e)

從介面 BlockingDeque 複製的描述

如果立即可行且不違反容量限制，則將指定的元素插入此雙端佇列的末尾；如果當前沒有空間可用，則拋出 IllegalStateException。當使用有容量限制的雙端佇列時，通常首選 offerLast。

指定者：

介面 BlockingDeque<E> 中的 addLast

指定者：

介面 Deque<E> 中的 addLast

參數：

e - 要添加的元素

拋出：

IllegalStateException - 如果此時由於容量限制而無法添加元素

NullPointerException - 如果指定的元素為 null

offerFirst

public boolean offerFirst(E e)

從介面 BlockingDeque 複製的描述

如果立即可行且不違反容量限制，則將指定的元素插入此雙端佇列的開頭，並在成功時返回 true；如果當前沒有空間可用，則返回 false。當使用有容量限制的雙端佇列時，此方法通常優於 addFirst 方法，後者可能無法插入元素，而只是拋出一個異常。

指定者：

介面 BlockingDeque<E> 中的 offerFirst

指定者：

介面 Deque<E> 中的 offerFirst

參數：

e - 要添加的元素

返回：

如果元素被添加到此雙端佇列，則返回 true，否則返回 false

拋出：

NullPointerException - 如果指定的元素為 null

offerLast

public boolean offerLast(E e)

從介面 BlockingDeque 複製的描述

如果立即可行且不違反容量限制，則將指定的元素插入此雙端佇列的末尾，並在成功時返回 true；如果當前沒有空間可用，則返回 false。當使用有容量限制的雙端佇列時，該方法通常優於 addLast 方法，後者可能無法插入元素，而只是拋出一個異常。

指定者：

介面 BlockingDeque<E> 中的 offerLast

指定者：

介面 Deque<E> 中的 offerLast

參數：

e - 要添加的元素

返回：

如果元素被添加到此雙端佇列，則返回 true，否則返回 false

拋出：

NullPointerException - 如果指定的元素為 null

putFirst

public void putFirst(E e)
              throws InterruptedException

從介面 BlockingDeque 複製的描述

將指定的元素插入此雙端佇列的開頭，必要時將一直等待可用空間。

指定者：

介面 BlockingDeque<E> 中的 putFirst

參數：

e - 要添加的元素

拋出：

NullPointerException - 如果指定的元素為 null

InterruptedException - 如果在等待時被中斷

putLast

public void putLast(E e)
             throws InterruptedException

從介面 BlockingDeque 複製的描述

將指定的元素插入此雙端佇列的末尾，必要時將一直等待可用空間。

指定者：

介面 BlockingDeque<E> 中的 putLast

參數：

e - 要添加的元素

拋出：

NullPointerException - 如果指定的元素為 null

InterruptedException - 如果在等待時被中斷

offerFirst

public boolean offerFirst(E e,
                          long timeout,
                          TimeUnit unit)
                   throws InterruptedException

從介面 BlockingDeque 複製的描述

將指定的元素插入此雙端佇列的開頭，必要時將在指定的等待時間內等待可用空間。

指定者：

介面 BlockingDeque<E> 中的 offerFirst

參數：

e - 要添加的元素

timeout - 放棄之前等待的時間長度，以 unit 為時間單位

unit - 確定如何解釋 timeout 參數的 TimeUnit

返回：

如果成功，則返回 true；如果在空間可用前超過了指定的等待時間，則返回 false

拋出：

NullPointerException - 如果指定的元素為 null

InterruptedException - 如果在等待時被中斷

offerLast

public boolean offerLast(E e,
                         long timeout,
                         TimeUnit unit)
                  throws InterruptedException

從介面 BlockingDeque 複製的描述

將指定的元素插入此雙端佇列的末尾，必要時將在指定的等待時間內等待可用空間。

指定者：

介面 BlockingDeque<E> 中的 offerLast

參數：

e - 要添加的元素

timeout - 放棄之前等待的時間長度，以 unit 為時間單位

unit - 確定如何解釋 timeout 參數的 TimeUnit

返回：

如果成功，則返回 true；如果在空間可用前超過了指定的等待時間，則返回 false

拋出：

NullPointerException - 如果指定的元素為 null

InterruptedException - 如果在等待時被中斷

removeFirst

public E removeFirst()

從介面 Deque 複製的描述

獲取並移除此雙端佇列第一個元素。此方法與 pollFirst 唯一的不同在於：如果此雙端佇列為空，它將拋出一個異常。

指定者：

介面 Deque<E> 中的 removeFirst

返回：

此雙端佇列的頭部

拋出：

NoSuchElementException - 如果此雙端佇列為空

removeLast

public E removeLast()

從介面 Deque 複製的描述

獲取並移除此雙端佇列的最後一個元素。此方法與 pollLast 唯一的不同在於：如果此雙端佇列為空，它將拋出一個異常。

指定者：

介面 Deque<E> 中的 removeLast

返回：

此雙端佇列的尾部

拋出：

NoSuchElementException - 如果此雙端佇列為空

pollFirst

public E pollFirst()

從介面 Deque 複製的描述

獲取並移除此雙端佇列的第一個元素；如果此雙端佇列為空，則返回 null。

指定者：

介面 Deque<E> 中的 pollFirst

返回：

此雙端佇列的頭部；如果此雙端佇列為空，則返回 null

pollLast

public E pollLast()

從介面 Deque 複製的描述

獲取並移除此雙端佇列的最後一個元素；如果此雙端佇列為空，則返回 null。

指定者：

介面 Deque<E> 中的 pollLast

返回：

此雙端佇列的尾部；如果此雙端佇列為空，則返回 null

takeFirst

public E takeFirst()
            throws InterruptedException

從介面 BlockingDeque 複製的描述

獲取並移除此雙端佇列的第一個元素，必要時將一直等待可用元素。

指定者：

介面 BlockingDeque<E> 中的 takeFirst

返回：

此雙端佇列的頭部

拋出：

InterruptedException - 如果在等待時被中斷

takeLast

public E takeLast()
           throws InterruptedException

從介面 BlockingDeque 複製的描述

獲取並移除此雙端佇列的最後一個元素，必要時將一直等待可用元素。

指定者：

介面 BlockingDeque<E> 中的 takeLast

返回：

此雙端佇列的尾部

拋出：

InterruptedException - 如果在等待時被中斷

pollFirst

public E pollFirst(long timeout,
                   TimeUnit unit)
            throws InterruptedException

從介面 BlockingDeque 複製的描述

獲取並移除此雙端佇列的第一個元素，必要時將在指定的等待時間等待可用元素。

指定者：

介面 BlockingDeque<E> 中的 pollFirst

參數：

timeout - 放棄之前等待的時間長度，以 unit 為時間單位

unit - 確定如何解釋 timeout 參數的 TimeUnit

返回：

此雙端佇列的頭部，如果在元素可用前超過了指定的等待時間，則返回 null

拋出：

InterruptedException - 如果在等待時被中斷

pollLast

public E pollLast(long timeout,
                  TimeUnit unit)
           throws InterruptedException

從介面 BlockingDeque 複製的描述

獲取並移除此雙端佇列的最後一個元素，必要時將在指定的等待時間內等待可用元素。

指定者：

介面 BlockingDeque<E> 中的 pollLast

參數：

timeout - 放棄之前等待的時間長度，以 unit 為時間單位

unit - 確定如何解釋 timeout 參數的 TimeUnit

返回：

此雙端佇列的尾部，如果在元素可用前超過了指定的等待時間，則返回 null

拋出：

InterruptedException - 如果在等待時被中斷

getFirst

public E getFirst()

從介面 Deque 複製的描述

獲取，但不移除此雙端佇列的第一個元素。 此方法與 peekFirst 唯一的不同在於：如果此雙端佇列為空，它將拋出一個異常。

指定者：

介面 Deque<E> 中的 getFirst

返回：

此雙端佇列的頭部

拋出：

NoSuchElementException - 如果此雙端佇列為空

getLast

public E getLast()

從介面 Deque 複製的描述

獲取，但不移除此雙端佇列的最後一個元素。此方法與 peekLast 唯一的不同在於：如果此雙端佇列為空，它將拋出一個異常。

指定者：

介面 Deque<E> 中的 getLast

返回：

此雙端佇列的尾部

拋出：

NoSuchElementException - 如果此雙端佇列為空

peekFirst

public E peekFirst()

從介面 Deque 複製的描述

獲取，但不移除此雙端佇列的第一個元素；如果此雙端佇列為空，則返回 null。

指定者：

介面 Deque<E> 中的 peekFirst

返回：

此雙端佇列的頭部；如果此雙端佇列為空，則返回 null

peekLast

public E peekLast()

從介面 Deque 複製的描述

獲取，但不移除此雙端佇列的最後一個元素；如果此雙端佇列為空，則返回 null。

指定者：

介面 Deque<E> 中的 peekLast

返回：

此雙端佇列的尾部；如果此雙端佇列為空，則返回 null

removeFirstOccurrence

public boolean removeFirstOccurrence(Object o)

從介面 BlockingDeque 複製的描述

從此雙端佇列移除第一次出現的指定元素。如果此雙端佇列不包含該元素，則不作更改。更確切地講，移除第一個滿足 o.equals(e) 的元素 e（如果存在這樣的元素）。如果此雙端佇列包含指定的元素（或者此雙端佇列由於調用而發生了更改），則返回 true。

指定者：

介面 BlockingDeque<E> 中的 removeFirstOccurrence

指定者：

介面 Deque<E> 中的 removeFirstOccurrence

參數：

o - 要從此雙端佇列移除的元素（如果存在）

返回：

如果由於此調用而移除了一個元素，則返回 true

removeLastOccurrence

public boolean removeLastOccurrence(Object o)

從介面 BlockingDeque 複製的描述

從此雙端佇列移除最後一次出現的指定元素。如果此雙端佇列不包含該元素，則不作更改。更確切地講，移除最後一個滿足 o.equals(e) 的元素 e（如果存在這樣的元素）。如果此雙端佇列包含指定的元素（或者此雙端佇列由於調用而發生了更改），則返回 true。

指定者：

介面 BlockingDeque<E> 中的 removeLastOccurrence

指定者：

介面 Deque<E> 中的 removeLastOccurrence

參數：

o - 要從此雙端佇列移除的元素（如果存在）

返回：

如果由於此調用而移除了一個元素，則返回 true

add

public boolean add(E e)

在不違反容量限制的情況下，將指定的元素插入此雙端佇列的末尾。當使用有容量限制的雙端佇列時，通常首選 offer 方法。

此方法等效於 addLast(E)。

指定者：

介面 Collection<E> 中的 add

指定者：

介面 BlockingDeque<E> 中的 add

指定者：

介面 BlockingQueue<E> 中的 add

指定者：

介面 Deque<E> 中的 add

指定者：

介面 Queue<E> 中的 add

覆寫：

類別 AbstractQueue<E> 中的 add

參數：

e - 要添加的元素

返回：

true（根據 Collection.add(E) 的規定）

拋出：

IllegalStateException - 如果此刻由於容量限制而無法添加元素

NullPointerException - 如果指定的元素為 null

offer

public boolean offer(E e)

從介面 BlockingDeque 複製的描述

如果立即可行且不違反容量限制，則將指定的元素插入此雙端佇列表示的佇列中（即此雙端佇列的尾部），並在成功時返回 true；如果當前沒有空間可用，則返回 false。當使用有容量限制的雙端佇列時，此方法通常優於 BlockingDeque.add(E) 方法，後者可能無法插入元素，而只是拋出一個異常。

此方法等效於 offerLast。

指定者：

介面 BlockingDeque<E> 中的 offer

指定者：

介面 BlockingQueue<E> 中的 offer

指定者：

介面 Deque<E> 中的 offer

指定者：

介面 Queue<E> 中的 offer

參數：

e - 要添加的元素

返回：

如果該元素已添加到此佇列，則返回 true；否則返回 false

拋出：

NullPointerException - 如果指定的元素為 null

put

public void put(E e)
         throws InterruptedException

從介面 BlockingDeque 複製的描述

將指定的元素插入此雙端佇列表示的佇列中（即此雙端佇列的尾部），必要時將一直等待可用空間。

此方法等效於 putLast。

指定者：

介面 BlockingDeque<E> 中的 put

指定者：

介面 BlockingQueue<E> 中的 put

參數：

e - 要添加的元素

拋出：

NullPointerException - 如果指定的元素為 null

InterruptedException - 如果在等待時被中斷

offer

public boolean offer(E e,
                     long timeout,
                     TimeUnit unit)
              throws InterruptedException

從介面 BlockingDeque 複製的描述

將指定的元素插入此雙端佇列表示的佇列中（即此雙端佇列的尾部），必要時將在指定的等待時間內一直等待可用空間。

此方法等效於 offerLast。

指定者：

介面 BlockingDeque<E> 中的 offer

指定者：

介面 BlockingQueue<E> 中的 offer

參數：

e - 要添加的元素

timeout - 放棄之前等待的時間長度，以 unit 為時間單位

unit - 確定如何解釋 timeout 參數的 TimeUnit

返回：

如果元素被添加到此雙端佇列，則返回 true，否則返回 false

拋出：

NullPointerException - 如果指定的元素為 null

InterruptedException - 如果在等待時被中斷

remove

public E remove()

獲取並移除此雙端佇列表示的佇列的頭部。此方法與 poll 的不同之處在於：如果此雙端佇列為空，它將拋出一個異常。

此方法等效於 removeFirst。

指定者：

介面 BlockingDeque<E> 中的 remove

指定者：

介面 Deque<E> 中的 remove

指定者：

介面 Queue<E> 中的 remove

覆寫：

類別 AbstractQueue<E> 中的 remove

返回：

此雙端佇列表示的佇列的頭部

拋出：

NoSuchElementException - 如果此雙端佇列為空

poll

public E poll()

從介面 BlockingDeque 複製的描述

獲取並移除此雙端佇列表示的佇列的頭部（即此雙端佇列的第一個元素）；如果此雙端佇列為空，則返回 null。

此方法等效於 Deque.pollFirst()。

指定者：

介面 BlockingDeque<E> 中的 poll

指定者：

介面 Deque<E> 中的 poll

指定者：

介面 Queue<E> 中的 poll

返回：

此雙端佇列的頭部；如果此雙端佇列為空，則返回 null

take

public E take()
       throws InterruptedException

從介面 BlockingDeque 複製的描述

獲取並移除此雙端佇列表示的佇列的頭部（即此雙端佇列的第一個元素），必要時將一直等待可用元素。

此方法等效於 takeFirst。

指定者：

介面 BlockingDeque<E> 中的 take

指定者：

介面 BlockingQueue<E> 中的 take

返回：

此雙端佇列的頭部

拋出：

InterruptedException - 如果在等待時被中斷

poll

public E poll(long timeout,
              TimeUnit unit)
       throws InterruptedException

從介面 BlockingDeque 複製的描述

獲取並移除此雙端佇列表示的佇列的頭部（即此雙端佇列的第一個元素），如有必要將在指定的等待時間內等待可用元素。

此方法等效於 pollFirst。

指定者：

介面 BlockingDeque<E> 中的 poll

指定者：

介面 BlockingQueue<E> 中的 poll

參數：

timeout - 放棄之前要等待的時間長度，用 unit 的時間單位表示

unit - 確定如何解釋 timeout 參數的 TimeUnit

返回：

此雙端佇列的頭部；如果在元素可用前超過了指定的等待時間，則返回 null

拋出：

InterruptedException - 如果在等待時被中斷

element

public E element()

獲取但不移除此雙端佇列表示的佇列的頭部。此方法與 peek 的不同之處在於：如果此雙端佇列為空，它將拋出一個異常。

此方法等效於 getFirst。

指定者：

介面 BlockingDeque<E> 中的 element

指定者：

介面 Deque<E> 中的 element

指定者：

介面 Queue<E> 中的 element

覆寫：

類別 AbstractQueue<E> 中的 element

返回：

此雙端佇列表示的佇列的頭部

拋出：

NoSuchElementException - 如果此雙端佇列為空

peek

public E peek()

從介面 BlockingDeque 複製的描述

獲取但不移除此雙端佇列表示的佇列的頭部（即此雙端佇列的第一個元素）；如果此雙端佇列為空，則返回 null。

此方法等效於 peekFirst。

指定者：

介面 BlockingDeque<E> 中的 peek

指定者：

介面 Deque<E> 中的 peek

指定者：

介面 Queue<E> 中的 peek

返回：

此雙端佇列的頭部；如果此雙端佇列為空，則返回 null

remainingCapacity

public int remainingCapacity()

返回理想情況下（沒有記憶體和資源約束）此雙端佇列可不受阻塞地接受的額外元素數。該數目總是等於此雙端佇列的初始容量，小於此雙端佇列的當前 size。

注意，不能 總是通過檢查 remainingCapacity 斷定試圖插入元素能否成功，因為可能出現另一個執行緒即將插入或移除一個元素的情況。

指定者：

介面 BlockingQueue<E> 中的 remainingCapacity

返回：

剩餘容量

drainTo

public int drainTo(Collection<? super E> c)

從介面 BlockingQueue 複製的描述

移除此佇列中所有可用的元素，並將它們添加到給定 collection 中。此操作可能比反覆輪詢此佇列更有效。在試圖向 collection c 中添加元素沒有成功時，可能導致在拋出相關異常時，元素會同時在兩個 collection 中出現，或者在其中一個 collection 中出現，也可能在兩個 collection 中都不出現。如果試圖將一個佇列放入自身佇列中，則會導致 IllegalArgumentException 異常。此外，如果正在進行此操作時修改指定的 collection，則此操作行為是不確定的。

指定者：

介面 BlockingQueue<E> 中的 drainTo

參數：

c - 接收傳輸元素的 collection

返回：

傳輸元素的數量

拋出：

UnsupportedOperationException - 如果指定 collection 不支持添加元素

ClassCastException - 如果此佇列元素的類別不允許將其添加到指定 collection

NullPointerException - 如果指定 collection 為 null

IllegalArgumentException - 如果指定 collection 是此佇列，或者此佇列元素的某些屬性不允許將其添加到指定 collection

drainTo

public int drainTo(Collection<? super E> c,
                   int maxElements)

從介面 BlockingQueue 複製的描述

最多從此佇列中移除給定數量的可用元素，並將這些元素添加到給定 collection 中。在試圖向 collection c 中添加元素沒有成功時，可能導致在拋出相關異常時，元素會同時在兩個 collection 中出現，或者在其中一個 collection 中出現，也可能在兩個 collection 中都不出現。如果試圖將一個佇列放入自身佇列中，則會導致 IllegalArgumentException 異常。此外，如果正在進行此操作時修改指定的 collection，則此操作行為是不確定的。

指定者：

介面 BlockingQueue<E> 中的 drainTo

參數：

c - 接收傳輸元素的 collection

maxElements - 傳輸元素的最大數量

返回：

傳輸元素的數量

拋出：

UnsupportedOperationException - 如果指定 collection 不支持添加元素

ClassCastException - 如果此佇列元素的類別不允許將其添加到指定 collection

NullPointerException - 如果指定 collection 為 null

IllegalArgumentException - 如果指定 collection 是此佇列，或者此佇列元素的某些屬性不允許將其添加到指定 collection

push

public void push(E e)

從介面 BlockingDeque 複製的描述

將元素推入此雙端佇列表示的堆疊(stack)空間。換句話說，在不違反容量限制的情況下，將元素插入雙端佇列的開頭。

此方法等效於 addFirst。

指定者：

介面 BlockingDeque<E> 中的 push

指定者：

介面 Deque<E> 中的 push

參數：

e - 要推入的元素

拋出：

IllegalStateException - 如果此時由於容量限制而無法添加元素

NullPointerException - 如果指定的元素為 null

pop

public E pop()

從介面 Deque 複製的描述

從此雙端佇列所表示的堆疊(stack)空間中彈出一個元素。換句話說，移除並返回此雙端佇列第一個元素。

此方法等效於 Deque.removeFirst()。

指定者：

介面 Deque<E> 中的 pop

返回：

此雙端佇列開頭的元素（它是此雙端佇列所表示的堆疊(stack)空間的頂部）

拋出：

NoSuchElementException - 如果此雙端佇列為空

remove

public boolean remove(Object o)

從此雙端佇列移除第一次出現的指定元素。如果此雙端佇列不包含該元素，則不作更改。更確切地講，移除第一個滿足 o.equals(e) 的元素 e（如果存在這樣的元素）。如果此雙端佇列包含指定的元素（或者此雙端佇列由於調用而發生了更改），則返回 true。

此方法等效於 removeFirstOccurrence。

指定者：

介面 Collection<E> 中的 remove

指定者：

介面 BlockingDeque<E> 中的 remove

指定者：

介面 BlockingQueue<E> 中的 remove

指定者：

介面 Deque<E> 中的 remove

覆寫：

類別 AbstractCollection<E> 中的 remove

參數：

o - 要從此雙端佇列移除的元素（如果存在）

返回：

如果此雙端佇列由於調用而發生更改，則返回 true

size

public int size()

返回此雙端佇列中的元素數。

指定者：

介面 Collection<E> 中的 size

指定者：

介面 BlockingDeque<E> 中的 size

指定者：

介面 Deque<E> 中的 size

指定者：

類別 AbstractCollection<E> 中的 size

返回：

此雙端佇列中的元素數

contains

public boolean contains(Object o)

如果此雙端佇列包含指定的元素，則返回 true。更確切地講，當且僅當此雙端佇列至少包含一個滿足 o.equals(e) 的元素 e，返回 true。

指定者：

介面 Collection<E> 中的 contains

指定者：

介面 BlockingDeque<E> 中的 contains

指定者：

介面 BlockingQueue<E> 中的 contains

指定者：

介面 Deque<E> 中的 contains

覆寫：

類別 AbstractCollection<E> 中的 contains

參數：

o - 檢查是否包含於此雙端佇列的物件

返回：

如果此雙端佇列包含指定的元素，則返回 true。

toArray

public Object[] toArray()

返回以恰當順序（從第一個元素到最後一個元素）包含此雙端佇列所有元素的陣列。

由於此雙端佇列不維護對返回陣列的任何參考，因而它將是“安全的”。（換句話說，此方法必須分派一個新的陣列）。因此，調用者可以自由地修改返回的陣列。

此方法充當了基於陣列的 API 與基於 collection 的 API 之間的橋樑。

指定者：

介面 Collection<E> 中的 toArray

覆寫：

類別 AbstractCollection<E> 中的 toArray

返回：

包含此雙端佇列中所有元素的陣列。

toArray

public <T> T[] toArray(T[] a)

返回以恰當順序包含此雙端佇列所有元素的陣列；返回陣列的運行時型別是指定陣列的運行時型別。如果指定的陣列能容納該雙端佇列，則將雙端佇列返回此處。否則，將分派一個具有指定陣列的運行時型別和此雙端佇列大小的新陣列。

如果指定的陣列能容納此雙端佇列，並且有剩餘的空間（即陣列的元素比雙端佇列多），那麼將陣列中緊接雙端佇列尾部的元素設置為 null。

像 toArray() 方法一樣，此方法充當基於陣列 的 API 與基於 collection 的 API 之間的橋樑。更進一步說，此方法允許對輸出陣列的運行時型別進行精確控制，在某些情況下，還可以用來節省分派開銷。

假定 x 是只包含字元串的一個已知雙端佇列。以下程式碼用來將該雙端佇列轉儲到一個新分派的 String 陣列：

String[] y = x.toArray(new String[0]);

注意，toArray(new Object[0]) 和 toArray() 在功能上是相同的。

指定者：

介面 Collection<E> 中的 toArray

覆寫：

類別 AbstractCollection<E> 中的 toArray

參數：

a - 要用來存儲雙端佇列元素的陣列（如果該陣列足夠大）；否則，將為此分派一個具有相同運行時型別的新陣列

返回：

包含此雙端佇列所有元素的陣列

拋出：

ArrayStoreException - 如果指定陣列的運行時型別不是此雙端佇列每個元素的運行時型別的父級類別型

NullPointerException - 如果指定的陣列為 null

toString

public String toString()

從類別 AbstractCollection 複製的描述

返回此 collection 的字元串表示形式。該字元串表示形式由 collection 元素的列表組成，這些元素按其迭代器返回的順序排列，並用方括號 ("[]") 括起來。相鄰元素由字元 ", "（逗號加空格）分隔。通過 String.valueOf(Object) 可以將元素轉換成字元串。

覆寫：

類別 AbstractCollection<E> 中的 toString

返回：

此 collection 的字元串表示形式

clear

public void clear()

以原子方式 (atomically) 從此雙端佇列移除所有元素。在此調用返回之後，該雙端佇列將為空。

指定者：

介面 Collection<E> 中的 clear

覆寫：

類別 AbstractQueue<E> 中的 clear

iterator

public Iterator<E> iterator()

返回在此雙端佇列元素上以恰當順序進行迭代的迭代器。元素將按從第一個（頭部）到最後一個（尾部）的順序返回。返回的 Iterator 是一個不會拋出 ConcurrentModificationException 的“弱一致”迭代器，能確保遍歷迭代器建構後存在的所有元素，並可以（但並不保證）反映建構後的任何修改。

指定者：

介面 Iterable<E> 中的 iterator

指定者：

介面 Collection<E> 中的 iterator

指定者：

介面 BlockingDeque<E> 中的 iterator

指定者：

介面 Deque<E> 中的 iterator

指定者：

類別 AbstractCollection<E> 中的 iterator

返回：

按恰當順序在此雙端佇列的元素上進行迭代的迭代器

descendingIterator

public Iterator<E> descendingIterator()

返回在此雙端佇列的元素上以逆向連續順序進行迭代的迭代器。元素將按從最後一個（尾部）到第一個（頭部）的順序返回。返回的 Iterator 是一個不會拋出 ConcurrentModificationException 的“弱一致”迭代器，能確保遍歷迭代器建構後存在的所有元素，並可以（但並不保證）反映建構後的任何修改。

指定者：

介面 Deque<E> 中的 descendingIterator

返回：

以逆向順序在此雙端佇列中的元素上進行迭代的迭代器