feat: add ConcurrentSkipListMapDemo1 with string-key example

What
- Created `ConcurrentSkipListMapDemo1` class.
- Demonstrated `ConcurrentSkipListMap<String, Integer>` usage.
- Inserted fruit names as keys and integers as values.
- Printed map contents showing natural key ordering.

Why
- Extends prior demo by using `String` keys instead of `Integer`.
- Highlights that `ConcurrentSkipListMap` maintains **lexicographic order** for strings.
- Reinforces thread-safe + sorted map usage in simple scenarios.

How
- Initialized a `ConcurrentSkipListMap<String, Integer>`.
- Added entries: `Apple=2`, `Banana=4`, `Mango=3`.
- Printed output, which automatically sorts keys: `{Apple=2, Banana=4, Mango=3}`.

Logic
- Keys in `ConcurrentSkipListMap` are always kept sorted.
- For `String` keys, natural ordering is lexicographic.
- Thread-safe without needing external synchronization.

Real-world applications
- Useful for maintaining sorted dictionaries or lookup tables in concurrent environments.
- Can efficiently support prefix-based queries or range operations with string keys.

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

Author: Someshdiwan

Section 25 Collections Frameworks/Map Interface/Concurrent HashMap/Concurrent Skip List Map/src/ConcurrentSkipListMapDemo1.java

@@ -0,0 +1,40 @@
+import java.util.concurrent.ConcurrentSkipListMap;
+
+/**
+ * Demonstrates the usage of {@link ConcurrentSkipListMap}.
+
+ * <p>
+ * Key points about ConcurrentSkipListMap:
+ * <ul>
+ *   <li>A scalable concurrent implementation of {@code ConcurrentNavigableMap}.</li>
+ *   <li>MAP --> SORTED --> THREAD SAFE --> ConcurrentSkipListMap</li>
+ *   <li>Maintains keys in <b>sorted order</b> (natural ordering or a custom {@code Comparator}).</li>
+ *   <li>Internally implemented using a <b>concurrent variant of SkipLists</b>.</li>
+ *   <li>Provides expected average <b>O(log n)</b> time cost for operations like
+ *       {@code containsKey()}, {@code get()}, {@code put()}, and {@code remove()}.</li>
+ *   <li>Supports safe concurrent access — multiple threads can insert, remove,
+ *       update, or traverse without external synchronization.</li>
+ * </ul>
+ * </p>
+ */
+
+public class ConcurrentSkipListMapDemo1 {
+    public static void main(String[] args) {
+        /* Create a ConcurrentSkipListMap.
+           - Thread-safe
+           - Maintains keys in sorted order
+        */
+        ConcurrentSkipListMap<String, Integer> map = new ConcurrentSkipListMap<>();
+
+        // Insert key-value pairs into the map.
+        map.put("Apple", 2);
+        map.put("Banana", 4);
+        map.put("Mango", 3);
+
+        /* Print the map.
+        * Output will be sorted by keys (lexicographic order):
+        * {Apple=2, Banana=4, Mango=3}
+        */
+        System.out.println(map);
+    }
+}