Java集合之LinkedHashMap

本文深入剖析了LinkedHashMap的工作原理,包括其基本结构、初始化过程、存储和读取元素的方法,以及如何利用它实现LRU缓存算法。同时,通过示例代码展示了按照访问顺序排序的效果。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

一、初识LinkedHashMap

上篇文章讲了HashMap。HashMap是一种非常常见、非常有用的集合,但在多线程情况下使用不当会有线程安全问题。

大多数情况下,只要不涉及线程安全问题,Map基本都可以使用HashMap,不过HashMap有一个问题,就是迭代HashMap的顺序并不是HashMap放置的顺序也就是无序。HashMap的这一缺点往往会带来困扰,因为有些场景,我们期待一个有序的Map。

这个时候,LinkedHashMap就闪亮登场了,它虽然增加了时间和空间上的开销,但是通过维护一个运行于所有条目的双向链表,LinkedHashMap保证了元素迭代的顺序该迭代顺序可以是插入顺序或者是访问顺序。

二、四个关注点在LinkedHashMap上的答案

关  注  点结      论
LinkedHashMap是否允许空Key和Value都允许空
LinkedHashMap是否允许重复数据Key重复会覆盖、Value允许重复
LinkedHashMap是否有序有序
LinkedHashMap是否线程安全非线程安全

 

 

 

 

 

三、LinkedHashMap基本结构

关于LinkedHashMap,先提两点:

1、LinkedHashMap可以认为是HashMap+LinkedList即它既使用HashMap操作数据结构,又使用LinkedList维护插入元素的先后顺序。

2、LinkedHashMap的基本实现思想就是----多态可以说,理解多态,再去理解LinkedHashMap原理会事半功倍;反之也是,对于LinkedHashMap原理的学习,也可以促进和加深对于多态的理解。

为什么可以这么说,首先看一下,LinkedHashMap的定义: 

public class LinkedHashMap<K,V>
    extends HashMap<K,V>
    implements Map<K,V>
{
    ...
}

看到,LinkedHashMap是HashMap的子类,自然LinkedHashMap也就继承了HashMap中所有非private的方法。再看一下LinkedHashMap中本身的方法:

看到LinkedHashMap中并没有什么操作数据结构的方法,也就是说LinkedHashMap操作数据结构(比如put一个数据),和HashMap操作数据的方法完全一样,无非就是细节上有一些的不同罢了。

LinkedHashMap只定义了两个属性:

/**
 * The head of the doubly linked list.
 * 双向链表的头节点
 */
private transient Entry<K,V> header;
/**
 * The iteration ordering method for this linked hash map: true
 * for access-order, false for insertion-order.
 * true表示最近最少使用次序,false表示插入顺序
 */
private final boolean accessOrder;

LinkedHashMap一共提供了五个构造方法:

// 构造方法1,构造一个指定初始容量和负载因子的、按照插入顺序的LinkedList
public LinkedHashMap(int initialCapacity, float loadFactor) {
    super(initialCapacity, loadFactor);
    accessOrder = false;
}
// 构造方法2,构造一个指定初始容量的LinkedHashMap,取得键值对的顺序是插入顺序
public LinkedHashMap(int initialCapacity) {
    super(initialCapacity);
    accessOrder = false;
}
// 构造方法3,用默认的初始化容量和负载因子创建一个LinkedHashMap,取得键值对的顺序是插入顺序
public LinkedHashMap() {
    super();
    accessOrder = false;
}
// 构造方法4,通过传入的map创建一个LinkedHashMap,容量为默认容量(16)和(map.zise()/DEFAULT_LOAD_FACTORY)+1的较大者,装载因子为默认值
public LinkedHashMap(Map<? extends K, ? extends V> m) {
    super(m);
    accessOrder = false;
}
// 构造方法5,根据指定容量、装载因子和键值对保持顺序创建一个LinkedHashMap
public LinkedHashMap(int initialCapacity,
             float loadFactor,
                         boolean accessOrder) {
    super(initialCapacity, loadFactor);
    this.accessOrder = accessOrder;
}

从构造方法中可以看出,默认都采用插入顺序来维持取出键值对的次序。所有构造方法都是通过调用父类的构造方法来创建对象的。

LinkedHashMap和HashMap的区别在于它们的基本数据结构上,看一下LinkedHashMap的基本数据结构,也就是Entry:

private static class Entry<K,V> extends HashMap.Entry<K,V> {
    // These fields comprise the doubly linked list used for iteration.
    Entry<K,V> before, after;

    Entry(int hash, K key, V value, HashMap.Entry<K,V> next) {
        super(hash, key, value, next);
    }
    ...
}

列一下Entry里面有的一些属性吧:

1、K key

2、V value

3、Entry<K, V> next

4、int hash

5、Entry<K, V> before

6、Entry<K, V> after

其中前面四个,也就是红色部分是从HashMap.Entry中继承过来的;后面两个,也就是蓝色部分是LinkedHashMap独有的。不要搞错了next和before、After,next是用于维护HashMap指定table位置上连接的Entry的顺序的,before、After是用于维护Entry插入的先后顺序的

还是用图表示一下,列一下属性而已:

第一张图为LinkedHashMap整体结构图,第二张图专门把循环双向链表抽取出来,直观一点,注意该循环双向链表的头部存放的是最久访问的节点或最先插入的节点,尾部为最近访问的或最近插入的节点,迭代器遍历方向是从链表的头部开始到链表尾部结束,在链表尾部有一个空的header节点,该节点不存放key-value内容,为LinkedHashMap类的成员属性,循环双向链表的入口。

四、初始化LinkedHashMap

假如有这么一段代码:

1 public static void main(String[] args)
2 {
3     LinkedHashMap<String, String> linkedHashMap =
4             new LinkedHashMap<String, String>();
5     linkedHashMap.put("111", "111");
6     linkedHashMap.put("222", "222");
7 }

首先是第3行~第4行,new一个LinkedHashMap出来,看一下做了什么:

通过源代码可以看出,在LinkedHashMap的构造方法中,实际调用了父类HashMap的相关构造方法来构造一个底层存放的table数组。

1 public LinkedHashMap() {
2     super();
3     accessOrder = false;
4 }
1 public HashMap() {
2     this.loadFactor = DEFAULT_LOAD_FACTOR;
3     threshold = (int)(DEFAULT_INITIAL_CAPACITY * DEFAULT_LOAD_FACTOR);
4     table = new Entry[DEFAULT_INITIAL_CAPACITY];
5     init();
6 }

我们已经知道LinkedHashMap的Entry元素继承HashMap的Entry,提供了双向链表的功能。在上述HashMap的构造器中,最后会调用init()方法,进行相关的初始化,这个方法在HashMap的实现中并无意义,只是提供给子类实现相关的初始化调用。
LinkedHashMap重写了init()方法,在调用父类的构造方法完成构造后,进一步实现了对其元素Entry的初始化操作。

1 void init() {
2      header = new Entry<K,V>(-1, null, null, null);
3      header.before = header.after = header;
4 }

这里出现了第一个多态:init()方法。尽管init()方法定义在HashMap中,但是由于:

1、LinkedHashMap重写了init方法

2、实例化出来的是LinkedHashMap

因此实际调用的init方法是LinkedHashMap重写的init方法。假设header的地址是0x00000000,那么初始化完毕,实际上是这样的:

注意这个header,hash值为-1,其他都为null,也就是说这个header不放在数组中,就是用来指示开始元素和标志结束元素的。

header的目的是为了记录第一个插入的元素是谁,在遍历的时候能够找到第一个元素。

五、LinkedHashMap存储元素

LinkedHashMap并未重写父类HashMap的put方法,而是重写了父类HashMap的put方法调用的子方法void recordAccess(HashMap m)  ,void addEntry(int hash, K key, V value, int bucketIndex) 和void createEntry(int hash, K key, V value, int bucketIndex),提供了自己特有的双向链接列表的实现。

继续看LinkedHashMap存储元素,也就是put("111","111")做了什么,首先当然是调用HashMap的put方法:

 1 //这个方法应该挺熟悉的,如果看了HashMap的解析的话
 2 public V put(K key, V value) {
 3     //key为null的情况
 4     if (key == null)
 5         return putForNullKey(value);
 6     //通过key算hash,进而算出在数组中的位置,也就是在第几个桶中
 7     int hash = hash(key.hashCode());
 8     int i = indexFor(hash, table.length);
 9     //查看桶中是否有相同的key值,如果有就直接用新值替换旧值,而不用再创建新的entry了
10     for (Entry<K,V> e = table[i]; e != null; e = e.next) {
11         Object k;
12         if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
13             V oldValue = e.value;
14             e.value = value;
15             e.recordAccess(this);
16             return oldValue;
17         }
18     }
19 
20     modCount++;    
21     //上面度是熟悉的东西,最重要的地方来了,就是这个方法,LinkedHashMap执行到这里,addEntry()方法不会执行HashMap中的方法,
22     //而是执行自己类中的addEntry方法,
23     addEntry(hash, key, value, i);
24     return null;
25 }

第23行又是一个多态,因为LinkedHashMap重写了addEntry方法,因此addEntry调用的是LinkedHashMap重写了的方法:

 1 void addEntry(int hash, K key, V value, int bucketIndex) {
 2     //调用create方法,将新元素以双向链表的的形式加入到映射中
 3     createEntry(hash, key, value, bucketIndex);
 4 
 5     // Remove eldest entry if instructed, else grow capacity if appropriate
 6     // 删除最近最少使用元素的策略定义  
 7     Entry<K,V> eldest = header.after;
 8     if (removeEldestEntry(eldest)) {
 9         removeEntryForKey(eldest.key);
10     } else {
11         if (size >= threshold)
12             resize(2 * table.length);
13     }
14 }

因为LinkedHashMap由于其本身维护了插入的先后顺序,因此LinkedHashMap可以用来做缓存,第7行~第9行是用来支持FIFO算法的,这里暂时不用去关心它。看一下createEntry方法: 

1 void createEntry(int hash, K key, V value, int bucketIndex) {
2     HashMap.Entry<K,V> old = table[bucketIndex];
3     Entry<K,V> e = new Entry<K,V>(hash, key, value, old);
4     table[bucketIndex] = e;
5     //将该节点插入到链表尾部
6     e.addBefore(header);
7     size++;
8 }
private void addBefore(Entry<K,V> existingEntry) {
    after  = existingEntry;
    before = existingEntry.before;
    before.after = this;
    after.before = this;
}

createEntry(int hash,K key,V value,int bucketIndex)方法覆盖了父类HashMap中的方法。这个方法不会拓展table数组的大小。该方法首先保留table中bucketIndex处的节点,然后调用Entry的构造方法(将调用到父类HashMap.Entry的构造方法)添加一个节点,即将当前节点的next引用指向table[bucketIndex] 的节点,之后调用的e.addBefore(header)是修改链表,将e节点添加到header节点之前。

第2行~第4行的代码和HashMap没有什么不同,新添加的元素放在table[i]上,差别在于LinkedHashMap还做了addBefore操作,这四行代码的意思就是让新的Entry和原链表生成一个双向链表。假设字符串111放在位置table[1]上,生成的Entry地址为0x00000001,那么用图表示是这样的:

如果熟悉LinkedList的源码应该不难理解,还是解释一下,注意下existingEntry表示的是header:

1、after=existingEntry,即新增的Entry的after=header地址,即after=0x00000000

2、before=existingEntry.before,即新增的Entry的before是header的before的地址,header的before此时是0x00000000,因此新增的Entry的before=0x00000000

3、before.after=this,新增的Entry的before此时为0x00000000即header,header的after=this,即header的after=0x00000001

4、after.before=this,新增的Entry的after此时为0x00000000即header,header的before=this,即header的before=0x00000001

这样,header与新增的Entry的一个双向链表就形成了。再看,新增了字符串222之后是什么样的,假设新增的Entry的地址为0x00000002,生成到table[2]上,用图表示是这样的:

 

就不细解释了,只要before、after清除地知道代表的是哪个Entry的就不会有什么问题。

注意,这里的插入有两重含义:

1.从table的角度看,新的entry需要插入到对应的bucket里,当有哈希冲突时,采用头插法将新的entry插入到冲突链表的头部。
2.从header的角度看,新的entry需要插入到双向链表的尾部。

总得来看,再说明一遍,LinkedHashMap的实现就是HashMap+LinkedList的实现方式,以HashMap维护数据结构,以LinkList的方式维护数据插入顺序。

六、LinkedHashMap读取元素

LinkedHashMap重写了父类HashMap的get方法,实际在调用父类getEntry()方法取得查找的元素后,再判断当排序模式accessOrder为true时(即按访问顺序排序),先将当前节点从链表中移除,然后再将当前节点插入到链表尾部。由于的链表的增加、删除操作是常量级的,故并不会带来性能的损失。

/**
 * 通过key获取value,与HashMap的区别是:当LinkedHashMap按访问顺序排序的时候,会将访问的当前节点移到链表尾部(头结点的前一个节点)
 */
public V get(Object key) {
    // 调用父类HashMap的getEntry()方法,取得要查找的元素。  
    Entry<K,V> e = (Entry<K,V>)getEntry(key);
    if (e == null)
        return null;
    // 记录访问顺序。
    e.recordAccess(this);
    return e.value;
}
/**
 * 在HashMap的put和get方法中,会调用该方法,在HashMap中该方法为空
 * 在LinkedHashMap中,当按访问顺序排序时,该方法会将当前节点插入到链表尾部(头结点的前一个节点),否则不做任何事
 */
void recordAccess(HashMap<K,V> m) {
    LinkedHashMap<K,V> lm = (LinkedHashMap<K,V>)m;
    //当LinkedHashMap按访问排序时
    if (lm.accessOrder) {
        lm.modCount++;
        //移除当前节点
        remove();
        //将当前节点插入到头结点前面
        addBefore(lm.header);
    }
}
/**
 * 移除节点,并修改前后引用
 */
private void remove() {
    before.after = after;
    after.before = before;
}
private void addBefore(Entry<K,V> existingEntry) {
    after  = existingEntry;
    before = existingEntry.before;
    before.after = this;
    after.before = this;
}

七、利用LinkedHashMap实现LRU算法缓存

前面讲了LinkedHashMap添加元素,删除、修改元素就不说了,比较简单,和HashMap+LinkedList的删除、修改元素大同小异,下面讲一个新的内容。

LinkedHashMap可以用来作缓存,比方说LRUCache,看一下这个类的代码,很简单,就十几行而已:

public class LRUCache extends LinkedHashMap
{
    public LRUCache(int maxSize)
    {
        super(maxSize, 0.75F, true);
        maxElements = maxSize;
    }

    protected boolean removeEldestEntry(java.util.Map.Entry eldest)
    {
        return size() > maxElements;
    }

    private static final long serialVersionUID = 1L;
    protected int maxElements;
}

顾名思义,LRUCache就是基于LRU算法的Cache(缓存),这个类继承自LinkedHashMap,而类中看到没有什么特别的方法,这说明LRUCache实现缓存LRU功能都是源自LinkedHashMap的。LinkedHashMap可以实现LRU算法的缓存基于两点:

1、LinkedList首先它是一个Map,Map是基于K-V的,和缓存一致

2、LinkedList提供了一个boolean值可以让用户指定是否实现LRU

那么,首先我们了解一下什么是LRU:LRU即Least Recently Used,最近最少使用,也就是说,当缓存满了,会优先淘汰那些最近最不常访问的数据。比方说数据a,1天前访问了;数据b,2天前访问了,缓存满了,优先会淘汰数据b。

我们看一下LinkedList带boolean型参数的构造方法:

public LinkedHashMap(int initialCapacity,
         float loadFactor,
                     boolean accessOrder) {
    super(initialCapacity, loadFactor);
    this.accessOrder = accessOrder;
}

就是这个accessOrder,它表示:

(1)false,所有的Entry按照插入的顺序排列

(2)true,所有的Entry按照访问的顺序排列

第二点的意思就是,如果有1 2 3这3个Entry,那么访问了1,就把1移到尾部去,即2 3 1。每次访问都把访问的那个数据移到双向队列的尾部去,那么每次要淘汰数据的时候,双向队列最头的那个数据不就是最不常访问的那个数据了吗?换句话说,双向链表最头的那个数据就是要淘汰的数据。

"访问",这个词有两层意思:

1、根据Key拿到Value,也就是get方法

2、修改Key对应的Value,也就是put方法

首先看一下get方法,它在LinkedHashMap中被重写:

public V get(Object key) {
    Entry<K,V> e = (Entry<K,V>)getEntry(key);
    if (e == null)
        return null;
    e.recordAccess(this);
    return e.value;
}

然后是put方法,沿用父类HashMap的:

 1 public V put(K key, V value) {
 2     if (key == null)
 3         return putForNullKey(value);
 4     int hash = hash(key.hashCode());
 5     int i = indexFor(hash, table.length);
 6     for (Entry<K,V> e = table[i]; e != null; e = e.next) {
 7         Object k;
 8         if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
 9             V oldValue = e.value;
10             e.value = value;
11             e.recordAccess(this);
12             return oldValue;
13         }
14     }
15 
16     modCount++;
17     addEntry(hash, key, value, i);
18     return null;
19 }

修改数据也就是第6行~第14行的代码。看到两端代码都有一个共同点:都调用了recordAccess方法且这个方法是Entry中的方法,也就是说每次的recordAccess操作的都是某一个固定的Entry。

recordAccess,顾名思义,记录访问,也就是说你这次访问了双向链表,我就把你记录下来,怎么记录?把你访问的Entry移到尾部去这个方法在HashMap中是一个空方法,就是用来给子类记录访问用的,看一下LinkedHashMap中的实现:

void recordAccess(HashMap<K,V> m) {
    LinkedHashMap<K,V> lm = (LinkedHashMap<K,V>)m;
    if (lm.accessOrder) {
        lm.modCount++;
        remove();
        addBefore(lm.header);
    }
}
private void remove() {
    before.after = after;
    after.before = before;
}
private void addBefore(Entry<K,V> existingEntry) {
    after  = existingEntry;
    before = existingEntry.before;
    before.after = this;
    after.before = this;
}

看到每次recordAccess的时候做了两件事情:

1、把待移动的Entry的前后Entry相连

2、把待移动的Entry移动到尾部

当然,这一切都是基于accessOrder=true的情况下。最后用一张图表示一下整个recordAccess的过程吧:

void recordAccess(HashMap<K,V> m) 这个方法就是我们一开始说的,accessOrder为true时,就是使用的访问顺序,访问次数最少到访问次数最多,此时要做特殊处理。处理机制就是访问了一次,就将自己往后移一位,这里就是先将自己删除了,然后在把自己添加,这样,近期访问的少的就在链表的开始,最近访问的元素就会在链表的末尾。如果为false。那么默认就是插入顺序,直接通过链表的特点就能依次找到插入元素,不用做特殊处理。

八、代码演示LinkedHashMap按照访问顺序排序的效果

最后代码演示一下LinkedList按照访问顺序排序的效果,验证一下上一部分LinkedHashMap的LRU功能:

public static void main(String[] args)
{
    LinkedHashMap<String, String> linkedHashMap =
            new LinkedHashMap<String, String>(16, 0.75f, true);
    linkedHashMap.put("111", "111");
    linkedHashMap.put("222", "222");
    linkedHashMap.put("333", "333");
    linkedHashMap.put("444", "444");
    loopLinkedHashMap(linkedHashMap);
    linkedHashMap.get("111");
    loopLinkedHashMap(linkedHashMap);
    linkedHashMap.put("222", "2222");
    loopLinkedHashMap(linkedHashMap);
}
    
public static void loopLinkedHashMap(LinkedHashMap<String, String> linkedHashMap)
{
    Set<Map.Entry<String, String>> set = inkedHashMap.entrySet();
    Iterator<Map.Entry<String, String>> iterator = set.iterator();
    
    while (iterator.hasNext())
    {
        System.out.print(iterator.next() + "\t");
    }
    System.out.println();
}

注意这里的构造方法要用三个参数那个且最后的要传入true,这样才表示按照访问顺序排序。看一下代码运行结果:

111=111    222=222    333=333    444=444    
222=222    333=333    444=444    111=111    
333=333    444=444    111=111    222=2222   

代码运行结果证明了两点:

1、LinkedList是有序的

2、每次访问一个元素(get或put),被访问的元素都被提到最后面去了

 

<think>嗯,用户让我介绍一下Java集合中的LinkedHashMap,还要结合源码分析。首先,我得回忆一下LinkedHashMap的基本概念和它在Java集合框架中的位置。LinkedHashMap是HashMap的子类,所以它应该具有HashMap的所有特性,比如允许null键值,非同步等等。但它的特殊之处在于维护了一个双向链表,用来保持插入顺序或者访问顺序。这可能就是用户想深入了解的地方。 接下来,我需要考虑用户的需求。他们可能已经对HashMap有一定的了解,现在想进一步学习LinkedHashMap的工作原理和内部实现。所以,我应该先对比HashMap和LinkedHashMap的区别,强调LinkedHashMap的有序性。然后,可能需要讲解LinkedHashMap数据结构,比如Entry节点的结构,双向链表是如何维护的。 然后,源码分析部分需要深入LinkedHashMap的关键方法,比如put、get、remove,以及如何维护访问顺序。比如,在HashMap的put方法中,LinkedHashMap可能重写了某些方法,比如afterNodeAccess和afterNodeInsertion,这些钩子方法的作用是什么。另外,访问顺序模式下,最近访问的节点会被移动到链表末尾,这在实现LRU缓存时很有用,这个点可能也需要提到。 用户可能还想知道LinkedHashMap如何实现迭代顺序的有序性。这时候需要分析迭代器的实现,可能是通过遍历双向链表而不是像HashMap那样遍历桶数组。此外,构造方法中的accessOrder参数的作用,以及如何影响元素顺序,这也是关键点。 另外,要注意到LinkedHashMap在实现LRU缓存时的应用。当accessOrder设置为true时,每次访问元素都会调整顺序,当达到容量时,会移除最老的元素。这部分可能需要结合removeEldestEntry方法的源码,说明如何扩展这个方法来控制缓存策略。 在结构上,应该先介绍LinkedHashMap的基本概念,然后数据结构,接着关键源码分析,最后应用场景。可能还需要给出一个简单的例子,比如如何用LinkedHashMap实现LRU缓存,这样用户更容易理解。 需要确认是否覆盖了主要的方法和内部类,比如Entry的结构,是否有新增的字段如before和after。同时,要注意源码的版本是否正确,假设是Java 8的源码,因为不同版本可能有差异。例如,在Java 8中,HashMap引入了树化结构,但LinkedHashMap仍然使用双向链表,这部分是否需要提及? 在讲解源码时,可能需要用代码块展示关键部分,比如Entry类的定义,以及afterNodeAccess方法的具体实现。但要注意不要粘贴过多代码,而是选择关键部分进行解释。 另外,用户可能对LinkedHashMap的性能感兴趣,比如HashMap相比,插入、删除、访问的时间复杂度是否有变化。虽然LinkedHashMap维护了双向链表,但大多数操作的时间复杂度仍然是O(1),因为链表操作是常量时间的。 最后,总结LinkedHashMap的特点和适用场景,帮助用户理解何时应该选择LinkedHashMap而不是其他集合类。例如,需要保持插入顺序或访问顺序,或者需要实现简单的LRU缓存时。 需要确保解释清晰,逻辑连贯,避免技术术语过多导致理解困难。同时,结合源码分析时要抓住重点,展示关键代码部分并解释其作用,帮助用户理解内部机制。</think>### Java 集合LinkedHashMap 解析源码分析 `LinkedHashMap` 是 `HashMap` 的子类,在保留 `HashMap` 高效查询能力的基础上,**通过双向链表维护元素的插入顺序或访问顺序**。它是实现 `LRU` 缓存策略的理想数据结构。 -- #### 核心特性 1. **有序性**:默认按插入顺序迭代,可配置为按访问顺序(最近访问的元素排在末尾)。 2. **性能**:查询、插入、删除的时间复杂度为 `O(1)`,略慢于 `HashMap`(需维护链表)。 3. **继承结构**:继承 `HashMap`,复用哈希表逻辑,重写链表维护相关方法。 --- ### 数据结构关键源码 #### 1. Entry 结构扩展 `LinkedHashMap.Entry` 继承 `HashMap.Node`,**新增 `before` 和 `after` 指针**,形成双向链表。 ```java 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); } } ``` -- #### 2. 关键属性 - **head/tail**:维护链表的头尾节点。 - **accessOrder**:`true` 表示按访问顺序排序,`false`(默认)表示按插入顺序。 ```java transient LinkedHashMap.Entry<K,V> head; // 链表头(最老元素) transient LinkedHashMap.Entry<K,V> tail; // 链表尾(最新元素) final boolean accessOrder; // 顺序控制标志 ``` --- ### 核心方法源码分析 #### 1. 插入链表维护 `LinkedHashMap` **未重写 `put()`**,直接复用 `HashMap` 的逻辑,但通过重写以下钩子方法维护链表: ```java // 插入新节点后,维护链表结构(可能触发删除最老元素) void afterNodeInsertion(boolean evict) { LinkedHashMap.Entry<K,V> first; if (evict && (first = head) != null && removeEldestEntry(first)) { removeNode(first.key, null, false, true); // 删除头节点(LRU 逻辑) } } // 是否删除最老元素(默认返回 false,需子类重写实现 LRU) protected boolean removeEldestEntry(Map.Entry<K,V> eldest) { return false; } ``` --- #### 2. 访问顺序调整 当 `accessOrder=true` 时,调用 `get()` 或 `getOrDefault()` 会触发 `afterNodeAccess()`,将节点移到链表末尾。 ```java public V get(Object key) { Node<K,V> e; if ((e = getNode(key)) == null) return null; if (accessOrder) afterNodeAccess(e); // 调整链表顺序 return e.value; } // 将节点移动到链表尾部(最近访问) void afterNodeAccess(Node<K,V> e) { LinkedHashMap.Entry<K,V> last = tail; if (accessOrder && last != e) { LinkedHashMap.Entry<K,V> p = (Entry<K,V>)e; LinkedHashMap.Entry<K,V> 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++; } } ``` --- #### 3. 迭代器实现 `LinkedHashMap` 的迭代器直接遍历双向链表,而非哈希桶数组,**保证顺序性**。 ```java abstract class LinkedHashIterator { LinkedHashMap.Entry<K,V> next = head; // 从头节点开始 LinkedHashMap.Entry<K,V> current; // ... public final boolean hasNext() { return next != null; } final LinkedHashMap.Entry<K,V> nextNode() { LinkedHashMap.Entry<K,V> e = next; // ... current = e; next = e.after; // 通过 after 指针遍历 return e; } } ``` -- ### 应用场景:实现 LRU 缓存 通过重写 `removeEldestEntry()`,限制最大容量并删除最久未使用的元素。 ```java public class LRUCache<K, V> extends LinkedHashMap<K, V> { private final int maxCapacity; public LRUCache(int maxCapacity) { super(maxCapacity, 0.75f, true); // accessOrder=true this.maxCapacity = maxCapacity; } @Override protected boolean removeEldestEntry(Map.Entry<K, V> eldest) { return size() > maxCapacity; // 容量超限时删除最老元素 } } ``` --- ### 总结 - **有序性**:双向链表维护插入/访问顺序。 - **扩展性**:通过钩子方法(如 `afterNodeAccess`)实现行为定制。 - **高效性**:在 `HashMap` 基础上以少量性能代价换取顺序控制。 - **应用场景**:需要顺序迭代或实现类似 LRU 的缓存策略时优先选择。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值