feat(ComparableDemo): add demo of natural ordering with Comparable

What
- Added Student class in package Package2 implementing Comparable<Student>:
  - Fields: name, gpa.
  - Constructor to initialize fields.
  - compareTo(Student other):
    - Primary ordering: GPA descending (higher first).
    - Secondary ordering: name ascending (alphabetical).
  - toString() overridden for readable output.
- Added ComparableDemo class:
  - Creates list of Student objects.
  - Sorts list using natural ordering (list.sort(null)).
  - Prints sorted students.
  - Creates list of Integer objects.
  - Sorts integers using their natural ordering (ascending).
  - Prints sorted numbers.

Why
- Demonstrates how Comparable defines a natural order for objects.
- Shows how Collections can use natural ordering when sorting with null comparator.
- Provides educational comparison between Student (custom natural order) and Integer (built-in natural order).

How
- Student implements Comparable and defines compareTo() logic.
- In main():
  - list.sort(null) sorts by Student’s compareTo() implementation.
  - numbers.sort(null) sorts by Integer’s natural order.
- Printed results for both lists.

Logic
- Inputs:
  - Students: Charlie (3.5), Bob (3.7), Alice (3.5), Akshit (3.9).
  - Integers: [2, 1, 99].
- Outputs:
  - Students sorted by GPA descending, then name ascending:
    [Student{name='Akshit', gpa=3.9}, Student{name='Bob', gpa=3.7}, Student{name='Alice', gpa=3.5}, Student{name='Charlie', gpa=3.5}]
  - Integers sorted ascending:
    [1, 2, 99].
- Flow:
  1. Define natural ordering in Student via compareTo.
  2. Use sort(null) to rely on that natural ordering.
  3. Print ordered collections.
- Edge cases:
  - Equal GPA and equal name → considered equal by compareTo.
- Complexity / performance: O(n log n) sorting.
- Concurrency / thread-safety: Local lists; not thread-safe but safe in demo context.
- Error handling: Not applicable.

Real-life applications
- Ranking students by GPA with consistent tiebreakers.
- Comparable makes classes naturally sortable without requiring external comparators.
- Useful in data structures like TreeSet or TreeMap that rely on natural ordering.

Notes
- Passing null to sort() explicitly signals to use natural ordering.
- Comparator can still be supplied later for alternate orderings without modifying class.
- Good practice: ensure compareTo is consistent with equals() for predictable behavior in sorted collections.

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

Author: Someshdiwan

Section 25 Collections Frameworks/List Interface/ArrayList/Comparator/src/Package2/ComparableDemo.java

@@ -0,0 +1,78 @@
+package Package2;
+
+import java.util.ArrayList;
+import java.util.List;
+
+// Student class implements Comparable to define natural ordering of Student objects.
+class Student implements Comparable<Student> {
+
+    // Instance variables: hold the student's name and GPA.
+    private String name;
+    private double gpa;
+
+    // Constructor: initializes Student with a name and GPA.
+    public Student(String name, double gpa) {
+        this.name = name;
+        this.gpa = gpa;
+    }
+
+    /* The Comparable interface imposes a total ordering on the objects of the class.
+     * - compareTo() defines the "natural ordering" of objects.
+     * - Collections like List or TreeMap can use this ordering for sorting automatically.
+
+     * In this implementation:
+     * - Students are compared primarily by GPA.
+     * - Order is descending by GPA (higher GPA comes first).
+     * - If GPAs are equal, comparison falls back to the student's name (ascending lexicographical order).
+     */
+
+    @Override
+    public int compareTo(Student other) {
+        // Compare by GPA (descending).
+        int gpaComparison = Double.compare(other.gpa, this.gpa);
+        if (gpaComparison != 0) {
+            return gpaComparison;
+        }
+        // If GPA is the same, compare by name (ascending).
+        return this.name.compareTo(other.name);
+    }
+
+    // Override toString to provide a human-readable representation of the Student object.
+    @Override
+    public String toString() {
+        return "Student{name='" + name + "', gpa=" + gpa + "}";
+    }
+}
+
+public class ComparableDemo {
+    public static void main(String[] args) {
+
+        // Create a list of Student objects.
+        List<Student> list = new ArrayList<>();
+        list.add(new Student("Charlie", 3.5));
+        list.add(new Student("Bob", 3.7));
+        list.add(new Student("Alice", 3.5));
+        list.add(new Student("Akshit", 3.9));
+
+        // Sort the list using natural ordering (defined in compareTo).
+        // Passing `null` to sort() means "use the natural ordering."
+        list.sort(null);
+        System.out.println(list);
+
+        // Create a list of integers.
+        List<Integer> numbers = new ArrayList<>();
+        numbers.add(2);
+        numbers.add(1);
+        numbers.add(99);
+
+        // Sort integers in their natural ordering (ascending).
+        numbers.sort(null);
+        System.out.println(numbers);
+
+        /* NOTE:
+         * - Comparable: Used when a class defines its own "natural order" by implementing compareTo().
+         * - Comparator: Used for custom sorting logic, external to the class.
+         * - In this example, Student implements Comparable, so we can sort Students naturally by GPA + name.
+         */
+    }
+}