Priority Queue

Author: Rajeev Kumar Singh

java-priority-queue-examples/src/CreatePriorityQueueExample.java

@@ -0,0 +1,39 @@
+import java.util.Comparator;
+import java.util.PriorityQueue;
+
+public class CreatePriorityQueueExample {
+    public static void main(String[] args) {
+        Comparator<String> stringLengthComparator = new Comparator<String>() {
+            @Override
+            public int compare(String s1, String s2) {
+                return s1.length() - s2.length();
+            }
+        };
+
+        /*
+        The above Comparator can also be created using lambda expression like this =>
+        Comparator<String> stringLengthComparator = (s1, s2) -> {
+            return s1.length() - s2.length();
+        };
+
+        The above statement can be shortened even further like this =>
+        Comparator<String> stringLengthComparator = Comparator.comparingInt(String::length);
+        */
+
+        // Create a Priority Queue with a custom Comparator
+        PriorityQueue<String> namePriorityQueue = new PriorityQueue<>(stringLengthComparator);
+
+        // Add items to a Priority Queue (ENQUEUE)
+        namePriorityQueue.add("Lisa");
+        namePriorityQueue.add("Robert");
+        namePriorityQueue.add("John");
+        namePriorityQueue.add("Chris");
+        namePriorityQueue.add("Angelina");
+        namePriorityQueue.add("Joe");
+
+        // Remove items from the Priority Queue (DEQUEUE)
+        while (!namePriorityQueue.isEmpty()) {
+            System.out.println(namePriorityQueue.remove());
+        }
+    }
+}

java-priority-queue-examples/src/PriorityQueueUserDefinedObjectExample.java

@@ -0,0 +1,83 @@
+import java.util.Objects;
+import java.util.PriorityQueue;
+
+class Person implements Comparable<Person> {
+    private String name;
+    private double salary;
+
+    public Person(String name, double salary) {
+        this.name = name;
+        this.salary = salary;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public double getSalary() {
+        return salary;
+    }
+
+    public void setSalary(double salary) {
+        this.salary = salary;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        Person person = (Person) o;
+        return Double.compare(person.salary, salary) == 0 &&
+                Objects.equals(name, person.name);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(name, salary);
+    }
+
+    @Override
+    public String toString() {
+        return "Person{" +
+                "name='" + name + '\'' +
+                ", salary=" + salary +
+                '}';
+    }
+
+    // Compare two person objects by their salary
+    @Override
+    public int compareTo(Person person) {
+        if(this.getSalary() > person.getSalary()) {
+            return 1;
+        } else if (this.getSalary() < person.getSalary()) {
+            return -1;
+        } else {
+            return 0;
+        }
+    }
+}
+
+
+public class PriorityQueueUserDefinedObjectExample {
+    public static void main(String[] args) {
+        PriorityQueue<Person> personPriorityQueue = new PriorityQueue<>();
+
+        // Add items to the Priority Queue
+        personPriorityQueue.add(new Person("Rajeev", 100000.00));
+        personPriorityQueue.add(new Person("Chris", 145000.00));
+        personPriorityQueue.add(new Person("Andrea", 115000.00));
+        personPriorityQueue.add(new Person("Jack", 167000.00));
+
+
+        /*
+            The compare() function implemented in the Person class is used to determine in what order the objects should be dequeued.
+        */
+        while (!personPriorityQueue.isEmpty()) {
+            System.out.println(personPriorityQueue.remove());
+        }
+    }
+}

java-treeset-examples/src/TreeSetUserDefinedObjectExample.java

@@ -4,19 +4,19 @@
 import java.util.TreeSet;
 
 class Employee implements Comparable<Employee> {
-    private Integer id;
+    private int id;
     private String name;
 
-    public Employee(Integer id, String name) {
+    public Employee(int id, String name) {
         this.id = id;
         this.name = name;
     }
 
-    public Integer getId() {
+    public int getId() {
         return id;
     }
 
-    public void setId(Integer id) {
+    public void setId(int id) {
         this.id = id;
     }
 
@@ -34,7 +34,7 @@ public boolean equals(Object o) {
         if (this == o) return true;
         if (o == null || getClass() != o.getClass()) return false;
         Employee employee = (Employee) o;
-        return Objects.equals(id, employee.id);
+        return id == employee.id;
     }
 
     @Override
@@ -45,7 +45,7 @@ public int hashCode() {
     // Compare employees based on their IDs
     @Override
     public int compareTo(Employee employee) {
-        return this.getId().compareTo(employee.getId());
+        return this.getId() - employee.getId();
     }
 
     @Override
@@ -65,22 +65,22 @@ public static void main(String[] args) {
         /*
            The requirement for a TreeSet of user defined objects is that
 
-           1. Either the object should implement the Comparable interface and provide
+           1. Either the class should implement the Comparable interface and provide
               the implementation for the compareTo() function.
            2. Or you should provide a custom Comparator while creating the TreeSet.
         */
 
         SortedSet<Employee> employees = new TreeSet<>();
 
-        // TreeSet uses the compareTo() method of the Book class to compare two books and sort them
+        // TreeSet uses the compareTo() method of the Employee class to compare two employees and sort them
         employees.add(new Employee(1010, "Rajeev"));
         employees.add(new Employee(1005, "Sachin"));
         employees.add(new Employee(1008, "Chris"));
 
         System.out.println("Employees (sorted based on Employee class's compareTo() function)");
         System.out.println(employees);
 
-        // Using a Custom Comparator
+        // Providing a Custom Comparator (This comparator compares the employees based on their Name)
         employees = new TreeSet<>(Comparator.comparing(Employee::getName));
 
         employees.add(new Employee(1010, "Rajeev"));