feat(Student): add Student class with Comparable and StudentDemo sorting example

What
- Added Student class:
  - Fields: name (String), gpa (double).
  - Constructor, getters.
  - equals() and hashCode() implemented via Objects for correct equality.
  - toString() overridden for debugging.
  - Comparable<Student> implemented to sort by GPA descending.
- Added StudentDemo class:
  - Creates list of Student objects (Charlie, Bob, Alice, Akshit).
  - Demonstrates two sorting approaches:
    1. Manual lambda comparator (GPA descending, then name descending).
    2. Comparator built using Comparator.comparing().reversed().thenComparing(Student::getName).
  - Prints student list after each sort.

Why
- Illustrates multiple ways of defining natural ordering and custom comparators in Java.
- Provides educational example of sorting by GPA (descending) and tie-breaking by name.
- Demonstrates the relationship between Comparable and Comparator utilities.

How
- In Student:
  - Implemented compareTo(Student o) → Double.compare(o.getGpa(), this.getGpa()).
  - Ensures natural ordering is GPA descending.
- In StudentDemo:
  - Created manual comparator lambda replicating GPA-first then name.
  - Applied students.sort(lambda) → prints first ordering.
  - Built Comparator via Comparator.comparing(Student::getGpa).reversed().thenComparing(Student::getName).
  - Applied Collections.sort(students, comparator) → prints second ordering.

Logic
- Inputs: list of students with names and GPAs.
- Outputs: two printouts of student list after different sorts.
- Flow:
  1. Construct student list.
  2. Sort with manual lambda.
  3. Print sorted list.
  4. Sort with Comparator helper.
  5. Print sorted list again.
- Example ordering:
  - After both sorts, order is consistent: Akshit (3.9), Bob (3.7), Alice (3.5), Charlie (3.5).
- Edge cases:
  - Students with same GPA and name → equals() ensures equality.
  - GPA floating-point precision handled by Double.compare.
- Complexity / performance: O(n log n) sort.
- Concurrency / thread-safety: Not thread-safe, but list is local in main.
- Error handling: Not required.

Real-life applications
- Student ranking systems, leaderboards, or GPA sorting.
- Demonstrates how tie-breaking can be implemented in multiple styles.
- Shows best practice of combining Comparable (natural order) with explicit Comparator (custom order).

Notes
- Manual comparator uses subtraction logic; prefer Double.compare for clarity and to avoid edge-case bugs.
- Comparator.comparing() is more concise and readable.
- Using thenComparing() provides natural tie-breaking without nesting conditionals.

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

Author: Someshdiwan

Section 25 Collections Frameworks/List Interface/ArrayList/Comparator/src/Package/Student.java

@@ -0,0 +1,50 @@
+package Package;
+
+import java.util.Objects;
+
+/**
+ * Student data class.
+ * Comparable implementation sorts by GPA descending (higher GPA first).
+ */
+
+public class Student implements Comparable<Student> {
+    private String name;
+    private double gpa;
+
+    public Student(String name, double gpa) {
+        this.name = name;
+        this.gpa  = gpa;
+    }
+
+    public String getName() { return name; }
+    public double getGpa()  { return gpa; }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        Student student = (Student) o;
+        return Double.compare(gpa, student.gpa) == 0 && Objects.equals(name, student.name);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(name, gpa);
+    }
+
+    @Override
+    public String toString() {
+        return "Student{" +
+                "name='" + name + '\'' +
+                ", gpa=" + gpa +
+                '}';
+    }
+
+    /**
+     * Comparable: sorts by GPA descending (higher GPA -> earlier).
+     */
+    @Override
+    public int compareTo(Student o) {
+        return Double.compare(o.getGpa(), this.getGpa());
+    }
+}

Section 25 Collections Frameworks/List Interface/ArrayList/Comparator/src/Package/StudentDemo.java

@@ -0,0 +1,54 @@
+package Package;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+
+/**
+ * Demonstrates sorting a List<Student>.
+ * Keeps your original manual comparator logic intact and then
+ * shows sorting with a Comparator built via Comparator.comparing().
+ */
+
+public class StudentDemo {
+    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));
+
+        // Comparator constructed with Comparator helpers (keeps the same ordering intent)
+        Comparator<Student> comparator = Comparator
+                .comparing(Student::getGpa)
+                .reversed()
+                .thenComparing(Student::getName);
+
+        // The original manual sort using lambda you provided (kept exactly)
+        students.sort((o1, o2) -> {
+            if (o2.getGpa() - o1.getGpa() > 0) {
+                return 1;
+            } else if (o2.getGpa() - o1.getGpa() < 0) {
+                return -1;
+            } else {
+                return o2.getName().compareTo(o1.getName());
+            }
+        });
+
+        // Print after the first sort
+        System.out.println("After manual sort (original logic):");
+        for (Student s : students) {
+            System.out.println(s.getName() + ": " + s.getGpa());
+        }
+
+        // Now sort again using the Comparator (same intended order)
+        Collections.sort(students, comparator);
+
+        // Print after Collections.sort (comparator)
+        System.out.println("\nAfter Collections.sort with comparator:");
+        for (Student s : students) {
+            System.out.println(s.getName() + ": " + s.getGpa());
+        }
+    }
+}