Java Util HashMap in Java with Examples

The HashMap in Java is one of the most widely used classes in the Java Collection Framework. It is part of the java.util package and allows developers to store and manipulate key-value pairs efficiently. In this article, we will explore the features, functionality, and HashMap examples in Java to help you understand its usage.

What is a HashMap in Java?

A HashMap is a data structure that implements the Map interface in Java. It is used to store data in a key-value pair format. Here are some of its key characteristics:

• Allows null values and one null key.
• Does not maintain any order for the stored elements.
• Not synchronized, meaning it is not thread-safe.
• Provides constant-time performance for basic operations like
  📄
  get and
  📄
  put.

How to Create a HashMap in Java?

You can create a HashMap using the following syntax:

import java.util.HashMap;

public class HashMapExample {
    public static void main(String[] args) {
        HashMap map = new HashMap<>();
    }
}

Common Operations in HashMap

Here are the most common operations performed on a HashMap in Java:

1. Adding Elements

Use the put() method to add key-value pairs to a HashMap:

HashMap map = new HashMap<>();
map.put(1, "Java");
map.put(2, "Python");
map.put(3, "C++");

2. Accessing Elements

Retrieve a value by using the get() method and providing the key:

String language = map.get(1); // Output: Java

3. Removing Elements

Remove a key-value pair using the remove() method:

map.remove(2); // Removes the entry with key 2

Examples of HashMap in Java

1. Iterating Over a HashMap

You can iterate through a HashMap using entrySet():

import java.util.HashMap;
import java.util.Map;

public class HashMapIteration {
    public static void main(String[] args) {
        HashMap map = new HashMap<>();
        map.put(1, "Java");
        map.put(2, "Python");
        map.put(3, "C++");

        for (Map.Entry entry : map.entrySet()) {
            System.out.println("Key: " + entry.getKey() + ", Value: " + entry.getValue());
        }
    }
}

2. Using HashMap for Counting Frequencies

A HashMap can be used to count the frequency of elements in an array:

import java.util.HashMap;

public class FrequencyCounter {
    public static void main(String[] args) {
        String[] words = {"apple", "banana", "apple", "orange", "banana", "apple"};
        HashMap frequencyMap = new HashMap<>();

        for (String word : words) {
            frequencyMap.put(word, frequencyMap.getOrDefault(word, 0) + 1);
        }

        System.out.println(frequencyMap);
    }
}

Advantages of HashMap

• Fast and efficient for large datasets.
• Flexible: Allows dynamic sizing and accepts null keys/values.
• Useful for implementing cache mechanisms, dictionaries, and lookup tables.

Limitations of HashMap

• Not thread-safe for multithreading environments.
• Does not maintain any order of elements.
• Performance may degrade if hash collisions occur frequently.

HashMap vs Other Java Collections

FAQs About HashMap in Java

1. What is the purpose of a HashMap in Java?

A HashMap is used to store and manage key-value pairs. It is ideal for quick lookups and efficient data manipulation.

2. Can a HashMap have duplicate keys?

No, keys in a HashMap must be unique. If a duplicate key is added, it will overwrite the existing entry.

3. How is a HashMap different from a Hashtable?

HashMap is unsynchronized and allows null keys/values, while Hashtable is synchronized and does not allow null keys or values.

Conclusion

The HashMap in Java is a powerful tool for storing and managing data as key-value pairs. By understanding its functionality and exploring Java HashMap examples, developers can leverage it effectively for various use cases. Whether you're implementing a cache, frequency counter, or a dictionary, the Java Collection Framework makes it easy to work with HashMap in Java.