【Java集合类源码分析】LinkedHashMap源码分析

版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/qq_18495465/article/details/71403720

【Java集合类源码分析】LinkedHashMap源码分析

一、LinkedHashMap简介

    LinkedHashMap是HashMap的一个子类,但它加入了一个双向链表的头结点,将插入的记录串成了一个双向循环链表,因此保存了记录的插入顺序,在用Iterator遍历LinkedHashMap时,取得的记录的顺序是插入次序或者是最近最少使用(LRU)次序。

public class LinkedHashMap<K,V>
    extends HashMap<K,V>
    implements Map<K,V>

    LinkedHashMap继承自HashMap并实现了Map接口。

二、LinkedHashMap内部结构

    LinkedHashMap内部会在Map.Entry类的基础上,增加两个Entry类型的引用:before,after。LinkedHashMap使用一个双向循环链表,将其内部所有的Entry串起来。
## LinkedHashMap内部结构图 ##

三、LinkedHashMap源码分析(JDK1.7)

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

    private static final long serialVersionUID = 3801124242820219131L;

    /**
     * 双向循环链表的头结点
     */
    private transient Entry<K,V> header;

    /**
     * 双向链表中元素排序规则的标志位
     * true:按访问顺序排序
     * false:按插入顺序排序
     * @serial
     */
    private final boolean accessOrder;

    /**
     * 构造一个具有指定初始容量和负载因子的空LinkedHashMap(按插入顺序排序)
     * @param  initialCapacity 初始容量
     * @param  loadFactor      加载因子
     */
    public LinkedHashMap(int initialCapacity, float loadFactor) {
        //调用HashMap的构造方法来构造底层数组
        super(initialCapacity, loadFactor);
        //链表中的元素默认按照插入顺序排序
        accessOrder = false;
    }

    /**
     * 构造一个具有指定的初始容量和默认负载因子(0.75)的空LinkedHashMap(按插入顺序排序)
     * @param  initialCapacity 初始容量
     */
    public LinkedHashMap(int initialCapacity) {
        super(initialCapacity);
        accessOrder = false;
    }

    /**
     * 构造一个具有默认初始容量(16)和默认负载因子(0.75)的空的LinkedHashMap(按插入顺序排序)
     */
    public LinkedHashMap() {
        super();
        accessOrder = false;
    }

    /**
     * 构造一个新的LinkedHashMap包含指定的map(按插入顺序排序)
     */
    public LinkedHashMap(Map<? extends K, ? extends V> m) {
        super(m);
        accessOrder = false;
    }

    /**
     * 构造一个具有指定初始容量,加载因子和排序模式的空的LinkedHashMap
     *
     * @param  initialCapacity 初始容量
     * @param  loadFactor      加载因子
     * @param  accessOrder     排序规则
     */
    public LinkedHashMap(int initialCapacity,
                         float loadFactor,
                         boolean accessOrder) {
        super(initialCapacity, loadFactor);
        this.accessOrder = accessOrder;
    }

    /**
     * 覆写HashMap中的init方法(HashMap中该方法为空)
     * 该方法在超类构造函数和伪构造函数(clone,readObject)插入元素前被调用
     * 初始化一个空的双向循环链表,头结点中不保存数据,头结点的下一个结点才开始保存数据
     */
    void init() {
        header = new Entry<>(-1, null, null, null);
        header.before = header.after = header;
    }

    /**
     * 覆写HashMap中的transfer方法,它在父类的resize方法中被调用
     * 扩容后将内部键值对重新映射到新的newTable中
     * 覆写该方法的目的是提高复制的效率
     * 利用双向循环链表的特点进行迭代,不用对底层的数组进行for循环
     */
    void transfer(HashMap.Entry[] newTable) {
        int newCapacity = newTable.length;
        for (Entry<K,V> e = header.after; e != header; e = e.after) {
            int index = indexFor(e.hash, newCapacity);
            e.next = newTable[index];
            newTable[index] = e;
        }
    }


    /**
     * 覆写HashMap中的containsValue方法
     * 覆写该方法的目的同样是为了提高查询的效率
     * 利用双向循环链表的特点进行迭代
     */
    public boolean containsValue(Object value) {
        // Overridden to take advantage of faster iterator
        if (value==null) {
            for (Entry e = header.after; e != header; e = e.after)
                if (e.value==null)
                    return true;
        } else {
            for (Entry e = header.after; e != header; e = e.after)
                if (value.equals(e.value))
                    return true;
        }
        return false;
    }

    /**
     * 覆写HashMap中的get方法,通过getEntry方法获取Entry对象
     * 注意recordAccess方法!!!
     */
    public V get(Object key) {
        Entry<K,V> e = (Entry<K,V>)getEntry(key);
        if (e == null)
            return null;
        e.recordAccess(this);
        return e.value;
    }

    /**
     * 清空LinkedHashMap,并将双向链表还原为只有头结点的空链表
     */
    public void clear() {
        super.clear();
        header.before = header.after = header;
    }

    /**
     *  在Map.Entry类的基础上,增加两个Entry类型的引用:before,after
     *  LinkedHashMap使用一个双向循环链表,将其内部所有的Entry串起来
     */
    private static class Entry<K,V> extends HashMap.Entry<K,V> {
        // These fields comprise the doubly linked list used for iteration.
        Entry<K,V> before, after;

        Entry(int hash, K key, V value, HashMap.Entry<K,V> next) {
            super(hash, key, value, next);
        }

        /**
         * 双向循环链表中,删除当前Entry
         */
        private void remove() {
            before.after = after;
            after.before = before;
        }

        /**
         * 双向循环链表中,将当前Entry插入到指定Entry前面
         */
        private void addBefore(Entry<K,V> existingEntry) {
            after  = existingEntry;
            before = existingEntry.before;
            before.after = this;
            after.before = this;
        }

        /**
         * 覆写HashMap中的recordAccess方法(HashMap中该方法为空)
         * 每当Map.get读取或Map.set修改预先存在的Entry时,超类将调用此方法
         * 该方法提供了LRU算法(accessOrder=true)的实现,将最近使用的Entry放到双向循环链表的尾部
         */
        void recordAccess(HashMap<K,V> m) {
            LinkedHashMap<K,V> lm = (LinkedHashMap<K,V>)m;
            //如果链表中元素按照访问顺序排序,则将当前访问的Entry移到双向循坏链表的尾部
            //如果按照插入顺序排序,则不做任何事情
            if (lm.accessOrder) {
                lm.modCount++;
                //移除当前访问的Entry
                remove();
                //将当前访问的Entry插入到链表的尾部
                addBefore(lm.header);
            }
        }

        void recordRemoval(HashMap<K,V> m) {
            remove();
        }
    }

    //迭代器
    private abstract class LinkedHashIterator<T> implements Iterator<T> {
        Entry<K,V> nextEntry    = header.after;
        Entry<K,V> lastReturned = null;

        /**
         * The modCount value that the iterator believes that the backing
         * List should have.  If this expectation is violated, the iterator
         * has detected concurrent modification.
         */
        int expectedModCount = modCount;

        public boolean hasNext() {
            return nextEntry != header;
        }

        public void remove() {
            if (lastReturned == null)
                throw new IllegalStateException();
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();

            LinkedHashMap.this.remove(lastReturned.key);
            lastReturned = null;
            expectedModCount = modCount;
        }

        Entry<K,V> nextEntry() {
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
            if (nextEntry == header)
                throw new NoSuchElementException();

            Entry<K,V> e = lastReturned = nextEntry;
            nextEntry = e.after;
            return e;
        }
    }

    //key迭代器
    private class KeyIterator extends LinkedHashIterator<K> {
        public K next() { return nextEntry().getKey(); }
    }

    //value迭代器
    private class ValueIterator extends LinkedHashIterator<V> {
        public V next() { return nextEntry().value; }
    }

    //Entry迭代器
    private class EntryIterator extends LinkedHashIterator<Map.Entry<K,V>> {
        public Map.Entry<K,V> next() { return nextEntry(); }
    }

    // These Overrides alter the behavior of superclass view iterator() methods
    Iterator<K> newKeyIterator()   { return new KeyIterator();   }
    Iterator<V> newValueIterator() { return new ValueIterator(); }
    Iterator<Map.Entry<K,V>> newEntryIterator() { return new EntryIterator(); }

    /**
     * 覆写HashMap中的addEntry方法
     * 并没有覆写HashMap中的put方法,而是覆写了put方法所调用的addEntry方法和recordAccess方法
     * put方法在插入的key已存在的情况下,会调用recordAccess方法
     */
    void addEntry(int hash, K key, V value, int bucketIndex) {
        createEntry(hash, key, value, bucketIndex);

        // 双向链表的第一个有效结点(header后的第一个结点)为最近最少使用结点
        Entry<K,V> eldest = header.after;
        //如果有指示则删除最近最少使用的结点,否则在合适的情况下增加容量
        //这要看对removeEldestEntry的覆写(默认是false不做任何处理)
        if (removeEldestEntry(eldest)) {
            removeEntryForKey(eldest.key);
        } else {
            if (size >= threshold)
                resize(2 * table.length);
        }
    }

    /**
     * 覆写HashMap中的createEntry方法
     * 与addEntry不同之处在于它不会调整表的大小或删除最近最少使用的结点。
     */
    void createEntry(int hash, K key, V value, int bucketIndex) {
        HashMap.Entry<K,V> old = table[bucketIndex];
        Entry<K,V> e = new Entry<>(hash, key, value, old);
        table[bucketIndex] = e;
        //每次插入Entry时,都将其添加到双向链表的尾部
        //这便会按照Entry插入LinkedHashMap的先后顺序来迭代元素
        //新put进来的Entry是最近访问的Entry,放在双向链表的尾部,符合LRU算法的实现
        e.addBefore(header);
        size++;
    }

    /**
     * 如果map应删除其最近最少访问的Entry,则返回true
     * 在将新Entry插入map后,该方法由put和putAll方法调用
     * 它为实施者提供一个添加新Entry时删除最老Entry的机会
     * 如果map代表一个缓存,这是非常有用的:它允许map通过删除最近最少使用的Entry(header后的那个结点)来减少内存消耗。
     * Sample use:
     *     private static final int MAX_ENTRIES = 100;
     *     protected boolean removeEldestEntry(Map.Entry eldest) {
     *        return size() > MAX_ENTRIES;
     *     }
     * @return   如果需要删除最近最少使用的结点,则返回true,否则返回false
     */
    protected boolean removeEldestEntry(Map.Entry<K,V> eldest) {
        return false;
    }
}

四、LinkedHashMap的put()和get()

    1、put()方法-向LinkedHashMap中存储键值对

/**
 * HashMap中的put方法(LinkedHashMap并没有覆写该方法而是覆写了put方法所调用的addEntry方法和recordAccess方法)
 */
public V put(K key, V value) {
    //若key为null,则将该键值对放置到table[0],即第一个桶
    if (key == null)
        return putForNullKey(value);
    //若key不为null,重新计算key的hashCode值
    int hash = hash(key.hashCode());
    //计算当前hashCode值确定应该将这一对键值对存放在哪一个桶中,即确定要存放桶的索引
    int i = indexFor(hash, table.length);
    //遍历所在桶中的Entry<K,V>链表,查找其中是否已经存在以key值为K存储的Entry<K,V>对象
    for (Entry<K,V> e = table[i]; e != null; e = e.next) {
        Object k;
        //已存在,定位到对应的Entry<K,V>,其中的value值更新为新的value值,并返回旧值
        if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
            V oldValue = e.value;
            e.value = value;
            e.recordAccess(this);
            return oldValue;
        }
    }
    //不存在,根据键值对<K,V>创建一个新的Entry<K,V>对象,然后添加到这个桶的链表头部
    modCount++;
    addEntry(hash, key, value, i);
    return null;
}

当要put进来的Entry的key在哈希表中已经存在的情况下,会覆盖旧value值并调用recordAccess方法,当该key不存在时,会调用addEntry方法将新的Entry插入到对应桶的单链表头部。

/**
 * 覆写HashMap中的recordAccess方法(HashMap中该方法为空)
 * 每当Map.get读取或Map.set修改预先存在的Entry时,超类将调用此方法
 * 该方法提供了LRU算法(accessOrder=true)的实现,将最近使用的Entry放到双向循环链表的尾部
 */
void recordAccess(HashMap<K,V> m) {
    LinkedHashMap<K,V> lm = (LinkedHashMap<K,V>)m;
    //如果链表中元素按照访问顺序排序,则将当前访问的Entry移到双向循坏链表的尾部
    //如果按照插入顺序排序,则不做任何事情
    if (lm.accessOrder) {
        lm.modCount++;
        //移除当前访问的Entry
        remove();
        //将当前访问的Entry插入到链表的尾部
        addBefore(lm.header);
    }
}

判断accessOrder是否为true,若为true,则将当前访问的Entry移动到双向循环链表的尾部,从而实现双向链表中的元素按照访问顺序来排序(最近访问的Entry放在双向循环链表的尾部,这样,前面就是最近未被访问的元素,实现了LRU算法)。

/**
 * 覆写HashMap中的addEntry方法
 */
void addEntry(int hash, K key, V value, int bucketIndex) {
    createEntry(hash, key, value, bucketIndex);

    // 双向链表的第一个有效结点(header后的第一个结点)为最近最少使用结点
    Entry<K,V> eldest = header.after;
    //如果有指示则删除最近最少使用的结点,否则在合适的情况下增加容量
    //这要看对removeEldestEntry的覆写(默认是false不做任何处理)
    if (removeEldestEntry(eldest)) {  //源码分析中对该方法已经做了详细讲解,这边不再重复
        removeEntryForKey(eldest.key);
    } else {
        if (size >= threshold)
            resize(2 * table.length);
    }
}

/**
 * 覆写HashMap中的createEntry方法
 */
void createEntry(int hash, K key, V value, int bucketIndex) {
    //创建新Entry,并将其插入到对应桶的单链表头部,与HashMap相同
    HashMap.Entry<K,V> old = table[bucketIndex];
    Entry<K,V> e = new Entry<>(hash, key, value, old);
    table[bucketIndex] = e;
    //每次插入Entry时,都将其添加到双向链表的尾部
    //这便会按照Entry插入LinkedHashMap的先后顺序来迭代元素
    //新put进来的Entry是最近访问的Entry,放在双向链表的尾部,符合LRU算法的实现
    e.addBefore(header);
    size++;
}

同样是将新Entry插入到table中对应桶所对应的单链表的头结点中,但在覆写后的createEntry中,将新Entry插入到了双向循环链表的尾部,从插入顺序层面来说,新Entry插入到双向循环链表的尾部,可以实现按照插入的先后顺序来迭代Entry,而从访问顺序层面来说,新Entry又是最近访问的Entry,也应该讲其放在双向循环链表的尾部。
    2、get()方法-根据指定的key值从LinkedHashMap中取value值

/**
 * 覆写HashMap中的get方法,通过getEntry方法获取Entry对象
 * 注意recordAccess方法(上面已经做了讲解,这边不再重复)
 * 若排序规则是按照插入的先后顺序,则什么也不做
 * 若排序规则是按照访问的先后顺序,则将当前访问的Entry移到双向循环链表的尾部
 */
public V get(Object key) {
    //调用HashMap中的getEntry方法
    Entry<K,V> e = (Entry<K,V>)getEntry(key);
    if (e == null)
        return null;
    e.recordAccess(this);
    return e.value;
}

/**
 * HashMap中的getEntry方法
 */
final Entry<K,V> getEntry(Object key) {
    int hash = (key == null) ? 0 : hash(key.hashCode());
    for (Entry<K,V> e = table[indexFor(hash, table.length)];
         e != null;
         e = e.next) {
        Object k;
        if (e.hash == hash &&
            ((k = e.key) == key || (key != null && key.equals(k))))
            return e;
    }
    return null;
}

五、总结

    1、LinkedHashMap相较于HashMap又额外定义了一个以header为头结点的空的双向循坏链表,每次put进来Entry时,除了将其保存在哈希表中的对应的位置上外,还要讲其插入到这个双向循坏链表的尾部以维持内部Entry顺序。
    2、LinkedHashMap继承自HashMap,除了遍历顺序外,其他特性与HashMap基本相同
    3、注意LinkedHashMap中的accessOrder标志位,当它为false时,表示双向循环链表中的元素按照Entry插入的先后顺序排序,即每次put新Entry时,将其插入到双向循环链表的尾部,这样在遍历这个链表时,Entry的输出顺序便和插入顺序一致,这也是LinkedHashMap默认的排序规则当它为true时,表示双向循环链表中的元素按照访问的先后顺序排序,从源码中可以看到,put和get方法均有调用recordAccess方法(put方法在key已存在覆盖原来Entry的情况下调用),该方法判断accessOrder是否为true,若为true,则将当前访问的Entry(put进去的Entry或get出来的Entry)移到双向循环链表的尾部(key之前不存在时,即put新Entry时,会调用addEntry方法,它会调用createEntry方法,该方法同样将新Entry插入到了双向循环链表的尾部,既符合插入的先后顺序,又符合访问的先后顺序),否则,什么也不做。
    4、LinkedHashMap是如何实现LRU的?首先,当accessOrder为true时,才会开启按访问顺序排序的模式,才能用来实现LRU算法。无论是put方法还是get方法,都会导致目标Entry成为最近访问的Entry,因此便把该Entry加入到了双向链表的末尾(get方法通过调用recordAccess方法来实现,put方法在覆盖已有key的情况下,也是通过调用recordAccess方法来实现,在插入新Entry时,则是通过createEntry中的addBefore方法来实现),这样便把最近使用了的Entry放入到了双向链表的后面,多次操作后,双向链表前面的Entry便是最近没有使用的,这样当结点个数满的时候,删除的最前面的Entry(head后面的那个Entry)便是最近最少使用的Entry。

阅读更多
想对作者说点什么?

博主推荐

换一批

没有更多推荐了,返回首页