LinkedHashMap

LinkedHashMap 是 Java 中的一种集合类，它是 HashMap 的一个子类，除了具有 HashMap 的所有特性外，还维护了一个双向链表来记录元素的插入顺序。以下是 LinkedHashMap 的主要特性和应用场景：

LinkedHashMap 的主要特性

1. 有序性：

   • LinkedHashMap 维护着一个双向链表，记录所有元素的插入顺序或访问顺序（基于配置）。
   • 默认情况下，LinkedHashMap 按照元素的插入顺序进行迭代。
   • 可以通过构造函数参数来指定是否按访问顺序（最近访问的元素会移到链表的末尾）进行迭代。

2. 快速访问：

   • 像 HashMap 一样，LinkedHashMap 依然保持了较快的查找、插入和删除操作的时间复杂度 O(1)。

3. 基于链表的顺序维护：

   • LinkedHashMap 通过维护一个链表来记录元素的顺序，因此迭代顺序稳定。

构造函数

LinkedHashMap 提供了一些构造函数，可以根据需要进行初始化：

public LinkedHashMap() {
    super();
}

public LinkedHashMap(int initialCapacity) {
    super(initialCapacity);
}

public LinkedHashMap(int initialCapacity, float loadFactor) {
    super(initialCapacity, loadFactor);
}

public LinkedHashMap(int initialCapacity, float loadFactor, boolean accessOrder) {
    super(initialCapacity, loadFactor);
    this.accessOrder = accessOrder;
}

• initialCapacity：初始容量。
• loadFactor：负载因子。
• accessOrder：如果为 true，则按访问顺序进行迭代；如果为 false，则按插入顺序进行迭代。

应用场景

1. 缓存实现：

   • LinkedHashMap 非常适合用于实现简单的缓存机制。通过设置 accessOrder 为 true，可以实现 LRU（最近最少使用）缓存。

   • 例如，可以通过重写 removeEldestEntry 方法来实现自动删除最老的缓存项：

     public class LRUCache<K, V> extends LinkedHashMap<K, V> {
         private final int maxSize;
     
         public LRUCache(int maxSize) {
             super(maxSize, 0.75f, true);
             this.maxSize = maxSize;
         }
     
         @Override
         protected boolean removeEldestEntry(Map.Entry<K, V> eldest) {
             return size() > maxSize;
         }
     }
     

2. 需要有序输出的场景：

   • 在需要保持元素插入顺序的场景中，例如在处理 JSON 数据时保持字段顺序，LinkedHashMap 非常有用。

3. 频率统计：

   • 通过按访问顺序迭代，可以轻松实现频率统计，追踪元素的使用频率和最近使用时间。

示例代码

下面是一个简单的使用 LinkedHashMap 的例子：

import java.util.LinkedHashMap;
import java.util.Map;

public class LinkedHashMapExample {
    public static void main(String[] args) {
        LinkedHashMap<Integer, String> map = new LinkedHashMap<>();

        map.put(1, "one");
        map.put(2, "two");
        map.put(3, "three");

        // 按插入顺序输出
        for (Map.Entry<Integer, String> entry : map.entrySet()) {
            System.out.println(entry.getKey() + " = " + entry.getValue());
        }

        // 访问一下元素
        map.get(2);

        // 再次按插入顺序输出
        System.out.println("After accessing key 2:");
        for (Map.Entry<Integer, String> entry : map.entrySet()) {
            System.out.println(entry.getKey() + " = " + entry.getValue());
        }
    }
}

以上代码展示了如何使用 LinkedHashMap 并输出按插入顺序的元素。如果你希望按照访问顺序进行输出，只需在创建 LinkedHashMap 时指定 accessOrder 为 true 即可：

LinkedHashMap<Integer, String> map = new LinkedHashMap<>(16, 0.75f, true);

关键机制

1. 双向链表：

   • 每个条目不仅包含键和值，还包含两个指针：before 和 after，分别指向前一个条目和后一个条目。这些指针将所有条目连接起来形成一个双向链表。

2. 插入顺序：

   • 默认情况下，LinkedHashMap 按照元素的插入顺序维护双向链表。每当一个新的条目被插入时，它会被添加到链表的末尾。

3. 访问顺序（可选）：

   • LinkedHashMap 也可以按照访问顺序维护双向链表，这需要在构造函数中将 accessOrder 参数设置为 true。当一个条目被访问时（通过 get 方法或其他访问方式），该条目会被移动到链表的末尾，从而更新其在链表中的位置。

LinkedHashMap 内部结构

LinkedHashMap 继承了 HashMap，并扩展了其节点结构 Node，使用了 LinkedHashMap.Entry 来取代 HashMap.Node。LinkedHashMap.Entry 额外包含了用于维护链表的 before 和 after 指针。

static class Entry<K, V> extends HashMap.Node<K, V> {
    Entry<K, V> before, after;
    Entry(int hash, K key, V value, Node<K, V> next) {
        super(hash, key, value, next);
    }
}

总结

LinkedHashMap 通过在其哈希表条目结构中增加两个指针（before 和 after），维护一个双向链表，从而保证元素的有序性。默认情况下，它按插入顺序迭代元素；如果在构造时指定 accessOrder 为 true，则按访问顺序迭代元素。这使得 LinkedHashMap 能够在特定的顺序要求下提供高效的键值对存储和访问。