java容器类---LinkedHashMap、LinkedHashSet

1、LinkedHashMap简介

1.1 LinkedHashMap数据结构


 

   

LinkedHashMap是HashMap的子类，与HashMap有着同样的存储结构，但它加入了一个双向链表的头结点，将所有put到LinkedHashmap的节点一一串成了一个双向循环链表，因此它保留了节点插入的顺序，可以使节点的输出顺序与输入顺序相同。

LinkedHashMap是Map接口的哈希表和链接列表实现，具有可预知的迭代顺序。此实现提供所有可选的映射操作，并允许使用null值和null键。

LinkedHashMap实现与HashMap的不同之处在于，前者维护着一个运行于所有条目的双重链接列表。此链接列表定义了迭代顺序，该迭代顺序可以是插入顺序或者是访问顺序。注意，此实现不是同步的。如果多个线程同时访问链接的哈希映射，而其中至少一个线程从结构上修改了该映射，则它必须保持外部同步。

根据链表中元素的顺序可以分为：按插入顺序的链表，和按访问顺序(调用get方法)的链表。

1.2 LinkedHashMap继承关系

 

[java] view plain copy
 
  1. public class LinkedHashMap<K,V>    
  2.     extends HashMap<K,V>    
  3.     implements Map<K,V>  

 

对于LinkedHashMap而言，它继承与HashMap、底层使用哈希表与双向链表来保存所有元素。其基本操作与父类HashMap相似，它通过重写父类相关的方法，来实现自己的链接列表特性。

1.3 LinkedHashMap成员变量

[java] view plain copy
 
  1.    //双向循环链表的头结点，整个LinkedHashMap中只有一个header，    
  2.    //它将哈希表中所有的Entry贯穿起来，header中不保存key-value对，只保存前后节点的引用    
  3.    private transient Entry<K,V> header;    
  4.    
  5.    //双向链表中元素排序规则的标志位。    
  6.    //accessOrder为false，表示按插入顺序排序    
  7.    //accessOrder为true，表示按访问顺序排序    
  8.    private final boolean accessOrder;     
  9.   
  10.   
  11.    //Enty的数据结构，多了两个指向前后节点的引用    
  12.    private static class Entry<K,V> extends HashMap.Entry<K,V> {    
  13.           
  14.        Entry<K,V> before, after;   
  15. ...  

2、LinkedHashMap构造函数

[java] view plain copy
 
  1. //调用HashMap的构造方法来构造底层的数组    
  2. public LinkedHashMap(int initialCapacity, float loadFactor) {    
  3.     super(initialCapacity, loadFactor);    
  4.     accessOrder = false;    //链表中的元素默认按照插入顺序排序    
  5. }    
  6.   
  7. //加载因子取默认的0.75f    
  8. public LinkedHashMap(int initialCapacity) {    
  9.     super(initialCapacity);    
  10.     accessOrder = false;    
  11. }    
  12.   
  13. //加载因子取默认的0.75f，容量取默认的16    
  14. public LinkedHashMap() {    
  15.     super();    
  16.     accessOrder = false;    
  17. }    
  18.   
  19. //含有子Map的构造方法，同样调用HashMap的对应的构造方法    
  20. public LinkedHashMap(Map<? extends K, ? extends V> m) {    
  21.     super(m);    
  22.     accessOrder = false;    
  23. }    
  24.   
  25. //该构造方法可以指定链表中的元素排序的规则    
  26. public LinkedHashMap(int initialCapacity,float loadFactor,boolean accessOrder) {    
  27.     super(initialCapacity, loadFactor);    
  28.     this.accessOrder = accessOrder;    
  29. }    
  30.   
  31. //覆写父类的init()方法（HashMap中的init方法为空），    
  32. //该方法在父类的构造方法和Clone、readObject中在插入元素前被调用，    
  33. //初始化一个空的双向循环链表，头结点中不保存数据，头结点的下一个节点才开始保存数据。    
  34. void init() {    
  35.     header = new Entry<K,V>(-1, null, null, null);    
  36.     header.before = header.after = header;    
  37. }   

3、LinkedHashMap常用方法

3.1 存储方法

 

[java] view plain copy
 
  1. //覆写HashMap中的addEntry方法，LinkedHashmap并没有覆写HashMap中的put方法，    
  2. //而是覆写了put方法所调用的addEntry方法和recordAccess方法，    
  3. //put方法在插入的key已存在的情况下，会调用recordAccess方法，    
  4. //在插入的key不存在的情况下，要调用addEntry插入新的Entry    
  5. void addEntry(int hash, K key, V value, int bucketIndex) {    
  6.     //创建新的Entry，并插入到LinkedHashMap中    
  7.     createEntry(hash, key, value, bucketIndex);    
  8.   
  9.     //双向链表的第一个有效节点（header后的那个节点）为近期最少使用的节点    
  10.     Entry<K,V> eldest = header.after;    
  11.     //如果有必要，则删除掉该近期最少使用的节点，    
  12.     //这要看对removeEldestEntry的覆写,由于默认为false，因此默认是不做任何处理的。    
  13.     if (removeEldestEntry(eldest)) {    
  14.         removeEntryForKey(eldest.key);    
  15.     } else {    
  16.         //扩容到原来的2倍    
  17.         if (size >= threshold)    
  18.             resize(2 * table.length);    
  19.     }    
  20. }    
  21.   
  22. void createEntry(int hash, K key, V value, int bucketIndex) {    
  23.     //创建新的Entry，并将其插入到数组对应槽的单链表的头结点处，这点与HashMap中相同    
  24.     HashMap.Entry<K,V> old = table[bucketIndex];    
  25.     Entry<K,V> e = new Entry<K,V>(hash, key, value, old);    
  26.     table[bucketIndex] = e;    
  27.     //每次插入Entry时，都将其移到双向链表的尾部，    
  28.     //这便会按照Entry插入LinkedHashMap的先后顺序来迭代元素，    
  29.     //同时，新put进来的Entry是最近访问的Entry，把其放在链表末尾 ，符合LRU算法的实现    
  30.     e.addBefore(header);    
  31.     size++;    
  32. }   

LinkedHashMap并未重写父类HashMap的put方法，而是重写了父类HashMap的put方法调用的子方法void addEntry(int hash, K key, V value, int bucketIndex) 和void createEntry(int hash, K key, V value, int bucketIndex)，提供了自己特有的双向链接列表的实现。

 

3.2 读取方法

[java] view plain copy
 
  1. //覆写HashMap中的get方法，通过getEntry方法获取Entry对象。    
  2. //注意这里的recordAccess方法，    
  3. //如果链表中元素的排序规则是按照插入的先后顺序排序的话，该方法什么也不做，    
  4. //如果链表中元素的排序规则是按照访问的先后顺序排序的话，则将e移到链表的末尾处。    
  5. public V get(Object key) {    
  6.     Entry<K,V> e = (Entry<K,V>)getEntry(key);    
  7.     if (e == null)    
  8.         return null;    
  9.     e.recordAccess(this);    
  10.     return e.value;    
  11. }    
  12.   
  13.     //覆写HashMap中的recordAccess方法（HashMap中该方法为空），    
  14.     //当调用父类的put方法，在发现插入的key已经存在时，会调用该方法，    
  15.     //调用LinkedHashmap覆写的get方法时，也会调用到该方法，    
  16.     //该方法提供了LRU算法的实现，它将最近使用的Entry放到双向循环链表的尾部，    
  17.     //accessOrder为true时，get方法会调用recordAccess方法    
  18.     //put方法在覆盖key-value对时也会调用recordAccess方法    
  19.     //它们导致Entry最近使用，因此将其移到双向链表的末尾    
  20.     void recordAccess(HashMap<K,V> m) {    
  21.         LinkedHashMap<K,V> lm = (LinkedHashMap<K,V>)m;    
  22.         //如果链表中元素按照访问顺序排序，则将当前访问的Entry移到双向循环链表的尾部，    
  23.         //如果是按照插入的先后顺序排序，则不做任何事情。    
  24.         if (lm.accessOrder) {    
  25.             lm.modCount++;    
  26.             //移除当前访问的Entry    
  27.             remove();    
  28.             //将当前访问的Entry插入到链表的尾部    
  29.             addBefore(lm.header);    
  30.         }    
  31.     }   

小结：

1.accessOrder==false时

1.1 put方法

key相同,覆盖原有的Entry，不做移动

key不同，新的Entry放在双向链表的尾部

1.2 get方法

返回查询结果，不做移动

2.accessOrder==true时

2.1 put方法

key相同,覆盖原有的Entry，将覆盖的Entry移到双向链表的尾部

key不同，新的Entry放在双向链表的尾部

2.2 get方法

返回查询结果，将当前访问的Entry移到双向链表的尾部

 

当有新元素加入Map的时候调用Entry的addEntry方法，会调用removeEldestEntry方法，这里就是实现LRU元素过期机制的地方，默认的情况下removeEldestEntry方法只返回false表示元素永远不过期。

 

[java] view plain copy
 
  1. //该方法是用来被覆写的，一般如果用LinkedHashmap实现LRU算法，就要覆写该方法，    
  2. //比如可以将该方法覆写为如果设定的内存已满，则返回true，这样当再次向LinkedHashMap中put    
  3. //Entry时，在调用的addEntry方法中便会将近期最少使用的节点删除掉（header后的那个节点）。    
  4. protected boolean removeEldestEntry(Map.Entry<K,V> eldest) {    
  5.     return false;    
  6. }   

该方法默认返回false，我们一般在用LinkedHashMap实现LRU算法时，要覆写该方法，一般的实现是，当设定的内存（这里指节点个数）达到最大值时，返回true，这样put新的Entry（该Entry的key在哈希表中没有已经存在）时，就会调用removeEntryForKey方法，将最近最少使用的节点删除（head后面的那个节点，实际上是最近没有使用）。 

 

4、LinkedHashMap的Iterator

 

[java] view plain copy
 
  1. //迭代器    
  2. private abstract class LinkedHashIterator<T> implements Iterator<T> {    
  3. Entry<K,V> nextEntry    = header.after;    
  4. Entry<K,V> lastReturned = null;   
  5.   
  6. //从head的下一个节点开始迭代    
  7. Entry<K,V> nextEntry() {    
  8.     if (modCount != expectedModCount)    
  9.     throw new ConcurrentModificationException();    
  10.         if (nextEntry == header)    
  11.             throw new NoSuchElementException();    
  12.   
  13.         Entry<K,V> e = lastReturned = nextEntry;    
  14.         nextEntry = e.after;    
  15.         return e;    
  16. }    
  17.   
  18. //key迭代器    
  19. private class KeyIterator extends LinkedHashIterator<K> {    
  20. public K next() { return nextEntry().getKey(); }    
  21. }    
  22.   
  23. //value迭代器    
  24. private class ValueIterator extends LinkedHashIterator<V> {    
  25. public V next() { return nextEntry().value; }    
  26. }    
  27.   
  28. //Entry迭代器    
  29. private class EntryIterator extends LinkedHashIterator<Map.Entry<K,V>> {    
  30. public Map.Entry<K,V> next() { return nextEntry(); }    
  31. }    


5、总结

 

1.LinkedHashMap可以用来实现LRU算法。

2.LinkedHashMap同样是非线程安全的，只在单线程环境下使用。

3.注意构造方法，前四个构造方法都将accessOrder设为false，说明默认是按照插入顺序排序的，而第五个构造方法可以自定义传入的accessOrder的值，因此可以指定双向循环链表中元素的排序规则，一般要用LinkedHashMap实现LRU算法，就要用该构造方法，将accessOrder置为true。

 

6、LinkedHashSet

LinkedHashSet具有HashSet的查询速度，且内部使用链表维护元素的顺序（插入的次序）。于是在使用迭代器遍历Set时，结果会按照元素的插入次序显示。

看LinkedHashSet的内容。

 

[java] view plain copy
 
  1. public class LinkedHashSet<E>  
  2.     extends HashSet<E>  
  3.     implements Set<E>, Cloneable, java.io.Serializable {  
  4.   
  5.     public LinkedHashSet(int initialCapacity, float loadFactor) {  
  6.             super(initialCapacity, loadFactor, true);  
  7.     }  
  8.   
  9.     public LinkedHashSet(int initialCapacity) {  
  10.         super(initialCapacity, .75f, true);  
  11.     }  
  12.   
  13.     public LinkedHashSet() {  
  14.         super(16, .75f, true);  
  15.     }  
  16.   
  17.     public LinkedHashSet(Collection<? extends E> c) {  
  18.         super(Math.max(2*c.size(), 11), .75f, true);  
  19.         addAll(c);  
  20.     }  
  21. }  

LinkedHashSet继承自HashSet，HashSet基于HashMap实现，看LinkedHashSet类只是定义了四个构造方法，也没看到和链表相关的内容，为什么说LinkedHashSet内部使用链表维护元素的插入顺序（插入的顺序）呢？
    注意这里的构造方法，都调用了父类HashSet的第五个构造方法：HashSet(int initialCapacity, float loadFactor, boolean dummy)。下面再给出这个构造方法的内容。

 

[java] view plain copy
 
  1. HashSet(int initialCapacity, float loadFactor, boolean dummy) {  
  2.      map = new LinkedHashMap<E,Object>(initialCapacity, loadFactor);  
  3.  }  

区别于其他的HashSet的构造方法，这个方法创建的是一个LinkedHashMap。LinkedHashMap继承自HashMap，同时自身有一个链表结构用于维护元素顺序，默认情况使用的是插入元素，所以LinkedHashSet既有HashSet的访问速度（因为访问的时候都是通过HashSet的方法访问的），同时可以维护顺序。

 

 

参考来源：

【Java集合源码剖析】LinkedHashmap源码剖析

深入Java集合学习系列：LinkedHashMap的实现原理

HashSet及LinkedHashSet源码分析(基于JDK1.6)

posted @ 2016-12-09 17:36  天涯海角路  阅读(218)  评论(0)    收藏  举报