feat(LinkedHashMapDemo): demonstrate insertion, access order, and iteration in LinkedHashMap

What
- Added LinkedHashMapDemo class.
- Constructed a LinkedHashMap with parameters `(5, 0.75F, true)`:
  - initial capacity = 5
  - load factor = 0.75
  - accessOrder = true (entries reorder on access).
- Inserted seven key-value pairs with integer keys and string values.
- Accessed keys 2, 5, and 1 using get().
- Iterated with forEach() to print the order.

Why
- To show how LinkedHashMap behaves with access-order enabled.
- Demonstrates that most recently accessed entries are moved to the end of the iteration order.
- Helps explain its relevance for caching strategies like LRU.

How
- Populated LHM with multiple entries.
- Called get(2), get(5), and get(1) to simulate access.
- Iterated with LHM.forEach((k,v) -> …) to display access-order iteration.

Logic
- Inputs:
  - Integer keys 1–7 with string messages as values.
- Processing:
  - LinkedHashMap maintains a doubly-linked list of entries.
  - With accessOrder=true, each access (get/put) moves the entry to the tail.
- Outputs:
  - Printed iteration order shows least recently accessed entries first, most recently accessed last.

Real-life applications
- LinkedHashMap with access-order is a foundation for implementing LRU caches:
  - Override `removeEldestEntry()` to automatically evict oldest entries when a size limit is exceeded.
- Useful in memory-sensitive apps, caching layers, and session management.
- Compared:
  - HashMap → no order guarantee.
  - LinkedHashMap (default) → preserves insertion order.
  - LinkedHashMap (accessOrder=true) → preserves access order.

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

Author: Someshdiwan

Section25CollectionFramework/src/HashMapDemo/LinkedHashMapDemo/LinkedHashMapED.java renamed to Section 25 Collections Frameworks/Map Interface/Linked HashMap/src/LinkedHashMapDemo1.java

@@ -1,19 +1,16 @@
-package HashMapDemo.LinkedHashMapDemo;
-
 import java.util.HashMap;
 import java.util.LinkedHashMap;
 import java.util.Map;
 
-public class LinkedHashMapED {
+public class LinkedHashMapDemo1 {
     public static void main(String[] args) {
         LinkedHashMap<String, Integer> linkedHashMap = new LinkedHashMap<>();
-        //But it maintain order.
-
+        // But it maintains order.
         linkedHashMap.put("Orange",10);
         linkedHashMap.put("Apple",20);
         linkedHashMap.put("Guava",13);
-        for(Map.Entry<String,Integer> entry : linkedHashMap.entrySet())
-        {
+
+        for(Map.Entry<String,Integer> entry : linkedHashMap.entrySet()) {
             System.out.println(entry.getKey()+": "+entry.getValue());
         }
 
@@ -23,16 +20,16 @@ public static void main(String[] args) {
         hashMap.put("Orange",10);
         hashMap.put("Apple",20);
         hashMap.put("Guava",13);
-        //HashMap Doesn't maintain any order.
+        // HashMap Doesn't maintain any order.
 
-        for(Map.Entry<String,Integer> entry : hashMap.entrySet())
-        {
+        for(Map.Entry<String,Integer> entry : hashMap.entrySet()) {
             System.out.println(entry.getKey()+": "+entry.getValue());
         }
     }
 }
 
-//Key Takeaways
-//LinkedHashMap maintains insertion order.
-//HashMap does not maintain any order—it is based on hash codes.
-//The difference in ordering is clearly visible in the output.
+/* Key Takeaways:
+LinkedHashMap maintains insertion order.
+HashMap does not maintain any order it is based on hash codes.
+The difference in ordering is clearly visible in the output.
+*/