Java中的LinkedHashMap

已于 2025-02-26 15:03:42 修改
阅读量411 收藏 5
点赞数 5
CC 4.0 BY-SA版权
分类专栏： Java集合 文章标签： java 开发语言
于 2025-02-26 14:51:06 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/RollingCode_999/article/details/145876076

LinkedHashMap继承自HashMap，并且实现了Map接口

LinkedHashMap在继承了HashMap的底层数据结构的同时，维护了一个双向链表，保证了数据插入或访问顺序，是有序的哈希表

特点

  1. 元素是有序的：维护了双向链表，默认是按照插入顺序(也可以实现访问顺序：每次访问节点就将当前节点移动到链表尾端)
  2. 元素的键不能重复，值可以重复
  3. 元素的键和值都支持null值
  4. hash冲突：根据key的hash值和数组长度位运算得到索引位，若此位置已经有值，则形成链表存储在此索引位(一个索引位为一个桶，桶内是链表或红黑树)
  5. 数组扩容：当数组元素个数大于数组容量的75%的时候，数组会进行扩容，扩容到原来的2倍
  6. 链表转红黑树：当链表长度大于8并且数组长度大于64时，链表转化为红黑树；当红黑树的节点个数减少到6时，会退化为链表
  7. 非线程安全：不支持多线程操作

底层原理

  • LinkedHashMap是基于数组+链表+红黑树+双向链表的数据结构实现的
  • 数组的默认初始化容量为16，比例因子为0.75，当数组元素个数大于16*0.75(临界值)，数组会进行扩容，并且将旧数组中的数组拷贝到新数组中
  • 当插入的元素出现hash冲突(计算出的索引位已经有值)，则会在当前索引位形成链表存储数据
  • 当链表长度大于8但是数组长度小于64的时候，数组会进行扩容，并将原数组中的链表拆分成2个链表存储在不同位置的桶中(索引位)
  • 当链表长度大于8但是数组长度大于64的时候，链表会转化为红黑树
  • 维护双向链表，确认元素插入或者访问的顺序。在解决hash冲突时调整链表或者红黑树，双向链表不需要调整

迭代器直接遍历双向链表：LinkedHashMap 的 entrySet()、keySet()、values() 遍历时间复杂度为 O(n)，且顺序确定

方法

构造方法
public class LinkedHashMap<K,V>
    extends HashMap<K,V>
    implements Map<K,V>
{
    
    //双向链表头节点
    transient LinkedHashMap.Entry<K,V> head;

    //双向链表尾节点
    transient LinkedHashMap.Entry<K,V> tail;

    //指定链表顺序：true 按照访问节点顺序；false 按照插入顺序
    final boolean accessOrder;

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

    //创建一个LinkedHashMap，手动设置初始化容量，默认比例因子0.75
    public LinkedHashMap(int initialCapacity) {
        super(initialCapacity);
        accessOrder = false;
    }

    //创建一个LinkedHashMap，默认初始化容量为16，比例因子为0.75
    public LinkedHashMap() {
        super();
        accessOrder = false;
    }

    //创建一个LinkedHashMap，将传入集合中的元素按照元素顺序复制到LinkedHashMap
    //(添加元素时维护了双向链表)
    public LinkedHashMap(Map<? extends K, ? extends V> m) {
        super();
        accessOrder = false;
        putMapEntries(m, false);
    }

    //创建一个LinkedHashMap，手动设置初始化容量，比例因子，元素顺序(按照插入还是访问顺序)
    public LinkedHashMap(int initialCapacity,
                         float loadFactor,
                         boolean accessOrder) {
        super(initialCapacity, loadFactor);
        this.accessOrder = accessOrder;
    }
}
添加单个元素

实际使用的是HashMap中的put方法，LinkedHashMap只是重写了创建节点的方法(此中维护双向链表)

    //hashmap中的put方法
    public V put(K key, V value) {
        return putVal(hash(key), key, value, false, true);
    }

    final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        Node<K,V>[] tab; Node<K,V> p; int n, i;
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;
        if ((p = tab[i = (n - 1) & hash]) == null)
            //调用LinkedHashMap中的方法创建节点
            tab[i] = newNode(hash, key, value, null);
        else {
           ......
        }
        ++modCount;
        if (++size > threshold)
            resize();
        afterNodeInsertion(evict);
        return null;
    }

    //创建新节点(LinkedHashMap.Entry继承自HashMap.Node，额外维护了双向链表的前后指针)
    Node<K,V> newNode(int hash, K key, V value, Node<K,V> e) {
        LinkedHashMap.Entry<K,V> p =
            new LinkedHashMap.Entry<>(hash, key, value, e);
        //建立新节点的双向链表关系(前后指针)
        linkNodeLast(p);
        return 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;
        }
    }
创建LinkedHashMap节点
    //创建节点后维护节点在双向链表中的位置
    TreeNode<K,V> newTreeNode(int hash, K key, V value, Node<K,V> next) {
        TreeNode<K,V> p = new TreeNode<>(hash, key, value, next);
        linkNodeLast(p);
        return p;
    }

    //创建节点后维护节点在双向链表中的位置
    Node<K,V> newNode(int hash, K key, V value, Node<K,V> e) {
        LinkedHashMap.Entry<K,V> p =
            new LinkedHashMap.Entry<>(hash, key, value, e);
        linkNodeLast(p);
        return p;
    }
添加多个元素

实际调用HashMap中的putAll方法，LinkedHashMap只是重写了创建节点的方法

    //实际调用hashmap中的方法
    public void putAll(Map<? extends K, ? extends V> m) {
        putMapEntries(m, true);
    }

    //hashmap中的方法
    final void putMapEntries(Map<? extends K, ? extends V> m, boolean evict) {
        ......
            for (Map.Entry<? extends K, ? extends V> e : m.entrySet()) {
                K key = e.getKey();
                V value = e.getValue();
                putVal(hash(key), key, value, false, evict);
            }
        }
    }

    //hashmap中的方法
    final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        Node<K,V>[] tab; Node<K,V> p; int n, i;
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;
        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);
        else {
           ......
        }
        ++modCount;
        if (++size > threshold)
            resize();
        afterNodeInsertion(evict);
        return null;
    }
删除单个元素

实际调用hashmap中的删除方法，在删除完成后，调用LinkedHashMap中的afterNodeRemoval方法解绑双向链表

    //hashmap中的删除方法
    public V remove(Object key) {
        Node<K,V> e;
        return (e = removeNode(hash(key), key, null, false, true)) == null ?
            null : e.value;
    }

    //在removeNode方法中，删除完节点后，调用afterNodeRemoval解绑双向链表
    void afterNodeRemoval(Node<K,V> e) { // unlink
        LinkedHashMap.Entry<K,V> p =
            (LinkedHashMap.Entry<K,V>)e, b = p.before, a = p.after;
        //在双向链表中，将已删除的节点中的前后指针置为null
        p.before = p.after = null;
        //如果e节点的前一个节点(b)为null，那么双向链表的头节点就是a
        if (b == null)
            head = a;
        //如果e节点的前一个节点(b)不为null，则b节点的后一个节点置为a
        else
            b.after = a;
        //如果e的后一个节点(a)是null，那么双向链表的尾节点就是b
        if (a == null)
            tail = b;
        //如果e的后一个节点(a)不为null，则a的前一个节点置为b
        else
            a.before = b;
    }
获取单个元素

如果设置了集合顺序为访问顺序，则获取到元素后要重新维护元素在双向列表中的位置(移动到链表的尾端)

    //调用hashmap中的getNode方法获取元素，
    //如果LinkedHashMap设置的顺序是按照访问顺序，
    //则调用afterNodeAccess重新维护元素在双向链表中的位置
    public V get(Object key) {
        Node<K,V> e;
        if ((e = getNode(hash(key), key)) == null)
            return null;
        if (accessOrder)
            afterNodeAccess(e);
        return e.value;
    }

    
    void afterNodeAccess(Node<K,V> e) { // move node to last
        LinkedHashMap.Entry<K,V> last;
        //首先将尾节点tail赋值给last，p指向e节点
        if (accessOrder && (last = tail) != e) {
            LinkedHashMap.Entry<K,V> p =
                (LinkedHashMap.Entry<K,V>)e, b = p.before, a = p.after;
            //e节点的后一个节点置为null
            p.after = null;
            //如果e节点的前一个节点(b)为null，则e节点的后一个节点(a)为头节点
            if (b == null)
                head = a;
            //如果e节点的前一个节点(b)不为null，则b的后一个节点是a
            else
                b.after = a;
            //如果e的后一个节点(a)不为null，则a的前一个节点是b
            if (a != null)
                a.before = b;
            //如果e的后一个节点(a)为null，则尾节点是b
            else
                last = b;
            //最终确认：last节点(也就是尾节点)是null，那么头节点就是e
            if (last == null)
                head = p;
            //last不为null，那么e的前一个节点是last(尾节点);last的后一个节点就是p
            else {
                p.before = last;
                last.after = p;
            }
            //双向链表尾部指针指向e
            tail = p;
            ++modCount;
        }
    }
迭代器
    abstract class LinkedHashIterator {
        LinkedHashMap.Entry<K,V> next;
        LinkedHashMap.Entry<K,V> current;
        int expectedModCount;

        //创建迭代器时，直接将双向链表的head放入迭代器的next
        LinkedHashIterator() {
            next = head;
            expectedModCount = modCount;
            current = null;
        }

        public final boolean hasNext() {
            return next != null;
        }

        //从head开始迭代遍历双向列表
        final LinkedHashMap.Entry<K,V> nextNode() {
            LinkedHashMap.Entry<K,V> e = next;
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
            if (e == null)
                throw new NoSuchElementException();
            current = e;
            next = e.after;
            return e;
        }

        public final void remove() {
            Node<K,V> p = current;
            if (p == null)
                throw new IllegalStateException();
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
            current = null;
            removeNode(p.hash, p.key, null, false, false);
            expectedModCount = modCount;
        }
    }

Java基础-LinkedHashMap
weixin_39248750的博客
04-23 2036
LinkedHashMap 继承自 HashMap，在 HashMap 基础上，通过维护一条双向链表，解决了 HashMap 不能随时保持遍历顺序和插入顺序一致的问题。 HashMap： LinkedHashMap： 一、基本定义 static class Entry<K,V> extends HashMap.Node<K,V> { Entry<K,V> before, after; Entry(int has..
java 中 LinkedHashMap使用总结
热门推荐
chen
10-13 1万+
初识LinkedHashMap 上两篇文章讲了HashMap和HashMap在多线程下引发的问题，说明了，HashMap是一种非常常见、非常有用的集合，并且在多线程情况下使用不当会有线程安全问题。 大多数情况下，只要不涉及线程安全问题，Map基本都可以使用HashMap，不过HashMap有一个问题，就是迭代HashMap的顺序并不是HashMap放置的顺序，也就是无序。HashMap的这一缺
Java基础 LinkedHashMap
深入Java世界：探索编程之美与技术深度
01-30 1266
LinkedHashMap是HashMap和双向链表的合二为一，即一个将所有Entry节点链入一个双向链表的HashMap（LinkedHashMap = HashMap + 双向链表）LinkedHashMap和HashMap是Java Collection Framework 的重要成员，也是Map族(如下图所示)LinkedHashMap是HashMap的子类（拥有HashMap的所有特性）
Java集合详解：LinkedHashMap
最新发布
qj19842011的专栏
05-15 963
就是带链表的HashMap；每一种数据结构都有其优势，同时也有其劣势，这使得不同的数据结构适用于不同的应用场景，但在实际应用中，有很多复杂和动态的应用场景通常需要采用不同的数据结构来处理，这个时候就需要组合不同的数据结构来满足特定应用场景的需求，就是一种组合数据结构的实现，它组合了链表和哈希表，不仅仅具有哈希表快速的随机存取能力，同时又保持了元素的插入或者访问顺序，可以通过链表对元素按照其插入或访问顺序进行快速的遍历。组合了双向链表和哈希表，关于哈希表和HashMap可看这篇。
【Java 集合】LinkedHashMap
LCN29的博客
11-28 2047
LinkedHashMap 是基于 HashMap 的实现的, 所以整体的结构是类似的, 唯一不同的是: 链表和红黑树的节点多维持了一个前驱节点指针和后驱节点指针。简单的理解就是 HashMap + 双向链表。因为继承了 HashMap, 直接复用父级 HashMap 的 table 属性, 存储的数据类型依旧是 Node// 继承 HashMap Node 节点的基础上, 追加了一个前驱指针和后驱指针。
Java 中的 LinkedHashMap
csdn_aspnet的专栏，请点击博客主页右上角三个点中的私信联系
10-07 789
应用：由于 LinkedHashMap 使用双向链接列表来维护插入顺序，我们可以通过重写removeEldestEntry()方法来实现 LRU 缓存功能，以实施在将新映射添加到映射时自动删除过时映射的策略。HashMap 具有快速插入、搜索和删除的优势，但它从不维护插入的轨迹和顺序，而 LinkedHashMap 则提供了可以按插入顺序访问元素的功能。由于 LinkedHashMap 中的元素是使用键进行索引的，因此只需重新插入我们希望更改的键的更新值即可更改键的值。因此，该参数是数据的键。
Java中LinkedHashMap源码解析
08-29
在LinkedHashMap中，putMapEntries方法用于将map中的所有条目插入到LinkedHashMap中。这个方法调用父类HashMap的put方法来实现数据的插入。 LinkedHashMap的实现原理是基于哈希表和链表的结合。它使用哈希表来存储...
详解Java中LinkedHashMap
08-30
在LinkedHashMap中，每个元素是一个Entry对象，Entry对象中包含了Key、Value、Hash值、之前的Entry对象和之后的Entry对象等信息。LinkedHashMap的基本数据结构是Entry数组，Entry数组中每个元素是一个Entry对象。 ...
如何将java中LinkedHashMap转为HashMap
07-31
在Java中，由于LinkedHashMap和HashMap有各自不同的实现和特性，直接将LinkedHashMap转换为HashMap会丢失LinkedHashMap原有的链表顺序（按插入顺序）。如果你需要的是普通哈希表并且不需要保持原来的排序，可以简单...
Java中 LinkedHashMap与HashMap的区别
06-02
在Java中，LinkedHashMap与HashMap都是Map接口的实现类，它们的主要区别在于它们维护键值对的顺序不同。 1. HashMap：HashMap不保证遍历顺序，因为它是基于哈希表实现。它允许空键和空值，并允许进行null的插入和...
Java集合之LinkedHashMap
woaimx_1314的博客
05-28 4479
第一张图为LinkedHashMap整体结构图，第二张图专门把循环双向链表抽取出来，直观一点，注意该循环双向链表的头部存放的是最久访问的节点或最先插入的节点，尾部为最近访问的或最近插入的节点，迭代器遍历方向是从链表的头部开始到链表尾部结束，在链表尾部有一个空的header节点，该节点不存放key-value内容，为LinkedHashMap类的成员属性，循环双向链表的入口。每次访问都把访问的那个数据移到双向队列的尾部去，那么每次要淘汰数据的时候，双向队列最头的那个数据不就是最不常访问的那个数据了吗？
深入浅出Java中的数据结构：LinkedHashMap详解
喵手的博客
05-15 1143
在Java编程中，我们经常需要使用Map这个数据结构来存储键值对，而是Map的一个实现类，它在HashMap的基础上维护了一个双向链表，并且按照插入顺序或者访问顺序来迭代元素。既保证了HashMap的快速访问性能，又提供了顺序访问的能力，因此在某些场景下非常有用。本文将从源代码解析、应用场景案例、优缺点分析等多个方面对进行详细介绍，希望能帮助读者更好地理解的实现原理和使用方法。本文主要介绍了Java中的这个数据结构，并对其源代码进行了分析和解读。通过对的应用场景案例和优缺点分析，读者可以更好地理解。
Java—LinkedHashMap
Neyscar的博客
10-31 857
LinkedHashMap是HashMap的子类，保证在遍历map元素时，可以按照添加的顺序实现遍历，对于频繁的遍历操作，它的执 行效率高于HashMap. 一些基本操作： 存储实现：put(Key,Value) 读取：get(Key) 遍历： LinkedHashMap<String,Integer> list=new LinkedHashMap<String,Integer>(); for(Entry<String, Integer> entry:list.entry
JDK8—LinkedHashMap源码浅析
lz710117239的博客
09-27 399
本篇文章叫做浅析，只是为了分析下LinkedHanshMap是如何保持有序的。 LinkedHashMap有一个子类： static class Entry extends HashMap.Node { Entry before, after; Entry(int hash, K key, V value, Node next) { su
Java零基础-集合：LinkedHashMap
喵手的博客
06-27 1356
在Java集合框架中，是一种特殊的Map实现，它继承自HashMap，并且保持了插入顺序或者访问顺序。对于Java零基础的学习者来说，理解的用法对于掌握Java集合操作非常重要。本文将详细介绍Java中的，包括其特性、操作方法、应用场景、优缺点分析，并通过代码示例和测试用例，帮助Java零基础的学习者快速掌握的使用。继承自HashMap，并且加入了一个双向链表来维护元素的顺序。它可以根据元素的插入顺序或者访问顺序来遍历元素。以下是: 向映射中添加一个键值对。: 根据键获取对应的值。
Java LinkedHashMap详解
御风而行
06-15 3978
1. LinkedHashMap概览 LinkedHashMap类定义 public class LinkedHashMap&lt;K,V&gt; extends HashMap&lt;K,V&gt; implements Map&lt;K,V&gt; LinkedHashMap直接继承自HashMap。所以说LinkedHashMap内部的实现也是数组+链表/红黑树...
java linkedhashmap_java学习-hashMap和linkedHashMap
weixin_31908803的博客
02-12 266
1、hashMap和linkedHashMap和treeMap1 * LinkedHashMap是继承于HashMap，是基于HashMap和双向链表来实现的。2 * HashMap无序；LinkedHashMap有序，可分为插入顺序和访问顺序两种。3 * 如果是访问顺序，那put和get操作已存在的Entry时，都会把Entry移动到双向链表的表尾(其实是先删除再插入)。4 * LinkedHa...
Java LinkedHashMap
这就是快乐嘛
06-08 305
LinkedHashMap继承HashMap，但相对HashMap有以下不同 1.插入是有顺序的，底层的Entry通过继承HashMap.Node，添加一个before和after结点实现插入有序 2.支持访问顺序 创建时调用构造函数LinkedHashMap(int initialCapacity,float loadFactor,boolean accessOrder)，指定第三个参数为true 3.LinkedHashMap的removeEldestEntry(Map.Entry eldest)方法，
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值