How do I use a PriorityQueue?

In-depth insights

Custom sorting with objects

With custom objects in a PriorityQueue, you need a Comparator for sorting:

class User {
   String name;
   int reputation;
   User(String name, int reputation) {
      this.name = name;
      this.reputation = reputation;
   }
}
// StackOverflow in a queue, reputation gets you first! 😁
PriorityQueue<User> usersQueue = new PriorityQueue<>(Comparator.comparingInt(user -> user.reputation));
usersQueue.offer(new User("Alice", 9001));
usersQueue.offer(new User("Bob", 5000)); 
User topUser = usersQueue.poll();
System.out.println(topUser.name); // Prints "Alice"


Highest priority first

To create a max-priority queue (highest value out first), use Collections.reverseOrder() or Comparator.reversed(). So much for humbleness, it's your time to shine at the top! ✨

PriorityQueue<Integer> maxPQ = new PriorityQueue<>(Collections.reverseOrder());
// or for custom objects
PriorityQueue<User> maxUserQueue = new PriorityQueue<>(Comparator.comparingInt(user -> user.reputation).reversed());


Concise comparator with lambdas

You can write Comparator in a more compact style using lambda expressions or method references. Because you've got important coding to do and every keystroke matters! ⏱️

// With lambda
PriorityQueue<String> lengthQueue = new PriorityQueue<>((s1, s2) -> s1.length() - s2.length());

// With method reference
PriorityQueue<String> lengthQueueMR = new PriorityQueue<>(Comparator.comparingInt(String::length));


Deciding between offer() and add()

The offer() method returns a boolean upon failure, making it the preferred choice for capacity-limited scenarios, so you won't rudely hit a wall when the room is full! 😮

if (!boundedQueue.offer(element)) {
   // Oops, no more room for more elements! Handle the error
}


Alternatively, add() can throw an IllegalStateException when you're not concerned with queue capacity or you want to catch exceptions with style:

try {
    unboundedQueue.add(element);
} catch (IllegalStateException e) {
    // Well, trying to overload won't work here. Do something about it.
}


Design and quirks to keep in mind

Preserving order in PriorityQueue

The iterative order of PriorityQueue elements is not necessarily the same as the priority-ordered output guarantee. To extract elements in guaranteed priority order, always use poll():

while (!pq.isEmpty()) {
    System.out.println(pq.poll()); // See you later, alligator 🐊
}


Extending PriorityQueue

It's best to use composition over inheritance when modifying the PriorityQueue's features to prevent side effects and keep momma PriorityQueue happy. 😊

Wondering about null

PriorityQueue does not permit null elements. Adding null brings up a NullPointerException, keeping your queue safe and squeaky clean. 🚷

try {
    pq.offer(null);
} catch (NullPointerException e) {
    // Nulls aren't allowed. We prefer something over nothing!
}
