LinkedHashMap继承了HashMap,HashMap具有的特性LinkedHashMap也有。
public class LinkedHashMap<K,V> extends HashMap<K,V> implements Map<K,V>
LinkedHashMap与HashMap不同的是,除了拥有与HashMap一样的存储结构之外,又额外维护了一个双向链表,默认按照插入顺序排列,也可以通过设置accessOrder字段实现LRU算法,此时按照访问顺序对节点排列。
1.LinkedHashMap的存储结构Entry
Entry继承了HashMap的Node,并且多出了两个字段before和after,这两个字段在构造双向链表时使用
/** * linkedHashMap的存储结构,继承了HashMap的Node */ static class Entry<K,V> extends HashMap.Node<K,V> { //比HashMap多出了两个成员变量before和after,构造双向链表使用,before指向当前节点在双向链表中的前一个节点,after指向后一个节点 Entry<K,V> before, after; Entry(int hash, K key, V value, Node<K,V> next) { //调用Node中的构造函数实例化对象 super(hash, key, value, next); } }
2.字段
(1)双向链表有一个头结点head和尾节点tail
(2)accessOrder为true的时候表示双向链表按照访问顺序排列,为false表示按照插入顺序排列。
private static final long serialVersionUID = 3801124242820219131L; /** * 双向链表的头结点 */ transient LinkedHashMap.Entry<K,V> head; /** * 双向链表的尾节点 */ transient LinkedHashMap.Entry<K,V> tail; /** * true表示双向链表按照访问的顺序来排列,false则表示按照插入顺序来排列 */ final boolean accessOrder;
3.构造函数
(1)由于LinkedHashMap继承了HashMap,因此默认容量和加载因子与HashMap一致。
(2)需要实现LRU算法时,需要使用 public LinkedHashMap(int initialCapacity,float loadFactor,boolean accessOrder)构造函数,将accessOrder设为true。
/** * 带有指定容量的构造函数 */ public LinkedHashMap(int initialCapacity) { super(initialCapacity); accessOrder = false; } /** * 无参构造函数,使用默认容量16和默认加载因子0.75 */ public LinkedHashMap() { super(); accessOrder = false; } /** * 构造函数 */ public LinkedHashMap(Map<? extends K, ? extends V> m) { super(); accessOrder = false; putMapEntries(m, false); } /** * 构造函数,带有初始容量、加载因子和accessOrder * accessOrder:true表示链表按照访问的顺序来排列,false则表示按照插入顺序来排列 */ public LinkedHashMap(int initialCapacity, float loadFactor, boolean accessOrder) { super(initialCapacity, loadFactor); this.accessOrder = accessOrder; }
LinkedHashMap中并没有重写添加方法,而是直接使用了HashMap中的添加方法,但是重写了创建新节点的newNode方法:
/** * 添加 * * @param hash key的hash值 * @param key key值 * @param value value值 * @param onlyIfAbsent 如果已经存在包含key值的对象,onlyIfAbsent为true时不更新该对象的value,否则将更新为新的value * @param evict if false, the table is in creation mode. * @return previous value, or null if none */ final V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict) { Node<K,V>[] tab; Node<K,V> p; int n, i; //如果哈希表(数组)为空 if ((tab = table) == null || (n = tab.length) == 0) //对哈希表扩容并返回哈希表的长度 n = (tab = resize()).length; //根据hash计算在数组中的索引,并获取该索引处的对象,如果为空,创建节点,放到该索引处 if ((p = tab[i = (n - 1) & hash]) == null) //创建新节点,放到索引为i的位置 tab[i] = newNode(hash, key, value, null); else { //如果索引处已经存在节点 Node<K,V> e; K k; //判断该节点的hash以及key值是否与要添加的对象的key相等 if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k)))) //将第一个节点赋值给e,稍后更新e的value为新的value(根据onlyIfAbsent判断) e = p; else if (p instanceof TreeNode) //如果是红黑树 e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value); else { //从链表中查找,如果查找为空就将新节点从尾部添加(尾插法),如果根据hash和key在链表中查到,中断循环 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; } //判断节点的hash以及key值是否与要添加的对象的key相等,中断查找 if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k)))) break; p = e; } } if (e != null) { //获取旧的value V oldValue = e.value; //如果onlyIfAbsent为false或者旧的value是空,更新为新的value if (!onlyIfAbsent || oldValue == null) e.value = value; afterNodeAccess(e); return oldValue; } } ++modCount; //如果长度超过了阈值 if (++size > threshold) //调整大小 resize(); afterNodeInsertion(evict); return null; }
newNode方法:
可以看到创建的是Entry节点,将节点添加到双向链表中并返回。
/** * 创建新的Node节点 * @param hash * @param key * @param value * @param e * @return */ Node<K,V> newNode(int hash, K key, V value, Node<K,V> e) { LinkedHashMap.Entry<K,V> p = new LinkedHashMap.Entry<K,V>(hash, key, value, e); //新节点链接尾插法插入链表 linkNodeLast(p); return p; } /** * 在双向链表中使用尾插法插入节点 * @param p */ 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; } }
在添加节点时如果节点已经存,在更新节点的value后会调用afterNodeAccess(e)方法,在HashMap中此方法什么也没有做,在LinkedHashMap中对方法进行了重写,将当前节点放入到双向链表的尾部:
/** * 该方法提供了LRU算法的实现,它将最近使用的节点放到双向循环链表的尾部 * @param e 要放到链表尾部的节点 */ void afterNodeAccess(Node<K,V> e) { // move node to last LinkedHashMap.Entry<K,V> last; //如果accessOrder为true并且当前节点不是尾节点 if (accessOrder && (last = tail) != e) { // e=p,代表要放到链表尾部的节点,b为它前一个节点,a为它指向的下一个节点 LinkedHashMap.Entry<K,V> p = (LinkedHashMap.Entry<K,V>)e, b = p.before, a = p.after; //将p的after设为null p.after = null; //如果p的一前个节点为空,说明p是头结点 if (b == null) //将头结点设为p的下一个节点a head = a; else //将p前一个节点的after指向a b.after = a; //如果p的后一个节点不为空 if (a != null) //将a的前一个节点指向p的前一个节点b a.before = b; else //如果p的后一个节点为空,将p的前一个节点先当做尾节点 last = b; //如果尾节点为空 if (last == null) //头结点 head = p; else { //将p的前一个节点指向尾节点 p.before = last; // 原来的尾节点的下一个节点指向p last.after = p; } //设置p为尾节点 tail = p; ++modCount; } }如果是创建新的节点,在方法的最后会调用afterNodeInsertion(evict)方法,HashMap中该方法同样什么也不做,LinkedHashMap重写了该方法,该方法是在实现LRU算法时删除最不经常使用的节点,双向链表中使用的是尾插法,因此多次操作后链表最前面的节点被认为是最近没有使用的:
/** * 删除最老的Entry * 因为添加节点采用的尾插法,多次操作后,双向链表前面的Entry便是最近没有使用的 * 如果实现LRU,需要重写removeEldestEntry方法,不然只会返回false不会删除节点 * @param evict */ void afterNodeInsertion(boolean evict) { // possibly remove eldest LinkedHashMap.Entry<K,V> first; if (evict && (first = head) != null && removeEldestEntry(first)) { K key = first.key; //删除头结点 removeNode(hash(key), key, null, false, true); } }在实现LRU算法时一般也需要重写removeEldestEntry方法,否则该方法用于返回的false,将不会删除节点:
/** * 是否移除最老的Entry * 如果实现LRU,需要重写removeEldestEntry方法 */ protected boolean removeEldestEntry(Map.Entry<K,V> eldest) { return false; }
(1)containsValue直接从双向链表中查找,而不用遍历整个哈希表,提高了效率。
(2)通过key查找的方法还是从哈希表中查找,因为根据key可以直接定位到在hash表的索引。
(3)调用get获取对象时,如果accessOrder为true同样会调用afterNodeAccess方法,实现LRU。
/** * 从双向链表中根据value查找对象 */ 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; } /** * 根据key获取对象,当查找为null时返回null */ public V get(Object key) { Node<K,V> e; //根据key的hash值查找对象,如果为空返回null if ((e = getNode(hash(key), key)) == null) return null; //如果链表中元素的排序规则是按照访问的先后顺序排序,将e链接到尾节点 if (accessOrder) afterNodeAccess(e); return e.value; } /** * 根据key获取对象,当查找为null时返回默认的值defaultValue */ public V getOrDefault(Object key, V defaultValue) { Node<K,V> e; if ((e = getNode(hash(key), key)) == null) return defaultValue; if (accessOrder) afterNodeAccess(e); return e.value; }
6.删除方法
LinkedHashMap使用HashMap中的删除方法,但是重写了afterNodeRemoval方法。
HashMap的删除方法:
/** * 根据key删除节点 * * @param hash hash for key * @param key the key * @param value the value to match if matchValue, else ignored * @param matchValue if true only remove if value is equal * @param movable if false do not move other nodes while removing * @return the node, or null if none */ final Node<K,V> removeNode(int hash, Object key, Object value, boolean matchValue, boolean movable) { Node<K,V>[] tab; Node<K,V> p; int n, index; if ((tab = table) != null && (n = tab.length) > 0 && (p = tab[index = (n - 1) & hash]) != null) { Node<K,V> node = null, e; K k; V v; //如果要删除的节点在头结点 if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k)))) node = p; else if ((e = p.next) != null) { if (p instanceof TreeNode) //如果是树结构 node = ((TreeNode<K,V>)p).getTreeNode(hash, key); else { //如果是链表,遍历链表找到要删除的节点 do { if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k)))) { node = e; break; } //记录要删除节点的前一个节点 p = e; } while ((e = e.next) != null); } } if (node != null && (!matchValue || (v = node.value) == value || (value != null && value.equals(v)))) { if (node instanceof TreeNode) //如果是红黑树,从树中删除节点 ((TreeNode<K,V>)node).removeTreeNode(this, tab, movable); else if (node == p) //如果要删除的是头结点,也就是在tab[index]位置的元素,将该节点的下一个节点放到table[index]处 tab[index] = node.next; else //如果要删除的节点在链表中,记录要删除节点的前一个节点,将该节点的next执行要删除节点的下一个节点 p.next = node.next; ++modCount; //更改大小 --size; afterNodeRemoval(node); return node; } } return null; }
linkedHashMap的afterNodeRemoval方法:
/** * 将节点从双向链表中移除 * @param e */ void afterNodeRemoval(Node<K,V> e) { // unlink 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; }
清空方法:
/** * 清空,直接将头结点和尾节点设为null */ public void clear() { super.clear(); head = tail = null; }
参考:
【Java集合源码剖析】LinkedHashmap源码剖析