Java HashMap replace() Method

The HashMap.replace() method in Java is used to replace the value associated with a specific key in the HashMap.

Table of Contents

1. Introduction
2. replace Method Syntax
3. Examples
   • Replacing a Value by Key
   • Replacing a Value by Key and Old Value
   • Real-World Use Case: Updating Employee Records
4. Conclusion

Introduction

The HashMap.replace() method is a member of the HashMap class in Java. It allows you to replace the value associated with a specific key, and optionally, only if the key is currently mapped to a specific value. This can be useful when you need to update specific entries in the map without affecting other mappings.

replace() Method Syntax

The replace method comes in two variations:

1. Replacing the value associated with a key:

public V replace(K key, V value)

• The method takes two parameters:
  • key of type K, which represents the key whose associated value is to be replaced.
  • value of type V, which represents the new value to be associated with the key.
• The method returns the previous value associated with the specified key, or null if there was no mapping for the key.

2. Replacing the value associated with a key only if it is currently mapped to a specified value:

public boolean replace(K key, V oldValue, V newValue)

• The method takes three parameters:
  • key of type K, which represents the key whose associated value is to be replaced.
  • oldValue of type V, which represents the expected current value.
  • newValue of type V, which represents the new value to be associated with the key.
• The method returns a boolean value:
  • true if the value was replaced.
  • false if the value was not replaced.

Examples

Replacing a Value by Key

The replace method can be used to replace the value associated with a specific key.

Example

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

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

        // Adding entries to the HashMap
        countries.put("India", "IN");
        countries.put("United States", "US");
        countries.put("Canada", "CA");

        // Replacing the value for the key "India"
        String oldValue = countries.replace("India", "IND");

        // Printing the old value and the updated HashMap
        System.out.println("Old value for India: " + oldValue);
        System.out.println("Updated HashMap: " + countries);
    }
}

Output:

Old value for India: IN
Updated HashMap: {India=IND, United States=US, Canada=CA}

Replacing a Value by Key and Old Value

The replace method can be used to replace the value associated with a specific key only if it is currently mapped to a specified value.

Example

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

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

        // Adding entries to the HashMap
        countries.put("India", "IN");
        countries.put("United States", "US");
        countries.put("Canada", "CA");

        // Replacing the value for the key "India" only if the current value is "IN"
        boolean isReplaced = countries.replace("India", "IN", "IND");

        // Printing the result of the replacement and the updated HashMap
        System.out.println("Value replaced: " + isReplaced);
        System.out.println("Updated HashMap: " + countries);
    }
}

Output:

Value replaced: true
Updated HashMap: {India=IND, United States=US, Canada=CA}

Real-World Use Case: Updating Employee Records

In a real-world scenario, you might use the replace method to update employee records in an employee database.

Example

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

public class UpdateEmployeeRecord {
    public static void main(String[] args) {
        // Creating a Map with String keys (employee IDs) and String values (employee names)
        Map<String, String> employeeDatabase = new HashMap<>();

        // Adding entries to the HashMap
        employeeDatabase.put("E001", "Ravi Kumar");
        employeeDatabase.put("E002", "Priya Sharma");
        employeeDatabase.put("E003", "Vijay Singh");

        // Replacing the name for the employee ID "E002"
        String oldEmployeeName = employeeDatabase.replace("E002", "Priya R. Sharma");

        // Replacing the name for the employee ID "E003" only if the current name is "Vijay Singh"
        boolean isReplaced = employeeDatabase.replace("E003", "Vijay Singh", "Vijay K. Singh");

        // Printing the old value and the updated employee database
        System.out.println("Old name for E002: " + oldEmployeeName);
        System.out.println("Name for E003 replaced: " + isReplaced);
        System.out.println("Updated Employee Database: " + employeeDatabase);
    }
}

Output:

Old name for E002: Priya Sharma
Name for E003 replaced: true
Updated Employee Database: {E001=Ravi Kumar, E002=Priya R. Sharma, E003=Vijay K. Singh}

Conclusion

The HashMap.replace() method in Java provides a way to replace the value associated with a specific key, and optionally, only if the key is currently mapped to a specific value. By understanding how to use this method, you can efficiently update entries in your HashMap without affecting other mappings. This method is useful in various scenarios, such as updating records, managing collections of data, and ensuring data integrity.