feat(ListDemo5): add ListDemo5 demonstrating ArrayList ops and iterators

What
- Added ListDemo5 class demonstrating ArrayList creation, insertion, mutation, and iteration.
- Shows:
  - Creating ArrayList with initial capacity.
  - Creating ArrayList from List.of(...)
  - add(E), add(index, E), addAll(index, Collection)
  - set(index, E) to replace elements
  - Iteration using Iterator and ListIterator with hasNext()/hasPrevious()

Why
- Educational example that ties together common ArrayList mutation APIs and both iterator types.
- Teaches safe insertion at specific indices, use of addAll at an index to splice collections, and how ListIterator lets you inspect traversal state.
- Useful for learners to observe the difference between forward-only Iterator and bidirectional ListIterator.

How
- Construct al1 with capacity 20 and al2 from List.of(50,60,70,80,90).
- Perform sequence:
  - al1.add(10)
  - al1.add(0, 5)
  - al1.addAll(1, al2)
  - al1.set(5, 70)
  - al1.set(6, 100)
- Iterate using Iterator<Integer> it = al1.iterator(); printing each element.
- Obtain ListIterator<Integer> it2 = al1.listIterator(); then loop while it2.hasNext(), printing hasPrevious() and hasNext() states.

Logic
- Inputs: two lists of integers; al2 used as source for addAll.
- Outputs:
  - Printed sequence of list elements (via Iterator).
  - For each position during ListIterator forward traversal, printed iterator state: hasPrevious() and hasNext().
- Flow:
  1. Build al1, splice in al2 at index 1.
  2. Replace elements at indices 5 and 6.
  3. Iterate forward using Iterator to print elements.
  4. Iterate forward using ListIterator and print hasPrevious()/hasNext() status at each step.
- Edge cases handled / notes:
  - set(index, value) requires index < size; code assumes the previous adds produced sufficient size for indices 5 and 6.
  - Iterator is fail-fast; modifying al1 during iteration (outside Iterator methods) would throw ConcurrentModificationException.
  - ListIterator can be used for bidirectional traversal and in-place modifications via set/add/remove.

Complexity / performance
- add(E) amortized O(1).
- add(index, E) and addAll(index, Collection) O(n) worst-case due to shifting.
- set(index, E) O(1).
- Iteration O(n).

Real-life applications
- Inserting a batch of elements into an existing ordered list at a specific position.
- Inspecting traversal cursor state in interactive UIs or editors using ListIterator.
- Teaching material for collection mutation vs iteration safety.

Notes
- If you want stable prints of iterator state with values, consider printing the returned value from it2.next() alongside hasPrevious()/hasNext().
- For production code, prefer checking size before calling set(index, ...) to avoid IndexOutOfBoundsException.

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

Author: Someshdiwan

Section 25 Collections Frameworks/List Interface/ArrayList/src/ListDemo5.java

@@ -0,0 +1,26 @@
+import java.util.*;
+
+public class ListDemo5 {
+    public static void main(String[] args) {
+        ArrayList<Integer> al1 = new ArrayList<>(20);
+        ArrayList<Integer> al2 = new ArrayList<>(List.of(50, 60, 70, 80, 90));
+
+        al1.add(10);
+        al1.add(0,5);
+        al1.addAll(1, al2);
+        al1.set(5,70);
+        al1.set(6, 100);
+
+        Iterator<Integer> it=al1.iterator();
+        while(it.hasNext()) {
+            System.out.println(it.next());
+        }
+
+        ListIterator<Integer> it2 = al1.listIterator();
+
+        while(it2.hasNext()) {
+            System.out.println(it2.hasPrevious());
+            System.out.println(it2.hasNext());
+        }
+    }
+}