Important Key Points about Java LinkedHashMap
Below are some important points about Java LinkedHashMap:
Order of elements:
Unlike HashMap, the iteration order of the elements in a LinkedHashMap is predictable.
Null Keys and Values:
Similar to HashMap, LinkedHashMap allows one null key and multiple null values.
Not Synchronized:
LinkedHashMap is not synchronized, which means it's not thread-safe. If multiple threads access a linked hash map concurrently, and at least one of the threads modifies the map structurally, it must be synchronized externally.
Performance:
The performance of LinkedHashMap can be slightly lower than HashMap due to the overhead of maintaining the linked list. But the difference is usually negligible unless you're dealing with very large numbers of entries.
Usage:
LinkedHashMap is useful in situations where you need a Map that also maintains its elements in order. This is particularly useful when you want to iterate over the keys or values of the map in a specific order that matches the order you added the elements.
Create LinkedHashMap
Here is the syntax to create an object of LinkedHashMap class:
// Creating a LinkedHashMap LinkedHashMap<String, Integer> dayNumberMapping = new LinkedHashMap<>();
Add Elements to LinkedHashMap
The put() method is used to add elements to the LinkedHashMap.
// Creating a LinkedHashMap
LinkedHashMap<String, Integer> dayNumberMapping = new LinkedHashMap<>();
// Adding new key-value pairs to the LinkedHashMap
dayNumberMapping.put("Mon", 1);
dayNumberMapping.put("Tus", 2);
dayNumberMapping.put("Wen", 3);
dayNumberMapping.put("Thu", 4);
dayNumberMapping.put("Fri", 5);
dayNumberMapping.put("Sat", 6);
System.out.println(dayNumberMapping);
Output:
{Mon=1, Tus=2, Wen=3, Thu=4, Fri=5, Sat=6, Sun=7}Access Elements from LinkedHashMap
We can access elements from a LinkedHashMap using the get() method.Here's an example with output:
import java.util.LinkedHashMap;
import java.util.Map;
public class Main {
public static void main(String[] args) {
// Create a LinkedHashMap
Map<String, Integer> students = new LinkedHashMap<>();
// Add elements to the LinkedHashMap
students.put("John", 12);
students.put("Alice", 15);
students.put("Bob", 14);
// Access elements from the LinkedHashMap
int johnAge = students.get("John");
int aliceAge = students.get("Alice");
int bobAge = students.get("Bob");
System.out.println("John's Age: " + johnAge);
System.out.println("Alice's Age: " + aliceAge);
System.out.println("Bob's Age: " + bobAge);
}
}
Output:
John's Age: 12
Alice's Age: 15
Bob's Age: 14In this example, we're using the get() method with the key of the element we want to access as the argument. This will return the value associated with that key.
Remember, if the key is not present in the map, the get() method will return null.
Remove Elements from LinkedHashMap
Removing entries from a LinkedHashMap can be done using the remove() method, which takes the key of the element to be removed as a parameter. Here is an example:
import java.util.LinkedHashMap;
import java.util.Map;
public class Main {
public static void main(String[] args) {
// Create a LinkedHashMap
Map<String, Integer> students = new LinkedHashMap<>();
// Add elements to the LinkedHashMap
students.put("John", 12);
students.put("Alice", 15);
students.put("Bob", 14);
System.out.println("Initial LinkedHashMap: " + students);
// Remove the entry with key 'Alice'
students.remove("Alice");
System.out.println("LinkedHashMap after removing Alice: " + students);
}
}
Output:
Initial LinkedHashMap: {John=12, Alice=15, Bob=14}
LinkedHashMap after removing Alice: {John=12, Bob=14}As you can see, the entry with the key "Alice" is no longer present in the LinkedHashMap after the remove() operation. If the key is not found in the LinkedHashMap, the remove() method simply does nothing and returns null.
Search Elements in LinkedHashMap
Searching for elements in a LinkedHashMap can be performed using the containsKey() and containsValue() methods.The containsKey() method is used to check if a specific key is present in the map, while the containsValue() method is used to check if a specific value is present in the map.
Here's an a complete example with output:
import java.util.LinkedHashMap;
public class Main {
public static void main(String[] args) {
// Create a LinkedHashMap
LinkedHashMap<String, Integer> map = new LinkedHashMap<>();
// Add some elements to the LinkedHashMap
map.put("One", 1);
map.put("Two", 2);
map.put("Three", 3);
// Search for a key in the LinkedHashMap
boolean exists = map.containsKey("Two");
System.out.println("Does key 'Two' exist? " + exists);
// Search for a value in the LinkedHashMap
exists = map.containsValue(3);
System.out.println("Does value '3' exist? " + exists);
}
}
Output:
Does key 'Two' exist? true
Does value '3' exist? trueIterate or Loop over a LinkedHashMap
Iterate over a LinkedHashMap using Java 8 forEach and lambda expression:
import java.util.LinkedHashMap;
import java.util.Map;
public class Main {
public static void main(String[] args) {
LinkedHashMap<String, Integer> map = new LinkedHashMap<>();
map.put("One", 1);
map.put("Two", 2);
map.put("Three", 3);
// Using Java 8 forEach and lambda expression
map.forEach((key, value) -> System.out.println("Key: " + key + ", Value: " + value));
}
}
Output:
Key: One, Value: 1
Key: Two, Value: 2
Key: Three, Value: 3Iterate over a LinkedHashMap’s entrySet using Java 8 forEach and lambda expression:
import java.util.LinkedHashMap;
import java.util.Map;
public class Main {
public static void main(String[] args) {
LinkedHashMap<String, Integer> map = new LinkedHashMap<>();
map.put("One", 1);
map.put("Two", 2);
map.put("Three", 3);
// Using Java 8 forEach and lambda expression over entrySet
map.entrySet().forEach(entry -> System.out.println("Key: " + entry.getKey() + ", Value: " + entry.getValue()));
}
}
Output:
Key: One, Value: 1
Key: Two, Value: 2
Key: Three, Value: 3Iterate over a LinkedHashMap’s entrySet using iterator():
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Map;
public class Main {
public static void main(String[] args) {
LinkedHashMap<String, Integer> map = new LinkedHashMap<>();
map.put("One", 1);
map.put("Two", 2);
map.put("Three", 3);
// Using iterator over entrySet
Iterator<Map.Entry<String, Integer>> iterator = map.entrySet().iterator();
while (iterator.hasNext()) {
Map.Entry<String, Integer> entry = iterator.next();
System.out.println("Key: " + entry.getKey() + ", Value: " + entry.getValue());
}
}
}
Output:
Key: One, Value: 1
Key: Two, Value: 2
Key: Three, Value: 3Iterate over a LinkedHashMap’s entrySet using iterator() and Java 8 forEachRemaining() method:
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Map;
public class Main {
public static void main(String[] args) {
LinkedHashMap<String, Integer> map = new LinkedHashMap<>();
map.put("One", 1);
map.put("Two", 2);
map.put("Three", 3);
// Using iterator and Java 8 forEachRemaining() method over entrySet
map.entrySet().iterator().forEachRemaining(entry -> System.out.println("Key: " + entry.getKey() + ", Value: " + entry.getValue()));
}
}
Output:
Key: One, Value: 1
Key: Two, Value: 2
Key: Three, Value: 3LinkedHashMap with User-Defined Objects
Here is an example of using a LinkedHashMap with user-defined objects. In this case, let's define a simple Person class and use it in a LinkedHashMap.
import java.util.LinkedHashMap;
import java.util.Map;
class Person {
String name;
int age;
Person(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
public class Main {
public static void main(String[] args) {
LinkedHashMap<Integer, Person> map = new LinkedHashMap<>();
// Adding elements to the map
map.put(1, new Person("Alice", 25));
map.put(2, new Person("Bob", 30));
map.put(3, new Person("Charlie", 35));
// Iterating over the map
for(Map.Entry<Integer, Person> entry : map.entrySet()) {
System.out.println("Key: " + entry.getKey() + ", Value: " + entry.getValue());
}
}
}
Output:
Key: 1, Value: Person{name='Alice', age=25}
Key: 2, Value: Person{name='Bob', age=30}
Key: 3, Value: Person{name='Charlie', age=35}Conclusion
In this article, you learned what is a LinkedHashMap, how to create a LinkedHashMap, how to add new key-value pairs to a LinkedHashMap, how to remove entries from a LinkedHashMap, how to search elements in LinkedHashMap, how to iterate over a LinkedHashMap, and how to use LinkedHashMap with user-defined objects.
Comments
Post a Comment
Leave Comment