Most visited

Recently visited

Added in API level 1

PriorityBlockingQueue

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

java.lang.Object
   ↳ java.util.AbstractCollection<E>
     ↳ java.util.AbstractQueue<E>
       ↳ java.util.concurrent.PriorityBlockingQueue<E>


一个无界的blocking queue ,使用与PriorityQueue类相同的排序规则,并提供阻塞检索操作。 虽然此队列在逻辑上是无界的,但由于资源耗尽(导致OutOfMemoryError ),尝试添加可能会失败。 该课程不允许null元素。 依赖于natural ordering的优先级队列也不允许插入不可比较的对象(这样做会导致ClassCastException )。

该类及其迭代器实现CollectionIterator接口的所有可选方法。 保证方法iterator()提供的迭代器以任何特定顺序遍历PriorityBlockingQueue的元素。 如果您需要有序遍历,请考虑使用Arrays.sort(pq.toArray()) 此外,可以使用方法drainTo以优先级顺序删除部分或全部元素,并将它们放入另一个集合中。

对这个类的操作不保证具有同等优先级的元素的排序。 如果您需要强制执行排序,则可以定义使用辅助键的自定义类或比较器来打破主要优先级值中的关系。 例如,这里有一个类将先进先出的tie-breaking应用于可比较的元素。 要使用它,你需要插入一个new FIFOEntry(anEntry)而不是一个普通的入口对象。

 class FIFOEntry<E extends Comparable<? super E>>
     implements Comparable<FIFOEntry<E>> {
   static final AtomicLong seq = new AtomicLong(0);
   final long seqNum;
   final E entry;
   public FIFOEntry(E entry) {
     seqNum = seq.getAndIncrement();
     this.entry = entry;
   }
   public E getEntry() { return entry; }
   public int compareTo(FIFOEntry<E> other) {
     int res = entry.compareTo(other.entry);
     if (res == 0 && other.entry != this.entry)
       res = (seqNum < other.seqNum ? -1 : 1);
     return res;
   }
 }

Summary

Public constructors

PriorityBlockingQueue()

使用默认的初始容量(11)创建一个 PriorityBlockingQueue ,该初始容量根据它们的 natural ordering对其元素进行 排序

PriorityBlockingQueue(int initialCapacity)

用指定的初始容量创建一个 PriorityBlockingQueue ,该初始容量根据它们的 natural ordering对其元素进行 排序

PriorityBlockingQueue(int initialCapacity, Comparator<? super E> comparator)

用指定的初始容量创建一个 PriorityBlockingQueue ,根据指定的比较器对其元素进行排序。

PriorityBlockingQueue(Collection<? extends E> c)

创建一个包含指定集合中元素的 PriorityBlockingQueue

Public methods

boolean add(E e)

将指定的元素插入到此优先级队列中。

void clear()

从这个队列中删除所有元素。

Comparator<? super E> comparator()

返回用于为了在这个队列中的元素,或比较 null如果此队列使用 natural ordering的元素。

boolean contains(Object o)

如果此队列包含指定的元素,则返回 true

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

最多从此队列中移除给定数量的可用元素,并将它们添加到给定集合中。

int drainTo(Collection<? super E> c)

从该队列中移除所有可用的元素,并将它们添加到给定的集合中。

Iterator<E> iterator()

返回此队列中元素的迭代器。

boolean offer(E e)

将指定的元素插入到此优先级队列中。

boolean offer(E e, long timeout, TimeUnit unit)

将指定的元素插入到此优先级队列中。

E peek()

检索但不移除此队列的头部,或者如果此队列为空,则返回 null

E poll(long timeout, TimeUnit unit)

检索并删除此队列的头部,如果元素变为可用,则等待达到指定的等待时间。

E poll()

检索并删除此队列的头部,或者如果此队列为空,则返回 null

void put(E e)

将指定的元素插入到此优先级队列中。

int remainingCapacity()

始终返回 Integer.MAX_VALUE因为 PriorityBlockingQueue不受容量限制。

boolean remove(Object o)

从该队列中移除指定元素的单个实例(如果存在)。

int size()

返回此集合中的元素数量。

Spliterator<E> spliterator()

返回此队列中元素的 Spliterator

E take()

检索并删除此队列的头部,如果需要等待,直到元素变为可用。

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

返回包含此队列中所有元素的数组; 返回数组的运行时类型是指定数组的运行时类型。

Object[] toArray()

返回包含此队列中所有元素的数组。

String toString()

返回此集合的字符串表示形式。

Inherited methods

From class java.util.AbstractQueue
From class java.util.AbstractCollection
From class java.lang.Object
From interface java.util.Queue
From interface java.util.Collection
From interface java.util.concurrent.BlockingQueue
From interface java.lang.Iterable

Public constructors

PriorityBlockingQueue

Added in API level 1
PriorityBlockingQueue ()

使用默认的初始容量(11)创建一个 PriorityBlockingQueue ,该容量根据它们的 natural ordering对其元素进行 排序

PriorityBlockingQueue

Added in API level 1
PriorityBlockingQueue (int initialCapacity)

使用指定的初始容量创建一个 PriorityBlockingQueue ,根据它们的元素 natural ordering对其元素进行 排序

Parameters
initialCapacity int: the initial capacity for this priority queue
Throws
IllegalArgumentException if initialCapacity is less than 1

PriorityBlockingQueue

Added in API level 1
PriorityBlockingQueue (int initialCapacity, 
                Comparator<? super E> comparator)

用指定的初始容量创建一个 PriorityBlockingQueue ,根据指定的比较器对其元素进行排序。

Parameters
initialCapacity int: the initial capacity for this priority queue
comparator Comparator: the comparator that will be used to order this priority queue. If null, the natural ordering of the elements will be used.
Throws
IllegalArgumentException if initialCapacity is less than 1

PriorityBlockingQueue

Added in API level 1
PriorityBlockingQueue (Collection<? extends E> c)

创建一个包含指定集合中元素的PriorityBlockingQueue 如果指定的集合是SortedSetPriorityQueue ,则此优先级队列将按照相同的顺序排序。 否则,该优先级队列将根据其元素的natural ordering进行排序。

Parameters
c Collection: the collection whose elements are to be placed into this priority queue
Throws
ClassCastException if elements of the specified collection cannot be compared to one another according to the priority queue's ordering
NullPointerException if the specified collection or any of its elements are null

Public methods

add

Added in API level 1
boolean add (E e)

将指定的元素插入到此优先级队列中。

Parameters
e E: the element to add
Returns
boolean true (as specified by add(E))
Throws
ClassCastException if the specified element cannot be compared with elements currently in the priority queue according to the priority queue's ordering
NullPointerException if the specified element is null

clear

Added in API level 1
void clear ()

从这个队列中删除所有元素。 此通话返回后,队列将为空。

comparator

Added in API level 1
Comparator<? super E> comparator ()

返回用于为了在这个队列中的元素,或比较 null如果此队列使用 natural ordering的元素。

Returns
Comparator<? super E> the comparator used to order the elements in this queue, or null if this queue uses the natural ordering of its elements

contains

Added in API level 1
boolean contains (Object o)

如果此队列包含指定的元素,则返回true 更正式地,返回true当且仅当该队列包含至少一个元素e ,使得o.equals(e)

Parameters
o Object: object to be checked for containment in this queue
Returns
boolean true if this queue contains the specified element

drainTo

Added in API level 1
int drainTo (Collection<? super E> c, 
                int maxElements)

最多从此队列中移除给定数量的可用元素,并将它们添加到给定集合中。 尝试将元素添加到集合c遇到的故障可能导致元素不在任何集合中,或者在引发关联的异常时集合中的任何一个集合或两个集合都不在元素中。 尝试将队列IllegalArgumentException自身导致IllegalArgumentException 此外,如果在操作正在进行时修改了指定的集合,则此操作的行为未定义。

Parameters
c Collection: the collection to transfer elements into
maxElements int: the maximum number of elements to transfer
Returns
int the number of elements transferred
Throws
UnsupportedOperationException
ClassCastException
NullPointerException
IllegalArgumentException

drainTo

Added in API level 1
int drainTo (Collection<? super E> c)

从该队列中移除所有可用的元素,并将它们添加到给定的集合中。 该操作可能比重复轮询该队列更有效。 尝试将元素添加到集合c遇到的故障可能导致元素不在任何集合中,或者在引发关联异常时集合中的任何一个集合或两个集合都不在元素中。 尝试将队列IllegalArgumentException自身导致IllegalArgumentException 此外,如果在操作正在进行时修改了指定的集合,则此操作的行为未定义。

Parameters
c Collection: the collection to transfer elements into
Returns
int the number of elements transferred
Throws
UnsupportedOperationException
ClassCastException
NullPointerException
IllegalArgumentException

iterator

Added in API level 1
Iterator<E> iterator ()

返回此队列中元素的迭代器。 迭代器不会以任何特定顺序返回元素。

返回的迭代器是 weakly consistent

Returns
Iterator<E> an iterator over the elements in this queue

offer

Added in API level 1
boolean offer (E e)

将指定的元素插入到此优先级队列中。 由于队列是无界的,这个方法永远不会返回false

Parameters
e E: the element to add
Returns
boolean true (as specified by offer(E))
Throws
ClassCastException if the specified element cannot be compared with elements currently in the priority queue according to the priority queue's ordering
NullPointerException if the specified element is null

offer

Added in API level 1
boolean offer (E e, 
                long timeout, 
                TimeUnit unit)

将指定的元素插入到此优先级队列中。 由于队列无false ,此方法不会阻止或返回false

Parameters
e E: the element to add
timeout long: This parameter is ignored as the method never blocks
unit TimeUnit: This parameter is ignored as the method never blocks
Returns
boolean true (as specified by BlockingQueue.offer)
Throws
ClassCastException if the specified element cannot be compared with elements currently in the priority queue according to the priority queue's ordering
NullPointerException if the specified element is null

peek

Added in API level 1
E peek ()

检索但不移除此队列的头部,或者如果此队列为空,则返回 null

Returns
E the head of this queue, or null if this queue is empty

poll

Added in API level 1
E poll (long timeout, 
                TimeUnit unit)

检索并删除此队列的头部,如果元素变为可用,则等待达到指定的等待时间。

Parameters
timeout long: how long to wait before giving up, in units of unit
unit TimeUnit: a TimeUnit determining how to interpret the timeout parameter
Returns
E the head of this queue, or null if the specified waiting time elapses before an element is available
Throws
InterruptedException

poll

Added in API level 1
E poll ()

检索并删除此队列的头部,或者如果此队列为空,则返回 null

Returns
E the head of this queue, or null if this queue is empty

put

Added in API level 1
void put (E e)

将指定的元素插入到此优先级队列中。 由于队列是无界的,这个方法永远不会被阻塞。

Parameters
e E: the element to add
Throws
ClassCastException if the specified element cannot be compared with elements currently in the priority queue according to the priority queue's ordering
NullPointerException if the specified element is null

remainingCapacity

Added in API level 1
int remainingCapacity ()

始终返回 Integer.MAX_VALUE因为 PriorityBlockingQueue不受容量限制。

Returns
int Integer.MAX_VALUE always

remove

Added in API level 1
boolean remove (Object o)

从该队列中移除指定元素的单个实例(如果存在)。 更正式地说,删除一个元素e ,使得o.equals(e) ,如果这个队列包含一个或多个这样的元素。 返回true当且仅当此队列包含指定的元素(或者等价地,如果此队列由于调用而更改)。

Parameters
o Object: element to be removed from this queue, if present
Returns
boolean true if this queue changed as a result of the call

size

Added in API level 1
int size ()

返回此集合中的元素数量。 如果此集合包含多个Integer.MAX_VALUE元素,则返回Integer.MAX_VALUE

Returns
int the number of elements in this collection

spliterator

Added in API level 24
Spliterator<E> spliterator ()

返回此队列中元素的 Spliterator

返回的分割符是 weakly consistent

Spliterator报告 SIZEDNONNULL

Implementation Note:
  • The Spliterator additionally reports SUBSIZED.
Returns
Spliterator<E> a Spliterator over the elements in this queue

take

Added in API level 1
E take ()

检索并删除此队列的头部,如果需要等待,直到元素变为可用。

Returns
E the head of this queue
Throws
InterruptedException

toArray

Added in API level 1
T[] toArray (T[] a)

返回包含此队列中所有元素的数组; 返回数组的运行时类型是指定数组的运行时类型。 返回的数组元素没有特定的顺序。 如果队列适合指定的数组,则返回其中。 否则,将使用指定数组的运行时类型和此队列的大小分配一个新数组。

如果此队列符合指定数组并且有空余空间(即阵列中的元素数多于此队列数),则紧接队列尾部的阵列中的元素将设置为 null

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

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

 String[] y = x.toArray(new String[0]);
Note that toArray(new Object[0]) is identical in function to toArray().

Parameters
a T: the array into which the elements of the queue are to be stored, if it is big enough; otherwise, a new array of the same runtime type is allocated for this purpose
Returns
T[] an array containing all of the elements in this queue
Throws
ArrayStoreException if the runtime type of the specified array is not a supertype of the runtime type of every element in this queue
NullPointerException if the specified array is null

toArray

Added in API level 1
Object[] toArray ()

返回包含此队列中所有元素的数组。 返回的数组元素没有特定的顺序。

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

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

Returns
Object[] an array containing all of the elements in this queue

toString

Added in API level 1
String toString ()

返回此集合的字符串表示形式。 字符串表示由收集元素的列表组成,它们按其迭代器返回的顺序包含在方括号中( "[]" )。 相邻元素由字符", " (逗号和空格)分隔。 元素被转换为字符串,如valueOf(Object)

Returns
String a string representation of this collection

Hooray!