java.applet

java.awt

java.awt.color

java.awt.datatransfer

java.awt.dnd

java.awt.event

java.awt.font

java.awt.geom

java.awt.im

java.awt.im.spi

java.awt.image

java.awt.image.renderable

java.awt.print

java.beans

java.beans.beancontext

java.io

java.lang

java.lang.annotation

java.lang.instrument

java.lang.management

java.lang.ref

java.lang.reflect

java.math

java.net

java.nio

java.nio.channels

java.nio.channels.spi

java.nio.charset

java.nio.charset.spi

java.rmi

java.rmi.activation

java.rmi.dgc

java.rmi.registry

java.rmi.server

java.security

java.security.acl

java.security.cert

java.security.interfaces

java.security.spec

java.sql

java.text

java.util

java.util.concurrent

java.util.concurrent.atomic

java.util.concurrent.locks

java.util.jar

java.util.logging

java.util.prefs

java.util.regex

java.util.zip

javax.accessibility

javax.activity

javax.crypto

javax.crypto.interfaces

javax.crypto.spec

javax.imageio

javax.imageio.event

javax.imageio.metadata

javax.imageio.plugins.bmp

javax.imageio.plugins.jpeg

javax.imageio.spi

javax.imageio.stream

javax.management

javax.management.loading

javax.management.modelmbean

javax.management.monitor

javax.management.openmbean

javax.management.relation

javax.management.remote

javax.management.remote.rmi

javax.management.timer

javax.naming

javax.naming.directory

javax.naming.event

javax.naming.ldap

javax.naming.spi

javax.net

javax.net.ssl

javax.print

javax.print.attribute

javax.print.attribute.standard

javax.print.event

javax.rmi

javax.rmi.CORBA

javax.rmi.ssl

javax.security.auth

javax.security.auth.callback

javax.security.auth.kerberos

javax.security.auth.login

javax.security.auth.spi

javax.security.auth.x500

javax.security.cert

javax.security.sasl

javax.sound.midi

javax.sound.midi.spi

javax.sound.sampled

javax.sound.sampled.spi

javax.sql

javax.sql.rowset

javax.sql.rowset.serial

javax.sql.rowset.spi

javax.swing

javax.swing.border

javax.swing.colorchooser

javax.swing.event

javax.swing.filechooser

javax.swing.plaf

javax.swing.plaf.basic

javax.swing.plaf.metal

javax.swing.plaf.multi

javax.swing.plaf.synth

javax.swing.table

javax.swing.text

javax.swing.text

javax.swing.text.parser

javax.swing.text.rtf

javax.swing.tree

javax.swing.undo

javax.transaction

javax.transaction.xa

javax.xml

javax.xml.datatype

javax.xml.namespace

javax.xml.parsers

javax.xml.transform

javax.xml.transform.dom

javax.xml.transform.sax

javax.xml.transform.stream

javax.xml.validation

javax.xml.xpath

org.ietf.jgss

org.omg.CORBA

org.omg.CORBA_2_3

org.omg.CORBA_2_3.portable

org.omg.CORBA.DynAnyPackage

org.omg.CORBA.ORBPackage

org.omg.CORBA.portable

org.omg.CORBA.TypeCodePackage

org.omg.CosNaming

org.omg.CosNaming.NamingContextExtPackage

org.omg.CosNaming.NamingContextPackage

org.omg.Dynamic

org.omg.DynamicAny

org.omg.DynamicAny.DynAnyFactoryPackage

org.omg.DynamicAny.DynAnyPackage

org.omg.IOP

org.omg.IOP.CodecFactoryPackage

org.omg.IOP.CodecPackage

org.omg.Messaging

org.omg.PortableInterceptor

org.omg.PortableInterceptor.ORBInitInfoPackage

org.omg.PortableServer

org.omg.PortableServer.CurrentPackage

org.omg.PortableServer.POAManagerPackage

org.omg.PortableServer.POAPackage

org.omg.PortableServer.portable

org.omg.PortableServer.ServantLocatorPackage

org.omg.SendingContext

org.omg.stub.java.rmi

org.w3c.dom

org.w3c.dom.bootstrap

org.w3c.dom.events

org.w3c.dom.ls

org.xml.sax

org.xml.sax.ext

org.xml.sax.helpers

allclasses-frame

allclasses-noframe

constant-values

deprecated-list

help-doc

JavaTM 2 Platform
Standard Ed. 5.0

java.util.concurrent
类 PriorityBlockingQueue<E>

java.lang.Object
  继承者 java.util.AbstractCollection<E>
      继承者 java.util.AbstractQueue<E>
          继承者 java.util.concurrent.PriorityBlockingQueue<E>
类型参数:
E - 此集合中所保存元素的类型。
所有已实现的接口:
Serializable, Iterable<E>, Collection<E>, BlockingQueue<E>, Queue<E>

public class PriorityBlockingQueue<E>
extends AbstractQueue<E>
implements BlockingQueue<E>, Serializable

一个无界的阻塞队列,它使用与类 PriorityQueue 相同的顺序规则,并且提供了阻塞检索的操作。虽然此队列逻辑上是无界的,但是由于资源被耗尽,所以试图执行添加操作可能会失败(导致 OutOfMemoryError)。此类不允许使用 null 元素。依赖自然顺序的优先级队列也不允许插入不可比较的对象(因为这样做会抛出 ClassCastException)。

此类及其迭代器可以实现 CollectionIterator 接口的所有可选 方法。iterator() 方法中所提供的迭代器并 保证以特定的顺序遍历 PriorityBlockingQueue 的元素。如果需要有序地遍历,则应考虑使用 Arrays.sort(pq.toArray())

此类是 Java Collections Framework 的成员。

从以下版本开始:
1.5
另请参见:
序列化表格

构造方法摘要
PriorityBlockingQueue()
          用默认的初始容量 (11) 创建一个 PriorityBlockingQueue,并根据元素的自然顺序排序其元素(使用 Comparable)。
PriorityBlockingQueue(Collection<? extends E> c)
          创建一个包含指定集合中元素的 PriorityBlockingQueue
PriorityBlockingQueue(int initialCapacity)
          使用指定的初始容量创建一个 PriorityBlockingQueue,并根据元素的自然顺序排序其元素(使用 Comparable)。
PriorityBlockingQueue(int initialCapacity, Comparator<? super E> comparator)
          使用指定的初始容量创建一个 PriorityBlockingQueue,并根据指定的比较器排序其元素。
 
方法摘要
 boolean add(E o)
          向此队列添加指定的元素。
 void clear()
          完全移除队列中的所有元素。
 Comparator<? super E> comparator()
          返回对此集合进行排序的比较器,如果此集合根据其元素的自然顺序排序(使用 Comparable),则返回 null
 boolean contains(Object o)
          如果此 collection 包含指定的元素,则返回 true
 int drainTo(Collection<? super E> c)
          移除此队列中所有可用的元素,并将它们添加到给定 collection 中。
 int drainTo(Collection<? super E> c, int maxElements)
          最多从此队列中移除给定数量的可用元素,并将这些元素添加到给定 collection 中。
 Iterator<E> iterator()
          返回对此队列中的元素进行迭代的迭代器。
 boolean offer(E o)
          将指定的元素插入到优先级队列中。
 boolean offer(E o, long timeout, TimeUnit unit)
          将指定的元素插入到优先级队列中。
 E peek()
          检索,但是不移除此队列的头,如果此队列为空,则返回 null
 E poll()
          检索并移除此队列的头,如果此队列为空,则返回 null
 E poll(long timeout, TimeUnit unit)
          检索并移除此队列的头部,如果此队列中没有任何元素,则等待指定等待的时间(如果有必要)。
 void put(E o)
          将指定的元素添加到优先级队列中。
 int remainingCapacity()
          总是返回 Integer.MAX_VALUE,因为 PriorityBlockingQueue 没有容量限制。
 boolean remove(Object o)
          从队列中移除指定元素的单个实例(如果存在)。
 int size()
          返回此 collection 中的元素数。
 E take()
          检索并移除此队列的头部,如果此队列不存在任何元素,则一直等待。
 Object[] toArray()
          返回包含此 collection 中所有元素的数组。
<T> T[]
toArray(T[] a)
          返回包含此 collection 中所有元素的数组;返回数组的运行时类型是指定数组的类型。
 String toString()
          返回此 collection 的字符串表示形式。
 
从类 java.util.AbstractQueue 继承的方法
addAll, element, remove
 
从类 java.util.AbstractCollection 继承的方法
containsAll, isEmpty, removeAll, retainAll
 
从类 java.lang.Object 继承的方法
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait
 
从接口 java.util.Queue 继承的方法
element, remove
 
从接口 java.util.Collection 继承的方法
addAll, containsAll, equals, hashCode, isEmpty, removeAll, retainAll
 

构造方法详细信息

PriorityBlockingQueue

public PriorityBlockingQueue()
用默认的初始容量 (11) 创建一个 PriorityBlockingQueue,并根据元素的自然顺序排序其元素(使用 Comparable)。


PriorityBlockingQueue

public PriorityBlockingQueue(int initialCapacity)
使用指定的初始容量创建一个 PriorityBlockingQueue,并根据元素的自然顺序排序其元素(使用 Comparable)。

参数:
initialCapacity - 此优先级队列的初始容量。
抛出:
IllegalArgumentException - 如果 initialCapacity 小于 1。

PriorityBlockingQueue

public PriorityBlockingQueue(int initialCapacity,
                             Comparator<? super E> comparator)
使用指定的初始容量创建一个 PriorityBlockingQueue,并根据指定的比较器排序其元素。

参数:
initialCapacity - 此优先级队列的初始容量。
comparator - 用于对此优先级队列进行排序的比较器。如果参数为 null,则根据元素的自然顺序排序。
抛出:
IllegalArgumentException - 如果 initialCapacity 小于 1。

PriorityBlockingQueue

public PriorityBlockingQueue(Collection<? extends E> c)
创建一个包含指定集合中元素的 PriorityBlockingQueue。优先级队列的初始容量是指定集合大小的 110%。如果指定的集合是 SortedSetPriorityQueue,那么此优先级队列将根据相同的比较器进行排序,如果集合根据其元素的自然顺序排序,则此队列也根据集合元素的自然顺序排序。否则,此优先级队列根据其元素的自然顺序排序。

参数:
c - 集合,其元素将被添加到此优先级队列中。
抛出:
ClassCastException - 如果根据优先级队列的排序规则无法相互比较指定集合的元素。
NullPointerException - 如果 c 或其中的任意元素为 null
方法详细信息

add

public boolean add(E o)
向此队列添加指定的元素。

指定者:
接口 Collection<E> 中的 add
指定者:
接口 BlockingQueue<E> 中的 add
覆盖:
AbstractQueue<E> 中的 add
参数:
o - 要添加的元素。
返回:
true(按照 Collection.add 的常规协定)。
抛出:
NullPointerException - 如果指定的元素为 null
ClassCastException - 如果根据优先级队列的排序规则,无法将指定的元素与优先级队列中当前的元素进行比较。

comparator

public Comparator<? super E> comparator()
返回对此集合进行排序的比较器,如果此集合根据其元素的自然顺序排序(使用 Comparable),则返回 null

返回:
对此集合进行排序的比较器,如果此集合根据其元素的自然顺序排序,则返回 null

offer

public boolean offer(E o)
将指定的元素插入到优先级队列中。

指定者:
接口 BlockingQueue<E> 中的 offer
指定者:
接口 Queue<E> 中的 offer
参数:
o - 所添加的元素。
返回:
true
抛出:
ClassCastException - 如果根据优先级队列的排序规则无法将指定的元素与优先级队列中当前的元素进行比较。
NullPointerException - 如果指定的元素为 null

put

public void put(E o)
将指定的元素添加到优先级队列中。由于该队列是无界的,所以此方法永远不会被阻塞。

指定者:
接口 BlockingQueue<E> 中的 put
参数:
o - 要添加的元素。
抛出:
ClassCastException - 如果根据优先级队列的排序规则无法将该元素与优先级队列中当前的元素进行比较。
NullPointerException - 如果指定的元素为 null

offer

public boolean offer(E o,
                     long timeout,
                     TimeUnit unit)
将指定的元素插入到优先级队列中。由于该队列是无界的,所以永远不会阻塞此方法。

指定者:
接口 BlockingQueue<E> 中的 offer
参数:
o - 要添加的元素。
timeout - 忽略此参数,因为永远不会阻塞此方法。
unit - 忽略此参数,因为永远不会阻塞此方法。
返回:
true
抛出:
ClassCastException - 如果根据优先级队列的排序规则无法将该元素与优先级队列中当前的元素进行比较。
NullPointerException - 如果指定的元素为 null

take

public E take()
       throws InterruptedException
从接口 BlockingQueue 复制的描述
检索并移除此队列的头部,如果此队列不存在任何元素,则一直等待。

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

poll

public E poll()
从接口 Queue 复制的描述
检索并移除此队列的头,如果此队列为空,则返回 null

指定者:
接口 Queue<E> 中的 poll
返回:
队列的头,如果此队列为空,则返回 null

poll

public E poll(long timeout,
              TimeUnit unit)
       throws InterruptedException
从接口 BlockingQueue 复制的描述
检索并移除此队列的头部,如果此队列中没有任何元素,则等待指定等待的时间(如果有必要)。

指定者:
接口 BlockingQueue<E> 中的 poll
参数:
timeout - 放弃之前等待的时间长度,以 unit 为时间单位
unit - 确定如何解释 timeout 参数的 TimeUnit
返回:
此队列的头部;如果在元素出现前超过了指定的等待时间,则返回 null
抛出:
InterruptedException - 如果在等待时被中断。

peek

public E peek()
从接口 Queue 复制的描述
检索,但是不移除此队列的头,如果此队列为空,则返回 null

指定者:
接口 Queue<E> 中的 peek
返回:
队列的头,如果此队列为空,则返回 null

size

public int size()
从类 AbstractCollection 复制的描述
返回此 collection 中的元素数。如果该 collection 包含多于 Integer.MAX_VALUE 的元素,则返回 Integer.MAX_VALUE

指定者:
接口 Collection<E> 中的 size
指定者:
AbstractCollection<E> 中的 size
返回:
此 collection 中的元素数。

remainingCapacity

public int remainingCapacity()
总是返回 Integer.MAX_VALUE,因为 PriorityBlockingQueue 没有容量限制。

指定者:
接口 BlockingQueue<E> 中的 remainingCapacity
返回:
Integer.MAX_VALUE

remove

public boolean remove(Object o)
从队列中移除指定元素的单个实例(如果存在)。

指定者:
接口 Collection<E> 中的 remove
覆盖:
AbstractCollection<E> 中的 remove
参数:
o - 要从此 collection 中移除的元素(如果存在)。
返回:
如果该 collection 包含指定的元素,则返回 true

contains

public boolean contains(Object o)
从类 AbstractCollection 复制的描述
如果此 collection 包含指定的元素,则返回 true。更正式地说,当且仅当此 collection 至少包含一个满足以下条件的元素 e 时才返回 true(o==null ? e==null : o.equals(e))

此实现迭代该 collection 中的元素,并依次检查每个元素以确定其是否与指定的元素相等。

指定者:
接口 Collection<E> 中的 contains
覆盖:
AbstractCollection<E> 中的 contains
参数:
o - 要检查的对象,以确定其是否包含在此 collection 中。
返回:
如果此 collection 包含指定的元素,则返回 true

toArray

public Object[] toArray()
从类 AbstractCollection 复制的描述
返回包含此 collection 中所有元素的数组。如果此 collection 保证其迭代器按顺序返回其元素,那么此方法也必须按相同的顺序返回这些元素。返回的数组将是“安全的”,因为此 collection 并不维护对返回数组的任何引用。(换句话说,即使 collection 受到数组的支持,此方法也必须分配一个新的数组)。因此,调用方可以随意修改返回的数组。

此实现会分配返回的数组,并迭代 collection 中的元素,将每个对象引用存储在数组的下一个连续元素中,并从元素 0 开始。

指定者:
接口 Collection<E> 中的 toArray
覆盖:
AbstractCollection<E> 中的 toArray
返回:
包含此 collection 中所有元素的数组。

toString

public String toString()
从类 AbstractCollection 复制的描述
返回此 collection 的字符串表示形式。该字符串表示形式由 collection 元素的列表组成,这些元素按其迭代器返回的顺序排列,并用方括号 ("[]") 括起来。相邻元素由字符 ", "(逗号加空格)分隔。通过 String.valueOf(Object) 可以将元素转换成字符串。

此实现会创建一个空字符串缓冲区,追加一个左方括号,然后在 collection 上进行迭代,依次追加每个元素的字符串表示形式。每追加一个元素后(最后一个元素除外),将追加字符串 ", "。最后,追加一个右括号。从字符串缓冲区获取一个字符串并返回它。

覆盖:
AbstractCollection<E> 中的 toString
返回:
此 collection 的字符串表示形式。

drainTo

public int drainTo(Collection<? super E> c)
从接口 BlockingQueue 复制的描述
移除此队列中所有可用的元素,并将它们添加到给定 collection 中。此操作可能比反复轮询此队列更有效。在试图向 c 集合中 add 元素没有成功时,可能导致在抛出相关异常时,元素会同时在两个 collection 中出现,或者在其中一个 collection 中出现,也可能在两个 collection 中都不出现。如果试图将一个队列放入自身队列中,则会导致 IllegalArgumentException 异常。此外,如果正在进行此操作时修改指定的 collection,则此操作行为是不确定的。

指定者:
接口 BlockingQueue<E> 中的 drainTo
参数:
c - 接收传输元素的 collection
返回:
传输元素的数量。

drainTo

public int drainTo(Collection<? super E> c,
                   int maxElements)
从接口 BlockingQueue 复制的描述
最多从此队列中移除给定数量的可用元素,并将这些元素添加到给定 collection 中。在试图向 c 集合中 add 元素没有成功时,可能导致在抛出相关异常时,元素会同时在两个 collection 中出现,或者在其中一个 collection 中出现,也可能在两个 collection 中都不出现。如果试图将一个队列放入自身队列中,则会导致 IllegalArgumentException 异常。此外,如果正在进行此操作时修改指定的 collection,则此操作行为是不确定的。

指定者:
接口 BlockingQueue<E> 中的 drainTo
参数:
c - 接收传输元素的 collection
maxElements - 传输元素的最大数量
返回:
传输元素的数量。

clear

public void clear()
完全移除队列中的所有元素。此调用返回后队列为空。

指定者:
接口 Collection<E> 中的 clear
覆盖:
AbstractQueue<E> 中的 clear

toArray

public <T> T[] toArray(T[] a)
从类 AbstractCollection 复制的描述
返回包含此 collection 中所有元素的数组;返回数组的运行时类型是指定数组的类型。如果指定的数组能容纳该 collection,则在此数组中返回 collection 的元素。否则,将根据指定数组的运行时类型和此 collection 的大小分配一个新数组。

如果指定的数组能容纳 collection,并且有剩余的空间(即数组的元素比 collection 多),那么会将紧挨着 collection 尾部的元素设置为 null(这对确定 collection 的长度很有用,但只有 在调用方知道 collection 不包含任何 null 元素时才可行)。

如果此 collection 保证其迭代器按顺序返回其元素,那么此方法也必须按相同的顺序返回这些元素。

此实现会检查该数组是否足够大,以包含该 collection 中的元素;如果不能包含,则将分配一个具有适当大小和类型的新数组(使用反射)。然后,在该 collection 上进行迭代,将每个对象引用存储在数组的下一个连续元素中,并从元素 0 开始。如果该数组比该 collection 大,则在该 collection 尾部后面的第一个位置存储 null

指定者:
接口 Collection<E> 中的 toArray
覆盖:
AbstractCollection<E> 中的 toArray
参数:
a - 存储此 collection 的元素的数组(如果其足够大);否则,将为此分配一个具有相同运行时类型的新数组。
返回:
包含此 collection 的元素的数组。

iterator

public Iterator<E> iterator()
返回对此队列中的元素进行迭代的迭代器。迭代器不以任何特定的顺序返回元素。返回的迭代器是一个线程安全的“快速失败”迭代器,它一旦检测到冲突即抛出 ConcurrentModificationException

指定者:
接口 Iterable<E> 中的 iterator
指定者:
接口 Collection<E> 中的 iterator
指定者:
AbstractCollection<E> 中的 iterator
返回:
对此队列中的元素进行迭代的迭代器。

JavaTM 2 Platform
Standard Ed. 5.0

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

版权所有 2004 Sun Microsystems, Inc. 保留所有权利。 请遵守许可证条款。另请参阅文档重新分发政策