Java ConcurrentHashMap keys() Method

The ConcurrentHashMap.keys() method in Java is used to obtain an enumeration of the keys contained in the ConcurrentHashMap.

Table of Contents

1. Introduction
2. keys Method Syntax
3. Examples
   • Retrieving Keys from a ConcurrentHashMap
   • Iterating Over Keys Using Enumeration
4. Real-World Use Case
   • Example: Listing Usernames in a Concurrent User Store
5. Conclusion

Introduction

The ConcurrentHashMap.keys() method is a member of the ConcurrentHashMap class in Java. It provides an enumeration of the keys contained in the map. The ConcurrentHashMap class is part of the java.util.concurrent package, designed for high concurrency and scalability.

keys() Method Syntax

The syntax for the keys method is as follows:

public Enumeration<K> keys()

• The method takes no parameters.
• The method returns an Enumeration of the keys contained in the map.

Examples

Retrieving Keys from a ConcurrentHashMap

The keys method can be used to retrieve the keys from a ConcurrentHashMap.

Example

import java.util.Enumeration;
import java.util.concurrent.ConcurrentHashMap;

public class KeysExample {
    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 the enumeration of keys
        Enumeration<String> keys = people.keys();

        // Printing the keys
        System.out.println("Keys in ConcurrentHashMap:");
        while (keys.hasMoreElements()) {
            System.out.println(keys.nextElement());
        }
    }
}

Output:

Keys in ConcurrentHashMap:
Ravi
Priya
Vijay

Iterating Over Keys Using Enumeration

You can use the keys method to iterate over the keys using an Enumeration.

Example

import java.util.Enumeration;
import java.util.concurrent.ConcurrentHashMap;

public class IterateKeysExample {
    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 the enumeration of keys
        Enumeration<String> keys = people.keys();

        // Iterating over the keys
        System.out.println("Iterating over keys:");
        while (keys.hasMoreElements()) {
            String key = keys.nextElement();
            System.out.println(key);
        }
    }
}

Output:

Iterating over keys:
Ravi
Priya
Vijay

Real-World Use Case

Example: Listing Usernames in a Concurrent User Store

A common real-world use case for ConcurrentHashMap is managing user data and listing usernames.

Example

import java.util.Enumeration;
import java.util.concurrent.ConcurrentHashMap;

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

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

        // Retrieving the enumeration of usernames
        Enumeration<String> usernames = userStore.keys();

        // Printing the usernames
        System.out.println("Usernames in User Store:");
        while (usernames.hasMoreElements()) {
            System.out.println(usernames.nextElement());
        }
    }
}

Output:

Usernames in User Store:
Ravi
Priya
Vijay

In this example, ConcurrentHashMap is used to manage user data, and the keys method is employed to list usernames in a thread-safe manner.

Conclusion

The ConcurrentHashMap.keys() method in Java provides a way to obtain an enumeration of the keys contained 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 retrieve and iterate over keys, making it a versatile tool for data management in multi-threaded scenarios.