JDK源码阅读 -- LinkedHashMap

1.成员变量介绍

• transient LinkedHashMap.Entry<K,V> head：LinkedHashMap是双向链表，头指针
• transient LinkedHashMap.Entry<K,V> tail：尾指针
• final boolean accessOrder：当accessOrder为true时，按照访问顺序排序；为false时，按照插入顺序排序

2.底层数据结构

• Entry：继承自HashMap的Node，多了after和before，用于维持双向链表，其中要注意next和after的区别，next是在HashMap中维护链表结构，与after并不相同。

static class Entry<K,V> extends HashMap.Node<K,V> {
        Entry<K,V> before, after;
        Entry(int hash, K key, V value, Node<K,V> next) {
            super(hash, key, value, next);
        }
    }

3.构造函数介绍

//用给定初始容量和加载因子来创建一个Map，调用了HashMap的构造函数，并且顺序默认为插入顺序
public LinkedHashMap(int initialCapacity, float loadFactor) {
        super(initialCapacity, loadFactor);
        accessOrder = false;
    }
//调用HashMap的构造函数
public LinkedHashMap(int initialCapacity) {
        super(initialCapacity);
        accessOrder = false;
    }

public LinkedHashMap() {
        super();
        accessOrder = false;
    }
public LinkedHashMap(Map<? extends K, ? extends V> m) {
        super();
        accessOrder = false;
        putMapEntries(m, false);
    }
//指定访问顺序
public LinkedHashMap(int initialCapacity,
                         float loadFactor,
                         boolean accessOrder) {
        super(initialCapacity, loadFactor);
        this.accessOrder = accessOrder;
    }

4.方法

• public boolean containsValue(Object value)：查看指定的value是否存在于map中

public boolean containsValue(Object value) {
        for (LinkedHashMap.Entry<K,V> e = head; e != null; e = e.after) { //通过双向链表很容易完成
            V v = e.value;
            if (v == value || (value != null && value.equals(v)))
                return true;
        }
        return false;
    }

• public V get(Object key):得到指定key的value值，通过HashMap中的getNode()方法完成

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

• public V getOrDefault(Object key, V defaultValue)：返回key值对应的value，若key不存在，则返回默认value

public V getOrDefault(Object key, V defaultValue) {
       Node<K,V> e;
       if ((e = getNode(hash(key), key)) == null)
           return defaultValue;
       if (accessOrder)
           afterNodeAccess(e);
       return e.value;
   }

• public void clear()：清空map
• void afterNodeAccess(Node<K,V> e):再结点被访问之后如果accessOrder为true时调用，调整双向链表的顺序
• public Collection values()：返回values的Collection
• public Set keySet()：返回key的set
• public Set<Map.Entry<K,V>> entrySet()：返回entry的Set

5.重写HashMap的方法

void afterNodeAccess(Node<K,V> e) { 
        LinkedHashMap.Entry<K,V> last;
        if (accessOrder && (last = tail) != e) {  //如果e不是尾部结点
            LinkedHashMap.Entry<K,V> p =
                (LinkedHashMap.Entry<K,V>)e, b = p.before, a = p.after;
            p.after = null;
            if (b == null)  //p是头结点
                head = a; //将a设置为头结点
            else
                b.after = a;  //删除p结点
            if (a != null)  //a不是尾部节点
                a.before = b;     // 删除p结点
            else
                last = b;
            if (last == null)
                head = p;
            else {
                p.before = last;
                last.after = p;
            }
            tail = p;   //将p设置为尾节点
            ++modCount;
        }
    }

• void afterNodeRemoval(Node<K,V> e):再结点删除之后调用，在HashMap中的removeNode（）方法末尾调用此方法，用于维护双链表结构

void afterNodeRemoval(Node<K,V> e) { // unlink
        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;
    }

• Node<K,V> newNode(int hash, K key, V value, Node<K,V> e)：返回一个新节点，自动将这个节点加入到双向链表的末尾

//LinkedHashMap
	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);
        return p;
    }
    //HashMap
    Node<K,V> newNode(int hash, K key, V value, Node<K,V> next) {
        return new Node<>(hash, key, value, next);
    }

• Node<K,V> replacementNode(Node<K,V> p, Node<K,V> next):根据原结点生成一个LinkedHashMap结点替换原结点

	//LinkedHashMap
	Node<K,V> replacementNode(Node<K,V> p, Node<K,V> next) {
        LinkedHashMap.Entry<K,V> q = (LinkedHashMap.Entry<K,V>)p;
        LinkedHashMap.Entry<K,V> t =
            new LinkedHashMap.Entry<K,V>(q.hash, q.key, q.value, next);
        transferLinks(q, t);
        return t;
    }
    //HashMap -- 
    Node<K,V> replacementNode(Node<K,V> p, Node<K,V> next) {
        return new Node<>(p.hash, p.key, p.value, next);
    }
    //用dst替换dst在链表中的位置
    private void transferLinks(LinkedHashMap.Entry<K,V> src,
                               LinkedHashMap.Entry<K,V> dst) {
        LinkedHashMap.Entry<K,V> b = dst.before = src.before;
        LinkedHashMap.Entry<K,V> a = dst.after = src.after;
        if (b == null)
            head = dst;
        else
            b.after = dst;
        if (a == null)
            tail = dst;
        else
            a.before = dst;
    }