feat(HashMap): add demo showing hash collisions with a simple custom hash function

What
- Added `CollisionInHashMapDemo` class with a `main` method.
- Implemented `simpleHash(String key)` function that:
  - Sums ASCII values of characters.
  - Returns sum modulo 10 to simulate bucket index in a hash table.
- Demonstrated how two different strings (`"ABC"` and `"CBA"`) can produce the same hash → collision.

Why
- To illustrate the **concept of collisions** in hashing.
- Real-world hash-based structures (HashMap, HashSet) must handle collisions because different keys can map to the same bucket index.
- Helps understand why Java’s `HashMap` uses both `hashCode()` and `equals()` for proper key management.

How
1. `"ABC"`:
   - A = 65, B = 66, C = 67
   - Sum = 198 → 198 % 10 = 8
2. `"CBA"`:
   - C = 67, B = 66, A = 65
   - Sum = 198 → 198 % 10 = 8
3. Both yield hash `8` → **collision** occurs (different keys, same bucket index).
4. Program prints these results to show how collisions arise.

Logic Recap
- Hash function reduces a large key space into a small set of bucket indexes.
- Collisions are inevitable because many keys map into fewer buckets.
- Good hashing strategies minimize collisions, but data structures must also resolve them (via chaining or open addressing).

Real-Life Application
- Explains why a robust `hashCode()` implementation is critical for user-defined objects used in HashMap.
- Demonstrates how two different strings can end up in the same bucket.
- Prepares foundation for understanding HashMap internals (buckets, linked lists, tree bins).

Notes
- This demo deliberately uses a weak hash function (`sum % 10`) to force collisions.
- In practice, Java’s `hashCode()` + HashMap’s spreading function reduce collisions but cannot eliminate them.
- Collision handling ensures map integrity (values not lost, proper key lookup).

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

Author: Someshdiwan

Section 25 Collections Frameworks/Map Interface/HashMap/src/CollisionInHashMapDemo.java

@@ -0,0 +1,42 @@
+public class CollisionInHashMapDemo {
+    public static void main(String[] args) {
+        System.out.println(simpleHash("ABC"));
+        System.out.println(simpleHash("CBA"));
+    }
+
+    public static int simpleHash(String key) {
+        int sum = 0;
+        for( char c : key.toCharArray()) {
+            sum += (int) c;
+        }
+        return sum % 10;
+    }
+}
+
+/*
+1. Purpose of Code:
+   - Yeh code ek simple **hash function** dikhata hai jo ek String ko ek chhote number me convert karta hai.
+   - Iska use mainly HashMap jaise data structures me hota hai jaha keys ko bucket index me map karna padta hai.
+
+2. Function simpleHash(String key):
+   - Ek String ko character array me convert karta hai.
+   - Har character ka ASCII value nikal ke `sum` me add karta hai.
+   - Finally `sum % 10` return karta hai → matlab remainder 10 se divide karne ke baad.
+
+   Example:
+   - `"ABC"` → A=65, B=66, C=67
+     sum = 198 → 198 % 10 = 8
+
+   - `"CBA"` → C=67, B=66, A=65
+     sum = 198 → 198 % 10 = 8
+
+3. Collision Concept:
+   - Dono Strings `"ABC"` aur `"CBA"` alag hain but hash value same (8) aayi.
+   - Is situation ko **Collision** bolte hain (different keys → same hash bucket).
+   - Real HashMap me bhi aisa ho sakta hai, isliye collision handling zaroori hai (chaining, open addressing, etc.).
+
+4. Quick Recap:
+   ✔ Hash function banaya jo string ko int me convert karta hai.
+   ✔ ASCII values add karke `% 10` se bucket index milta hai.
+   ✔ Example me `"ABC"` aur `"CBA"` dono ka result same aaya → Collision example.
+*/