PriorityQueue
In this chapter you will learn:
- What is PriorityQueue Class and how to use PriorityQueue Class
- Using a comparator with a priority queu
Use PriorityQueue Class
PriorityQueue
extends AbstractQueue
and implements the Queue
interface.
It creates a queue that is prioritized based on the queue's comparator.
PriorityQueue
is a generic class that has this declaration:
class PriorityQueue<E>
E
specifies the type of objects stored in the queue.
PriorityQueues are dynamic, growing as necessary.
PriorityQueue
defines the six constructors shown here:
PriorityQueue( )
builds an empty queue. Its starting capacity is 11.PriorityQueue(int capacity)
builds a queue that has the specified initial capacity.PriorityQueue(int capacity, Comparator<? super E> comp)
builds a queue with the specified capacity and comparator.PriorityQueue(Collection<? extends E> c)
initialized with the collection passed.PriorityQueue(PriorityQueue<? extends E> c)
initialized with the collection passed.PriorityQueue(SortedSet<? extends E> c)
initialized with the collection passed.
If no comparator is specified when a PriorityQueue is constructed, then the default comparator is used. The default comparator will order the queue in ascending order.
Thus, the head of the queue will be the smallest value. By providing a custom comparator, you can specify a different ordering scheme.
PriorityQueue
' comparator()
method return a reference to the comparator:
Comparator<? super E> comparator( )
If natural ordering is used for the invoking queue, null is returned.
To properly use a PriorityQueue
, you must call methods
such as offer( )
and poll( )
, which are
defined by the Queue
interface.
Adding randomly generated integers to a priority queue
import java.util.PriorityQueue;
import java.util.Queue;
//from ja v a2 s . c o m
public class Main {
public static void main(String[] args) {
Queue<Integer> qi = new PriorityQueue<Integer>();
for (int i = 0; i < 15; i++){
qi.add((int) (Math.random() * 100));
}
while (!qi.isEmpty()){
System.out.print(qi.poll() + " ");
}
System.out.println();
}
}
The code above generates the following result.
Using a comparator with a priority queu
The following code uses a comparator with a priority queue.
import java.util.Comparator;
import java.util.PriorityQueue;
import java.util.Queue;
/* j ava2s .c o m*/
public class Main {
final static int Count = 15;
public static void main(String[] args) {
Comparator<Integer> cmp;
cmp = new Comparator<Integer>() {
public int compare(Integer e1, Integer e2) {
return e2 - e1;
}
};
Queue<Integer> qi = new PriorityQueue<Integer>(Count, cmp);
for (int i = 0; i < Count; i++){
qi.add((int) (Math.random() * 100));
}
while (!qi.isEmpty()){
System.out.print(qi.poll() + " ");
}
System.out.println();
}
}
98 96 92 74 71 70 54 37 37 34 20 18 14 9 7
import java.util.Comparator;
import java.util.PriorityQueue;
// j a v a 2 s . c o m
enum ProductQuality {
High, Medium, Low
}
class Product implements Comparable<Product> {
String name;
ProductQuality priority;
Product(String str, ProductQuality pri) {
name = str;
priority = pri;
}
public int compareTo(Product msg2) {
return priority.compareTo(msg2.priority);
}
}
class MessageComparator implements Comparator<Product> {
public int compare(Product msg1, Product msg2) {
return msg2.priority.compareTo(msg1.priority);
}
}
public class Main {
public static void main(String args[]) {
PriorityQueue<Product> pq = new PriorityQueue<Product>(3);
pq.add(new Product("A", ProductQuality.Low));
pq.add(new Product("B", ProductQuality.High));
pq.add(new Product("C", ProductQuality.Medium));
Product m;
while ((m = pq.poll()) != null)
System.out.println(m.name + " Priority: " + m.priority);
PriorityQueue<Product> pqRev = new PriorityQueue<Product>(3, new MessageComparator());
pqRev.add(new Product("D", ProductQuality.Low));
pqRev.add(new Product("E", ProductQuality.High));
pqRev.add(new Product("F", ProductQuality.Medium));
while ((m = pqRev.poll()) != null)
System.out.println(m.name + " Priority: " + m.priority);
}
}
Next chapter...
What you will learn in the next chapter: