Java Stack, Queue, Comparator and Comparable

Author: Rajeev Kumar Singh

Readme.md

@@ -13,3 +13,7 @@
 6. [Java HashSet Tutorial with Examples](https://www.callicoder.com/java-hashset/)
 
 7. [Java TreeSet Tutorial with Examples](https://www.callicoder.com/java-treeset/)
+
+8. [Java Stack Class Tutorial with Examples](https://www.callicoder.com/java-stack/)
+
+9. [Java Queue Interface Tutorial with Examples](https://www.callicoder.com/java-queue/)

java-comparable-comparator-examples/src/ComparableExample.java

@@ -10,18 +10,18 @@ public static void main(String[] args) {
 
         employees.add(new Employee(1010, "Rajeev", 100000.00, LocalDate.of(2010, 7, 10)));
         employees.add(new Employee(1004, "Chris", 95000.50, LocalDate.of(2017, 3, 19)));
-        employees.add(new Employee(1007, "David", 134000.00, LocalDate.of(2017, 9, 28)));
+        employees.add(new Employee(1015, "David", 134000.00, LocalDate.of(2017, 9, 28)));
 
         System.out.println("Employees (Before Sorting) : " + employees);
 
         // This will use the `compareTo()` method of the `Employee` class to compare two employees and sort them.
         Collections.sort(employees);
 
-        System.out.println("Employees (After Sorting) : " + employees);
+        System.out.println("\nEmployees (After Sorting) : " + employees);
 
         // This will use the same `compareTo()` method of the `Employee` class but will reverse the order
         Collections.sort(employees, Comparator.reverseOrder());
-        System.out.println("Employees (After Sorting with reverseOrder)" + employees);
+        System.out.println("\nEmployees (After Sorting with reverseOrder)" + employees);
     }
 
 }

java-comparable-comparator-examples/src/ComparatorExample.java

@@ -27,9 +27,9 @@ public static void main(String[] args) {
         Collections.sort(employees, Comparator.comparing(Employee::getJoiningDate));
         System.out.println("\nEmployees (Sorted by JoiningDate) : " + employees);
 
-        // Sort employees by descending order of Name
+        // Sort employees by Name in descending order
         Collections.sort(employees, Comparator.comparing(Employee::getName).reversed());
-        System.out.println("\nEmployees (Sorted by Name Descending Order) : " + employees);
+        System.out.println("\nEmployees (Sorted by Name in descending order) : " + employees);
 
         // Chaining multiple Comparators
         // Sort by Salary. If Salary is same then sort by Name

java-comparable-comparator-examples/src/Employee.java

@@ -1,4 +1,5 @@
 import java.time.LocalDate;
+import java.util.Objects;
 
 class Employee implements Comparable<Employee> {
     private int id;
@@ -56,6 +57,20 @@ public int compareTo(Employee anotherEmployee) {
         return this.getId() - anotherEmployee.getId();
     }
 
+    // Two employees are equal if their IDs are equal
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        Employee employee = (Employee) o;
+        return id == employee.id;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(id);
+    }
+
     @Override
     public String toString() {
         return "Employee{" +

java-linkedhashmap-examples/src/RemoveEntriesFromLinkedHashMapExample.java

@@ -11,11 +11,11 @@ public static void main(String[] args) {
 
         System.out.println("husbandWifeMapping : " + husbandWifeMapping);
 
-        // Remove the entry with the given key from the LinkedHashMap
+        // Remove a key from the LinkedHashMap
         String wife = husbandWifeMapping.remove("John");
         System.out.println("Removed John and his wife " + wife + " from the mapping. New husbandWifeMapping : " + husbandWifeMapping);
 
-        // Remove the entry with the given key from the LinkedHashMap only if the key is mapped to the given value
+        // Remove a key from the LinkedHashMap only if it is mapped to the given value
         boolean isRemoved = husbandWifeMapping.remove("John", "Susan");
         System.out.println("Did John get removed from the mapping? : " + isRemoved);
     }

java-queue-examples/src/QueueExample.java

@@ -0,0 +1,28 @@
+import java.util.LinkedList;
+import java.util.Queue;
+
+public class QueueExample {
+    public static void main(String[] args) {
+        // Create and initialize a Queue using a LinkedList
+        Queue<String> waitingQueue = new LinkedList<>();
+
+        // Adding new elements to the Queue (The Enqueue operation)
+        waitingQueue.add("Rajeev");
+        waitingQueue.add("Chris");
+        waitingQueue.add("John");
+        waitingQueue.add("Mark");
+        waitingQueue.add("Steven");
+
+        System.out.println("WaitingQueue : " + waitingQueue);
+
+        // Removing an element from the Queue using remove() (The Dequeue operation)
+        // The remove() method throws NoSuchElementException if the Queue is empty
+        String name = waitingQueue.remove();
+        System.out.println("Removed from WaitingQueue : " + name + " | New WaitingQueue : " + waitingQueue);
+
+        // Removing an element from the Queue using poll()
+        // The poll() method is similar to remove() except that it returns null if the Queue is empty.
+        name = waitingQueue.poll();
+        System.out.println("Removed from WaitingQueue : " + name + " | New WaitingQueue : " + waitingQueue);
+    }
+}

java-queue-examples/src/QueueSizeSearchFrontExample.java

@@ -0,0 +1,40 @@
+import java.util.LinkedList;
+import java.util.Queue;
+
+public class QueueSizeSearchFrontExample {
+    public static void main(String[] args) {
+        Queue<String> waitingQueue = new LinkedList<>();
+
+        waitingQueue.add("Jennifer");
+        waitingQueue.add("Angelina");
+        waitingQueue.add("Johnny");
+        waitingQueue.add("Sachin");
+
+        System.out.println("WaitingQueue : " + waitingQueue);
+
+        // Check is a Queue is empty
+        System.out.println("is waitingQueue empty? : " + waitingQueue.isEmpty());
+
+        // Find the size of the Queue
+        System.out.println("Size of waitingQueue : " + waitingQueue.size());
+
+        // Check if the Queue contains an element
+        String name = "Johnny";
+        if(waitingQueue.contains(name)) {
+            System.out.println("WaitingQueue contains " + name);
+        } else {
+            System.out.println("Waiting Queue doesn't contain " + name);
+        }
+
+        // Get the element at the front of the Queue without removing it using element()
+        // The element() method throws NoSuchElementException if the Queue is empty
+        String firstPersonInTheWaitingQueue =  waitingQueue.element();
+        System.out.println("First Person in the Waiting Queue (element()) : " + firstPersonInTheWaitingQueue);
+
+        // Get the element at the front of the Queue without removing it using peek()
+        // The peek() method is similar to element() except that it returns null if the Queue is empty
+        firstPersonInTheWaitingQueue = waitingQueue.peek();
+        System.out.println("First Person in the Waiting Queue : " + firstPersonInTheWaitingQueue);
+
+    }
+}

java-stack-examples/src/StackExample.java

@@ -0,0 +1,29 @@
+import java.util.Stack;
+
+public class StackExample {
+    public static void main(String[] args) {
+        // Creating a Stack
+        Stack<String> stackOfCards = new Stack<>();
+
+        // Pushing new items to the Stack
+        stackOfCards.push("Jack");
+        stackOfCards.push("Queen");
+        stackOfCards.push("King");
+        stackOfCards.push("Ace");
+
+        System.out.println("Stack => " + stackOfCards);
+        System.out.println();
+
+        // Popping items from the Stack
+        String cardAtTop = stackOfCards.pop();  // Throws EmptyStackException if the stack is empty
+        System.out.println("Stack.pop() => " + cardAtTop);
+        System.out.println("Current Stack => " + stackOfCards);
+        System.out.println();
+
+        // Get the item at the top of the stack without removing it
+        cardAtTop = stackOfCards.peek();
+        System.out.println("Stack.peek() => " + cardAtTop);
+        System.out.println("Current Stack => " + stackOfCards);
+
+    }
+}

java-stack-examples/src/StackSizeSearchExample.java

@@ -0,0 +1,32 @@
+import java.util.Stack;
+
+public class StackSizeSearchExample {
+    public static void main(String[] args) {
+        Stack<String> stackOfCards = new Stack<>();
+
+        stackOfCards.push("Jack");
+        stackOfCards.push("Queen");
+        stackOfCards.push("King");
+        stackOfCards.push("Ace");
+
+        System.out.println("Stack : " + stackOfCards);
+
+        // Check if the Stack is empty
+        System.out.println("Is Stack empty? : " + stackOfCards.isEmpty());
+
+        // Find the size of Stack
+        System.out.println("Size of Stack : " + stackOfCards.size());
+
+        // Search for an element
+        // The search() method returns the 1-based position of the element from the top of the stack
+        // It returns -1 if the element was not found in the stack
+        int position = stackOfCards.search("Queen");
+
+        if(position != -1) {
+            System.out.println("Found the element \"Queen\" at position : " + position);
+        } else {
+            System.out.println("Element not found");
+        }
+
+    }
+}