feat(SortedMapDemo3): showcase TreeMap operations with natural and custom ordering

What
- Added SortedMapDemo3 class.
- Demonstrates TreeMap with:
  • Natural ordering of String keys (alphabetical).
  • Standard navigation methods: firstKey, lastKey, headMap, tailMap, subMap.
  • Views: keySet(), values(), entrySet().
  • Lookup operations: containsKey, containsValue, get.
- Added second TreeMap with Comparator.reverseOrder() for descending integer keys.
- Printed behavior of navigation methods under descending order.

Why
- To illustrate the versatility of TreeMap / SortedMap API:
  • How it maintains sorted keys automatically.
  • How range queries (headMap, tailMap, subMap) work.
  • How ordering semantics change when using custom Comparator.
- Reinforces differences between key views, value views, and entry sets.

How
- Constructed TreeMap<String,Integer> with default natural order:
  • Inserts: Vivek=91, Shubham=99, Mohit=78, Vipul=77.
  • Tree sorted by key alphabetically → {Mohit=78, Shubham=99, Vipul=77, Vivek=91}.
- Demonstrated:
  • firstKey() = Mohit, lastKey() = Vivek.
  • headMap("Vivek") → keys < "Vivek".
  • tailMap("Vivek") → keys ≥ "Vivek".
  • subMap("Mohit","Vivek") → bounded range [Mohit,Vivek).
  • keySet() = view of keys, values() = view of values.
  • containsKey("Mohit") → true, containsValue(100) → false, get("Vipul") → 77.
- Constructed TreeMap<Integer,String> with reverse order comparator:
  • Inserts keys {91,99,78,77}.
  • Sorted descending → {99=Shubham,91=Vivek,78=Mohit,77=Vipul}.
  • firstKey() = 99, lastKey() = 77 under descending rules.

Logic
- Data structure: TreeMap (Red-Black tree).
- Complexity:
  - put/get/remove = O(log n).
  - headMap/tailMap/subMap produce backed views (changes affect original map).
- Ordering semantics:
  - Natural order: Strings sorted lexicographically.
  - Custom comparator: Integers sorted descending.
  - firstKey()/lastKey() adapt to comparator’s order, not numeric magnitude.
- Keys must be mutually comparable; null keys not allowed in TreeMap.

Real-life applications
- Directory-style lookups sorted by names.
- Range queries (subMap for bounded searches).
- Reverse leaderboards / ranking systems with descending comparators.
- Efficient retrieval of smallest/largest keys in O(log n).

Summary
- TreeMap automatically sorts keys by natural or custom order.
- SortedMap API offers powerful range and view operations.
- Custom comparators change semantics of navigation methods consistently.

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

Author: Someshdiwan

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

@@ -0,0 +1,58 @@
+import java.util.Collection;
+import java.util.Comparator;
+import java.util.Set;
+import java.util.SortedMap;
+import java.util.TreeMap;
+
+public class SortedMapDemo3 {
+    public static void main(String[] args) {
+        // SortedMap is an interface. TreeMap is a common implementation that
+        // keeps keys in sorted order (natural order by default).
+        SortedMap<String, Integer> map = new TreeMap<>();
+
+        // Put some entries
+        map.put("Vivek", 91);
+        map.put("Shubham", 99);
+        map.put("Mohit", 78);
+        map.put("Vipul", 77);
+
+        // Print full map (keys in sorted order)
+        System.out.println("Full map (natural order): " + map);
+
+        // firstKey() and lastKey()
+        System.out.println("First key: " + map.firstKey()); // smallest key
+        System.out.println("Last key:  " + map.lastKey());  // largest key
+
+        // headMap(toKey): returns a view of the map whose keys are strictly < toKey
+        System.out.println("headMap(\"Vivek\"): " + map.headMap("Vivek"));
+
+        // tailMap(fromKey): returns a view of the map whose keys are >= fromKey
+        System.out.println("tailMap(\"Vivek\"): " + map.tailMap("Vivek"));
+
+        // subMap(fromKey, toKey): keys in [fromKey, toKey)
+        System.out.println("subMap(\"Mohit\", \"Vivek\"): " + map.subMap("Mohit", "Vivek"));
+
+        // keySet(), values(), entrySet() - examples of views
+        Set<String> keys = map.keySet();
+        Collection<Integer> values = map.values();
+        System.out.println("Keys view:   " + keys);
+        System.out.println("Values view: " + values);
+
+        // containsKey / containsValue / get
+        System.out.println("Contains key 'Mohit'?   " + map.containsKey("Mohit"));
+        System.out.println("Contains value 100?     " + map.containsValue(100));
+        System.out.println("Value for 'Vipul':     " + map.get("Vipul"));
+
+        // Demonstrate custom comparator (descending) by creating a new TreeMap
+        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("Descending-key TreeMap: " + descMap);
+
+        // firstKey / lastKey reflect ordering of the map
+        System.out.println("First key in descending map (highest): " + descMap.firstKey());
+        System.out.println("Last key in descending map  (lowest):  " + descMap.lastKey());
+    }
+}