Internal Working of LinkedHashMap in Java

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

Author: Someshdiwan

Section 25 Collections Frameworks/Map Interface/Linked HashMap/src/Internal Working of LinkedHashMap in Java/HashMap and LinkedHashMap.txt

@@ -0,0 +1,74 @@
+HashMap and LinkedHashMap so you clearly see why one preserves order and the other doesn’t.
+
+⸻
+
+🔹 HashMap (No Order Guarantee)
+
+Keys inserted: "Shubham", "Bob", "Akshit"
+
+Internal Structure (buckets):
+
+Bucket[0] : null
+Bucket[1] : ("Bob" -> 80)
+Bucket[2] : ("Akshit" -> 78)
+Bucket[3] : ("Shubham" -> 92)
+Bucket[4] : null
+...
+Bucket[15]: null
+
+Iteration → Goes bucket by bucket:
+Output may look like: {Akshit=78, Shubham=92, Bob=80}
+
+❌ Order is NOT insertion-based
+❌ Order is NOT access-based
+
+•	Why unordered? Because keys are placed in buckets based on hashCode % capacity.
+•	Iteration just walks bucket array → so order looks random.
+
+⸻
+
+🔹 LinkedHashMap (accessOrder = false → Insertion Order)
+
+Keys inserted: "Orange", "Apple", "Guava"
+
+Doubly Linked List (insertion order maintained):
+
+HEAD <-> Orange(10) <-> Apple(20) <-> Guava(13) <-> TAIL
+
+Iteration output:
+Orange=10
+Apple=20
+Guava=13
+
+	•	Preserves insertion order by default.
+
+⸻
+
+🔹 LinkedHashMap (accessOrder = true → Access Order)
+
+Keys inserted: "Orange", "Apple", "Guava"
+Access pattern: get("Apple"), get("Orange"), get("Guava")
+
+Doubly Linked List (reordered on access):
+
+HEAD <-> Apple(20) <-> Orange(10) <-> Guava(13) <-> TAIL
+
+Iteration output:
+Apple=20
+Orange=10
+Guava=13
+
+	•	Every time an entry is accessed, it is moved to the end.
+	•	Newest (most recently accessed) items go at the tail.
+	•	Oldest (least accessed) stay near the head.
+
+This mechanism is exactly how LRU Cache is built using LinkedHashMap.
+
+⸻
+
+⚡ Quick Recap:
+	•	HashMap → Bucket-based, order = unpredictable.
+	•	LinkedHashMap (Insertion Order) → Order of insertion is preserved.
+	•	LinkedHashMap (Access Order) → Reorders entries based on access (like LRU).
+
+⸻

Section 25 Collections Frameworks/Map Interface/Linked HashMap/src/Internal Working of LinkedHashMap in Java/Internal Working Hindi.txt

@@ -0,0 +1,115 @@
+Internal Working of LinkedHashMap in Java
+
+Introduction:
+
+- `LinkedHashMap` Java Collections Framework ka ek class hai jo `HashMap` ko extend karta hai.
+- Yeh **key-value pairs store karta hai** bilkul HashMap ki tarah,
+lekin saath hi ek **doubly-linked list** maintain karta hai jo order preserve karti hai.
+- Isliye isme fast access ke saath insertion order ya access order maintain karna possible hai.
+
+---
+
+1. Underlying Data Structure:
+- Internally, `LinkedHashMap` uses:
+  1. **Hash Table** → Fast access ke liye (O(1) average for put/get).
+  2. **Doubly Linked List** → Order preserve karne ke liye.
+
+- Har ek entry ek special class hoti hai:
+
+  static class Entry<K,V> extends HashMap.Node<K,V> {
+      Entry<K,V> before, after;
+  }
+  - `before` and `after` pointers ek **linked list chain** banate hain.
+
+---
+
+2. Order Preservation:
+
+- `LinkedHashMap` do tarah ka order maintain kar sakta hai:
+  1. **Insertion Order (default)**: Jo key pehle daali gayi, woh pehle traverse hogi.
+  2. **Access Order (optional)**: Agar constructor me `accessOrder = true` pass karo,
+  toh har get/put operation ke baad woh entry list ke end me shift ho jaati hai.
+
+Example:
+
+LinkedHashMap<Integer, String> map = new LinkedHashMap<>(16, 0.75f, true);
+
+Yahan `true` matlab access order maintain karna.
+
+---
+
+3. Internal Working Steps:
+
+### put(K,V)
+1. Key ka `hashCode()` calculate hota hai → bucket index milta hai.
+2. Agar key pehle se exist karta hai → value overwrite hoti hai.
+3. Agar new key hai → ek naya `Entry` banega.
+   - Entry hash table me insert hota hai (HashMap jaisa).
+   - Saath hi entry doubly linked list me bhi add hota hai (order preserve karne ke liye).
+
+---
+
+### get(K)
+1. Key ka `hashCode()` calculate karke bucket search hoti hai.
+2. Agar entry milti hai aur map access-order mode me hai:
+   - Entry ko linked list ke end me shift kar diya jata hai.
+3. Value return hoti hai.
+
+---
+
+4. Complexity
+-------------
+- `put()`, `get()`, `remove()` → O(1) average time (HashMap ki tarah).
+- Order maintain karne ki wajah se thoda extra overhead lagta hai.
+
+---
+
+5. ASCII Diagram:
+
+Insertion Order Example:
+
+```
+Hash Table (buckets):
+  [ ] [ ] [ (1,A) ] [ (2,B) ] [ (3,C) ] ...
+
+Linked List (order chain):
+  Head → (1,A) <-> (2,B) <-> (3,C) ← Tail
+```
+
+Access Order Example (agar accessOrder = true):
+
+- Suppose get(1) call kiya:
+```
+Before: Head → (1,A) <-> (2,B) <-> (3,C)
+After:  Head → (2,B) <-> (3,C) <-> (1,A)
+```
+
+---
+
+6. Advantages
+-------------
+- Predictable iteration order (HashMap ka yeh drawback fix karta hai).
+- Useful for building **LRU Cache** (Least Recently Used cache).
+
+---
+
+7. Disadvantages
+----------------
+- Thoda zyada memory use karta hai (doubly linked list pointers ke wajah se).
+- Thoda performance overhead hota hai as compared to plain HashMap.
+
+---
+
+8. Common Use Cases
+-------------------
+- LRU Cache implementation.
+- Jab order of insertion ya access preserve karna zaroori ho.
+- Predictable iteration chahiye fast lookup ke saath.
+
+---
+
+Summary:
+- `LinkedHashMap = HashMap + LinkedList`
+- Provides O(1) put/get/remove operations.
+- Maintains order (insertion or access).
+- Ideal for caches, predictable iteration, aur jab HashMap ka unordered behavior avoid karna ho.

Section 25 Collections Frameworks/Map Interface/Linked HashMap/src/Internal Working of LinkedHashMap in Java/Internal Working of LinkedHashMap (with accessOrder & eviction).txt

@@ -0,0 +1,124 @@
+📌 Internal Working of LinkedHashMap (with accessOrder & eviction)
+=================================================================
+
+1. Core Formula Recap
+---------------------
+
+- **Threshold** = `capacity × loadFactor`
+- **Rehash Trigger**: when `size > threshold`
+- **Access Order**:
+  - If `accessOrder = false` → Order = Insertion order
+  - If `accessOrder = true` → Order = Access order (recently accessed node is moved to the end)
+- **Eviction Rule (via removeEldestEntry)**:
+  - Called **after each put()**.
+  - If `true`, eldest entry (head of linked list) is removed.
+
+---
+
+2. ASCII Flow: Insertion Order (Default)
+----------------------------------------
+(accessOrder = false)
+
+```
+Put(1,A) → 1:A
+Put(2,B) → 1:A → 2:B
+Put(3,C) → 1:A → 2:B → 3:C
+```
+Iteration → `[1:A, 2:B, 3:C]`
+
+---
+
+3. ASCII Flow: Access Order (accessOrder = true)
+------------------------------------------------
+
+```
+Initial:  1:A → 2:B → 3:C
+
+Access(1) → Move 1:A to end
+Result:   2:B → 3:C → 1:A
+
+Access(2) → Move 2:B to end
+Result:   3:C → 1:A → 2:B
+```
+
+Iteration → in order of **most recent access**.
+
+---
+
+4. ASCII Flow: With Eviction (removeEldestEntry)
+------------------------------------------------
+
+Suppose max size = 3 (`removeEldestEntry()` removes if size > 3)
+
+```
+Insert(1:A) → 1:A
+Insert(2:B) → 1:A → 2:B
+Insert(3:C) → 1:A → 2:B → 3:C
+Insert(4:D) → capacity exceeded → remove eldest (1:A)
+Result:      2:B → 3:C → 4:D
+```
+
+If accessOrder = true:
+```
+Initial:  2:B → 3:C → 4:D
+Access(2) → Move 2:B to end
+Result:   3:C → 4:D → 2:B
+Insert(5:E) → remove eldest (3:C)
+Result:   4:D → 2:B → 5:E
+```
+
+---
+
+5. Internal Structure
+---------------------
+
+LinkedHashMap = HashMap + Doubly Linked List.
+
+```
+Buckets (Hash Table):
+   0    1    2    ...
+  [ ]  [ ]  [ ]  ...
+
+Linked List (Order Maintenance):
+Head ↔ Node1 ↔ Node2 ↔ Node3 ↔ Tail
+```
+
+- Each entry stores:
+  - `key`
+  - `value`
+  - `hash`
+  - `next` (for bucket chain)
+  - `before` and `after` (for doubly linked list)
+
+---
+
+6. Practical Formula Examples
+------------------------------
+
+- **Threshold** = `capacity × loadFactor`
+  - Example: capacity = 16, loadFactor = 0.75 → threshold = 12
+  → Rehash after 13th element.
+
+- **Access Order Movement**:
+  - On every `get(key)` or `put(key,value)` (when key exists):
+    - Node is removed from its current linked list position.
+    - Node is reinserted at **tail** of linked list.
+
+- **Eviction**:
+  - After every `put()`, `removeEldestEntry()` runs:
+    ```java
+    protected boolean removeEldestEntry(Map.Entry<K,V> eldest) {
+        return size() > MAX_ALLOWED;
+    }
+    ```
+
+---
+
+🔑 Quick Recap
+--------------
+- **Insertion Order** (default): Iterates in the order elements were put.
+- **Access Order** (`true`): Recently accessed elements move to tail → Useful for **LRU caching**.
+- **removeEldestEntry()**: Automatic eviction rule (e.g., max cache size).
+- **Threshold** controls rehashing.
+
+👉 `LinkedHashMap` = predictable iteration + ability to implement efficient caches.