Module java.base
Package java.util.concurrent

Class LinkedBlockingDeque<E>

java.lang.Object
java.util.AbstractCollection<E>
java.util.AbstractQueue<E>
java.util.concurrent.LinkedBlockingDeque<E>
类型参数:
E - 此双端队列中保存的元素类型
所有实现的接口:
Serializable, Iterable<E>, Collection<E>, BlockingDeque<E>, BlockingQueue<E>, Deque<E>, Queue<E>, SequencedCollection<E>
public class LinkedBlockingDeque<E> extends AbstractQueue<E> implements BlockingDeque<E>, Serializable
基于链接节点的可选边界阻塞双端队列。

可选的容量限制构造参数用作防止过度扩展的方式。如果未指定容量，则等于Integer.MAX_VALUE。除非这会使双端队列超过容量，否则在每次插入时动态创建链接节点。

大多数操作在常数时间内运行（忽略阻塞时间）。异常包括remove、removeFirstOccurrence、removeLastOccurrence、contains、iterator.remove()以及批量操作，所有这些操作都在线性时间内运行。

此类及其迭代器实现了Collection和Iterator接口的所有可选方法。

此类是Java集合框架的成员。

自 JDK 版本:
1.6
参见:

  • Constructor Summary

    Constructors
    Constructor
    Description
    LinkedBlockingDeque()
    创建一个容量为Integer.MAX_VALUE的LinkedBlockingDeque。
    LinkedBlockingDeque(int capacity)
    创建一个具有给定（固定）容量的LinkedBlockingDeque。
    LinkedBlockingDeque(Collection<? extends E> c)
    创建一个容量为Integer.MAX_VALUE的LinkedBlockingDeque，最初包含给定集合的元素，按照集合迭代器的遍历顺序添加。

  • Method Summary

    Modifier and Type
    Method
    Description
    boolean
    add(E e)
    将指定的元素插入到此双端队列的末尾，除非会违反容量限制。
    boolean
    addAll(Collection<? extends E> c)
    将指定集合中的所有元素按照指定集合迭代器返回的顺序添加到此双端队列的末尾。
    void
    addFirst(E e)
    如果当前立即可以这样做而不违反容量限制，则将指定的元素插入到此双端队列的前面，如果当前没有可用空间，则抛出IllegalStateException。
    void
    addLast(E e)
    如果当前立即可以这样做而不违反容量限制，则将指定的元素插入到此双端队列的末尾，如果当前没有可用空间，则抛出IllegalStateException。
    void
    clear()
    原子性地从此双端队列中移除所有元素。
    boolean
    contains(Object o)
    如果此双端队列包含指定的元素，则返回true。
    Iterator<E>
    descendingIterator()
    以逆序顺序返回此双端队列中的元素的迭代器。
    int
    drainTo(Collection<? super E> c)
    从此队列中移除所有可用元素并将它们添加到给定集合中。
    int
    drainTo(Collection<? super E> c, int maxElements)
    从此队列中最多移除给定数量的可用元素并将它们添加到给定集合中。
    E
    element()
    检索但不移除由此双端队列表示的队列的头部。
    void
    forEach(Consumer<? super E> action)
    对Iterable的每个元素执行给定的操作，直到所有元素都已处理或操作引发异常。
    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()
    从由此双端队列表示的堆栈中弹出一个元素。
    void
    push(E e)
    如果当前立即可以这样做而不违反容量限制，则将指定的元素推送到由此双端队列表示的堆栈（换句话说，在此双端队列的头部），如果当前没有可用空间，则抛出IllegalStateException。
    void
    put(E e)
    如果需要，等待空间变得可用，将指定的元素插入到由此双端队列表示的队列中（换句话说，在此双端队列的尾部）。
    void
    putFirst(E e)
    如果需要，等待空间变得可用，将指定的元素插入到此双端队列的前面。
    void
    putLast(E e)
    如果需要，等待空间变得可用，将指定的元素插入到此双端队列的末尾。
    int
    remainingCapacity()
    返回此双端队列在不阻塞的情况下理想地（在没有内存或资源约束的情况下）可以接受的附加元素数量。
    E
    remove()
    检索并移除由此双端队列表示的队列的头部。
    boolean
    remove(Object o)
    从此双端队列中删除指定元素的第一个出现。
    boolean
    removeAll(Collection<?> c)
    删除此集合中包含在指定集合中的所有元素（可选操作）。
    E
    removeFirst()
    检索并移除此双端队列的第一个元素。
    boolean
    removeFirstOccurrence(Object o)
    从此双端队列中删除指定元素的第一个出现。
    boolean
    removeIf(Predicate<? super E> filter)
    删除满足给定谓词的此集合的所有元素。
    E
    removeLast()
    检索并移除此双端队列的最后一个元素。
    boolean
    removeLastOccurrence(Object o)
    删除此双端队列中指定元素的最后一个出现。
    boolean
    retainAll(Collection<?> c)
    仅保留此集合中包含在指定集合中的元素（可选操作）。
    int
    size()
    返回此双端队列中的元素数量。
    Spliterator<E>
    spliterator()
    返回此双端队列中元素的Spliterator。
    E
    take()
    如果需要，等待直到由此双端队列表示的队列的头部（换句话说，此双端队列的第一个元素）变为可用。
    E
    takeFirst()
    如果需要，等待直到此双端队列的第一个元素变为可用。
    E
    takeLast()
    如果需要，等待直到此双端队列的最后一个元素变为可用。
    Object[]
    toArray()
    返回包含此双端队列中所有元素的数组，按正确顺序（从第一个到最后一个元素）。
    <T> T[]
    toArray(T[] a)
    返回包含此双端队列中所有元素的数组，按正确顺序排列；返回数组的运行时类型与指定数组的类型相同。

    Methods declared in class java.util.AbstractCollection

    containsAll, isEmpty, toString

    Methods declared in class java.lang.Object

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

    Methods declared in interface java.util.Collection

    containsAll, equals, hashCode, isEmpty, parallelStream, stream, toArray

    Methods declared in interface java.util.Deque

    reversed

  • Constructor Details

    • 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，最初包含给定集合中的元素，按照集合迭代器的遍历顺序添加。
      参数:
      c - 最初包含元素的集合
      抛出:
      NullPointerException - 如果指定的集合或其任何元素为null

  • Method Details

    • addFirst

      public void addFirst(E e)
      从接口复制的描述: BlockingDeque
      如果可以立即在不违反容量限制的情况下在此双端队列的前面插入指定的元素，则执行此操作，如果当前没有可用空间，则抛出IllegalStateException。在使用容量受限的双端队列时，通常最好使用offerFirst。
      指定者:
      addFirst 在接口 BlockingDeque<E>
      指定者:
      addFirst 在接口 Deque<E>
      指定者:
      addFirst 在接口 SequencedCollection<E>
      参数:
      e - 要添加的元素
      抛出:
      IllegalStateException - 如果此双端队列已满
      NullPointerException - 如果指定的元素为null

    • addLast

      public void addLast(E e)
      从接口复制的描述: BlockingDeque
      如果可以立即在不违反容量限制的情况下在此双端队列的末尾插入指定的元素，则执行此操作，如果当前没有可用空间，则抛出IllegalStateException。在使用容量受限的双端队列时，通常最好使用offerLast。
      指定者:
      addLast 在接口 BlockingDeque<E>
      指定者:
      addLast 在接口 Deque<E>
      指定者:
      addLast 在接口 SequencedCollection<E>
      参数:
      e - 要添加的元素
      抛出:
      IllegalStateException - 如果此双端队列已满
      NullPointerException - 如果指定的元素为null

    • offerFirst

      public boolean offerFirst(E e)
      从接口复制的描述: BlockingDeque
      如果可以立即在不违反容量限制的情况下在此双端队列的前面插入指定的元素，则执行此操作，返回true表示成功，如果当前没有可用空间则返回false。在使用容量受限的双端队列时，通常最好使用addFirst方法，该方法只会通过抛出异常来失败地插入元素。
      指定者:
      offerFirst 在接口 BlockingDeque<E>
      指定者:
      offerFirst 在接口 Deque<E>
      参数:
      e - 要添加的元素
      返回:
      true表示元素已添加到此双端队列，否则返回false
      抛出:
      NullPointerException - 如果指定的元素为null

    • offerLast

      public boolean offerLast(E e)
      从接口复制的描述: BlockingDeque
      如果可以立即在不违反容量限制的情况下在此双端队列的末尾插入指定的元素，则执行此操作，返回true表示成功，如果当前没有可用空间则返回false。在使用容量受限的双端队列时，通常最好使用addLast方法，该方法只会通过抛出异常来失败地插入元素。
      指定者:
      offerLast 在接口 BlockingDeque<E>
      指定者:
      offerLast 在接口 Deque<E>
      参数:
      e - 要添加的元素
      返回:
      true表示元素已添加到此双端队列，否则返回false
      抛出:
      NullPointerException - 如果指定的元素为null

    • putFirst

      public void putFirst(E e) throws InterruptedException
      从接口复制的描述: BlockingDeque
      如果需要，将指定的元素插入到此双端队列的前面，并等待空间变得可用。
      指定者:
      putFirst 在接口 BlockingDeque<E>
      参数:
      e - 要添加的元素
      抛出:
      NullPointerException - 如果指定的元素为null
      InterruptedException - 如果在等待时被中断

    • putLast

      public void putLast(E e) throws InterruptedException
      从接口复制的描述: BlockingDeque
      如果需要，将指定的元素插入到此双端队列的末尾，并等待空间变得可用。
      指定者:
      putLast 在接口 BlockingDeque<E>
      参数:
      e - 要添加的元素
      抛出:
      NullPointerException - 如果指定的元素为null
      InterruptedException - 如果在等待时被中断

    • offerFirst

      public boolean offerFirst(E e, long timeout, TimeUnit unit) throws InterruptedException
      从接口复制的描述: BlockingDeque
      如果需要，将指定的元素插入到此双端队列的前面，如果必要，等待指定的等待时间以使空间变得可用。
      指定者:
      offerFirst 在接口 BlockingDeque<E>
      参数:
      e - 要添加的元素
      timeout - 在unit单位内等待放弃的时间
      unit - 一个TimeUnit，确定如何解释timeout参数
      返回:
      true表示成功，或者如果指定的等待时间在空间可用之前过去，则返回false
      抛出:
      NullPointerException - 如果指定的元素为null
      InterruptedException - 如果在等待时被中断

    • offerLast

      public boolean offerLast(E e, long timeout, TimeUnit unit) throws InterruptedException
      从接口复制的描述: BlockingDeque
      将指定的元素插入到此双端队列的末尾，在必要时等待指定的等待时间以便腾出空间。
      指定者:
      offerLast 在接口 BlockingDeque<E>
      参数:
      e - 要添加的元素
      timeout - 在单位unit中等待多长时间后放弃
      unit - 一个TimeUnit，用于解释timeout参数
      返回:
      如果成功，则返回true，如果指定的等待时间在空间可用之前过去，则返回false
      抛出:
      NullPointerException - 如果指定的元素为null
      InterruptedException - 在等待时被中断

    • removeFirst

      public E removeFirst()
      从接口复制的描述: Deque
      检索并删除此双端队列的第一个元素。此方法与pollFirst的不同之处仅在于，如果此双端队列为空，则会抛出异常。
      指定者:
      removeFirst 在接口 Deque<E>
      指定者:
      removeFirst 在接口 SequencedCollection<E>
      返回:
      此双端队列的头部
      抛出:
      NoSuchElementException - 如果此双端队列为空

    • removeLast

      public E removeLast()
      从接口复制的描述: Deque
      检索并删除此双端队列的最后一个元素。此方法与pollLast的不同之处仅在于，如果此双端队列为空，则会抛出异常。
      指定者:
      removeLast 在接口 Deque<E>
      指定者:
      removeLast 在接口 SequencedCollection<E>
      返回:
      此双端队列的尾部
      抛出:
      NoSuchElementException - 如果此双端队列为空

    • pollFirst

      public E pollFirst()
      从接口复制的描述: Deque
      检索并删除此双端队列的第一个元素，如果此双端队列为空，则返回null。
      指定者:
      pollFirst 在接口 Deque<E>
      返回:
      此双端队列的头部，如果此双端队列为空，则返回null

    • pollLast

      public E pollLast()
      从接口复制的描述: Deque
      检索并删除此双端队列的最后一个元素，如果此双端队列为空，则返回null。
      指定者:
      pollLast 在接口 Deque<E>
      返回:
      此双端队列的尾部，如果此双端队列为空，则返回null

    • takeFirst

      public E takeFirst() throws InterruptedException
      从接口复制的描述: BlockingDeque
      检索并删除此双端队列的第一个元素，必要时等待，直到有元素可用为止。
      指定者:
      takeFirst 在接口 BlockingDeque<E>
      返回:
      此双端队列的头部
      抛出:
      InterruptedException - 在等待时被中断

    • takeLast

      public E takeLast() throws InterruptedException
      从接口复制的描述: BlockingDeque
      检索并删除此双端队列的最后一个元素，必要时等待，直到有元素可用为止。
      指定者:
      takeLast 在接口 BlockingDeque<E>
      返回:
      此双端队列的尾部
      抛出:
      InterruptedException - 在等待时被中断

    • pollFirst

      public E pollFirst(long timeout, TimeUnit unit) throws InterruptedException
      从接口复制的描述: BlockingDeque
      检索并删除此双端队列的第一个元素，必要时等待，直到有元素可用为止，最长等待指定的等待时间。
      指定者:
      pollFirst 在接口 BlockingDeque<E>
      参数:
      timeout - 在单位unit中等待多长时间后放弃
      unit - 一个TimeUnit，用于解释timeout参数
      返回:
      此双端队列的头部，如果指定的等待时间在元素可用之前过去，则返回null
      抛出:
      InterruptedException - 在等待时被中断

    • pollLast

      public E pollLast(long timeout, TimeUnit unit) throws InterruptedException
      从接口复制的描述: BlockingDeque
      检索并删除此双端队列的最后一个元素，必要时等待，直到有元素可用为止，最长等待指定的等待时间。
      指定者:
      pollLast 在接口 BlockingDeque<E>
      参数:
      timeout - 在单位unit中等待多长时间后放弃
      unit - 一个TimeUnit，用于解释timeout参数
      返回:
      此双端队列的尾部，如果指定的等待时间在元素可用之前过去，则返回null
      抛出:
      InterruptedException - 在等待时被中断

    • getFirst

      public E getFirst()
      从接口复制的描述: Deque
      检索但不删除此双端队列的第一个元素。此方法与peekFirst的不同之处仅在于，如果此双端队列为空，则会抛出异常。
      指定者:
      getFirst 在接口 Deque<E>
      指定者:
      getFirst 在接口 SequencedCollection<E>
      返回:
      此双端队列的头部
      抛出:
      NoSuchElementException - 如果此双端队列为空

    • getLast

      public E getLast()
      从接口复制的描述: Deque
      检索但不移除此双端队列的最后一个元素。此方法与peekLast的区别仅在于，如果此双端队列为空，则会抛出异常。
      指定者：
      getLast 在接口 Deque<E>
      指定者：
      getLast 在接口 SequencedCollection<E>
      返回：
      此双端队列的尾部
      抛出：
      NoSuchElementException - 如果此双端队列为空

    • peekFirst

      public E peekFirst()
      从接口复制的描述： Deque
      检索但不移除此双端队列的第一个元素，如果此双端队列为空，则返回null。
      指定者：
      peekFirst 在接口 Deque<E>
      返回：
      此双端队列的头部，如果此双端队列为空则返回null

    • peekLast

      public E peekLast()
      从接口复制的描述： Deque
      检索但不移除此双端队列的最后一个元素，如果此双端队列为空则返回null。
      指定者：
      peekLast 在接口 Deque<E>
      返回：
      此双端队列的尾部，如果此双端队列为空则返回null

    • removeFirstOccurrence

      public boolean removeFirstOccurrence(Object o)
      从接口复制的描述： BlockingDeque
      从此双端队列中移除指定元素的第一个出现。如果双端队列不包含该元素，则保持不变。更正式地说，移除第一个满足o.equals(e)的元素e（如果存在）。如果此双端队列包含指定的元素，则返回true（或者等效地，如果此双端队列由于调用而更改，则返回true）。
      指定者：
      removeFirstOccurrence 在接口 BlockingDeque<E>
      指定者：
      removeFirstOccurrence 在接口 Deque<E>
      参数：
      o - 如果存在，则从此双端队列中移除的元素
      返回：
      如果调用导致移除一个元素，则返回true

    • removeLastOccurrence

      public boolean removeLastOccurrence(Object o)
      从接口复制的描述： BlockingDeque
      从此双端队列中移除指定元素的最后一个出现。如果双端队列不包含该元素，则保持不变。更正式地说，移除最后一个满足o.equals(e)的元素e（如果存在）。如果此双端队列包含指定的元素，则返回true（或者等效地，如果此双端队列由于调用而更改，则返回true）。
      指定者：
      removeLastOccurrence 在接口 BlockingDeque<E>
      指定者：
      removeLastOccurrence 在接口 Deque<E>
      参数：
      o - 如果存在，则从此双端队列中移除的元素
      返回：
      如果调用导致移除一个元素，则返回true

    • add

      public boolean add(E e)
      将指定的元素插入此双端队列的末尾，除非违反容量限制。在使用容量受限的双端队列时，通常最好使用方法offer。

      此方法等效于addLast(E)。

      指定者：
      add 在接口 BlockingDeque<E>
      指定者：
      add 在接口 BlockingQueue<E>
      指定者：
      add 在接口 Collection<E>
      指定者：
      add 在接口 Deque<E>
      指定者：
      add 在接口 Queue<E>
      覆盖：
      add 在类 AbstractQueue<E>
      参数：
      e - 要添加的元素
      返回：
      true（如Collection.add(E)所指定）
      抛出：
      IllegalStateException - 如果此双端队列已满
      NullPointerException - 如果指定的元素为null

    • offer

      public boolean offer(E e)
      从接口复制的描述： BlockingDeque
      如果可以立即在不违反容量限制的情况下将指定元素插入此双端队列（换句话说，在此双端队列的尾部），则将指定元素插入队列，成功时返回true，如果当前没有空间可用则返回false。在使用容量受限的双端队列时，此方法通常优于BlockingDeque.add(E)方法，后者只能通过抛出异常来失败地插入元素。

      此方法等效于offerLast。

      指定者：
      offer 在接口 BlockingDeque<E>
      指定者：
      offer 在接口 BlockingQueue<E>
      指定者：
      offer 在接口 Deque<E>
      指定者：
      offer 在接口 Queue<E>
      参数：
      e - 要添加的元素
      返回：
      如果元素已添加到此队列，则返回true，否则返回false
      抛出：
      NullPointerException - 如果指定的元素为null

    • put

      public void put(E e) throws InterruptedException
      从接口复制的描述： BlockingDeque
      如果需要，将指定元素插入由此双端队列表示的队列（换句话说，在此双端队列的尾部），等待空间变得可用。

      此方法等效于putLast。

      指定者：
      put 在接口 BlockingDeque<E>中
      指定者：
      put 在接口 BlockingQueue<E>中
      参数：
      e - 要添加的元素
      抛出：
      NullPointerException - 如果指定的元素为null
      InterruptedException - 如果在等待时被中断

    • offer

      public boolean offer(E e, long timeout, TimeUnit unit) throws InterruptedException
      从接口复制的描述： BlockingDeque
      将指定的元素插入到此双端队列表示的队列中（换句话说，在此双端队列的尾部），如果需要等待空间变得可用，则最多等待指定的等待时间。

      此方法等效于offerLast。

      指定者：
      offer 在接口 BlockingDeque<E>中
      指定者：
      offer 在接口 BlockingQueue<E>中
      参数：
      e - 要添加的元素
      timeout - 等待放弃之前的时间，以unit为单位
      unit - 一个TimeUnit，用于解释timeout参数
      返回：
      如果元素已添加到此双端队列，则为true，否则为false
      抛出：
      NullPointerException - 如果指定的元素为null
      InterruptedException - 如果在等待时被中断

    • remove

      public E remove()
      检索并删除此双端队列表示的队列的头部。此方法与poll()的不同之处仅在于，如果此双端队列为空，则会抛出异常。

      此方法等效于removeFirst。

      指定者：
      remove 在接口 BlockingDeque<E>中
      指定者：
      remove 在接口 Deque<E>中
      指定者：
      remove 在接口 Queue<E>中
      覆盖：
      remove 在类 AbstractQueue<E>中
      返回：
      此双端队列表示的队列的头部
      抛出：
      NoSuchElementException - 如果此双端队列为空

    • poll

      public E poll()
      从接口复制的描述： BlockingDeque
      检索并删除此双端队列表示的队列的头部（换句话说，此双端队列的第一个元素），如果此双端队列为空，则返回null。

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

      指定者：
      poll 在接口 BlockingDeque<E>中
      指定者：
      poll 在接口 Deque<E>中
      指定者：
      poll 在接口 Queue<E>中
      返回：
      此双端队列的头部，如果此双端队列为空，则返回null

    • take

      public E take() throws InterruptedException
      从接口复制的描述： BlockingDeque
      检索并删除此双端队列表示的队列的头部（换句话说，此双端队列的第一个元素），必要时等待直到有元素可用。

      此方法等效于takeFirst。

      指定者：
      take 在接口 BlockingDeque<E>中
      指定者：
      take 在接口 BlockingQueue<E>中
      返回：
      此双端队列的头部
      抛出：
      InterruptedException - 如果在等待时被中断

    • poll

      public E poll(long timeout, TimeUnit unit) throws InterruptedException
      从接口复制的描述： BlockingDeque
      检索并删除此双端队列表示的队列的头部（换句话说，此双端队列的第一个元素），如果需要等待直到指定的等待时间以便元素可用。

      此方法等效于pollFirst。

      指定者：
      poll 在接口 BlockingDeque<E>中
      指定者：
      poll 在接口 BlockingQueue<E>中
      参数：
      timeout - 等待放弃之前的时间，以unit为单位
      unit - 一个TimeUnit，用于解释timeout参数
      返回：
      此双端队列的头部，如果指定的等待时间过去而在元素可用之前，则返回null
      抛出：
      InterruptedException - 如果在等待时被中断

    • element

      public E element()
      检索但不删除此双端队列表示的队列的头部。此方法与peek()的不同之处仅在于，如果此双端队列为空，则会抛出异常。

      此方法等效于getFirst。

      指定者：
      element 在接口 BlockingDeque<E>中
      指定者：
      element 在接口 Deque<E>中
      指定者：
      element 在接口 Queue<E>中
      覆盖：
      element 在类 AbstractQueue<E>中
      返回：
      此双端队列的头部
      抛出：
      NoSuchElementException - 如果此双端队列为空

    • peek

      public E peek()
      从接口复制的描述： BlockingDeque
      检索但不移除由此双端队列表示的队列的头部（换句话说，此双端队列的第一个元素），如果此双端队列为空，则返回null。

      此方法等效于peekFirst。

      指定者：
      peek 在接口 BlockingDeque<E>
      指定者：
      peek 在接口 Deque<E>
      指定者：
      peek 在接口 Queue<E>
      返回：
      此双端队列的头部，如果此双端队列为空则返回null

    • remainingCapacity

      public int remainingCapacity()
      返回此双端队列在不阻塞的情况下理想地（在没有内存或资源限制的情况下）可以接受的附加元素数量。这始终等于此双端队列的初始容量减去当前size的双端队列。

      请注意，您不能仅通过检查remainingCapacity来确定插入元素的尝试是否成功，因为可能会出现另一个线程即将插入或移除元素的情况。

      指定者：
      remainingCapacity 在接口 BlockingQueue<E>
      返回：
      剩余容量

    • drainTo

      public int drainTo(Collection<? super E> c)
      从接口中复制的描述： BlockingQueue
      从此队列中删除所有可用元素并将它们添加到给定的集合中。此操作可能比重复轮询此队列更有效。在尝试将元素添加到集合c时遇到失败可能导致在抛出相关异常时元素既不在集合中也不在队列中，或者同时在两者中。尝试将队列排空到自身会导致IllegalArgumentException。此外，如果在操作进行中修改了指定的集合，则此操作的行为是未定义的。
      指定者：
      drainTo 在接口 BlockingQueue<E>
      参数：
      c - 要传输元素的集合
      返回：
      传输的元素数量
      抛出：
      UnsupportedOperationException - 如果指定集合不支持添加元素
      ClassCastException - 如果此队列的元素类别阻止将其添加到指定集合中
      NullPointerException - 如果指定的集合为null
      IllegalArgumentException - 如果指定的集合为此队列，或者此队列的某个元素属性阻止将其添加到指定集合中

    • drainTo

      public int drainTo(Collection<? super E> c, int maxElements)
      从接口中复制的描述： BlockingQueue
      从此队列中最多删除给定数量的可用元素，并将它们添加到给定的集合中。在尝试将元素添加到集合c时遇到失败可能导致在抛出相关异常时元素既不在集合中也不在队列中，或者同时在两者中。尝试将队列排空到自身会导致IllegalArgumentException。此外，如果在操作进行中修改了指定的集合，则此操作的行为是未定义的。
      指定者：
      drainTo 在接口 BlockingQueue<E>
      参数：
      c - 要传输元素的集合
      maxElements - 要传输的最大元素数量
      返回：
      传输的元素数量
      抛出：
      UnsupportedOperationException - 如果指定集合不支持添加元素
      ClassCastException - 如果此队列的元素类别阻止将其添加到指定集合中
      NullPointerException - 如果指定的集合为null
      IllegalArgumentException - 如果指定的集合为此队列，或者此队列的某个元素属性阻止将其添加到指定集合中

    • push

      public void push(E e)
      从接口中复制的描述： BlockingDeque
      如果可以立即这样做而不违反容量限制，则将元素推送到由此双端队列表示的堆栈（换句话说，在此双端队列的头部），如果当前没有可用空间，则抛出IllegalStateException。

      此方法等效于addFirst。

      指定者：
      push 在接口 BlockingDeque<E>
      指定者：
      push 在接口 Deque<E>
      参数：
      e - 要推送的元素
      抛出：
      IllegalStateException - 如果此双端队列已满
      NullPointerException - 如果指定的元素为null

    • pop

      public E pop()
      从接口中复制的描述： Deque
      从由此双端队列表示的堆栈中弹出一个元素。换句话说，删除并返回此双端队列的第一个元素。

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

      指定者：
      pop 在接口 Deque<E>
      返回：
      此双端队列前端的元素（即由此双端队列表示的堆栈的顶部）
      抛出：
      NoSuchElementException - 如果此双端队列为空

    • remove

      public boolean remove(Object o)
      从此双端队列中删除指定元素的第一个出现。如果双端队列不包含该元素，则它保持不变。更正式地说，删除第一个元素e，使得o.equals(e)（如果存在这样的元素）。如果此双端队列包含指定的元素，则返回true（或者等效地，如果此双端队列由于调用而更改）。

      此方法等效于removeFirstOccurrence。

      指定者:
      remove 在接口 BlockingDeque<E>中
      指定者:
      remove 在接口 BlockingQueue<E>中
      指定者:
      remove 在接口 Collection<E>中
      指定者:
      remove 在接口 Deque<E>中
      覆盖:
      remove 在类 AbstractCollection<E>中
      参数:
      o - 如果存在，则从此双端队列中删除的元素
      返回:
      true 如果调用导致此双端队列发生更改

    • size

      public int size()
      返回此双端队列中的元素数量。
      指定者:
      size 在接口 BlockingDeque<E>中
      指定者:
      size 在接口 Collection<E>中
      指定者:
      size 在接口 Deque<E>中
      返回:
      此双端队列中的元素数量

    • contains

      public boolean contains(Object o)
      如果此双端队列包含指定的元素，则返回true。更正式地说，仅当此双端队列包含至少一个元素e使得o.equals(e)时，才返回true。
      指定者:
      contains 在接口 BlockingDeque<E>中
      指定者:
      contains 在接口 BlockingQueue<E>中
      指定者:
      contains 在接口 Collection<E>中
      指定者:
      contains 在接口 Deque<E>中
      覆盖:
      contains 在类 AbstractCollection<E>中
      参数:
      o - 要在此双端队列中检查包含性的对象
      返回:
      true 如果此双端队列包含指定的元素

    • addAll

      public boolean addAll(Collection<? extends E> c)
      将指定集合中的所有元素按照指定集合的迭代器返回顺序追加到此双端队列的末尾。尝试将双端队列的addAll到自身将导致IllegalArgumentException。
      指定者:
      addAll 在接口 Collection<E>中
      指定者:
      addAll 在接口 Deque<E>中
      覆盖:
      addAll 在类 AbstractQueue<E>中
      参数:
      c - 要插入到此双端队列中的元素
      返回:
      true 如果调用导致此双端队列发生更改
      抛出:
      NullPointerException - 如果指定的集合或其任何元素为null
      IllegalArgumentException - 如果集合为此双端队列
      IllegalStateException - 如果此双端队列已满
      参见:

    • toArray

      public Object[] toArray()
      返回一个包含此双端队列中所有元素的数组，按正确顺序排列（从第一个到最后一个元素）。

      返回的数组将是“安全”的，因为此双端队列不维护对它的任何引用。（换句话说，此方法必须分配一个新数组）。因此，调用者可以自由修改返回的数组。

      此方法充当基于数组和基于集合的API之间的桥梁。

      指定者:
      toArray 在接口 Collection<E>中
      覆盖:
      toArray 在类 AbstractCollection<E>中
      返回:
      包含此双端队列中所有元素的数组

    • toArray

      public <T> T[] toArray(T[] a)
      返回一个包含此双端队列中所有元素的数组，按正确顺序排列；返回数组的运行时类型是指定数组的类型。如果双端队列适合于指定数组，则将其返回。否则，将使用指定数组的运行时类型和此双端队列的大小分配一个新数组。

      如果此双端队列适合于指定数组且有多余空间（即，数组的元素多于此双端队列），则数组中紧接双端队列末尾的元素设置为null。

      与toArray()方法一样，此方法充当基于数组和基于集合的API之间的桥梁。此外，此方法允许精确控制输出数组的运行时类型，并且在某些情况下可用于节省分配成本。

      假设x是已知仅包含字符串的双端队列。以下代码可用于将双端队列转储到新分配的String数组中：

       String[] y = x.toArray(new String[0]);
      注意，toArray(new Object[0])在功能上与toArray()相同。
      指定者:
      toArray 在接口 Collection<E>中
      覆盖:
      toArray 在类 AbstractCollection<E>中
      类型参数:
      T - 包含集合的数组的组件类型
      参数:
      a - 要存储双端队列元素的数组，如果足够大；否则，将为此目的分配一个具有相同运行时类型的新数组
      返回:
      包含此双端队列中所有元素的数组
      抛出:
      ArrayStoreException - 如果指定数组的运行时类型不是此双端队列中每个元素的运行时类型的超类型
      NullPointerException - 如果指定数组为null

    • clear

      public void clear()
      原子性地从此双端队列中移除所有元素。此调用返回后，双端队列将为空。
      指定者:
      clear 在接口 Collection<E>中
      覆盖:
      clear 在类 AbstractQueue<E>中

    • iterator

      public Iterator<E> iterator()
      返回一个按正确顺序遍历此双端队列中元素的迭代器。元素将按从第一个（头部）到最后一个（尾部）的顺序返回。

      返回的迭代器是弱一致的。

      指定者:
      iterator 在接口 BlockingDeque<E>中
      指定者:
      iterator 在接口 Collection<E>中
      指定者:
      iterator 在接口 Deque<E>中
      指定者:
      iterator 在接口 Iterable<E>中
      指定者:
      iterator 在类 AbstractCollection<E>中
      返回:
      一个按正确顺序遍历此双端队列中元素的迭代器

    • descendingIterator

      public Iterator<E> descendingIterator()
      返回一个按相反顺序遍历此双端队列中元素的迭代器。元素将按从最后一个（尾部）到第一个（头部）的顺序返回。

      返回的迭代器是弱一致的。

      指定者:
      descendingIterator 在接口 Deque<E>中
      返回:
      一个按相反顺序遍历此双端队列中元素的迭代器

    • spliterator

      public Spliterator<E> spliterator()
      返回一个在此双端队列中元素上执行遍历的Spliterator。

      返回的Spliterator是弱一致的。

      Spliterator报告Spliterator.CONCURRENT、Spliterator.ORDERED和Spliterator.NONNULL。

      指定者:
      spliterator 在接口 Collection<E>中
      指定者:
      spliterator 在接口 Iterable<E>中
      实现注意:
      Spliterator实现了trySplit以允许有限的并行性。
      返回:
      一个在此双端队列中元素上执行遍历的Spliterator
      自从:
      1.8

    • forEach

      public void forEach(Consumer<? super E> action)
      从接口复制的描述: Iterable
      对Iterable的每个元素执行给定操作，直到所有元素都已处理或操作引发异常。如果指定了顺序，则按迭代顺序执行操作。操作引发的异常将传递给调用者。

      如果操作执行会修改元素的底层来源并产生副作用，则此方法的行为是未指定的，除非覆盖类已指定了并发修改策略。

      指定者:
      forEach 在接口 Iterable<E>中
      参数:
      action - 要对每个元素执行的操作
      抛出:
      NullPointerException - 如果指定的操作为null

    • removeIf

      public boolean removeIf(Predicate<? super E> filter)
      从接口复制的描述: Collection
      删除满足给定谓词的此集合的所有元素。在迭代期间抛出的错误或运行时异常或由谓词引发的异常将传递给调用者。
      指定者:
      removeIf 在接口 Collection<E>中
      参数:
      filter - 一个返回true以删除元素的谓词
      返回:
      如果有任何元素被删除，则返回true
      抛出:
      NullPointerException - 如果指定的过滤器为null

    • removeAll

      public boolean removeAll(Collection<?> c)
      从类复制的描述: AbstractCollection
      删除此集合中与指定集合中包含的所有元素相同的所有元素（可选操作）。调用返回后，此集合将不包含与指定集合中的元素相同的任何元素。
      指定者:
      removeAll 在接口 Collection<E>中
      覆盖:
      removeAll 在类 AbstractCollection<E>中
      参数:
      c - 包含要从此集合中删除的元素的集合
      返回:
      如果此调用导致集合发生更改，则返回true
      抛出:
      NullPointerException - 如果此集合包含一个或多个null元素，指定的集合不支持null元素（可选）或指定的集合为null
      参见:

    • retainAll

      public boolean retainAll(Collection<?> c)
      从类复制的描述: AbstractCollection
      仅保留此集合中包含在指定集合中的元素（可选操作）。换句话说，从此集合中删除不包含在指定集合中的所有元素。
      指定者:
      retainAll 在接口 Collection<E>中
      覆盖:
      retainAll 在类 AbstractCollection<E>中
      参数:
      c - 包含要在此集合中保留的元素的集合
      返回:
      如果此调用导致集合发生更改，则返回true
      抛出:
      NullPointerException - 如果此集合包含一个或多个null元素，指定的集合不允许null元素（可选）或指定的集合为null
      参见: