feat(ComparatorDemo): add custom comparator sorting students by GPA desc then Name asc

What
- Added Student class:
  - Fields: name (String), gpa (double).
  - Constructor, getters for name and gpa.
- Added ComparatorDemo class:
  - Creates list of Student objects: Alice (3.5), Bob (3.1), Charlie (3.9), Akshit (3.4), Smith (3.4).
  - Demonstrates sorting with a custom Comparator via lambda:
    - Primary: GPA descending.
    - Secondary: Name ascending (alphabetical).
  - Prints sorted students to stdout.

Why
- Shows how to implement flexible, context-specific ordering without modifying Student class.
- Highlights Comparator as external strategy for sorting compared to Comparable (natural ordering).
- Demonstrates dictionary-order comparison of Strings with compareTo().

How
- Used Students.sort((o1, o2) -> {...}) lambda comparator.
- GPA comparison: o2.getGpa() - o1.getGpa() for descending order.
- If GPAs equal: fallback to o1.getName().compareTo(o2.getName()) for ascending lex order.
- Iterated and printed each student’s name and GPA after sorting.

Logic
- Inputs: list of 5 students.
- Outputs:
  Sorted order:
  1. Charlie (3.9)
  2. Alice (3.5)
  3. Akshit (3.4)
  4. Smith (3.4)
  5. Bob (3.1)
- Flow:
  1. Sort list using custom comparator.
  2. Comparator returns +1 / -1 depending on GPA difference.
  3. On equal GPAs, compareTo() ensures alphabetical order.
  4. Print sorted list.
- Edge cases:
  - Floating point subtraction can be imprecise; safer to use Double.compare().
  - Equal GPA and equal name → comparator returns 0; considered equal by sorting.
- Complexity / performance: O(n log n).
- Concurrency / thread-safety: Not thread-safe; demo is local and safe.
- Error handling: Not applicable.

Real-life applications
- Ranking students by GPA while ensuring stable alphabetical order for ties.
- Useful in education systems, leaderboards, reporting tools.
- Comparator lambdas allow context-specific sorting without modifying entity class.

Notes
- Using Double.compare(o2.getGpa(), o1.getGpa()) is clearer and avoids floating-point pitfalls.
- Comparator.comparingDouble(Student::getGpa).reversed().thenComparing(Student::getName) offers a cleaner functional alternative.
- Current implementation demonstrates verbose lambda logic for educational clarity.

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

Author: Someshdiwan

Section25CollectionFramework/src/ListDemo/ArrayListLinkedListStack/ComparatorDemo.java renamed to Section 25 Collections Frameworks/List Interface/ArrayList/Comparator/src/ComparatorDemo.java

@@ -1,14 +1,12 @@
-package ListDemo.ArrayListLinkedListStack;
-
 import java.util.ArrayList;
 import java.util.List;
 
-class Student{
+class Student {
     private String name;
 
     private double gpa;
 
-    public Student(String name, double gpa){
+    public Student(String name, double gpa) {
         this.name = name;
         this.gpa = gpa;
     }
@@ -39,32 +37,28 @@ public static void main(String[] args) {
         // This comparator sorts the students primarily by descending GPA.
         // If two students have the same GPA, it sorts them alphabetically by name.
 
-        Students.sort((o1,o2)->
-        {
+        Students.sort((o1,o2)-> {
             // Calculate the difference in GPA (note: o2 - o1 gives descending order).
-           if(o2.getGpa() - o1.getGpa() > 0)
-           {
-               // If o2 has a higher GPA, it should come before o1.
-               return 1;
-           }
-           else if (o2.getGpa() - o1.getGpa() < 0)
-           {
-               // If o1 has a higher GPA, it should come before o2.
-               return -1;
-           }
-           else
-           {
-               // If GPAs are equal, sort by name in ascending (alphabetical) order.
-               return o1.getName().compareTo(o2.getName());
-               //Lexicographically compare kar raha hai...words ko dictionary order (alphabetical order)
-               //mein compare kiya ja raha hai. Java mein, jab hum String ke compareTo() method ko call karte hain,
-               //toh woh dono strings ke characters ko ek-ek karke compare karta hai
-           }
+            if(o2.getGpa() - o1.getGpa() > 0) {
+                // If o2 has a higher GPA, it should come before o1.
+                return 1;
+            }
+
+            else if (o2.getGpa() - o1.getGpa() < 0) {
+                // If o1 has a higher GPA, it should come before o2.
+                return -1;
+            }
+            else {
+                // If GPAs are equal, sort by name in ascending (alphabetical) order.
+                return o1.getName().compareTo(o2.getName());
+                //Lexicographically compare kar raha hai...words ko dictionary order (alphabetical order)
+                //mein compare kiya ja raha hai. Java mein, jab hum String ke compareTo() method ko call karte hain,
+                //toh woh dono strings ke characters ko ek-ek karke compare karta hai
+            }
         });
 
-        for(Student s : Students)
-        {
+        for(Student s : Students) {
             System.out.println(s.getName()+": "+s.getGpa());
         }
     }
-}
+}