Java LinkedHashMap containsKey() Method

The LinkedHashMap.containsKey() method in Java is used to check if a specific key exists in a LinkedHashMap.

Table of Contents

1. Introduction
2. containsKey Method Syntax
3. Examples
   • Checking Key Existence in a LinkedHashMap
4. Real-World Use Case
   • Example: User Authentication
5. Conclusion

Introduction

The LinkedHashMap.containsKey() method is a member of the LinkedHashMap class in Java. It allows you to check if a specific key is present in the map. This can be useful in scenarios where you need to verify the presence of a key before performing certain operations, such as updating or deleting an entry.

containsKey() Method Syntax

The syntax for the containsKey method is as follows:

public boolean containsKey(Object key)

• The method takes one parameter:
  • key of type Object, which represents the key to be checked.
• The method returns true if the map contains a mapping for the specified key, and false otherwise.

Examples

Checking Key Existence in a LinkedHashMap

The containsKey method can be used to check if a key exists in a LinkedHashMap.

Example

import java.util.LinkedHashMap;

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

        // Checking if certain keys exist in the LinkedHashMap
        boolean containsRavi = people.containsKey("Ravi");
        boolean containsAmit = people.containsKey("Amit");

        // Printing the results
        System.out.println("LinkedHashMap contains key 'Ravi': " + containsRavi);
        System.out.println("LinkedHashMap contains key 'Amit': " + containsAmit);
    }
}

Output:

LinkedHashMap contains key 'Ravi': true
LinkedHashMap contains key 'Amit': false

Real-World Use Case

Example: User Authentication

A common real-world use case for LinkedHashMap.containsKey() is checking if a username exists in a user database before authenticating a user. For example, let's consider a simple authentication system where usernames are stored in a LinkedHashMap.

Example

import java.util.LinkedHashMap;

public class UserAuthentication {
    public static void main(String[] args) {
        // Creating a LinkedHashMap to store usernames and passwords
        LinkedHashMap<String, String> userDatabase = new LinkedHashMap<>();

        // Adding users to the database
        userDatabase.put("Ravi", "password123");
        userDatabase.put("Priya", "securePass");
        userDatabase.put("Vijay", "myPassword");

        // Function to authenticate user
        authenticateUser(userDatabase, "Ravi", "password123");
        authenticateUser(userDatabase, "Amit", "wrongPass");
    }

    public static void authenticateUser(LinkedHashMap<String, String> userDatabase, String username, String password) {
        // Checking if the username exists in the database
        if (userDatabase.containsKey(username)) {
            // Checking if the password matches
            if (userDatabase.get(username).equals(password)) {
                System.out.println("Authentication successful for user: " + username);
            } else {
                System.out.println("Authentication failed for user: " + username + ". Incorrect password.");
            }
        } else {
            System.out.println("Authentication failed for user: " + username + ". Username not found.");
        }
    }
}

Output:

Authentication successful for user: Ravi
Authentication failed for user: Amit. Username not found.

In this example, LinkedHashMap.containsKey() is used to check if the username exists in the user database before attempting to authenticate the user.

Conclusion

The LinkedHashMap.containsKey() method in Java provides a way to check if a specific key exists in a LinkedHashMap. By understanding how to use this method, you can efficiently manage collections of key-value pairs in your Java applications, especially in scenarios where you need to verify the presence of a key before performing operations. The method allows you to check for key existence, making it a versatile tool for data management.