LinkedHashMap源码分析

文章目录

• 继承体系
• 简介
• 属性
• 内部类
• 构造方法
• 关键方法解析
• 插入顺序实现
• newNode
• newTreeNode
• linkNodeLast
• 访问顺序实现
• get
• afterNodeAccess
• HashMap为LinkedHashMap做的钩子
• 移除旧元素
• 总结

继承体系

继承HashMap，在其基础上记录插入顺序。

简介

LinkedHashMap具有可预测的迭代顺序，与HashMap的不同之处在于，它维护一个遍历所有条目的双向链接列表。此链表定义了迭代顺序，通常是将键插入映射中的顺序。请注意，如果将键重新插入到地图中，则插入顺序不会受到影响。
非线程安全，支持快速失败

我们知道HashMap是 数组+链表+红黑树，LinkedHashMap继承了它，内部也是这样的结构，只是在每次插入节点时，记录节点前后的节点。

属性

//双向队列的队头
transient LinkedHashMap.Entry<K,V> head;
//双向队列的队尾
transient LinkedHashMap.Entry<K,V> tail;
//定义hash表迭代方式 true：访问顺序，false：插入顺序
final boolean accessOrder;

内部类

//扩展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);
    }
}

构造方法

//调用父类无参构造 使用默认加载因子和容量
public LinkedHashMap() {
    super();
    accessOrder = false;
}
public LinkedHashMap(int initialCapacity) {
    super(initialCapacity);
    accessOrder = false;
}
public LinkedHashMap(int initialCapacity, float loadFactor) {
    super(initialCapacity, loadFactor);
    accessOrder = false;
}
//初始化后 插入map集合数据
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;
}

关键方法解析

LinkedHashMap有两种顺序，插入顺序和访问顺序，默认插入顺序。
先来看看它是怎么记录插入顺序的

插入顺序实现

既然是记录插入顺序，那么就要在put方法操作后修改双向链表。然而LinkedHashmap中没有put，使用的HashMap的put方法，这从何入手找到它的切入点呢？
其实呢，HashMap的方法put时要有一个‘节点’，那么只需要在创建节点的方法里面处理顺序就可以了，LinkedHashMap重写了节点创建方法。

newNode

-- 注意这里的linkNodeLast(p)方法
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;
}

newTreeNode

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

linkNodeLast

-- 将节点双向链表最后
private void linkNodeLast(LinkedHashMap.Entry<K,V> p) {
   LinkedHashMap.Entry<K,V> last = tail;//将当前最后节点取出
    tail = p;//尾节点指向即将成为最后节点的p
    if (last == null)//说明是初始化 将p放入头
        head = p;
    else {//加入双向链表最后
        p.before = last;
        last.after = p;
    }
}

访问顺序实现

既然是访问，那必然是调用了get方法，LinkedHashMap重写了get方法

get

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

afterNodeAccess

-- 将节点移到最后
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;
    }
}

HashMap为LinkedHashMap做的钩子

// LinkedHashMap后处理的回调
// 这些方法HashMap没有实现 但是在添加、获取、移除后调用了
// 那么LinkedHashMap那边实现后 当添加后回调这些方法处理双向链表
void afterNodeAccess(Node<K,V> p) { }	
void afterNodeInsertion(boolean evict) { }
void afterNodeRemoval(Node<K,V> p) { }

移除旧元素

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

这个方法没有实现，在插入数据后调用了
继承此类，重写这个方法，可以做缓存，默认并不会移除旧元素
看下面这个jdk中类的缓存实现

总结

（1）LinkedHashMap继承自HashMap，具有HashMap的所有特性；

（2）LinkedHashMap内部维护了一个双向链表存储所有的元素；

（3）如果accessOrder为false(默认)，按插入顺序遍历元素、为true按访问顺序遍历元素；

（4）默认的LinkedHashMap并不会移除旧元素，如果需要移除旧元素，则需要重写removeEldestEntry()方法设定移除策略；