HashMap and HashSet

HashMap and HashSet are two of the most important data structures in the Java Collections Framework. They are widely used in enterprise applications, Spring Boot projects, REST APIs, microservices, banking systems, e-commerce platforms, and large-scale backend applications because of their excellent performance and efficient data retrieval capabilities.

While HashMap stores data in key-value pairs, HashSet stores unique values without duplicates. Both use a hashing mechanism internally, which allows operations such as insertion, deletion, and lookup to be performed very efficiently.

Understanding HashMap and HashSet is essential for every Java Backend Engineer because these collections are among the most frequently used data structures in professional software development and technical interviews.

What Is Hashing?

Before understanding HashMap and HashSet, it is important to understand hashing.

Hashing is a technique used to convert data into a unique numeric value called a hash code.

Example:

String name = "Rahul";

System.out.println(name.hashCode());

Output:

Various Integer Value

The hash code helps Java determine where data should be stored in memory.

Hashing enables fast searching and retrieval operations.

Why Hashing Is Important

Hashing provides:

• Fast lookups
• Efficient storage
• Quick insertions
• Better scalability
• Improved application performance

Modern enterprise applications depend heavily on hashing techniques.

Introduction to HashMap

HashMap is a collection class that stores data as key-value pairs.

Example:

HashMap<Integer, String> students =
        new HashMap<>();

Data can be stored as:

101 -> Rahul
102 -> Priya
103 -> Amit

The key identifies the value.

HashMap is one of the most commonly used collections in Java.

Why HashMap Is Important

HashMap provides:

• Fast data retrieval
• Efficient storage
• Dynamic sizing
• Key-based access
• Excellent performance

Most backend applications use HashMap extensively.

Creating a HashMap

Example:

HashMap<Integer, String> students =
        new HashMap<>();

Using the Map interface:

Map<Integer, String> students =
        new HashMap<>();

This approach follows object-oriented design principles.

Adding Elements to HashMap

Example:

students.put(101, "Rahul");
students.put(102, "Priya");
students.put(103, "Amit");

Output concept:

{
101=Rahul,
102=Priya,
103=Amit
}

The put() method inserts data into the map.

Retrieving Values

Example:

System.out.println(students.get(102));

Output:

Priya

The value is retrieved using its key.

This operation is extremely fast.

Updating Values

Example:

students.put(102, "Neha");

Output:

102=Neha

The old value is replaced.

Removing Elements

Example:

students.remove(101);

The specified key-value pair is removed.

Checking Key Existence

Example:

students.containsKey(102);

Output:

true

This method checks whether a key exists.

Checking Value Existence

Example:

students.containsValue("Priya");

Output:

true

This verifies whether a value exists.

Getting Total Elements

Example:

students.size();

Output:

3

Returns the number of entries.

Iterating Through HashMap

Example:

for(Map.Entry<Integer, String> entry :
        students.entrySet()) {

    System.out.println(
            entry.getKey() +
            " " +
            entry.getValue()
    );

}

Output:

101 Rahul
102 Priya
103 Amit

Iteration is commonly used in backend applications.

Internal Working of HashMap

Internally, HashMap uses:

Hash Table

The process:

1. Generate hash code.
2. Calculate bucket location.
3. Store key-value pair.
4. Retrieve data using hash code.

Example:

Key → HashCode → Bucket

This mechanism provides fast access.

HashMap Allows One Null Key

Example:

students.put(null, "Admin");

Valid.

HashMap allows:

• One null key
• Multiple null values

This behavior is important to remember.

Duplicate Keys

Example:

students.put(101, "Rahul");

students.put(101, "Amit");

Output:

101=Amit

Duplicate keys are not allowed.

The latest value replaces the previous value.

Real-World Example: Product Inventory

Example:

HashMap<Integer, String> products =
        new HashMap<>();

Data:

products.put(101, "Laptop");
products.put(102, "Mouse");
products.put(103, "Keyboard");

Retrieve:

System.out.println(products.get(101));

Output:

Laptop

HashMap is ideal for inventory management.

Introduction to HashSet

HashSet is a collection class used to store unique elements.

Example:

HashSet<String> skills =
        new HashSet<>();

Unlike HashMap:

No Key
Only Values

HashSet automatically removes duplicates.

Why HashSet Is Important

HashSet provides:

• Unique value storage
• Fast lookups
• Efficient performance
• Duplicate prevention

These features make it useful in many applications.

Creating a HashSet

Example:

HashSet<String> cities =
        new HashSet<>();

Using Set interface:

Set<String> cities =
        new HashSet<>();

This is the preferred approach.

Adding Elements

Example:

cities.add("Jaipur");
cities.add("Delhi");
cities.add("Mumbai");

Output:

[Jaipur, Delhi, Mumbai]

Elements are added successfully.

Duplicate Handling

Example:

cities.add("Delhi");

cities.add("Delhi");

Output:

Delhi

Only one copy is stored.

HashSet automatically removes duplicates.

Checking Existence

Example:

cities.contains("Delhi");

Output:

true

The contains() method is extremely fast.

Removing Elements

Example:

cities.remove("Delhi");

The specified value is removed.

Getting Total Elements

Example:

cities.size();

Output:

3

Returns the total number of unique elements.

Iterating Through HashSet

Example:

for(String city : cities) {

    System.out.println(city);

}

Output:

Jaipur
Delhi
Mumbai

Iteration is simple and efficient.

Internal Working of HashSet

HashSet internally uses:

HashMap

Every value becomes a key in an internal HashMap.

Example concept:

Delhi -> PRESENT
Mumbai -> PRESENT
Jaipur -> PRESENT

This design enables fast operations.

HashSet and Null Values

Example:

cities.add(null);

Valid.

HashSet allows:

One Null Value

Additional null entries are ignored.

HashSet Does Not Maintain Order

Example:

cities.add("Delhi");
cities.add("Mumbai");
cities.add("Jaipur");

Output order may vary.

HashSet does not guarantee insertion order.

For ordered storage:

LinkedHashSet

should be used.

Real-World Example: User Skills

Example:

HashSet<String> skills =
        new HashSet<>();

Data:

skills.add("Java");
skills.add("Spring");
skills.add("Java");

Output:

Java
Spring

Duplicate skills are automatically removed.

HashMap vs HashSet

Although both use hashing, they serve different purposes.

Data Storage

HashMap

Stores:

Key + Value

HashSet

Stores:

Only Values

Duplicate Handling

HashMap

Duplicate keys not allowed.

HashSet

Duplicate values not allowed.

Retrieval

HashMap

Retrieve by key.

Example:

products.get(101);

HashSet

No direct indexing.

Search using:

contains()

Internal Structure

HashMap

Uses:

Hash Table

HashSet

Uses:

HashMap Internally

Comparison Table

When to Use HashMap

Use HashMap when:

• Data requires key-value mapping.
• Fast retrieval is required.
• Product catalogs are managed.
• User records are stored.
• Configuration data is maintained.

Examples:

Product Inventory
Customer Records
Configuration Settings
User Sessions

When to Use HashSet

Use HashSet when:

• Uniqueness is required.
• Duplicate data must be eliminated.
• Fast existence checking is needed.

Examples:

Unique Skills
Unique Email IDs
Unique Usernames
Unique Product Categories

HashMap and HashSet in Spring Boot

Spring Boot applications frequently use:

HashMap

Map<String, Object> response;

HashSet

Set<String> permissions;

These collections are essential in enterprise development.

Advantages of HashMap

• Fast retrieval
• Dynamic sizing
• Efficient storage
• Flexible key-value mapping
• Enterprise scalability

Advantages of HashSet

• Unique value storage
• Fast searching
• Duplicate prevention
• High performance
• Easy implementation

These benefits make both collections extremely useful.

Common Mistakes Beginners Make

Using HashSet When Order Matters

HashSet does not maintain insertion order.

Use:

LinkedHashSet

instead.

Using Duplicate Keys in HashMap

Duplicate keys overwrite existing values.

Ignoring Generics

Incorrect:

HashMap map =
        new HashMap();

Correct:

HashMap<Integer, String> map =
        new HashMap<>();

Generics improve type safety.

Best Practices

• Use interfaces whenever possible.
• Choose HashMap for key-value storage.
• Choose HashSet for uniqueness.
• Use generics.
• Avoid unnecessary duplicates.
• Understand hashing fundamentals.

These practices improve software quality and maintainability.

Real-World Backend Applications

HashMap and HashSet are widely used in:

Banking Systems

Map<AccountId, Account>

E-Commerce Platforms

Map<ProductId, Product>

Authentication Systems

Set<String> Roles

User Management

Set<String> Permissions

Inventory Systems

Map<Integer, Product>

Modern backend applications rely heavily on these collections.

Summary

HashMap and HashSet are powerful collection classes that use hashing to provide efficient data storage and retrieval. HashMap stores data as key-value pairs, while HashSet stores unique values and automatically prevents duplicates.

Understanding hashing, internal implementation, performance characteristics, and real-world use cases helps developers choose the right collection for their applications. Mastering HashMap and HashSet is essential for Java backend development, enterprise software engineering, and technical interviews.

Frequently Asked Questions (FAQs)

1. What is the difference between HashMap and HashSet?

HashMap stores key-value pairs, while HashSet stores only unique values.

2. Does HashMap allow duplicate keys?

No. Duplicate keys overwrite existing values.

3. Does HashSet allow duplicates?

No. HashSet automatically removes duplicate values.

4. Does HashMap allow null values?

Yes. HashMap allows one null key and multiple null values.

5. Why are HashMap and HashSet important?

They provide fast data storage, retrieval, duplicate prevention, and efficient application performance.

Internal Link

Want to explore additional programming and software development topics? Click here for more free courses