java.lang.Object
- java.util.AbstractCollection<E>
- - java.util.AbstractQueue<E>
  - - java.util.PriorityQueue<E>

参数类型

E - 此队列中保留的元素类型

实现的所有接口

Serializable ， Iterable<E> ， Collection<E> ， Queue<E>
```
public class PriorityQueue<E>
extends AbstractQueue<E>
implements Serializable
```
基于优先级堆的无界优先级queue 。优先级队列的元素根据其natural ordering或队列构造时提供的Comparator进行排序，具体取决于使用的构造函数。优先级队列不允许null元素。依赖于自然排序的优先级队列也不允许插入不可比较的对象（这样做可能导致ClassCastException ）。
此队列的头部是指定排序的最小元素。如果多个元素被绑定为最小值，则头部是这些元素之一 - 关系被任意打破。队列检索操作poll ， remove ， peek ，和element访问在队列的头部的元件。

优先级队列是无限制的，但具有内部容量，用于控制用于存储队列中元素的数组的大小。它始终至少与队列大小一样大。当元素添加到优先级队列时，其容量会自动增加。未指定增长政策的详细信息。

该类及其迭代器实现了Collection和Iterator接口的所有可选方法。方法iterator()中提供的迭代器和方法spliterator()中提供的Spliterator 不保证以任何特定顺序遍历优先级队列的元素。如果您需要有序遍历，请考虑使用Arrays.sort(pq.toArray()) 。

请注意，此实现不同步。 如果任何线程修改队列，则多个线程不应同时访问PriorityQueue实例。而是使用线程安全的PriorityBlockingQueue类。

实现注意事项：此实现提供了O（日志（n））的时间入队和出队方法（ offer ， poll ， remove()和add ）; 线性时间为remove(Object)和contains(Object)方法; 和恒定时间检索方法（ peek ， element ，和size ）。

此类是Java Collections Framework的成员。

从以下版本开始：

1.5

另请参见：

Serialized Form

构造方法摘要

构造方法
构造器	描述
`PriorityQueue()`	使用默认初始容量（11）创建`PriorityQueue` ，根据其natural ordering对其元素进行排序。
`PriorityQueue(int initialCapacity)`	创建具有指定初始容量的`PriorityQueue` ，该容量根据其natural ordering对其元素进行排序。
`PriorityQueue(int initialCapacity, Comparator<? super E> comparator)`	创建具有指定初始容量的 `PriorityQueue` ，该容量根据指定的比较器对其元素进行排序。
`PriorityQueue(Collection<? extends E> c)`	创建包含指定集合中的元素的 `PriorityQueue` 。
`PriorityQueue(Comparator<? super E> comparator)`	创建具有默认初始容量的 `PriorityQueue` ，其元素根据指定的比较器进行排序。
`PriorityQueue(PriorityQueue<? extends E> c)`	创建包含指定优先级队列中的元素的 `PriorityQueue` 。
`PriorityQueue(SortedSet<? extends E> c)`	创建一个 `PriorityQueue`其中包含指定有序集合中的元素。

方法摘要

所有方法实例方法具体的方法
变量和类型	方法	描述
`boolean`	`add(E e)`	将指定的元素插入此优先级队列。
`void`	`clear()`	从此优先级队列中删除所有元素。
`Comparator<? super E>`	`comparator()`	返回用于为了在这个队列中的元素，或比较`null`如果此队列根据所述排序natural ordering的元素。
`boolean`	`contains(Object o)`	如果此队列包含指定的元素，则返回 `true` 。
`void`	`forEach(Consumer<? super E> action)`	对 `Iterable`每个元素执行给定操作，直到处理 `Iterable`所有元素或操作引发异常。
`Iterator<E>`	`iterator()`	返回此队列中元素的迭代器。
`boolean`	`offer(E e)`	将指定的元素插入此优先级队列。
`boolean`	`remove(Object o)`	从此队列中删除指定元素的单个实例（如果存在）。
`boolean`	`removeAll(Collection<?> c)`	删除此集合的所有元素，这些元素也包含在指定的集合中（可选操作）。
`boolean`	`removeIf(Predicate<? super E> filter)`	删除此集合中满足给定谓词的所有元素。
`boolean`	`retainAll(Collection<?> c)`	仅保留此集合中包含在指定集合中的元素（可选操作）。
`Spliterator<E>`	`spliterator()`	在此队列中的元素上创建late-binding和故障快速 `Spliterator` 。
`Object[]`	`toArray()`	返回包含此队列中所有元素的数组。
`<T> T[]`	`toArray(T[] a)`	返回包含此队列中所有元素的数组; 返回数组的运行时类型是指定数组的运行时类型。

声明方法的类 java.util.AbstractQueue
addAll, element, remove

声明方法的类 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, size, stream, toArray

声明方法的接口 java.util.Queue
peek, poll

- 构造方法详细信息
  - PriorityQueue
```
public PriorityQueue()
```
    使用默认初始容量（11）创建PriorityQueue ，根据其natural ordering对其元素进行排序。
  - PriorityQueue
```
public PriorityQueue(int initialCapacity)
```
    创建具有指定初始容量的PriorityQueue ，该容量根据其natural ordering对其元素进行排序。
    
    参数
    
    initialCapacity - 此优先级队列的初始容量
    
    异常
    
    IllegalArgumentException - 如果 initialCapacity小于1
  - PriorityQueue
```
public PriorityQueue(Comparator<? super E> comparator)
```
    创建具有默认初始容量的 PriorityQueue ，其元素根据指定的比较器进行排序。
    
    参数
    
    comparator - 将用于对此优先级队列进行排序的比较器。如果null ，将使用natural ordering的元素。
    
    从以下版本开始：
    
    1.8
  - PriorityQueue
```
public PriorityQueue(int initialCapacity,
                     Comparator<? super E> comparator)
```
    创建具有指定初始容量的 PriorityQueue ，该容量根据指定的比较器对其元素进行排序。
    
    参数
    
    initialCapacity - 此优先级队列的初始容量
    
    comparator - 将用于对此优先级队列进行排序的比较器。如果null ，将使用natural ordering的元素。
    
    异常
    
    IllegalArgumentException - 如果 initialCapacity小于1
  - PriorityQueue
```
public PriorityQueue(Collection<? extends E> c)
```
    创建包含指定集合中元素的PriorityQueue 。如果指定的集合是SortedSet的实例或另一个PriorityQueue ，则将根据相同的顺序对此优先级队列进行排序。否则，将根据其元素的natural ordering对此优先级队列进行排序。
    
    参数
    
    c - c其元素放入此优先级队列的集合
    
    异常
    
    ClassCastException - 如果根据优先级队列的顺序，指定集合的元素无法相互比较
    
    NullPointerException - 如果指定的集合或其任何元素为null
  - PriorityQueue
```
public PriorityQueue(PriorityQueue<? extends E> c)
```
    创建包含指定优先级队列中的元素的PriorityQueue 。此优先级队列将按照与给定优先级队列相同的顺序排序。
    
    参数
    
    c - c其元素放入此优先级队列的优先级队列
    
    异常
    
    ClassCastException -如果元素 c不能相互比较根据 c的订货
    
    NullPointerException - 如果指定的优先级队列或其任何元素为null
  - PriorityQueue
```
public PriorityQueue(SortedSet<? extends E> c)
```
    创建包含指定有序集中的元素的PriorityQueue 。此优先级队列将按照与给定排序集相同的顺序排序。
    
    参数
    
    c - c其元素放入此优先级队列的已排序集
    
    异常
    
    ClassCastException - 如果指定的有序集的元素不能根据有序集的排序相互比较
    
    NullPointerException - 如果指定的有序集或其任何元素为null
- 方法详细信息
  - add
```
public boolean add(E e)
```
    将指定的元素插入此优先级队列。
    
    Specified by:
    
    add ，界面 Collection<E>
    
    Specified by:
    
    add在界面 Queue<E>
    
    重写：
    
    add在类 AbstractQueue<E>
    
    参数
    
    e - 要添加的元素
    
    结果
    
    true （由 Collection.add(E)指定）
    
    异常
    
    ClassCastException - 如果根据优先级队列的顺序无法将指定的元素与当前在此优先级队列中的元素进行比较
    
    NullPointerException - 如果指定的元素为null
  - offer
```
public boolean offer(E e)
```
    将指定的元素插入此优先级队列。
    
    Specified by:
    
    offer在界面 Queue<E>
    
    参数
    
    e - 要添加的元素
    
    结果
    
    true （由 Queue.offer(E)指定）
    
    异常
    
    ClassCastException - 如果指定的元素无法根据优先级队列的顺序与当前在此优先级队列中的元素进行比较
    
    NullPointerException - 如果指定的元素为null
  - remove
```
public boolean remove(Object o)
```
    从此队列中删除指定元素的单个实例（如果存在）。更正式地，如果此队列包含一个或多个此类元素，则删除元素e ，使其为o.equals(e) 。当且仅当此队列包含指定元素时（或等效地，如果此队列因调用而更改），则返回true 。
    
    Specified by:
    
    remove在界面 Collection<E>
    
    重写：
    
    remove在类 AbstractCollection<E>
    
    参数
    
    o - 要从此队列中删除的元素（如果存在）
    
    结果
    
    true如果此队列因调用而更改
  - contains
```
public boolean contains(Object o)
```
    如果此队列包含指定的元素，则返回true 。更正式地，返回true当且仅当此队列包含至少一个元素e这样o.equals(e) 。
    
    Specified by:
    
    contains在界面 Collection<E>
    
    重写：
    
    contains在类 AbstractCollection<E>
    
    参数
    
    o - 要在此队列中检查包含的对象
    
    结果
    
    true如果此队列包含指定的元素
  - toArray
```
public Object[] toArray()
```
    返回包含此队列中所有元素的数组。元素没有特别的顺序。
    返回的数组将是“安全的”，因为此队列不会保留对它的引用。（换句话说，此方法必须分配一个新数组）。因此调用者可以自由修改返回的数组。
    
    此方法充当基于阵列和基于集合的API之间的桥梁。
    
    Specified by:
    
    toArray在界面 Collection<E>
    
    重写：
    
    toArray在类 AbstractCollection<E>
    
    结果
    
    包含此队列中所有元素的数组
  - toArray
```
public <T> T[] toArray(T[] a)
```
    返回包含此队列中所有元素的数组; 返回数组的运行时类型是指定数组的运行时类型。返回的数组元素没有特定的顺序。如果队列适合指定的数组，则返回其中。否则，将使用指定数组的运行时类型和此队列的大小分配新数组。
    如果队列适合指定的数组并且有空间（即，数组的元素多于队列），则紧跟集合结尾的数组中的元素将设置为null 。
    
    与toArray()方法一样，此方法充当基于数组的API和基于集合的API之间的桥梁。此外，该方法允许精确控制输出阵列的运行时类型，并且在某些情况下可以用于节省分配成本。
    
    假设x是一个已知仅包含字符串的队列。以下代码可用于将队列转储到新分配的String数组中：
    
    String[] y = x.toArray(new String[0]);
    请注意， toArray(new Object[0])在功能上与toArray()相同。
    Specified by:
    
    toArray在界面 Collection<E>
    
    重写：
    
    toArray在类 AbstractCollection<E>
    
    参数类型
    
    T - 要包含集合的数组的组件类型
    
    参数
    
    a - 要存储队列元素的数组（如果足够大）; 否则，为此目的分配相同运行时类型的新数组。
    
    结果
    
    包含此队列中所有元素的数组
    
    异常
    
    ArrayStoreException - 如果指定数组的运行时类型不是此队列中每个元素的运行时类型的超类型
    
    NullPointerException - 如果指定的数组为null
  - iterator
```
public Iterator<E> iterator()
```
    返回此队列中元素的迭代器。迭代器不会以任何特定顺序返回元素。
    
    Specified by:
    
    iterator在界面 Collection<E>
    
    Specified by:
    
    iterator在界面 Iterable<E>
    
    Specified by:
    
    iterator在类 AbstractCollection<E>
    
    结果
    
    此队列中元素的迭代器
  - clear
```
public void clear()
```
    从此优先级队列中删除所有元素。此调用返回后，队列将为空。
    
    Specified by:
    
    clear在接口 Collection<E>
    
    重写：
    
    clear在类 AbstractQueue<E>
  - comparator
```
public Comparator<? super E> comparator()
```
    返回用于为了在这个队列中的元素，或比较null如果此队列根据所述排序natural ordering的元素。
    
    结果
    
    用于对此队列进行排序的比较器，如果此队列根据其元素的自然顺序排序， null
  - spliterator
```
public final Spliterator<E> spliterator()
```
    在此队列中的元素上创建late-binding和fail-fast Spliterator 。分裂器不以任何特定顺序遍历元素（未报告ORDERED特征）。
    该Spliterator报告Spliterator.SIZED ， Spliterator.SUBSIZED和Spliterator.NONNULL 。覆盖实现应记录其他特征值的报告。
    
    Specified by:
    
    spliterator在界面 Collection<E>
    
    Specified by:
    
    spliterator在界面 Iterable<E>
    
    结果
    
    对此队列中的元素进行了 Spliterator
    
    从以下版本开始：
    
    1.8
  - removeIf
```
public boolean removeIf(Predicate<? super E> filter)
```
    从界面复制的说明： Collection
    
    删除此集合中满足给定谓词的所有元素。在迭代期间或通过谓词抛出的错误或运行时异常被中继到调用者。
    
    Specified by:
    
    removeIf在界面 Collection<E>
    
    参数
    
    filter - 一个谓词，它为要删除的元素返回 true
    
    结果
    
    true是否删除了任何元素
    
    异常
    
    NullPointerException - 如果指定的过滤器为null
  - removeAll
```
public boolean removeAll(Collection<?> c)
```
    复制自类的说明： AbstractCollection
    
    删除此集合的所有元素，这些元素也包含在指定的集合中（可选操作）。此调用返回后，此集合将不包含与指定集合相同的元素。
    
    Specified by:
    
    removeAll在界面 Collection<E>
    
    重写：
    
    removeAll在类 AbstractCollection<E>
    
    参数
    
    c - 包含要从此集合中删除的元素的集合
    
    结果
    
    true如果此集合因呼叫而更改
    
    异常
    
    NullPointerException - 如果此集合包含一个或多个null元素且指定的集合不支持null元素（ optional ），或者指定的集合为null
    
    另请参见：
    
    AbstractCollection.remove(Object) ， AbstractCollection.contains(Object)
  - retainAll
```
public boolean retainAll(Collection<?> c)
```
    复制自类： AbstractCollection描述
    
    仅保留此集合中包含在指定集合中的元素（可选操作）。换句话说，从此集合中删除未包含在指定集合中的所有元素。
    
    Specified by:
    
    retainAll在界面 Collection<E>
    
    重写：
    
    retainAll类 AbstractCollection<E>
    
    参数
    
    c - 包含要在此集合中保留的元素的集合
    
    结果
    
    true如果此集合因呼叫而更改
    
    异常
    
    NullPointerException - 如果此集合包含一个或多个null元素且指定的集合不允许null元素（ optional ），或者指定的集合为null
    
    另请参见：
    
    AbstractCollection.remove(Object) ， AbstractCollection.contains(Object)
  - forEach
```
public void forEach(Consumer<? super E> action)
```
    从界面复制的说明： Iterable
    
    对Iterable每个元素执行给定操作，直到处理Iterable所有元素或操作引发异常。如果指定了该顺序，则按迭代顺序执行操作。操作抛出的异常将转发给调用者。
    如果操作执行修改元素的基础源的副作用，则此方法的行为未指定，除非重写类已指定并发修改策略。
    
    Specified by:
    
    forEach在界面 Iterable<E>
    
    参数
    
    action - 要为每个元素执行的操作
    
    异常
    
    NullPointerException - if the specified action is null

Class PriorityQueue<E>

构造方法摘要

方法摘要

声明方法的类 java.util.AbstractQueue

声明方法的类 java.util.AbstractCollection

声明方法的类 java.lang.Object

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

声明方法的接口 java.util.Queue

构造方法详细信息

PriorityQueue

PriorityQueue

PriorityQueue

PriorityQueue

PriorityQueue

PriorityQueue

PriorityQueue

方法详细信息

add

offer

remove

contains

toArray

toArray

iterator

clear

comparator

spliterator

removeIf

removeAll

retainAll

forEach