Java ConcurrentHashMap get() Method

The ConcurrentHashMap.get() method in Java is used to retrieve the value associated with a specified key from a ConcurrentHashMap.

Table of Contents

1. Introduction
2. get Method Syntax
3. Examples
   • Retrieving Entries from a ConcurrentHashMap
   • Handling Non-Existent Keys
4. Real-World Use Case
   • Example: Fetching User Session Data
5. Conclusion

Introduction

The ConcurrentHashMap.get() method is a member of the ConcurrentHashMap class in Java. It allows you to retrieve the value associated with a specified key from a ConcurrentHashMap. If the key is present, the method returns the corresponding value. If the key is not present, it returns null. 

The ConcurrentHashMap class is part of the java.util.concurrent package, designed for high concurrency and scalability.

get() Method Syntax

The syntax for the get method is as follows:

public V get(Object key)

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

Examples

Retrieving Entries from a ConcurrentHashMap

The get method can be used to retrieve values from a ConcurrentHashMap.

Example

import java.util.concurrent.ConcurrentHashMap;

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

        // Retrieving values from the ConcurrentHashMap
        Integer ageRavi = people.get("Ravi");
        Integer agePriya = people.get("Priya");

        // Printing the retrieved values
        System.out.println("Age of Ravi: " + ageRavi);
        System.out.println("Age of Priya: " + agePriya);
    }
}

Output:

Age of Ravi: 25
Age of Priya: 30

Handling Non-Existent Keys

The get method returns null if the specified key is not present in the ConcurrentHashMap.

Example

import java.util.concurrent.ConcurrentHashMap;

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

        // Attempting to retrieve a value for a non-existent key
        Integer ageVijay = people.get("Vijay");

        // Checking if the key exists and printing the result
        if (ageVijay == null) {
            System.out.println("Vijay is not present in the ConcurrentHashMap.");
        } else {
            System.out.println("Age of Vijay: " + ageVijay);
        }
    }
}

Output:

Vijay is not present in the ConcurrentHashMap.

Real-World Use Case

Example: Fetching User Session Data

A common real-world use case for ConcurrentHashMap is managing user session data in a concurrent environment, where retrieving session information efficiently is crucial.

Example

import java.util.concurrent.ConcurrentHashMap;
import java.util.Map;

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", "Session1");
        userSessions.put("Priya", "Session2");
        userSessions.put("Vijay", "Session3");
        userSessions.put("Anita", "Session4");

        // Retrieving and printing user sessions
        System.out.println("User Sessions: ");
        for (Map.Entry<String, String> entry : userSessions.entrySet()) {
            String session = userSessions.get(entry.getKey());
            System.out.println(entry.getKey() + ": " + session);
        }
    }
}

Output:

User Sessions:
Vijay: Session3
Priya: Session2
Ravi: Session1
Anita: Session4

In this example, ConcurrentHashMap is used to maintain and retrieve user session data in a thread-safe manner, ensuring that concurrent access does not lead to data inconsistency.

Conclusion

The ConcurrentHashMap.get() method in Java provides a way to retrieve the value associated with a specified key 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 existing and non-existent keys, making it a versatile tool for data retrieval in multi-threaded scenarios.