LinkedHashMap源码解析

一 简介

1、概念

　　LinkedHashMap是HashMap的子类，与HashMap有着同样的存储结构，但它加入了一个双向链表的头结点，将所有put到LinkedHashmap的节点一一串成了一个双向循环链表，因此它保留了节点插入的顺序，可以使节点的输出顺序与输入顺序相同。
LinkedHashMap的遍历速度只和实际的数据有关，和容量无关。
LinkedHashMap是非线程安全的，只在单线程环境下使用。

2、成员变量

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

//该链表遍历的顺序，false为插入顺序，true为访问顺序
private final boolean accessOrder;

//LinkedHashMap的Entry元素。继承HashMap的Entry元素，又保存了其上一个元素before和下一个元素after的引用。
private static class Entry<K,V> extends HashMap.Entry<K,V>

3、构造函数

public LinkedHashMap();

public LinkedHashMap(int initialCapacity);

public LinkedHashMap(int initialCapacity, float loadFactor);

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

public LinkedHashMap(int initialCapacity,float loadFactor,boolean accessOrder);

　　当accessOrder为true时，会去创建一个按照访问的顺序的而排序的LinkedHashMap。这种类型的map适合去构建LRU(最近最少使用)缓存。
　　前四个构造方法都将accessOrder设为false，说明LinkedHashMap默认是按照插入顺序排序的，而第五个构造方法可以自定义传入的accessOrder的值，因此可以指定双向循环链表中元素的排序规则，一般要用LinkedHashMap实现LRU算法，就要用该构造方法，将accessOrder置为true。

4、成员方法概览

public void clear();

public boolean containsValue(Object value);

public V get(Object key);

　　LinkedHash只覆写了父类的这3个公共方法，其余的还是使用父类的一些成员方法。

5、顺序控制

　　accessOrder控制了该链表遍历的顺序，当它false时，表示双向链表中的元素按照Entry插入LinkedHashMap到中的先后顺序排序，即每次put到LinkedHashMap中的Entry都放在双向链表的尾部，这样遍历双向链表时，Entry的输出顺序便和插入的顺序一致，这也是默认的双向链表的存储顺序；当它为true时，表示双向链表中的元素按照访问的先后顺序排列，可以看到，虽然Entry插入链表的顺序依然是按照其put到LinkedHashMap中的顺序，但put和get方法均有调用recordAccess方法（put方法在key相同，覆盖原有的Entry的情况下调用recordAccess方法），该方法判断accessOrder是否为true，如果是，则将当前访问的Entry（put进来的Entry或get出来的Entry）移到双向链表的尾部（key不相同时，put新Entry时，会调用addEntry，它会调用creatEntry，该方法同样将新插入的元素放入到双向链表的尾部，既符合插入的先后顺序，又符合访问的先后顺序，因为这时该Entry也被访问了），否则，什么也不做。

二 源码分析

1、初始化

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

　　该方法覆写父类的init()方法（HashMap中的init方法为空），该方法在父类的构造方法和Clone、readObject中在插入元素前被调用，然后初始化一个空的双向循环链表，头结点中不保存数据，头结点的下一个节点才开始保存数据。

2、顺序调整

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

　　该方法覆写了HashMap中的recordAccess方法（HashMap中该方法为空），LinkedHashMap没有自己实现put方法，当调用父类的put方法，在发现插入的key已经存在时，会调用该方法。调用LinkedHashmap覆写的get方法时，也会调用到该方法。
　　当accessOrder为true时，该方法提供了LRU算法的实现，它将最近使用的Entry放到双向循环链表的尾部，保持LinkedHashMap中的键值对顺序是按照访问循序排列。如果accessOrder为false时，该方法不做操作。

3、扩容

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中的transfer方法，它在父类的resize方法中被调用，扩容后，将key-value对重新映射到新的newTable中。覆写该方法的目的是为了提高复制的效率，这里充分利用双向循环链表的特点进行迭代，不用对底层的数组进行for循环。

4、get操作

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中的get方法，该方法与父类HashMap中的实现唯一不同的地方在于：如果查询的结果不为空，则调用顺序调整方法recordAccess()去调整LinkedHashMap中的元素顺序。

5、put操纵

　　LinkedHashMap没有覆写父类的put方法，只是覆写了put方法中调用的addEntry方法，在增加元素时，同时将元素添加到LinkedHashMap中维护得双向循环链表。

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

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

6、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中的containsValue方法，覆写该方法的目的同样是为了提高查询的效率，利用双向循环链表的特点进行查询，少了对数组的外层for循环。

7、清除操作

public void clear() {
    super.clear();
    header.before = header.after = header;
}

　　清空HashMap，因为LinkedHashMap中额外维护利率一个双向链表，所以需要将双向链表还原为只有头结点的空链表

三 应用

1、使用linkedHashMap实现LRU缓存

　　覆写了LinkedHashMap的removeEldestEntry方法，因为LinkedHashMap覆写了父类的addEntry方法，每次put元素时，addEntry方法都会调用该方法去判断是否替换最近最少使用的元素。当达到缓存的容量上线时removeEldestEntry就会返回ture，从而调用removeEntryForKey方法将最近最少使用的元素直接删除。

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

    private static final long serialVersionUID = 1L;  

    //定义缓存的容量  
    private int capacity;  

    //带参数的构造器     
    public LRULinkedHashMap(int capacity){  
        //调用LinkedHashMap的构造器，传入以下参数  
        super(16,0.75f,true);  
        //传入指定的缓存最大容量  
        this.capacity=capacity;  
    }  

    //实现LRU的关键方法，如果map里面的元素个数大于了缓存最大容量，则删除链表的顶端元素  
    @Override  
    public boolean removeEldestEntry(Map.Entry<K, V> eldest){    
        return size()>capacity;  
    }    
}

测试类

public class LRUTest {

    public static void main(String[] args) {
        Map<String,Object> map = new LRULinkedHashMap<String,Object>(5);
        map.put("a", "11");
        map.put("b", "22");
        map.put("c", "33");
        map.put("d", "44");
        map.put("e", "55");
        map.put("f", "66");
        map.put("d", "77");
        map.put("b", "88");

        for(Map.Entry<String, Object> entry:map.entrySet())
            System.out.println(entry.getKey()+":"+entry.getValue());
    }

}

结果如下
c:33
e:55
f:66
d:77
b:88

参考链接：http://blog.csdn.net/exceptional_derek/article/details/11713255