LinkedHashMap源码解析

LinkedHashMap源码解析

简介

LinkedHashMap是基于HashMap衍生出来的一种数据结构，它通过额外维护一个双向链表来实现记录访问顺序或者插入顺序。既然LinkedHashMap是继承自HashMap，那么很多底层和HashMap一致，这里我们只了解LinkedHashMap独有的特性。

1、重要的成员变量

// 顺序队列的头节点
transient LinkedHashMap.Entry<K,V> head;
// 顺序队列的尾节点
transient LinkedHashMap.Entry<K,V> tail;
// 是否按访问顺序排序，默认为false
final boolean accessOrder;

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

3、核心方法

3.1 内部类 Entry

这个Entry类继承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);
    }
}

3.2 newNode(int hash, K key, V value, Node<K,V> e)

在LinkedHashMap中重写了newNode方法，在创建新节点后，会将该节点插入到顺序队列尾部。

// HashMap
Node<K,V> newNode(int hash, K key, V value, Node<K,V> next) {
    return new Node<>(hash, key, value, next);
}

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

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

3.3 newTreeNode(int hash, K key, V value, Node<K,V> next)

在LinkedHashMap中同样重写了newTreeNode方法，在创建新节点后，会将该节点插入到顺序队列尾部。

// HashMap
TreeNode<K,V> newTreeNode(int hash, K key, V value, Node<K,V> next) {
    return new TreeNode<>(hash, key, value, next);
}

// LinkedHashMap
TreeNode<K,V> newTreeNode(int hash, K key, V value, Node<K,V> next) {
    TreeNode<K,V> p = new TreeNode<K,V>(hash, key, value, next);
    linkNodeLast(p);
    return p;
}

3.4 afterNodeAccess(Node<K,V> e)

在LinkedHashMap实现了此方法，用于将节点在被访问后（或被替换）按accessOrder设置顺序。

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

3.4 afterNodeInsertion(boolean evict)

新插入节点后，是否需要删除最老的节点。
在这里我们发现removeEldestEntry(Map.Entry<K,V> eldest) 方法直接返回的false，所以如果我们需要删除节点则需要重写此方法。一般用于控制顺序列表数据容量。

void afterNodeInsertion(boolean evict) { // possibly remove eldest
    LinkedHashMap.Entry<K,V> first;
    if (evict && (first = head) != null && removeEldestEntry(first)) {
        K key = first.key;
        removeNode(hash(key), key, null, false, true);
    }
}

protected boolean removeEldestEntry(Map.Entry<K,V> eldest) {
    return false;
}

3.4 afterNodeRemoval(Node<K,V> e)

节点被移除后，需要维护顺序列表的结构。

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