1.前言
LinkedHashMap继承于HashMap,如果对HashMap原理还不清楚的同学,请先看上一篇:HashMap源码分析
2.LinkedHashMap使用与实现
先来一张LinkedHashMap的结构图:
2.1 应用场景
当希望顺序存取key-value时,需要使用LinkedHashMap。
Map<String, String> hashMap = new HashMap<String, String>();
hashMap.put("name1", "josan1");
hashMap.put("name2", "josan2");
hashMap.put("name3", "josan3");
Set<Entry<String, String>> set = hashMap.entrySet();
Iterator<Entry<String, String>> iterator = set.iterator();
while(iterator.hasNext()) {
Entry entry = iterator.next();
String key = (String) entry.getKey();
String value = (String) entry.getValue();
System.out.println("key:" + key + ",value:" + value);
}
我们是按照xxx1、xxx2、xxx3的顺序插入的,但是遍历的结果并不是按照插入的顺序输出的。同样的数据,我们再试试LinkedHashMap:
Map<String, String> linkedHashMap = new LinkedHashMap<>();
linkedHashMap.put("name1", "josan1");
linkedHashMap.put("name2", "josan2");
linkedHashMap.put("name3", "josan3");
Set<Entry<String, String>> set = linkedHashMap.entrySet();
Iterator<Entry<String, String>> iterator = set.iterator();
while(iterator.hasNext()) {
Entry entry = iterator.next();
String key = (String) entry.getKey();
String value = (String) entry.getValue();
System.out.println("key:" + key + ",value:" + value);
}
根据输出结果可知,LinkedHashMap默认是按照插入顺序遍历的。
2.2 定义和构造方法
public class LinkedHashMap<K,V>
extends HashMap<K,V>
implements Map<K,V>
{
LinkedHashMap提供了多个构造方法,我们先看空参的构造方法。
public LinkedHashMap() {
// 调用HashMap的构造方法,其实就是初始化Entry[] table
super();
// 这里是指是否基于访问排序,默认为false
accessOrder = false;
}
super调用了父类HashMap的构造方法,然后把accessOrder属性设置为false。LinkedHashMap存储数据是有序的,而且分为两种:插入顺序和访问顺序。
这里accessOrder设置为false,表示LinkedHashMap中存储的顺序是按照调用put方法插入的顺序进行排序的。LinkedHashMap也提供了可以设置accessOrder的构造方法,我们来看看这种模式下,LinkedHashMap遍历顺序有什么特点?
Map<String, String> linkedHashMap = new LinkedHashMap<>(16, 0.75f, true);//true表示accessOrder设置为true
linkedHashMap.put("name1", "josan1");
linkedHashMap.put("name2", "josan2");
linkedHashMap.put("name3", "josan3");
System.out.println("开始时顺序:");
Set<Entry<String, String>> set = linkedHashMap.entrySet();
Iterator<Entry<String, String>> iterator = set.iterator();
while(iterator.hasNext()) {
Entry entry = iterator.next();
String key = (String) entry.getKey();
String value = (String) entry.getValue();
System.out.println("key:" + key + ",value:" + value);
}
System.out.println("通过get方法,导致key为name1对应的Entry到表尾");
linkedHashMap.get("name1");
Set<Entry<String, String>> set2 = linkedHashMap.entrySet();
Iterator<Entry<String, String>> iterator2 = set2.iterator();
while(iterator2.hasNext()) {
Entry entry = iterator2.next();
String key = (String) entry.getKey();
String value = (String) entry.getValue();
System.out.println("key:" + key + ",value:" + value);
}
HashMap的构造函数中调用了init方法,而在HashMap中init方法是空实现。但LinkedHashMap重写了该方法,所以在LinkedHashMap的构造方法里,调用了自身的init方法,init的重写实现如下:
/**
* Called by superclass constructors and pseudoconstructors (clone,
* readObject) before any entries are inserted into the map. Initializes
* the chain.
*/
@Override
void init() {
// 创建了一个hash=-1,key、value、next都为null的Entry
header = new Entry<>(-1, null, null, null);
// 创建了一个只有头部节点的双向链表
header.before = header.after = header;
}
LinkedHashMap实现了独有的静态内部类Entry,它继承了HashMap.Entry,定义如下:
/**
* LinkedHashMap entry.
*/
private static class Entry<K,V> extends HashMap.Entry<K,V> {
// These fields comprise the doubly linked list used for iteration.
Entry<K,V> before, after;
Entry(int hash, K key, V value, HashMap.Entry<K,V> next) {
super(hash, key, value, next);
}
所以LinkedHashMap构造函数主要功能是:调用HashMap构造函数初始化了一个Entry[] table,然后调用自身的init方法初始化了一个只有头结点的双向链表。
2.3 put方法
LinkedHashMap还是使用父类HashMap的put方法:
public V put(K key, V value) {
// 对key为null的处理
if (key == null)
return putForNullKey(value);
// 计算hash
int hash = hash(key);
// 得到在table中的index
int i = indexFor(hash, table.length);
// 遍历table[index],是否key已经存在,存在则替换,并返回旧值
for (Entry<K,V> e = table[i]; e != null; e = e.next) {
Object k;
if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
V oldValue = e.value;
e.value = value;
e.recordAccess(this);
return oldValue;
}
}
modCount++;
// 如果key之前在table中不存在,则调用addEntry,LinkedHashMap重写了该方法
addEntry(hash, key, value, i);
return null;
}
这里看看LinkedHashMap的addEntry方法:
void addEntry(int hash, K key, V value, int bucketIndex) {
// 调用父类的addEntry,增加一个Entry到HashMap中
super.addEntry(hash, key, value, bucketIndex);
// removeEldestEntry方法默认返回false,不用考虑
Entry<K,V> eldest = header.after;
if (removeEldestEntry(eldest)) {
removeEntryForKey(eldest.key);
}
}
这里调用了父类HashMap的addEntry方法:
void addEntry(int hash, K key, V value, int bucketIndex) {
// 扩容相关
if ((size >= threshold) && (null != table[bucketIndex])) {
resize(2 * table.length);
hash = (null != key) ? hash(key) : 0;
bucketIndex = indexFor(hash, table.length);
}
// LinkedHashMap进行了重写
createEntry(hash, key, value, bucketIndex);
}
这里主要看createEntry方法,LinkedHashMap进行了重写:
void createEntry(int hash, K key, V value, int bucketIndex) {
HashMap.Entry<K,V> old = table[bucketIndex];
// e就是新创建了Entry,会加入到table[bucketIndex]的表头
Entry<K,V> e = new Entry<>(hash, key, value, old);
table[bucketIndex] = e;
// 把新创建的Entry,加入到双向链表中
e.addBefore(header);
size++;
}
我们来看看LinkedHashMap.Entry的addBefore方法:
private void addBefore(Entry<K,V> existingEntry) {
after = existingEntry;
before = existingEntry.before;
before.after = this;
after.before = this;
}
从这里就可以看出,当put元素时,不但要把它加入到HashMap中去,还要加入到双向链表中,所以可以看出LinkedHashMap就是HashMap+双向链表,下面用图来表示逐步往LinkedHashMap中添加数据的过程,红色部分是双向链表,黑色部分是HashMap结构,header是一个Entry类型的双向链表表头,本身不存储数据。
首先只加入一个元素Entry1,假设index为0:
当再加入一个元素Entry2,假设index为15:
当再加入一个元素Entry3, 假设index也是0:
以上就是LinkedHashMap的put的所有过程了,总体来看,跟HashMap的put类似,只不过多了把新增的Entry加入到双向列表末尾位置。
2.4 扩容
在HashMap的put方法中,如果发现前元素个数超过了扩容阀值时,会调用resize方法如下:
void resize(int newCapacity) {
Entry[] oldTable = table;
int oldCapacity = oldTable.length;
if (oldCapacity == MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return;
}
Entry[] newTable = new Entry[newCapacity];
boolean oldAltHashing = useAltHashing;
useAltHashing |= sun.misc.VM.isBooted() &&
(newCapacity >= Holder.ALTERNATIVE_HASHING_THRESHOLD);
boolean rehash = oldAltHashing ^ useAltHashing;
// 把旧table的数据迁移到新table
transfer(newTable, rehash);
table = newTable;
threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);
}
LinkedHashMap重写了transfer方法,实现如下:
void transfer(HashMap.Entry[] newTable, boolean rehash) {
// 扩容后的容量是之前的2倍
int newCapacity = newTable.length;
// 遍历双向链表,把所有双向链表中的Entry,重新就算hash,并加入到新的table中
for (Entry<K,V> 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;
}
}
LinkedHashMap扩容时,数据的再散列和HashMap是不一样的。
HashMap先遍历旧table,再遍历旧table中每个元素的单向链表,取得Entry以后重新计算hash值,然后存放到新table的对应位置。
LinkedHashMap遍历双向链表,取得每一个Entry,然后重新计算hash值,然后存放到新table的对应位置。
从遍历的效率来说,遍历双向链表的效率要高于遍历table,因为遍历双向链表是N次(N为元素个数);而遍历table是N+table的空余个数(N为元素个数)。
2.5 双向链表的重排序
前面分析的主要是当前LinkedHashMap中不存在当前key时,新增Entry的情况。当key如果已经存在时,则更新Entry的value。代码如下:
for (Entry<K,V> e = table[i]; e != null; e = e.next) {
Object k;
if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
V oldValue = e.value;
e.value = value;
// 重排序
e.recordAccess(this);
return oldValue;
}
}
主要看e.recordAccess(this)这个方法。这个方法跟访问顺序有关; HashMap是无序的,所以在HashMap.Entry的recordAccess方法是空实现,但是LinkedHashMap是有序的,LinkedHashMap.Entry对recordAccess方法进行了重写。
void recordAccess(HashMap<K,V> m) {
LinkedHashMap<K,V> lm = (LinkedHashMap<K,V>)m;
// 如果LinkedHashMap的accessOrder为true,则进行重排序
// 比如前面提到LruCache中使用到的LinkedHashMap的accessOrder属性就为true
if (lm.accessOrder) {
lm.modCount++;
// 把更新的Entry从双向链表中移除
remove();
// 再把更新的Entry加入到双向链表的表尾
addBefore(lm.header);
}
}
在LinkedHashMap中,accessOrder为true(访问顺序模式)才会put时对更新的Entry进行重新排序。如果是插入顺序模式时,不会重新排序,这里的排序只是指在双向链表中的顺序(在HashMap中table数组存储没有关系),双向链表从header Entry顺着after方向遍历时,Entry从最旧到最新排列。
举个例子:开始时,HashMap中有Entry1、Entry2、Entry3,并设置LinkedHashMap为访问顺序。更新Entry1时,会先把Entry1从双向链表中删除,然后再把Entry1加入到双向链表的表尾,而Entry1在HashMap结构中的存储位置没有变化,对比图如下所示:
2.6 get方法
LinkedHashMap对get方法进行了如下重写:
public V get(Object key) {
// 调用genEntry得到Entry
Entry<K,V> e = (Entry<K,V>)getEntry(key);
if (e == null)
return null;
// 如果LinkedHashMap是访问顺序的,则get时,也需要重新排序
e.recordAccess(this);
return e.value;
}
先调用了getEntry方法,通过key得到Entry,而LinkedHashMap并没有重写getEntry方法,所以调用的是HashMap的getEntry方法,在上一篇文章中我们分析过HashMap的getEntry方法:首先通过key算出hash值,然后根据hash值算出在table中存储的index,然后遍历table[index]的单向链表去对比key,如果找到了就返回Entry。
后面调用了LinkedHashMap.Entry的recordAccess方法,其实就是把get的Entry移动到双向链表的表尾。
2.7 遍历方式获取数据
先来看看HashMap使用遍历方式取数据的过程:
这样取出来的Entry顺序肯定跟插入顺序不同了,既然LinkedHashMap是有序的,那么它是怎么实现的呢?
先看看LinkedHashMap取遍历方式获取数据的代码:
Map<String, String> linkedHashMap = new LinkedHashMap<>();
linkedHashMap.put("name1", "josan1");
linkedHashMap.put("name2", "josan2");
linkedHashMap.put("name3", "josan3");
Set<Entry<String, String>> set = linkedHashMap.entrySet();
Iterator<Entry<String, String>> iterator = set.iterator();
while(iterator.hasNext()) {
Entry entry = iterator.next();
String key = (String) entry.getKey();
String value = (String) entry.getValue();
System.out.println("key:" + key + ",value:" + value);
}
LinkedHashMap没有重写entrySet方法,我们先来看HashMap中的entrySet实现:
public Set<Map.Entry<K,V>> entrySet() {
return entrySet0();
}
private Set<Map.Entry<K,V>> entrySet0() {
Set<Map.Entry<K,V>> es = entrySet;
return es != null ? es : (entrySet = new EntrySet());
}
private final class EntrySet extends AbstractSet<Map.Entry<K,V>> {
public Iterator<Map.Entry<K,V>> iterator() {
return newEntryIterator();
}
}
LinkedHashMap重写了newEntryIterator方法:
Iterator<Map.Entry<K,V>> newEntryIterator() {
return new EntryIterator();
}
我们来看看LinkedHashMap的内部类EntryIterator的定义:
private class EntryIterator extends LinkedHashIterator<Map.Entry<K,V>> {
public Map.Entry<K,V> next() {
return nextEntry();
}
}
private abstract class LinkedHashIterator<T> implements Iterator<T> {
// 默认下一个返回的Entry为双向链表表头的下一个元素
Entry<K,V> nextEntry = header.after;
Entry<K,V> lastReturned = null;
public boolean hasNext() {
return nextEntry != header;
}
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;
}
}
nextEntry方法遍历的是双向链表(HashMap遍历的是table数组中的单向链表)。
从头结点Entry header的下一个节点开始,只要把当前返回的Entry的after作为下一个应该返回的节点即可。直到到达双向链表的尾部时,after为双向链表的表头节点Entry header,这时候hasNext就会返回false,表示没有下一个元素了。
易知遍历出来的结果为Entry1、Entry2...Entry6。
可得,LinkedHashMap是有序的,且是通过双向链表来保证顺序的。
2.8 remove方法
LinkedHashMap没有提供remove方法,所以调用还是父类HashMap的remove方法,实现如下:
public V remove(Object key) {
Entry<K,V> e = removeEntryForKey(key);
return (e == null ? null : e.value);
}
final Entry<K,V> removeEntryForKey(Object key) {
int hash = (key == null) ? 0 : hash(key);
int i = indexFor(hash, table.length);
Entry<K,V> prev = table[i];
Entry<K,V> e = prev;
while (e != null) {
Entry<K,V> next = e.next;
Object k;
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k)))) {
modCount++;
size--;
if (prev == e)
table[i] = next;
else
prev.next = next;
// LinkedHashMap.Entry重写了该方法
e.recordRemoval(this);
return e;
}
prev = e;
e = next;
}
return e;
}
在上一篇HashMap中就分析了remove过程,其实就是断开其他对象对自己的引用。比如被删除Entry是在单向链表的表头,则让它的next放到表头,这样它就没有被引用了;如果不是在表头,它是被别的Entry的next引用着,这时候就让上一个Entry的next指向它自己的next,这样,它也就没被引用了。
在HashMap.Entry中recordRemoval方法是空实现,但是LinkedHashMap.Entry对其进行了重写:
void recordRemoval(HashMap<K,V> m) {
remove();
}
private void remove() {
before.after = after;
after.before = before;
}
删除双向链表中的Entry,意味着要断开当前要被删除的Entry被其他对象通过after和before的方式引用。
所以,LinkedHashMap的remove操作分成2部分:
1.把它从table中删除,即断开table或者其他对象通过next对其引用。2. 把它从双向链表中删除,断开其他对应通过after和before对其引用。
3 HashMap与LinkedHashMap的结构对比
再来看看HashMap和LinkedHashMap的结构图,是不是秒懂了。LinkedHashMap其实就是可以看成HashMap的基础上,多了一个双向链表来维持顺序。
4 总结
- LinkedHashMap是继承于HashMap,是基于HashMap和双向链表来实现的。
- HashMap无序;LinkedHashMap有序,可分为插入顺序和访问顺序两种。如果是访问顺序,那put和get操作已存在的Entry时,都会把Entry移动到双向链表的表尾(其实是先删除再插入)。
- LinkedHashMap存取数据,还是跟HashMap一样使用的Entry[]的方式,双向链表只是为了保证顺序。
- LinkedHashMap是线程不安全的。