feat(Demo): add CopyOnWriteArrayList demo with concurrent modification

What
- Introduced Demo class showcasing `CopyOnWriteArrayList` usage.
- Demonstrates safe iteration and modification of a list while traversing.
- Compared to `ArrayList`, which throws `ConcurrentModificationException` on modification during iteration.
- Adds shoppingList example where "Butter" is added while reading items.

Why
- Highlights difference between normal `ArrayList` and thread-safe `CopyOnWriteArrayList`.
- Teaches the copy-on-write mechanism: snapshot for readers, fresh copy for each write.
- Useful for scenarios where reads dominate writes and thread safety is required.

How
- Declared `CopyOnWriteArrayList<Integer>` (unused placeholder for demonstration).
- Declared `shoppingList` as a `CopyOnWriteArrayList<String>`.
- Added initial elements ("Milk", "Eggs", "Bread").
- Iterated with for-each, and while reading "Eggs", added "Butter".
- Printed list before and after to show Butter successfully added during iteration.

Logic
- Inputs: hardcoded items Milk, Eggs, Bread.
- Outputs: console print of items during iteration, message "Adding Butter...", and final updated list with Butter included.
- Flow:
  1. Add 3 items to shoppingList.
  2. Print initial list.
  3. Iterate and print each item.
     - If item == "Eggs", add "Butter" to the list.
  4. Print updated list at end.
- Edge cases:
  - With `ArrayList`, adding inside loop would throw `ConcurrentModificationException`.
  - With `CopyOnWriteArrayList`, no exception: iteration uses snapshot, modifications visible only in subsequent iterations or prints.

Complexity
- Read (iteration, get) is O(1) per operation.
- Write (add/remove/set) is O(n) because a new copy of the array is created.
- Iteration is safe but iterators do not reflect modifications made after iterator creation.

Applications
- Ideal for read-heavy, write-light use cases:
  - Event listener lists.
  - Caches with infrequent updates.
  - Configurations that are read often but updated rarely.
- Thread-safe alternative to `ArrayList` without explicit synchronization.

Notes
- CopyOnWriteArrayList consumes more memory on writes due to creating new copies.
- For write-heavy workloads, it is inefficient — prefer `ConcurrentLinkedQueue` or other concurrent collections.

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

Author: Someshdiwan

Section 25 Collections Frameworks/List Interface/Copy On Write ArrayList/src/Demo.java

@@ -0,0 +1,56 @@
+import java.util.List;
+import java.util.concurrent.CopyOnWriteArrayList;
+
+public class Demo {
+    public static void main(String[] args) {
+        CopyOnWriteArrayList<Integer> list = new CopyOnWriteArrayList<>();
+
+        // List<String> shoppingList = new ArrayList<>();
+        // Uncomment and see error then comment and run.
+
+        List<String> shoppingList = new CopyOnWriteArrayList<>();
+        shoppingList.add("Milk");
+        shoppingList.add("Eggs");
+        shoppingList.add("Bread");
+
+        /*
+         System.out.println("Initial Shopping List: "+shoppingList);
+         for(String item : shoppingList) {
+             System.out.println(item);
+         }
+        */
+
+        // Read and write both at a time while reading.
+        System.out.println("Initial Shopping List: "+ shoppingList);
+
+        for(String item : shoppingList) {
+            System.out.println(item);
+
+            if(item.equals("Eggs")) {
+                shoppingList.add("Butter");
+                System.out.println("Adding Butter while reading.");
+            }
+        }
+        System.out.println("Updated shopping list: "+ shoppingList);
+    }
+}
+
+/*
+Single threaded operation and snapshot create karta hai...photocopy of an item or object.
+
+Copy On Write means That whenever a write operation like adding or removing an element,
+instead of directly modifying the existing list, a new copy of the list is created,
+and the modification is applied to that copy
+
+This ensures that other threads reading the last while it's being modified are being unaffected.
+
+Read Operations: Fast and direct, since they happen-on a static list without interference from modification.
+
+write operations: A new copy of the list is created for every modification.
+
+The reference to the list is then updated so that subsequent(later) reads use this new list.
+
+Notepad --> Notepad copy
+
+Applications Read intensive operations ho.More memory consumption things here.
+*/