E - the type of elements held in this collectionpublic classPriorityQueue<E>extendsAbstractQueue<E>implementsSerializable
Comparator provided at queue construction time, depending on which constructor is used. A priority queue does not permitnull elements. A priority queue relying on natural ordering also does not permit insertion of non-comparable objects (doing so may result inClassCastException).Thehead of this queue is theleast element with respect to the specified ordering. If multiple elements are tied for least value, the head is one of those elements -- ties are broken arbitrarily. The queue retrieval operationspoll,remove,peek, andelement access the element at the head of the queue.
A priority queue is unbounded, but has an internalcapacity governing the size of an array used to store the elements on the queue. It is always at least as large as the queue size. As elements are added to a priority queue, its capacity grows automatically. The details of the growth policy are not specified.
This class and its iterator implement all of theoptional methods of theCollection andIterator interfaces. The Iterator provided in methoditerator() isnot guaranteed to traverse the elements of the priority queue in any particular order. If you need ordered traversal, consider usingArrays.sort(pq.toArray()).
Note that this implementation is not synchronized. Multiple threads should not access aPriorityQueue instance concurrently if any of the threads modifies the queue. Instead, use the thread-safePriorityBlockingQueue class.
Implementation note: this implementation provides O(log(n)) time for the enqueuing and dequeuing methods (offer,poll,remove() andadd); linear time for theremove(Object) andcontains(Object) methods; and constant time for the retrieval methods (peek,element, andsize).
This class is a member of the Java Collections Framework.
| Constructor | Description |
|---|---|
PriorityQueue() | Creates a PriorityQueue with the default initial capacity (11) that orders its elements according to theirnatural ordering. |
PriorityQueue(Collection<? extendsE> c) | Creates a PriorityQueue containing the elements in the specified collection. |
PriorityQueue(Comparator<? superE> comparator) | Creates a PriorityQueue with the default initial capacity and whose elements are ordered according to the specified comparator. |
PriorityQueue(int initialCapacity) | Creates a PriorityQueue with the specified initial capacity that orders its elements according to theirnatural ordering. |
PriorityQueue(int initialCapacity,Comparator<? superE> comparator) | Creates a PriorityQueue with the specified initial capacity that orders its elements according to the specified comparator. |
PriorityQueue(PriorityQueue<? extendsE> c) | Creates a PriorityQueue containing the elements in the specified priority queue. |
PriorityQueue(SortedSet<? extendsE> c) | Creates a PriorityQueue containing the elements in the specified sorted set. |
| Modifier and Type | Method | Description |
|---|---|---|
boolean | add(E e) | Inserts the specified element into this priority queue. |
void | clear() | Removes all of the elements from this priority queue. |
Comparator<? superE> | comparator() | Returns the comparator used to order the elements in this queue, or null if this queue is sorted according to thenatural ordering of its elements. |
boolean | contains(Object o) | Returns true if this queue contains the specified element. |
Iterator<E> | iterator() | Returns an iterator over the elements in this queue. |
boolean | offer(E e) | Inserts the specified element into this priority queue. |
E | peek() | Retrieves, but does not remove, the head of this queue, or returns null if this queue is empty. |
E | poll() | Retrieves and removes the head of this queue, or returns null if this queue is empty. |
boolean | remove(Object o) | Removes a single instance of the specified element from this queue, if it is present. |
int | size() | Returns the number of elements in this collection. |
Spliterator<E> | spliterator() | Creates alate-binding andfail-fast Spliterator over the elements in this queue. |
Object[] | toArray() | Returns an array containing all of the elements in this queue. |
<T> T[] | toArray(T[] a) | Returns an array containing all of the elements in this queue; the runtime type of the returned array is that of the specified array. |
addAll,element,removecontainsAll,isEmpty,removeAll,retainAll,toStringclone,equals,finalize,getClass,hashCode,notify,notifyAll,wait,wait,waitcontainsAll,equals,hashCode,isEmpty,parallelStream,removeAll,removeIf,retainAll,streampublic PriorityQueue()
PriorityQueue with the default initial capacity (11) that orders its elements according to theirnatural ordering.public PriorityQueue(int initialCapacity)
PriorityQueue with the specified initial capacity that orders its elements according to theirnatural ordering.initialCapacity - the initial capacity for this priority queueIllegalArgumentException - ifinitialCapacity is less than 1public PriorityQueue(Comparator<? superE> comparator)
PriorityQueue with the default initial capacity and whose elements are ordered according to the specified comparator.comparator - the comparator that will be used to order this priority queue. Ifnull, thenatural ordering of the elements will be used.public PriorityQueue(int initialCapacity,Comparator<? superE> comparator)
PriorityQueue with the specified initial capacity that orders its elements according to the specified comparator.initialCapacity - the initial capacity for this priority queuecomparator - the comparator that will be used to order this priority queue. Ifnull, thenatural ordering of the elements will be used.IllegalArgumentException - ifinitialCapacity is less than 1public PriorityQueue(Collection<? extendsE> c)
PriorityQueue containing the elements in the specified collection. If the specified collection is an instance of aSortedSet or is anotherPriorityQueue, this priority queue will be ordered according to the same ordering. Otherwise, this priority queue will be ordered according to thenatural ordering of its elements.c - the collection whose elements are to be placed into this priority queueClassCastException - if elements of the specified collection cannot be compared to one another according to the priority queue's orderingNullPointerException - if the specified collection or any of its elements are nullpublic PriorityQueue(PriorityQueue<? extendsE> c)
PriorityQueue containing the elements in the specified priority queue. This priority queue will be ordered according to the same ordering as the given priority queue.c - the priority queue whose elements are to be placed into this priority queueClassCastException - if elements ofc cannot be compared to one another according toc's orderingNullPointerException - if the specified priority queue or any of its elements are nullpublic PriorityQueue(SortedSet<? extendsE> c)
PriorityQueue containing the elements in the specified sorted set. This priority queue will be ordered according to the same ordering as the given sorted set.c - the sorted set whose elements are to be placed into this priority queueClassCastException - if elements of the specified sorted set cannot be compared to one another according to the sorted set's orderingNullPointerException - if the specified sorted set or any of its elements are nullpublic boolean add(E e)
add in interface Collection<E>add in interface Queue<E>add in class AbstractQueue<E>e - the element to addtrue (as specified byCollection.add(E))ClassCastException - if the specified element cannot be compared with elements currently in this priority queue according to the priority queue's orderingNullPointerException - if the specified element is nullpublic boolean offer(E e)
offer in interface Queue<E>e - the element to addtrue (as specified byQueue.offer(E))ClassCastException - if the specified element cannot be compared with elements currently in this priority queue according to the priority queue's orderingNullPointerException - if the specified element is nullpublic E peek()
Queuenull if this queue is empty.public boolean remove(Object o)
e such thato.equals(e), if this queue contains one or more such elements. Returnstrue if and only if this queue contained the specified element (or equivalently, if this queue changed as a result of the call).remove in interface Collection<E>remove in class AbstractCollection<E>o - element to be removed from this queue, if presenttrue if this queue changed as a result of the callpublic boolean contains(Object o)
true if this queue contains the specified element. More formally, returnstrue if and only if this queue contains at least one elemente such thato.equals(e).contains in interface Collection<E>contains in class AbstractCollection<E>o - object to be checked for containment in this queuetrue if this queue contains the specified elementpublic Object[] toArray()
The returned array will be "safe" in that no references to it are maintained by this queue. (In other words, this method must allocate a new array). The caller is thus free to modify the returned array.
This method acts as bridge between array-based and collection-based APIs.
toArray in interface Collection<E>toArray in class AbstractCollection<E>public <T> T[] toArray(T[] a)
If the queue fits in the specified array with room to spare (i.e., the array has more elements than the queue), the element in the array immediately following the end of the collection is set tonull.
Like thetoArray() method, this method acts as bridge between array-based and collection-based APIs. Further, this method allows precise control over the runtime type of the output array, and may, under certain circumstances, be used to save allocation costs.
Supposex is a queue known to contain only strings. The following code can be used to dump the queue into a newly allocated array ofString:
String[] y = x.toArray(new String[0]);toArray(new Object[0]) is identical in function totoArray().toArray in interface Collection<E>toArray in class AbstractCollection<E>T - the runtime type of the array to contain the collectiona - 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.ArrayStoreException - if the runtime type of the specified array is not a supertype of the runtime type of every element in this queueNullPointerException - if the specified array is nullpublic Iterator<E> iterator()
iterator in interface Iterable<E>iterator in interface Collection<E>iterator in class AbstractCollection<E>public int size()
Collectionsize in interface Collection<E>size in class AbstractCollection<E>public void clear()
clear in interface Collection<E>clear in class AbstractQueue<E>public E poll()
Queuenull if this queue is empty.public Comparator<? superE> comparator()
null if this queue is sorted according to thenatural ordering of its elements.null if this queue is sorted according to the natural ordering of its elementspublic final Spliterator<E> spliterator()
Spliterator over the elements in this queue.TheSpliterator reportsSpliterator.SIZED,Spliterator.SUBSIZED, andSpliterator.NONNULL. Overriding implementations should document the reporting of additional characteristic values.
spliterator in interface Iterable<E>spliterator in interface Collection<E>Spliterator over the elements in this queue