04-LinkedHashMap

最新推荐文章于 2023-08-08 11:17:46 发布

惑边

最新推荐文章于 2023-08-08 11:17:46 发布

阅读量642

点赞数

分类专栏： Java

本文链接：https://blog.csdn.net/my_momo_csdn/article/details/102676394

版权

Java 专栏收录该内容

11 篇文章 0 订阅

订阅专栏

LinkedHashMap

LinkedHashMap继承HashMap并且实现Map接口，它是Map接口的hash表和双向链表的双重实现，也就是说一方面具备HashMap的特点，另一方面内部还使用双向链表保存了全部元素，链表支持按照插入顺序和访问顺序这两种排序方式，因此在某些时候可以借助LinkedHashMap来实现特定的需求，典型的就是按照访问顺序排序来实现LRU。

一、主要数据结构和属性

1.1 Entry

Entry继承了HashMap.Node，HashMap.Node保存看键值对和k-v对、hash值和next指针，在继承它的基础上Entry添加了前后指针，由此具备了双向链表的数据结构基础。

    /**
     * HashMap.Node subclass for normal LinkedHashMap entries.
     */
    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);
        }
    }

1.2 主要属性

LinkedHashMap内部通过双向链表维护节点之间的顺序，通过在Node中加入了前后指针这两个字段来实现的，在主要成员属性里面保存了整个双向链表的头尾指针，以及排序方式。

//双向链表头结点
transient LinkedHashMap.Entry<K,V> head;
//双向链表尾结点
transient LinkedHashMap.Entry<K,V> tail;
//双向链表的迭代顺序，true代表访问顺序，false代表插入顺序(默认)
final boolean accessOrder;

二、继承自HashMap的钩子方法

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

这几个方法是定义在HashMap中，但在HashMap中默认是空实现，LinkedHashMap实现了这几个方法，看名字基本就知道什么含义，而LinkedHashMap的排序也正是基于这几个方法来实现的，他们分别会在节点新增、删除和访问之后调用，我们先看看这几个方法；

2.1 afterNodeAccess

afterNodeAccess会在节点被访问后调用，如果是按照访问顺序迭代双向链表，就需要执行下面的逻辑。下面的逻辑不难，但是看起来有点绕，只需要吧4种情况弄清楚就好了，就是b-p-a，null-p-a，b-p-null，null-p-null，其中p代表需要处理的节点，b代表前驱，a代表后继。

    void afterNodeAccess(Node<K,V> e) { // move node to last
        LinkedHashMap.Entry<K,V> last;
        //1.循环遍历链表，accessOrder为true代表是按照访问顺序排序，e不是尾节点就进去处理
        if (accessOrder && (last = tail) != e) {
            //2.p为需要处理的节点
            LinkedHashMap.Entry<K,V> p = (LinkedHashMap.Entry<K,V>)e, b = p.before, a = p.after;
            //3.将p的后继置为null
            p.after = null;
            //4.如果前驱为null，说明p就是head，现在p移走了，那么p的后继a就成了head
            if (b == null)
                head = a;
            else
                //5.如果前驱不为null，说明p是中间节点，那么就把前驱和后继连起来
                b.after = a;
            //6.这里开始处理后继，后继不为null，就把后继和前驱连起来
            if (a != null)
                a.before = b;
            else
                //7.后继为null，说明p本身就是尾节点，那么p移走了，原来的前驱b成为尾节点
                last = b;
            //8.当p没有前驱后继的时候，也就是只有p一个节点的时候会出现last为null的情况，此时p就是head
            if (last == null)
                head = p;
            else {
                //9.将p放到链表的尾部
                p.before = last;
                last.after = p;
            }
            //10.p是最后一个，放在tail
            tail = p;
            ++modCount;
        }
    }

2.2 afterNodeInsertion

afterNodeInsertion会在节点被插入后执行，里面会根据参数和removeEldestEntry方法的返回值来决定是否需要删除first节点，也就是最老的节点。
需要注意的是移除的逻辑是在HashMap的removeNode方法中已经实现好了的，在removeNode中会依赖部分子方法，子方法如果和LinkedHashMap有关，LinkedHashMap都重写了，具体在重写的方法里面介绍了，这里简单带一下。

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

2.3 afterNodeRemoval

afterNodeRemoval会在节点移除后调用，主要是将前驱和后继连起来，考虑到null的情况，把afterNodeAccess的逻辑看明白了，这个就容易多了;

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

三、主要方法

3.1 构造方法

LinkedHashMap有很多重载的构造方法，给出比较典型的；这里提一下accessOrder为true代表按照访问顺序排序，false代表按照插入顺序排序，默认是false

//给出初始容量、加载因子和访问顺序参数
public LinkedHashMap(int initialCapacity, float loadFactor,boolean accessOrder) {
        super(initialCapacity, loadFactor);
        this.accessOrder = accessOrder;
}

3.2 get获取操作

get操作是调用HashMap中实现好的getNode，不过需要注意的是如果访问结果不是null，并且是按照访问顺序迭代，那么就需要执行前面介绍过的afterNodeAccess方法，之所以会有get方法原因在于LinkedHashMap重写这个方法，便于在访问后通过accessOrder属性调用afterNodeAccess，来保证链表是通过访问顺序排序的，其他的比如put操作还是通过HashMap的方法实现，不过会调用前面提到的钩子方法。

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

3.3 removeEldestEntry核心方法

removeEldestEntry是LinkedHashMap最为核心的方法之一，他是交给子类重写的，默认返回false，他是LinkedHash删除最老的值的依据，子类可以重写逻辑来控制返回值。返回true表示LinkedHashMap需要移除最老的key，反之则不用。
put和putAll方法在插入新元素之后会调用afterNodeInsertion，在afterNodeInsertion里面判断是否需要删除最老的元素，需要的话就会调用afterNodeRemoval删除最老的元素，这里的依据就是removeEldestEntry的返回值，由此也知道删除最老的元素的动作是在新增元素的时候触发的。
删除动作不需要我们实现，我们只需要通过该接口的返回值告诉LinkedHashMap是否需要删除了，下一次添加元素的时候就会执行删除动作，这也是利用LinkedHashMap实现LRU的关键，在afterNodeInsertion方法的判断逻辑里面我们可以看到该方法的调用。

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

四、内部方法

内部方法是private修饰的，外部不能访问，它们为其他方法提供内部调用。另外还有一些继承自HashMap的protected方法，需要LinkedHashMap子类自行重写逻辑的方法。

4.1 linkNodeLast

linkNodeLast将一个节点添加到双向链表的尾部

   private void linkNodeLast(LinkedHashMap.Entry<K,V> p) {
        LinkedHashMap.Entry<K,V> last = tail;
        tail = p;
        if (last == null)
            //1.last为null说明没有节点，那么新的节点就是head
            head = p;
        else {
            //2.相互指向对方
            p.before = last;
            last.after = p;
        }
    }

4.2 transferLinks

transferLinks将一个节点替换为另一个节点

    private void transferLinks(LinkedHashMap.Entry<K,V> src,LinkedHashMap.Entry<K,V> dst) {
        //1.先将目标节点dst的前后指针指向原来节点的前驱和后继
        LinkedHashMap.Entry<K,V> b = dst.before = src.before;
        LinkedHashMap.Entry<K,V> a = dst.after = src.after;
        //2.如果源节点的前驱为null，那么目标节点替换后就是head
        if (b == null)
            head = dst;
        else
            //3.源节点前驱不是null，那就将源节点的前驱设置为目标节点的前驱
            b.after = dst;
        //4.后继的处理方式和前驱一样
        if (a == null)
            tail = dst;
        else
            a.before = dst;
    }

4.3 重写的方法

另外有几个方法，在HashMap中会调用的，比如替换节点之类的，这些方法原本在HashMap中就实现好了，但是LinkedHashMap因为数据结构的变化实现方式有一些改变，因此重写了该部分方法，比如newNode、replacementNode、newTreeNode、replacementTreeNode、这些方法功能比较明确，就不解析了。

五、其他

5.1 containsValue

containsValue因为不能根据key查找，只能一个一个遍历，在HashMap中的实现是挨个遍历Hash桶，然后遍历每个桶里面的链表，LinkedHashMap则是遍历双向链表，复杂度都是O(N)

public boolean containsValue(Object value) {
        //1.遍历双向链表，找到就返回true
        for (LinkedHashMap.Entry<K,V> e = head; e != null; e = e.after) {
            V v = e.value;
            if (v == value || (value != null && value.equals(v)))
                return true;
        }
        return false;
    }

5.2 clear

clear

    public void clear() {
        super.clear();
        head = tail = null;
    }

5.3 辅助内部类

LinkedHashMap将原本的HashMap而外还使用链表连接在一起，但是HashMap是K-V结构，有时候我们会需要单独获取K的集合和V的集合，因此LinkedHashMap内部使用辅助的内部类LinkedKeySet来表示K的集合，其内部也使用双向链表连接，LinkedValues也是一样表示双向链表的Value集合，另外还有LinkedEntrySet表示，这里面不深入开展了，有兴趣可以自行研究。

    final class LinkedKeySet extends AbstractSet<K> {
        public final int size()                 { return size; }
        public final void clear()               { LinkedHashMap.this.clear(); }
        //迭代器返回LinkedKeyIterator
        public final Iterator<K> iterator() {
            return new LinkedKeyIterator();
        }
        //是否存在的方法，都是通过LinkedHashMap外边的方法来判断的
        public final boolean contains(Object o) { return containsKey(o); }
        public final boolean remove(Object key) {
            return removeNode(hash(key), key, null, false, true) != null;
        }
        public final Spliterator<K> spliterator()  {
            return Spliterators.spliterator(this, Spliterator.SIZED |
                                            Spliterator.ORDERED |
                                            Spliterator.DISTINCT);
        }
        public final void forEach(Consumer<? super K> action) {
            if (action == null)
                throw new NullPointerException();
            int mc = modCount;
            for (LinkedHashMap.Entry<K,V> e = head; e != null; e = e.after)
                action.accept(e.key);
            if (modCount != mc)
                throw new ConcurrentModificationException();
        }
    }

六、使用示例

6.1 按照access顺序

我们先看下面的例子,我们设置accessOrder为true按照访问顺序排序，起初保存了key1、key2、key3。然后遍历，双向链表的顺序是key1-key2-key3，因为key3是最后访问的，因此在链表的最尾部，这个在前面的源码分析过。
然后我们访问一次key2，因此key2就会挪到链表尾部，由此遍历顺序就是key1-key3-key2，如此我们看到了按照访问顺序排序的效果。

public class LinkedHashMapTest {

    public static void main(String[] args) {
        LinkedHashMap<String,Integer> linkedHashMap = new LinkedHashMap(10, 0.75F, true);

        linkedHashMap.put("key1",1);
        linkedHashMap.put("key2",2);
        linkedHashMap.put("key3",3);
        Set<String> strings = linkedHashMap.keySet();

        for (String k: strings) {
            System.out.print(k + "  ");
        }
        linkedHashMap.get("key2");
        System.out.print("\n----------------\n");
        for (String k: strings) {
            System.out.print(k + "  ");
        }
    }
}

输出：
key1  key2  key3  
----------------
key1  key3  key2

再看下面的，我设置阈值为3，当元素个数大于3的时候，removeEldestEntry方法返回true，此时就会返回最近最久未被访问的元素(LRU),第一次访问，顺序是key1 - key2 - key3，然后访问了一次key1，由此第二次访问顺序就变成了key2 - key3 - key1，然后加入key4，此时元素大于3个，最久未被访问的元素key2被删除，第三次访问链表顺序就是key3 - key1 - key4

public class LinkedHashMapTest {

    private static final int SIZE_THRESHOLD = 3;

    public static void main(String[] args) {
        LinkedHashMap<String, Integer> linkedHashMap = new LinkedHashMap<String, Integer>(10, .75F, true) {

            private static final long serialVersionUID = 4267176411845948333L;

            @Override
            protected boolean removeEldestEntry(Map.Entry<String, Integer> eldest) {
                //元素个数大于阈值，就删除最老未被访问的元素
                if (size() > SIZE_THRESHOLD) {
                    return true;
                }
                return false;
            }
        };

        linkedHashMap.put("key1", 1);
        linkedHashMap.put("key2", 2);
        linkedHashMap.put("key3", 3);
        Set<String> strings = linkedHashMap.keySet();

        for (String k : strings) {
            System.out.print(k + "  ");
        }
        linkedHashMap.get("key1");
        System.out.print("\n----------------\n");
        for (String k : strings) {
            System.out.print(k + "  ");
        }
        System.out.print("\n----------------\n");
        linkedHashMap.put("key4", 4);
        for (String k : strings) {
            System.out.print(k + "  ");
        }
    }
}

输出：
key1  key2  key3  
----------------
key2  key3  key1  
----------------
key3  key1  key4

6.2 按照insert顺序

再看一个按照插入顺序访问，这个比较简单了，不传参数默认就是插入顺序。如下代码所示，不管访问与否，访问的顺序就是插入的顺序。

public class LinkedHashMapTest {

    public static void main(String[] args) {
        LinkedHashMap<String, Integer> linkedHashMap = new LinkedHashMap<String, Integer>();

        linkedHashMap.put("key1", 1);
        linkedHashMap.put("key2", 2);
        linkedHashMap.put("key3", 3);
        Set<String> strings = linkedHashMap.keySet();

        for (String k : strings) {
            System.out.print(k + "  ");
        }
        linkedHashMap.get("key1");
        System.out.print("\n----------------\n");
        for (String k : strings) {
            System.out.print(k + "  ");
        }
        System.out.print("\n----------------\n");
        linkedHashMap.put("key4", 4);
        for (String k : strings) {
            System.out.print(k + "  ");
        }
    }
}

输出：
key1  key2  key3  
----------------
key1  key2  key3  
----------------
key1  key2  key3  key4

七、小结

LinkedHashMap继承自HashMap，它的数据节点在HashMap节点的基础之上添加了前驱后继节点指针，除了维护原本Hash表的结构之外，还维护了一个双向链表的结构。
双向链表支持按照插入顺序排序(false 默认)和按照访问顺序排序(true)，通过accessOrder来控制。
在按照访问顺序排序的模式下，LinkedHashMap主要通过HashMap预留的一个removeEldestEntry方法来决定什么时候需要清除最老的元素，一种典型的场景是，当元素个数达到预先设置的阈值则删除最老元素，由此达到LRU的效果。当然删除的过程中需要对双向链表数据结构进行维护，这些也是通过HashMap在预先留下的钩子方法实现的，三个重要的钩子方法会在新增元素、删除元素、访问元素后被调用。
按照插入顺序是默认的，这种模式可以对HashMap表中的元素进行排序，这也是HashMap不具备的功能。