JavaSE（9）——LinkedHashMap源码

LinkedHashMap源码

1. 特征

• 底层是散列表和双向链表
• 允许为null，不同步
• 插入顺序是有序的 (底层链表致使有序)
• 负载因子和初始容量对LinkedHashMap影响很大

问题：

• access-ordered和insertion-ordered具体的使用和意思
• 为什么说初始容量对遍历没有影响？

2. 属性

/**
* 在原有的HashMap中的Node中，加入了before和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);
    }
}

//节点链表的头
transient Entry<K,V> head;

//节点链表的尾
transient Entry<K,V> tail;

//true：访问顺序
//false：插入顺序
final boolean accessOrder;

3. 方法

3.1 基本方法

/**
* 初始化散列表和双向链表
*/
void reinitialize() {
    super.reinitialize();
    head = tail = null;
}

Node<K,V> newNode(int hash, K key, V value, Node<K,V> e) {
    Entry<K,V> p = new Entry<K,V>(hash, key, value, e);
    //创建了节点Entry，将entry插入到双向链表的末尾，然后返回entry
    linkNodeLast(p);
    return p;
}

​ 从这两个方法可以看出，LinkedHashMap底层确实是由散列表和双向链表构成的。

3.2 构造方法

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

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

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

public LinkedHashMap(int initialCapacity,
                     float loadFactor,
                     boolean accessOrder) {
    super(initialCapacity, loadFactor);
    this.accessOrder = accessOrder;
}

public LinkedHashMap(Map<? extends K, ? extends V> m) {
    super();
    accessOrder = false;
    putMapEntries(m, false);
}

从构造方法可以看出，LinkedHashMap默认使用插入顺序

3.3 put方法

LinkedHashMap中没有重写put方法，所以put方法和HashMap中的put方法一样，只有其中创建节点时的newNode方法使用了LinkedHashMap中重写的方法。

Node<K,V> newNode(int hash, K key, V value, Node<K,V> e) {
    Entry<K,V> p = new Entry<K,V>(hash, key, value, e);
    //创建了节点Entry，将entry插入到双向链表的末尾，然后返回entry
    linkNodeLast(p);
    return p;
}

3.4 get方法

public V get(Object key) {
    Node<K,V> e;
    
   //getNode和hash方法都是父类中的方法
    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
    Entry<K,V> last;

    //此时链表顺序为访问顺序，当链表末尾不是当前节点
    if (accessOrder && (last = tail) != e) {
        //p：当前访问节点e
        //b：e的前一个节点
        //a：e的后一个节点
        Entry<K,V> p =
            (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;
    }
}

3.5 remove方法

LinkedHashMap中没有重写HashMap的remove方法，只重写了afterNodeRemoval()方法，进行了删除后处理

//重写的afterRemove方法
void afterNodeRemoval(Node<K,V> e) { // unlink
    //p：当前删除节点e
    //b：e的前一个节点
    //a：e的后一个节点
    Entry<K,V> p =
            (Entry<K,V>)e, b = p.before, a = p.after;
    //将当前节点的前后引用清空，以便GC回收节点
    p.before = p.after = null;
    
    //当前一个节点为空时，则当前删除节点为链表头部，将后一个节点放到链表头部
    if (b == null)
        head = a;
    //否则当前节点为中间节点，将后一个节点与前一个节点相连
    else
        b.after = a;
    
    //当后一个节点为空时，则当前删除节点为链表尾，则把前一个元素设置为链表尾
    if (a == null)
        tail = b;
    //否则当前删除节点为中间节点，把前一个节点和后一个节点相连
    else
        a.before = b;
}

3.6 遍历方法

//重写的entrySet方法，使用了LinkedEntrySet
public Set<Map.Entry<K,V>> entrySet() {
    Set<Map.Entry<K,V>> es;
    return (es = entrySet) == null ? (entrySet = new LinkedEntrySet()) : es;
}

abstract class LinkedHashIterator {
    Entry<K,V> next;
    Entry<K,V> current;
    int expectedModCount;

    LinkedHashIterator() {
        next = head;
        expectedModCount = modCount;
        current = null;
    }

    public final boolean hasNext() {
        return next != null;
    }

    //按照双向链表的顺序进行遍历
    final Entry<K,V> nextNode() {
        Entry<K,V> e = next;
        if (modCount != expectedModCount)
            throw new ConcurrentModificationException();
        if (e == null)
            throw new NoSuchElementException();
        current = e;
        next = e.after;
        return e;
    }

    public final void remove() {
        Node<K,V> p = current;
        if (p == null)
            throw new IllegalStateException();
        if (modCount != expectedModCount)
            throw new ConcurrentModificationException();
        current = null;
        K key = p.key;
        removeNode(hash(key), key, null, false, false);
        expectedModCount = modCount;
    }
}

final class LinkedEntrySet extends AbstractSet<Map.Entry<K,V>> {
    public final int size()                 { return size; }
    public final void clear()               { this.clear(); }
    public final Iterator<Map.Entry<K,V>> iterator() {
        return new LinkedEntryIterator();
    }
    public final boolean contains(Object o) {
        if (!(o instanceof Map.Entry))
            return false;
        Map.Entry<?,?> e = (Map.Entry<?,?>) o;
        Object key = e.getKey();
        Node<K,V> candidate = getNode(hash(key), key);
        return candidate != null && candidate.equals(e);
    }
    public final boolean remove(Object o) {
        if (o instanceof Map.Entry) {
            Map.Entry<?,?> e = (Map.Entry<?,?>) o;
            Object key = e.getKey();
            Object value = e.getValue();
            return removeNode(hash(key), key, value, true, true) != null;
        }
        return false;
    }
    public final Spliterator<Map.Entry<K,V>> spliterator() {
        return Spliterators.spliterator(this, Spliterator.SIZED |
                                        Spliterator.ORDERED |
                                        Spliterator.DISTINCT);
    }
    public final void forEach(Consumer<? super Map.Entry<K,V>> action) {
        if (action == null)
            throw new NullPointerException();
        int mc = modCount;
        for (Entry<K,V> e = head; e != null; e = e.after)
            action.accept(e);
        if (modCount != mc)
            throw new ConcurrentModificationException();
    }
}

从迭代器可以看出，LinkedHashMap中迭代时按照底层维护的双向链表的顺序进行迭代，而不是按照散列表顺序 (但是链表中元素都来源于散列表)。因此，初始化容量对遍历没有影响，

4. 总结

LinkedHashMap比HashMap多了一个双向链表的维护，在数据结构而言它要复杂一些，阅读源码起来比较轻松一些，因为大多都由HashMap实现了…

阅读源码的时候我们会发现多态是无处不在的~子类用父类的方法，子类重写了父类的部分方法即可达到不一样的效果！

​ 比如：

• LinkedHashMap并没有重写put方法，而put方法内部的newNode()方法重写了。
• LinkedHashMap调用父类的put方法，里面回调的是重写后的newNode()，从而达到目的！

LinkedHashMap可以设置两种遍历顺序：

• 访问顺序（access-ordered）
• 插入顺序（insertion-ordered）
• 默认是插入顺序的

对于访问顺序，它是LRU(最近最少使用)算法的实现，要使用它要么重写LinkedListMap的几个方法(removeEldestEntry(Map.Entry<K,V> eldest)和afterNodeInsertion(boolean evict))，要么是扩展成LRUMap来使用，不然设置为访问顺序（access-ordered）的用处不大~

LinkedHashMap遍历的是内部维护的双向链表，所以说初始容量对LinkedHashMap遍历是不受影响的