LinkedHashMap源码
1. 特征
- 底层是散列表和双向链表
- 允许为null,不同步
- 插入顺序是有序的 (底层链表致使有序)
- 负载因子和初始容量对LinkedHashMap影响很大
问题:
- access-ordered和insertion-ordered具体的使用和意思
- 为什么说初始容量对遍历没有影响?
2. 属性
/**
* 在原有的HashMap中的Node中,加入了before和after属性
*/
static class Entry<K,V> extends HashMap.Node<K,V> {
Entry<K,V> before, after;
Entry(int hash, K key, V value, Node<K,V> next) {
super(hash, key, value, next);
}
}
//节点链表的头
transient Entry<K,V> head;
//节点链表的尾
transient Entry<K,V> tail;
//true:访问顺序
//false:插入顺序
final boolean accessOrder;
3. 方法
3.1 基本方法
/**
* 初始化散列表和双向链表
*/
void reinitialize() {
super.reinitialize();
head = tail = null;
}
Node<K,V> newNode(int hash, K key, V value, Node<K,V> e) {
Entry<K,V> p = new Entry<K,V>(hash, key, value, e);
//创建了节点Entry,将entry插入到双向链表的末尾,然后返回entry
linkNodeLast(p);
return p;
}
从这两个方法可以看出,LinkedHashMap底层确实是由散列表和双向链表构成的。
3.2 构造方法
public LinkedHashMap() {
super();
accessOrder = false;
}
public LinkedHashMap(int initialCapacity) {
super(initialCapacity);
accessOrder = false;
}
public LinkedHashMap(int initialCapacity, float loadFactor) {
super(initialCapacity, loadFactor);
accessOrder = false;
}
public LinkedHashMap(int initialCapacity,
float loadFactor,
boolean accessOrder) {
super(initialCapacity, loadFactor);
this.accessOrder = accessOrder;
}
public LinkedHashMap(Map<? extends K, ? extends V> m) {
super();
accessOrder = false;
putMapEntries(m, false);
}
从构造方法可以看出,LinkedHashMap默认使用插入顺序
3.3 put方法
LinkedHashMap中没有重写put方法,所以put方法和HashMap中的put方法一样,只有其中创建节点时的newNode方法使用了LinkedHashMap中重写的方法。
Node<K,V> newNode(int hash, K key, V value, Node<K,V> e) {
Entry<K,V> p = new Entry<K,V>(hash, key, value, e);
//创建了节点Entry,将entry插入到双向链表的末尾,然后返回entry
linkNodeLast(p);
return p;
}
3.4 get方法
public V get(Object key) {
Node<K,V> e;
//getNode和hash方法都是父类中的方法
if ((e = getNode(hash(key), key)) == null)
return null;
if (accessOrder)
afterNodeAccess(e);
return e.value;
}
//将当前访问节点放到链表尾部
void afterNodeAccess(Node<K,V> e) { // move node to last
Entry<K,V> last;
//此时链表顺序为访问顺序,当链表末尾不是当前节点
if (accessOrder && (last = tail) != e) {
//p:当前访问节点e
//b:e的前一个节点
//a:e的后一个节点
Entry<K,V> p =
(Entry<K,V>)e, b = p.before, a = p.after;
p.after = null;
//若前一个节点为空,则当前节点为链表中的头结点
if (b == null)
head = a;
//否则,此时访问节点为中间节点,将后一个节点连接到前一个节点之后
else
b.after = a;
//若后一个节点不为空,则当前访问节点为链表中间节点,将后面节点和前面节点相连
if (a != null)
a.before = b;
//否则,此时访问节点为链表尾结点
else
last = b;
//若尾节点为空,则当前访问节点为链表头结点
if (last == null)
head = p;
//否则将当前访问节点放在链表尾部
else {
p.before = last;
last.after = p;
}
tail = p;
++modCount;
}
}
3.5 remove方法
LinkedHashMap中没有重写HashMap的remove方法,只重写了afterNodeRemoval()方法,进行了删除后处理
//重写的afterRemove方法
void afterNodeRemoval(Node<K,V> e) { // unlink
//p:当前删除节点e
//b:e的前一个节点
//a:e的后一个节点
Entry<K,V> p =
(Entry<K,V>)e, b = p.before, a = p.after;
//将当前节点的前后引用清空,以便GC回收节点
p.before = p.after = null;
//当前一个节点为空时,则当前删除节点为链表头部,将后一个节点放到链表头部
if (b == null)
head = a;
//否则当前节点为中间节点,将后一个节点与前一个节点相连
else
b.after = a;
//当后一个节点为空时,则当前删除节点为链表尾,则把前一个元素设置为链表尾
if (a == null)
tail = b;
//否则当前删除节点为中间节点,把前一个节点和后一个节点相连
else
a.before = b;
}
3.6 遍历方法
//重写的entrySet方法,使用了LinkedEntrySet
public Set<Map.Entry<K,V>> entrySet() {
Set<Map.Entry<K,V>> es;
return (es = entrySet) == null ? (entrySet = new LinkedEntrySet()) : es;
}
abstract class LinkedHashIterator {
Entry<K,V> next;
Entry<K,V> current;
int expectedModCount;
LinkedHashIterator() {
next = head;
expectedModCount = modCount;
current = null;
}
public final boolean hasNext() {
return next != null;
}
//按照双向链表的顺序进行遍历
final Entry<K,V> nextNode() {
Entry<K,V> e = next;
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
if (e == null)
throw new NoSuchElementException();
current = e;
next = e.after;
return e;
}
public final void remove() {
Node<K,V> p = current;
if (p == null)
throw new IllegalStateException();
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
current = null;
K key = p.key;
removeNode(hash(key), key, null, false, false);
expectedModCount = modCount;
}
}
final class LinkedEntrySet extends AbstractSet<Map.Entry<K,V>> {
public final int size() { return size; }
public final void clear() { this.clear(); }
public final Iterator<Map.Entry<K,V>> iterator() {
return new LinkedEntryIterator();
}
public final boolean contains(Object o) {
if (!(o instanceof Map.Entry))
return false;
Map.Entry<?,?> e = (Map.Entry<?,?>) o;
Object key = e.getKey();
Node<K,V> candidate = getNode(hash(key), key);
return candidate != null && candidate.equals(e);
}
public final boolean remove(Object o) {
if (o instanceof Map.Entry) {
Map.Entry<?,?> e = (Map.Entry<?,?>) o;
Object key = e.getKey();
Object value = e.getValue();
return removeNode(hash(key), key, value, true, true) != null;
}
return false;
}
public final Spliterator<Map.Entry<K,V>> spliterator() {
return Spliterators.spliterator(this, Spliterator.SIZED |
Spliterator.ORDERED |
Spliterator.DISTINCT);
}
public final void forEach(Consumer<? super Map.Entry<K,V>> action) {
if (action == null)
throw new NullPointerException();
int mc = modCount;
for (Entry<K,V> e = head; e != null; e = e.after)
action.accept(e);
if (modCount != mc)
throw new ConcurrentModificationException();
}
}
从迭代器可以看出,LinkedHashMap中迭代时按照底层维护的双向链表的顺序进行迭代,而不是按照散列表顺序 (但是链表中元素都来源于散列表)。因此,初始化容量对遍历没有影响,
4. 总结
LinkedHashMap比HashMap多了一个双向链表的维护,在数据结构而言它要复杂一些,阅读源码起来比较轻松一些,因为大多都由HashMap实现了…
阅读源码的时候我们会发现多态是无处不在的~子类用父类的方法,子类重写了父类的部分方法即可达到不一样的效果!
比如:
- LinkedHashMap并没有重写put方法,而put方法内部的
newNode()
方法重写了。 - LinkedHashMap调用父类的put方法,里面回调的是重写后的
newNode()
,从而达到目的!
LinkedHashMap可以设置两种遍历顺序:
- 访问顺序(access-ordered)
- 插入顺序(insertion-ordered)
- 默认是插入顺序的
对于访问顺序,它是LRU(最近最少使用)算法的实现,要使用它要么重写LinkedListMap的几个方法(removeEldestEntry(Map.Entry<K,V> eldest)
和afterNodeInsertion(boolean evict)
),要么是扩展成LRUMap来使用,不然设置为访问顺序(access-ordered)的用处不大~
LinkedHashMap遍历的是内部维护的双向链表,所以说初始容量对LinkedHashMap遍历是不受影响的