LinkedHashMap 实现 LruCache 的底层数据结构?

综合技术 2017-06-13 阅读原文

LinkedHashMap

LinkedHashMap 是 HashMap 的子类,其数据结构是和 HashMap 是差不多的,也是由数组组成,每一个数组的元素都是由链表去维护。但是 LinkedHashMap 还增加了双向链表来维护数据的顺序。

数据结构图解:

LinkedHashMap 的底层数据结构

1、按照访问顺序存取数据

最近最少使用算法的原理就是按照对数据的访问顺序进行的一次排序,在指定的时间对在链表中比较靠前的元素进行移除操作。

LinkedHashMap map = new LinkedHashMap(0, 0.75f, true);

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

上面创建 LinkedHashMap 对象,注意第三个参数为 true ,也就是内部的 accessOrder = true,默认情况该属性是为 false 的,表示按照 插入顺序 排序,若是为 true 表示按照 访问顺序 排序。因为当前的 LinkedHashMap 是需要按照访问顺序排序的因此 accessOrder 应该需要赋值为 true 才行。

2、成员属性

在分析源码之前首先了解几个需要知道的成员属性。

  • HashMapEntry

HashMapEntry 是一种数据结构,用于对 key-value 的封装,并且定义了 next 属性,这个属性是在链表中使用的,它用于指向该 HashMapEntry 在 链表 中的下一个 HashMapEntry 对象。

static class HashMapEntry implements Map.Entry {
        final K key;
        V value;
        HashMapEntry next;
        int hash;
        ...
}
  • table

table 是一个 HashMapEntry 数组类型数据,每次通过 put 方法添加进来的 key-value 都会被封装为 HashMapEntry 对象,然后添加到该 table 的指定位置上。

transient HashMapEntry[] table = (HashMapEntry[]) EMPTY_TABLE;

3、存数据

map.put("1", "hello1");
map.put("2", "hello2");
map.put("3", "hello3");
map.put("4", "hello4");

因为 LinkedHashMap 没有重写 HashMap 的 put 方法,因此存储数据的会调用父类 HashMap 的 put 方法。下面来关注一下 HashMap#put 方法。因为真正存储还要计算 hash 值之类,因此下面的图解只是简单的描述一些数据的存储。

LinkedHashMap数据存储图解

  • HashMap#put
public V put(K key, V value) {
    if (table == EMPTY_TABLE) {
        inflateTable(threshold);
    }
    //key 为 null 的情况
    if (key == null)
        return putForNullKey(value);
    //根据 key 计算出对应的 hash 值
    int hash = sun.misc.Hashing.singleWordWangJenkinsHash(key);

    //调用 indexFor 方法计算出这个 key-value 应该存放在 table 数组的哪个角标位置i上。
    int i = indexFor(hash, table.length);
    //遍历整个 table 数组
    for (HashMapEntry e = table[i]; e != null; e = e.next) {
        Object k;
        //当前需要存储的 key 是存在的
        if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
            //更新操作
            V oldValue = e.value;
            e.value = value;
            //该方法在 HashMap 中是空实现,但是在 LinkedHashMap 中有具体的实现。
            //这个方法是用于对当前的 HashMapEntry 进行排序操作。
            e.recordAccess(this);
            return oldValue;
        }
    }
    modCount++;
    //addEntry 已经被 LinkedHashMap 复写了,因此直接关注 LinkedHashMap 的具体实现即可。
    addEntry(hash, key, value, i);
    return null;
}

void recordAccess(HashMap m) {
    LinkedHashMap lm = (LinkedHashMap)m;
    if (lm.accessOrder) {
        lm.modCount++;
        remove();
        addBefore(lm.header);
    }
}
  • LinkedHashMap#addEntry
void addEntry(int hash, K key, V value, int bucketIndex) {

        // Remove eldest entry if instructed
        //注意 header.after 指向就是双向链表的头部,在 accessOrder = true 的情况下的,也就是最近最少使用的一些元素。
        // header.after 为啥是双向链表的头部呢,下面会有图解。
        LinkedHashMapEntry eldest = header.after;
        if (eldest != header) {
            boolean removeEldest;
            size++;
            try {
                //removeEldestEntry 这个方法默认返回 false,它表示是否要移除先前存储的元素,
                //这个操作得让用户去实现这个方法,例如可以定义当 size() 超过了指定得值后,返回true 等。
                removeEldest = removeEldestEntry(eldest);
            } finally {
                size--;
            }
            if (removeEldest) {
                //移除指定元素。
                removeEntryForKey(eldest.key);
            }
        }

        //上面的代码只是判断是否要移除先前的元素
        //下面还是回调到 Hashmap#addEntry 方法了。
        super.addEntry(hash, key, value, bucketIndex);
    }
  • HashMap#addEntry,真正添加的操作还是有 HashMap 的 addEntry 去实现的。
void addEntry(int hash, K key, V value, int bucketIndex) {
    //判断是否要进行扩容操作。
    if ((size >= threshold) && (null != table[bucketIndex])) {
        resize(2 * table.length);
        hash = (null != key) ? sun.misc.Hashing.singleWordWangJenkinsHash(key) : 0;
        bucketIndex = indexFor(hash, table.length);
    }
    //根据 key 和 value 创建出一个 entry 对象出来
    createEntry(hash, key, value, bucketIndex);
}
  • LinkedHashMap #createEntry

代码执行到了 createEntry 中,因为 LinkedHashMap 已经实现了该方法,因此直接浏览 LinkedHasdhMap 即可;在该方法中,首先根据第四个参数 bucjetIndex 找到对应 table 数组指定位置的 LinkedHashMapEntry 对象,将该 LinkedHashMapEntry 添加到指定的位置上。然后调用 e.addBefore(header) ,注意该方法是维护双向链表的核心方法,表示将该元素添加到双向链表的尾部,也就是 header 节点的前面位置,具体的操作可以看下面的图解。现在可以知道,每次新添加进来的数据都会放在双向链表的尾部,那么就是说头部就是比较少去访问到的元素,因此若是需要移除一些没有怎么访问到的元素,就应该从头部开始移除,这就是为什么上面的 addEntry 方法中要用到 header.after 了,因为 header.after 表示的就是双向链表中最少使用的那个 entry 对象。

void createEntry(int hash, K key, V value, int bucketIndex) {
    HashMapEntry old = table[bucketIndex];
    LinkedHashMapEntry e = new LinkedHashMapEntry(hash, key, value, old);
    table[bucketIndex] = e;
    e.addBefore(header);
    size++;
}

维护双向链表的 e.addBefore(header)

private void addBefore(LinkedHashMapEntry existingEntry) {
    after  = existingEntry;
    before = existingEntry.before;
    before.after = this;
    after.before = this;
}

4、取数据

因为取出这个数据表示该 Entry 被访问,因此该 Entry 在双向链表的顺序要重新排序,因此LinkedHashMap 重写了 get 方法。

  • LinkedHashMap#get

    public V get(Object key) {
      LinkedHashMapEntry e = (LinkedHashMapEntry)getEntry(key);
      if (e == null)
          return null;
      //排序操作
      e.recordAccess(this);
      return e.value;
    }
  • HashMap#getEntry()

该方法并没有被 LinkedHashMap 复写,它表示根据指定的 key 获取到保存该 key-value 的 Entry 对象。内部实现的原理就是通过遍历 table 数组,找到每一个 Entry 元素,然后遍历该 Entry 链表的所有元素,判断链表的每一个 Entry 的 hash 值和需要获取的 key 的 hash 是否一致。

final Entry getEntry(Object key) {
    if (size == 0) {
        return null;
    }
    int hash = (key == null) ? 0 : sun.misc.Hashing.singleWordWangJenkinsHash(key);
    for (HashMapEntry 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;
}

遍历数据

循环遍历获取每一个 Entry 对象,然后输出对应的 key 和 value 值。从下面的输出值中可以看出,它是一种顺序输出的。

“`java

for (Map.Entry entry : map.entrySet()) {

System.out.println(“key:” + entry.getKey() + “;value:” + entry.getValue());

}

方式1:

map.put(“1”, “hello1”);

map.put(“2”, “hello2”);

map.put(“3”, “hello3”);

map.put(“4”, “hello4”);

key:1;value:hello1

key:2;value:hello2

key:3;value:hello3

key:4;value:hello4

方式2:

map.put(“1”, “hello1”);

map.put(“2”, “hello2”);

map.put(“3”, “hello3”);

//在这里取出了 key 为 “1” 的元素,那么该 Entry 的排序就会发生改变。

map.get(“1”);

map.put(“4”, “hello4”);

key:2;value:hello2

key:3;value:hello3

key:1;value:hello1

key:4;value:hello4

* HashMap#entrySet()

> 获取所有 Entry 对象的 set 集合
> 
```java
public Set<Map.Entry> entrySet() {
    //内部调用了entrySet0
    return entrySet0();
}


private Set<Map.Entry> entrySet0() {
    Set<Map.Entry> es = entrySet;
    return es != null ? es : (entrySet = new EntrySet());
}
  • EntrySet#iterator()

注意 foreach 循环底层也是通过调用 EntrySet 的 iterator() 不断的去调用 next() 方法循环的。

private final class EntrySet extends AbstractSet<Map.Entry> {
        public Iterator<Map.Entry> iterator() {
            //内部调用了 newEntryIterator()
            return newEntryIterator();
        }
  • LinkedHashMap#newEntryIterator

这里的 newEntryInterator 已经被 LinkedHashMap 复写了,因此只看 LinkedHahMap 的 newEntryInterator 方法

Iterator<Map.Entry> newEntryIterator() { 
    return new EntryIterator(); 
}

private class EntryIterator extends LinkedHashIterator<Map.Entry> {
   public Map.Entry next() { 
        return nextEntry(); 
   }
}
  • LinkedHashIterator#nextEntry()
private abstract class LinkedHashIterator implements Iterator {
    //header.after 上面描述过了,这表示双向链表的头部的下一个 Entry 对象,是最近最少使用的元素。
    LinkedHashMapEntry nextEntry    = header.after;
    LinkedHashMapEntry lastReturned = null;
    /**
     * The modCount value that the iterator believes that the backing
     * List should have.  If this expectation is violated, the iterato
     * 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 的方法,该方法会在 Iterator.next() 方法内部调用
    Entry nextEntry() {
        if (modCount != expectedModCount)
            throw new ConcurrentModificationException();
        if (nextEntry == header)
            throw new NoSuchElementException();
        LinkedHashMapEntry e = lastReturned = nextEntry;
        nextEntry = e.after;
        return e;
    }
}

5、在 DiskLruCache 移除最近最少使用的元素的的源码 trimeToSize()

在这里也是获取了 EntrySet 的 iterator() 然后不断地调用 next() 方法获取最近最少使用的元素,然后调用 remove 方法进行移除操作。

private void trimToSize() throws IOException {
    while (size > maxSize) {
        final Map.Entry toEvict = lruEntries.entrySet().iterator().next();
        remove(toEvict.getKey());
    }
}
简书

责编内容by:简书阅读原文】。感谢您的支持!

您可能感兴趣的

JavaScript 版数据结构与算法(九)排序和搜索... 在讲解排序和搜索算法前,我们先编写一个 ArrayList 类,使其包含私有变量 array ,用于盛放数组,同时还包含 insert 和 ...
Python数据结构与算法刷题(4)——D进制的A+B... 作者:王大伟 Python爱好者社区唯一小编 博客:https://ask.hellobi.com/blog/wangdawei 感谢关注天善智能,走好...
python数据分析快速入门教程2-pandas数据结构... Title: python数据分析快速入门教程2-pandas数据结构 Date: 2018-03-31 9:20 Category: ...
LinkedHashMap 底层分析 006tNc79ly1fo6w785brkj31g80ytjx5.jpg 众所周知 HashMap 是一个无序的 Map ,因为每次...
数据结构-二分插入排序 接上文 直接插入排序 直接插入排序每轮比较中,都需要把待处理的元素与前面每一位元素进行比较。那么有没有一种方法可以优化下,减少比较次数呢?答案当然是有的...