Java ConcurrentHashMap remove() Method

The ConcurrentHashMap.remove() method in Java is used to remove key-value pairs from a ConcurrentHashMap.

Table of Contents

1. Introduction
2. remove Method Syntax
3. Examples
   • Removing Entries from a ConcurrentHashMap
   • Conditional Removal
4. Real-World Use Case
   • Example: Removing Expired User Sessions
5. Conclusion

Introduction

The ConcurrentHashMap.remove() method is a member of the ConcurrentHashMap class in Java. It allows you to remove key-value pairs from the map. The ConcurrentHashMap class is part of the java.util.concurrent package, designed for high concurrency and scalability.

remove() Method Syntax

There are two variations of the remove method:

Basic Remove

public V remove(Object key)

• The method takes one parameter:
  • key of type Object, which represents the key to be removed.
• The method returns the value associated with the key, or null if there was no mapping for the key.

Conditional Remove

public boolean remove(Object key, Object value)

• The method takes two parameters:
  • key of type Object, which represents the key to be removed.
  • value of type Object, which represents the value expected to be associated with the key.
• The method returns true if the key-value pair was removed, false otherwise.

Examples

Removing Entries from a ConcurrentHashMap

The basic remove method can be used to remove key-value pairs from a ConcurrentHashMap.

Example

import java.util.concurrent.ConcurrentHashMap;

public class RemoveExample {
    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);

        // Removing an entry from the ConcurrentHashMap
        Integer removedValue = people.remove("Priya");

        // Printing the result of the removal
        System.out.println("Removed value for 'Priya': " + removedValue);

        // Printing the ConcurrentHashMap after removal
        System.out.println("ConcurrentHashMap: " + people);
    }
}

Output:

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

Conditional Removal

The conditional remove method can be used to remove a key-value pair only if it is currently mapped to a specified value.

Example

import java.util.concurrent.ConcurrentHashMap;

public class ConditionalRemoveExample {
    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);

        // Removing an entry from the ConcurrentHashMap conditionally
        boolean isRemoved = people.remove("Priya", 30);

        // Printing the result of the conditional removal
        System.out.println("Was 'Priya' removed? " + isRemoved);

        // Printing the ConcurrentHashMap after conditional removal
        System.out.println("ConcurrentHashMap: " + people);
    }
}

Output:

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

Real-World Use Case

Example: Removing Expired User Sessions

A common real-world use case for ConcurrentHashMap is managing user session data and removing expired sessions.

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");

        // Removing an expired session
        userSessions.remove("Priya");

        // Printing the user sessions after removal
        System.out.println("User Sessions: " + userSessions);
    }
}

Output:

User Sessions: {Vijay=Active, Ravi=Active}

In this example, ConcurrentHashMap is used to manage user session data, and the remove method is employed to remove expired sessions in a thread-safe manner.

Conclusion

The ConcurrentHashMap.remove() method in Java provides a way to remove key-value pairs from 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 removals, making it a versatile tool for data management in multi-threaded scenarios.