Map Implementation in Java
Java provides a powerful data structure called Map, which is used to store key-value pairs. A Map is a collection of unique keys and their corresponding values, and it provides efficient methods to add, remove, and access elements in constant time.
In this blog, we will discuss the implementation of the Map interface in Java and explore some of its useful methods.
This post was originally posted at https://agrawalsuneet.github.io/blogs/map-implementation-in-java/ and later reposted on Medium.
What is a Map?
A map is used to store key value pairs where each key in a map will be unique.
Map Interface in Java
The Map interface is part of the java.util package and is used to store key-value pairs. The Map interface is not a subtype of the Collection interface. Therefore it behaves a bit differently from the rest of the collection types. The Map interface provides several methods to manipulate the key-value pairs. Here are some of the most commonly used methods:
- put(key, value): Adds the specified key-value pair to the map. If the key already exists, the old value is replaced by the new value.
- get(key): Returns the value associated with the specified key, or null if the key is not found.
- remove(key): Removes the key-value pair with the specified key from the map, if it exists.
- containsKey(key): Returns true if the map contains the specified key, false otherwise.
- keySet(): Returns a Set of all the keys in the map.
- clear(): Removes all the elements from the map.
- values(): Returns a Collection of all the values in the map.
General-Purpose Map Implementations
HashMap Implementation
HashMap is the most commonly used implementation of the Map interface. It is an unordered collection of key-value pairs and provides constant-time performance for the basic operations, such as get and put. It uses the hash function to compute the hash code of the key, which is then used to find the bucket in which the entry should be stored.
Here is an example of how to create a HashMap and add elements to it:
// create a new HashMap
HashMap myMap = new HashMap<>();
// add some key-value pairs to the map
myMap.put("apple", 1);
myMap.put("banana", 2);
myMap.put("orange", 3);
// get the value for a specific key
Integer value = myMap.get("banana");
System.out.println("The value for the key 'banana' is: " + value);
// remove a key-value pair from the map
myMap.remove("orange");
// iterate over the key-value pairs in the map
for (String key : myMap.keySet()) {
System.out.println("Key: " + key + ", Value: " + myMap.get(key));
}TreeMap Implementation
TreeMap is a sorted implementation of the Map interface. It maintains the elements in a sorted order based on the natural ordering of the keys or a custom Comparator. It provides logarithmic time performance for the basic operations, such as get and put.
