文章目录
- LinkedHashMap
- 一、主要数据结构和属性
- 二、继承自HashMap的钩子方法
- 2.1 afterNodeAccess
- 2.2 afterNodeInsertion
- 2.3 afterNodeRemoval
- 三、主要方法
- 3.1 构造方法
- 3.2 get获取操作
- 3.3 removeEldestEntry核心方法
- 四、内部方法
- 4.1 linkNodeLast
- 4.2 transferLinks
- 4.3 重写的方法
- 五、其他
- 5.1 containsValue
- 5.2 clear
- 5.3 辅助内部类
- 六、使用示例
- 6.1 按照access顺序
- 6.2 按照insert顺序
- 七、小结
LinkedHashMap
- LinkedHashMap继承HashMap并且实现Map接口，它是Map接口的hash表和双向链表的双重实现，也就是说一方面具备HashMap的特点，另一方面内部还使用双向链表保存了全部元素，链表支持按照插入顺序和访问顺序这两种排序方式，因此在某些时候可以借助LinkedHashMap来实现特定的需求，典型的就是按照访问顺序排序来实现LRU。
一、主要数据结构和属性
1.1 Entry
- Entry继承了HashMap.Node，HashMap.Node保存看键值对和k-v对、hash值和next指针，在继承它的基础上Entry添加了前后指针，由此具备了双向链表的数据结构基础。
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);
}
}
1.2 主要属性
- LinkedHashMap内部通过双向链表维护节点之间的顺序，通过在Node中加入了前后指针这两个字段来实现的，在主要成员属性里面保存了整个双向链表的头尾指针，以及排序方式。
transient LinkedHashMap.Entry<K,V> head;
transient LinkedHashMap.Entry<K,V> tail;
final boolean accessOrder;
二、继承自HashMap的钩子方法
void afterNodeAccess(Node<K,V> p) { }
void afterNodeInsertion(boolean evict) { }
void afterNodeRemoval(Node<K,V> p) { }
- 这几个方法是定义在HashMap中，但在HashMap中默认是空实现，LinkedHashMap实现了这几个方法，看名字基本就知道什么含义，而LinkedHashMap的排序也正是基于这几个方法来实现的，他们分别会在节点新增、删除和访问之后调用，我们先看看这几个方法；
2.1 afterNodeAccess
- afterNodeAccess会在节点被访问后调用，如果是按照访问顺序迭代双向链表，就需要执行下面的逻辑。下面的逻辑不难，但是看起来有点绕，只需要吧4种情况弄清楚就好了，就是b-p-a，null-p-a，b-p-null，null-p-null，其中p代表需要处理的节点，b代表前驱，a代表后继。
void afterNodeAccess(Node<K,V> e) {
LinkedHashMap.Entry<K,V> last;
if (accessOrder && (last = tail) != e) {
LinkedHashMap.Entry<K,V> p = (LinkedHashMap.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;
}
}
2.2 afterNodeInsertion
- afterNodeInsertion会在节点被插入后执行，里面会根据参数和removeEldestEntry方法的返回值来决定是否需要删除first节点，也就是最老的节点。
- 需要注意的是移除的逻辑是在HashMap的removeNode方法中已经实现好了的，在removeNode中会依赖部分子方法，子方法如果和LinkedHashMap有关，LinkedHashMap都重写了，具体在重写的方法里面介绍了，这里简单带一下。
void afterNodeInsertion(boolean evict) {
LinkedHashMap.Entry<K,V> first;
if (evict && (first = head) != null && removeEldestEntry(first)) {
K key = first.key;
removeNode(hash(key), key, null, false, true);
}
}
2.3 afterNodeRemoval
- afterNodeRemoval会在节点移除后调用，主要是将前驱和后继连起来，考虑到null的情况，把afterNodeAccess的逻辑看明白了，这个就容易多了;
void afterNodeRemoval(Node<K,V> e) {
LinkedHashMap.Entry<K,V> p = (LinkedHashMap.Entry<K,V>)e, b = p.before, a = p.after;
p.before = p.after = null;
if (b == null)
head = a;
else
b.after = a;
if (a == null)
tail = b;
else
a.before = b;
}
三、主要方法
3.1 构造方法
- LinkedHashMap有很多重载的构造方法，给出比较典型的；这里提一下accessOrder为true代表按照访问顺序排序，false代表按照插入顺序排序，默认是false
public LinkedHashMap(int initialCapacity, float loadFactor,boolean accessOrder) {
super(initialCapacity, loadFactor);
this.accessOrder = accessOrder;
}
3.2 get获取操作
- get操作是调用HashMap中实现好的getNode，不过需要注意的是如果访问结果不是null，并且是按照访问顺序迭代，那么就需要执行前面介绍过的afterNodeAccess方法，之所以会有get方法原因在于LinkedHashMap重写这个方法，便于在访问后通过accessOrder属性调用afterNodeAccess，来保证链表是通过访问顺序排序的，其他的比如put操作还是通过HashMap的方法实现，不过会调用前面提到的钩子方法。
public V get(Object key) {
Node<K,V> e;
if ((e = getNode(hash(key), key)) == null)
return null;
if (accessOrder)
afterNodeAccess(e);
return e.value;
}
3.3 removeEldestEntry核心方法
- removeEldestEntry是LinkedHashMap最为核心的方法之一，他是交给子类重写的，默认返回false，他是LinkedHash删除最老的值的依据，子类可以重写逻辑来控制返回值。返回true表示LinkedHashMap需要移除最老的key，反之则不用。
- put和putAll方法在插入新元素之后会调用afterNodeInsertion，在afterNodeInsertion里面判断是否需要删除最老的元素，需要的话就会调用afterNodeRemoval删除最老的元素，这里的依据就是removeEldestEntry的返回值，由此也知道删除最老的元素的动作是在新增元素的时候触发的。
- 删除动作不需要我们实现，我们只需要通过该接口的返回值告诉LinkedHashMap是否需要删除了，下一次添加元素的时候就会执行删除动作，这也是利用LinkedHashMap实现LRU的关键，在afterNodeInsertion方法的判断逻辑里面我们可以看到该方法的调用。
protected boolean removeEldestEntry(Map.Entry<K,V> eldest) {
return false;
}
四、内部方法
- 内部方法是private修饰的，外部不能访问，它们为其他方法提供内部调用。另外还有一些继承自HashMap的protected方法，需要LinkedHashMap子类自行重写逻辑的方法。
4.1 linkNodeLast
- linkNodeLast将一个节点添加到双向链表的尾部
private void linkNodeLast(LinkedHashMap.Entry<K,V> p) {
LinkedHashMap.Entry<K,V> last = tail;
tail = p;
if (last == null)
head = p;
else {
p.before = last;
last.after = p;
}
}
4.2 transferLinks
- transferLinks将一个节点替换为另一个节点
private void transferLinks(LinkedHashMap.Entry<K,V> src,LinkedHashMap.Entry<K,V> dst) {
LinkedHashMap.Entry<K,V> b = dst.before = src.before;
LinkedHashMap.Entry<K,V> a = dst.after = src.after;
if (b == null)
head = dst;
else
b.after = dst;
if (a == null)
tail = dst;
else
a.before = dst;
}
4.3 重写的方法
- 另外有几个方法，在HashMap中会调用的，比如替换节点之类的，这些方法原本在HashMap中就实现好了，但是LinkedHashMap因为数据结构的变化实现方式有一些改变，因此重写了该部分方法，比如newNode、replacementNode、newTreeNode、replacementTreeNode、这些方法功能比较明确，就不解析了。
五、其他
5.1 containsValue
- containsValue因为不能根据key查找，只能一个一个遍历，在HashMap中的实现是挨个遍历Hash桶，然后遍历每个桶里面的链表，LinkedHashMap则是遍历双向链表，复杂度都是O(N)
public boolean containsValue(Object value) {
for (LinkedHashMap.Entry<K,V> e = head; e != null; e = e.after) {
V v = e.value;
if (v == value || (value != null && value.equals(v)))
return true;
}
return false;
}
5.2 clear
public void clear() {
super.clear();
head = tail = null;
}
5.3 辅助内部类
- LinkedHashMap将原本的HashMap而外还使用链表连接在一起，但是HashMap是K-V结构，有时候我们会需要单独获取K的集合和V的集合，因此LinkedHashMap内部使用辅助的内部类LinkedKeySet来表示K的集合，其内部也使用双向链表连接，LinkedValues也是一样表示双向链表的Value集合，另外还有LinkedEntrySet表示，这里面不深入开展了，有兴趣可以自行研究。
final class LinkedKeySet extends AbstractSet<K> {
public final int size() { return size; }
public final void clear() { LinkedHashMap.this.clear(); }
public final Iterator<K> iterator() {
return new LinkedKeyIterator();
}
public final boolean contains(Object o) { return containsKey(o); }
public final boolean remove(Object key) {
return removeNode(hash(key), key, null, false, true) != null;
}
public final Spliterator<K> spliterator() {
return Spliterators.spliterator(this, Spliterator.SIZED |
Spliterator.ORDERED |
Spliterator.DISTINCT);
}
public final void forEach(Consumer<? super K> action) {
if (action == null)
throw new NullPointerException();
int mc = modCount;
for (LinkedHashMap.Entry<K,V> e = head; e != null; e = e.after)
action.accept(e.key);
if (modCount != mc)
throw new ConcurrentModificationException();
}
}
六、使用示例
6.1 按照access顺序
- 我们先看下面的例子,我们设置accessOrder为true按照访问顺序排序，起初保存了key1、key2、key3。然后遍历，双向链表的顺序是key1-key2-key3，因为key3是最后访问的，因此在链表的最尾部，这个在前面的源码分析过。
- 然后我们访问一次key2，因此key2就会挪到链表尾部，由此遍历顺序就是key1-key3-key2，如此我们看到了按照访问顺序排序的效果。
public class LinkedHashMapTest {
public static void main(String[] args) {
LinkedHashMap<String,Integer> linkedHashMap = new LinkedHashMap(10, 0.75F, true);
linkedHashMap.put("key1",1);
linkedHashMap.put("key2",2);
linkedHashMap.put("key3",3);
Set<String> strings = linkedHashMap.keySet();
for (String k: strings) {
System.out.print(k + " ");
}
linkedHashMap.get("key2");
System.out.print("\n----------------\n");
for (String k: strings) {
System.out.print(k + " ");
}
}
}
输出：
key1 key2 key3
----------------
key1 key3 key2
- 再看下面的，我设置阈值为3，当元素个数大于3的时候，removeEldestEntry方法返回true，此时就会返回最近最久未被访问的元素(LRU),第一次访问，顺序是key1 - key2 - key3，然后访问了一次key1，由此第二次访问顺序就变成了key2 - key3 - key1，然后加入key4，此时元素大于3个，最久未被访问的元素key2被删除，第三次访问链表顺序就是key3 - key1 - key4
public class LinkedHashMapTest {
private static final int SIZE_THRESHOLD = 3;
public static void main(String[] args) {
LinkedHashMap<String, Integer> linkedHashMap = new LinkedHashMap<String, Integer>(10, .75F, true) {
private static final long serialVersionUID = 4267176411845948333L;
@Override
protected boolean removeEldestEntry(Map.Entry<String, Integer> eldest) {
if (size() > SIZE_THRESHOLD) {
return true;
}
return false;
}
};
linkedHashMap.put("key1", 1);
linkedHashMap.put("key2", 2);
linkedHashMap.put("key3", 3);
Set<String> strings = linkedHashMap.keySet();
for (String k : strings) {
System.out.print(k + " ");
}
linkedHashMap.get("key1");
System.out.print("\n----------------\n");
for (String k : strings) {
System.out.print(k + " ");
}
System.out.print("\n----------------\n");
linkedHashMap.put("key4", 4);
for (String k : strings) {
System.out.print(k + " ");
}
}
}
输出：
key1 key2 key3
----------------
key2 key3 key1
----------------
key3 key1 key4
6.2 按照insert顺序
- 再看一个按照插入顺序访问，这个比较简单了，不传参数默认就是插入顺序。如下代码所示，不管访问与否，访问的顺序就是插入的顺序。
public class LinkedHashMapTest {
public static void main(String[] args) {
LinkedHashMap<String, Integer> linkedHashMap = new LinkedHashMap<String, Integer>();
linkedHashMap.put("key1", 1);
linkedHashMap.put("key2", 2);
linkedHashMap.put("key3", 3);
Set<String> strings = linkedHashMap.keySet();
for (String k : strings) {
System.out.print(k + " ");
}
linkedHashMap.get("key1");
System.out.print("\n----------------\n");
for (String k : strings) {
System.out.print(k + " ");
}
System.out.print("\n----------------\n");
linkedHashMap.put("key4", 4);
for (String k : strings) {
System.out.print(k + " ");
}
}
}
输出：
key1 key2 key3
----------------
key1 key2 key3
----------------
key1 key2 key3 key4
七、小结
- LinkedHashMap继承自HashMap，它的数据节点在HashMap节点的基础之上添加了前驱后继节点指针，除了维护原本Hash表的结构之外，还维护了一个双向链表的结构。
- 双向链表支持按照插入顺序排序(false 默认)和按照访问顺序排序(true)，通过accessOrder来控制。
- 在按照访问顺序排序的模式下，LinkedHashMap主要通过HashMap预留的一个removeEldestEntry方法来决定什么时候需要清除最老的元素，一种典型的场景是，当元素个数达到预先设置的阈值则删除最老元素，由此达到LRU的效果。当然删除的过程中需要对双向链表数据结构进行维护，这些也是通过HashMap在预先留下的钩子方法实现的，三个重要的钩子方法会在新增元素、删除元素、访问元素后被调用。
- 按照插入顺序是默认的，这种模式可以对HashMap表中的元素进行排序，这也是HashMap不具备的功能。
