feat(ComparatorVsComparableDemo): add demo comparing Comparable vs Comparator

What
- Added Student class implementing Comparable<Student>:
  - Natural ordering defined: GPA descending, then Name ascending.
  - compareTo(Student other) first compares GPA (higher first), then name.
  - toString() overridden for readable output.
- Added ComparatorVsComparableDemo class with main method:
  - Created list of Student objects (Charlie, Bob, Alice, Akshit).
  - Demonstrated three sorting approaches:
    1. Using Comparable (Collections.sort) → GPA desc, Name asc.
    2. Using Comparator → sort by Name ascending.
    3. Using Comparator with chaining → GPA ascending, then Name descending.

Why
- Demonstrates clear difference between Comparable and Comparator.
- Provides educational example with both natural ordering and flexible custom orderings.
- Shows practical usage of Comparator.comparing(), comparingDouble(), and thenComparing().

How
- Comparable:
  - compareTo implemented in Student → defines single natural ordering.
  - Used Collections.sort(students) with no comparator.
- Comparator:
  - Used list.sort(Comparator.comparing(s -> s.name)) for name ascending.
  - Used list.sort(Comparator.comparingDouble(s -> s.gpa).thenComparing(...)) for GPA asc, Name desc.
- Printed results after each sort to verify differences.

Logic
- Inputs: list of students with GPA and names.
- Outputs:
  - After Comparable: [Akshit (3.9), Bob (3.7), Alice (3.5), Charlie (3.5)].
  - After Comparator (Name asc): [Akshit, Alice, Bob, Charlie].
  - After Comparator (GPA asc, Name desc): [Charlie (3.5), Alice (3.5), Bob (3.7), Akshit (3.9)].
- Flow:
  1. Natural order sort via Comparable.
  2. Custom order sort by name via Comparator.
  3. Another custom sort by GPA asc, then name desc.
- Edge cases:
  - Students with identical GPA and name → treated as equal by compareTo.
- Complexity / performance: O(n log n) sort.
- Concurrency / thread-safety: Not thread-safe; local list only.
- Error handling: Not needed here.

Real-life applications
- Comparable: best when there’s one canonical ordering (IDs, dates, scores).
- Comparator: flexible for multi-criteria sorting in UIs, reports, or user-specified orders.
- Useful in databases, ranking systems, and sorting utilities.

Notes
- Comparable provides a single natural order hardcoded into the class.
- Comparator provides external, pluggable strategies, allowing multiple sort orders without modifying the class.
- Comparator chaining (thenComparing) simplifies multi-field sorting.

Signed-off-by: https://github.com/Someshdiwan <[email protected]>

Author: Someshdiwan

Section 25 Collections Frameworks/List Interface/ArrayList/Comparator/src/Package1/ComparatorVsComparableDemo.java

@@ -0,0 +1,81 @@
+package Package1;
+
+import java.util.*;
+
+// Student implements Comparable → defines natural ordering
+class Student implements Comparable<Student> {
+    String name;
+    double gpa;
+
+    public Student(String name, double gpa) {
+        this.name = name;
+        this.gpa = gpa;
+    }
+
+    // Natural ordering → GPA descending, then name ascending
+    @Override
+    public int compareTo(Student other) {
+        int gpaComparison = Double.compare(other.gpa, this.gpa);
+        if (gpaComparison != 0) return gpaComparison;
+        return this.name.compareTo(other.name);
+    }
+
+    @Override
+    public String toString() {
+        return "{name='" + name + "', gpa=" + gpa + "}";
+    }
+}
+
+public class ComparatorVsComparableDemo {
+    public static void main(String[] args) {
+        List<Student> students = new ArrayList<>();
+        students.add(new Student("Charlie", 3.5));
+        students.add(new Student("Bob", 3.7));
+        students.add(new Student("Alice", 3.5));
+        students.add(new Student("Akshit", 3.9));
+
+        // Using Comparable (natural ordering)
+        Collections.sort(students);
+        System.out.println("Sorted by Comparable (GPA desc, Name asc): " + students);
+
+        // Using Comparator (custom ordering → Name only, ascending)
+        students.sort(Comparator.comparing(s -> s.name));
+        System.out.println("Sorted by Comparator (Name asc): " + students);
+
+        // Another Comparator → GPA ascending, then Name descending
+        students.sort(Comparator
+                .comparingDouble((Student s) -> s.gpa)
+                .thenComparing(Comparator.comparing((Student s) -> s.name).reversed()));
+        System.out.println("Sorted by Comparator (GPA asc, Name desc): " + students);
+    }
+}
+
+/*
+1. Comparable:
+   - Defined inside the class using compareTo().
+   - Provides "natural ordering" of objects.
+   - Only ONE natural order can exist per class.
+   - Example here: GPA descending, then Name ascending.
+
+2. Comparator:
+   - External object or lambda passed when sorting.
+   - Allows multiple different sorting logics without changing the class.
+   - Can be chained (thenComparing).
+   - Example here:
+       a) By Name ascending
+       b) By GPA ascending, then Name descending
+
+3. Key Differences:
+
+| Aspect           | Comparable                         | Comparator                          |
+|------------------|------------------------------------|-------------------------------------|
+| Package          | java.lang                          | java.util                           |
+| Method           | compareTo(Object o)                | compare(Object o1, Object o2)       |
+| Location         | Inside the class itself            | Separate class / lambda / method ref|
+| Ordering Count   | One natural order per class        | Multiple custom orders possible     |
+| Usage            | Collections.sort(list)             | list.sort(Comparator) / TreeSet(c)  |
+
+4. When to Use:
+- Comparable → If there is a single, natural way to compare objects (e.g., GPA for students, ID for employees).
+- Comparator → If you need flexible or multiple ways to sort (by GPA, by name, by age, etc.).
+*/