feat(LinkedHashMapAccessOrderDemo): showcase LinkedHashMap with access-order enabled

What
- Added LinkedHashMapAccessOrderDemo class.
- Created a LinkedHashMap with parameters (initialCapacity=11, loadFactor=0.3f, accessOrder=true).
- Inserted three entries: Orange, Apple, Guava.
- Accessed entries with get() calls to trigger reordering.
- Iterated and printed entries to demonstrate access-order iteration.

Why
- To explain how LinkedHashMap can operate in two modes:
  - Insertion order (default).
  - Access order (when accessOrder=true).
- Demonstrates how entries are moved to the end on access, forming the foundation for LRU (Least Recently Used) cache implementations.

How
- Constructed LinkedHashMap with accessOrder flag set to true.
- Called get() on "Apple", "Orange", and "Guava".
- Iterated over entrySet() and printed results.
- Added commentary showing how repeated access patterns shift entries.

Logic
- Inputs: key-value pairs of fruits and integers.
- Processing:
  - On each get(key), LinkedHashMap internally re-links the accessed node to the tail of its doubly-linked list.
  - Iteration order now reflects most-recently accessed items last.
- Outputs:
  - Final printed order corresponds to access order, not insertion order.

Real-life applications
- LinkedHashMap with accessOrder=true is widely used to build LRU caches.
  - Least-recently accessed entries remain at the front of the list.
  - Newest or most-recently accessed entries are moved to the end.
- HashMap → no guaranteed order.
- LinkedHashMap → guarantees either insertion or access order, making it more predictable in ordered-use cases.

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

Author: Someshdiwan

Section 25 Collections Frameworks/Map Interface/Linked HashMap/src/LinkedHashMapAccessOrderDemo.java

@@ -0,0 +1,59 @@
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+public class LinkedHashMapAccessOrderDemo {
+    public static void main(String[] args) {
+        // LinkedHashMap with access-order enabled (true).
+        // Constructor params → (initialCapacity=11, loadFactor=0.3f, accessOrder=true)
+        // accessOrder = true → Entries are reordered whenever accessed (get/put).
+        // threshold = capacity × loadFactor
+        LinkedHashMap<String, Integer> linkedHashMap = new LinkedHashMap<>(11, 0.3f, true);
+
+        // Insertion of entries
+        linkedHashMap.put("Orange", 10);
+        linkedHashMap.put("Apple", 20);
+        linkedHashMap.put("Guava", 13);
+
+        // Multiple get() calls reorder the entries in access order.
+        // The most recently accessed entry always moves to the END.
+        linkedHashMap.get("Apple");
+        linkedHashMap.get("Orange");
+        linkedHashMap.get("Guava");
+        /*
+        linkedHashMap.get("Apple");
+        linkedHashMap.get("Orange");
+        linkedHashMap.get("Apple");
+        linkedHashMap.get("Guava");
+        */
+
+        // Iteration now respects *access order*.
+        // That means the order you see here is not insertion order,
+        // but the order in which elements were last accessed.
+        System.out.println("LinkedHashMap (access order):");
+
+        for (Map.Entry<String, Integer> entry : linkedHashMap.entrySet()) {
+            System.out.println(entry.getKey() + ": " + entry.getValue());
+        }
+    }
+}
+
+/* LinkedHashMap = HashMap + Doubly Linked List + Configurable access order.
+•	LinkedHashMap does guarantee ordering:
+•	If accessOrder=false → preserves insertion order.
+•	If accessOrder=true → preserves access order (most recently accessed entries go to the end).
+
+Theory: LinkedHashMap with accessOrder = true
+
+1. Insertion order is NOT preserved here. Instead, entries are reordered based on *access*.
+2. Each time you do get(key) or put(key, value):
+   → That entry moves to the END of the doubly-linked list.
+3. This is how LinkedHashMap can be used to implement LRU Cache:
+   - The least recently used entries stay at the beginning.
+   - The most recently accessed entries move to the end.
+
+•	HashMap → No ordering (entries are placed in buckets based on hash).
+
+•	LinkedHashMap → Ordering is guaranteed:
+•	accessOrder=false → insertion order.
+•	accessOrder=true → access order.
+*/