LinkedHashMap源码分析

最新推荐文章于 2024-07-09 09:11:42 发布

墨玉浮白

最新推荐文章于 2024-07-09 09:11:42 发布

阅读量474

点赞数 1

分类专栏： Java 文章标签： Java

本文链接：https://blog.csdn.net/qq_36299025/article/details/89241267

版权

Java 专栏收录该内容

20 篇文章 0 订阅

订阅专栏

简介

LinkedHashMap继承HashMap（线程不安全…），内部主体还是一个哈希表，底层用的仍然是拉链式散列结构，由数组+链表/红黑树组成（加入红黑树分析起来可能会有一点乱，本文淡化红黑树分析，以双向链表为主。如果对红黑树不熟悉，可以参考我的红黑树学习笔记）。在HashMap的基础上，重写了一个Entry，并在上面添加了两个变量：前继结点引用before和后继结点引用after，也就是双向链表。所以LinkedHashMap的内部结构和HashMap差不多，唯一就是升级为了双向链表，通过双向链表解决了HashMap不能保证遍历顺序和插入顺序的缺点。

看一下成员变量

accessOrder表示是否按照访问顺序排序，其中一个构造器可以指定accessOrder。既然是继承了HashMap，那么不用多说，也是线程不安全的…另外这里有个疑问，既然LinkedHashMap继承HashMap，HashMap实现了Map接口，那怎么LinkedHashMap还要再去显式的再去实现Map接口呢？个人猜测可能只是强调一下LinkedHashMap真的是实现Map接口，是Map的小弟，这里不实现也没啥毛病。

public class LinkedHashMap<K,V> extends HashMap<K,V> implements Map<K,V> {
   //双向链表头结点，遍历的时候能快速找到他
   private transient Entry<K,V> header;
   //是否按访问顺序排序
   private final boolean accessOrder;
   ...
}

Entry节点

上面提到了Entry，是在HashMap的基础上重写了Entry并增加了before和after两个变量，使其拓展成了双向链表。详细的应该是这样的：entey<——before+entry（hash+key+value+next）+after——>entry。可能next和after全都指向下一个entry，也有可能next——>null，而after——>entry。

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

另外还有分别指向表头、表尾的两个变量：head和tail

//双向链表的头结点
transient LinkedHashMap.Entry<K,V> head;
//双向链表的尾节点
transient LinkedHashMap.Entry<K,V> tail;

构造方法

相比于HashMap，无非就是多了一个控制迭代的节点输出顺序accessOrder

1.空构造

默认accessOrder为false，即迭代时的输出顺序就是插入顺序。比如插入1、2、3，迭代输出就是1、2、3；若为true，输出顺序即节点访问顺序。比如插入1、2、3，迭代之前访问了2，又访问了1，迭代出来就是3、2、1

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

2.指定初始化容量

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

3.指定初始化容量、加载因子

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

4.指定初始化容量、加载因子、输出顺序变量

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

5.指定Map

map包浆变LinkedHashMap

public LinkedHashMap(Map<? extends K, ? extends V> m) {
     super(); 
     accessOrder = false; 
     //批量插入一个map中的所有数据到本集合中。 
     putMapEntries(m, false);
}

辅助方法putMapEntries

//evict初始化时为false，其他情况为true
    final void putMapEntries(Map<? extends K, ? extends V> m, boolean evict) {
        //拿到m的元素数量
        int s = m.size();
        //m数量大于0
        if (s > 0) {
            //当前表是空的
            if (table == null) { // pre-size
                //根据m的元素数量和当前表的加载因子，计算出阈值
                float ft = ((float)s / loadFactor) + 1.0F;
                //修正阈值的边界 不能超过MAXIMUM_CAPACITY
                int t = ((ft < (float)MAXIMUM_CAPACITY) ?
                         (int)ft : MAXIMUM_CAPACITY);
                //如果新的阈值 > 当前阈值
                if (t > threshold)
                    threshold = tableSizeFor(t);//>=新的阈值的 满足2的n次方的阈值
            }
            //如果不空且m的元素数量大于阈值
            else if (s > threshold)
                resize();// 一定得扩容了
            //遍历 m 依次将元素加入当前表中。
            for (Map.Entry<? extends K, ? extends V> e : m.entrySet()) {
                K key = e.getKey();
                V value = e.getValue();
                putVal(hash(key), key, value, false, evict);
            }
        }
    }

常规操作

1.put方法

在JDK1.8中并没有重写put方法，只是调用了putVal方法，并在该方法中调用了其他辅助方法。总的来说，LinkedHashMap重写了newNode(),在每次构建新节点时，通过linkNodeLast§;将新节点链接在内部双向链表的尾部

public V put(K key, V value) {
    return putVal(hash(key), key, value, false, true);
}

辅助方法putVal

该方法会在putMapEntries批量插入数据或者put插入单个数据时调用

// HashMap中的实现
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
               boolean evict) {
    Node<K,V>[] tab; Node<K,V> p; int n, i;
    if ((tab = table) == null || (n = tab.length) == 0) {...}
    // 通过节点 hash 定位节点所在的桶位置，并检测桶中是否包含节点引用
    if ((p = tab[i = (n - 1) & hash]) == null) {...}
    else {
        Node<K,V> e; K k;
        if (p.hash == hash &&
            ((k = p.key) == key || (key != null && key.equals(k))))
            e = p;
        //TreeNode...
        else if (p instanceof TreeNode) {...}
        else {
            // 对链表遍历，并计算链表长度
            for (int binCount = 0; ; ++binCount) {
                // 未在单链表中找到要插入的节点，将新节点放在单链表的后面
                if ((e = p.next) == null) {
                    //构建新节点，通过linkNodeLast(p)将新节点链接在内部双向链表的尾部
                    p.next = newNode(hash, key, value, null);
                    if (binCount >= TREEIFY_THRESHOLD - 1) {...}
                    break;
                }
                // 插入的节点已经存在于单链表中
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    break;
                p = e;
            }
        }
        if (e != null) { // existing mapping for key
            V oldValue = e.value;
            if (!onlyIfAbsent || oldValue == null) {...}
            afterNodeAccess(e);    // 回调方法，后续说明
            return oldValue;
        }
    }
    ++modCount;
    if (++size > threshold) {...}
    //这个方法我想就不用再多说了吧...HashMap专门留下来的，新节点插入之后回调
    afterNodeInsertion(evict);
    return null;
}

辅助方法newNode

把新节点接在双向链表的尾部

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);
    // 将 Entry 接在双向链表的尾部
    linkNodeLast(p);
    return p;
}

辅助方法linkNodeLast

将新增的节点，链接在链表尾部

private void linkNodeLast(LinkedHashMap.Entry<K,V> p) {
    LinkedHashMap.Entry<K,V> last = tail;
    tail = p;
    // last 为 null，表明链表还未建立
    if (last == null)
        head = p;
    else {
        // 将新节点 p 接在链表尾部
        p.before = last;
        last.after = p;
    }
}

2.get方法

accessOrder为true的时候，要去回调afterNodeAccess(Node<K,V> e)方法

public V get(Object key) {
    Node<K,V> e;
    if ((e = getNode(hash(key), key)) == null)
        return null;
    // 如果 accessOrder 为 true，则调用 afterNodeAccess 将被访问节点移动到链表最后
    if (accessOrder)
        afterNodeAccess(e);
    return e.value;
}

辅助方法afterNodeAccess

将当前被访问到的节点e，移动至内部的双向链表的尾部

void afterNodeAccess(Node<K,V> e) {
    LinkedHashMap.Entry<K,V> last;//原来的尾结点
    //accessOrder 是true ，且原尾节点不等于e
    if (accessOrder && (last = tail) != e) {
        //e强转成双向链表节点p
        LinkedHashMap.Entry<K,V> p =
            (LinkedHashMap.Entry<K,V>)e, b = p.before, a = p.after;
        p.after = null;//p现在是尾节点， 后置节点一定是null
        //如果p的前置节点是null，则p以前是头结点，所以更新现在的头结点是p的后置节点a
        if (b == null)
            head = a;
        else //否则更新p的前直接点b的后置节点为a
            b.after = a;
        //如果p的后置节点不是null，则更新后置节点a的前置节点为b
        if (a != null)
            a.before = b;
        //如果原本p的后置节点是null，则p就是尾节点。 此时 更新last的引用为 p的前置节点b
        else
            last = b;
        //原本尾节点是null  则，链表中就一个节点
        if (last == null)
            head = p;
        else {  //否则 更新 当前节点p的前置节点为 原尾节点last， last的后置节点是p
            // 将 p 接在链表的最后
            p.before = last;
            last.after = p;
        }
        tail = p;//尾节点的引用赋值成p
        ++modCount;
    }
}

3.remove方法

因为LinkedHashMap的删除逻辑和HashMap无异，所以并没有重写remove方法。但是重写了afterNodeRemoval方法，会在removeNode被调用。值得注意的是，removeNode方法会在所有和删除结点的方法中被调用，是整个remove事件中的“刽子手”。概括一下整个过程，有3板斧：1.根据hash值定位到桶的位置；2.分情况遍历链表或调用红黑树remove方法；3.将目标从LinkedHashMap的双向链表中移除（当然往后节点的前后指向关系就变了）

public V remove(Object key) {
    Node<K,V> e;
    return (e = removeNode(hash(key), key, null, false, true)) == null ?
        null : e.value;
}
//删除节点
final Node<K,V> removeNode(int hash, Object key, Object value,
                           boolean matchValue, boolean movable) {
    Node<K,V>[] tab; Node<K,V> p; int n, index;// p 是待删除节点的前置节点
    //hash表不为空，根据hash值算出来的index位置下有结点
    if ((tab = table) != null && (n = tab.length) > 0 &&
        (p = tab[index = (n - 1) & hash]) != null) {
        Node<K,V> node = null, e; K k; V v;//node是待删除结点
        if (p.hash == hash &&
            ((k = p.key) == key || (key != null && key.equals(k))))
            node = p;//将待删除节点引用赋给node
        else if ((e = p.next) != null) { //循环遍历 找到待删除节点，赋值给node
            if (p instanceof TreeNode) {...}//暂时先淡化这一部分
            else {
                // 遍历单链表，寻找要删除的节点，并赋值给 node 变量
                do {
                    if (e.hash == hash &&
                        ((k = e.key) == key ||
                         (key != null && key.equals(k)))) {
                        node = e;
                        break;
                    }
                    p = e;
                } while ((e = e.next) != null);
            }
        }
        //如果有待删除节点node，  且 matchValue为false，或者值也相等
        if (node != null && (!matchValue || (v = node.value) == value ||
                             (value != null && value.equals(v)))) {
            if (node instanceof TreeNode) {...}
            // 将要删除的节点从单链表中移除
            else if (node == p)//说明是链表头是待删除节点
                tab[index] = node.next;
            else//待删除节点在表中间
                p.next = node.next;
            ++modCount;
            --size;
            afterNodeRemoval(node);    // 调用删除回调方法进行后续操作
            return node;
        }
    }
    return null;
}

辅助方法afterNodeRemoval

删除节点e的同时将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 的前置后置节点都置空
    p.before = p.after = null;
    //如果前置节点是null，则现在的头结点应该是后置节点a
    if (b == null)
        head = a;
     //否则将前置节点b的后置节点指向a
    else
        b.after = a;
    //同理如果后置节点时null ，则尾节点应是b
    if (a == null)
        tail = b;
    //否则更新后置节点a的前置节点为b
    else
        a.before = b;
}

最后

LinkedHashMap继承了HashMap，只是重写了几个方法，以及在构造中加入了影响迭代时输出顺序的变量。只要增加、修改、删除节点，就会增加节点或者修改链表的节点顺序。
accessOrder这个变量十分的关键，起着决定性作用。false，插入节点的顺序；true，访问节点的顺序。
put并没有重写，只是重写了newNode方法，并通过一系列辅助方法来把新构建的结点链接到双向链表的尾部。