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

渊渟岳2025-07-14 9:56

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

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

LinkedHashMap = HashMap + LinkedList ？

就像这幅图一样？

1. Entry（节点）数据结构

1.1. HashMap.Node

java 复制代码 
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

java 复制代码 
// 头节点
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) 方法，维护双链结构的尾部插入

java 复制代码 
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) 方法，维护双链结构的尾部插入

java 复制代码 
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);方法完成节点转化

java 复制代码 
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时，插入后才需要移除头部节点

java 复制代码 
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的值。

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

3.3. 删除后

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

java 复制代码 
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. 核心方法

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

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

java 复制代码 
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);
	}
}

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

java 复制代码 
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的缓存容器，源码如下

java 复制代码 
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全栈学习路线、学习资源和面试题一条龙

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

相关推荐
渊渟岳8 天前
HashMap集合--基本操作流程的源码可视化
java集合
渊渟岳22 天前
Java集合--从本质出发理解HashMap
java集合
渊渟岳1 个月前
Java集合--LinkedList源码可视化
java集合
云边小网安1 个月前
java集合（十） ---- LinkedList 类
java·开发语言·青少年编程·java集合
云边小网安1 个月前
java集合篇（六） ---- ListIterator 接口
java·开发语言·青少年编程·java集合
渊渟岳1 个月前
Java集合源码--ArrayList的可视化操作过程
java集合
总是学不会.7 个月前
【集合】Java 8 - Stream API 17种常用操作与案例详解
java·windows·spring boot·mysql·intellij-idea·java集合
怒放的生命.9 个月前
集合框架07：LinkedList使用
java·开发语言·ide·java集合·linkedlist集合
小胖子——鑫1 年前
Java常用集合(List、Map)类型相关问题整理
java·java集合·面试解答
热门推荐
01全球最强模型Grok4，国内已可免费使用！（附教程）02KGG转MP3工具|非KGM文件|解密音频03Coze扣子平台完整体验和实践（附国内和国际版对比）04身弱武修法：玄之又玄，奇妙之门05集群聊天服务器---MySQL数据库的建立06扣子（coze）实战|我用扣子搭建了一个自动分析小红薯笔记内容的AI应用|详细步骤拆解07使用Ruby接入实时行情API教程08基于odoo17的设计模式详解---单例模式09DeepSeek各版本说明与优缺点分析10LOT: 通过逻辑增强大型语言模型的零样本Chain-of-Thought推理能力