Diving into Sorted Maps in Java

Hello again! This lesson's topic is Sorted Maps. Similar to other map structures, Sorted Maps store key-value pairs but in an ordered manner. Learning about Sorted Maps enriches our set of tools for organized and efficient data manipulation. Today's goal is to work with Sorted Maps using Java's TreeMap class.

In Java, we differentiate between regular maps like HashMap and Sorted Maps. Comparing HashMap to TreeMap is akin to comparing a messy bookshelf to a well-organized library — the latter maintains order. HashMap does not guarantee any order of keys, whereas TreeMap sorts the keys in natural order (if they implement the Comparable interface) or according to a specified comparator.

The TreeMap class is part of the Java Collections Framework and provides a Red-Black tree-based implementation of the NavigableMap interface. This ensures that the map is always sorted according to the natural ordering of its keys or by a custom comparator.

To create a TreeMap object, you can either use the default constructor or initialize it with a map. The keys used in a TreeMap must be immutable and comparable. For instance:

import java.util.TreeMap;

public class TreeMapExample {
    public static void main(String[] args) {
        // TreeMap with fruits as keys and corresponding counts as values
        TreeMap<String, Integer> treeMap = new TreeMap<>();
        treeMap.put("banana", 3);
        treeMap.put("apple", 4);
        treeMap.put("pear", 1);
        treeMap.put("orange", 2);

        // Print the TreeMap
        System.out.println(treeMap);
    }
}

The output will be:

{apple=4, banana=3, orange=2, pear=1}

In this example, the keys are sorted in alphabetical order. This means that "apple" comes first because 'a' is earlier in the alphabet than 'b' from "banana", 'o' from "orange", and 'p' from "pear". Conversely, "pear" is the greatest key because 'p' has a higher ASCII value than 'a', 'b', and 'o'.

A TreeMap object boasts several useful methods. Here are some crucial ones:

• treeMap.ceilingKey(key): This returns the least key greater than or equal to the specified key, or null if there is no such key.
• treeMap.floorKey(key): This returns the greatest key less than or equal to the specified key, or null if there is no such key.
• treeMap.remove(key): This removes the entry for the specified key if it is present and returns its associated value.
• treeMap.get(key): This returns the value to which the specified key is mapped, or null if the map contains no mapping for the key.
• treeMap.lastEntry(): This returns the key-value pair corresponding to the greatest key, or null if the map is empty.

Consider the following Java code, which incorporates these methods:

import java.util.TreeMap;

public class TreeMapMethods {
    public static void main(String[] args) {
        // Initialize TreeMap
        TreeMap<String, Integer> treeMap = new TreeMap<>();
        treeMap.put("banana", 3);
        treeMap.put("apple", 4);
        treeMap.put("pear", 1);
        treeMap.put("orange", 2);

        // 'apple' is less than or equal to 'apple'
        System.out.println("Ceiling key of 'apple': " + treeMap.ceilingKey("apple")); // Output: apple

        // 'apple' is less than or equal to 'apple'
        System.out.println("Floor key of 'apple': " + treeMap.floorKey("apple")); // Output: apple

        // Remove 'apple' and print the removed value
        Integer removedValue = treeMap.remove("apple");
        System.out.println("Removed value: " + removedValue); // Output: 4

        // Attempt to fetch a nonexisting key
        Integer value = treeMap.get("apple");
        if (value == null) {
            System.out.println("Value: Not found"); // Output: Value: Not found
        }

        // Get the last key-value pair
        System.out.println("Last entry: " + treeMap.lastEntry()); // Output: pear=1
    }
}