The LinkedHashMap.containsKey()
method in Java is used to check if a specific key exists in a LinkedHashMap
.
Table of Contents
- Introduction
containsKey
Method Syntax- Examples
- Checking Key Existence in a LinkedHashMap
- Real-World Use Case
- Example: User Authentication
- 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 typeObject
, which represents the key to be checked.
- The method returns
true
if the map contains a mapping for the specified key, andfalse
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.