【Java源码分析】LinkedHashMap源码分析

LinkedHashMap

Map接口的哈希表和链表实现，具有可预测的迭代顺序。此实现与 HashMap的不同之处在于它维护一个双向链表，该列表贯穿其所有条目。这个链表定义了迭代顺序，通常是键插入映射的顺序（插入顺序）。

实现不是同步的。

当我们将true传递给accessOrder时，我们将实例化一个访问顺序LinkedHashMap 。 访问顺序LinkedHashMap维护从最近使用到最近使用的元素的访问顺序，而不是插入顺序。

用法

插入顺序

import java.util.*;
public class Test {
    public static void main(String[] args) {
        LinkedHashMap<Integer, String> map = new LinkedHashMap<>();
        map.put(1, "A");
        map.put(2, "B");
        map.put(3, "C");
        System.out.println(map.keySet().toString());
        map.get(2);
        System.out.println(map.keySet().toString());//[1,2,3]
    }


}

访问顺序

import java.util.*;
public class Test {
    public static void main(String[] args) {
        LinkedHashMap<Integer, String> map = new LinkedHashMap<>(16,0.75f,true);
        map.put(1, "A");
        map.put(2, "B");
        map.put(3, "C");
        System.out.println(map.keySet().toString());
        map.get(2);
        System.out.println(map.keySet().toString());//[1,3,2]
    }

属性

 static class Entry<K,V> extends HashMap.Node<K,V> {
        Entry<K,V> before, after;//Enty的数据结构，多了两个指向前后节点的引用 
        Entry(int hash, K key, V value, Node<K,V> next) {
            super(hash, key, value, next);
        }
    }
    //双向循环链表的头结点
    transient LinkedHashMap.Entry<K,V> head;

    /**
     * 双向循环链表的尾结点
     */
    transient LinkedHashMap.Entry<K,V> tail;

    /**
     * accessOrder为false，表示按插入顺序排序  
     * accessOrder为true，表示按访问顺序排序
     *
     * @serial
     */
    final boolean accessOrder;

插入节点

重新HashMap,putVal之后会执行

 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);// 插入到link尾部
        return p;
    }

    private void linkNodeLast(LinkedHashMap.Entry<K,V> p) {
        LinkedHashMap.Entry<K,V> last = tail;
        tail = p;
        if (last == null)
            head = p;
        else {//双向指针
            p.before = last;
            last.after = p;
        }
    }  
    

执行插入除了所有put进来的Entry都保存在哈希表中，但它又额外定义了一个以head为头结点的空的双向循环链表，每次put进来Entry，除了将其保存到对哈希表中对应的位置上外，还要将其插入到双向循环链表的尾部。

上面是按插入顺序，如果是访问顺序的调用afterNodeAccess。

获取节点

 public V get(Object key) {
        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) { //移动节点到最后
        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;
        }
    }

删除节点

LinkedHashMap的remove方法是直接使用的HashMap的remove方法。

void afterNodeRemoval(Node<K,V> e) { // 当前移除元素的前后元素进行连接
        LinkedHashMap.Entry<K,V> p =
            (LinkedHashMap.Entry<K,V>)e, b = p.before, a = p.after;
        p.before = p.after = null;
        if (b == null)
            head = a;
        else
            b.after = a;
        if (a == null)
            tail = b;
        else
            a.before = b;
    }

总结

• LinkedHashMap继承自HashMap
• LinkedHashMap还可以按照访问顺序进行排序，如果想按照访问顺序进行排序，那么首先要将accessOrder设置为true，接着在afterNodeAccess中会对LinkedHashMap进行双向链表调整。
• 是HashMap和LinkedList两个集合类的存储结构的结合。在LinkedHashMapMap中，所有put进来的Entry都保存在哈希表中，但它又额外定义了一个以head为头结点的空的双向循环链表，每次put进来Entry，除了将其保存到对哈希表中对应的位置上外，还要将其插入到双向循环链表的尾部。