How do you implement a LinkedHashMap in Java?

Table of Contents

Introduction

A LinkedHashMap is a specific implementation of the Map interface in Java that combines the features of a HashMap and a LinkedList. It maintains the insertion order of the entries, meaning that the order in which elements are added to the map is preserved when iterating over the map. This is different from a regular HashMap, which does not guarantee any order of elements.

In this guide, we will explore how to implement a LinkedHashMap, its features, and some practical examples.

What is a LinkedHashMap?

A LinkedHashMap is a hash table and linked list implementation of the Map interface. It uses a hash table to store the map entries and a linked list to maintain the order of insertion. This combination allows the map to provide constant-time performance for basic operations such as get(), put(), and remove(), while also maintaining the order of elements.

Features of LinkedHashMap:

  • Insertion Order: The most significant feature of LinkedHashMap is that it maintains the insertion order of elements. When you iterate over the map, the entries are returned in the order they were added.
  • Efficiency: Like HashMap, LinkedHashMap offers constant-time performance for basic operations.
  • Optional Access Order: LinkedHashMap also allows maintaining the order of access rather than insertion order through a constructor option.

How to Create and Use a LinkedHashMap?

A LinkedHashMap is part of the java.util package, and it can be easily created and used. Here’s a basic implementation example:

Example 1: Creating and Using a LinkedHashMap

Output:

In the above example, the LinkedHashMap preserves the order of insertion, which is exactly how the entries are printed out.

Example 2: LinkedHashMap with Access Order

In addition to insertion order, you can create a LinkedHashMap that maintains the order in which entries are accessed. This can be useful for implementing LRU (Least Recently Used) caches, where the least recently accessed entries are removed first.

Output:

Here, the constructor LinkedHashMap<>(16, 0.75f, true) sets the map to maintain access order rather than insertion order. When you access the elements, they are reordered accordingly.

Key Methods in LinkedHashMap

The LinkedHashMap class provides several useful methods that can help in manipulating and retrieving data from the map:

  1. **put(K key, V value)**: Adds a key-value pair to the map.
  2. **get(Object key)**: Retrieves the value associated with the given key.
  3. **remove(Object key)**: Removes the entry with the specified key.
  4. **containsKey(Object key)**: Checks if the map contains the given key.
  5. **containsValue(Object value)**: Checks if the map contains the given value.
  6. **size()**: Returns the number of key-value pairs in the map.
  7. **clear()**: Removes all entries from the map.
  8. **keySet()**: Returns a set view of the keys in the map.
  9. **values()**: Returns a collection view of the values in the map.

Example 3: Using Methods in LinkedHashMap

Output:

Advantages of Using LinkedHashMap

  1. Insertion Order: The map maintains the order of entries based on the sequence in which they were added.
  2. Efficient Access: Like HashMap, LinkedHashMap provides constant-time performance for most operations.
  3. Flexibility: You can choose whether to maintain insertion order or access order by passing a true value for the accessOrder parameter in the constructor.
  4. LRU Cache Implementation: The access order feature makes LinkedHashMap suitable for implementing an LRU (Least Recently Used) cache.

Conclusion

The LinkedHashMap is a versatile and powerful class in Java that combines the best features of HashMap (constant-time performance) and LinkedList (maintaining the order of entries). You can use it when you need a Map implementation that preserves the order of insertion or access. The ability to maintain both insertion order and access order makes it an excellent choice for scenarios like implementing caches or maintaining predictable iteration behavior.

By understanding how to create and use a LinkedHashMap, you can efficiently manage key-value pairs with the added benefit of ordering, which sets it apart from other map implementations like HashMap and TreeMap.

Share
Similar Questions