【源码面经】Java源码系列-LinkedHashMap

面试题

1. LinkedHashMap如何实现有序的
2. 如何用LinkedHashMap实现LRU

源码解析

LinkedHashMap在Map的基础上进行了扩展，提供了按序访问的能力。这个顺序经过accessOrder控制，能够是结点的插入顺序，也能够是结点的访问时间顺序。

LinkedHashMap还提供了removeEldestEntry方法，能够用来删除最老访问结点。

经过accessOrder和removeEldestEntry能够用来实现LRU缓存。

如图所示，LinkedHashMap实现顺序访问的方法比较简单，在HashMap实现以外，还维护了一个双向链表。每当插入结点时，不只要在Map中维护，还须要在链表中进行维护。HashMap中的put, get等方法都提供了一些钩子方法，如afterNodeAccess、afterNodeInsertion和afterNodeRemoval等。经过这些方法，LinkedHashMap能够对这些结点进行一些特性化的维护。

当遍历LinkedHashMap时经过遍历链表代替遍历Map中的各个槽，从而实现按序访问。

底层数据结构

/** * LinkedHashMap普通的链表结点，继承了HashMap的Node，在此基础上 * 对每一个Node添加了before和after指针。LinkedHashMap在HashMap的 * 基础上，还维护了一个双向链表，链表中的结点就是Map中的每一个结点， * 经过此链表，LinkedHashMap就实现了维护结点顺序的目的 */
    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);
        }
    }

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

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

    /** * true-按访问顺序(最先操做过的结点靠前) * false-按插入顺序遍历(最先插入的结点靠前) * * @serial */
    final boolean accessOrder;
复制代码

Node结点

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);
        // 建立一个key-value对时，不只要放入map中，还有放入LinkedHashMap
        // 内置的双向链表中，用来维护插入顺序
        linkNodeLast(p);
        return p;
    }

    Node<K, V> replacementNode(Node<K, V> p, Node<K, V> next) {
        LinkedHashMap.Entry<K, V> q = (LinkedHashMap.Entry<K, V>) p;
        LinkedHashMap.Entry<K, V> t =
                new LinkedHashMap.Entry<K, V>(q.hash, q.key, q.value, next);
        // 用t结点代替q结点在双向链表中的位置
        transferLinks(q, t);
        return t;
    }

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

    TreeNode<K, V> replacementTreeNode(Node<K, V> p, Node<K, V> next) {
        LinkedHashMap.Entry<K, V> q = (LinkedHashMap.Entry<K, V>) p;
        TreeNode<K, V> t = new TreeNode<K, V>(q.hash, q.key, q.value, next);
        transferLinks(q, t);
        return t;
    }
复制代码

工具方法

// 在双向链表尾部添加结点
    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;
        }
    }

    // 使用dst结点覆盖src结点在双向链表中的位置
    private void transferLinks(LinkedHashMap.Entry<K, V> src, LinkedHashMap.Entry<K, V> dst) {
        LinkedHashMap.Entry<K, V> b = dst.before = src.before;
        LinkedHashMap.Entry<K, V> a = dst.after = src.after;
        if (b == null)
            head = dst;
        else
            b.after = dst;
        if (a == null)
            tail = dst;
        else
            a.before = dst;
    }
    
    /** * 每次插入新Node时，是否须要删除最老的结点。 * * @return true-删除最老结点，false-不删除 */
    protected boolean removeEldestEntry(Map.Entry<K, V> eldest) {
        return false;
    }
复制代码

构造方法

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


    /** * 能够指定遍历结点的顺序 * * @param accessOrder true-按访问顺序(最先操做过的结点靠前) * false-按插入顺序遍历(最先插入的结点靠前) */
    public LinkedHashMap(int initialCapacity, float loadFactor, boolean accessOrder) {
        super(initialCapacity, loadFactor);
        this.accessOrder = accessOrder;
    }
复制代码

钩子方法

// 重写HashMap中提供给LinkedHashMap的钩子方法

    /** * HashMap 调用remove方法后，会调用这个钩子方法，e为删除的结点 */
    void afterNodeRemoval(Node<K, V> e) {
        // p = e; b = p.before; a = p.after;
        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 调用put等方法后，会调用这个钩子方法 * * @param evict false-table处于建立模式(即经过构造方法调用) */
    void afterNodeInsertion(boolean evict) {
        LinkedHashMap.Entry<K, V> first;

        // 若是map中存在元素，且须要删除eldest元素，则从链表和Map中
        // 删除双向链表头结点。removeEldestEntry在LinkedHashMap默认返回
        // false。该方法能够用来实现LRU缓存
        if (evict && (first = head) != null && removeEldestEntry(first)) {
            K key = first.key;
            removeNode(hash(key), key, null, false, true);
        }
    }

    /** * HashMap 调用put, get等方法后，会调用这个钩子方法，更改最新访问时间。 * 能够用来实现LRU缓存 * * @param e 最近操做过的结点 */
    void afterNodeAccess(Node<K, V> e) {
        LinkedHashMap.Entry<K, V> last;

        // 若是accessOrder为true，表明按最新遍历时间维护链表
        // 则将e移至链表尾部
        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;
        }
    }
复制代码

其余

public boolean containsValue(Object value) {
        // 由于LinkedHashMap中使用双向链表维护了全部Node，因此只须要遍历
        // 双向链表便可遍历全部Node。而不用遍历Map。

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

    public V get(Object key) {
        Node<K, V> e;
        // 寻找key对应结点
        if ((e = getNode(hash(key), key)) == null)
            return null;
        // 若是须要按访问时间排序，则更新结点在双向链表中的位置
        if (accessOrder)
            afterNodeAccess(e);
        return e.value;
    }

    public V getOrDefault(Object key, V defaultValue) {
        Node<K, V> e;
        if ((e = getNode(hash(key), key)) == null)
            return defaultValue;
        if (accessOrder)
            afterNodeAccess(e);
        return e.value;
    }

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

    public void forEach(BiConsumer<? super K, ? super V> action) {
        if (action == null)
            throw new NullPointerException();
        int mc = modCount;
        // 覆写了遍历方法，用遍历双向链表代替遍历map，从而实现了按序遍历。

        for (LinkedHashMap.Entry<K, V> e = head; e != null; e = e.after)
            action.accept(e.key, e.value);
        if (modCount != mc)
            throw new ConcurrentModificationException();
    }
复制代码

迭代器

abstract class LinkedHashIterator {
        // 下一个要遍历的结点
        LinkedHashMap.Entry<K, V> next;
        // 上一个遍历过的结点
        LinkedHashMap.Entry<K, V> current;
        // 版本号
        int expectedModCount;

        LinkedHashIterator() {
            next = head;
            expectedModCount = modCount;
            current = null;
        }

        public final boolean hasNext() {
            return next != null;
        }

        final LinkedHashMap.Entry<K, V> nextNode() {
            LinkedHashMap.Entry<K, V> e = next;
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
            if (e == null)
                throw new NoSuchElementException();
            current = e;
            // 遍历双向链表的下一个结点
            next = e.after;
            return e;
        }

        public final void remove() {
            Node<K, V> p = current;
            if (p == null)
                throw new IllegalStateException();
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
            current = null;
            K key = p.key;
            removeNode(hash(key), key, null, false, false);
            expectedModCount = modCount;
        }
    }
复制代码

面试题解答

1. LinkedHashMap如何实现有序的

   LinkedHashMap在HashMap的基础上，还将每一个key-value对应的Node维护在了一个额外的双向链表中。

   LinkedHashMap经过accessOrder能够支持按插入的顺序访问，或者按遍历的顺序访问

   accessOrder

   • false: 按插入顺序排序，map中每插入一个结点时，将这个结点同时放置在双向链表的结尾
   • true: 按访问顺序排序，当操做map中的一个结点时，经过HashMap提供的钩子方法(afterNodeAccess、afterNodeInsertion和afterNodeRemoval)找到这个结点在链表中的位置，并移动到链表结尾。这样链表的头结点就是链表最久没有访问过的结点

   遍历的时候，经过便利双向链表代替遍历map的每一个槽，来实现顺序访问。

2. 如何用LinkedHashMap实现LRU

   首先分析LRU算法有哪些特性

   1. 新数据插入到链表尾部(表明最新访问)；
   2. 每当缓存命中(即缓存数据被访问)则将数据移到链表尾部(表明最新访问)；
   3. 当链表满的时候，将链表头部的数据丢弃(删除最久未访问结点)；

   在LinkedHashMap保证结点有序的状况下，经过设置accessOrder为true，采用按遍历顺序维护结点。

   1. put方法将结点插入到双向链表尾部实现LRU特性 1；
   2. 钩子方法afterNodeAccess实现LRU特性 2；
   3. 实现removeEldestEntry方法，删除最久未访问结点。实现LRU特性 3；