概述
文章的内容基于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