How Data Is Stored Internally In HashMap

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

Author: Someshdiwan

Section 25 Collections Frameworks/Map Interface/HashMap/src/Hash Map Working/How Data Is Stored Internally In HashMap/ HashCode → bucketIndex mapping in HashMap.txt

@@ -0,0 +1,65 @@
+hashCode → bucketIndex mapping in HashMap:
+
+⸻
+
+1. Formula Recap
+
+HashMap internally hashCode ko le kar bucket index nikalta hai:
+
+bucketIndex = (hashCode(key)) & (n - 1)
+
+•	n = array ka size (capacity), always power of 2 (like 16, 32, …).
+•	& (n-1) fast modulus operation hai (better than %).
+
+⸻
+
+2. Example Keys
+•	Key1 = "ABC" → hashCode = 64578
+•	Key2 = "CBA" → hashCode = 64018
+
+Assume HashMap ki capacity = 16 (default).
+
+⸻
+
+3. Calculate Bucket Index
+
+bucketIndex("ABC") = 64578 & (16 - 1)
+                   = 64578 & 15
+                   = 2
+
+bucketIndex("CBA") = 64018 & (16 - 1)
+                   = 64018 & 15
+                   = 2
+
+Dono ka bucket index 2 nikla → Collision!
+
+⸻
+
+4. ASCII Diagram: Buckets in HashMap
+
+HashMap Buckets (capacity = 16)
+
+Index:   0   1   2         3   4 ... 15
+         ─────────────────────────────────
+Bucket: [ ] [ ] [ "ABC" ] [ ] [ ]     [ ]
+
+After inserting "CBA":
+
+Index:   0   1   2                 3   4 ... 15
+         ──────────────────────────────────────
+Bucket: [ ] [ ] [ "ABC" -> "CBA" ] [ ] [ ]     [ ]
+
+⸻
+
+5. How Collision is Handled?
+•	Java 7 and earlier → LinkedList chaining (all collided entries chained at same bucket).
+•	Java 8+ → If too many collisions (≥ 8 entries in one bucket),
+LinkedList is converted into a Balanced Tree (Red-Black Tree) for faster lookup (O(log n)).
+
+⸻
+
+HashMap me hashCode → bucketIndex mapping karke decide hota hai key kis bucket me jayega.
+
+Agar same bucketIndex nikla → collision → LinkedList ya Tree structure use hota hai.
+
+⸻

Section25CollectionFramework/src/HashMapDemo/HashMap/How Data is stored internally in HashMap/Handle Collisions.png renamed to Section 25 Collections Frameworks/Map Interface/HashMap/src/Hash Map Working/How Data Is Stored Internally In HashMap/Handle Collisions.png

@@ -0,0 +1,140 @@
+How HashMap Uses hashCode() and equals()
+
+A HashMap in Java stores key-value pairs.
+
+When inserting an object as a key, HashMap:
+- Computes its hashCode() to determine the bucket index.
+- Uses equals() to check if two objects are identical.
+
+---
+
+What Are We Doing Here?
+
+We are demonstrating how HashMap works internally when we use custom objects (Person) as keys.
+
+Specifically, we are implementing the hashCode() and equals() methods to ensure proper behavior when storing and
+retrieving values from a HashMap.
+
+---
+
+Key Concepts Demonstrated in the Code
+-------------------------------------
+
+1. Using HashMap with a Custom Class (Person) as Key
+   - `HashMap<Person, String> map = new HashMap<>();`
+   - We store a person's profession (e.g., "Engineer") using Person objects as keys.
+
+2. How hashCode() and equals() Work in HashMap
+   - `hashCode()` ensures that objects with the same name and id have the same hash code.
+   - `equals()` ensures that if two Person objects have the same name and id, they are treated as the same key.
+
+3. How Entries are Stored in HashMap
+   - `map.put(p1, "Engineer");` → p1 (Alice, 1) is stored.
+   - `map.put(p2, "Designer");` → p2 (Bob, 2) is stored.
+   - `map.put(p3, "Manager");` → p3 (Alice, 1) has the same hash code as p1, so it replaces p1's value.
+
+4. Checking HashMap Behavior
+
+System.out.println(“HashMap Size: “ + map.size()); // Output: 2
+System.out.println(“Value for p1: “ + map.get(p1)); // Output: Manager
+System.out.println(“Value for p3: “ + map.get(p3)); // Output: Manager
+
+- Even though we inserted three objects, the size is 2 because p3 replaced p1.
+
+5. Comparing with a HashMap<String, Integer>
+
+Map<String, Integer> map1 = new HashMap<>();
+map1.put(“Shubham”, 90);
+map1.put(“Neha”, 92);
+map1.put(“Shubham”, 99);
+
+// Shubham is added twice, but its value (90) is replaced with (99).
+
+- HashMap maintains unique keys, and if a duplicate key is added, it replaces the existing value.
+
+---
+
+Internal Working of HashMap
+---------------------------
+
+Step 1: Calculate hashCode()
+
+@Override
+public int hashCode() {
+return Objects.hash(name, id);
+}
+
+- Generates a hash code based on `name` and `id`.
+
+Step 2: Determine Bucket Index
+- The hash code is used to determine the bucket.
+- If two objects have the same hash code, they go into the same bucket.
+
+Step 3: Handle Collisions Using equals()
+
+@Override
+public boolean equals(Object obj) {
+if (this == obj) return true;
+if (obj == null || getClass() != obj.getClass()) return false;
+Person other = (Person) obj;
+return id == other.id && Objects.equals(name, other.name);
+}
+
+- If `equals()` returns true, the new value replaces the old value.
+
+---
+
+Code Example
+------------
+```java
+import java.util.*;
+
+class Person {
+    private String name;
+    private int id;
+
+    public Person(String name, int id) {
+        this.name = name;
+        this.id = id;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(name, id);
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj) return true;
+        if (obj == null || getClass() != obj.getClass()) return false;
+        Person other = (Person) obj;
+        return id == other.id && Objects.equals(name, other.name);
+    }
+}
+
+public class HashMapDemo {
+    public static void main(String[] args) {
+        Map<Person, String> map = new HashMap<>();
+
+        Person p1 = new Person("Alice", 1);
+        Person p2 = new Person("Bob", 2);
+        Person p3 = new Person("Alice", 1);
+
+        map.put(p1, "Engineer");
+        map.put(p2, "Designer");
+        map.put(p3, "Manager");
+
+        System.out.println("HashMap Size: " + map.size());
+        System.out.println("Value for p1: " + map.get(p1));
+        System.out.println("Value for p3: " + map.get(p3));
+    }
+}
+
+⸻
+
+Conclusion
+1.	Without hashCode() and equals(), HashMap would treat all Person objects as unique, even if they had the same name and id.
+2.	Implementing hashCode() and equals() ensures correct key comparison and prevents duplicate keys.
+3.	This behavior is similar to how HashMap<String, Integer> works, where the same string key replaces the previous value.
+
+---

Section 25 Collections Frameworks/Map Interface/HashMap/src/Hash Map Working/How Data Is Stored Internally In HashMap/HashMap Custom Key HashCode Equals Explanation..txt

@@ -0,0 +1,107 @@
+code + diagram showing, how p1 and p3 (same hash, same equals) land in the same bucket, and why one replaces the other:
+
+How HashMap Uses hashCode() and equals():
+
+A HashMap in Java stores key-value pairs.
+
+When inserting an object as a key, HashMap:
+- Computes its hashCode() to determine the bucket index.
+- Uses equals() to check if two objects are identical.
+
+---
+
+Key Concepts with Example (Person class)
+----------------------------------------
+
+1. Custom Object as Key
+   - We create a `Person` class with `name` and `id`.
+   - Implement `hashCode()` and `equals()` so HashMap can identify duplicates.
+
+2. Behavior
+   - `map.put(p1, "Engineer");` → p1 (Alice, 1) stored.
+   - `map.put(p2, "Designer");` → p2 (Bob, 2) stored.
+   - `map.put(p3, "Manager");` → p3 (Alice, 1) same hash + equals → replaces p1’s value.
+
+3. Result
+   - `map.size()` → 2 (because p3 replaced p1).
+   - `map.get(p1)` and `map.get(p3)` → both return `"Manager"`.
+
+---
+
+Code Example
+
+import java.util.*;
+
+class Person {
+    private String name;
+    private int id;
+
+    public Person(String name, int id) {
+        this.name = name;
+        this.id = id;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(name, id); // Hash based on name + id
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj) return true;
+        if (obj == null || getClass() != obj.getClass()) return false;
+        Person other = (Person) obj;
+        return id == other.id && Objects.equals(name, other.name);
+    }
+}
+
+public class HashMapDemo {
+    public static void main(String[] args) {
+        Map<Person, String> map = new HashMap<>();
+
+        Person p1 = new Person("Alice", 1);
+        Person p2 = new Person("Bob", 2);
+        Person p3 = new Person("Alice", 1); // Same as p1 logically
+
+        map.put(p1, "Engineer");
+        map.put(p2, "Designer");
+        map.put(p3, "Manager"); // Replaces value of p1
+
+        System.out.println("HashMap Size: " + map.size());
+        System.out.println("Value for p1: " + map.get(p1));
+        System.out.println("Value for p3: " + map.get(p3));
+    }
+}
+
+⸻
+
+ASCII Diagram — How Keys Are Stored
+
+Assume capacity = 4 buckets for simplicity.
+
+Buckets: index 0     1         2        3
+         |      |          |        |
+         v      v          v        v
+        [ ]   [p2]      [p1]     [ ]
+
+Step 1: p1 ("Alice",1) hashes → bucket[2]
+        bucket[2] -> (Alice,1,"Engineer")
+
+Step 2: p2 ("Bob",2) hashes → bucket[1]
+        bucket[1] -> (Bob,2,"Designer")
+
+Step 3: p3 ("Alice",1) hashes → bucket[2]
+        - Same hash as p1
+        - equals() → true
+        - REPLACE old value
+
+Final State:
+bucket[1] -> (Bob,2,"Designer")
+bucket[2] -> (Alice,1,"Manager")
+
+⸻
+
+Conclusion
+1.	hashCode() decides the bucket (fast lookup).
+2.	equals() decides whether to overwrite or treat as a new entry.
+3.	That’s why p3 replaces p1, keeping HashMap keys unique.

Section 25 Collections Frameworks/Map Interface/HashMap/src/Hash Map Working/How Data Is Stored Internally In HashMap/HashMap CustomKey Internal Working.txt

@@ -0,0 +1,61 @@
+ASCII Diagram — How HashMap Stores Keys and Values (Buckets):
+
+This simplified ASCII shows how HashMap maps keys to buckets using hashCode → index, and how collisions are chained
+(linked list or tree after a threshold).
+
+Assume capacity = 8 (bucket array of size 8).
+Index is computed from hash(key).
+
+Buckets (index 0..7):
+
+index:   0      1      2      3      4      5      6              7
+        |      |      |      |      |      |      |              |
+        v      v      v      v      v      v      v              v
+      [ ]   [K2]   [K1]   [ ]   [K3]   [ ]   [K4] -> [K5]       [ ]
+
+Legend:
+- [Kx] denotes a node storing (key, value, hash, next)
+- "->" denotes chaining (collision list).
+- After Java 8, long chains may convert into a balanced tree (for performance).
+
+------------------------------------------------------------
+
+Example Mapping (Conceptual):
+- Key K1 hashes to index 2 → bucket[2] → (K1, V1)
+- Key K2 hashes to index 1 → bucket[1] → (K2, V2)
+- Key K3 hashes to index 4 → bucket[4] → (K3, V3)
+- Key K4 and K5 both hash to index 6 (collision):
+    bucket[6] → (K4, V4) → (K5, V5)
+  If depth > TREEIFY_THRESHOLD, this bucket may become a Red-Black Tree.
+
+------------------------------------------------------------
+
+Memory Layout (Simplified):
+- table[]  → array of Node<K,V> references (size = capacity).
+- Each Node contains: int hash; K key; V value; Node<K,V> next;
+
+------------------------------------------------------------
+
+How get(key) Works (High Level):
+1. Compute hash = spread(key.hashCode()).
+2. index = (table.length - 1) & hash   // fast modulus since length is power of 2.
+3. node = table[index]
+4. while (node != null):
+       if (node.hash == hash && node.key.equals(key)) return node.value
+       node = node.next
+5. If not found → return null.
+
+------------------------------------------------------------
+
+Rehashing (Resize) Steps (when size > threshold):
+1. Create new table with larger capacity (usually double).
+2. Recompute index for each existing node.
+3. Move nodes to new table.
+4. Update reference to new table.
+
+------------------------------------------------------------
+
+Notes:
+- Good hashCode() distribution avoids collisions.
+- Default capacity = 16, load factor = 0.75 → threshold = 16 * 0.75 = 12
+- HashMap allows one null key (stored in table[0]) and multiple null values.