您的位置：首页 > 编程语言 > Java开发

Java 集合：LinkedHashMap工作原理及实现

2017-09-13 00:00 211 查看

LinkedHashMap 概述

由于 HashMap 中的 entry 是无序的，也就是说，当

map.entrySet()

得到的 entry的集合既不能按照插入顺序排列，也不能按照访问先后顺序排序。

那么 LinkedHashMap 就可以解决这个问题。LinkedHashMap 可以让元素：

按照插入顺序排列

也可以按照访问的先后顺序排序

这里需要注意，不能按照 key 的大小排序，那是 TreeMap 的功能，不要弄混淆了。

如下 Demo：

public class Test {
public static void main(String args[]){
Map<String,String> map = new LinkedHashMap<>(16,0.75f,true);

map.put("A","a");
map.put("B","b");
map.put("C","c");
map.put("D","d");
map.put("E","e");

for(Map.Entry<String,String> entry : map.entrySet()) {
System.out.println(entry);
}

map.get("D");
map.get("B");
System.out.println("==========");

for(Map.Entry<String,String> entry : map.entrySet()) {
System.out.println(entry);
}
}
}

那么输出：

A=a
B=b
C=c
D=d
E=e
==========
A=a
C=c
E=e
D=d
B=b

这里可以看到，在

map.get("D");

和

map.get("B");

之后，打印的最后就变了，这个是按照访问来排序。

原理

LinkedHashMap 继承于 HashMap，很多方法都是直接用了 HashMap 的方法，那么本身再在 HashMap 的基础上提供一个排序的功能。

它的成员变量有：

transient LinkedHashMap.Entry<K,V> head;
transient LinkedHashMap.Entry<K,V> tail;
final boolean accessOrder;

这个时候其实可以猜到，其实是用了一个链表来维护顺序。这个 accssOrder 表示是否需要按照访问顺序来排序，如果不需要，那么默认就是按照插入顺序来排序。如上代码的构造方法

LinkedHashMap<>(16,0.75f,true);

的 true 就表示了需要按照访问顺序。

put(K key, V value)

在进行

put(K key, V value)

操作的时候， LinkedHashMap 实际上是调用了 HashMap 的

put(K key, V value)

方法，然后在 HashMap 中的

put(K key, V value)

方法后，有一句：

afterNodeAccess(e);

这个方法就是留给 LinkedHashMap 来实现。除此之外，还有

// Callbacks to allow LinkedHashMap post-actions
void afterNodeAccess(Node<K,V> p) { }
void afterNodeInsertion(boolean evict) { }
void afterNodeRemoval(Node<K,V> p) { }

并且注释已经写明了是给 LinkedHashMap 来用的。

到这里，我们就可以知道原理：LinkedHashMap 进行
put(K key, V value)
操作的时候，调用了 HashMap 的
put(K key, V value)
，然后 HashMap 再调用回 LinkedHashMap 特定的方法，来实现排序，
get()
,
remove()
方法同理。而 LinkedHashMap 实现排序的方式就是通过链表。

参考：Java LinkedHashMap工作原理及实现，用的其实是一个双向链表。

再具体一下

afterNodeAccess(e);

，以下这个是 HashMap 的 put 方法：

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
......
else {
Node<K,V> e; K k;
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
else if (p instanceof TreeNode)
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
else {
for (int binCount = 0; ; ++binCount) {
if ((e = p.next) == null) {
p.next = newNode(hash, key, value, null);
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
break;
}
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);return oldValue;
}
}
......
}

可以看到，在 else 的 for 循环中，put 了这个 key-value 之后，会在下面

if (e != null)

调用

afterNodeAccess(e);

：

这里要注意一点，这里的节点类型是：

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

可以看到，保存了 before, after; 其实这个就是用来引用前后节点的，这样可以用来做双端队列。

void afterNodeAccess(Node<K,V> e) { // move node to last
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;
}
}

这个代码就可以具体看到，首先，判断你是不是要按照访问顺序来使用，如果不是的话，那这里什么也不做。（具体可以用纸笔画画）。

（完）。

内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理

标签： Java Map

相关文章推荐

新的分享

章节导航