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/LinkedHashMapBasics.java renamed to Section 25 Collections Frameworks/Map Interface/Linked HashMap/src/LinkedHashMapDemo.java

@@ -1,14 +1,12 @@
-package HashMapDemo.LinkedHashMapDemo;
-
 import java.util.LinkedHashMap;
 
-public class LinkedHashMapBasics {
+public class LinkedHashMapDemo {
     public static void main(String[] args) {
-        /*LinkedHashMap<Integer, String> LHM = new LinkedHashMap<>(5);*/
+        /* LinkedHashMap<Integer, String> LHM = new LinkedHashMap<>(5); */
 
         LinkedHashMap<Integer, String> LHM = new LinkedHashMap<>(5,.75F,true);
-        //true = means order of their access . 1st key show most recently used key.
-        //You can change the loading factor. 0.75...
+        // true = means order of their access . 1st key show most recently used key.
+        // You can change the loading factor. 0.75...
 
         LHM.put(1,"Hello");
         LHM.put(2,"Bye");
@@ -18,17 +16,17 @@ public static void main(String[] args) {
         LHM.put(6,"I am the BatMan");
         LHM.put(7,"Just Grind Hard Everyday and night");
 
-        //Take String references for value.
+        // Take String references for value.
         String s = LHM.get(2);
         String s1 = LHM.get(5);
         String s2= LHM.get(1);
-        //Keys ko access kar Rahe hai and Most recently access key and Most recently accessed key.
+        // Keys ko access kar Rahe hai and Most recently access key and Most recently accessed key.
         //Most recently accessed at the last and least recently accessed at the start.
 
         LHM.forEach((k,v)->System.out.println(k+" "+v));
     }
 }
-/*
-Suppose you want to limit the size of the Linked-Hash Map then you need to override the method inside Class
-and anonymous class
-must be...protected boolean ....*/
+
+/* Suppose you want to limit the size of the Linked-Hash Map then you need to override the method inside Class
+and anonymous class must be...protected boolean ....
+*/