Java Map Interface

Java Map Interface is used to store data in the form of key-value pairs. It allows you to store and access data using a key. It is widely used in real-world applications like searching, updating, and managing data.

In this chapter, you will learn about the Java Map interface, its features, and examples.

What is Map Interface in Java?

The Map interface in Java is a part of the java.util package. It stores data as key-value pairs, where each key is unique and maps to only one value. A Map is useful when you want to search, update, or delete data using a key.

Why to Use Map Interface?

The following points explain why the Map interface is useful:

• Efficient Data Retrieval:
  Map allows fast searching of values using keys. It is very useful when you need to quickly access data from a large dataset.
• No Duplicate Keys:
  Each key in a Map is unique and maps to only one value. This helps maintain data consistency and avoids duplicate entries.
• Flexible Data Types:
  You can store different types of objects as keys and values in a Map. This makes it flexible for representing different types of relationships.
• Associative Structure:
  Map works like a dictionary where each key is linked to a value. It helps in organizing data in a meaningful and structured way.
• Caching and Memoization:
  Map can store results of operations so they can be reused later. This improves performance by avoiding repeated calculations.

Key Features of Map Interface

The following points describe the key features of the Map interface:

• Key-Value Pair Structure:
  Map stores data in the form of key and value pairs. Each key is used to access its corresponding value.
• No Duplicate Keys:
  A Map does not allow duplicate keys, but it can have duplicate values. If you add a duplicate key, the old value is replaced with the new value.
• Allows Null Values:
  Some Map implementations allow null keys and values. For example, HashMap allows one null key and multiple null values.
• Not a Subtype of Collection:
  Map is not a part of the Collection interface. It is a separate interface in the Java Collections Framework.
• Traversal Using Set:
  A Map cannot be traversed directly. To iterate over it, you need to use keySet(), values(), or entrySet() methods.
• Different Implementations:
  Map has different implementations like HashMap, LinkedHashMap, and TreeMap. Each implementation works differently based on ordering and performance.

Key Features of Map Interface

The following points describe the key features of the Map interface:

• Key-Value Pair Structure:
  Map stores data in the form of key and value pairs. Each key is used to access its corresponding value.
• No Duplicate Keys:
  A Map does not allow duplicate keys, but it can have duplicate values. If you add a duplicate key, the old value is replaced with the new value.
• Allows Null Values:
  Some Map implementations allow null keys and values. For example, HashMap allows one null key and multiple null values.
• Not a Subtype of Collection:
  Map is not a part of the Collection interface. It is a separate interface in the Java Collections Framework.
• Traversal Using Set:
  A Map cannot be traversed directly. To iterate over it, you need to use keySet(), values(), or entrySet() methods.
• Different Implementations:
  Map has different implementations like HashMap, LinkedHashMap, and TreeMap. Each implementation works differently based on ordering and performance.

Hierarchy of Map Interface

The following image shows the hierarchy of the Map interface and its implementations:

Classes of Map Interface

The following table describes the commonly used classes that implement the Map interface:

Methods of Map Interface

The following table shows the commonly used methods of the Map interface:

Map.Entry Interface

Map.Entry is an inner interface of the Map interface which represents a single pair of key-value in a map. It additionally allows one to get a map and to iterate over its entries, convert the map to a set of keys/values, etc. It returns a collection-view of the map, whose elements are of this class. It provides methods to get keys and values.

Methods of Map.Entry interface

The following table shows the commonly used methods of the Map.Entry interface:

Java Map Examples

Here are some examples of the Java Map interface to understand its usage.

Example 1: Non-Generic Map (Old Style)

In this example, we are using a non-generic Map and traversing it using Iterator.

Output:

1 Amit
2 Jai
5 Rahul
6 Amit

Example 2: Generic Map Using HashMap

In this example, we are using a generic Map and traversing it using entrySet().

Output:

100 Amit
101 Vijay
102 Rahul

Example 3: Sorting Map by Key (Ascending Order)

Output:

100=Amit
101=Vijay
102=Rahul

Example 4: Sorting Map by Key (Descending Order)

In this example, we are sorting the Map entries by key in descending order.

Output:

102=Rahul
101=Vijay
100=Amit

Note: The Map interface is implemented by several classes such as HashMap, LinkedHashMap, and TreeMap.

HashMap

HashMap is an important data structure in Java which implements the Map interface. In this way, it provides a scheme for storing of key-value pairs. A HashMap has each key unique and only has one value for each key. This enables the lookup of values by their keys that are paired with them.

One of the most important features of HashMap is its underlying implementation as a hash table that allows constant-time performance for basic operations such as insertion, deletion, and retrieval on average, providing a good hash function and proper capacity management.

Example

In this example, we are creating a HashMap to store student IDs and names, retrieving a value using a key, iterating through the map, and checking if a key exists.

Output:

Student with ID 1002 is: Emily BrownStudent Records:
ID: 1001, Name: John Smith
ID: 1002, Name: Emily Brown
ID: 1003, Name: Michael Johnson
Student with ID 1004 exists in records: false

LinkedHashMap

LinkedHashMap is a class in Java that extends HashMap and implements the Map interface. It is similar to HashMap in functionality but maintains a predictable iteration order, that is, the order in which keys were inserted into the map (insertion order). This makes LinkedHashMap a good choice when the insertion order needs to be preserved.

LinkedHashMap has a special feature of maintaining a doubly linked list of its entries, which allows iteration in either insertion order or access order (the order in which entries were last accessed).

Example

In this example, we are creating a LinkedHashMap to store student IDs and names, and iterating over the entries while maintaining insertion order.

Output:

Student Records:
ID: 1001, Name: John Smith
ID: 1002, Name: Emily Brown
ID: 1003, Name: Michael Johnson

TreeMap

TreeMap is a sorted map implementation that stores key-value pairs in a Red-Black tree structure. It ensures that elements are arranged based on their keys, either in natural order or using a user-defined comparator.

This data structure provides O(log n) time complexity for insertion, deletion, and retrieval operations. TreeMap implements the NavigableMap interface, which provides methods for navigation and range-based operations.

It is commonly used for maintaining data in sorted order, performing range searches, and processing data efficiently in a sorted manner.

Example

In this example, we are creating a TreeMap to store student IDs and names, and iterating over the entries in sorted (ascending) order of keys.

Output:

Student Records:
ID: 1001, Name: John Smith
ID: 1002, Name: Emily Brown
ID: 1003, Name: Michael Johnson