Java ConcurrentHashMap replace() Method

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

Table of Contents

1. Introduction
2. replace Method Syntax
3. Examples
   • Replacing Values in a ConcurrentHashMap
   • Conditional Replace
4. Real-World Use Case
   • Example: Updating User Session States
5. Conclusion

Introduction

The ConcurrentHashMap.replace() method is a member of the ConcurrentHashMap class in Java. It allows you to replace the value associated with a specific key. The ConcurrentHashMap class is part of the java.util.concurrent package, designed for high concurrency and scalability.

replace() Method Syntax

There are two variations of the replace method:

Basic Replace

public V replace(K key, V value)

• The method takes two parameters:
  • key of type K, which represents the key whose 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 key, or null if there was no mapping for the key.

Conditional Replace

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 value expected to be associated with the key.
  • newValue of type V, which represents the new value to be associated with the key.
• The method returns true if the value was replaced, false otherwise.

Examples

Replacing Values in a ConcurrentHashMap

The basic replace method can be used to replace the value associated with a key in a ConcurrentHashMap.

Example

import java.util.concurrent.ConcurrentHashMap;

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

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

        // Replacing the value for an existing key
        Integer previousValue = people.replace("Priya", 32);

        // Printing the results
        System.out.println("Previous value for 'Priya': " + previousValue);
        System.out.println("ConcurrentHashMap: " + people);
    }
}

Output:

Previous value for 'Priya': 30
ConcurrentHashMap: {Ravi=25, Priya=32, Vijay=35}

Conditional Replace

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

Example

import java.util.concurrent.ConcurrentHashMap;

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

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

        // Replacing the value for an existing key conditionally
        boolean isReplaced = people.replace("Priya", 30, 32);

        // Printing the results
        System.out.println("Was 'Priya' replaced? " + isReplaced);
        System.out.println("ConcurrentHashMap: " + people);
    }
}

Output:

Was 'Priya' replaced? true
ConcurrentHashMap: {Ravi=25, Priya=32, Vijay=35}

Real-World Use Case

Example: Updating User Session States

A common real-world use case for ConcurrentHashMap is managing user session data and updating session states.

Example

import java.util.concurrent.ConcurrentHashMap;

public class UserSessionStore {
    public static void main(String[] args) {
        // Creating a ConcurrentHashMap to manage user sessions
        ConcurrentHashMap<String, String> userSessions = new ConcurrentHashMap<>();

        // Adding user sessions to the ConcurrentHashMap
        userSessions.put("Ravi", "Active");
        userSessions.put("Priya", "Inactive");
        userSessions.put("Vijay", "Active");

        // Updating a session state
        userSessions.replace("Priya", "Active");

        // Conditionally updating a session state
        boolean isSessionUpdated = userSessions.replace("Vijay", "Active", "Inactive");

        // Printing the results
        System.out.println("Is Vijay's session state updated? " + isSessionUpdated);
        System.out.println("User Sessions: " + userSessions);
    }
}

Output:

Is Vijay's session state updated? true
User Sessions: {Ravi=Active, Priya=Active, Vijay=Inactive}

In this example, ConcurrentHashMap is used to manage user session data, and the replace method is employed to update session states in a thread-safe manner.

Conclusion

The ConcurrentHashMap.replace() method in Java provides a way to replace the value associated with a specific key in a ConcurrentHashMap in a thread-safe manner. By understanding how to use this method, you can efficiently manage collections of key-value pairs in your Java applications, especially in concurrent environments. The method allows you to handle both basic and conditional replacements, making it a versatile tool for data management in multi-threaded scenarios.