Java HashMap replace() Method

The HashMap.replace(K key, V value) method in Java is used to replace the value for a specified key only if it is currently mapped to some 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. replace Method Syntax
3. Examples
   • Replacing an Entry in a HashMap
   • Real-World Use Case: Updating Product Prices
4. Conclusion

Introduction

The HashMap.replace(K key, V value) method is a member of the HashMap class in Java. It allows you to replace the value associated with a key only if it is currently mapped to some value. This can be useful for updating entries in a map without adding new ones if the key does not already exist.

replace() Method Syntax

The syntax for the replace method is as follows:

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.

Examples

Replacing an Entry in a HashMap

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

Example

import java.util.HashMap;

public class ReplaceExample {
    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 replace method
        Integer oldValue1 = people.replace("Ravi", 28); // Should replace the value
        Integer oldValue2 = people.replace("Amit", 40); // Should not replace the value since "Amit" does not exist

        // Printing the results
        System.out.println("Old value for Ravi: " + oldValue1); // Should print 25
        System.out.println("Old value for Amit: " + oldValue2); // Should print null

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

Output:

Old value for Ravi: 25
Old value for Amit: null
Updated HashMap: {Ravi=28, Priya=30, Vijay=35}

Real-World Use Case: Updating Product Prices

In a real-world scenario, you might use the replace method to update the prices of products in a product catalog.

Example

import java.util.HashMap;

public class UpdateProductPrices {
    public static void main(String[] args) {
        // Creating a HashMap with String keys (product IDs) and Integer values (prices)
        HashMap<String, Integer> productPrices = new HashMap<>();

        // Adding entries to the HashMap
        productPrices.put("P001", 1000);
        productPrices.put("P002", 1500);
        productPrices.put("P003", 2000);

        // Using replace method to update prices
        Integer oldPrice1 = productPrices.replace("P001", 1200); // Should replace the price
        Integer oldPrice2 = productPrices.replace("P004", 1800); // Should not replace the price since "P004" does not exist

        // Printing the results
        System.out.println("Old price for P001: " + oldPrice1); // Should print 1000
        System.out.println("Old price for P004: " + oldPrice2); // Should print null

        // Printing the updated product prices
        System.out.println("Updated Product Prices: " + productPrices);
    }
}

Output:

Old price for P001: 1000
Old price for P004: null
Updated Product Prices: {P001=1200, P002=1500, P003=2000}

Conclusion

The HashMap.replace(K key, V value) method in Java provides a way to replace the value associated with a key only if it is currently mapped to some value. By understanding how to use this method, you can efficiently update entries in a map without adding new ones if the key does not already exist. This method is useful in various scenarios, such as updating records in a database, managing configuration settings, and handling state transitions in collections.