feat(ComparableInterfaceDemoIMP): add TreeSet demo with Point implementing Comparable

What
- Added Point class:
  - Fields: x, y (int coordinates).
  - Constructor to initialize coordinates.
  - toString() overridden for readable output ("X=a Y=b").
  - Implements Comparable:
    - compareTo(Object o):
      - Compares by x coordinate.
      - If equal, compares by y coordinate.
      - Returns negative/positive/0 accordingly.
- Added ComparableInterfaceDemoIMP class:
  - Demonstrates storing Point objects in a TreeSet.
  - Inserts points (1,1), (5,5), (5,2).
  - Prints TreeSet, which maintains sorted order based on compareTo().

Why
- Shows how TreeSet requires elements to be comparable.
- Demonstrates defining natural ordering for custom objects.
- Educational example: points ordered first by x, then by y.

How
- TreeSet<Point> created.
- Added three points:
  - (1,1) → first.
  - (5,2) → before (5,5) since y=2 < 5 when x=5 equal.
- TreeSet automatically sorts elements using compareTo().
- Printed TreeSet showing order.

Logic
- Inputs: points (1,1), (5,5), (5,2).
- Outputs: sorted TreeSet:
  [X=1 Y=1, X=5 Y=2, X=5 Y=5].
- Flow:
  1. TreeSet invokes compareTo() on insertion.
  2. Orders by x ascending.
  3. Break ties with y ascending.
- Edge cases:
  - Equal (x,y) → compareTo returns 0 → treated as duplicate, not added.
  - Casting: compareTo(Object o) uses raw Comparable; better to implement Comparable<Point> for type safety.
- Complexity / performance:
  - TreeSet operations O(log n) due to Red-Black tree.
- Concurrency / thread-safety:
  - TreeSet is not thread-safe; local demo safe.
- Error handling:
  - No explicit error handling; ClassCastException if mixed types inserted.

Real-life applications
- Managing sorted collections of coordinates, events, or objects with natural ordering.
- Useful in computational geometry, scheduling, or leaderboard systems.
- Demonstrates role of Comparable for user-defined types in sorted data structures.

Notes
- Comparable<Point> should be used instead of raw Comparable for generics safety.
- TreeSet relies entirely on compareTo for both ordering and duplicate detection.
- Comparator alternative could allow flexible custom orderings (e.g., sort by y first).

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

Author: Someshdiwan

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

@@ -0,0 +1,103 @@
+package Package2;
+
+import java.util.TreeSet;
+
+// A simple Point class representing a 2D coordinate.
+// Implements Comparable so that Point objects can be sorted in a TreeSet.
+class Point implements Comparable {
+    int x;
+    int y;
+
+    // Constructor to initialize a Point with x and y coordinates.
+    public Point(int x, int y) {
+        this.x = x;
+        this.y = y;
+    }
+
+    // Provide a human-readable string representation of the Point.
+    @Override
+    public String toString() {
+        return "X=" + x + " Y=" + y;
+    }
+
+    /* compareTo() defines the "natural ordering" for Point objects.
+     * - First compare by x-coordinate.
+     * - If x is equal, then compare by y-coordinate.
+     * - Returns:
+     *   - negative if this < other,
+     *   - positive if this > other,
+     *   - 0 if both coordinates are equal.
+     */
+
+    @Override
+    public int compareTo(Object o) {
+        Point p = (Point) o;
+
+        if (this.x < p.x)
+            return -1;
+        else if (this.x > p.x)
+            return 1;
+        else {
+            if (this.y < p.y)
+                return -1;
+            else if (this.y > p.y)
+                return 1;
+            else
+                return 0;
+        }
+    }
+}
+
+public class ComparableInterfaceDemoIMP {
+    public static void main(String[] args) {
+        /* In this program, we are storing objects of our own class (Point) inside a TreeSet.
+         * TreeSet:
+         * - A TreeSet is a sorted set (implements NavigableSet).
+         * - It requires elements to be comparable in order to maintain sorted order.
+
+         * Therefore:
+         * - Our Point class implements Comparable so that TreeSet can compare Point objects.
+         * - The compareTo() method defines how two Point objects are compared.
+         */
+
+        TreeSet<Point> TS = new TreeSet<>();
+
+        // Objects are compared using the compareTo() method defined in Point.
+        TS.add(new Point(1, 1));
+        TS.add(new Point(5, 5));
+        TS.add(new Point(5, 2)); // Will be placed before (5,5) since y=2 < y=5
+
+        // Printing TreeSet will show sorted order of Points (by x, then by y).
+        System.out.println(TS);
+    }
+}
+
+/* Summary:
+- This program demonstrates how to store objects of a user-defined class (Point) inside a TreeSet.
+- Since TreeSet is a sorted collection, objects must be comparable.
+- By implementing Comparable and overriding compareTo(), we define the natural ordering of Point objects.
+
+1. Why Comparable?
+   - TreeSet is a sorted set (backed by a Red-Black Tree).
+   - It requires a way to compare objects to maintain order.
+   - For user-defined classes, we must provide comparison logic.
+   - Implementing Comparable and overriding compareTo() achieves this.
+
+2. Ordering Logic in compareTo():
+   - First compares by x-coordinate.
+   - If x values are equal, then compare by y-coordinate.
+   - Returns:
+       - Negative → this < other
+       - Positive → this > other
+       - 0 → both points are equal
+
+3. Output Example:
+   Input points: (1,1), (5,5), (5,2)
+   Sorted order: [(1,1), (5,2), (5,5)]
+
+4. Key Notes:
+   - TreeSet automatically sorts using compareTo().
+   - Duplicate elements (same x and y) are not stored.
+   - Comparable → natural ordering inside the class.
+   - Comparator (alternative) → external custom ordering.
+*/