Java中常见数据结构Map之LinkedHashMap

柔光的暖阳◎ 2022-05-14 02:28 256阅读 0赞

看到Linked就知道它是有序的Map，即插入顺序和取出顺序是一致的， 究竟是怎样做到的呢？ 下面就一窥源码吧。

**1， LinkedHashMap基本结构**

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

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

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

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

根据链表中元素的顺序可以分为：**按插入顺序的链表，和按访问顺序(调用get方法)的链表。**

默认是按插入顺序排序，如果指定按访问顺序排序，那么调用get方法后，会将这次访问的元素移至链表尾部，不断访问可以形成按访问顺序排序的链表。  可以重写removeEldestEntry方法返回true值指定插入元素时移除最老的元素。

(以下源码截图皆为JDK7)

[![Image(4)][Image_4]][Image_4_Image_4]

LinkedHashMap是继承HashMap， 也就是说LinkedHashMap的结构也是和HashMap那样(数组+链表)。

LinkedHashMap最大的差别在于Entry的定义上：

[![Image(5)][Image_5]][Image_5_Image_5]

这里维护了一个before和after的Entry， 见名思意， 就是每个Entry<K,V>都维护它的上一个元素和下一个元素的关系。这也是LinkedHashMap有序的关键所在。

接着我们再看下header的定义：

[![Image(6)][Image_6]][Image_6_Image_6]

上图可以看出header的hash值为-1， 所以并不在hash表的table上。 其实header就是为了记录双向链表的头结点和尾节点。

LinkedHashMap的元素关系如下：

[![Image(7)][Image_7]][Image_7_Image_7]

**2， LinkedHashMap中主要方法介绍**

LinkedHashMap中重写的方法不是很多， 请看下图：

[![Image(8)][Image_8]][Image_8_Image_8]

假如有这么一段代码：

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，那么初始化完毕，实际上是这样的：

![249993-20161213164756542-224440628.png][]

注意这个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，那么用图表示是这样的：

![249993-20161214110719058-422696089.png][]

如果熟悉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\]上，用图表示是这样的：

![249993-20161214112800604-1097231647.png][]

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

注意，这里的插入有两重含义：

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

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

**3、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;
    }

**4、利用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的过程吧：

![249993-20161214141549995-522671418.png][]

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

**5、代码演示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），被访问的元素都被提到最后面去了

[Image_4]: https://images2017.cnblogs.com/blog/799093/201709/799093-20170923233420790-944756962.png
[Image_4_Image_4]: /images/20220514/1d350db27c684f7aa6c181a35bc94222.png
[Image_5]: https://images2017.cnblogs.com/blog/799093/201709/799093-20170923233422087-1290290404.png
[Image_5_Image_5]: /images/20220514/48b9488fcbdc434796fc98c89c23f446.png
[Image_6]: https://images2017.cnblogs.com/blog/799093/201709/799093-20170923233423243-1264764462.png
[Image_6_Image_6]: /images/20220514/14839095aff7402294ef67aecd80714d.png
[Image_7]: https://images2017.cnblogs.com/blog/799093/201709/799093-20170923233424384-870091534.png
[Image_7_Image_7]: /images/20220514/cbeffdea205444ec87ba0c67b0408155.png
[Image_8]: https://images2017.cnblogs.com/blog/799093/201709/799093-20170923233426681-502272644.png
[Image_8_Image_8]: /images/20220514/59c980c34e884c8abed9e090a9c4e4e9.png
[249993-20161213164756542-224440628.png]: /images/20220514/319f13ac41414bc1b585108d2dbfcc6d.png
[249993-20161214110719058-422696089.png]: /images/20220514/4df6e47f18f9417983bf20790a8c5af3.png
[249993-20161214112800604-1097231647.png]: /images/20220514/96209dc36cd64a7994f53f5a60b88db0.png
[249993-20161214141549995-522671418.png]: /images/20220514/ff437820df4140a7a625c0fdcd48d2c5.png