Java SortedMap Interface

Author:

Introduction

The SortedMap interface in Java, part of the java.util package, is a specialized map that maintains its entries in ascending key order. This interface extends the Map interface and adds methods that provide navigation and sorted views of the map. The most commonly used implementation of SortedMap is TreeMap.

Table of Contents

  1. What is the SortedMap Interface?
  2. Common Implementations
  3. Common Methods
  4. Examples of Using the SortedMap Interface
  5. Conclusion

1. What is the SortedMap Interface?

The SortedMap interface extends the Map interface and maintains its entries sorted according to the natural ordering of the keys or by a specified comparator. This ordering is consistent with equals only if the comparator used is consistent with equals.

2. Common Implementations

  • TreeMap: A Red-Black tree-based implementation of the SortedMap interface. It provides guaranteed log(n) time cost for the basic operations (get, put, remove) and maintains the order of its keys.

3. Common Methods

  • comparator(): Returns the comparator used to order the keys in this map, or null if this map uses the natural ordering of its keys.
  • subMap(K fromKey, K toKey): Returns a view of the portion of this map whose keys range from fromKey, inclusive, to toKey, exclusive.
  • headMap(K toKey): Returns a view of the portion of this map whose keys are strictly less than toKey.
  • tailMap(K fromKey): Returns a view of the portion of this map whose keys are greater than or equal to fromKey.
  • firstKey(): Returns the first (lowest) key currently in this map.
  • lastKey(): Returns the last (highest) key currently in this map.

4. Examples of Using the SortedMap Interface

Example 1: Basic Usage with TreeMap

This example demonstrates how to use a TreeMap with the SortedMap interface.

import java.util.SortedMap;
import java.util.TreeMap;

public class SortedMapExample {
    public static void main(String[] args) {
        SortedMap<Integer, String> map = new TreeMap<>();

        // Adding elements to the map
        map.put(3, "Three");
        map.put(1, "One");
        map.put(4, "Four");
        map.put(2, "Two");

        // Displaying the map
        System.out.println("SortedMap: " + map);

        // Accessing the first and last keys
        System.out.println("First Key: " + map.firstKey());
        System.out.println("Last Key: " + map.lastKey());

        // Getting a subMap
        SortedMap<Integer, String> subMap = map.subMap(2, 4);
        System.out.println("SubMap from 2 to 4: " + subMap);

        // Getting a headMap
        SortedMap<Integer, String> headMap = map.headMap(3);
        System.out.println("HeadMap up to 3: " + headMap);

        // Getting a tailMap
        SortedMap<Integer, String> tailMap = map.tailMap(3);
        System.out.println("TailMap from 3: " + tailMap);
    }
}

Output:

SortedMap: {1=One, 2=Two, 3=Three, 4=Four}
First Key: 1
Last Key: 4
SubMap from 2 to 4: {2=Two, 3=Three}
HeadMap up to 3: {1=One, 2=Two}
TailMap from 3: {3=Three, 4=Four}

Example 2: Using Custom Comparator

This example shows how to use a TreeMap with a custom comparator.

import java.util.Comparator;
import java.util.SortedMap;
import java.util.TreeMap;

public class CustomComparatorExample {
    public static void main(String[] args) {
        Comparator<String> reverseOrder = Comparator.reverseOrder();
        SortedMap<String, Integer> map = new TreeMap<>(reverseOrder);

        // Adding elements to the map
        map.put("Banana", 1);
        map.put("Apple", 2);
        map.put("Cherry", 3);

        // Displaying the map
        System.out.println("SortedMap with Custom Comparator: " + map);

        // Accessing the first and last keys
        System.out.println("First Key: " + map.firstKey());
        System.out.println("Last Key: " + map.lastKey());
    }
}

Output:

SortedMap with Custom Comparator: {Cherry=3, Banana=1, Apple=2}
First Key: Cherry
Last Key: Apple

Example 3: Navigating through the Map

This example demonstrates how to navigate through the SortedMap using different methods.

import java.util.SortedMap;
import java.util.TreeMap;

public class NavigationExample {
    public static void main(String[] args) {
        SortedMap<Integer, String> map = new TreeMap<>();

        // Adding elements to the map
        map.put(1, "One");
        map.put(2, "Two");
        map.put(3, "Three");
        map.put(4, "Four");
        map.put(5, "Five");

        // Displaying the map
        System.out.println("SortedMap: " + map);

        // Accessing elements using navigational methods
        System.out.println("HeadMap (less than 3): " + map.headMap(3));
        System.out.println("TailMap (3 and more): " + map.tailMap(3));
        System.out.println("SubMap (2 to 4): " + map.subMap(2, 4));
    }
}

Output:

SortedMap: {1=One, 2=Two, 3=Three, 4=Four, 5=Five}
HeadMap (less than 3): {1=One, 2=Two}
TailMap (3 and more): {3=Three, 4=Four, 5=Five}
SubMap (2 to 4): {2=Two, 3=Three}

Example 4: Using SortedMap with Custom Objects

This example demonstrates how to use a SortedMap with custom objects, requiring the implementation of Comparable or providing a Comparator.

import java.util.*;

public class CustomObjectSortedMapExample {
    public static void main(String[] args) {
        SortedMap<Person, Integer> map = new TreeMap<>();

        // Adding custom objects to the map
        map.put(new Person("Raj", 30), 1);
        map.put(new Person("Anita", 25), 2);
        map.put(new Person("Vikram", 35), 3);

        // Iterating over the map
        for (Map.Entry<Person, Integer> entry : map.entrySet()) {
            System.out.println(entry.getKey() + " => " + entry.getValue());
        }
    }
}

class Person implements Comparable<Person> {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public int compareTo(Person other) {
        return Integer.compare(this.age, other.age);
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person person = (Person) o;
        return age == person.age && Objects.equals(name, person.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }

    @Override
    public String toString() {
        return "Person{name='" + name + "', age=" + age + "}";
    }
}

Output:

Person{name='Anita', age=25} => 2
Person{name='Raj', age=30} => 1
Person{name='Vikram', age=35} => 3

5. Conclusion

The SortedMap interface in Java provides a powerful way to manage maps that maintain their entries in ascending key order. By using different implementations like TreeMap, developers can take advantage of navigational methods and custom ordering. The examples provided demonstrate common usage patterns and highlight the capabilities of the SortedMap interface.

Comments

Post a Comment

Leave Comment