LinkedBlockingDeque (Java Platform SE 6) - JavaTM 2 Platform Standard Edition 6.0 API 规范中文版

概述

软件包

类

使用

树

已过时

索引

帮助

Java^TM Platform
Standard Ed. 6

上一个类 下一个类

框架 无框架

摘要：嵌套 | 字段 | 构造方法 | 方法

详细信息：字段 | 构造方法 | 方法

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
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()
          从此双端队列所表示的堆栈中弹出一个元素。

void push(E e)
          将元素推入此双端队列表示的栈。

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()` 创建一个容量为 `Integer.MAX_VALUE` 的 `LinkedBlockingDeque`。
`LinkedBlockingDeque(Collection<? extends E> c)` 创建一个容量为 `Integer.MAX_VALUE` 的 `LinkedBlockingDeque`，最初包含给定 collection 的元素，以该 collection 迭代器的遍历顺序添加。
`LinkedBlockingDeque(int capacity)` 创建一个具有给定（固定）容量的 `LinkedBlockingDeque`。

从类 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 复制的描述

将元素推入此双端队列表示的栈。换句话说，在不违反容量限制的情况下，将元素插入双端队列的开头。

此方法等效于 addFirst。

指定者：: 接口 BlockingDeque<E> 中的 push
指定者：: 接口 Deque<E> 中的 push

参数：: e - 要推入的元素
抛出：: IllegalStateException - 如果此时由于容量限制而无法添加元素; NullPointerException - 如果指定的元素为 null

pop

public E pop()

从接口 Deque 复制的描述

从此双端队列所表示的堆栈中弹出一个元素。换句话说，移除并返回此双端队列第一个元素。

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

指定者：: 接口 Deque<E> 中的 pop

返回：: 此双端队列开头的元素（它是此双端队列所表示的堆栈的顶部）
抛出：: NoSuchElementException - 如果此双端队列为空

remove

public boolean remove(Object o)

此方法等效于 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

返回：: 以逆向顺序在此双端队列中的元素上进行迭代的迭代器

概述

软件包

类

使用

树

已过时

索引

帮助

Java^TM Platform
Standard Ed. 6

上一个类 下一个类

框架 无框架

摘要：嵌套 | 字段 | 构造方法 | 方法

详细信息：字段 | 构造方法 | 方法

提交错误或意见
有关更多的 API 参考资料和开发人员文档，请参阅 Java SE 开发人员文档。该文档包含更详细的、面向开发人员的描述，以及总体概述、术语定义、使用技巧和工作代码示例。

LinkedBlockingDeque (Java Platform SE 6) - JavaTM 2 Platform Standard Edition 6.0 API 规范中文版

java.util.concurrent 类 LinkedBlockingDeque<E>

LinkedBlockingDeque

LinkedBlockingDeque

LinkedBlockingDeque

addFirst

addLast

offerFirst

offerLast

putFirst

putLast

offerFirst

offerLast

removeFirst

removeLast

pollFirst

pollLast

takeFirst

takeLast

pollFirst

pollLast

getFirst

getLast

peekFirst

peekLast

removeFirstOccurrence

removeLastOccurrence

add

offer

put

offer

remove

poll

take

poll

element

peek

remainingCapacity

drainTo

drainTo

push

pop

remove

size

contains

toArray

toArray

toString

clear

iterator

descendingIterator

java.util.concurrent
类 LinkedBlockingDeque<E>