• Java - LinkedHashMap原理分析

    Java - LinkedHashMap原理分析

    前言

    Java中，Map类型的集合有很多种，我们之前分析过两种：

    我们知道，HashMap关键就在于Hash。哈希值它并不能像数组那样是顺序的。因此我们插入的元素无法保证顺序性。因此，衍生出一个LinkedHashMap，本文就来讲解下它的原理。

    一. LinkedHashMap原理

    首先，LinkedHashMap 它是基于HashMap 的结构基础上创建的类。只不过在其基础上，有着双向链表的特性，并且元素的存储具有一定的顺序。

    1.1 LinkedHashMap的结构

    我们看下，

    public class LinkedHashMap<K,V> extends HashMap<K,V> implements Map<K,V> {
	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);
        }
    }
    transient LinkedHashMap.Entry<K,V> head;
    transient LinkedHashMap.Entry<K,V> tail;
    final boolean accessOrder;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11

    我们可以看到几个重要的成员变量：

    • Entry：用来实现双向链表的（也是和HashMap的一个不同点）。
    • head：链表的头。
    • tail：链表的尾。
    • accessOrder：控制插入的顺序。

    我们再来看下它的默认构造函数：

    public LinkedHashMap() {
    super();
    accessOrder = false;
}

    • 1
    • 2
    • 3
    • 4

    可以见到，super()，调用的就是HashMap的构造。除此之外，accessOrder的值赋值为false。

    accessOrder的值决定着元素之间的顺序：

    • false（默认）：按照插入顺序排序。
    • true：按照访问顺序排序（将当前元素移动至链表的末尾，即最后输出）。

    我们这里来个例子，就可以更加直观的看这个顺序问题了：

    按照插入顺序排序：

    public static void main(String[] args) throws Exception {
    LinkedHashMap<Integer, Integer> map = new LinkedHashMap<Integer, Integer>() {{
        put(1, 1);
        put(2, 2);
        put(3, 3);
        put(4, 4);
    }};
    for (Map.Entry<Integer, Integer> entry : map.entrySet()) {
        System.out.println(entry.getKey() + ", " + entry.getValue());
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11

    结果如下：
    在这里插入图片描述

    按照访问顺序排序：

    public static void main(String[] args) throws Exception {
    LinkedHashMap<Integer, Integer> map = new LinkedHashMap<Integer, Integer>(16, 0.75F, true) {{
        put(1, 1);
        put(2, 2);
        put(3, 3);
        put(4, 4);
    }};
    System.out.println("元素访问： " + map.get(3) + " 移动到链表末尾");
    System.out.println("元素访问： " + map.get(1) + " 移动到链表末尾");
    for (Map.Entry<Integer, Integer> entry : map.entrySet()) {
        System.out.println(entry.getKey() + ", " + entry.getValue());
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13

    结果如下：
    在这里插入图片描述

    那么接下来我们就从put函数开始看起，看看LinkedHashMap是如何维护顺序的。我们点入源码，我们可以发现，函数直接跳到了HashMap内部中的put函数，说明LinkedHashMap并没有重写put函数，而是直接调用父类HashMap的。

    1.2 元素插入

    因为在之前的文章中讲的比较详细了，我们直接把文章内容复制过来：

    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;
    // 1.添加元素之前，先判断当前哈希桶数组的大小，是否是null或者空
    if ((tab = table) == null || (n = tab.length) == 0)
    	// 如果是，那么需要将数组扩容，这样才能存储元素呀。
        n = (tab = resize()).length;
    // 2. (n - 1) & hash ：计算这个key对应的哈希桶下标
    // 若此时对应的哈希桶中没有存储任何元素，即为null，就是没有发生碰撞，直接创建一个新的Node链表即可。
    if ((p = tab[i = (n - 1) & hash]) == null)
        tab[i] = newNode(hash, key, value, null);
    else {
    	// 3.否则发生碰撞
        Node<K,V> e; K k;
        // 如果当前位置的数据，即链表的首节点，就是要找的，那么进行值的替换，
        if (p.hash == hash &&
            ((k = p.key) == key || (key != null && key.equals(k))))
            e = p;
        // 如果key不一样，那么就需要进行判断，判断当前节点是否是红黑树结构
        else if (p instanceof TreeNode)
        	// 如果是，那么就需要根据红黑树的逻辑来添加一个新节点
            e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
        else {
        	// 如果不是红黑树，那么就是链表，遍历整个哈希冲突链，看看是否有重复的key
            for (int binCount = 0; ; ++binCount) {
            	// 如果没有找到重复的，就在链表的末尾添加一个新元素
                if ((e = p.next) == null) {
                    p.next = newNode(hash, key, value, null);
                    // 插入完成之后，再判断是否需要转化为红黑树，即链表长度是否超过阈值
                    if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                        treeifyBin(tab, hash);
                    break;
                }
                // 如果找到了重复的key，就替换数据
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    break;
                p = e;
            }
        }
        // 如果找到的节点不是null，就将旧值替换为新值
        if (e != null) { 
            V oldValue = e.value;
            if (!onlyIfAbsent || oldValue == null)
                e.value = value;
            afterNodeAccess(e);
            return oldValue;
        }
    }
    // 插入完成之后，增加元素数量。判断是否需要扩容。
    ++modCount;
    if (++size > threshold)
        resize();
    afterNodeInsertion(evict);
    return null;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60

    那么顺序控制的部分体现在哪呢？LinkedHashMap中的accessOrder变量也没用到呀？看过Java - HashMap原理分析这篇文章的同学可能发现到，上述源码中有两个函数并没有讲解到：

    afterNodeAccess(e);
afterNodeInsertion(evict);

    • 1
    • 2

    为什么没有讲这两个函数？因为在HashMap中，这两个函数没有什么实现：
    在这里插入图片描述
    但是！在LinkedHashMap中就有对应实现了，Java里面，如果子类重写了父类的方法，那么就会使用子类的函数去执行。

    不仅如此，代码里还有一段代码隐藏的比较深：

     tab[i] = newNode(hash, key, value, null);

    • 1

    实际上，newNode 在LinkedHashMap中也重写了！

    Node<K,V> newNode(int hash, K key, V value, Node<K,V> e) {
	// 用Entry来封装下
    LinkedHashMap.Entry<K,V> p =
        new LinkedHashMap.Entry<K,V>(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 {
    	// 否则将当前节点接到last的后面
        p.before = last;
        last.after = p;
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21

    1.2.1 afterNodeAccess 函数(将元素放到最后)

    我们来看下源码：

    // 将元素移动到最后
void afterNodeAccess(Node<K,V> e) { 
    LinkedHashMap.Entry<K,V> last;
    // 如果accessOrder为true，即代表按照访问顺序来排序
    if (accessOrder && (last = tail) != e) {
    	// p指向当前元素，b代表前驱节点。a代表后继节点。b <-> p <-> a
        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
        	// 前驱节点的next指针指向后驱节点。
            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;
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34

    说白了一共就俩步骤：

    1. 将当前操作的元素，先从双向链表中剔除。
    2. 然后再将当前操作元素，放到双向链表的末尾。

    1.2.2 afterNodeInsertion 函数(删除最老元素，LRU运用)

    直接看源码：

    // evict 代表为驱逐，即是否允许移除元素
void afterNodeInsertion(boolean evict) { // possibly remove eldest
    LinkedHashMap.Entry<K,V> first;
    // removeEldestEntry：判断是否满足移除最老节点
    if (evict && (first = head) != null && removeEldestEntry(first)) {
        K key = first.key;
        // 删除对应的节点
        removeNode(hash(key), key, null, false, true);
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10

    我们知道HashMap中，对于每个哈希槽中的链表，如果有新的元素进来，都是通过尾插法来插入到链表中的，即插入到链表的末尾。因此头结点就是这个哈希槽中最老的元素了。

    但是removeEldestEntry实际上，它默认返回false，即说白了afterNodeInsertion这个函数它什么也不会干：

    protected boolean removeEldestEntry(Map.Entry<K,V> eldest) {
    return false;
}

    • 1
    • 2
    • 3

    既然默认的情况下，afterNodeInsertion并不会起到什么特殊作用，但是有些场景下，它就可以发挥了，比如：我们用LinkedHashMap去实现一个LRU算法。那么这个时候，我们就需要重写removeEldestEntry这个函数。

    LRU算法，最少最近使用，如果保存的数据满了，我们需要将最近最少使用的数据给删除掉。那么如何用LinkedHashMap来实现呢？

    • 首先，将accessOrder这个变量设置为true。那么每次访问这个变量的时候，都会将这个变量放到链表的末尾。
    • 那么这样一来链表的头部元素就是最久没用使用的那个元素了，当元素满的时候，我们就需要删除他。我们只需要让removeEldestEntry在一定条件下返回true即可。

    代码如下：

    public class LRUCache extends LinkedHashMap<Integer, Integer> {
    private int capacity;

    public LRUCache(int capacity) {
        super(capacity, 0.75F, true);
        this.capacity = capacity;
    }

    public int get(int key) {
        return super.getOrDefault(key, -1);
    }

    public void put(int key, int value) {
        super.put(key, value);
    }

    @Override
    protected boolean removeEldestEntry(Map.Entry<Integer, Integer> eldest) {
        return size() > capacity;
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21

    1.3 元素获取

    同理，LinkedHashMap中的get函数，本质上还是使用的父类HashMap的函数，只不过稍微封装了下：

    public V get(Object key) {
    Node<K,V> e;
    // 调用父类HashMap的函数，获取元素
    if ((e = getNode(hash(key), key)) == null)
        return null;
    // 如果开启了按照访问顺序排序，那么还要维护下链表结构，让当前元素放到链表的末尾。
    if (accessOrder)
        afterNodeAccess(e);
    return e.value;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10

    1.4 元素删除

    元素删除这块，还得看HashMap，它里面有个静态内部类HashIterator：

    abstract class HashIterator {
	public final void remove() {
       Node<K,V> p = current;
       	// 理论上不可能删除null，是的抛出异常
        if (p == null)
            throw new IllegalStateException();
        // 高并发下很容易造成这种情况，会抛出异常
        if (modCount != expectedModCount)
            throw new ConcurrentModificationException();
        current = null;
        K key = p.key;
        // 节点删除
        removeNode(hash(key), key, null, false, false);
        expectedModCount = modCount;
    }
}

final Node<K,V> removeNode(int hash, Object key, Object value,
                               boolean matchValue, boolean movable) {
   Node<K,V>[] tab; Node<K,V> p; int n, index;
    // 只有table数组非空，才可以进行数组删除。并且对应的哈希槽节点不是null
    if ((tab = table) != null && (n = tab.length) > 0 &&
        (p = tab[index = (n - 1) & hash]) != null) {
        Node<K,V> node = null, e; K k; V v;
        // 【第一部分】主要在做元素的查找操作。
        // 如果哈希槽的首节点就是要找的，那么直接复制给node对象
        if (p.hash == hash &&
            ((k = p.key) == key || (key != null && key.equals(k))))
            node = p;
        // 否则遍历链表（或者是红黑树）去查找要找的元素
        else if ((e = p.next) != null) {
        	// 如果是红黑树，那么根据红黑树的方法去遍历
            if (p instanceof TreeNode)
                node = ((TreeNode<K,V>)p).getTreeNode(hash, key);
            else {
            	// 否则哈希槽对应的就是链表，遍历链表，查找对应的元素
                do {
                    if (e.hash == hash &&
                        ((k = e.key) == key ||
                         (key != null && key.equals(k)))) {
                        node = e;
                        break;
                    }
                    p = e;
                } while ((e = e.next) != null);
            }
        }
        // 【第二部分】元素删除操作，
        // 如果找到元素了，再进行元素删除
        if (node != null && (!matchValue || (v = node.value) == value ||
                             (value != null && value.equals(v)))) {
            // 红黑树删除节点                
            if (node instanceof TreeNode)
                ((TreeNode<K,V>)node).removeTreeNode(this, tab, movable);
            // 如果要删除的元素正好是首节点，那么直接将首节点指向删除元素的下一个即可
            else if (node == p)
                tab[index] = node.next;
            else
                // 否则正常的删除该节点（通过改变指针指向，跳过待删除元素即可）
                p.next = node.next;
            // 修改数+1
            ++modCount;
            // 元素数量-1
            --size;
            afterNodeRemoval(node);
            return node;
        }
    }
    return null;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70

    同样的，在HashMap中，afterNodeRemoval这个函数并没有具体的实现，LinkedHashMap同样对此进行了实现，因为LinkedHashMap中的链表是双向链表，因此还要多做几个操作去维护双向链表。主要是维护头尾节点。

    我们看下源码：

    void afterNodeRemoval(Node<K,V> e) { 
	// e是待删除元素，b前驱节点，a后继节点
   LinkedHashMap.Entry<K,V> p =
        (LinkedHashMap.Entry<K,V>)e, b = p.before, a = p.after;
    // 先断开当前节点
    p.before = p.after = null;
    // 【维护after指针】
    // 前驱节点是null，说明当前节点是头节点，直接赋值即可。
    if (b == null)
        head = a;
    else
    	// 否则，修改前驱节点的next指针，跳过待删除节点，直接指向后继节点即可
        b.after = a;
    // 【维护before指针】
    // 对链表尾的处理，若后继节点为null，说明当前节点是尾结点。直接赋值即可。
    if (a == null)
        tail = b;
    else
    	// 同理，跳过待删除节点。
        a.before = b;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21

    二. 总结

    1.LinkedHashMap的实现基于HashMap（继承关系），put/get/remove的底层都依赖于父类HashMap中的实现。

    2.不同的是，LinkedHashMap中的节点是Entry而不再是Node节点。主要是因为LinkedHashMap中的链表是双向链表。而HashMap中的是单向链表。

    3.LinkedHashMap中，对于put/get/remove的底层实现，比HashMap多了一些操作（只不过LinkedHashMap有具体的实现，而HashMap中没有）：

    • put：afterNodeAccess，将元素放到链表末尾。
    • get：afterNodeAccess，将元素放到链表末尾。
    • remove：afterNodeRemoval，维护双向链表的头尾节点。

    4.同时LinkedHashMap多了一个accessOrder变量，用于控制链表的元素顺序：

    • true：按照访问顺序排序（包括插入操作）。
    • false：默认的，按照插入顺序排序。
  • 相关阅读:
    Redis高效、安全的不停机数据迁移方案
    本月本周github热度霸榜项目——jeecgboot
    2-3、bean的作用域生命周期，以及xml自动装配
    YOLOv5实战：如何添加RepVgg模块
    linux内核漏洞（CVE-2022-0847）
    adb调试Linux嵌入式设备记录
    ue4中Pak文件中挂载的资源名称获取
    Hadoop伪分布式搭建
    SCA Nacos 服务注册和配置中心（一）
    javaweb JAVA JSP电车租赁系统jsp租赁系统 jsp汽车租赁 电车租赁网站案例源码
  • 原文地址：https://blog.csdn.net/Zong_0915/article/details/126903832