feat(IdentityHashMapDemo): add example showing reference-based key comparison

What
- Added IdentityHashMapDemo class.
- Created an IdentityHashMap<String,Integer>.
- Inserted two distinct String objects with the same content `"Akshit"`.
- Printed System.identityHashCode() for both keys.
- Printed final map contents.

Why
- To demonstrate the difference between HashMap and IdentityHashMap:
  • HashMap compares keys using equals() + hashCode().
  • IdentityHashMap compares keys using reference equality (==).
- Showcases how two logically equal Strings can be treated as different keys.

How
- Constructed key1 and key2 using `new String("Akshit")` to ensure different references.
- Inserted (key1, 90) and (key2, 92) into the IdentityHashMap.
- Because key1 != key2 (reference inequality), both entries are stored.
- Printing identityHashCode confirms distinct memory references.

Logic
- Inputs:
  - key1 = new String("Akshit")
  - key2 = new String("Akshit")
- Processing:
  - IdentityHashMap.put(key1,90) → adds entry.
  - IdentityHashMap.put(key2,92) → treated as a separate entry.
- Outputs:
  - Two identityHashCodes (different values).
  - Map contents with two entries.
- Constraints:
  - IdentityHashMap does not allow null keys comparison by content; only by reference.
- Complexity:
  - O(1) average for put/get.
  - Behavior difference only in equality check.

Real-life applications
- Useful in scenarios where object identity matters more than logical equality:
  • Caching frameworks where exact object reference is required.
  • Serialization/deserialization cycles.
  • Handling proxy objects where equals() may be overridden.
- Rarely used in business logic; mostly in JVM internals or advanced libraries.

Notes
- Normal HashMap would have only one entry (second value overwrites the first).
- IdentityHashMap preserves both entries because reference equality differs.
- Demonstrates the subtle but important difference in equality semantics.

Signed-off-by: https://github.com/Someshdiwan <someshdiwan369@gmail.com>

Author: Someshdiwan

Section 25 Collections Frameworks/Map Interface/Identity HashMap/src/IdentityHashMapDemo.java

@@ -0,0 +1,51 @@
+import java.util.IdentityHashMap;
+import java.util.Map;
+
+public class IdentityHashMapDemo {
+    public static void main(String[] args) {
+        Map<String, Integer> map = new IdentityHashMap<>();
+
+        /*
+         * IdentityHashMap ek special Map implementation hai jo keys ko compare karta hai
+         * sirf reference equality (==) ke basis par.
+
+         * Matlab:
+         * - Normal HashMap me comparison hota hai equals() aur hashCode() ke basis par.
+         * - IdentityHashMap me comparison hota hai (k1 == k2).
+
+         * Example:
+         * Agar do alag String objects "Akshit" banaye (new String("Akshit")),
+         * to HashMap unko equal maan lega (kyunki equals() true hoga).
+         * Lekin IdentityHashMap unko alag treat karega (kyunki == false hoga).
+         */
+
+        // Agar chaho to neeche ka HashMap wala line use karke difference check kar sakte ho:
+        // Map<String, Integer> map = new HashMap<>();
+
+        String key1 = new String("Akshit");
+        String key2 = new String("Akshit");
+
+        map.put(key1, 90);
+        map.put(key2, 92);
+
+        // identityHashCode() ek utility hai jo object ka "memory reference based hash" deta hai.
+        // Isse pata chalta hai ki dono objects alag-alag memory me store hain.
+        System.out.println(System.identityHashCode(key1));
+        System.out.println(System.identityHashCode(key2));
+
+        /*
+         * Normal HashMap me:
+         *   - key1.equals(key2) true hota (kyunki String content same hai).
+         *   - hashCode bhi same aata → same bucket me jaata.
+         *   - Result: sirf ek entry banti, value overwrite ho jaati.
+         *
+         * IdentityHashMap me:
+         *   - key1 == key2 false hai (alag objects hai).
+         *   - Isliye dono alag keys treat hote hain.
+         *   - Result: 2 alag entries banti hain.
+         */
+
+        // System.out.println(key1.equals(key2));  // Ye true hoga (normal equals check)
+        System.out.println(map);
+    }
+}