HashMap居然可以和它直接合体？？？

LinkedHashMap集合继承于HashMap，学习LinkedHashMap重点对比 LinkedHashMap 与 HashMap 的异同

特别强调两者的 Entry（节点）数据结构、数据结构的不同带来的特性差异、HashMap 的后置处理机制及最少访问删除策略。

LinkedHashMap = HashMap + LinkedList ？

就像这幅图一样？

1. Entry（节点）数据结构

1.1. HashMap.Node

static class Node<K,V> implements Map.Entry<K,V> {
    final int hash;
    final K key;
    V value;
    Node<K,V> next;
    // … 构造、getKey/getValue/setValue、equals/hashCode 等 …
}

字段说明：hash：key 的哈希值，key、value：存储的键值对，next：链表或树化时的链表指针。

1.2. LinkedHashMap.Entry

// 头节点
transient LinkedHashMap.Entry<K,V> head;
// 尾节点
transient LinkedHashMap.Entry<K,V> tail;
// 节点类
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);
    }
}

新增字段说明：before、after：维护插入/访问顺序的双向链表；

链表头尾：在 LinkedHashMap 中，维护一个 head 和 tail 指针，插入时追加到尾部。

LinkedHashMap 数据结构就像它的名称一样Linked + HashMap，它是在HashMap的基础上，维护了一个双向链表。这个双向链表就像LinkedList一样，可以维护节点插入的顺序。

LinkedHashMap 数据结构是两种形态共存的数据结构

• 你可以忽略双向链表，把它看做普通的HashMap；
• 也可以忽略HashMap，把它看作是双向链表。

如果你不想使用LinkedHashMap，但又想要维护HashMap的插入顺序，那你可以在HashMap.put元素后，同时将该元素保存到LinkedList.add集合，但这样就需要你确保集合一致性，比如插入和删除。这么想想，还不如直接用LinkedHashMap集合较为稳妥。

其实LinkedHashMap 一部分源码为的就是维护HashMap与双向链表的一致性，及操作过程做的一些扩展。比如：节点创建时的双向链表尾部插入和HashMap的后置处理。

1.3. 两者对比

特性	HashMap	LinkedHashMap
底层数据结构	数组 + 链表/红黑树	数组 + 链表/红黑树 + 双向链表
迭代顺序	不保证顺序	按插入顺序（或访问顺序，可选）
内存开销	较小	较大（每个节点额外维护链表指针）
适用场景	一般的键值存取	需要按插入或访问顺序遍历 (如 LRU 缓存)

1.4. 详细的数据结构案例

通过下面的案例图，清楚地看见每个节点的指向。

假设插入顺序为：22、23、45、89、25、38、49、28

插入完成后的数据结构如图，

图中信息含义： 当前节点信息只显示key值，next为下一个映射冲突节点；before为双链结构的上一节点，after为双链结构的下一节点；绿色虚线是整个LinkedHashMap的双链结构的连接关系。

可以清楚地看到，相比HashMap每个节点都需要多维护before和after节点，LinkedHashMap也就需要更多的空间。

2. 节点创建和转化重写

2.1. 创建Entry节点

链表节点创建的同时，通过linkNodeLast(p) 方法，维护双链结构的尾部插入

Node<K,V> newNode(int hash, K key, V value, Node<K,V> e) {
	LinkedHashMap.Entry<K,V> p =
		new LinkedHashMap.Entry<K,V>(hash, key, value, e);
	linkNodeLast(p);
	return p;
}

2.2. 树节点创建

红黑树节点创建的同时，通过linkNodeLast(p) 方法，维护双链结构的尾部插入

TreeNode<K,V> newTreeNode(int hash, K key, V value, Node<K,V> next) {
	TreeNode<K,V> p = new TreeNode<K,V>(hash, key, value, next);
	linkNodeLast(p);
	return p;
}

2.3. 节点转化

树节点转化为Entry节点和Entry节点转化树节点都做了重写，通过transferLinks(q, t);方法完成节点转化

Node<K,V> replacementNode(Node<K,V> p, Node<K,V> next) {
	LinkedHashMap.Entry<K,V> q = (LinkedHashMap.Entry<K,V>)p;
	LinkedHashMap.Entry<K,V> t =
		new LinkedHashMap.Entry<K,V>(q.hash, q.key, q.value, next);
	transferLinks(q, t);
	return t;
}

TreeNode<K,V> replacementTreeNode(Node<K,V> p, Node<K,V> next) {
	LinkedHashMap.Entry<K,V> q = (LinkedHashMap.Entry<K,V>)p;
	TreeNode<K,V> t = new TreeNode<K,V>(q.hash, q.key, q.value, next);
	transferLinks(q, t);
	return t;
}

这些都是多态的简单应用，HashMap 引用指向不同的实例化子类，实现不同的功能。

3. HashMap 的后置处理（post-processing）

HashMap 本身在节点插入、访问、删除后并不做额外操作。LinkedHashMap 则通过重写以下钩子方法，在插入、访问或删除时维护自己的双链表结构。

3.1. 插入后

仅在evict=true 并且removeEldestEntry(first)==true时，插入后才需要移除头部节点

void afterNodeInsertion(boolean evict) { // possibly remove eldest
	LinkedHashMap.Entry<K,V> first;
	if (evict && (first = head) != null && removeEldestEntry(first)) {
		K key = first.key;
		removeNode(hash(key), key, null, false, true);
	}
}

3.2. 访问后

仅在 accessOrder = true 时，访问后需调整顺序；需要在LinkedHashMap 的构造方法中设定accessOrder的值。

void afterNodeAccess(Node<K,V> e) {
    LinkedHashMap.Entry<K,V> p = (LinkedHashMap.Entry<K,V>)e;
    // 将 p 移到双向链表尾部
    moveNodeToLast(p);
}

3.3. 删除后

只要节点作删除，LinkedHashMap集合就必须删除双链表上的Entry 节点

void afterNodeRemoval(Node<K,V> e) {
    // 将 e 从双向链表中摘除
    unlinkNode((LinkedHashMap.Entry<K,V>)e);
}

这三步合称为 后置处理，保证在 put、get、remove 等操作时，链表结构的正确维护。

但是、

为什么LinkedHashMap集合在插入完成后，需要多做一步删除头节点的操作呢？

为什么访问完成后需要将访问节点移动到双链表的尾部呢？

4. 最少访问删除策略

为什么是 LinkedHashMap 而不是 HashMap：

LinkedHashMap 在 HashMap 基础上，增加了 双向链表，用来记录：插入顺序（默认）或访问顺序（accessOrder = true 时）

这就可以实现：记录最近访问的节点（最近访问的放到链表尾部）；删除最久未访问的节点（链表头）

4.1. 核心方法

protected boolean removeEldestEntry(Map.Entry<K,V> eldest) {
    return false; // 默认不删除
}

这是一个 钩子，这个钩子removeEldestEntry(first) 在插入后缀处理中调用，LinkedHashMap 的源码如下：

void afterNodeInsertion(boolean evict) { // possibly remove eldest
	LinkedHashMap.Entry<K,V> first;
	if (evict && (first = head) != null && removeEldestEntry(first)) {
		K key = first.key;
		removeNode(hash(key), key, null, false, true);
	}
}

你可以自己重写，制定属于自己的处理策略：

LinkedHashMap<K,V> lru = new LinkedHashMap<K,V>(16, 0.75f, true) {
    protected boolean removeEldestEntry(Map.Entry<K,V> eldest) {
        return size() > 100; // 超过 100 个就删除最老的
    }
};

当每次 put 后：afterNodeInsertion 调用 removeEldestEntry，如果返回 true，就从链表头删除最老节点

总结：

LinkedHashMap 用 removeEldestEntry + accessOrder=true 可实现简单 LRU 缓存。

HashMap 不自带任何访问追踪或自动删除机制，必须由使用者自己实现。

4.2. LRU缓存例子

LRU 缓存（Least Recently Used Cache，最近最少使用缓存）是一种常用的 缓存淘汰策略，它的核心思想是：

如果数据最近被访问过，那么将来被访问的可能性也更高；反之则淘汰。

规定固定大小为4的缓存容器，源码如下

public class LRUDemo {
    public static void main(String[] args) {
        // 指定只能缓存四个数据
        LinkedHashMap<String, String> linkedHashMap = new LinkedHashMap<>(16, 0.75f, true) {
            protected boolean removeEldestEntry(Map.Entry<String, String> eldest) {
                return size() > 4;
            }
        };

        linkedHashMap.put("A","1");
        linkedHashMap.put("B","2");
        linkedHashMap.put("C","3");
        linkedHashMap.put("D","4");
        printOrder(linkedHashMap);
        linkedHashMap.get("B"); // B 被访问，移到末尾
        printOrder(linkedHashMap);
        linkedHashMap.put("E","5");   // 淘汰最老的 A
        printOrder(linkedHashMap);
    }
    public static void printOrder(LinkedHashMap<String, String> linkedHashMap ) {
        System.out.print("数据结构：" + "\n[head]");
        for (Map.Entry<String, String> entry : linkedHashMap.entrySet()) {
            System.out.print(" ⇄ " + entry.getKey());
        }
        System.out.println(" ⇄ [tail]\n");
    }
}

执行输出结果如下：

数据结构：

[head] ⇄ A ⇄ B ⇄ C ⇄ D ⇄ [tail]

数据结构：

[head] ⇄ A ⇄ C ⇄ D ⇄ B ⇄ [tail]

数据结构：

[head] ⇄ C ⇄ D ⇄ B ⇄ E ⇄ [tail]

5. HashMap与LinkedHashMap区别汇总

对比维度	HashMap	LinkedHashMap
节点类型	HashMap.Node	LinkedHashMap.Entry（继承自 HashMap.Node）
顺序保证	无	按插入顺序或访问顺序
额外字段	next	next + before + after
内存消耗	较低	较高（每个节点多两个引用）
put 后置处理	无	afterNodeInsertion（链表尾部插入 + 可选淘汰）
get 后置处理	无	afterNodeAccess（访问时链表重排序，仅 accessOrder = true）
remove 后置处理	无	afterNodeRemoval（从链表中摘除）
用途	高效快速随机存取	需要遍历顺序、实现 LRU 缓存、保持可预测迭代顺序

通过上述对比，可以看出 LinkedHashMap 只是对 HashMap 的轻量增强：

1. 核心额外逻辑：在每次增删改查操作后，钩入双向链表维护；
2. 额外空间开销：每个节点多俩指针；
3. 功能收益：可提供插入顺序或访问顺序的迭代、可实现基于访问顺序的缓存淘汰（如 LRU）。

6. 总结

LinkedHashMap集合继承于HashMap，重点对比 LinkedHashMap 与 HashMap 不同的数据结构的带来的特性差异；为什么需要LinkedHashMap这种两种形态共存的数据结构；以及通过HashMap 的后置处理机制轻松实现数据结构的功能扩展；并且对LinkedHashMap最少访问删除策略LRU做了简单案例演示。

往期推荐

分类	往期文章
Java集合原理	HashMap集合–基本操作流程的源码可视化 Java集合–HashMap底层原理可视化，秒懂扩容、链化、树化 Java集合–从本质出发理解HashMap Java集合–LinkedList源码可视化 Java集合源码–ArrayList的可视化操作过程
设计模式秘籍 （已全部开源）	掌握设计模式的两个秘籍 往期设计模式文章的：设计模式
软件设计师	软考中级–软件设计师毫无保留的备考分享通过软考后却领取不到实体证书？ 2023年下半年软考考试重磅消息
Java学习路线 和相应资源	Java全栈学习路线、学习资源和面试题一条龙

原创不易，觉得还不错的，三连支持：点赞、分享、推荐↓

来源链接：https://www.cnblogs.com/dennyLee2025/p/18983432