feat(HashMapDemo3): add HashMap entrySet iteration and formatted printing demo

What
- Implemented `HashMapDemo3` to show how to retrieve entries from a `HashMap` using `entrySet()`
  and iterate over them with formatted output.
- Added logic to print both the original map and processed key–value pairs.

Why
- Demonstrates a more structured way of accessing `HashMap` contents (key + value together).
- Highlights the fact that `HashMap` does not maintain insertion or sorted order.
- Provides an example of formatting values (e.g., uppercase transformation) without modifying the original map.

How
1. Created a `HashMap<Integer, String>` and inserted sample entries (`Jack`, `Smith`, `Shubham`, `John`).
2. Printed the original map directly.
3. Retrieved entries via `map.entrySet()`.
4. Iterated over each entry:
   - Printed key and value with formatted width using `printf`.
   - Printed the uppercase version of the value (demonstrating transformation without changing the map).
5. Printed the final map again to show contents remain unchanged.

Notes on ordering
- `HashMap` **does not guarantee iteration order**.
- The printed order depends on hash distribution and internal bucket structure.
- With a small number of elements, output may look "sorted" by coincidence, but this is unreliable.
- For predictable ordering:
  - Use `LinkedHashMap` → preserves insertion order.
  - Use `TreeMap` → sorts by key.

Real-life application
- Iterating key–value mappings for reporting, logging, or transforming data (like uppercase conversion).
- Useful in scenarios like processing user IDs → names, product IDs → details, etc.

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

Author: Someshdiwan

Section 25 Collections Frameworks/Map Interface/HashMap/src/HashMapDemo3.java

@@ -0,0 +1,48 @@
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Set;
+
+public class HashMapDemo3 {
+    public static void main(String[] args) {
+        HashMap<Integer, String> map = new HashMap<>();
+
+        map.put(1, "Jack");
+        map.put(31, "Smith");
+        map.put(11, "Shubham");
+        map.put(2, "John");
+
+        System.out.println("Original Map: " + map);
+
+        // List of entries.
+        Set<Map.Entry<Integer, String>> entries = map.entrySet();
+
+        for (Map.Entry<Integer, String> entry : entries) {
+            System.out.printf("%-3d : %-10s%n", entry.getKey(), entry.getValue());
+            System.out.printf("     %-10s%n", entry.getValue().toUpperCase());
+        }
+        System.out.println("Final Map: " + map);
+    }
+}
+
+/*
+The reason the HashMap sometimes looks like it is printing in natural (sorted) order is purely coincidental and
+depends on the internal hashing mechanism.
+
+Why does it look sorted?
+
+1. HashMap does not guarantee order
+   - The order of elements depends on the hash function and how entries are placed into buckets.
+
+2. Small number of elements
+   - When there are only a few entries, it may sometimes appear sorted by chance,
+     but this behavior is not reliable.
+
+3. JDK version & HashMap implementation details
+   - In some Java versions, the way the hashing algorithm and bucket assignments work
+     can make the output look sorted in certain cases.
+   - However, this should never be relied upon.
+
+Conclusion:
+If you need a predictable order, do not use HashMap.
+Use `TreeMap` (sorted by keys) or `LinkedHashMap` (insertion order) instead.
+*/