Java的LinkedHashMap 源码解析

最新推荐文章于 2024-12-04 08:30:00 发布
原创 最新推荐文章于 2024-12-04 08:30:00 发布 · 1k 阅读 · 11 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java #开发语言

LinkedHashMap 是 Java 中的一种有序 Map，它扩展了 HashMap，提供了有序的元素存储方式。在 LinkedHashMap 中，元素的有序性可以按照插入顺序或访问顺序来维护，而这个有序性是通过维护一个双向链表来实现的，这也是实现 LRU Cache 功能的基础。在接下来的源码解析中，我们将深入探讨 LinkedHashMap 的实现。

在这里插入图片描述

主要结论

在开始分析源码之前，让我们首先总结一些关键结论：

  1. LinkedHashMap 继承了 HashMap，因此它的底层数据结构与 HashMap 相同，都是由数组、链表或红黑树组成，同时也使用相同的扩容机制。

    /**
 * 用指定的初始容量、加载因子和排序模式构造一个空的LinkedHashMap实例。
 *
 * @param initialCapacity 初始容量
 * @param loadFactor      加载因子
 * @param accessOrder     排序模式 - <tt>true</tt> 表示按访问顺序，<tt>false</tt> 表示按插入顺序
 * @throws IllegalArgumentException 如果初始容量为负数或加载因子为非正数
 */
public LinkedHashMap(int initialCapacity, float loadFactor, boolean accessOrder) {
    // 调用 HashMap 的构造方法，继承了 HashMap 的底层数据结构和扩容机制
    super(initialCapacity, loadFactor);
    this.accessOrder = accessOrder;
}

  2. LinkedHashMap 使用双向链表来维护数据的顺序，与 HashMap 的拉链式存储方式不同。

    /*
 * 实现说明。此类的先前版本在内部结构上略有不同。由于超类 HashMap 现在对一些节点使用树结构，类 LinkedHashMap.Entry 现在被视为中介节点类，也可以转换为树形结构。在当前上下文中，此类的名称 LinkedHashMap.Entry 在几个方面都有点令人困惑，但不能更改。否则，即使它不被导出到此包外，已知一些现有源代码依赖于调用 removeEldestEntry 时的符号解析特例规则，以抑制由于模糊的用法而导致的编译错误。因此，我们保留名称以保持编译性不变。
 *
 * 节点类的更改还需要使用两个字段（head、tail）而不是指向头节点的指针来维护双向链接的前后列表。该类以前也使用了不同风格的回调方法来进行访问、插入和删除。
 */

/**
 * 用于常规 LinkedHashMap 条目的 HashMap.Node 子类。
 */
static class Entry<K,V> extends HashMap.Node<K,V> {
    Entry<K,V> before, after;
    Entry(int hash, K key, value, Node<K,V> next) {
        super(hash, key, value, next);
    }
}

  3. LinkedHashMap 存储顺序与添加顺序一致，但也可以通过 accessOrder 参数决定是否在访问元素时移动元素，以实现 LRU 缓存功能。

    /**
 * 在删除元素之后，将元素从双向链表中删除
 */
void afterNodeRemoval(Node<K,V> e) { // unlink
        LinkedHashMap.Entry<K,V> p =
            (LinkedHashMap.Entry<K,V>)e, b = p.before, a = p.after;
        p.before = p.after = null;
        if (b == null)
            head = a;
        else
            b.after = a;
        if (a == null)
            tail = b;
        else
            a.before = b;
}

/**
 * 在访问元素之后，将该元素放到双向链表的尾巴处
 */
void afterNodeAccess(Node<K,V> e) { // move node to last
        LinkedHashMap.Entry<K,V> last;
        if (accessOrder && (last = tail) != e) {
            LinkedHashMap.Entry<K,V> p =
                (LinkedHashMap.Entry<K,V>)e, b = p.before, a = p.after;
            p.after = null;
            if (b == null)
                head = a;
            else
                b.after = a;
            if (a != null)
                a.before = b;
            else
                last = b;
            if (last == null)
                head = p;
            else {
                p.before = last;
                last.after = p;
            }
            tail = p;
            ++modCount;
        }
}

内部结构

LinkedHashMap 内部类 Entry 继承自 HashMap 的 Node，同时增加了 “前继节点” 和 “后继节点” 来支持双向链表的特性。此外，LinkedHashMap 中还有两个重要的成员变量：

  • head：记录 LinkedHashMap 的头节点。
  • tail：记录 LinkedHashMap 的尾节点。
  • accessOrder：表示是否根据访问顺序进行排序，如果 accessOrder 为 true，LinkedHashMap 会在元素被访问时将其移至链表末尾，实现 LRU 缓存。

内部方法

LinkedHashMap 定义了一些私有的内部方法，用于操作双向链表：

  • linkNodeLast(LinkedHashMap.Entry<K,V> p)：将元素连接到链表尾部。

    /**
 * 将元素连接到链表尾部。
 *
 * @param p 要连接到链表尾部的元素
 */
private void linkNodeLast(LinkedHashMap.Entry<K,V> p) {
    LinkedHashMap.Entry<K,V> last = tail;
    tail = p;
    if (last == null)
        head = p;
    else {
        p.before = last;
        last.after = p;
    }
}

  • transferLinks(LinkedHashMap.Entry<K,V> src, LinkedHashMap.Entry<K,V> dst)：将一个节点的前继节点和后继节点链接到另一个节点。

    /**
 * 将一个节点的前继节点和后继节点链接到另一个节点。
 *
 * @param src 要转移链接的源节点
 * @param dst 目标节点
 */
private void transferLinks(LinkedHashMap.Entry<K,V> src,
                           LinkedHashMap.Entry<K,V> dst) {
    LinkedHashMap.Entry<K,V> b = dst.before = src.before;
    LinkedHashMap.Entry<K,V> a = dst.after = src.after;
    if (b == null)
        head = dst;
    else
        b.after = dst;
    if (a == null)
        tail = dst;
    else
        a.before = dst;
}

  • afterNodeRemoval(Node<K,V> e)：在删除元素后，将元素从双向链表中删除。

    /**
 * 在删除元素后，将元素从双向链表中删除。
 *
 * @param e 要删除的元素
 */
void afterNodeRemoval(Node<K,V> e) { 
    LinkedHashMap.Entry<K,V> p =
        (LinkedHashMap.Entry<K,V>)e, b = p.before, a = p.after;
    p.before = p.after = null;
    if (b == null)
        head = a;
    else
        b.after = a;
    if (a == null)
        tail = b;
    else
        a.before = b;
}

  • afterNodeInsertion(boolean evict)：在插入元素后，可能删除最老的元素。

    /**
 * 在插入元素后，可能删除最老的元素。
 *
 * @param evict 如果为 true，可能会删除最老的元素
 */
void afterNodeInsertion(boolean evict) { // 可能删除最老的元素
    LinkedHashMap.Entry<K,V> first;
    if (evict && (first = head) != null && removeEldestEntry(first)) {
        K key = first.key;
        removeNode(hash(key), key, null, false, true);
    }
}

  • afterNodeAccess(Node<K,V> e)：在访问元素后，将元素放到链表的尾部。

    /**
 * 在访问元素后，将元素放到链表的尾部。
 *
 * @param e 要移动的元素
 */
void afterNodeAccess(Node<K,V> e) { // 将节点移动到最后
    LinkedHashMap.Entry<K,V> last;
    if (accessOrder && (last = tail) != e) { // 如果 accessOrder 与 (last = tail) != e 为 true
        LinkedHashMap.Entry<K,V> p =
            (LinkedHashMap.Entry<K,V>)e, b = p.before, a = p.after;
        p.after = null;
        if (b == null)
            head = a;
        else
            b.after = a;
        if (a != null)
            a.before = b;
        else
            last = b;
        if (last == null)
            head = p;
        else {
            p.before = last;
            last.after = p;
        }
        tail = p;
        ++modCount;
    }
}

构造方法

LinkedHashMap 提供了多个构造方法，包括：

  • LinkedHashMap(int initialCapacity, float loadFactor)：指定初始容量和加载因子的构造方法。

    /**
 * 指定初始容量和加载因子的构造方法。
 *
 * @param initialCapacity 初始容量
 * @param loadFactor 加载因子
 */
public LinkedHashMap(int initialCapacity, float loadFactor) {
    super(initialCapacity, loadFactor);
    accessOrder = false;
}

  • LinkedHashMap(int initialCapacity)：指定初始容量的构造方法。

    /**
 * 指定初始容量的构造方法。
 *
 * @param initialCapacity 初始容量
 */
public LinkedHashMap(int initialCapacity) {
    super(initialCapacity);
    accessOrder = false;
}

  • LinkedHashMap()：默认构造方法。

    /**
 * 默认构造方法。
 */
public LinkedHashMap() {
    super();
    accessOrder = false;
}

  • LinkedHashMap(Map<? extends K, ? extends V> m)：使用现有映射初始化构造方法。

    /**
 * 使用现有映射初始化构造方法。
 *
 * @param m 要使用的映射
 */
public LinkedHashMap(Map<? extends K, ? extends V> m) {
    super();
    accessOrder = false;
    putMapEntries(m, false);
}

  • LinkedHashMap(int initialCapacity, float loadFactor, boolean accessOrder)：可以设置 accessOrder 参数以决定是否按照访问顺序排序。

    /**
 * 可以设置 accessOrder 参数以决定是否按照访问顺序排序。
 *
 * @param initialCapacity 初始容量
 * @param loadFactor 加载因子
 * @param accessOrder 如果为 true，则按照访问顺序排序；否则按照插入顺序排序
 */
public LinkedHashMap(int initialCapacity, float loadFactor, boolean accessOrder) {
    super(initialCapacity, loadFactor);
    this.accessOrder = accessOrder;
}

LinkedHashMap 的源码解析包括实现 newNode、replacementNode、newTreeNode、replacementTreeNode 等节点插入和替换的方法，以及实现 containsValue、get、getOrDefault、keySet、entrySet 等其他操作。这些方法负责在 LinkedHashMap 中维护元素的顺序和实现 LRU 缓存功能。

总结

LinkedHashMap 是一个有序的 Map，它维护元素的有序性，可以按照插入顺序或访问顺序排列元素。这个有序性是通过维护一个双向链表来实现的。另外，LinkedHashMap 提供了 accessOrder 参数来决定是否在访问元素时移动元素，以实现 LRU 缓存功能。这使得 LinkedHashMap 成为一个非常有用的数据结构，适用于需要有序性和缓存功能的场景。

《Java源码分析》：LinkedHashMap
wojiushimogui的博客
07-21 2127
《Java源码分析》：LinkedHashMap最近也即将要参加校招，因此，就准备花几天的时间专门来将我们用的比较多的集合类的源码都看下，并以写博客的形式来记录相关思路。便于以后复习。前面刚看了下HashMap类的源码，博客在这里：http://blog.youkuaiyun.com/u010412719/article/details/51980632Hashtable类的源码分析，博客在这里：http://
Java LinkedHashMap 深度解析
最新发布
记录学习的过程
05-08 989
特性描述数据结构哈希表 + 双向链表元素顺序可维护插入顺序或访问顺序（LRU）性能特征接近 HashMap 的查询性能，略高的内存开销线程安全性非线程安全（同 HashMap）允许 null允许 null 键和 null 值迭代性能迭代效率高于 HashMap（直接遍历链表）@Override// 当值大于1000时移除最老条目。
Java之LinkedHashMap源码分析（第一篇：初步了解）
王员外的博客
08-11 349
前言：HashMap一切都好，就是有一个缺点，当我们去遍历HashMap中的元素时，发现与插入顺序无关，它是完全无序的，我们想要一个有序的HashMap LinkedHashMap就在此背景下诞生了，它提供了两种有序的方式，满足你遍历的需求，牛13 0、听闻可以利用LinkedHashMap实现LRU，LinkedHashMap是靠什么保持HashMap中的元素的顺序的呢？我们一点点看下...
java之LinkedHashMap源码详细解析
码农研究僧的博客
03-09 1728
LinkedHashMap结合了hashmap和双向链表 LinkedHashMap是HashMap的子类，有着和HashMap的多数特性。 其特点大概有： key和value都允许为空 key可重复可覆盖，value可重复 有序的 非线程安全的 还可实现LRU (最近最少使用)算法
Java源码解析之LinkedHashMap
luoru的博客
03-27 277
Java源码解读之LinkedHashMap HashMap 是用于映射(键值对)处理的数据类型，不保证元素的顺序按照插入顺序来排列，为了解决这一问题，Java 在 JDK1.4 以后提供了 LinkedHashMap 来实现有序的 HashMap LinkedHashMap 是 HashMap 的子类，它保留了元素的插入顺序，在内部维护着一个按照元素插入顺序或者元素访问顺序来排列的链表，默认是按...
LinkedHashMap源码分析
欢谷悠扬
05-14 211
1.简述 LinkedHashMap继承自HashMap 创建对象与HashMap的基本一致，基本都是调用HashMap的构造方法 在newCode方法中完成了按照插入顺序构建链表的过程 LinkedHashMap还可以按照访问顺序进行排序，如果想按照访问顺序进行排序，那么首先要将accessOrder设置为true，接着在afterNodeAccess中会对LinkedHashMap进行双向链表调整。 2.重要成员变量 // 双向链表的头部 transient LinkedHashMap.Entry
JavaLinkedHashMap源码解析Java开发Ja
11-22
6. **源码解析**： - `LinkedHashMap` 的核心是 `Entry` 类，它继承自 `HashMap` 的 `Node` 类，额外维护了前后节点的引用。 - `putEntryAt()` 和 `createEntryAt()` 方法负责在链表的正确位置插入新的节点。 - `...
Java中LinkedHashMap源码解析
08-29
Java中LinkedHashMap源码解析 LinkedHashMap是Java中的一种哈希表实现，它继承自HashMap，具有可预知的迭代顺序。LinkedHashMap维护着一个运行于所有条目的双重链表结构，该链表定义了迭代顺序，可以是插入或者访问...
Java面试要点58 - Java LinkedHashMap访问顺序源码解析
程序媛学姐的博客
12-04 814
本文深入分析了LinkedHashMap中访问顺序的实现机制。通过双向链表结构维护元素顺序，并在访问时动态调整节点位置，LinkedHashMap很好地解决了有序访问的需求。这种实现不仅保证了元素的访问顺序，还提供了自动删除最旧元素的功能，使其成为实现LRU缓存的理想选择。
【Java集合框架】篇五：HashMap、LinkedHashMap源码解析
酷奇的博客
03-03 1005
jdk8中，我们调用空参构造器，创建实例时，底层没用立即初始化数组容量，在我们第一次put元素时，才初始化一个容量为16的数组table，并将元素添加到table（类似懒汉式） jdk8中，将内部类Entry改名为Node（名称合理化），意味着我们创建的数组式Node[]，不再是Entry[]。 jdk8中，key1和key2的哈希值和内容不同，则(key1,value1)与(key2,value3)构成单向链表，(key2,value2)指向(key1,value1)（尾插法）。因为头插法在多线程的情况下
JDK容器学习之LinkedHashMap （一）：底层存储结构分析
weixin_34018202的博客
10-12 236
2019独角兽企业重金招聘Python工程师标准>>> ...
Java：Map常用方法
m0_51755061的博客
03-23 471
Map常用方法0. 总结：常用方法：1. 常用方法 0. 总结：常用方法： 添加：put(Object key,Object value) 删除：remove(Object key) 修改：put(Object key,Object value) 查询：get(Object key) 长度：size() 遍历：keySet() / values() / entrySet() 1. 常用方法 （1）添加、删除、修改操作： Object put(Object key,Object value)：将指定ke
Java集合------LinkedHashMap底层原理
热门推荐
剑小纯的夜话白鹭
03-27 2万+
Java集合------LinkedHashMap底层原理 前言 在集合中,除了常用的HashMap,还有今天我们要说的LinkedHashMap.为什么会有LinkedHashMap这个集合呢?因为我们在迭代HashMap的时候是无序的,我们希望有一个有序的map来方便我们的使用,这个时候就有了LinkedHashMap. 正文 首先,LinkedHashMap通过维护一个运行于所有条目的双向链...
Java中LinkedHashMap底层实现
F_Hello_World的博客
01-09 604
目录 序言： 1：LinkedHashMap中的put(key,value) 1.1：LinkedHashMap中对putVal()方法源码描述： 1.2：LinkedHashMap中对节点操作方法源码描述： 1.3：LinkedHashMap中afterNodeAcces()方法源码描述： 1.4：LinkedHashMap中afterNodeInsertion()方法源码描述： ...
java LinkedHashMap 底层实现和源码分析
Arthurs_L的博客
08-08 535
开局分析 首先外面来认识下这个类，LinkedHashMap，从继承和实现方面讲，继承自HashMap，且实现了Map接口，且内部未做线程安全处理。那么这里对HashMap不是太熟悉的可以先参考我前面写过的《java HashMap 源码分析和底层实现》，作为一个Map体系的代表性集合，其经典使用场景应该就是LRU-cache的应用了。现在还是按照老龟巨！从源码开始分析 成员及构造方法 成员...
Java进阶-LinkedHashMap 底层分析
weixin_33712881的博客
08-11 166
众所周知HashMap是一个无序的Map，因为每次根据key的hashcode映射到Entry数组上，所以遍历出来的顺序并不是写入的顺序。 因此 JDK 推出一个基于HashMap但具有顺序的LinkedHashMap来解决有排序需求的场景。 它的底层是...
LinkedHashMap底层实现原理 [Java]
m0_57001006的博客
12-09 811
LinkedHashMap的底层实现原理: LinkedHashMap中存储的元素我们在打印时可以按照这些元素装入集合的顺序进行打印 LinkedHashMap是HashMap类的一个子类 LinkedHashMap可以说是在HashMap的基础上添加了一对LinkedHashMap.Entry<K,V>类型的引用before和after 底层存储单元: LinkedHashMap中底层是通过LinkedHashMap.Entry类进行存储的 LinkedHashMap.Entry类
java源码阅读 - LinkedHashMap
理想万岁万万岁的博客
03-26 754
通过源码对LinkedHashMap详细分析
LinkedHashMap 源码分析，底层竟这么简单！
Java技术栈，分享最主流的Java技术
01-22 362
来源：cnblogs.com/panzi/p/10845079.htmlLinkedHashMap是一个键有序的 HashMap，可以将 LinkedHashMap 理解为 LinkL...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

全粘架构师

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值