最近在工作中遇到了使用优先级队列PriorityQueue,听名字就感觉这个队列可以按照一定的规律对队列中的元素进行摆放，于是带着这些问题就学习了一下源码，在PriorityQueue中优先级取决于Comparator比较器，他会按照用户指定的比较规则将元素放入队列中，从而保证队列中元素优先级越高的越在队列前面，优先级低的越在队列后面。
实现原理
Java中PriorityQueue通过二叉小顶堆实现，可以用一棵完全二叉树表示（任意一个非叶子节点的权值，都不大于其左右子节点的权值），也就意味着可以通过数组来作为PriorityQueue的底层实现。
通过数组表示小顶堆实现
leftNo = parentNo * 2 + 1
rightNo = parentNo * 2 + 2
parentNo = (nodeNo - 1) /2
通过上述三个公式，可以轻易计算出某个节点的父节点以及子节点的下标。这也就是为什么可以直接用数组来存储堆的原因。
方法解析
- add()或offer()
public boolean add(E e) {
return offer(e);
}
public boolean offer(E e) {
// 判断当前添加元素是否为null(表示队列中不允许添加null)
if (e == null)
throw new NullPointerException();
modCount++;
// 当前队列中元素个数
int i = size;
// 判断当前元素个数是否大于队列长度
if (i >= queue.length)
// 对队列进行扩容
grow(i + 1);
// 队列中元素个数加1
size = i + 1;
// 如果队列中没有元素
if (i == 0)
// 将添加元素直接放入队列
queue[0] = e;
else
// 如果队列中存在元素在进行插入时，由于底层是使用小顶堆实现所以需要对堆结点进行调整
siftUp(i, e);
return true;
}
private void siftUp(int k, E x) {
// 如果比较器不为空时
if (comparator != null)
// 使用比较器对小顶堆结点进行调整
siftUpUsingComparator(k, x);
else
// 使用自然排序对小顶堆结点进行调整
siftUpComparable(k, x);
}
// 主要是在小顶堆中通过循环的方式对父节点和子节点进行比较调整位置
// 保证小顶堆的性质
private void siftUpUsingComparator(int k, E x) {
// 判断k是否是小顶堆中的顶结点
while (k > 0) {
// 获取当前插入结点对应下标k的父节点下标
int parent = (k - 1) >>> 1;
// 获取对应下标的元素
Object e = queue[parent];
// 使用比较器对父节点和当前添加结点进行比较
// 如果当前添加结点大于父节点时，跳出while循环
if (comparator.compare(x, (E) e) >= 0)
break;
// 当添加结点小于父节点则和父节点进行交换位置
queue[k] = e;
// 将父节点下标赋值给k
k = parent;
}
// 由于添加结点大于父节点则直接插入对应下标位置
queue[k] = x;
}
private void siftUpComparable(int k, E x) {
// Comparable接口表示自然排序只要类实现的此接口说明这个类具有排序的功能
// 向上转型获取自然排序的规律
// 其对小顶堆调整的逻辑和上述一样
Comparable<? super E> key = (Comparable<? super E>) x;
while (k > 0) {
int parent = (k - 1) >>> 1;
Object e = queue[parent];
if (key.compareTo((E) e) >= 0)
break;
queue[k] = e;
k = parent;
}
queue[k] = key;
}
新加入的元素可能会破坏小顶堆的性质，因此需要进行必要的调整。
- element()或peek()
public E element() {
// 调用peek方法
E x = peek();
// 如果x不为null
if (x != null)
// 返回x
return x;
else
// x为null抛出没有找到结点异常
throw new NoSuchElementException();
}
public E peek() {
// 判断队列中结点数是否为0
// 为0返回null
// 不为0返回队列即小顶堆顶结点
return (size == 0) ? null : (E) queue[0];
}
- remove()或poll()
public E remove() {
// 调用poll方法获取队列即小顶堆的头结点(优先级高)
E x = poll();
// 如果x不为null
if (x != null)
// 返回x
return x;
else
// 否则抛出没有查询到结点异常
throw new NoSuchElementException();
}
public E poll() {
// 判断当前队列元素个数是否的等于0
if (size == 0)
// 返回null
return null;
// 当前队列元素个数减一赋值给s
int s = --size;
// 操作数加1
modCount++;
// 获取队列即小顶堆的头结点
E result = (E) queue[0];
// 获取在队列即小顶堆中s对应的元素赋值给x
E x = (E) queue[s];
// 将s的位置设置为null
queue[s] = null;
// 如果s不为0(说明队列或者小顶堆中还有元素或结点)
if (s != 0)
// 对队列即小顶堆中的结点进行筛选找出优先级较高的
siftDown(0, x);
// 返回结果
return result;
}
private void siftDown(int k, E x) {
// 如果比较器不为null
if (comparator != null)
// 使用比较器对小顶堆中的结点进行筛选
siftDownUsingComparator(k, x);
else
// 使用自然排序对小顶堆中的结点进行筛选
siftDownComparable(k, x);
}
private void siftDownUsingComparator(int k, E x) {
int half = size >>> 1;
while (k < half) {
int child = (k << 1) + 1;
Object c = queue[child];
int right = child + 1;
if (right < size &&
comparator.compare((E) c, (E) queue[right]) > 0)
c = queue[child = right];
if (comparator.compare(x, (E) c) <= 0)
break;
queue[k] = c;
k = child;
}
queue[k] = x;
}
private void siftDownComparable(int k, E x) {
Comparable<? super E> key = (Comparable<? super E>)x;
int half = size >>> 1;
while (k < half) {
int child = (k << 1) + 1;
Object c = queue[child];
int right = child + 1;
if (right < size &&
((Comparable<? super E>) c).compareTo((E) queue[right]) > 0)
c = queue[child = right];
if (key.compareTo((E) c) <= 0)
break;
queue[k] = c;
k = child;
}
queue[k] = key;
}
源码
public class PriorityQueue<E> extends AbstractQueue<E>
implements java.io.Serializable {
// 序列化id
private static final long serialVersionUID = -7720805057305804111L;
// 默认初始化大小 11
private static final int DEFAULT_INITIAL_CAPACITY = 11;
// 队列
transient Object[] queue;
// 队列长度默认 0
private int size = 0;
// 比较器
private final Comparator<? super E> comparator;
// 操作数
transient int modCount = 0;
// 无餐构造器
public PriorityQueue() {
this(DEFAULT_INITIAL_CAPACITY, null);
}
// 带参数构造器(队列初始大小)
public PriorityQueue(int initialCapacity) {
this(initialCapacity, null);
}
// 带参构造器(比较器--定义比较规则)
public PriorityQueue(Comparator<? super E> comparator) {
this(DEFAULT_INITIAL_CAPACITY, comparator);
}
// 带参构造器(初始大小，比较器)
public PriorityQueue(int initialCapacity,
Comparator<? super E> comparator) {
// 初始大小小于1
if (initialCapacity < 1)
// 抛出非法参数异常
throw new IllegalArgumentException();
// 创建队列
this.queue = new Object[initialCapacity];
// 初始化比较器
this.comparator = comparator;
}
// 带参构造器(Collection子类集合)
public PriorityQueue(Collection<? extends E> c) {
// 判断是否是SortedSet子类
if (c instanceof SortedSet<?>) {
SortedSet<? extends E> ss = (SortedSet<? extends E>) c;
// 获取SortedSet的比较器对队列比较器进行初始化
this.comparator = (Comparator<? super E>) ss.comparator();
// 初始化结点来自集合
initElementsFromCollection(ss);
}
// 判断是否是PriorityQueue子类
else if (c instanceof PriorityQueue<?>) {
PriorityQueue<? extends E> pq = (PriorityQueue<? extends E>) c;
// 获取PriorityQueue的比较器对队列比较器进行初始化
this.comparator = (Comparator<? super E>) pq.comparator();
// 初始化来自PriorityQueue
initFromPriorityQueue(pq);
}
else {
// 初始化比较器为null
this.comparator = null;
// 初始化来自集合
initFromCollection(c);
}
}
// 带参构造器(PriorityQueue)
public PriorityQueue(PriorityQueue<? extends E> c) {
// 对比较器进行初始化
this.comparator = (Comparator<? super E>) c.comparator();
// 初始化来自PriorityQueue
initFromPriorityQueue(c);
}
// 带参构造器(SortedSet)
public PriorityQueue(SortedSet<? extends E> c) {
// 对比较器进行初始化
this.comparator = (Comparator<? super E>) c.comparator();
// 初始化结点来自集合
initElementsFromCollection(c);
}
// 初始化来自PriorityQueue
private void initFromPriorityQueue(PriorityQueue<? extends E> c) {
// 如果两个class相同
if (c.getClass() == PriorityQueue.class) {
// 将c转为数组赋值给队列
this.queue = c.toArray();
// 队列长度为数组长度
this.size = c.size();
} else {
// 初始化来自集合
initFromCollection(c);
}
}
// 初始化结点来自集合
private void initElementsFromCollection(Collection<? extends E> c) {
// 将集合转为数组
Object[] a = c.toArray();
// 如果两个class相同
if (a.getClass() != Object[].class)
// 将a数组中的元素拷贝到Object数组中
a = Arrays.copyOf(a, a.length, Object[].class);
// 数组长度
int len = a.length;
// 个长度等于1 或者比较器不为null
if (len == 1 || this.comparator != null)
//
for (int i = 0; i < len; i++)
if (a[i] == null)
throw new NullPointerException();
this.queue = a;
this.size = a.length;
}
private void initFromCollection(Collection<? extends E> c) {
initElementsFromCollection(c);
heapify();
}
// 队列最大容量(Integer最大-8)
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
// 队列扩容
private void grow(int minCapacity) {
// 将队列长度赋值给oldCapacaity
int oldCapacity = queue.length;
// 新队列长度为：当前队列长度小于64则当前队列长度+2，当队列大于64则当前队列加当前队列的 一半
int newCapacity = oldCapacity + ((oldCapacity < 64) ?
(oldCapacity + 2) :
(oldCapacity >> 1));
// 新长度减最大长度大于0时
if (newCapacity - MAX_ARRAY_SIZE > 0)
// 算最大容量(将要使用的长度)
newCapacity = hugeCapacity(minCapacity);
// 反之将newCapacity作为队列新的长度进行扩容
queue = Arrays.copyOf(queue, newCapacity);
}
// 计算最大容量
private static int hugeCapacity(int minCapacity) {
// 将要使用长度小于0
if (minCapacity < 0)
// 抛出内存不足错误
throw new OutOfMemoryError();
// 判断将要使用长度是否大于最大长度，大于返回Integr最大长度反之返回最大长度(Integre.MAX_VALUE-8)
return (minCapacity > MAX_ARRAY_SIZE) ?
Integer.MAX_VALUE :
MAX_ARRAY_SIZE;
}
// 向队列中添加元素
public boolean add(E e) {
return offer(e);
}
// 向队列中添加元素
public boolean offer(E e) {
// 如果元素为null
if (e == null)
// 抛出空指针异常
throw new NullPointerException();
// 操作数加1
modCount++;
// 将当前队列元素个数赋值为i
int i = size;
// 如果i大于队列长度
if (i >= queue.length)
// 将当前长度加1对队列进行扩容
grow(i + 1);
// 当前队列中元素个数加1
size = i + 1;
// 如果i等于0表示当前队列为空
if (i == 0)
// 将新的元素放入队列头部
queue[0] = e;
else
// 将元素放入队列相应位置(当前队列中元素个数，将要添加到队列中的元素)
siftUp(i, e);
// 返回true
return true;
}
// 检索但不删除此队列的开头，如果此队列为空，则返回或者返回null。
public E peek() {
// 如果当前队列也是为0则返回null反之返回队列头元素
return (size == 0) ? null : (E) queue[0];
}
// 根据对象获取在队列中的位置
private int indexOf(Object o) {
// 当前对象不能为空
if (o != null) {
// 遍历队列
for (int i = 0; i < size; i++)
// 找到相同的
if (o.equals(queue[i]))
// 返回下标
return i;
}
// 没找到返回-1
return -1;
}
// 移除队列中指定元素
public boolean remove(Object o) {
// 获取元素在队列中的下标
int i = indexOf(o);
// 下标为-1，表示队列中没有当前元素
if (i == -1)
// 返回false
return false;
else {
// 根据下标从队列中移除元素
removeAt(i);
// 返回true
return true;
}
}
// 从队列中移除指定元素
boolean removeEq(Object o) {
// 遍历队列
for (int i = 0; i < size; i++) {
// 找到指定元素
if (o == queue[i]) {
// 通过下标移除队列中元素
removeAt(i);
// 返回true
return true;
}
}
// 在队列中没有找到返回false
return false;
}
// 判断队列中是否包含指定元素
public boolean contains(Object o) {
// 获取元素在队列中下标，有返回1反之-1
return indexOf(o) != -1;
}
// 将队列转为数组
public Object[] toArray() {
return Arrays.copyOf(queue, size);
}
// 将队列转换到指定数组(指定数组类型)
public <T> T[] toArray(T[] a) {
// 获取当前队列中的元素个数
final int size = this.size;
// 传入数组长度小于队列也是个数
if (a.length < size)
// 将队列数据放到指定数组中
return (T[]) Arrays.copyOf(queue, size, a.getClass());
System.arraycopy(queue, 0, a, 0, size);
// 指定数组长度大于队列中元素个数
if (a.length > size)
//
a[size] = null;
return a;
}
// 返回队列中的元素个数
public int size() {
return size;
}
// 清空队列
public void clear() {
// 操作数加1
modCount++;
// 遍历队列
for (int i = 0; i < size; i++)
// 将队列每个直null
queue[i] = null;
// 队列元素个数赋值为0
size = 0;
}
// 检索并删除此队列的开头，如果此队列为空，则返回或返回null。
public E poll() {
// 判断队列中元素是否为0
if (size == 0)
// 为0 返回null
return null;
// 队列元素个数减一赋值给s
int s = --size;
// 操作数加1
modCount++;
// 获取队列头部元素
E result = (E) queue[0];
// 获取队列最后一个元素
E x = (E) queue[s];
// 将队列最后一个位置值空
queue[s] = null;
// 如果s不等于0表示当前队列里不只有一个元素
if (s != 0)
// 对队列其他元素进行重新排列
siftDown(0, x);
// 返回第一个元素
return result;
}
// 根据下标移除队列中指定元素
private E removeAt(int i) {
// 操作数加1
modCount++;
// 当前duil元素数减1，赋值给s
int s = --size;
// 如果是s==i表示当前移除的是最后一个元素
if (s == i)
// 移除队列中最后一个元素
queue[i] = null;
else {
// 获取s下标对应的元素(最后一个元素)
E moved = (E) queue[s];
// 将s下标对应的位置值空
queue[s] = null;
// 参数：要移除元素的下标，最后一个元素
siftDown(i, moved);
// 如果要移除的元素等于最后的一个元素
if (queue[i] == moved) {
siftUp(i, moved);
// 如果要移除的元素不等于最后一个元素
if (queue[i] != moved)
// 返回最后一个元素
return moved;
}
}
return null;
}
扫一扫
2971
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
