Queue:
======
-> Queue is a collection can store values in "First In and First Out (FIFO)" Order but not necessarily.

PriorityQueue:
==============
-> PriorityQueue is a class which implements from Queue interface.
Syntax:
	public class PriorityQueue implements Queue{
		// implementation
	}
-> PriorityQueue consisting of two pointers:
	1) Head
	2) Tail
-> Elements are added from the tail pointer and elements can be removed from head pointer.
-> PriorityQueue can perform other extra functionality like: inspection, extraction etc.

Creation of PriorityQueue:
==========================
Syntax:
	PrioerityQueue<T> Identifier = new PrioertyQueue<>();

package com.pack.p1;

import java.util.ArrayList;
import java.util.PriorityQueue;

public class MainClass {

	public static void main(String[] args) {
		// for creation of Priorty Queue of an Integer type
		PriorityQueue<Integer> pqi = new PriorityQueue<Integer>();
		
		ArrayList<Integer> ali = new ArrayList<Integer>();
		
		System.out.println("The Given PriorityQueue = "+pqi);
		
		// adding of elements into PriorityQueue
		pqi.add(100);
		pqi.add(-110);
		pqi.add(79);
		pqi.add(97);
		pqi.add(0);
		
		System.out.println("The PriorityQueue After adding elements = "+pqi);
		
		pqi.add(-110);
		pqi.add(79);
		
		System.out.println("The PriorityQueue After adding duplicated elements = "+pqi);
//		System.out.println(pqi[0]);
		
//		pqi.add(null);
		
//		System.out.println(pqi);
		
		ali.add(null);
		ali.add(100);
		ali.add(1023);
		
		System.out.println(ali);
	}

}

Q: When we can use while loop and when we can use for loop?
===========================================================
while: 
=====
	When we cannot estimate the number of iterations before the implementation, we can use "while loop".

for:
=====
When we can estimate the number of iterations before the implementation, we can use "for loop".

package com.pack.p1;

import java.util.PriorityQueue;

public class MainClass {

	public static void main(String[] args) {
		// for creation of Priorty Queue of an Integer type
		PriorityQueue<Integer> pqi = new PriorityQueue<Integer>();
		
		System.out.println("The Given PriorityQueue = "+pqi);
		
		for(int i = 1;i <= 100;++i) {
			if(i % 15 == 0) {
				pqi.add(i);
			}
		}
		System.out.println("The PriorityQueue After adding elements = "+pqi);
		
		
	}

}

Q: Is PriorityQueue can sort the elements while printing?
=========================================================
No

package com.pack.p1;

import java.util.PriorityQueue;

public class MainClass {

	public static void main(String[] args) {
		// for creation of Priorty Queue of an Integer type
		PriorityQueue<Integer> pqi = new PriorityQueue<Integer>();
		
		System.out.println("The Given PriorityQueue = "+pqi);
		
		pqi.add(1122);
		pqi.add(100);
		pqi.add(-1);
		pqi.add(7799);
		pqi.add(1234);
		
		System.out.println("The PriorityQueue After adding elements = "+pqi);
		
		
	}

}

Output:
=======
The Given PriorityQueue = []
The PriorityQueue After adding elements = [-1, 1122, 100, 7799, 1234]

Removing of elements from the PriorityQueue:
============================================
remove()

package com.pack.p1;

import java.util.PriorityQueue;

public class MainClass {

	public static void main(String[] args) {
		// for creation of Priorty Queue of an Integer type
		PriorityQueue<Integer> pqi = new PriorityQueue<Integer>();
		
		System.out.println("The Given PriorityQueue = "+pqi);
		
		pqi.add(1122);
		pqi.add(100);
		pqi.add(-1);
		pqi.add(7799);
		pqi.add(1234);
		
		System.out.println("The PriorityQueue After adding elements = "+pqi);
		
		System.out.println(pqi.remove(-1));
		
		System.out.println("The PriorityQueue = "+pqi);
	}

}
 
====================================================
package com.pack.p1;

import java.util.Iterator;
import java.util.PriorityQueue;

public class MainClass {

	public static void main(String[] args) {
		// for creation of Priorty Queue of an Integer type
		PriorityQueue<Integer> pqi = new PriorityQueue<Integer>();
		
		System.out.println("The Given PriorityQueue = "+pqi);
		
		pqi.add(1122);
		pqi.add(100);
		pqi.add(-1);
		pqi.add(7799);
		pqi.add(1234);
		
		System.out.println("The PriorityQueue After adding elements = "+pqi);
		
		System.out.println(pqi.peek());
		pqi.remove(-1);
		System.out.println("The PrioerityQueue = "+pqi);
		System.out.println(pqi.peek());
		
		for(Integer i :pqi) {
			System.out.println(i);
		}
		System.out.println("================");
		
		Iterator it = pqi.iterator();
		while(it.hasNext()) {
			System.out.println(it.next());
		}
	}

}

==========================================================
package com.pack.p1;

import java.util.PriorityQueue;

class Patient implements Comparable<Patient>{
	private String name;
	private int severity;
	
	public Patient(String name, int severity) {
		super();
		this.name = name;
		this.severity = severity;
	}

	public String getName() {
		return name;
	}

	public int getSeverity() {
		return severity;
	}

	@Override
	public int compareTo(Patient o) {
		return Integer.compare(o.getSeverity(), this.getSeverity());
	}

	@Override
	public String toString() {
		return "Patient [name=" + name + ", severity=" + severity + "]";
	}
}

public class ERPriorityQueue {

	public static void main(String[] args) {
		PriorityQueue<Patient> p = new PriorityQueue<>();
		p.add(new Patient("John",5));
		p.add(new Patient("Smith",8));
		p.add(new Patient("Bob",2));
		p.add(new Patient("Jhansi",6));
		p.add(new Patient("Sakshen",7));
		p.add(new Patient("Bobby",3));
		p.add(new Patient("Jhonny",9));
		p.add(new Patient("Smitha",2));
		p.add(new Patient("Nirnay",10));
		
		while(!p.isEmpty()) {
			System.out.println(p.poll());
		}
	}

}