java源码解读之LinkedHashMap------jdk 1.7

前面分析了HashMap的实现，我们知道其底层数据存储是一个hash表（数组+单向链表）。接下来我们看一下另一个LinkedHashMap，它是HashMap的一个子类，他在HashMap的基础上维持了一个双向链表（hash表+双向链表），在遍历的时候可以使用插入顺序（先进先出，类似于FIFO），或者是最近最少使用（LRU）的顺序。

 来具体看下LinkedHashMap的实现。

1.定义  

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

2. 属性

//其他属性从hashmap处继承
//头结点
private transient Entry header;
//引用自网上:当accessOrder为true时表示LinkedHashMap内部节点按照访问次数排序,最老的节点也就是访问最少的节点.当 accessOrder为false时表示LinkedHashMap内部节点按照插入顺序排序,最老的节点也就是最早插入的节点,该值默认为false.
private final boolean accessOrder;

//其他基本一致,来看看entry是怎么重写的才能实现双向链表
private static class Entry<K,V> extends HashMap.Entry<K,V> {
    //属性有前后节点,实现双向链表的关键
    Entry before, after;
    Entry(int hash, K key, V value, HashMap.Entry next) {
        //直接调用父类的构造方法
        super(hash, key, value, next);
    }
    private void remove() {
        //例如有三个节点,第一个节点的下一个节点指向第三个节点,第三个节点的上一个节点指向第一个节点
        before.after = after;
        after.before = before;
    }
    //把一个节点加到当前节点的前
    private void addBefore(Entry existingEntry) {
        //将当前节点的下一个节点指向传入节点
        after = existingEntry;
        //把当前节点的前一个节点指向传入节点的上一个节点
        before = existingEntry.before;
        //改变前后节点的指向为自己
        before.after = this;
        after.before = this;
    }
    //在hashmap调用put相同key的时候,get,putForNullKey的时候调用
    void recordAccess(HashMap m) {
        LinkedHashMap lm = (LinkedHashMap)m;
        //如果开启算法排序
        if (lm.accessOrder) {
            //修改次数+1
            lm.modCount++;
            //先删除再添加,进行排序
            //删除当前节点
            remove();
            //把当前元素加入到header前
            addBefore(lm.header);
        }
    }
    //删除当前元素
    void recordRemoval(HashMap m) {
        remove();
    }
}

3. 构造器

//自己设定临界值和负载因子
public LinkedHashMap(int initialCapacity, float loadFactor) {
    super(initialCapacity, loadFactor);
    accessOrder = false;
}
//自己设置临界值
public LinkedHashMap(int initialCapacity) {
    super(initialCapacity);
    accessOrder = false;
}
//使用默认属性
public LinkedHashMap() {
    super();
    accessOrder = false;
}
//根据传入的map集合创建LinkedHashMap
public LinkedHashMap(Map m) {
    super(m);
    accessOrder = false;
}
//自己设定临界值和负载因子,是否开启算法排序
public LinkedHashMap(int initialCapacity,
                     float loadFactor,
                     boolean accessOrder) {
    super(initialCapacity, loadFactor);
    this.accessOrder = accessOrder;
}

4. 解析部分方法源码

4.1 解析部分源码
    LinkedHashMap是继承hashmap的,所以增删改查方法基本一致,只是重写了其中几个方法

void transfer(HashMap.Entry[] newTable, boolean rehash) {
    int newCapacity = newTable.length;
    //从hashmap的foreach遍历改为从头结点开始遍历
    for (Entry 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);
        //把newTable[index]原来位置的结点改为当前节点e节点的下一个节点
        e.next = newTable[index];
        //把newTable[index]赋值为当前节点e
        newTable[index] = e;
    }
}
void init() {
    //创建LinkedHashMap前,先创建头节点
    header = new Entry<>(-1, null, null, null);
    header.before = header.after = header;
}
public V get(Object key) {
    //如果通过key查找不到对应entry,则直接返回null
    Entry e = (Entry)getEntry(key);
    if (e == null)
        return null;
    //与hashmap最大的不同,如果开启了算法排序,则对entry进行排序
    e.recordAccess(this);
    return e.value;
}
public void clear() {
    super.clear();
    //LinkedHashMap与hashmap不同的清空之处在于他有一个头节点的前后关系需要清理
    header.before = header.after = header;
}
void addEntry(int hash, K key, V value, int bucketIndex) {
    super.addEntry(hash, key, value, bucketIndex);
    //判断是否需要删除头结点,因为header不存元素,所以是header的下一个元素,默认是false
    Entry eldest = header.after;
    if (removeEldestEntry(eldest)) {
        removeEntryForKey(eldest.key);
    }
}
void createEntry(int hash, K key, V value, int bucketIndex) {
    //正常的添加节点
    HashMap.Entry old = table[bucketIndex];
    Entry e = new Entry<>(hash, key, value, old);
    table[bucketIndex] = e;
    //维护节点的前后关系
    e.addBefore(header);
    size++;
}