What is the Map Interface in Java?
- The Map interface in Java is part of the java.util package, and it represents a collection of key-value pairs.
- It is designed to store information in such a way that each key maps to exactly one value.
- Typically a principal data structure that gives productive retrieval, insertion, and deletion of components based on keys.
- Not at all like other collection interfaces (like List or Set), which deal with components in an ordered or unordered sequence, a Map organizes information using keys and values.
- Each key in a Map is one of a kind, and each key maps to exactly one value.
- Maps are ordinarily used to show associations, such as mapping names to phone numbers, or product IDs to product details.
Types of Map Interface in Java Implementations
Java offers a few implementations of the Map interface, each with different characteristics, performance, and use cases. The foremost commonly utilized Map types are:
1.HashMap
- Description:HashMap is the foremost broadly used Map implementation. It stores the information in a hash table and uses the hash value of the keys to decide where to store the key-value pairs.
- Key Characteristics:
1.It permits null values and one null key.
2.Gives constant time (O(1)) complexity for essential operations like get(), put(), and remove(), on average.
3.Does not ensure any particular order of its entries.
- Example:
Map<String, Integer> map = new HashMap<>();
map.put("Alice", 30);
map.put("Bob", 25);
System.out.println(map.get("Alice")); // Output: 30
2.LinkedHashMap
- Description: LinkedHashMap is a subclass of HashMap that keeps up the order of insertion. It uses a doubly linked list to preserve the order in which entries were inserted.
- Key Characteristics:
1.It permits null values and one null key.
2.Gives predictable iteration order (insertion order).
3.Marginally slower than HashMap due to extra overhead of keeping up the linked list.
- Example:
Map<String, Integer> linkedMap = new LinkedHashMap<>();
linkedMap.put("Alice", 30);
linkedMap.put("Bob", 25);
for (Map.Entry<String, Integer> entry : linkedMap.entrySet()) {
System.out.println(entry.getKey() + ": " + entry.getValue());
}
// Output: Alice: 30, Bob: 25
3.TreeMap
- Description: TreeMap is a Map implementation based on a Red-Black tree. It stores entries in a sorted order concurring to the natural ordering of the keys or by a indicated comparator.
- Key Characteristics:
1.It does not permit null keys but permits null values.
2.Gives log(n) time complexity for fundamental operations.
3.Guarantees that the map entries are sorted.
- Example:
Map<String, Integer> treeMap = new TreeMap<>();
treeMap.put("Alice", 30);
treeMap.put("Bob", 25);
System.out.println(treeMap.firstKey()); // Output: Alice (since it's sorted alphabetically)
4.Hashtable
- Description: Hashtable is a legacy class that’s comparable to HashMap, but it is synchronized. It is considered outdated, and in advanced applications, HashMap or ConcurrentHashMap is preferred.
- Key Characteristics:
1.Synchronized, meaning thread-safe.
2.Does not permit null keys or null values.
3.Slower compared to HashMap since of synchronization overhead.
- Example:
Map<String, Integer> hashtable = new Hashtable<>();
hashtable.put("Alice", 30);
hashtable.put("Bob", 25);
System.out.println(hashtable.get("Alice")); // Output: 30
5.ConcurrentHashMap
- Description: ConcurrentHashMap is a thread-safe variation of HashMap, designed for concurrent access. It permits numerous threads to examined and type in to the map without requiring external synchronization.
- Key Characteristics:
1.Exceedingly concurrent, with thread-safe operations.
2.Does not permit null keys or values.
3.Separates the map into segments, permitting numerous threads to work on different segments concurrently.
- Example:
Map<String, Integer> concurrentMap = new ConcurrentHashMap<>();
concurrentMap.put("Alice", 30);
concurrentMap.put("Bob", 25);
System.out.println(concurrentMap.get("Alice")); // Output: 30
Fundamental Operations on Maps
- Put – Adds a key-value pair to the map. In case the key as of now exists, the old value is replaced by the new value.
map.put("John", 28);
- Get – Retrieves the value related with the given key.
int age = map.get("John"); // Returns 28
- Remove – Removes the key-value pair related with the required key.
map.remove("John");
- ContainsKey – Checks if the map contains the required key.
boolean contains = map.containsKey("Alice");
KeySet – Returns a Set view of the keys contained within the map.
Set<String> keys = map.keySet();
- Values – Returns a Collection view of the values within the map.
Collection<Integer> values = map.values();