feat: add CopyOnWriteArraySet vs ConcurrentSkipListSet demo

What
- New demo `CopyOnWriteArraySetDemo` comparing two thread-safe `Set` implementations:
  - `CopyOnWriteArraySet` (backed by `CopyOnWriteArrayList`).
  - `ConcurrentSkipListSet` (concurrent, sorted set based on skip list).

Why
- Illustrates differences in iteration and modification behavior under concurrent-like patterns.
- Demonstrates how copy-on-write iterators remain unaffected by modifications, while skip-list iterators reflect changes.

How
- Created both sets and added integers 1–5.
- Iterated `CopyOnWriteArraySet` while adding element `6` → safe, but iterator does not see the modification until future iterations.
- Iterated `ConcurrentSkipListSet` while adding element `6` → safe, iterator reflects concurrent modifications and includes new element in iteration.
- Printed initial contents and iteration results.

Logic
- `CopyOnWriteArraySet`:
  - Snapshot semantics for iterators → modifications create new underlying array copies, no `ConcurrentModificationException`.
  - No duplicates allowed.
- `ConcurrentSkipListSet`:
  - Lock-free, concurrent skip list implementation.
  - Iterators are weakly consistent → may reflect modifications made during traversal.

Applications
- Use `CopyOnWriteArraySet` for small, mostly-read sets where iteration speed and consistency matter more than mutation performance.
- Use `ConcurrentSkipListSet` for sorted sets under heavy concurrent updates where you want modifications visible during traversal.

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

Author: Someshdiwan

Section25CollectionFramework/src/ListDemo/CopyOnWriteArrayListDemo/CopyOnWriteArraySetDemo.java renamed to Section 25 Collections Frameworks/List Interface/Copy On Write ArrayList/src/CopyOnWriteArraySetDemo.java

@@ -1,16 +1,12 @@
-package ListDemo.CopyOnWriteArrayListDemo;
-
 import java.util.concurrent.ConcurrentSkipListSet;
 import java.util.concurrent.CopyOnWriteArraySet;
 
 public class CopyOnWriteArraySetDemo {
     public static void main(String[] args) {
-        // Thread-Safe
-        // Copy-On-Write Mechanism
-        // No Duplicate Elements
-        // Iterators Do Not Reflect Modifications
+        // Thread-Safe, Copy-On-Write Mechanism, No Duplicate Elements, Iterators Do Not Reflect Modifications
 
         CopyOnWriteArraySet<Integer> copyOnWriteSet = new CopyOnWriteArraySet<>();
+
         ConcurrentSkipListSet<Integer> concurrentSkipListSet = new ConcurrentSkipListSet<>();
 
         for (int i = 1; i <= 5; i++) {
@@ -19,22 +15,30 @@ public static void main(String[] args) {
         }
 
         System.out.println("Initial CopyOnWriteArraySet: " + copyOnWriteSet);
+
         System.out.println("Initial ConcurrentSkipListSet: " + concurrentSkipListSet);
 
         System.out.println("\nIterating and modifying CopyOnWriteArraySet:");
-        for (Integer num : copyOnWriteSet) {
+
+        for (Integer num : copyOnWriteSet)
+        {
             System.out.println("Reading from CopyOnWriteArraySet: " + num);
+
             // Attempting to modify the set during iteration
             copyOnWriteSet.add(6);
         }
-        /*System.out.println(copyOnWriteSet);*/
+        /* System.out.println(copyOnWriteSet); */
+
 
         System.out.println("\nIterating and modifying ConcurrentSkipListSet:");
-        for (Integer num : concurrentSkipListSet) {
+
+        for (Integer num : concurrentSkipListSet)
+        {
             System.out.println("Reading from ConcurrentSkipListSet: " + num);
+
             // Attempting to modify the set during iteration
-           /* if (num == 5)*/
+            /* if (num == 5)*/
                 concurrentSkipListSet.add(6);
-            }
         }
     }
+}