集合框架源码分析五之LinkedHashMap，LinkedHashSet

LinkedHashMap是为了解决遍历Hash表的无序问题，它内部维护了一个链表用于记录你插入元素（或你访问元素的顺序）的位置，遍历时直接遍历链表，元素的顺序即为你插入的顺序，但是Entry对象要多加两个成员变量before和after用于记录链表的前驱和后继。所以LinkedHashMap的的存储效率要低于HashMap，但是遍历效率要高于HashMap。

import java.util.ConcurrentModificationException;

import java.util.HashMap;

import java.util.Iterator;

import java.util.Map;

import java.util.NoSuchElementException;

/**

* LinkedHashMap内部不仅存储了一个散列表，

* 也维护了一个链表，

* 根据链表中元素的顺序可以分为：按插入顺序的链表，和按访问顺序(调用get方法)的链表。

* 默认是按插入顺序排序，如果指定按访问顺序排序，那么调用get方法后，会将这次访问的元素

* 移至链表尾部，不断访问可以形成按访问顺序排序的链表。

* 可以重写removeEldestEntry方法返回true值指定插入元素时移除最老的元素

*/

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

implements Map<K,V>

{

private static final long serialVersionUID = 3801124242820219131L;

/**

* 此Map中维护的一个双向循环链表的头节点

*/

private transient Entry<K,V> header;

/**

*

* 遍历Map的顺序的变量，

* true为按访问顺序遍历

* false为按插入顺序遍历

*/

private final boolean accessOrder;

/**

*

* 构造一个空的，按插入顺序遍历的LinkedHashMap实例，

* 初始容量与加载因子由自己指定

*/

public LinkedHashMap(int initialCapacity, float loadFactor) {

super(initialCapacity, loadFactor);

accessOrder = false;

}

/**

* 构造一个空的，按插入顺序遍历的LinkedHashMap实例，

* 初始容量由自己指定

*/

public LinkedHashMap(int initialCapacity) {

super(initialCapacity);

accessOrder = false;

}

/**

*

* 构造一个空的，按插入顺序遍历的LinkedHashMap实例

* 初始容量与加载因子按HashMap的默认值16与0.75

*/

public LinkedHashMap() {

super();

accessOrder = false;

}

/**

* 构造一个非空，按插入顺序遍历的LinkedHashMap实例

*/

public LinkedHashMap(Map<? extends K, ? extends V> m) {

super(m);

accessOrder = false;

}

public LinkedHashMap(int initialCapacity,

float loadFactor,

boolean accessOrder) {

super(initialCapacity, loadFactor);

this.accessOrder = accessOrder;

}

/**

*

* 在HashMap每个构造方法中都会调用一次此init()方法

* 这里是初始化一个双向循环链表的头节点

*/

void init() {

header = new Entry<K,V>(-1, null, null, null);

header.before = header.after = header;

}

/**

*

* 在父类HashMap进行容量扩充时会调用此方法

* 把原来Entry数组中的对象经过重新计算索引转移到此newTable中

* 这里与HashMap中的transfer方法的实现不再相同，而且比它更快。

*

* HashMap是遍历Entry数组，需要检查是否为null，如果不为空的话则就需

* 要遍历数组中的链表，而这里所有的元素都链接成了一个链表，直接遍历此

* 链表就可以遍历出LinkedHashMap中的所有元素。

*/

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);
//根据新容量重新计算index

e.next = newTable[index]; //最后添加的节点放最前面

newTable[index] = e;

}

}

/**

*

* 查找Map中是否含有本值，这里重写了HashMap的containsValue方法

* 因为在LinkedHashMap中只需要遍历链表查找，这比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;

}

/**

*

* 通过key值获得value，如果没有找到此key则返回null。

* 不过返回null也可能是其value为null

* 通过contain方法可判断Map中是否含有此键

*

* 重写此方法的原因是：

* 如果map中链表是按照访问顺序进行排序，

* 就需要把本次访问的元素移到链表尾部，表示

* 这是你最新访问的元素,以后可能会继续访问它

*

*/

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;

}

/**

* 移除元素，清空链表

*/

public void clear() {

super.clear();

header.before = header.after = header;

}

/**

* LinkedHashMap 的Entry对象.

*/

private static class Entry<K,V> extends HashMap.Entry<K,V> {

// 包含其前驱和后继的信息.

Entry<K,V> before, after;

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

super(hash, key, value, next);

}

/**

*

* 在链表中移除此对象只需要修改前驱和后继的指针

*/

private void remove() {

before.after = after;

after.before = before;

}

/**

*

* 把元素插入到指定的存在的元素之前

* 链表的插入也是修改指针

*/

private void addBefore(Entry<K,V> existingEntry) {

after = existingEntry;

before = existingEntry.before;

before.after = this;

after.before = this;

}

/**

*

* 当调用父类的put或putAll方法，发现要插入的键已经存在时会调用此方法，

* 当调用LinkedHashMap的get方法时会调用此方法。

* 如果LinkedHashMap是按访问顺序遍历的，就移动此Entry

* 到链表的最后位置，否则do nothing

*/

void recordAccess(HashMap<K,V> m) {

LinkedHashMap<K,V> lm = (LinkedHashMap<K,V>)m;

if (lm.accessOrder) {

lm.modCount++;

remove(); //移除它

addBefore(lm.header); //再把她添加到链表尾部

}

}

/**

* 在移除元素时会调用此方法，即调用

* 父类的remove(key)方法时调用它

* 这里是改变链表指针，移除链表中的此元素

*/

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;

/**

* 检测同步

*/

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;

}

}

//依次重写next方法，返回不同的迭代器。

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

/**

*

* 重写父类addEntry方法

*/

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

createEntry(hash, key, value, bucketIndex);

/*如果子类重写了removeEldestEntry方法并返回true，

将在map中移除链表中的第一个元素，否则检测是否需要扩充容量。

eldest元素即为链表中的第一个元素*/

Entry<K,V> eldest = header.after;

if (removeEldestEntry(eldest)) {

removeEntryForKey(eldest.key);

} else {

if (size >= threshold)

resize(2 * table.length); //扩充至原来的2倍

}

}

/**

*

* 重写父类的createEntry方法，此方法不需要检测是否要扩充容量，

* 与HashMap中此方法的唯一区别时，这里不仅把元素插入到散列表中，

* 而且将元素插入到了链表尾

*/

void createEntry(int hash, K key, V value, int bucketIndex) {

HashMap.Entry<K,V> old = table[bucketIndex];

Entry<K,V> e = new Entry<K,V>(hash, key, value, old);

table[bucketIndex] = e;

e.addBefore(header);

size++;

}

/**

*

* 此方法会在调用put()或putAll()方法时调用，此方法告诉linkedHashMap

* 是否在添加一个元素后移除最老的元素

* 比如下面代码会让LinedHashMap的大小始终保持在100

* private static final int MAX_ENTRIES = 100;

*

* protected boolean removeEldestEntry(Map.Entry eldest) {

* return size() > MAX_ENTRIES;

* }

* 此方法默认返回false，需要子类去复写此方法

*

* 什么是eldest元素?

* 如果按插入问顺序来说，是map中最先插入的元素

* 如果按访问顺序来说，是map中最久未被访问的元素

*/

protected boolean removeEldestEntry(Map.Entry<K,V> eldest) {

return false;

}

}

关于LinkedHashSet

/**

* LinkedHashSet实际上是基于LinkedHashMap的基础上实现的，

* LinkedHashSet继承自HashSet，在HashSet中有一构造方法

* HashSet(int initialCapacity, float loadFactor, boolean dummy)

* 第三个参数dummy为true时new出了一个LinkedHashMap实例，以Set中的

* 元素为键，以一个Object的虚假的对象为值，所以HashSet中的元素不可能重复。

* 以下构造函数dummy都为true

*/

public class LinkedHashSet<E>

extends HashSet<E>

implements Set<E>, Cloneable, java.io.Serializable {

private static final long serialVersionUID = -2851667679971038690L;

public LinkedHashSet(int initialCapacity, float loadFactor) {

super(initialCapacity, loadFactor, true);

}

public LinkedHashSet(int initialCapacity) {

super(initialCapacity, .75f, true);

}

public LinkedHashSet() {

super(16, .75f, true);

}

public LinkedHashSet(Collection<? extends E> c) {

super(Math.max(2*c.size(), 11), .75f, true);

addAll(c);

}

}