JKD1.8源码解析之LinkedHashMap

LinkedHashMap与HashMap的区别

• LinkedHashMap与HashMap主要的区别在于，LinkedHashMap可以按照访问或者插入数据的顺序遍历元素，而HashMap是散列存储和读取数据，还有一个特性值可以配置一个参数实现删除比较老旧的头结点，这个特性可以在缓存方面使用，在添加元素的时候，可以把当前在双向量表的表头数据删除掉。

LinkedHashMap类继承关系

• 继承自HashMap， 实现了map接口

3个实例变量

• transient LinkedHashMap.Entry<K,V> head;
  使用transient关键字，说明这个字段不用会被序列化到流中。双向链表的表头，在双向链表中的每个节点都是Entry,这个实体在后面在了解。

• transient LinkedHashMap.Entry<K,V> tail;
  双向链表的尾部

• final boolean accessOrder;
  是否按照访问顺序遍历，如何设置成true，那在每次get后会把get的那个节点从双向列表中移到表尾，初始化创建实例是指定，一旦指定就可可更改，因为用的是final 关键字。如果设置成false，则get后和HashMap就一样啦。

• 有5种构造方法
  构造方法的本质就是调用父类HashMap的构造方法，不同的是在调用父类构造方法后，完成accessOrder的初始化默认是false，可以通过构造方法设置这个值。其中构造方法可以实现将一个实现Map接口的集合作为参数整合到创建的LinkedHashMap中。

public LinkedHashMap(int initialCapacity) {
super(initialCapacity);
accessOrder = false;
}

既然LinkedHashMap可以实现按照访问的顺序或者插入的顺序遍历列表,就要知道这个特性的实现原理是什么才行。
先看看LinkedHashMap是如何put的，LinkedHashMap并没有实现自己的put的方法，而是在父类的putval添加了处理，看代码

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        Node<K,V>[] tab; Node<K,V> p; int n, i;
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;
        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);// 这个地方很重要，LinkedHashMap重写了 newNode ，将插入的元素添加到链表表尾，完成双向的绑定。
        else {
            Node<K,V> e; K k;
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                e = p;
            else if (p instanceof TreeNode)
                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
            else {
                for (int binCount = 0; ; ++binCount) {
                    if ((e = p.next) == null) {
                        p.next = newNode(hash, key, value, null);
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                            treeifyBin(tab, hash);
                        break;
                    }
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        break;
                    p = e;
                }
            }
            if (e != null) { // existing mapping for key
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                afterNodeAccess(e);// e 元素表示put操作后返回的旧元素，这种覆盖旧值的情况下也在访问后移动的双向链表的表尾。
                return oldValue;
            }
        }
        ++modCount;
        if (++size > threshold)
            resize();
        afterNodeInsertion(evict);// 这几话的意思是将put的元素移动到双向链表的表尾，同时这个方法中还可以指定是否删除双向链表的表头数据。
        return null;
    }

来看看newNode

Node<K,V> newNode(int hash, K key, V value, Node<K,V> e) {
        LinkedHashMap.Entry<K,V> p =
            new LinkedHashMap.Entry<K,V>(hash, key, value, e);
        linkNodeLast(p);// 主要是这个方法，linkNodeLast将当前节点连接到表尾
        return p;
    }
private void linkNodeLast(LinkedHashMap.Entry<K,V> p) {
        LinkedHashMap.Entry<K,V> last = tail;// 像这种链表操作经常用到临时变量，起到中间变换的作用
        tail = p;// 把当前节点设置成尾节点
        if (last == null)// 表尾元素为空说明双向链表为空，直接将当前节点设置成head
            head = p;
        else {// 双向链表最常用的套路
            p.before = last;
            last.after = p;
        }
    }

来看看afterNodeInsertion

void afterNodeInsertion(boolean evict) { // possibly remove eldest
        LinkedHashMap.Entry<K,V> first;
        if (evict && (first = head) != null && removeEldestEntry(first)) {// 这个removeEldestEntry 默认是false,需要继承LinkedHashMap重写这个方法才可以使用。
            K key = first.key;
            removeNode(hash(key), key, null, false, true);// 将老旧的头结点删除掉
        }
    }

public V get(Object key) { // 重写了父类的get方法
Node<K,V> e;
if ((e = getNode(hash(key), key)) == null)// 这里和父类的是一样的
return null;
if (accessOrder)
afterNodeAccess(e);// 不同的地方，当按照访问顺序遍历时，做处理
return e.value;
}
看下是如何实现将访问过的元素放在双向链表的表尾的

    void afterNodeAccess(Node<K,V> e) { // move node to last
            LinkedHashMap.Entry<K,V> last;
            if (accessOrder && (last = tail) != e) {
                LinkedHashMap.Entry<K,V> p =
                    (LinkedHashMap.Entry<K,V>)e, 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;
            }
        }

这里画张图更好，灵魂画手开始。。。

当前节点的前后节点的其他位置情况看代码类推即可。

• 性能上的差异
  但是这里有一个需要思考的问题，因为hashMap的操作的效率高的原因是应为每个桶是单链表，根据hash(key) &(n-1)的值获取数组中的第一个节点，这个节点是哈希桶的节点，然后遍历这个桶根据，key的hash值、key的equals比较寻找元素是否重复。但是LinkedHashMap每个Entry的next链接的是下一个插入的元素，那么如果两个hash值相同的key,中插入了很多元素的话，那找到下一个元素的时间就要比HashMap要多些。