数据结构Map-----LinkedHashMap源码解析

LinkedHashMap：重要的成员变量以及构造方法

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

    /**
     * 头节点，这是一个很重要的节点，用来维护一个双向循环链表
     */
    transient LinkedEntry<K, V> header;

    /**
     * True if access ordered, false if insertion ordered.
     * 关系到LinkedHashMap的排序方式，也决定了那个元素会是最近最少使用的元素。
     * 稍后我会详细的说一下true和false对于排序方式的区别。
     */
    private final boolean accessOrder;

    /**
     * 无参构造，注意accessOrder 默认是false
     */
    public LinkedHashMap() {
        init();
        accessOrder = false;
    }

    /**
     *最终调用了3个参数的构造方法
     */
    public LinkedHashMap(int initialCapacity) {
        this(initialCapacity, DEFAULT_LOAD_FACTOR);
    }

    /**
     *最终调用了3个参数的构造方法
     */
    public LinkedHashMap(int initialCapacity, float loadFactor) {
        this(initialCapacity, loadFactor, false);
    }

    /**
     *调用了super也就是父类HashMap的2参构造，同时跟无参构造一样调用了init方法和对于accessOrder的赋值方法
     */
    public LinkedHashMap(
            int initialCapacity, float loadFactor, boolean accessOrder) {
        super(initialCapacity, loadFactor);
        init();
        this.accessOrder = accessOrder;
    }

    //初始化了个LinkedEntry实例header
    @Override void init() {
        header = new LinkedEntry<K, V>();
    }  
}

LinkedEntry 和 HashMapEntry :

/**
 * LinkedEntry
 */
static class LinkedEntry<K, V> extends HashMapEntry<K, V> {
    LinkedEntry<K, V> nxt;
    LinkedEntry<K, V> prv;

    /** Create the header entry */
    LinkedEntry() {
        super(null, null, 0, null);
        nxt = prv = this;
    }

    /** Create a normal entry */
    LinkedEntry(K key, V value, int hash, HashMapEntry<K, V> next,
                LinkedEntry<K, V> nxt, LinkedEntry<K, V> prv) {
        super(key, value, hash, next);
        this.nxt = nxt;
        this.prv = prv;
    }
}

/**
 * HashMapEntry
 */
static class HashMapEntry<K, V> implements Entry<K, V> {
       final K key;
       V value;
       final int hash;
       HashMapEntry<K, V> next;

       HashMapEntry(K key, V value, int hash, HashMapEntry<K, V> next) {
           this.key = key;
           this.value = value;
           this.hash = hash;
           this.next = next;
       }
 }

通过对比我们发现LinkedEntry的构造方法中调用了super(key, value, hash, next); 同时还增加了两个新的特有属性 nxt 和 prv。如果来记得我之前关于LinkedList的源码解析的那篇文章的话，就大致可以猜到这两个属性是干什么的，没错就是引用元素前后其他元素的，也就是指针。

还记得上一篇中我使用★来包裹的函数吗，这里我也贴出来作比较，来看一看LinkedHashMap和HashMap的区别

/**
 * HashMap
 */
void preModify(HashMapEntry<K, V> e) { }


/**
 * LinkedHashMap
 */
@Override 
void preModify(HashMapEntry<K, V> e) {
    if (accessOrder) {
        makeTail((LinkedEntry<K, V>) e);
    }
}

这个方法是出现在put方法中的，LinedkHashMap并没有自己实现put方法，而是依然使用的父类HashMap的put方法，我们可以发现影响两者实现不同的关键在于accessOrder的值上面，如果是false那么两者的实现可以说是完全一样的，但是如果是true的话LinkedHashMap就会执makeTail函数。而我们知道使用无参构造创建LinkedHashMap的时候accessOrder默认值就是false，所以我们先暂时搁置不去看这个函数

/**
 * HashMap
 */
void postRemove(HashMapEntry<K, V> e) { }

/**
 * LinkedHashMap
 */
@Override 
void postRemove(HashMapEntry<K, V> e) {
    LinkedEntry<K, V> le = (LinkedEntry<K, V>) e;
    le.prv.nxt = le.nxt;
    le.nxt.prv = le.prv;
    le.nxt = le.prv = null; // Help the GC (for performance)
}

这个方法是出现在remove方法中的，LinedkHashMap也没有自己实现remove方法，而是依然使用的父类HashMap的remove方法，这是只是操纵了LinedEntry特有的两个属性nxt和prv的指针引用，学过链表结构的想必都知道这个几行代码就是将元素e的前后元素的指针重新进行了赋值，同时将自身的引用断开置空。基本过程就如下图

/**
 * HashMap
 */
void addNewEntry(K key, V value, int hash, int index) {
    table[index] = new HashMapEntry<K, V>(key, value, hash, table[index]);
}

/**
 * LinkedHashMap
 */
@Override 
void addNewEntry(K key, V value, int hash, int index) {
    LinkedEntry<K, V> header = this.header;

    // Remove eldest entry if instructed to do so.
    LinkedEntry<K, V> eldest = header.nxt;
    if (eldest != header && removeEldestEntry(eldest)) {
        remove(eldest.key);
    }

    // Create new entry, link it on to list, and put it into table
    LinkedEntry<K, V> oldTail = header.prv;
    LinkedEntry<K, V> newTail = new LinkedEntry<K,V>(
            key, value, hash, table[index], header, oldTail);
    table[index] = oldTail.nxt = header.prv = newTail;
}

这个方法也是出现在put方法中，如果大家细心的话，可以发现LinedkHashMap的addNewEntry做了和HashMap的addNewEntry相同的事情。同时还做了一些HashMap没有做的事情

/**
 * HashMap
 */
table[index] = new HashMapEntry<K, V>(key, value, hash, table[index]);

/**
 * LinkedHashMap
 */
newTail = new LinkedEntry<K,V>(key, value, hash, table[index], header, oldTail);
table[index] = oldTail.nxt = header.prv = newTail;

总结：刨除header, oldTail就发现其实逻辑是一样的，那么header, oldTail额外干了什么呢，还得记得LinkedEntry的构造吗，去看看你就会想起来了，通过代码可以看出，它维护了一个以header为头节点的双向循环链表，通过上面的几个个比较，到这里想必大家现在应该有点知道了为什么LinkedEntry比HashMapEntry多出的两个属性nxt和pre到底用来干什么的。也就是说LinkedHashMap不但完全跟HashMap一样维护了一个散列链表，同时跟LinkedList一样也维护了一个双向循环链表，所以LinkedHashMap真的是名副其实啊也就是说LinkedHashMap不但像HashMap那样维护了一个Entry[]数组，同时也像LinkedList那样有一个以header为头结点的链表。

Entry[] 数组 table

LinekedEntry header为头结点的链表

我们知道LinkedHashMap的增加和删除调用的是父类HashMap的方法，那么我们来看一下get方法有什么区别

• 查找

/**
 * HashMap
 */
public V get(Object key) {
    if (key == null) {
        HashMapEntry<K, V> e = entryForNullKey;
        return e == null ? null : e.value;
    }

    int hash = Collections.secondaryHash(key);
    HashMapEntry<K, V>[] tab = table;
    for (HashMapEntry<K, V> e = tab[hash & (tab.length - 1)];
            e != null; e = e.next) {
        K eKey = e.key;
        if (eKey == key || (e.hash == hash && key.equals(eKey))) {
            return e.value;
        }
    }
    return null;
}

/**
 * LinkedHashMap
 */
@Override 
public V get(Object key) {
    /*
     * This method is overridden to eliminate the need for a polymorphic
     * invocation in superclass at the expense of code duplication.
     */
    if (key == null) {
        HashMapEntry<K, V> e = entryForNullKey;
        if (e == null)
            return null;
        if (accessOrder)
            makeTail((LinkedEntry<K, V>) e);
        return e.value;
    }

    int hash = Collections.secondaryHash(key);
    HashMapEntry<K, V>[] tab = table;
    for (HashMapEntry<K, V> e = tab[hash & (tab.length - 1)];
            e != null; e = e.next) {
        K eKey = e.key;
        if (eKey == key || (e.hash == hash && key.equals(eKey))) {
            if (accessOrder)
                makeTail((LinkedEntry<K, V>) e);
            return e.value;
        }
    }
    return null;
}

对比发现如果accessOrder如果是false是完全没有区别的，而且我们通过之前对比也多次见到了accessOrder这个变量的身影，可以说这个属性的值决定了很多事情，那么如accessOrder为true的话它都干了些什么呢？那么我们来看makeTail函数究竟做了些什么？

/**
 * 是不是看起来不是那么复杂，而且十分眼熟，好像就是链表指针相关的各种操作，你链我啊 我链你的
 */
private void makeTail(LinkedEntry<K, V> e) {
    // Unlink e
    e.prv.nxt = e.nxt;
    e.nxt.prv = e.prv;

    // Relink e as tail
    LinkedEntry<K, V> header = this.header;
    LinkedEntry<K, V> oldTail = header.prv;
    e.nxt = header;
    e.prv = oldTail;
    oldTail.nxt = header.prv = e;
    modCount++;
}

实际上就是当我们get获取到元素的时候重新调整了该元素在链表中的位置。
相信还有一种数据结构大家不陌生吧就是队列，我们知道LinkedList也是实现Queue接口的

public class LinkedList<E> extends AbstractSequentialList<E> implements
        List<E>, Deque<E>, Queue<E>, Cloneable, Serializable {

所以LindedList其实就是队列的一种，而我们知道队列区别于栈结构的，队列是先进先出，队尾进入，队头出，而栈结构是先进后出的，栈顶进入，栈顶出。

看图我们就可以发现header头节点的nxt所指向的元素就是队头，而header头结点pre指向的元素就是队尾。

而当accessOrder为false的时候，是不执行makeTail函数的，LindedHashMap中的排序方式就是像队列一样先进先出，而且元素的顺序不会发生变化的（保持上图的LinedEntry1和LinedEntry2顺序），即使重新put了key值相同的元素，通过HashMap的源码可以发现他也只是执行了替换，没有执行addNewEntry，所以也就没有机会重新更改指针指向。而队列我们都知道队列满了的时候是从队头删除元素，腾出空间来使用的，所以这种形式下，最先进入队列或者链表中的就是最早的最老的元素，也就是header的nxt，

而当accessOrder为true的时候，是执行makeTail函数的，LindedHashMap中的排序方式就会随着访问和插入操作，元素的顺序就会发生变化的，重新更改指针指向（比如我们访问了LinkedEntry1，那么LinedEntry1就会放到LinkedEntry2的后面，如上图）。每次我们访问一个元素的时候都会改变元素的指针指向，将该元素放回队尾，重新调整header的pre指向，假如我们访问的正好是header.nxt指向的元素，那么header.nxt就会发生变化，那么上面提到的最老的元素就会发生了变化，而header.nxt永远指向的是最近最少使用的

想必看到这里大家对于Android缓存策略Lru到底是怎么实现的应该有了一定的了解了，那就是使用一个了accessOrder为true的LinkedHashMap。

下一篇我将简单带大家看一下LruCache的源码。