java容器源码分析(七)——LinkedHashMap

本文内容：

LinkedHashMap概述

LinkedHashMap源码分析

LinkedHashMap概述

---

LinkedHashMap相似 于HashMap，区别在于采用迭代器迭代每一个元素时，其顺序是按照插入次序或者是LRU次序。

其继承 关系以下：

LinkedHashMap直接继承了HashMap，实现了Map接口。

LinkedHashMap用Hash存储全部元素，但迭代时却又能够按顺序遍历，这是如何作到的呢？

LinkedHashMap源码分析

---

看一下LinkedHashMap的属性

/**
 * The head of the doubly linked list.
 */
private transient Entry<K,V> header;

/**
 * The iteration ordering method for this linked hash map: <tt>true</tt>
 * for access-order, <tt>false</tt> for insertion-order.
 *
 * @serial
 */
private final boolean accessOrder;

其中header列表记录着元素的插入或者LRU次序，因此很明显，LinkedHashMap可以迭代器顺序访问必定和这个header有关。其实确实是的，header是一个循环双向链表！accessOrder则用来标记是按插入顺序仍是访问顺序。

构造函数：

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

调用了HashMap的构造函数，在HashMap的构造函数中调用了init()方法

@Override
void init() {
    header = new Entry<>(-1, null, null, null);
    header.before = header.after = header;
}

init是初始化header链表。header链表是Entry类型，LinkedHashMap的一个内部静态类，继承了HashMap.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);
    }

   //省略
}

看LinkedHashMap，大部分都是重写(override）父类的一些方法。

/**
 * This override differs from addEntry in that it doesn't resize the
 * table or remove the eldest entry.
 */
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;
    e.addBefore(header);
    size++;
}

createEntry不只把元素添加进了table数组，还经过addBefore将其添加进header链表。

private void addBefore(Entry<K,V> existingEntry) {
    after  = existingEntry;
    before = existingEntry.before;
    before.after = this;
    after.before = this;
}

在header前面插入该元素。最后造成这样的链表：

这个链表在迭代器中用。

void addEntry(int hash, K key, V value, int bucketIndex) {
    super.addEntry(hash, key, value, bucketIndex);

    // Remove eldest entry if instructed
    Entry<K,V> eldest = header.after;
    if (removeEldestEntry(eldest)) {
        removeEntryForKey(eldest.key);
    }
}
protected boolean removeEldestEntry(Map.Entry<K,V> eldest) {
    return false;
}

这里，会调用removeEntryForKey去除最老的元素，但removeEldestEntry方法返回的是false，这样不是永远不会执行removeEntryForKey吗？是的。

这样作是为了让LinkedHashMap的行为是符合正常的Map，不会由于增长元素而把旧的元素给去除。

那直接忽略不就好了吗？

看注释，若是咱们想实现一个cache，只须要重载LinkedHashMap，而后重写removeEldestEntry就能够完成简单的，限制大小的LRU缓存了。好比实现一个100元素的cache，能够这样写：

  private static final int MAX_ENTRIES = 100;
      
  protected boolean removeEldestEntry(Map.Entry eldest) {
      return size() > MAX_ENTRIES;
  }

再看一下transfer

@Override
void transfer(HashMap.Entry[] newTable, boolean rehash) {
    int newCapacity = newTable.length;
    for (Entry<K,V> e = header.after; e != header; e = e.after) {
        if (rehash)
            e.hash = (e.key == null) ? 0 : hash(e.key);
        int index = indexFor(e.hash, newCapacity);
        e.next = newTable[index];
        newTable[index] = e;
    }
}

这个方法被父类的resize调用，重写它是为了实现性能优化！为何呢？由于这里直接用了header链表，而HashMap是遍历全部的table槽。

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

遍历header链表，查看是否包含该value.

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

和HashMap方法相比，多了recordAccess方法的调用。recordAccess方法在Entry中实现。

void recordAccess(HashMap<K,V> m) {
    LinkedHashMap<K,V> lm = (LinkedHashMap<K,V>)m;
    if (lm.accessOrder) {
        lm.modCount++;
        remove();
        addBefore(lm.header);
    }
}
private void remove() {
    before.after = after;
    after.before = before;
}

由代码可知，若是accessOrder被设置成true，就能够有LRU的功能。

最后还剩下iterator方法没看，咱们说LinkedHashMap是支持按插入顺序或者LRU顺序的，说的是遍历的时候。它的实现方法就是遍历header链表。

把LinkedHashMap的迭代器所有贴出来，和HashMap差很少：

private class KeyIterator extends LinkedHashIterator<K> {
    public K next() { return nextEntry().getKey(); }
}

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

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

它们都继承了LinkedHashIterator，LinkedHashIterator是LinkedHashMap的内部抽象类，继承Iterator

private abstract class LinkedHashIterator<T> implements Iterator<T>

LinkedHashIterator的属性以下：

Entry<K,V> nextEntry    = header.after;
Entry<K,V> lastReturned = null;
int expectedModCount = modCount;

hasNext方法：

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

remove方法

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

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

nextEntry方法

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

iterator的实现思路和HashMap很类似，代码找着header链表的结构就很容易理解了。

总结

---

LinkedHashMap使用hash来存放元素，同时也将该元素存放在header链表中，这样，就能够hash方式get/put元素，List方式迭代元素。