feat(HashCodeAndEqualsMethod): demonstrate importance of overriding equals() and hashCode() in HashMap keys

What
- Added `HashCodeAndEqualsMethod` class with a `main` method.
- Introduced a custom `Person` class that overrides `equals()` and `hashCode()`.
- Demonstrates how `HashMap` uses these methods for key comparison and replacement.
- Also included an example with `Map<String, Integer>` to show default behavior.

Why
- To explain how Java collections like `HashMap` rely on both `hashCode()` and `equals()` to store and retrieve values.
- Shows that without proper overrides, logically equal objects may still be treated as different keys.
- Reinforces the contract: if two objects are equal (`equals()` returns true), their `hashCode()` must be the same.

How
1. Created three `Person` objects:
   - `p1("Alice", 1)`
   - `p2("Bob", 2)`
   - `p3("Alice", 1)` (same values as p1).
2. Inserted all three into a `HashMap<Person, String>`.
   - `p1 → "Engineer"`
   - `p2 → "Designer"`
   - `p3 → "Manager"`
3. Because `p1.equals(p3)` is true and both have same hashCode, `p3` replaces the value of `p1` inside the map.
4. Verified by printing: map size is `2` and `p1`/`p3` return `"Manager"`.
5. Added a `Map<String, Integer>` demo:
   - `"Shubham"` added twice → second value replaces first.
   - `"Neha"` added once.

Logic
- Step 1: Insert keys into map.
- Step 2: HashMap computes index using `hashCode()`.
- Step 3: If multiple keys fall in same bucket, it checks `equals()`.
- Step 4: If equal → replaces value; if not → inserts new entry.
- Step 5: Demonstrate with custom objects (`Person`) and built-in type (`String`).

Real-life Applications
- Correct behavior in caching, sets, and maps where uniqueness of keys is required.
- Critical when using objects as keys in `HashMap`, `HashSet`, `Hashtable`.
- Avoids subtle bugs where duplicates may incorrectly appear due to missing overrides.

Notes
- Always override `equals()` and `hashCode()` together.
- Use `Objects.hash()` for concise hashCode implementations.
- Use `Objects.equals()` for safe null-aware comparisons in `equals()`.
- Inconsistent implementation can break contract: two equal objects must always have the same hash code.

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

Author: Someshdiwan

Section 25 Collections Frameworks/Map Interface/HashMap/src/HashCodeAndEqualsMethod/Code Recap.txt

@@ -0,0 +1,121 @@
+Code Recap:
+
+HashMap<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");
+
+👉 Yahaan hum ek `HashMap` bana rahe hain jisme **key = Person object** aur **value = Job title (String)**.
+- `p1` = Alice, id=1
+- `p2` = Bob, id=2
+- `p3` = Alice, id=1 (same data as p1, lekin alag object)
+
+---
+
+Step-by-Step Internal Working:
+
+1. **map.put(p1, "Engineer");**
+   - `p1.hashCode()` calculate hua.
+   - Maan lo bucket index = 5 aaya.
+   - `p1` key bucket[5] me insert ho gaya → value "Engineer".
+
+   ```
+   Bucket[5] → (p1 -> Engineer)
+   ```
+---
+
+2. **map.put(p2, "Designer");**
+   - `p2.hashCode()` nikala, maan lo index = 9 aaya.
+   - Key `p2` bucket[9] me store ho gaya → value "Designer".
+
+   ```
+   Bucket[5] → (p1 -> Engineer)
+   Bucket[9] → (p2 -> Designer)
+   ```
+
+---
+
+3. **map.put(p3, "Manager");**
+   - `p3.hashCode()` nikala.
+   - Kyunki `p3` bhi `"Alice", 1` hai, iska hashCode same as `p1`.
+   - Matlab bucket index = 5 aaya (same as p1).
+   - Ab bucket[5] ke andar `equals()` check hoga:
+     - `p1.equals(p3)` → true (kyunki name aur id dono same).
+   - Isliye HashMap ne purani value `"Engineer"` replace karke nayi value `"Manager"` daal di.
+
+   ```
+   Bucket[5] → (p3 -> Manager)   // replace
+   Bucket[9] → (p2 -> Designer)
+   ```
+---
+
+Output Behavior
+
+System.out.println("HashMap Size: " + map.size());
+// Output: 2   (p1 aur p3 same key consider hue)
+
+System.out.println("Value for p1: " + map.get(p1));
+// Output: Manager (Engineer replace ho gaya)
+
+System.out.println("Value for p3: " + map.get(p3));
+// Output: Manager
+
+---
+
+Dusra Example: Strings as Keys
+
+map1.put("Shubham", 90);   // new entry
+map1.put("Neha", 92);      // new entry
+map1.put("Shubham", 99);   // same key → replace 90 with 99
+```
+
+Resulting Map:
+```
+"Shubham" → 99
+"Neha"    → 92
+```
+
+---
+
+ASCII Flow Diagram:
+
+Insert p1("Alice",1) → hash=5 → bucket[5] → store (Engineer)
+
+Insert p2("Bob",2)   → hash=9 → bucket[9] → store (Designer)
+
+Insert p3("Alice",1) → hash=5 → bucket[5]
+                        |
+                        |--> check equals(p1,p3) = true
+                        |--> replace old value "Engineer"
+                        v
+                    bucket[5] → (p3 -> Manager)
+```
+
+
+Key Takeaways:
+
+1. **HashMap key lookup = hashCode() + equals():**
+   - Pehle `hashCode()` se bucket milta hai.
+   - Fir bucket ke andar `equals()` check hota hai.
+
+2. **Duplicate Keys → Replace Value**
+   - Agar `hashCode()` same hai aur `equals()` true hai → key same maana jaata hai aur value replace hoti hai.
+
+3. **Why override hashCode() and equals()?**
+   - Custom objects (Person) ko key banane ke liye correct equality define karna zaroori hai.
+   - Nahi toh HashMap unhe alag objects treat karega, chahe data same ho.
+
+4. **Strings Example**
+   - `"Shubham"` key dobara daalne pe value overwrite ho jaati hai (90 → 99).
+
+1.	HashMap key comparison do steps me hota hai:
+•	Pehle hashCode() check karke bucket find karo.
+•	Fir bucket ke andar equals() se compare karo.
+
+2.	Agar hashCode() aur equals() dono match ho gaye → key same hai → value replace ho jaati hai.
+3.	Agar hashCode() same hai but equals() false hai → collision handle hota hai (LinkedList/TreeNode ban ke).
+4.	Isliye custom objects (Person) ko HashMap key banate time hashCode() aur equals() override karna zaroori hai.

Section25CollectionFramework/src/CustomHashMapDemo/HashCodeAndEqualsMethod.java renamed to Section 25 Collections Frameworks/Map Interface/HashMap/src/HashCodeAndEqualsMethod/HashCodeAndEqualsMethod.java

@@ -1,4 +1,4 @@
-package CustomHashMapDemo;
+package HashCodeAndEqualsMethod;
 
 import java.util.HashMap;
 import java.util.Map;
@@ -25,20 +25,12 @@ public static void main(String[] args) {
 
 
         Map<String, Integer> map1 = new HashMap<>();
-        map1.put("Shubham", 90); // hashcode1 --> index1
-        map1.put("Neha", 92); // hashcode2 --> index2
-        map1.put("Shubham", 99); // hashcode1 --> index1 --> equals() --> replace
-
+        map1.put("Shubham", 90);       // hashcode1 --> index1
+        map1.put("Neha", 92);         // hashcode2 --> index2
+        map1.put("Shubham", 99);     // hashcode1 --> index1 --> equals() --> replace
     }
 }
 
-/*
-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.
-*/
-
 class Person {
     private String name;
     private int id;
@@ -80,4 +72,4 @@ public boolean equals(Object obj) {
     public String toString() {
         return "id: " + id + ", name: " + name;
     }
-}
+}