Java中常见数据结构Map之LinkedHashMap

Posted 2020-10-08 一枝花算不算浪漫

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Java中常见数据结构Map之LinkedHashMap相关的知识，希望对你有一定的参考价值。

前面已经说完了HashMap，接着来说下LinkedHashMap。

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

1， LinkedHashMap基本结构

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

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

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

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

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

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

(以下源码截图皆为JDK7)

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

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

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

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

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

LinkedHashMap的元素关系如下：

2， LinkedHashMap中主要方法介绍

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

以下部分截取自： http://www.cnblogs.com/xiaoxi/p/6170590.html 感谢原作者，写的确实很好。

假如有这么一段代码：

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的方式维护数据插入顺序。

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

Java集合详解6：TreeMap和红黑树

Java中常见数据结构Set之HashSet

Java集合之Map

JAVA-初步认识-常用对象API(集合框架-Map集合常见子类对象)

Java中常见数据结构：list与map -底层如何实现