feat(ConcurrentHashMapDemo): add minimal example with detailed internal notes

What
- Added ConcurrentHashMapDemo class.
- Created a ConcurrentHashMap<String, Integer>.
- Inserted two key-value pairs ("World" → 2, "Hello" → 1).
- Printed map contents.

Why
- Demonstrates how to use ConcurrentHashMap with a minimal example.
- Preserves original simple logic while adding educational documentation.
- Explains internal implementation differences between Java 7 and Java 8+.

How
- map.put() safely adds entries, supporting concurrency without explicit synchronization.
- System.out.println(map) prints current contents (unordered).
- Documentation added to describe segment-based locking (Java 7) vs CAS-based design (Java 8).

Logic
- Input: none (map entries hardcoded).
- Processing: thread-safe puts into the ConcurrentHashMap.
- Output: printed contents of the map.
- Order of keys is non-deterministic because ConcurrentHashMap does not guarantee ordering.

Real-life applications
- Thread-safe caches.
- Shared counters or statistics maps.
- Concurrent access to maps without needing synchronized blocks.

Notes
- Use ConcurrentHashMap when multiple threads read/write frequently.
- Not ordered: if you need order, use ConcurrentSkipListMap instead.
- Avoid storing null keys or values (not supported in ConcurrentHashMap).

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

Author: Someshdiwan

Section 25 Collections Frameworks/Map Interface/Concurrent HashMap/src/ConcurrentHashMapDemo.java

@@ -0,0 +1,40 @@
+import java.util.concurrent.ConcurrentHashMap;
+
+/**
+ * Demonstrates the basic usage of {@link ConcurrentHashMap} with the exact
+ * logic you had originally.
+ *
+ * <p>
+ * This class contains a short example showing two puts and a println of the map.
+ * The example is intentionally minimal to keep the logic unchanged while providing
+ * detailed documentation about the internal locking/implementation evolution:
+ * </p>
+ *
+ * <ul>
+ *   <li><b>Java 7:</b> ConcurrentHashMap used segment-based locking (multiple segments,
+ *       each a small hash table). Writes locked only the affected segment.</li>
+ *   <li><b>Java 8:</b> Implementation moved to a lock-free / CAS-based design for most
+ *       operations (still needs synchronization for table resize and some collision cases).
+ *       This yields better concurrency and throughput.</li>
+ * </ul>
+ */
+
+public class ConcurrentHashMapDemo {
+    public static void main(String[] args) {
+        // Create a ConcurrentHashMap (thread-safe map implementation).
+        ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();
+
+        /*
+         * Put two entries into the map.
+         * NOTE: This logic is kept exactly as in the original snippet (no changes).
+         */
+        map.put("World", 2);
+        map.put("Hello", 1);
+
+        /*
+         * Print the current map contents to standard output.
+         * The printed order is not guaranteed; ConcurrentHashMap is not ordered.
+         */
+        System.out.println(map);
+    }
+}