The LinkedHashMap.remove(Object key)
method in Java is used to remove the mapping for a specified key from a LinkedHashMap
if it is present.
Table of Contents
- Introduction
remove
Method Syntax- Examples
- Removing Entries from a LinkedHashMap
- Handling Non-Existent Keys
- Real-World Use Case
- Example: Removing Inactive User Sessions
- Conclusion
Introduction
The LinkedHashMap.remove(Object key)
method is a member of the LinkedHashMap
class in Java. It allows you to remove the mapping for a specified key from the LinkedHashMap
. If the key is found and the mapping is removed, the method returns the value that was associated with the key. If the key is not found, the method returns null
.
remove() Method Syntax
The syntax for the remove
method is as follows:
public V remove(Object key)
- The method takes one parameter:
key
of typeObject
, which represents the key whose mapping is to be removed.
- The method returns the value associated with the specified key, or
null
if the map contains no mapping for the key.
Examples
Removing Entries from a LinkedHashMap
The remove
method can be used to remove key-value pairs from a LinkedHashMap
.
Example
import java.util.LinkedHashMap;
public class RemoveExample {
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);
// Removing an entry from the LinkedHashMap
Integer removedValue = people.remove("Priya");
// Printing the removed value and the LinkedHashMap after removal
System.out.println("Removed value: " + removedValue);
System.out.println("LinkedHashMap after removal: " + people);
}
}
Output:
Removed value: 30
LinkedHashMap after removal: {Ravi=25, Vijay=35}
Handling Non-Existent Keys
The remove
method returns null
if the specified key is not found in the LinkedHashMap
.
Example
import java.util.LinkedHashMap;
public class NonExistentKeyExample {
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);
// Attempting to remove a non-existent key from the LinkedHashMap
Integer removedValue = people.remove("Amit");
// Checking if the key was found and printing the result
if (removedValue == null) {
System.out.println("Key 'Amit' does not exist in the LinkedHashMap.");
} else {
System.out.println("Removed value: " + removedValue);
}
}
}
Output:
Key 'Amit' does not exist in the LinkedHashMap.
Real-World Use Case
Example: Removing Inactive User Sessions
A common real-world use case for LinkedHashMap.remove(Object key)
is removing inactive user sessions from a session manager. For example, let’s consider a scenario where user sessions are stored in a LinkedHashMap
, and we need to remove sessions that have been inactive for a certain period.
Example
import java.util.LinkedHashMap;
import java.util.Map;
public class SessionManager {
public static void main(String[] args) {
// Creating a LinkedHashMap to store user sessions
LinkedHashMap<String, String> userSessions = new LinkedHashMap<>();
// Adding some user sessions
userSessions.put("Ravi", "Active");
userSessions.put("Priya", "Inactive");
userSessions.put("Vijay", "Active");
// Removing inactive user sessions
String removedSession = userSessions.remove("Priya");
// Printing the removed session status and the updated session map
System.out.println("Removed session status: " + removedSession);
System.out.println("Updated User Sessions: " + userSessions);
}
}
Output:
Removed session status: Inactive
Updated User Sessions: {Ravi=Active, Vijay=Active}
In this example, LinkedHashMap.remove(Object key)
is used to remove inactive user sessions, demonstrating how to handle both the removal of existing entries and checking for the presence of keys.
Conclusion
The LinkedHashMap.remove(Object key)
method in Java provides a way to remove the mapping for a specified key from a LinkedHashMap
. By understanding how to use this method, you can efficiently manage collections of key-value pairs in your Java applications. The method allows you to handle both the removal of existing entries and checking for the presence of keys, making it a versatile tool for data management.