概述

文章的内容基于JDK1.7进行分析，之所以选用这个版本，是因为1.8的有些类做了改动，增加了阅读的难度，虽然是1.7，但是对于1.8做了重大改动的内容，文章也会进行说明。

LinkedHashMap,见名知义，带链表的HashMap, 所以LinkedHashMap是有序，LinkedHashMap作为HashMap的扩展，它改变了HashMap无序的特征。它使用了一个双向的链表来会维护key-value对的次序，该链表维护了map的迭代顺序，该迭代顺序和key-value对的插入顺序保持一致。LinkedHashMap重写了父类的一些方法，这些方法也会在下面的文章中进行说明。

数据结构继承关系java.lang.Object

java.util.AbstractMap

java.util.HashMap

java.util.LinkedHashMap

从上面的集成关系中看出，LinkedHashMap集成了HashMap类，所以便拥有了HashMap开放的所有功能，而LinkedList在所有功能的基础上又进行了升级，添加了记住元素添加顺序的职责。实现接口Serializable, Cloneable, Map

LinkedHashMap 可序列化，可以被克隆 ,实现了Map接口基本属性private transient Entry header;  //双向链表的头节点private final boolean accessOrder;  //排序的规则，false按插入顺序排序，true访问顺序排序

重要方法深度解析构造方法//LinkedHashMap的构造方法，都是通过调用父类的构造方法来实现，大部分accessOrder默认为falsepublic LinkedHashMap(int initialCapacity, float loadFactor) {    super(initialCapacity, loadFactor);

accessOrder = false;

}public LinkedHashMap(int initialCapacity) {    super(initialCapacity);

accessOrder = false;

}public LinkedHashMap() {    super();

accessOrder = false;

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

}

上面是LinkedHashMap的构造方法，通过传入初始化参数和代码看出，LinkedHashMap的构造方法和父类的构造方法，是一一对应的。也是通过super()关键字来调用父类的构造方法来进行初始化，唯一的不同是最后一个构造方法，提供了AccessOrder参数，用来指定LinkedHashMap的排序方式，accessOrder =false -> 插入顺序进行排序 ， accessOrder = true -> 访问顺序进行排序。

put()方法

LinkedHashMap并没有重写父类的put()方法，说明调用put方法时实际上调用的是父类的put方法。

get()方法public V get(Object key) {

Entry e = (Entry)getEntry(key); //调用父类的getEntry()方法

if (e == null)        return null;

e.recordAccess(this);  //判断排序方式，如果accessOrder = true , 删除当前e节点

return e.value;

}

remove()

LinkedHashMap并没有重写父类的remove()方法，说明调用remove方法时实际上调用的是父类的remove()方法。

源码解析Entry定义private static class Entry extends HashMap.Entry {    //定义Entry类型的两个变量，或者称之为前后的两个指针

Entry before, after;    //构造方法与HashMap的没有区别，也是调用父类的Entry构造方法

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中为空

void recordAccess(HashMap m) {

LinkedHashMap lm = (LinkedHashMap)m;        if (lm.accessOrder) {

lm.modCount++;

remove();

addBefore(lm.header);

}

}    //方法重写 ，HashMap中方法为空

void recordRemoval(HashMap m) {

remove();

}

}public class LinkedHashMap extends HashMap    implements Map{    //可序列化版本号

private static final long serialVersionUID = 3801124242820219131L;    //双向链表的头指针

private transient Entry header;    //双向链表的排序方法，false 插入顺序排序，true访问顺序排序

private final boolean accessOrder;    //构造方法，指定初始大小，指定负载因子

public LinkedHashMap(int initialCapacity, float loadFactor) {        super(initialCapacity, loadFactor);

accessOrder = false;

}    //构造方法，指定初始容量

public LinkedHashMap(int initialCapacity) {        super(initialCapacity);

accessOrder = false;

}    //无参构造方法k，采用默认参数

public LinkedHashMap() {        super();

accessOrder = false;

}    //将指定的m集合转化为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;

}    //重写父类init方法，init方法在父类构造函数被调用，初始化双向链表

//header的前驱和后继都是指向它自己

@Override

void init() {

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

header.before = header.after = header;

}    //重写父类的transfer方法，在HashMap执行扩容操作时被调用，HashMap中的是通过遍历Entry[]数组的方式来实现数据的拷贝复制，重写后是通过遍历双向链表的方式来进行数据的复制。遍历双向链表的方式效率上更高一些

@Override

void transfer(HashMap.Entry[] newTable, boolean rehash) {        int newCapacity = newTable.length;        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);

e.next = newTable[index];

newTable[index] = e;

}

}    //重写父类的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;

}    //重写父类的get方法

public V get(Object key) {

Entry e = (Entry)getEntry(key); //返回实体

if (e == null)            return null;

e.recordAccess(this); //如果是访问顺序排序，则将e移动到链表的末尾处

return e.value;

}    //清除集合

public void clear() {        super.clear();

header.before = header.after = header;

}    //内部类实现了迭代方法

private abstract class LinkedHashIterator implements Iterator {

Entry nextEntry    = header.after;

Entry 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 nextEntry() {            if (modCount != expectedModCount)                throw new ConcurrentModificationException();            if (nextEntry == header)                throw new NoSuchElementException();

Entry e = lastReturned = nextEntry;

nextEntry = e.after;            return e;

}

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

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

}    private class EntryIterator extends LinkedHashIterator> {        public Map.Entry next() { return nextEntry(); }

}    // These Overrides alter the behavior of superclass view iterator() methods

Iterator newKeyIterator()   { return new KeyIterator();   }    Iterator newValueIterator() { return new ValueIterator(); }

Iterator> newEntryIterator() { return new EntryIterator(); }    //重写父类的addEntry方法

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

Entry eldest = header.after;        if (removeEldestEntry(eldest)) {

removeEntryForKey(eldest.key);

}

}    //重写createEntry方法

//执行两步操作：

// 1. 添加到table数组中， 2 . 插入到双向链表中

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

}    protected boolean removeEldestEntry(Map.Entry eldest) {        return false;

}

}

下面详细的分析一下LinkedHashMap中操作的实现：HashMap h = new LinkedHashMap();

h.put("张三", 18);

上面是简短的两句代码，来看一下到底包含了何种的操作。

图解LinkedHashMap的put操作.png

上面的图片已经描述的很清楚了，在此不再添加文字的表述。

关于删除方法，感兴趣的可以自行研究。

总结

LinkedHashMap继承了HashMap类，重写了部分方法，在HashMap中一些空的实现，LinkedHashMap都做了实现，扩展了HashMap类的功能，LinkedHashMap可以保存元素的插入顺序，顺序有两种方式一种是按照插入顺序排序，一种按照访问做排序。默认以插入顺序排序，性能比HashMap略低，线程也是不安全的。

至此，Java集合的源码系列就分析完了，像HashTable,stack等集合从开发者的角度上已经不建议在使用，因为已经是比较古老的类，有了更好类做了替代。

作者：起个名忒难

链接：https://www.jianshu.com/p/daf16e703049