Map集合框架(二)——LinkedHashMap(JDK1.8)

(一)Map子父层级：

map接口常用实现类分为：HashMap、LinkedHashMap、HashTable、TreeMap、Properties;

(二)Map实现类

1、LinkedHashMap实现类

（1）LinkedHashMap继承于HashMap,底层结构使用HashMap的数组+链表+红黑树，其数组Node变为Entry,
      Entry继承于HashMap的Node,自身Entry增加了两个before和after指针(Entry);
（2）LinkedHashMap由于继承HashMap,其默认容量、默认扩容阈值、默认负载因子、扩容机制、树化等操作均是继承HashMap;
（3）LinkedHashMap自身重写了HashMap中的部分方法，主要作用为维护双向链表的顺序如newNode、
    afterNodeAccess、afterNodeInsertion、afterNodeRemoval;
（4）LinkedHashMap是线程不安全的，在多线程环境下，会报并发修改异常java.util.ConcurrentModificationException。

2、常见源码

（1）构造方法

//无参构造，调用父类HashMap的无参构造方法,默认排序为插入顺序
 public LinkedHashMap() {
     super();//HashMap无参构造
     accessOrder = false;//双向链表的顺序，false默认为插入顺序  true为访问顺序
 }
 //设置指定容量大小的构造函数，同理调用父类HashMap的对应方法，默认插入顺序
 public LinkedHashMap(int initialCapacity) {
     super(initialCapacity);//HashMap设置初始容量构造方法
     accessOrder = false;
 }
 //同时设置初始容量、负载因子和排序方式，自定义实现容器控制，同理调用HashMap对应方法
 public LinkedHashMap(int initialCapacity,float loadFactor,boolean accessOrder) {
     super(initialCapacity, loadFactor);//调用父类HashMap初始容量和负载因子构造
     this.accessOrder = accessOrder;//自定义排序
 }
 //基于已存在的Map进行构造新的Map
 public LinkedHashMap(Map<? extends K, ? extends V> m) {
     super();//父类无参
     accessOrder = false;//默认插入排序
     putMapEntries(m, false);//构造初始链表顺序
 }

（2）put方法

 //LinkedHashMap同样继承的HashMap的put方法，唯一不同之处为putVal方法中①②③处
 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;
 	if ((p = tab[i = (n - 1) & hash]) == null)
 		tab[i] = newNode(hash, key, value, null);//①此处新建node为LinkedHashMap重写方法
 	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) {
 					//①此处新建node为LinkedHashMap重写方法
 					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);//②是否为访问顺序，如果访问顺序则需要进行位置节点调整,linkedHashMap进行重写
 			return oldValue;
 		}
 	}
 	++modCount;
 	if (++size > threshold)
 		resize();
 	afterNodeInsertion(evict);//③LinkedHashMap重写
 	return null;
 }

第①处不同：维护新节点到末尾

   Node<K,V> newNode(int hash, K key, V value, Node<K,V> e) {
       //创建新的LinkedHashMap，基于Entry去创建，Entry继承于HashMap的Node
       LinkedHashMap.Entry<K,V> p = new LinkedHashMap.Entry<K,V>(hash, key, value, e);
       linkNodeLast(p);//维护新节点的顺序
       return p;
   }
   //链接到末尾
   private void linkNodeLast(LinkedHashMap.Entry<K,V> p) {
       LinkedHashMap.Entry<K,V> last = tail;//双向链表的尾指针
       tail = p;//将新Entry赋值到尾指针
       if (last == null)//判定是否为第一个节点
           head = p;//将其设置为头指针
       else {
           p.before = last;//新节点与前节点之间的链接
           last.after = p;//前节点与新节点之间的链接
       }
   }

第②处不同：put中是替换操作，看排序方式是否需要调整节点位置，访问顺序为true，插入为false

 void afterNodeAccess(Node<K,V> e) { // move node to last
     LinkedHashMap.Entry<K,V> last;
     if (accessOrder && (last = tail) != e) {//验证是否为访问顺序和当前put替换值是否为尾节点
         LinkedHashMap.Entry<K,V> p =
             (LinkedHashMap.Entry<K,V>)e, b = p.before, a = p.after;
         p.after = null;//将当前节点后续置空，用于放置顺序最后
         if (b == null)//判定当前node是否为头节点
             head = a;//将第二个节点置为头指针
         else
             b.after = a;//将当前节点拿出，后续节点连接
         if (a != null)//判定当前节点后续是否存在节点
             a.before = b;//将后节点的before指针连接到当前节点的前节点
         else
             last = b;//标记last节点为当前节点的前节点
         if (last == null)//判定last是否为空即是否容器只有替换节点
             head = p;//将当前唯一节点设置为头指针
         else {
             p.before = last;//容器不止一个节点，则将替换节点连接到容器的最后一个节点
             last.after = p;//最后一个节点的后续为新的替换节点
         }
         tail = p;//将此替换put操作放置尾节点
         ++modCount;//操作数并发修改异常时会触发
     }
 }

第③处不同：实现LRU算法的关键点，去掉最少访问的节点

  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);//删除最早节点，会重写afterNodeRemoval方法去调整顺序
      }
  }

  //实现LRU算法，必须重写removeEldestEntry方法，LinkedHashMap默认返回的是false，不删除
  protected boolean removeEldestEntry(Map.Entry<K,V> eldest) {
      return false;
  }

（3）get方法

  public V get(Object key) {
      Node<K,V> e;//调用HashMap的getNode查找逻辑
      if ((e = getNode(hash(key), key)) == null)
          return null;
      if (accessOrder)//是否访问排序
          afterNodeAccess(e);//调整顺序
      return e.value;
  }

（4）remove方法

 //调用的HashMap的remove方法，removeNode方法也是HasMap中的，其中会重写afterNodeRemoval方法去调整顺序
   public V remove(Object key) {
       Node<K,V> e;
       return (e = removeNode(hash(key), key, null, false, true)) == null ?
           null : e.value;
   }

3、总结

（1）LinkedHashMap继承HashMap,其构造函数封装，底层调用父类的构造方法，put、get、remove均使用HashMap中的方法，
    在其实现上重写了部分方法如put中的newNode、afterNodeAccess、afterNodeInsertion、还有remove中的afterNodeRemoval;
（2）LinkedHashMap继承HashMap,其默认容量、默认扩容阈值、默认负载因子、扩容机制、树化等操作均使用父类的HashMap,
    但自身增加了头指针head和尾指针tail(Entry),构成双向链表;
（3）LinkedHashMap底层由父类的Node变为Entry，主要是在Entry上增加了before和after指针，用于维护双向链表;
（4）自身未增加其他线程安全措施即也是线程不安全、未同步，多线程环境报并发修改异常java.util.ConcurrentModificationException。