feat(HashMapOrderDemo): illustrate non-deterministic iteration order in HashMap

What
- Added HashMapOrderDemo class.
- Demonstrated basic HashMap operations:
  - put() to insert/update entries.
  - getOrDefault() for safe retrieval.
- Printed the map contents to show iteration order.
- Added detailed comments explaining why HashMap does not preserve insertion order.

Why
- To highlight that HashMap does not guarantee ordering of keys or entries.
- Developers often mistakenly assume insertion order is preserved.
- Provides guidance on when to use LinkedHashMap or TreeMap instead.

How
- Created a HashMap<String, Integer>.
- Inserted three entries: ("Shubham", 91), ("Bob", 80), ("Akshit", 78).
- Retrieved non-existing key with getOrDefault("Vipul", 0).
- Updated "Shubham" to new value 92.
- Printed the HashMap to observe output order.

Logic
- Inputs: string keys and integer scores.
- Processing:
  - HashMap places entries into internal buckets using hashCode().
  - Iteration traverses buckets, not insertion sequence.
- Outputs:
  - Map print shows contents in an arbitrary, non-guaranteed order.
  - Example: {Akshit=78, Shubham=92, Bob=80} but actual order may differ.

Real-life applications
- HashMap → use when you need fast key-based lookups and order doesn’t matter.
- LinkedHashMap → use when insertion order or access-order must be preserved.
- TreeMap → use when you need keys sorted by natural ordering or a custom Comparator.

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

Author: Someshdiwan

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

@@ -0,0 +1,46 @@
+import java.util.HashMap;
+
+public class HashMapOrderDemo {
+    public static void main(String[] args) {
+
+        // Create a HashMap (default capacity 16, load factor 0.75)
+        HashMap<String, Integer> hashMap = new HashMap<>();
+
+        // Put elements into the HashMap
+        hashMap.put("Shubham", 91);
+        hashMap.put("Bob", 80);
+        hashMap.put("Akshit", 78);
+
+        // getOrDefault: returns value if key exists; otherwise returns default (0 here).
+        Integer res = hashMap.getOrDefault("Vipul", 0);
+
+        // Update the value for "Shubham" (replaces old value).
+        hashMap.put("Shubham", 92);
+
+        // Print HashMap
+        System.out.println("HashMap contents: " + hashMap);
+
+        /*
+         * Important: HashMap does NOT guarantee order of keys.
+         * Why?
+         *  - Internally, entries are stored in buckets (based on hashCode).
+         *  - Iteration goes bucket by bucket, not in insertion order.
+         *  - Therefore, output order may look random, may differ across runs or JDK versions.
+
+         * Example Output:
+         *   {Akshit=78, Shubham=92, Bob=80}
+
+         * But order is NOT reliable or predictable.
+         */
+    }
+}
+
+/* Theory: HashMap Order
+
+1. HashMap uses hashing → elements go into buckets based on hashCode().
+2. Because bucket placement is not related to insertion sequence,
+   iteration does NOT preserve insertion order.
+3. If you need guaranteed order:
+   - Use LinkedHashMap (insertion-order or access-order).
+   - Or use TreeMap (sorted order).
+*/