LinkedHashMap实现原理

1.LinkedHashMap 概述

HashMap 是无序的，HashMap在 put的时候是根据 key的 hashcode进行 hash然后放入对应的地方。所以在按照一定顺序 put进 HashMap中，然后遍历出 HashMap的顺序跟 put的顺序不同（除非在 put的时候 key已经按照 hashcode排序号了，这种几率非常小）

JAVA 在 JDK1.4以后提供了 LinkedHashMap来帮助我们实现了有序的 HashMap！

LinkedHashMap 是 HashMap 的一个子类，它保留插入的顺序，如果需要输出的顺序和输入时的相同，那么就选用LinkedHashMap。

LinkedHashMap 是 Map 接口的哈希表和链接列表实现，具有可预知的迭代顺序。此实现提供所有可选的映射操作，并允许使用null 值和null 键。此类不保证映射的顺序，特别是它不保证该顺序恒久不变。

LinkedHashMap 实现与 HashMap 的不同之处在于，LinkedHashMap维护着一个运行于所有条目的双重链接列表。此链接列表定义了迭代顺序，该迭代顺序可以是插入顺序或者是访问顺序。

注意，此实现不是同步的。如果多个线程同时访问链接的哈希映射，而其中至少一个线程从结构上修改了该映射，则它必须保持外部同步。

根据链表中元素的顺序可以分为：按插入顺序的链表，和按访问顺序(调用get 方法)的链表。默认是按插入顺序排序，如果指定按访问顺序排序，那么调用get方法后，会将这次访问的元素移至链表尾部，不断访问可以形成按访问顺序排序的链表。

小 Demo

我在最开始学习 LinkedHashMap的时候，看到访问顺序、插入顺序等等，有点晕了，随着后续的学习才慢慢懂得其中原理，所以我会先在进行做几个demo 来演示一下LinkedHashMap 的使用。看懂了其效果，然后再来研究其原理。

HashMap

看下面这个代码：

public static void main(String[] args) {    Map<String, String> map = new HashMap<String, String>();    map.put("apple", "苹果");    map.put("watermelon", "西瓜");    map.put("banana", "香蕉");    map.put("peach", "桃子");    Iterator iter = map.entrySet().iterator();    while (iter.hasNext()) {        Map.Entry entry = (Map.Entry) iter.next();        System.out.println(entry.getKey() + "=" + entry.getValue());    }}

一个比较简单的测试 HashMap的代码，通过控制台的输出，我们可以看到 HashMap是没有顺序的。

banana=香蕉apple=苹果peach=桃子watermelon=西瓜

LinkedHashMap

我们现在将 map 的实现换成 LinkedHashMap，其他代码不变：Map<String, String> map = new LinkedHashMap<String, String>();

看一下控制台的输出：

apple=苹果watermelon=西瓜banana=香蕉peach=桃子

我们可以看到，其输出顺序是完成按照插入顺序的！也就是我们上面所说的保留了插入的顺序。我们不是在上面还提到过其可以按照访问顺序进行排序么？好的，我们还是通过一个例子来验证一下：

public static void main(String[] args) {    Map<String, String> map = new LinkedHashMap<String, String>(16,0.75f,true);    map.put("apple", "苹果");    map.put("watermelon", "西瓜");    map.put("banana", "香蕉");    map.put("peach", "桃子");    map.get("banana");    map.get("apple");    Iterator iter = map.entrySet().iterator();    while (iter.hasNext()) {        Map.Entry entry = (Map.Entry) iter.next();        System.out.println(entry.getKey() + "=" + entry.getValue());    }}

代码与之前的都差不多，但我们多了两行代码，并且初始化 LinkedHashMap的时候，用的构造函数也不相同，看一下控制台的输出结果：

watermelon=西瓜peach=桃子banana=香蕉apple=苹果

这也就是我们之前提到过的，LinkedHashMap可以选择按照访问顺序进行排序。

2.LinkedHashMap 的实现

对于 LinkedHashMap而言，它继承与 HashMap(public class LinkedHashMap<K,V> extends HashMap<K,V> implements Map<K,V>)、底层使用哈希表与双向链表来保存所有元素。其基本操作与父类 HashMap 相似，它通过重写父类相关的方法，来实现自己的链接列表特性。下面我们来分析 LinkedHashMap 的源代码：

成员变量

LinkedHashMap 采用的 hash 算法和 HashMap 相同，但是它重新定义了数组中保存的元素Entry，该Entry 除了保存当前对象的引用外，还保存了其上一个元素before 和下一个元素after 的引用，从而在哈希表的基础上又构成了双向链接列表。看源代码：

/*** The iteration ordering method for this linked hash map: <tt>true</tt>* for access-order, <tt>false</tt> for insertion-order.* 如果为true，则按照访问顺序；如果为false，则按照插入顺序。*/private final boolean accessOrder;/*** 双向链表的表头元素。 */private transient Entry<K,V> header;/*** LinkedHashMap的Entry元素。* 继承HashMap的Entry元素，又保存了其上一个元素before和下一个元素after的引用。 */private static class Entry<K,V> extends HashMap.Entry<K,V> {    Entry<K,V> before, after;    ……}

LinkedHashMap 中的 Entry 集成与HashMap 的Entry，但是其增加了before 和after 的引用，指的是上一个元素和下一个元素的引用。

初始化

通过源代码可以看出，在 LinkedHashMap的构造方法中，实际调用了父类 HashMap的相关构造方法来构造一个底层存放的 table数组，但额外可以增加 accessOrder这个参数，如果不设置，默认为 false，代表按照插入顺序进行迭代；当然可以显式设置为true，代表以访问顺序进行迭代。如：

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

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

但在 LinkedHashMap重写了 init() 方法，在调用父类的构造方法完成构造后，进一步实现了对其元素 Entry的初始化操作。

/*** Called by superclass constructors and pseudoconstructors (clone,* readObject) before any entries are inserted into the map.  Initializes* the chain.*/@Overridevoid init() {  header = new Entry<>(-1, null, null, null);  header.before = header.after = header;}

存储

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)，提供了自己特有的双向链接列表的实现。我们在之前的文章中已经讲解了HashMap的put方法，我们在这里重新贴一下HashMap 的put 方法的源代码：

HashMap.put:

public V put(K key, V value) {        if (key == null)            return putForNullKey(value);        int hash = hash(key);        int i = indexFor(hash, table.length);        for (Entry<K,V> e = table[i]; e != null; e = e.next) {            Object k;            if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {                V oldValue = e.value;                e.value = value;                e.recordAccess(this);                return oldValue;            }        }        modCount++;        addEntry(hash, key, value, i);        return null;}

重写方法：

void recordAccess(HashMap<K,V> m) {    LinkedHashMap<K,V> lm = (LinkedHashMap<K,V>)m;    if (lm.accessOrder) {        lm.modCount++;        remove();        addBefore(lm.header);        }}void addEntry(int hash, K key, V value, int bucketIndex) {    // 调用create方法，将新元素以双向链表的的形式加入到映射中。    createEntry(hash, key, value, bucketIndex);    // 删除最近最少使用元素的策略定义    Entry<K,V> eldest = header.after;    if (removeEldestEntry(eldest)) {        removeEntryForKey(eldest.key);    } else {        if (size >= threshold)            resize(2 * table.length);    }}void createEntry(int hash, K key, V value, int bucketIndex) {    HashMap.Entry<K,V> old = table[bucketIndex];    Entry<K,V> e = new Entry<K,V>(hash, key, value, old);    table[bucketIndex] = e;    // 调用元素的addBrefore方法，将元素加入到哈希、双向链接列表。      e.addBefore(header);    size++;}private void addBefore(Entry<K,V> existingEntry) {    after  = existingEntry;    before = existingEntry.before;    before.after = this;    after.before = this;}

读取

LinkedHashMap 重写了父类 HashMap 的 get 方法，实际在调用父类getEntry() 方法取得查找的元素后，再判断当排序模式accessOrder 为true 时，记录访问顺序。由于的链表的增加、删除操作是常量级的，性能不会带来较大损失。LinkedHashMap最牛逼的地方在于recordAccess()方法

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;}

1.//覆写HashMap中的recordAccess方法（HashMap中该方法为空），  2.//当调用父类的put方法，在发现插入的key已经存在时，会调用该方法，  3.//调用LinkedHashmap覆写的get方法时，也会调用到该方法，  4.//该方法提供了LRU算法的实现，它将最近使用的Entry放到双向循环链表的尾部，  5.//accessOrder为true时，get方法会调用recordAccess方法  6.//put方法在覆盖key-value对时也会调用recordAccess方法  7.//它们导致Entry最近使用，因此将其移到双向链表的末尾  8.void recordAccess(HashMap<K,V> m) {  9.    LinkedHashMap<K,V> lm = (LinkedHashMap<K,V>)m;  10.    //如果链表中元素按照访问顺序排序，则将当前访问的Entry移到双向循环链表的尾部，  11.    //如果是按照插入的先后顺序排序，则不做任何事情。  12.    if (lm.accessOrder) {  13.        lm.modCount++;  14.        remove();//移除当前访问的Entry  15.        addBefore(lm.header);//将当前访问的Entry插入到链表的尾部  16.    }  17.}  

1./** 2.* Removes this entry from the linked list. 3.*/  4.private void remove() {  5.    before.after = after;  6.    after.before = before;  7.}  8.  9./**clear链表，设置header为初始状态*/  10.public void clear() {  11. super.clear();  12. header.before = header.after = header;  13.}  

排序模式

LinkedHashMap 定义了排序模式 accessOrder，该属性为boolean 型变量，对于访问顺序，为true；对于插入顺序，则为false。一般情况下，不必指定排序模式，其迭代顺序即为默认为插入顺序。

这些构造方法都会默认指定排序模式为插入顺序。如果你想构造一个 LinkedHashMap，并打算按从近期访问最少到近期访问最多的顺序（即访问顺序）来保存元素，那么请使用下面的构造方法构造LinkedHashMap：public LinkedHashMap(int initialCapacity, float loadFactor, boolean accessOrder)

该哈希映射的迭代顺序就是最后访问其条目的顺序，这种映射很适合构建 LRU缓存。LinkedHashMap提供了 removeEldestEntry(Map.Entry<K,V> eldest)方法。该方法可以提供在每次添加新条目时移除最旧条目的实现程序，默认返回 false，这样，此映射的行为将类似于正常映射，即永远不能移除最旧的元素。

我们会在后面的文章中详细介绍关于如何用 LinkedHashMap构建 LRU 缓存。

3.总结

其实 LinkedHashMap几乎和 HashMap一样：从技术上来说，不同的是它定义了一个 Entry<K,V> header，这个 header不是放在 Table里，它是额外独立出来的。LinkedHashMap通过继承 hashMap中的 Entry<K,V>,并添加两个属性Entry<K,V> before,after,和header 结合起来组成一个双向链表，来实现按插入顺序或访问顺序排序。

LinkedHashMap是HashMap+LinkedList的结合

新元素put进来的Entry会保存在HashMap中，同时它也会被加入一个header为头指针的双向循环链表的尾部！

在写关于 LinkedHashMap的过程中，记起来之前面试的过程中遇到的一个问题，也是问我 Map的哪种实现可以做到按照插入顺序进行迭代？当时脑子是突然短路的，但现在想想，也只能怪自己对这个知识点还是掌握的不够扎实，所以又从头认真的把代码看了一遍。

不过，我的建议是，大家首先首先需要记住的是：LinkedHashMap能够做到按照插入顺序或者访问顺序进行迭代，这样在我们以后的开发中遇到相似的问题，才能想到用 LinkedHashMap 来解决，否则就算对其内部结构非常了解，不去使用也是没有什么用的。