feat(SortedMapDemo4): add demo of TreeMap with natural and custom comparator ordering

What
- Added SortedMapDemo4 class.
- Demonstrated TreeMap with:
  • Natural ordering of String keys (alphabetical ascending).
  • Navigation methods: firstKey, lastKey, headMap, tailMap, subMap.
  • Lookup methods: containsKey, containsValue, get.
  • Views: keySet() and values().
- Added second TreeMap with Comparator.reverseOrder() to show descending Integer keys.

Why
- To illustrate how SortedMap (via TreeMap) behaves with default natural ordering and with a custom comparator.
- Show the difference in semantics when ordering is reversed.
- Teach usage of range queries (headMap, tailMap, subMap) and map views.

How
- Constructed TreeMap<String,Integer> with default natural ordering.
- Inserted entries:
  • Vivek=91, Shubham=99, Mohit=78, Vipul=77.
- Verified ascending key order in output.
- Called navigation methods:
  • firstKey() = Mohit, lastKey() = Vivek.
  • headMap("Vivek") = {Mohit=78, Shubham=99, Vipul=77}.
  • tailMap("Vivek") = {Vivek=91}.
  • subMap("Mohit","Vivek") = {Mohit=78, Shubham=99, Vipul=77}.
- Looked up key/value presence and retrieved a value.
- Printed keySet() and values() views.
- Constructed TreeMap<Integer,String> with Comparator.reverseOrder().
  • Inserted entries {91=Vivek, 99=Shubham, 78=Mohit, 77=Vipul}.
  • Printed descending order {99=Shubham, 91=Vivek, 78=Mohit, 77=Vipul}.
  • Verified firstKey() = 99, lastKey() = 77.

Logic
- Data structure: TreeMap (Red-Black tree).
- Complexity: put/get/remove = O(log n).
- Range methods (headMap, tailMap, subMap) produce live backed views.
- Ordering depends on comparator:
  • Natural order: lexicographic ascending for Strings.
  • Comparator.reverseOrder(): numeric descending for Integers.
- firstKey()/lastKey() reflect current comparator order.
- Null keys not allowed, null values allowed.

Real-life applications
- Maintaining a sorted directory of users (by name).
- Leaderboards sorted by scores (descending comparator).
- Range queries (e.g., find users with IDs in certain ranges).
- Easy retrieval of smallest/largest keys in current ordering.

Summary
- TreeMap provides sorted storage and navigation for keys.
- Natural order vs custom comparator order changes all key-based operations.
- Range views (headMap, tailMap, subMap) are efficient and backed by the tree.

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

Author: Someshdiwan

Section 25 Collections Frameworks/Map Interface/Sorted Map/src/SortedMapDemo4.java

@@ -0,0 +1,56 @@
+import java.util.*;
+
+public class SortedMapDemo4 {
+    public static void main(String[] args) {
+        // SortedMap is an interface, TreeMap is its implementation.
+        // TreeMap maintains keys in sorted (natural) order by default.
+        SortedMap<String, Integer> sortedMap = new TreeMap<>();
+
+        // Adding entries
+        sortedMap.put("Vivek", 91);
+        sortedMap.put("Shubham", 99);
+        sortedMap.put("Mohit", 78);
+        sortedMap.put("Vipul", 77);
+
+        // Printing full map - automatically sorted by keys (ascending order)
+        System.out.println("Full Map: " + sortedMap);
+
+        // firstKey() - smallest key
+        System.out.println("First Key: " + sortedMap.firstKey());
+
+        // lastKey() - largest key
+        System.out.println("Last Key: " + sortedMap.lastKey());
+
+        // headMap(toKey) - keys < toKey
+        System.out.println("headMap(\"Vivek\"): " + sortedMap.headMap("Vivek"));
+
+        // tailMap(fromKey) - keys >= fromKey
+        System.out.println("tailMap(\"Vivek\"): " + sortedMap.tailMap("Vivek"));
+
+        // subMap(fromKey, toKey) - keys in [fromKey, toKey)
+        System.out.println("subMap(\"Mohit\", \"Vivek\"): " + sortedMap.subMap("Mohit", "Vivek"));
+
+        // containsKey() and containsValue()
+        System.out.println("Contains key 'Shubham'? " + sortedMap.containsKey("Shubham"));
+        System.out.println("Contains value 100? " + sortedMap.containsValue(100));
+
+        // Get a value by key
+        System.out.println("Value for 'Vipul': " + sortedMap.get("Vipul"));
+
+        // Views
+        System.out.println("Key Set: " + sortedMap.keySet());
+        System.out.println("Values: " + sortedMap.values());
+
+
+        // Example with custom Comparator
+        SortedMap<Integer, String> descMap = new TreeMap<>(Comparator.reverseOrder());
+        descMap.put(91, "Vivek");
+        descMap.put(99, "Shubham");
+        descMap.put(78, "Mohit");
+        descMap.put(77, "Vipul");
+
+        System.out.println("\nCustom Comparator (Descending Order): " + descMap);
+        System.out.println("First Key (Highest): " + descMap.firstKey());
+        System.out.println("Last Key  (Lowest): " + descMap.lastKey());
+    }
+}