Map之LinkedHashMap

于 2021-05-28 19:07:46 发布
阅读量230 收藏 1
点赞数
分类专栏： Java八股文系列 文章标签： java hashmap
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_39290259/article/details/117372099
版权

image

一、LinkedHashMap源码分析（jdk1.8）

1.1 成员变量

public class LinkedHashMap<K,V>
    extends HashMap<K,V>
    implements Map<K,V>
{
    //头指针，指向第一个node
    transient LinkedHashMap.Entry<K,V> head;

    //尾指针，指向最后一个node
    transient LinkedHashMap.Entry<K,V> tail;

    //true表示按照访问顺序迭代，false时表示按照插入顺序 
    final boolean accessOrder;
}

LinkedHashMap继承了HashMap，也就是说它有HashMap的所有特性。

1.2 基本元素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);
        }
    }

LinkedHashMap的Entry增加了俩个指针，用于维护所有Entry的插入顺序，而Node的next的指针只维护各个桶中的node的链接顺序，LinkedHashMap示意图如下图。
image

key的插入顺序是key1，key2，key3，key4。

1.3 构造方法

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

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

可以看到，如果不指定accessOrder的话，默认的都是false，也就是插入序。

1.4 维护链表的方法

HashMap中有三个空的方法：

    // Callbacks to allow LinkedHashMap post-actions
    void afterNodeAccess(Node<K,V> p) { }
    void afterNodeInsertion(boolean evict) { }
    void afterNodeRemoval(Node<K,V> p) { }

LinkedHashMap重写了这三个回调方法，在恰当的时候，HashMap会调用LinkedHashMap的这三个方法来维护链表的顺序，这是多态的体现，先看看这三个方法的作用，然后再研究何时会调用这三个方法。

1.4.1 afterNodeAccess

    // 在节点被访问后根据accessOrder判断是否需要调整链表顺序，需要的话把e节点调放在最后面
    void afterNodeAccess(Node<K,V> e) { // move node to last
        LinkedHashMap.Entry<K,V> last;
        if (accessOrder && (last = tail) != e) {//accessOrder为true才有效
            //p指向待删除元素，b是前驱，a是后继
            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;
            //这里执行将p放到尾部
            if (last == null)
                head = p;
            else {
                p.before = last;
                last.after = p;
            }
            tail = p;
            ++modCount;
        }
    }

被调用的地方：HashMap#putVal(…)

    //evict默认为true
    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)
            n = (tab = resize()).length;
        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);
        else {
            Node<K,V> e; K k;
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                e = p;
            else if (p instanceof TreeNode)
                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
            else {
                for (int binCount = 0; ; ++binCount) {
                    if ((e = p.next) == null) {
                        p.next = newNode(hash, key, value, null);
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                            treeifyBin(tab, hash);
                        break;
                    }
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        break;
                    p = e;
                }
            }
            if (e != null) { // 此时的e指向的就是在map中的那个插入点
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                //这里就是将新插入的节点维护到LinkedHashMap的尾部
                afterNodeAccess(e);
                return oldValue;
            }
        }
        ++modCount;
        if (++size > threshold)
            resize();
        afterNodeInsertion(evict);
        return null;
    }

所以afterNodeAccess的作用就是当一个新的节点插入进来后，根据accessOrder来对这个节点的after和before指着进行调整，如果accessOrder为true，那么新插进来的节点在整个双向链表中会变为last节点，如果为false，那么什么也不做。举个例子：

    public static void main(String[] args) {
        HashMap<Object, Object> map = new LinkedHashMap<>(16, 0.75f, true);
        map.put("10", 10);
        map.put("1", 1);
        map.put("3", 3);
        map.put("2", 2);
        map.put("3", 33);
        for (Map.Entry entry : map.entrySet()) {
            System.out.println(entry.getValue());
        }
        //输出结果：10 1 2 33
    }

    public static void main(String[] args) {
        HashMap<Object, Object> map = new LinkedHashMap<>(16, 0.75f, false);
        map.put("10", 10);
        map.put("1", 1);
        map.put("3", 3);
        map.put("2", 2);
        map.put("3", 33);
        for (Map.Entry entry : map.entrySet()) {
            System.out.println(entry.getValue());
        }
        //输出结果：10 1 33 2
    }

当key相同时，新的value会覆盖旧的value，当accessOrder为true时，新的节点会排在双向链表的末尾；accessOrder为false时，新的节点会在双向链表中保持在旧的节点所在的位置。

1.4.2 afterNodeRemoval

    //在节点删除后，维护链表
    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;
        if (b == null)
            head = a;
        else
            b.after = a;
        if (a == null)
            tail = b;
        else
            a.before = b;
    }

被调用的地方：HashMap#removeNode(…)

afterNodeRemoval的作用就是当删除掉一个节点时，同时也要在双向链表中删掉这个节点的after和before指针，并把这个节点的前驱节点和后继节点连接起来。

1.4.3 afterNodeInsertion

    void afterNodeInsertion(boolean evict) { // possibly remove eldest
        LinkedHashMap.Entry<K,V> first;
        //removeEldestEntry(first)默认返回false，所以afterNodeInsertion这个方法其实并不会执行
        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;
    }

afterNodeInsertion这个方法为什么默认不执行呢？这个方法实际是给我们自己扩展的。后面会根据一个实例来分析这个方法的作用。

被调用的地方：HashMap#putVal(…)

    //evict默认为true
    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)
            n = (tab = resize()).length;
        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);
        else {
            Node<K,V> e; K k;
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                e = p;
            else if (p instanceof TreeNode)
                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
            else {
                for (int binCount = 0; ; ++binCount) {
                    if ((e = p.next) == null) {
                        p.next = newNode(hash, key, value, null);
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                            treeifyBin(tab, hash);
                        break;
                    }
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        break;
                    p = e;
                }
            }
            if (e != null) { // 此时的e指向的就是在map中的那个插入点
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                //这里就是将新插入的节点维护到LinkedHashMap的尾部
                afterNodeAccess(e);
                return oldValue;
            }
        }
        ++modCount;
        if (++size > threshold)
            resize();
        //当put完一个节点后，执行这个方法，evict默认为true
        afterNodeInsertion(evict);
        return null;
    }

1.5 get操作

    public V get(Object key) {
        Node<K,V> e;
        if ((e = getNode(hash(key), key)) == null)
            return null;
        if (accessOrder)
            afterNodeAccess(e);//如果accessOrder为true，那么就把get的元素放到双向链表的末尾
        return e.value;
    }

代码示例：

    public static void main(String[] args) {
        HashMap<Object, Object> map = new LinkedHashMap<>(16, 0.75f, true);
        map.put("10", 10);
        map.put("1", 1);
        map.put("3", 3);
        map.put("2", 2);
        map.put("3", 33);
        System.out.println(map);
        map.get("10");
        System.out.println("=====");
        System.out.println(map);
    }

结果：

{10=10, 1=1, 2=2, 3=33}
=====
{1=1, 2=2, 3=33, 10=10}

accessOrder为true，get(“10”)后，“10”这个节点跑到了链表的末尾。

1.6 使用LinkedHashMap实现LRU（Least recently used，最近最少使用）算法

经过上面的分析，发现accessOrder为true时，put操作和g（Least recently used，最近最少使用）et操作都会把操作过的元素放在双向链表的末端，也就是把最近使用过的元素放在最新端，根据这个特性可以用LinkedHashMap来实现LRU算法。HashMap#putVal(…)，HashMap的putVal方法调用了afterNodeInsertion方法，当accessOrder为true时，这个方法才生效，看看这个方法的具体作用：

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

也就是说只要重写了removeEldestEntry方法，使其返回true就可以删除双向链表中的第一个节点。下面就是LRU算法的具体实现。

public class LRU<K,V> extends LinkedHashMap<K, V> implements Map<K, V> {

    private static final long serialVersionUID = 1L;

    public LRU(int initialCapacity,
             float loadFactor,
                        boolean accessOrder) {
        super(initialCapacity, loadFactor, accessOrder);
    }

    /** 
     * @description 重写LinkedHashMap中的removeEldestEntry方法，当LRU中元素多余6个时，
     *              删除最不经常使用的元素
     */  
    protected boolean removeEldestEntry(java.util.Map.Entry<K, V> eldest) {
        // TODO Auto-generated method stub
        if(size() > 6){
            return true;
        }
        return false;
    }

    public static void main(String[] args) {

        HashMap<Character, Integer> lru = new LRU<Character, Integer>(
                16, 0.75f, true);

        String s = "abcdefghijkl";
        for (int i = 0; i < s.length(); i++) {
            lru.put(s.charAt(i), i);
        }
        System.out.println("LRU中key为h的Entry的值为： " + lru.get('h'));
        System.out.println("LRU的大小 ：" + lru.size());
        System.out.println("LRU ：" + lru);
    }
}

结果：

LRU中key为h的Entry的值为： 7
LRU的大小 ：6
LRU ：{g=6, i=8, j=9, k=10, l=11, h=7}

具体的方法调用链为：

HashMap#putVal(…)->LinkedHashMap#afterNodeInsertion(…)->LRU#removeEldestEntry(…)->HashMap#removeNode(…)

二、LinkedHashMap常见面试问题

2.1 LinkedHashMap与HashMap的不同点？

结构上没有本质的区别，LinkedHashMap记录了键值对的插入顺序，可以按照插入顺序来遍历键值对，而HashMap没有记录插入顺序。

2.2 LinkedHashMap是如何记录的插入顺序的呢？

LinkedHashMap继承了HashMap，本身具有HashMap的全部特性，LinkedHashMap内部的Entry类继承了HashMap的Node类，而这个Entry类比Node类多了两个指针，这两个指针分别指向Entry的前驱节点和后继节点，靠这两个指针就可以维护一个键值对的双向链表，从而记录插入顺序。

2.3 LinkedHashMap中accessOrder的作用？

accessOrder是LinkedHashMap中的一个布尔型成员变量。false代表着插入顺序，true代表着访问顺序。也就是accessOrder为true时，最新访问的键值对会被放到双向链表的末尾。

三、总结

LinkedHashMap是一个记录了键值对插入顺序的HashMap，其中LinkedHashMap和HashMap对多态的实现值得学习。

weixin_39290259
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值