What Is HashMap in Data Structure?


Heather Bennett

HashMap is a commonly used data structure in programming that provides a way to store and retrieve data efficiently. It is part of the Java Collections Framework and is widely used in various applications.

What Is HashMap?

HashMap is a class in Java that implements the Map interface, which means it stores key-value pairs. In simple terms, it can be thought of as a collection of items where each item has a unique key associated with it. This allows for efficient retrieval of values based on their keys.

How Does HashMap Work?

Internally, HashMap uses an array to store the key-value pairs. Each element in the array is called a bucket. When you put a key-value pair into the HashMap, it calculates the hash code of the key and uses it to determine which bucket to place the pair into.

  • If two keys have the same hash code, they will be placed in the same bucket.
  • If two different keys have different hash codes, they will be placed in different buckets.
  • If multiple pairs end up in the same bucket due to hash collisions, then they are stored as linked lists within that bucket.

When you want to retrieve a value from a HashMap using its key, it calculates the hash code of the key again and uses it to locate the corresponding bucket. It then iterates through any linked list in that bucket until it finds the pair with the matching key.

Advantages of Using HashMap

  • Fast Retrieval: HashMap provides constant time performance for retrieval operations (get and put) on average.
  • Flexible Key Types: Unlike some other data structures, HashMap allows for any type of object as keys.
  • Duplicate Keys: While each key in a HashMap must be unique, it is possible to have multiple key-value pairs with the same value.

Common Operations on HashMap

  • put(key, value): Adds a new key-value pair to the HashMap.
  • get(key): Retrieves the value associated with the specified key.
  • remove(key): Removes the key-value pair with the specified key from the HashMap.
  • size(): Returns the number of key-value pairs in the HashMap.
  • containsKey(key): Checks if the HashMap contains a specific key.
  • containsValue(value): Checks if the HashMap contains a specific value.

Example Usage of HashMap:

import java.util.HashMap;

public class Example {
public static void main(String[] args) {
// Create a new HashMap
HashMap numbers = new HashMap<>();

// Add key-value pairs
numbers.put(“one”, 1);
numbers.put(“two”, 2);
numbers.put(“three”, 3);

// Retrieve values
System.out.println(numbers.get(“one”)); // Output: 1
System.get(“two”)); // Output: 2

// Remove a pair

// Check size of the map
System.size()); // Output: 2

// Check if map contains a specific key or value
System.containsKey(“two”)); // Output: true
System.containsValue(3)); // Output: false

In this example, we create a HashMap called “numbers” that maps strings to integers. We add key-value pairs and perform various operations like retrieving values, removing a pair, checking the size of the map, and checking if it contains specific keys or values.


HashMap is a powerful data structure that provides efficient storage and retrieval of key-value pairs. It is widely used in Java programming due to its flexibility and performance benefits. Understanding how HashMap works and its common operations will help you utilize it effectively in your projects.

Discord Server - Web Server - Private Server - DNS Server - Object-Oriented Programming - Scripting - Data Types - Data Structures

Privacy Policy