【集合源码系列】LinkedHashMap源码解析

最新推荐文章于 2021-08-31 22:15:26 发布
最新推荐文章于 2021-08-31 22:15:26 发布
阅读量266 收藏
点赞数
分类专栏： # 集合源码 文章标签： java linkedHashMap 源码
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43934607/article/details/108871825
版权

集合源码解析

LinkedHashMap

  • LinkedHashMap 继承自 HashMap 类，基本上没有重写 HashMap 的方法，只是把 HashMap 空实现的预留拓展点实现了。
数据结构
  • Map 拓展属性
/**
 * 头节点。
 *
 * 越老的节点，放在越前面。所以头节点，指向链表的开头
 */
transient LinkedHashMap.Entry<K,V> head;

/**
 * 尾节点
 *
 * 越新的节点，放在越后面。所以尾节点，指向链表的结尾
 */
transient LinkedHashMap.Entry<K,V> tail;

/**
 * 是否按照访问的顺序。
 *
 * true ：按照 key-value 的插入和访问顺序进行排序（即放置到链表的结尾，被 tail 指向）。
 * false ：按照 key-value 的插入顺序进行排序，访问该节点不会给该节点重新排序，
 *		   如果插入的 key 对应的 Entry 节点已经存在，也会被放到结尾。
 */
final boolean accessOrder;
  • 数据节点 Entry (拓展了前后指针)
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);
    }
}
构造方法

LinkedHashMap 一共有 5 个构造方法，其中四个和 HashMap 相同，只是多初始化 accessOrder = false 。所以，默认使用插入顺序进行访问。

  • 允许自定义 accessOrder 属性。
public LinkedHashMap(int initialCapacity,
                     float loadFactor,
                     boolean accessOrder) {
    super(initialCapacity, loadFactor);
    this.accessOrder = accessOrder;
}
创建节点

和 HashMap 的 newNode() 不同点是会让 tail 指向该节点，并且 Entry 是双向链表

Node<K,V> newNode(int hash, K key, V value, Node<K,V> e) {
    // <1> 创建 Entry 节点
    LinkedHashMap.Entry<K,V> p =
        new LinkedHashMap.Entry<>(hash, key, value, e);
    // <2> 添加到结尾
    linkNodeLast(p);
    // 返回
    return p;
}

// 添加到结尾,被 tail 指向
private void linkNodeLast(LinkedHashMap.Entry<K,V> p) {
    // 记录原尾节点到 last 中
    LinkedHashMap.Entry<K,V> last = tail;
    // 设置 tail 指向 p ，变更新的尾节点
    tail = p;
    // 如果原尾节点 last 为空，说明 head 也为空，所以 head 也指向 p
    if (last == null)
        head = p;
    // last <=> p ，相互指向
    else {
        p.before = last;
        last.after = p;
    }
}
后置拓展点
  • afterNodeAccess()

在 accessOrder 属性为 true 时，当 Entry 节点被访问时，放置到链表的结尾，被 tail 指向。

void afterNodeAccess(Node<K,V> e) { // move node to last
    LinkedHashMap.Entry<K,V> last;
    // accessOrder 判断必须是满足按访问顺序。
    // (last = tail) != e 将 tail 赋值给 last,并且判断是否 e 已经是队尾。如果是队尾，就不处理了。
    if (accessOrder && (last = tail) != e) {
        
        // 将 e 赋值给 p 【因为要 Node 类型转换成 Entry 类型】
        // 同时 b、a 分别是 e 的前后节点
        LinkedHashMap.Entry<K,V> p =
            (LinkedHashMap.Entry<K,V>)e, b = p.before, a = p.after;
        // 第一步，将 p 从链表中移除
        p.after = null;
        
        // 处理 b 的下一个节点指向 a
        if (b == null)
            head = a;
        else
            b.after = a;
        
        // 处理 a 的前一个节点指向 b       
        if (a != null)
            a.before = b;
        else
            last = b;
        
        // 第二步，将 p 添加到链表的尾巴。实际这里的代码，和 linkNodeLast 是一致的。        
        if (last == null)
            head = p;
        else {
            p.before = last;
            last.after = p;
        }
        
        // tail 指向 p ，实际就是 e 。
        tail = p;
        // 增加修改次数
        ++modCount;
    }
}

补充：

因为 HashMap 提供的 #get(Object key) 和 #getOrDefault(Object key, V defaultValue) 方法，并未调用 #afterNodeAccess(Node<K,V> e) 方法，这在按照读取顺序访问显然不行，所以 LinkedHashMap 重写这两方法的代码

public V get(Object key) {
    // 获得 key 对应的 Node
    Node<K,V> e;
    if ((e = getNode(hash(key), key)) == null)
        return null;
    // 如果访问到，回调节点被访问
    if (accessOrder)
        afterNodeAccess(e);
    return e.value;
}

public V getOrDefault(Object key, V defaultValue) {
    // 获得 key 对应的 Node
    Node<K,V> e;
   if ((e = getNode(hash(key), key)) == null)
       return defaultValue;
    // 如果访问到，回调节点被访问
    if (accessOrder)
       afterNodeAccess(e);
   return e.value;
}
  • afterNodeInsertion()

当 Entry 节点被添加时，放置到链表的结尾，被 tail 指向。

// evict 翻译为驱逐，表示是否允许移除元素
void afterNodeInsertion(boolean evict) { // possibly remove eldest
    LinkedHashMap.Entry<K,V> first;
    // first = head 记录当前头节点。因为移除从头开始，最老
    // <1> removeEldestEntry(first) 判断是否满足移除最老节点
    if (evict && (first = head) != null && removeEldestEntry(first)) {
        // <2> 移除指定节点
        K key = first.key;
        removeNode(hash(key), key, null, false, true);
    }
}

protected boolean removeEldestEntry(Map.Entry<K,V> eldest) {
    // 默认情况下，都不移除最老的节点
    return false;
}

拓展：

如何基于 LinkedHashMap 实现 LRU 算法的缓存。

class LRUCache<K, V> extends LinkedHashMap<K, V> {

    private final int CACHE_SIZE;

    /**
     * 传递进来最多能缓存多少数据
     *
     * @param cacheSize 缓存大小
     */
    public LRUCache(int cacheSize) {
        // true 表示让 LinkedHashMap 按照访问顺序来进行排序，最近访问的放在头部，最老访问的放在尾部。
        super((int) Math.ceil(cacheSize / 0.75) + 1, 0.75f, true);
        CACHE_SIZE = cacheSize;
    }

    /**
     * 添加元素的时候会调用这个拓展点，如果超过了 CACHE_SIZE，就会删除最老的节点，从而实现 LRU。
     */
    @Override
    protected boolean removeEldestEntry(Map.Entry<K, V> eldest) {
        // 当 map 中的数据量大于指定的缓存个数的时候，就自动删除最老的数据。
        return size() > CACHE_SIZE;
    }
}
  • afterNodeRemoval()

当 Entry 节点被添加时，从链表中删除该节点，让 tail 指向倒数第二个节点

void afterNodeRemoval(Node<K,V> e) { // unlink
    // 将 e 赋值给 p 【因为要 Node 类型转换成 Entry 类型】
    // 同时 b、a 分别是 e 的前后节点
    LinkedHashMap.Entry<K,V> p =
        (LinkedHashMap.Entry<K,V>)e, b = p.before, a = p.after;
    // 将 p 从链表中移除
    p.before = p.after = null;
    // 处理 b 的下一个节点指向 a
    if (b == null)
        head = a;
    else
        b.after = a;
    // 处理 a 的前一个节点指向 b
    if (a == null)
        tail = b;
    else
        a.before = b;
}
清空
public void clear() {
    // 清空
    super.clear();
    // 标记 head 和 tail 为 null
    head = tail = null;
}
迭代器
  • 转换成 Set/Collection

keySet

public Set<K> keySet() {
    // 获得 keySet 缓存
    Set<K> ks = keySet;
    // 如果不存在，则进行创建
    if (ks == null) {
        ks = new LinkedKeySet(); // LinkedKeySet 是 LinkedHashMap 自定义的
        keySet = ks;
    }
    return ks;
}


final class LinkedKeySet extends AbstractSet<K> {
    
    public final Iterator<K> iterator() {
        return new LinkedKeyIterator(); 
    }
    
    // 通过head + tail 构成的双向链表进行遍历，而不是遍历 table 数组。
    public final void forEach(Consumer<? super K> action) {
        if (action == null)
            throw new NullPointerException();
        int mc = modCount;
        // 链表遍历
        for (LinkedHashMap.Entry<K,V> e = head; e != null; e = e.after)
            action.accept(e.key);
        if (modCount != mc)
            throw new ConcurrentModificationException();
    }

    //------------------直接调用 LinkedHashMap 的方法 ------------------------
    public final int size()                 { return size; }
    public final void clear()               { LinkedHashMap.this.clear(); }
    
    public final boolean contains(Object o) { return containsKey(o); }
    public final boolean remove(Object key) {
        return removeNode(hash(key), key, null, false, true) != null;
    }
    public final Spliterator<K> spliterator()  {
        return Spliterators.spliterator(this, Spliterator.SIZED |
                                        Spliterator.ORDERED |
                                        Spliterator.DISTINCT);
    }
    public Object[] toArray() { return keysToArray(new Object[size]); }
    public <T> T[] toArray(T[] a) { return keysToArray(prepareArray(a)); }
    
}


final class LinkedKeyIterator extends LinkedHashIterator
    implements Iterator<K> {

    // key
    public final K next() { return nextNode().getKey(); }
}

values

public Collection<V> values() {
    // 获得 values 缓存
    Collection<V> vs = values;
    // 如果不存在，则进行创建
    if (vs == null) {
        vs = new LinkedValues(); // LinkedValues 是 LinkedHashMap 自定义的
        values = vs;
    }
    return vs;
}

final class LinkedValues extends AbstractCollection<V> {
    public final Iterator<V> iterator() {
        return new LinkedValueIterator(); // <X>
    }
    
    // 同 LinkedKeySet ，其余方法略
}

final class LinkedValueIterator extends LinkedHashIterator
    implements Iterator<V> {

    // value
    public final V next() { return nextNode().value; }
}

entrySet

public Set<Map.Entry<K,V>> entrySet() {
    Set<Map.Entry<K,V>> es;
    // LinkedEntrySet 是 LinkedHashMap 自定义的
    return (es = entrySet) == null ? (entrySet = new LinkedEntrySet()) : es;
}

final class LinkedEntrySet extends AbstractSet<Map.Entry<K,V>> {
    public final Iterator<Map.Entry<K,V>> iterator() {
        return new LinkedEntryIterator(); // <X>
    }
    
    // 同 LinkedKeySet ，其余方法略
}


final class LinkedEntryIterator extends LinkedHashIterator
    implements Iterator<Map.Entry<K,V>> {

    // Entry
    public final Map.Entry<K,V> next() { return nextNode(); }
}
  • LinkedHashIterator
abstract class LinkedHashIterator {

    // 下一个节点
    LinkedHashMap.Entry<K,V> next;
    // 当前节点
    LinkedHashMap.Entry<K,V> current;
    // 修改次数
    int expectedModCount;

    LinkedHashIterator() {
        next = head;
        expectedModCount = modCount;
        current = null;
    }

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

    final LinkedHashMap.Entry<K,V> nextNode() {
        LinkedHashMap.Entry<K,V> e = next;
        // 如果发生了修改，抛出 ConcurrentModificationException 异常
        if (modCount != expectedModCount)
            throw new ConcurrentModificationException();
        // 如果 e 为空，说明没有下一个节点，则抛出 NoSuchElementException 异常
        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();
        // 如果发生了修改，抛出 ConcurrentModificationException 异常
        if (modCount != expectedModCount)
            throw new ConcurrentModificationException();
        // 标记 current 为空，因为被移除了
        current = null;
        // 移除节点
        removeNode(p.hash, p.key, null, false, false);
        // 修改 expectedModCount 次数
        expectedModCount = modCount;
    }

}
小结
  • LinkedHashMap 是 HashMap 的子类，增加了顺序访问的特性。
    • 【默认】当 accessOrder = false 时，按照 key-value 的插入顺序进行访问。
    • 当 accessOrder = true 时，按照 key-value 的插入和读取顺序进行访问。
  • LinkedHashMap 的顺序特性，通过内部的双向链表实现，所以我们把它看成是 LinkedList + LinkedHashMap 的组合。
  • LinkedHashMap 通过重写 HashMap 提供的回调方法，从而实现其对顺序的特性的处理。同时，因为 LinkedHashMap 的顺序特性，需要重写 #keysToArray(T[] a) 等遍历相关的方法。
  • LinkedHashMap 可以方便实现 LRU 算法的缓存
槑！
关注
专栏目录
linkedhashmap 排序_LinkedHashMap 原理分析
weixin_29468281的博客
12-25 2100
LinkedHashMap的原理大致和上篇文章提到的数据结构类似。LRU算法实现它继承自HashMap ， 实现了map 接口。 所以，我们先来看下HashMap 的实现方式。 一. HashMapHashMap 的目的是为了实现一种键值对， 能够在O（1）的时间复杂度内找到键所对应的值值所在的位置。HashMap内存结构图主要的数据结构由以下两个属性实现。 // 每一个节点的hash值，由key...
源码浅析：LinkedHashMap、HashTable
小辙
11-15 211
上周对HashMap的源码进行了简单的分析，Map还有一起其他的实现类，本文对其他主要几个类的实现进行简单的分析，主要包括有LinkedHashMap，HashTable。 本文的两个结构与HashMap有较大的关联，关于HashMap可以参考上一篇文章：HashMap源码浅析 1 LinkedHashMap LinkedHashMap继承了HashMap，同时也实现了Map接口。在使用迭代器遍历的时候，可以按照put的顺序，进行遍历。 1.1 底层实现 LinkedHashMap听名字可以知道是 H.
LinkedHashMap排序
JavaClub
06-16 1万+
LinkedHashMap排序问题
LinkedHashMap 排序
JackieLiuLixi的专栏
07-16 6852
import java.util.ArrayList; import java.util.Collections; import java.util.Comparator; import java.util.HashMap; import java.util.LinkedHashMap; import java.util.List; import java.ut
[Map]利用LinkedHashMap来排序
chengludai0486的博客
09-12 1400
题目:已知一个 HashMap<Integer，User>集合， User 有 name（String）和 age（int）属性。请写一个方法实现对 HashMap 的排序功能，该方法接收 HashMap<Integer，User>为形参，返回类型为 HashMap&l...
Java集合框架源码分析之LinkedHashMap详解
08-29
Java集合框架源码分析之LinkedHashMap详解 Java集合框架中的LinkedHashMap是HashMap的子类，它继承了HashMap的存储结构，但引入了一个双向链表的头结点，将所有put到LinkedHashMap的节点连接成一个双向循环链表，...
拆行解码 Java 集合源码之 LinkedHashMap
游戈程序员
02-20 91
特性 LinkedHashMap 继承自 HashMap，像是 put、get、扩容等操作都是沿袭自父类。 只是在此基础上，重写了对相关结点的钩子方法，去构建了结点的双向链表。 这样做的目的，就是为了维护可预测的结点遍历顺序。 这种遍历顺序默认是结点的插入顺序（当 key 已存在的情况下，put 的更新时不会改变原有的顺序。），可以设置为访问顺序。 可以以 Map 为基准构建，将 Map 中结点的原有顺序作为遍历顺序。 基于访问顺序，可以方便地实现 LRU 缓存。 初始容量和负载因子，同 HashMap。
Jdk1.8集合框架之LinkedHashMap源码解析
哈罗德Android笔记
06-22 594
LinkedHashMap和HashMap的区别 HashMap的迭代器 LinkedHashMap的迭代器 LinkedHashMap.Entry 保存插入顺序和访问顺序 LinkedHashMap和HashMap的区别 LinkedHashMap是HashMap的子类，它和HashMap的区别是，可以按照节点插入的自然顺序（或者节点的操作顺序）来迭代所有节点。而且它的迭代比...
JavaLinkedHashMap源码解析Java开发Ja
最新发布
11-22
6. **源码解析**： - `LinkedHashMap` 的核心是 `Entry` 类，它继承自 `HashMap` 的 `Node` 类，额外维护了前后节点的引用。 - `putEntryAt()` 和 `createEntryAt()` 方法负责在链表的正确位置插入新的节点。 - `...
Java使用LinkedHashMap进行分数排序
08-30
主要介绍了Java使用LinkedHashMap进行分数排序的相关代码，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
LinkedHashMap对key进行排序
热门推荐
weixin_44777693的博客
08-06 1万+
对LinkedHashMap按key进行降序排序 public static void main(String[] args) { LinkedHashMap<String,String> map = new LinkedHashMap<String,String>(); map.put("1","aaa"); map.put("3","bbb")...
Java容器深度总结：LinkedHashMap
白日梦想家的博客
09-14 694
旧游无处不堪寻。无寻处，惟有少年心。 内容1.LinkedHashMap概述2.LinkedHashMap的定义 1.LinkedHashMap概述 LinkedHashMap来自于JDK1.4，直接继承自 HashMap，并且在 HashMap 基础上，通过维护由所有Entry节点构成的双向链表，来保证元素有序。 LinkedHashMap 继承了 HashMap，因此具有和 HashMap一样的快速查找特性，LinkedHashMap 对 HashMap高度复用，因此建议先学习HashMap的相关知.
Java Map数据结构与排序
x_i_y_u_e的专栏
09-25 1883
一、简单介绍Map        在讲解Map排序之前，我们先来稍微了解下map。map是键值对的集合接口，它的实现类主要包括：HashMap,TreeMap,Hashtable以及LinkedHashMap等。其中这四者的区别如下（简单介绍）：        HashMap：我们最常用的Map，它根据key的HashCode 值来存储数据,根据key可以直接获取它的Value，同时它具有很快
linkedHashmap排序机制
weixin_57763462的博客
08-31 5322
LinkedHashMap = HashMap + 双向链表这个说法，对于我们快速理解LinkedHashMap很有启发性。LinkedHashMap不会去改变HashMap节点的性质，LinkedHashMap所做的，只是建立节点之间的联系，LinkedHashMap的增删改查操作，只是在HashMap的增删改查的基础上，进行head和tail指针的移动。总之一句话：LinkedHashMap的所有操作，都是基于HashMap，对自己的双向链表的操作。有点拗口，OK，再换一种说法大家理解一下：Linked
JDK源码解析之LinkedHashMap的两种排序
孤独的根号三_
10-14 1241
概述：        HashMap 是我们平常项目中经常使用到的集合之一，它存储的是键值对，采用的是 数组 + 链表 + 红黑树的数据结构（详细可看我之前写的一篇关于HashMap的源码的博客），存储的数据是无序的，但是如果我们项目中需要用到有序的HashMap，那么我们可以使用LinkedHashMap，使用归使用， 但是LinkedHashMap 为什么是有序的呢？ 接下来就让我们进通
LinkedHashMap特性与HashMap排序
lingchen336的博客
07-19 782
HashMap:新key的加入或旧key的value的改变会刷新map中key的位置，变化的key总是存储在最前面。 LinkedHashMap：有序的HashMap，key的改变不会影响key在map中的位置。 如下一道DB面试题： /** @author hetao @date 2021/7/5 数字去重:输入一组数字，按数字出现的次数排序，次数多的排在最前面，次数相同按出现顺序排序。 使用LinkedHashMap 有序map， map排序 输入123,56,123,89 输出123,56,89
HashMap排序
one_dayR的博客
05-29 254
题目：已知一个 HashMap<Integer，User>集合， User 有 name（String）和 age（int）属性。请写一个方法实现对 HashMap 的排序功能，该方法接收 HashMap<Integer，User>为形参，返回类型为 HashMap<Integer，User>， 要求对 HashMap 中的 User 的 age 倒序进行排序。...
从源码看LinkedHashMap如何实现的排序
zip_tts的博客
01-06 1878
LinkedHashMap源码分析  LinkedLinkedHashMap继承自HashMap,与HashMap不同的是，LinkedLinkedHashMap实现了HashMap所不具备的排序功能。所使用的方式是将HashMap的节点连接成双向链表结构，从而实现排序功能。   LinkedHashMap具有两种排序方式：按照插入顺序排序和按照最近使用顺序排序。而最近使用顺序正好是LRU算法实...
深入解析Java LinkedHashMap：源码与实现原理
"本文详细分析了Java集合框架中的LinkedHashMap，包括其简介、源码剖析以及在实现LRU算法中的应用。" 在Java集合框架中，`LinkedHashMap`是一个特殊的哈希映射数据结构，它是`HashMap`的子类。与`HashMap`不同，`...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值