Java HashMap remove(Object key, Object value) Method

The HashMap.remove(Object key, Object value) method in Java is used to remove the entry for a specified key only if it is currently mapped to a specified value. This guide will cover the method's usage, explain how it works, and provide examples to demonstrate its functionality.

Table of Contents

1. Introduction
2. remove Method Syntax
3. Examples
   • Removing an Entry with Specific Key and Value
   • Real-World Use Case: Conditional Removal in a User Database
4. Conclusion

Introduction

The HashMap.remove(Object key, Object value) method is a member of the HashMap class in Java. It allows you to remove a key-value pair from the map only if the key is currently mapped to the specified value. This can be useful for ensuring that the correct entry is removed based on both key and value.

remove() Method Syntax

The syntax for the remove method is as follows:

public boolean remove(Object key, Object value)

• The method takes two parameters:
  • key of type Object, which represents the key whose mapping is to be removed.
  • value of type Object, which represents the value expected to be associated with the specified key.
• The method returns a boolean value:
  • true if the entry was removed.
  • false if the entry was not removed because the key was not mapped to the specified value.

Examples

Removing an Entry with Specific Key and Value

The remove method can be used to remove a key-value pair from a HashMap only if the key is currently mapped to the specified value.

Example

import java.util.HashMap;

public class RemoveSpecificExample {
    public static void main(String[] args) {
        // Creating a HashMap with String keys and Integer values
        HashMap<String, Integer> people = new HashMap<>();

        // Adding entries to the HashMap
        people.put("Ravi", 25);
        people.put("Priya", 30);
        people.put("Vijay", 35);

        // Using remove method
        boolean removed1 = people.remove("Ravi", 25); // Should remove the entry
        boolean removed2 = people.remove("Priya", 35); // Should not remove the entry

        // Printing the results
        System.out.println("Was Ravi removed? " + removed1); // Should print true
        System.out.println("Was Priya removed? " + removed2); // Should print false

        // Printing the updated HashMap
        System.out.println("Updated HashMap: " + people);
    }
}

Output:

Was Ravi removed? true
Was Priya removed? false
Updated HashMap: {Priya=30, Vijay=35}

Real-World Use Case: Conditional Removal in a User Database

In a real-world scenario, you might use the remove method to conditionally remove user entries from a database based on their current values, such as removing a user only if their status is inactive.

Example

import java.util.HashMap;

public class ConditionalRemoval {
    public static void main(String[] args) {
        // Creating a HashMap with String keys (user IDs) and String values (statuses)
        HashMap<String, String> userDatabase = new HashMap<>();

        // Adding entries to the HashMap
        userDatabase.put("U001", "active");
        userDatabase.put("U002", "inactive");
        userDatabase.put("U003", "active");

        // Using remove method to conditionally remove users
        boolean removed1 = userDatabase.remove("U002", "inactive"); // Should remove the entry
        boolean removed2 = userDatabase.remove("U003", "inactive"); // Should not remove the entry

        // Printing the results
        System.out.println("Was user U002 removed? " + removed1); // Should print true
        System.out.println("Was user U003 removed? " + removed2); // Should print false

        // Printing the updated user database
        System.out.println("Updated User Database: " + userDatabase);
    }
}

Output:

Was user U002 removed? true
Was user U003 removed? false
Updated User Database: {U001=active, U003=active}

Conclusion

The HashMap.remove(Object key, Object value) method in Java provides a way to remove a key-value pair from a HashMap only if the key is currently mapped to the specified value. By understanding how to use this method, you can ensure that entries are removed conditionally based on both key and value, adding an extra layer of control to your map operations. This method is useful in various scenarios, such as conditional deletions in databases, ensuring data integrity, and managing collections with specific removal criteria.