feat(ComparatorDemo3): add demo of Arrays utilities and lexicographic comparison

What
- Added ComparatorDemo3 class:
  - Demonstrates usage of java.util.Arrays methods for array comparison and manipulation.
  - Created two int[] arrays a and b.
  - Compared arrays with Arrays.compare(a, b) → lexicographic comparison.
  - Copied array a into c using Arrays.copyOf(a, a.length).
  - Printed all elements of c.
  - Converted primitive int[] to Integer[] using streams and boxing for deep comparison.
  - Checked equality with Arrays.deepEquals(objA, objC).
  - Left comments suggesting use of other methods: Arrays.mismatch(), Arrays.sort(), Arrays.parallelPrefix().

Why
- Teaches how Arrays utilities simplify operations like comparison, copying, and equality checks.
- Highlights difference between compare() (lexicographic) and deepEquals() (content-based).
- Provides a foundation for exploring more advanced Arrays methods.

How
- Arrays.compare(a, b):
  - Compares arrays element by element.
  - Returns negative if first mismatching element in a < b.
  - Returns positive if a > b at mismatch.
  - Returns 0 if arrays are equal.
- Arrays.copyOf(a, a.length): duplicates array a fully.
- Arrays.stream(a).boxed(): converts int[] → Stream<Integer>.
- toArray(Integer[]::new): collects stream into Integer[].
- Arrays.deepEquals(objA, objC): checks equality element by element for object arrays.

Logic
- Inputs:
  - a = [2,4,6,8,1,3,5,11].
  - b = [2,4,6,8,1,3,5,7].
- Outputs:
  - Arrays.compare(a, b) → positive result (11 > 7 at mismatch).
  - Copy of a into c → identical to a.
  - Printed elements of c.
  - deepEquals(objA, objC) → true, since a and c are equal element by element.
- Edge cases:
  - Arrays.compare handles different lengths: shorter is "less" if all common elements match.
  - deepEquals requires object arrays, hence boxing needed for int[].
- Complexity / performance:
  - compare() and deepEquals() run in O(n).
  - Boxing adds overhead; only required for object-level comparisons.
- Concurrency / thread-safety: Not thread-safe; operations on local arrays are safe in demo.
- Error handling: Not applicable.

Real-life applications
- Comparing arrays for equality or lexicographic order (e.g., version numbers).
- Copying arrays for immutability or manipulation without altering originals.
- Using deepEquals() for nested or object arrays.
- Arrays utilities simplify common operations in algorithms, testing, or data processing.

Notes
- For primitive arrays, prefer Arrays.equals(a, c) instead of deepEquals after boxing.
- Arrays.mismatch(a, b) can find the first differing index.
- Arrays.parallelPrefix() supports efficient prefix-sum style computations in parallel.

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

Author: Someshdiwan

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

@@ -1,41 +1,41 @@
-package ListDemo.ArraysandComparator;
-
 import java.util.Arrays;
 
 /**
  * This class demonstrates the usage of Arrays and the Comparator interface in Java.
  *
  * @see <a href="https://www.geeksforgeeks.org/comparator-interface-java/">Comparator Interface - GeeksforGeeks</a>
  */
-public class ComparatorDemo {
-    public static void main(String[] args)
-    {
+
+public class ComparatorDemo3 {
+    public static void main(String[] args) {
         int a[] = {2,4,6,8,1,3,5,11};
         int b[] = {2,4,6,8,1,3,5,7};
+
         /*
-        Checking both array same or not.
-        Try to remove one element from both array one by one. remove one or many as you wish.
+        Checking both arrays the same or not.
+        Try to remove one element from both arrays one by one. remove one or many as you wish.
         The method Arrays.compare(a, b) in Java compares two arrays lexicographically.
         This means it compares elements one by one from the beginning, and as soon as it finds a mismatch,
         it determines the order based on that difference.
         */
+
         System.out.println(Arrays.compare(a,b));
 
-       //int c[] =  Arrays.copyOf(a,4);
-       int c[] =  Arrays.copyOf(a,a.length);
-       for(int x:c)
-           System.out.println("Print all elements: "+x);
+        //int c[] =  Arrays.copyOf(a,4);
+        int c[] =  Arrays.copyOf(a,a.length);
+        for(int x:c)
+            System.out.println("Print all elements: "+x);
 
         // Convert primitive int[] to Integer[] for deepEquals
         Integer[] objA = Arrays.stream(a).boxed().toArray(Integer[]::new);
         Integer[] objC = Arrays.stream(c).boxed().toArray(Integer[]::new);
 
         System.out.println("Are arrays deeply equal? " + Arrays.deepEquals(objA, objC));
 
-        /*Try others methods also.*/
+        /* Try others methods also. */
 
-        //Arrays.mismatch(, );
-        //Arrays.sort();
-        //Arrays.parallelPrefix();
+        // Arrays.mismatch(, );
+        // Arrays.sort();
+        // Arrays.parallelPrefix();
     }
-}
+}