Java HashMap replace() Method

📘 Premium Read: Access my best content on Medium member-only articles — deep dives into Java, Spring Boot, Microservices, backend architecture, interview preparation, career advice, and industry-standard best practices.

🎓 Top 15 Udemy Courses (80-90% Discount): My Udemy Courses - Ramesh Fadatare — All my Udemy courses are real-time and project oriented courses.

▶️ Subscribe to My YouTube Channel (176K+ subscribers): Java Guides on YouTube

▶️ For AI, ChatGPT, Web, Tech, and Generative AI, subscribe to another channel: Ramesh Fadatare on YouTube

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.