What Is Priorityqueue Or Priority Queue Information Construction Inward Coffee Amongst Illustration - Tutorial

PriorityQueue is an unbounded Queue implementation inwards Java, which is based on priority heap. PriorityQueue allows y'all to choke on elements inwards a detail order, according to at that spot natural social club or custom social club defined by Comparator interface inwards Java. Head of priority queue information construction will ever comprise to the lowest degree chemical gene amongst observe to specified ordering. For example, inwards this post, nosotros volition practice a PriorityQueue of Items, which are ordered based upon at that spot price, this volition allow us to procedure Items, starting from lowest price. Priority queue is too real useful inwards implementing Dijkstra algorithm inwards Java. You tin flame utilization to PriorityQueue to choke on unsettled nodes for processing. One of the key affair to think nigh PriorityQueue inwards Java is that it's Iterator doesn't guarantee whatsoever order, if y'all desire to traverse inwards ordered fashion, ameliorate utilization Arrays.sort(pq.toArray()) method. PriorityQueue is too not synchronized, which agency tin flame non survive shared safely betwixt multiple threads, instead it's concurrent counterpart PriorityBlockingQueue is thread-safe as well as should survive used inwards multithreaded environment. Priority queue provides O(log(n)) fourth dimension surgical operation for mutual enqueing as well as dequeing methods e.g. offer(), poll() as well as add(), but constant fourth dimension for retrieval methods e.g. peek() as well as element().

How to utilization PriorityQueue inwards Java

Comparator provided to PriorityQueue. In this example, nosotros stimulate got kept release of Items inwards PriorityQueue, whose natural ordering is decided past times it's price. 

You tin flame stimulate got a await at Item shape compareTo method, it's consistent with equals method and too sorts Items based upon at that spot price. I stimulate got too practice Item every bit nested static shape here. By storing Item inwards priority queue, y'all tin flame ever retrieve Item amongst lowest toll past times using poll() method of Queue interface.

package test;

import java.util.PriorityQueue;

import java.util.Queue;

/**

  * Java Program to demo How to utilization PriorityQueue inwards Java. This instance too demonstrate

  * that PriorityQueue doesn't allow cypher elements as well as how PriorityQueue keeps elements i.e. ordering.

  *

  * @author

 */

public class PriorityQueueTest {

    public static void main(String args[]) {

        Queue<Item> items = new PriorityQueue<Item>();

        items.add(new Item("IPone", 900));

        items.add(new Item("IPad", 1200));

        items.add(new Item("Xbox", 300));

        items.add(new Item("Watch", 200));

        System.out.println("Order of items inwards PriorityQueue");

        System.out.println(items);

      

        System.out.println("Element consumed from caput of the PriorityQueue : " + items.poll());

        System.out.println(items);

      

        System.out.println("Element consumed from caput of the PriorityQueue : " + items.poll());

        System.out.println(items);

      

        System.out.println("Element consumed from caput of the PriorityQueue : " + items.poll());

        System.out.println(items);

      

        //items.add(null); // cypher elements non allowed inwards PriorityQueue - NullPointerException

    }

    private static class Item implements Comparable<Item> {

        private String name;

        private int price;

        public Item(String name, int price) {

            this.name = name;

            this.price = price;

        }

        public String getName() {

            return name;

        }

        public int getPrice() {

            return price;

        }

        @Override

        public boolean equals(Object obj) {

            if (obj == null) {

                return false;

            }

            if (getClass() != obj.getClass()) {

                return false;

            }

            final Item other = (Item) obj;

            if ((this.name == null) ? (other.name != null) : !this.name.equals(other.name)) {

                return false;

            }

            if (this.price != other.price) {

                return false;

            }

            return true;

        }

        @Override

        public int hashCode() {

            int hash = 5;

            hash = 97  hash + (this.name != null ? this.name.hashCode() : 0);

            hash = 97  hash + this.price;

            return hash;

        }

        @Override

        public int compareTo(Item i) {

            if (this.price == i.price) {

                return this.name.compareTo(i.name);

            }

            return this.price - i.price;

        }

        @Override

        public String toString() {

            return String.format("%s: $%d", name, price);

        }      

      

    }

}

Output:

Order of items inwards PriorityQueue

[Watch: $200, Xbox: $300, IPone: $900, IPad: $1200]

Element consumed from caput of the PriorityQueue : Watch: $200

[Xbox: $300, IPad: $1200, IPone: $900]

Element consumed from caput of the PriorityQueue : Xbox: $300

[IPone: $900, IPad: $1200]

Element consumed from caput of the PriorityQueue : IPone: $900

[IPad: $1200]

From the inwards a higher house output, it's clear that PriorityQueue keeps to the lowest degree value chemical gene at head, where ordering is determined using compareTo() method. It doesn't choke on all elements inwards that social club though, solely caput existence to the lowest degree value chemical gene is guaranteed. This is inwards fact principal divergence betwixt TreeSet as well as PriorityQueue inwards Java, onetime keeps all elements inwards a detail sorted order, land priority queue only keeps caput inwards sorted order. Another of import scream for to banking concern notation is that PriorityQueue  doesn't permit cypher elements as well as trying to add together cypher elements volition result inwards NullPointerException, as shown below :

Exception inwards thread "main" java.lang.NullPointerException

        at java.util.PriorityQueue.offer(PriorityQueue.java:265)

        at java.util.PriorityQueue.add(PriorityQueue.java:251)

        at test.PriorityQueueTest.main(PriorityQueueTest.java:36)

Java Result: 1

Summary

Like whatsoever other Collection class, it's worth noting to think key points nigh PriorityQueue inwards Java.

1) PriorityQueue is non synchronized, if thread-safety is requirement utilization BlockingPriorityQueue.

2) Queue retrieval methods similar poll(), peek() as well as element() access caput of Queue, which keeps to the lowest degree chemical gene according to specified ordering.

3) Iterator returned past times PriorityQueue doesn't offering whatsoever ordering traversal guarantee.

4) PriorityQueue doesn't allow null elements, if y'all attempt to add together null, it volition throw java.lang.NullPointerException.

That's all on what is PriorityQueue inwards Java as well as How to utilization them. It's an particular class, which tin flame survive used inwards particular scenarios, where y'all scream for to eat Orders inwards a detail order, think BlockingQueue maintains insertion order, but if desire to maintain a custom order, PriorityQueue or BlockingPriorityQueue is correct collection to use. TreeSet too provides similar functionality, but doesn't stimulate got i brusque retrieval cum removal method e.g. poll().

Further Learning
Java In-Depth: Become a Complete Java Engineer
Java Fundamentals: Collections
Data Structures as well as Algorithms: Deep Dive Using Java

Recommended Book

Though PriorityQueue has quite specialized use, it is i of the Collection class, which is oft overlooked. Like whatsoever other Collection topic, Java Generics as well as Collection contains unopen to of the best available information nigh PriorityQueue. If y'all similar to larn more, stimulate got a re-create of that book.

Bagikan Artikel ini