feat(ComparatorDemo2): add demo of custom comparators for integers and strings

What
- Added StringLengthComparator:
  - Implements Comparator<String>.
  - Compares two strings by their length.
  - Returns negative if first is shorter, positive if longer, 0 if equal.
- Added MyComparator:
  - Implements Comparator<Integer>.
  - Compares integers by subtraction (ascending order).
- Added ComparatorDemo2 main class:
  - Example 1: Creates a list of integers [2,3,9,7,1], sorts using MyComparator, prints result.
  - Example 2: Creates a list of strings ["banana","apple","date"], sorts using StringLengthComparator, prints result.

Why
- Demonstrates how to implement and use custom comparators for flexible sorting.
- Highlights the power of Comparator to define multiple external orderings for the same data type.
- Educational example showing comparator usage beyond natural ordering.

How
- Defined two comparator classes implementing Comparator interface.
- In main():
  - list.sort(new MyComparator()) sorts integers ascending.
  - words.sort(new StringLengthComparator()) sorts strings by length ascending.
- Printed results to verify.

Logic
- Inputs:
  - Integers: [2,3,9,7,1].
  - Strings: ["banana","apple","date"].
- Outputs:
  - Integers sorted ascending: [1,2,3,7,9].
  - Strings sorted by length ascending: ["date","apple","banana"].
- Flow:
  1. list.sort() calls compare() from MyComparator → orders numbers.
  2. words.sort() calls compare() from StringLengthComparator → orders by string length.
- Edge cases:
  - MyComparator’s subtraction could overflow for large values; safer to use Integer.compare(o1,o2).
  - StringLengthComparator’s subtraction is safe, but Integer.compare(o1.length(), o2.length()) is clearer.
- Complexity / performance: O(n log n).
- Concurrency / thread-safety: Local lists only; not thread-safe in multi-thread contexts.
- Error handling: None required.

Real-life applications
- Sorting by string length (useful for formatting, UI, word games).
- Sorting integers or custom objects with specific rules (ranking, thresholds).
- Comparators allow different ordering without modifying the class.

Notes
- Comparator.comparingInt(String::length) is a cleaner functional alternative to StringLengthComparator.
- Integer::compare avoids overflow issues.
- This demo illustrates the verbose, explicit class-based comparator approach for clarity.

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

Author: Someshdiwan

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

@@ -0,0 +1,62 @@
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.*;
+
+// Comparator to compare Strings based on their length
+class StringLengthComparator implements Comparator<String> {
+
+    public int compare(String o1, String o2) {
+        // return 0;
+        // If you want to treat all strings as equal
+
+        // return Integer.compare(o1.length(), o2.length());
+        // Alternative way to compare by length
+
+        return o1.length() - o2.length(); // Compare based on string length
+        /*
+           Example Logic:
+           o1    o2
+           "Ok"  "Bye"
+           → "Ok".length() = 2
+           → "Bye".length() = 3
+           → 2 - 3 = -1  (so "Ok" comes before "Bye")
+        */
+    }
+}
+
+// Comparator to compare Integers in ascending order
+class MyComparator implements Comparator<Integer> {
+    @Override
+    public int compare(Integer o1, Integer o2) {
+        return o1 - o2; // Positive if o1 > o2, Negative if o1 < o2
+        /*
+           Example:
+           o1 = 5, o2 = 3 → 5 - 3 = 2  (5 comes after 3)
+           o1 = 3, o2 = 5 → 3 - 5 = -2 (3 comes before 5)
+        */
+    }
+}
+
+public class ComparatorDemo2 {
+    public static void main(String[] args) {
+        // Comparator in Java is very important when sorting based on custom logic.
+
+        // Example 1: Sorting integers using MyComparator
+        List<Integer> list = new ArrayList<>();
+        list.add(2);
+        list.add(3);
+        list.add(9);
+        list.add(7);
+        list.add(1);
+
+        list.sort(new MyComparator());  // Use MyComparator to sort integers
+        System.out.println("Sorted integers: " + list);
+
+        // Example 2: Sorting strings based on their length using StringLengthComparator
+        List<String> words = Arrays.asList("banana", "apple", "date");
+
+        words.sort(new StringLengthComparator());  // Use StringLengthComparator to sort by length
+        System.out.println("Sorted strings by length: " + words);
+    }
+}