Java LinkedHashMap replace() Method

The LinkedHashMap.replace(K key, V oldValue, V newValue) method in Java is used to replace the value for a specific key only if it is currently mapped to a specified value.

Table of Contents

1. Introduction
2. replace Method Syntax
3. Examples
   • Replacing Values Conditionally
   • Handling Non-Matching Values
4. Real-World Use Case
   • Example: Updating User Status
5. Conclusion

Introduction

The LinkedHashMap.replace(K key, V oldValue, V newValue) method is a member of the LinkedHashMap class in Java. It allows you to replace the value for a specific key only if the key is currently mapped to a specified value. This method is useful for conditional updates where the update should only occur if the current value matches the expected old value.

replace() Method Syntax

The syntax for the replace method is as follows:

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

• The method takes three parameters:
  • key of type K, which represents the key whose 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 true if the value was replaced, and false otherwise.

Examples

Replacing Values Conditionally

The replace method can be used to replace values in a LinkedHashMap only if the current value matches the expected old value.

Example

import java.util.LinkedHashMap;

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

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

        // Replacing value conditionally
        boolean isReplaced = people.replace("Priya", 30, 31);

        // Printing the result of the replacement and the LinkedHashMap
        System.out.println("Was the value replaced? " + isReplaced);
        System.out.println("LinkedHashMap after replacement: " + people);
    }
}

Output:

Was the value replaced? true
LinkedHashMap after replacement: {Ravi=25, Priya=31, Vijay=35}

Handling Non-Matching Values

The replace method returns false if the current value does not match the expected old value.

Example

import java.util.LinkedHashMap;

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

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

        // Attempting to replace value with a non-matching old value
        boolean isReplaced = people.replace("Priya", 29, 31);

        // Printing the result of the replacement and the LinkedHashMap
        System.out.println("Was the value replaced? " + isReplaced);
        System.out.println("LinkedHashMap after attempt: " + people);
    }
}

Output:

Was the value replaced? false
LinkedHashMap after attempt: {Ravi=25, Priya=30, Vijay=35}

Real-World Use Case

Example: Updating User Status

A common real-world use case for LinkedHashMap.replace(K key, V oldValue, V newValue) is updating user status in an application only if the current status matches an expected value. For example, let's consider a scenario where user statuses are stored in a LinkedHashMap, and we want to update the status only if the current status is "inactive".

Example

import java.util.LinkedHashMap;

public class UpdateUserStatus {
    public static void main(String[] args) {
        // Creating a LinkedHashMap to store user statuses
        LinkedHashMap<String, String> userStatuses = new LinkedHashMap<>();

        // Adding user statuses to the LinkedHashMap
        userStatuses.put("Ravi", "active");
        userStatuses.put("Priya", "inactive");
        userStatuses.put("Vijay", "active");

        // Updating status conditionally
        boolean isUpdated = userStatuses.replace("Priya", "inactive", "active");

        // Printing the result of the update and the updated user statuses
        System.out.println("Was the status updated? " + isUpdated);
        System.out.println("Updated User Statuses: " + userStatuses);
    }
}

Output:

Was the status updated? true
Updated User Statuses: {Ravi=active, Priya=active, Vijay=active}

In this example, LinkedHashMap.replace(K key, V oldValue, V newValue) is used to update user statuses conditionally, demonstrating how to handle conditional updates based on the current value.

Conclusion

The LinkedHashMap.replace(K key, V oldValue, V newValue) method in Java provides a way to conditionally replace the value associated with a specific key. By understanding how to use this method, you can ensure that updates occur only when the current value matches an expected old value, making it a versatile tool for data management in your Java applications.