Java Program to Implement PriorityQueue API

This Java program Implements PriorityQueue API.An unbounded priority queue based on a priority heap. The elements of the priority queue are ordered according to their natural ordering, or by a Comparator provided at queue construction time, depending on which constructor is used. A priority queue does not permit null elements. A priority queue relying on natural ordering also does not permit insertion of non-comparable objects (doing so may result in ClassCastException).

Here is the source code of the Java Program to Implement PriorityQueue. The Java program is successfully compiled and run on a Linux system. The program output is also shown below.

```
import java.util.Collection;
```
```
import java.util.Comparator;
```
```
import java.util.Iterator;
```
```
import java.util.PriorityQueue;
```
```
 
```
```
public class PriorityQueueImpl<E>
```
```
{
```

    private PriorityQueue<E> priorityQueue;

```
 
```
```
    /**
```

     * Creates a PriorityQueue with the default initial capacity (11) that

     * orders its elements according to their natural ordering.

```
     **/
```
```
    public PriorityQueueImpl()
```
```
    {
```

        priorityQueue = new PriorityQueue<E>();

```
    }
```
```
 
```
```
    /**
```

     * Creates a PriorityQueue containing the elements in the specified

```
     * collection.
```
```
     **/
```

    public PriorityQueueImpl(Collection<? extends E> c)

```
    {
```

        priorityQueue = new PriorityQueue<E>(c);

```
    }
```
```
 
```
```
    /**
```

     * Creates a PriorityQueue with the specified initial capacity that orders

     * its elements according to their natural ordering.

```
     **/
```

    public PriorityQueueImpl(int initialCapacity)

```
    {
```

        priorityQueue = new PriorityQueue<E>(initialCapacity);

```
    }
```
```
 
```
```
    /**
```

     * Creates a PriorityQueue with the specified initial capacity that orders

     * its elements according to the specified comparator.

```
     **/
```

    public PriorityQueueImpl(int initialCapacity, Comparator<? super E> comparator)

```
    {
```

        priorityQueue = new PriorityQueue<E>(initialCapacity, comparator);

```
    }
```
```
 
```

    /** Inserts the specified element at the tail of this queue. **/

```
    public boolean add(E e)
```
```
    {
```
```
        return priorityQueue.add(e);
```
```
    }
```
```
 
```

    /** Atomically removes all of the elements from this queue. **/

```
    public void clear()
```
```
    {
```
```
        priorityQueue.clear();
```
```
    }
```
```
 
```

    /** Returns true if this queue contains the specified element. **/

```
    public boolean contains(Object o)
```
```
    {
```

        return priorityQueue.contains(o);

```
    }
```
```
 
```

    /** Returns an iterator over the elements in this queue in proper sequence. **/

```
    public Iterator<E> iterator()
```
```
    {
```

        return priorityQueue.iterator();

```
    }
```
```
 
```
```
    /**
```

     * Inserts the specified element at the tail of this queue if it is possible

     * to do so immediately without exceeding the queue's capacity, returning

     * true upon success and false if this queue is full.

```
     **/
```
```
    public boolean offer(E e)
```
```
    {
```
```
        return priorityQueue.offer(e);
```
```
    }
```
```
 
```
```
    /**
```

     * Retrieves, but does not remove, the head of this queue, or returns null

```
     * if this queue is empty.
```
```
     **/
```
```
    public E peek()
```
```
    {
```
```
        return priorityQueue.peek();
```
```
    }
```
```
 
```
```
    /**
```

     * Retrieves and removes the head of this queue, or returns null if this

```
     * queue is empty.
```
```
     **/
```
```
    public E poll()
```
```
    {
```
```
        return priorityQueue.poll();
```
```
    }
```
```
 
```
```
    /**
```

     * Removes a single instance of the specified element from this queue, if it

```
     * is present.
```
```
     **/
```
```
    public boolean remove(Object o)
```
```
    {
```
```
        return priorityQueue.remove(o);
```
```
    }
```
```
 
```

    /** Returns the number of elements in this queue. **/

```
    public int size()
```
```
    {
```
```
        return priorityQueue.size();
```
```
    }
```
```
 
```
```
    /**
```

     * Returns an array containing all of the elements in this queue, in proper

```
     * sequence.
```
```
     **/
```
```
    public Object[] toArray()
```
```
    {
```
```
        return priorityQueue.toArray();
```
```
    }
```
```
 
```
```
    /**
```

     * Returns an array containing all of the elements in this queue, in proper

     * sequence; the runtime type of the returned array is that of the specified

```
     * array.
```
```
     **/
```
```
    public <T> T[] toArray(T[] a) 
```
```
    {
```

        return priorityQueue.toArray(a);

```
    }
```
```
 
```

    public static void main(String... arg)

```
    {
```

        PriorityQueueImpl<Integer> priorityQueue = new PriorityQueueImpl<Integer>();

```
        priorityQueue.add(200);
```
```
        priorityQueue.add(49);
```
```
        priorityQueue.add(-400);
```
```
        priorityQueue.add(240);
```
```
        priorityQueue.add(0);
```

        System.out.println("the elements of the priorityQueue is ");

        Iterator<Integer> itr = priorityQueue.iterator();

```
        while (itr.hasNext())
```
```
        {
```

            System.out.print(itr.next() + "\t");

```
        }
```
```
        System.out.println();
```
```
        priorityQueue.offer(600);
```
```
        priorityQueue.offer(700);
```

        System.out.println("the peak element of the priorityQueue is(by peeking) " + priorityQueue.peek());

        System.out.println("the peak element of the priorityQueue is(by polling) " + priorityQueue.poll());

        System.out.println("element 300 removed " + priorityQueue.remove(300));

        System.out.println("the priorityQueue contains 400 :" + priorityQueue.contains(400));

        System.out.println("the priorityQueue contains 100 :" + priorityQueue.contains(200));

        System.out.println("the size of the priorityQueue is " + priorityQueue.size());

```
    }
```
```
}
```

$ javac PriorityQueueImpl.java
$ java PriorityQueueImpl
the elements of the priorityQueue is 
-400	0	49	240	200	
the peak element of the priorityQueue is(by peeking) -400
the peak element of the priorityQueue is(by polling) -400
element 300 removed false
the priorityQueue contains 400 :false
the priorityQueue contains 100 :true
the size of the priorityQueue is 6

Sanfoundry Global Education & Learning Series – 1000 Java Programs.

If you wish to look at all Java Programming examples, go to Java Programs.

« Prev - Java Program to Implement PriorityBlockingQueue API

» Next - Java Program to Implement LinkedBlockingDeque API

Related Posts:

Recommended Articles: