模块 java.base
包 java.util.concurrent

类 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>
public class LinkedBlockingDeque<E> extends AbstractQueue <E> implements BlockingDeque <E>, Serializable
基于链接节点的可选边界 阻塞双端队列。

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

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

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

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

自从：
1.6
参见：

  • 构造方法总结

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

  • 方法总结

    修饰符和类型
    方法
    描述
    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)
    以正确的顺序返回一个包含此双端队列中所有元素的数组；返回数组的运行时类型是指定数组的类型。

    在类 java.util.AbstractCollection 中声明的方法

    containsAll, isEmpty, toString

    在类 java.lang.Object 中声明的方法

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

    在接口 java.util.Collection 中声明的方法

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

  • 构造方法详细信息

    • 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 - 如果指定的集合或其任何元素为空

  • 方法详情

    • addFirst

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

    • addLast

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

    • offerFirst

      public boolean offerFirst(E  e)
      从接口 BlockingDeque 复制的描述
      如果可以在不违反容量限制的情况下立即插入指定元素，则将指定元素插入此双端队列的前面，成功时返回 true，如果当前没有可用空间则返回 false。当使用容量受限的双端队列时，此方法通常优于 addFirst 方法，后者只能通过抛出异常来插入元素失败。
      指定者：
      offerFirst 在接口 BlockingDeque<E> 中
      指定者：
      offerFirst 在接口 Deque<E> 中
      参数：
      e - 要添加的元素
      返回：
      true 如果元素被添加到这个双端队列，否则 false
      抛出：
      NullPointerException - 如果指定元素为空

    • offerLast

      public boolean offerLast(E  e)
      从接口 BlockingDeque 复制的描述
      如果可以在不违反容量限制的情况下立即插入指定元素，则在此双端队列的末尾插入指定元素，成功时返回 true，如果当前没有可用空间则返回 false。当使用容量受限的双端队列时，此方法通常优于 addLast 方法，后者可能仅通过抛出异常来插入元素失败。
      指定者：
      offerLast 在接口 BlockingDeque<E> 中
      指定者：
      offerLast 在接口 Deque<E> 中
      参数：
      e - 要添加的元素
      返回：
      true 如果元素被添加到这个双端队列，否则 false
      抛出：
      NullPointerException - 如果指定元素为空

    • putFirst

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

    • putLast

      public void putLast(E  e) throws InterruptedException
      从接口 BlockingDeque 复制的描述
      在此双端队列的末尾插入指定的元素，必要时等待空间可用。
      指定者：
      putLast 在接口 BlockingDeque<E> 中
      参数：
      e - 要添加的元素
      抛出：
      NullPointerException - 如果指定元素为空
      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 - 如果指定元素为空
      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 - 如果指定元素为空
      InterruptedException - 如果在等待时被打断

    • removeFirst

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

    • removeLast

      public E  removeLast()
      从接口 Deque 复制的描述
      检索并删除此双端队列的最后一个元素。此方法与 pollLast 的不同之处仅在于，如果此双端队列为空，它会抛出异常。
      指定者：
      removeLast 在接口 Deque<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> 中
      返回：
      这个双端队列的头
      抛出：
      NoSuchElementException - 如果这个双端队列是空的

    • getLast

      public E  getLast()
      从接口 Deque 复制的描述
      检索但不删除此双端队列的最后一个元素。此方法与 peekLast 的不同之处仅在于，如果此双端队列为空，它会抛出异常。
      指定者：
      getLast 在接口 Deque<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 复制的描述
      从此双端队列中移除第一次出现的指定元素。如果双端队列不包含该元素，则它不变。更正式地说，删除第一个元素 e 这样 o.equals(e) （如果存在这样的元素）。如果此双端队列包含指定元素，则返回 true（或者等效地，如果此双端队列因调用而更改）。
      指定者：
      removeFirstOccurrence 在接口 BlockingDeque<E> 中
      指定者：
      removeFirstOccurrence 在接口 Deque<E> 中
      参数：
      o - 要从此双端队列中删除的元素（如果存在）
      返回：
      true 如果一个元素作为这个调用的结果被移除

    • removeLastOccurrence

      public boolean removeLastOccurrence(Object  o)
      从接口 BlockingDeque 复制的描述
      从此双端队列中移除指定元素的最后一次出现。如果双端队列不包含该元素，则它不变。更正式地说，删除最后一个元素 e 这样 o.equals(e) （如果存在这样的元素）。如果此双端队列包含指定元素，则返回 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 - 如果指定元素为空

    • 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 - 如果指定元素为空

    • put

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

      此方法等效于 putLast 。

      指定者：
      put 在接口 BlockingDeque<E> 中
      指定者：
      put 在接口 BlockingQueue<E> 中
      参数：
      e - 要添加的元素
      抛出：
      NullPointerException - 如果指定元素为空
      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 - 如果指定元素为空
      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。

      请注意，您 cannot 总是通过检查 remainingCapacity 来判断插入元素的尝试是否会成功，因为可能是另一个线程即将插入或删除元素的情况。

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

    • drainTo

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

    • drainTo

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

    • push

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

      此方法等效于 addFirst 。

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

    • 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。更正式地说，返回 true 当且仅当此双端队列包含至少一个元素 e 使得 o.equals(e) 。
      指定者：
      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 - 如果指定的集合或其任何元素为空
      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 - 如果指定数组为空

    • 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.CONCURRENT 、Spliterator.ORDERED 和 Spliterator.NONNULL 。

      指定者：
      spliterator 在接口 Collection<E> 中
      指定者：
      spliterator 在接口 Iterable<E> 中
      实现注意事项：
      Spliterator 实现 trySplit 以允许有限的并行性。
      返回：
      a Spliterator 在此双端队列中的元素上
      自从：
      1.8

    • forEach

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

      如果操作执行修改元素的底层源的副作用，则此方法的行为是未指定的，除非重写类已指定并发修改策略。

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

    • removeIf

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

    • removeAll

      public boolean removeAll(Collection <?> c)
      从类复制的描述：AbstractCollection
      删除此集合的所有也包含在指定集合中的元素（可选操作）。此调用返回后，此集合将不包含与指定集合共有的元素。
      指定者：
      removeAll 在接口 Collection<E> 中
      重写：
      removeAll 在类 AbstractCollection<E> 中
      参数：
      c - 包含要从此集合中删除的元素的集合
      返回：
      true 如果此集合因调用而更改
      抛出：
      NullPointerException - 如果此集合包含一个或多个空元素并且指定的集合不支持空元素 (optional)，或者如果指定的集合为空
      参见：

    • retainAll

      public boolean retainAll(Collection <?> c)
      从类复制的描述：AbstractCollection
      仅保留此集合中包含在指定集合中的元素（可选操作）。换句话说，从该集合中移除所有未包含在指定集合中的元素。
      指定者：
      retainAll 在接口 Collection<E> 中
      重写：
      retainAll 在类 AbstractCollection<E> 中
      参数：
      c - 包含要保留在此集合中的元素的集合
      返回：
      true 如果此集合因调用而更改
      抛出：
      NullPointerException - 如果此集合包含一个或多个空元素并且指定的集合不允许空元素 (optional)，或者如果指定的集合为空
      参见：