给jdk写注释系列之jdk1.6容器(5)-LinkedHashMap源码解析

 1     /**
 2      * LinkedHashMap entry.
 3      */
 4     private static class Entry<K,V> extends HashMap.Entry<K,V> {
 5         // These fields comprise the doubly linked list used for iteration.
 6         // 双向链表的上一个节点before和下一个节点after
 7         Entry<K,V> before, after ;
 8 
 9        // 构造方法直接调用父类HashMap的构造方法（super）
10        Entry( int hash, K key, V value, HashMap.Entry<K,V> next) {
11             super(hash, key, value, next);
12         }
13 
14         /**
15          * 从链表中删除当前节点的方法
16          */
17         private void remove() {
18             // 改变当前节点前后两个节点的引用关系，当前节点没有被引用后，gc可以回收
19             // 将上一个节点的after指向下一个节点
20             before.after = after;
21             // 将下一个节点的before指向前一个节点
22             after.before = before;
23         }
24 
25         /**
26          * 在指定的节点前加入一个节点到链表中（也就是加入到链表尾部）
27          */
28         private void addBefore(Entry<K,V> existingEntry) {
29             // 下面改变自己对前后的指向
30             // 将当前节点的after指向给定的节点（加入到existingEntry前面嘛）
31             after  = existingEntry;
32             // 将当前节点的before指向给定节点的上一个节点
33             before = existingEntry.before ;
34 
35             // 下面改变前后最自己的指向
36             // 上一个节点的after指向自己
37             before.after = this;
38             // 下一个几点的before指向自己
39             after.before = this;
40         }
41 
42         // 当向Map中获取查询元素或修改元素（put相同key）的时候调用这个方法
43         void recordAccess(HashMap<K,V> m) {
44             LinkedHashMap<K,V> lm = (LinkedHashMap<K,V>)m;
45             // 如果accessOrder为true，也就是使用最近较少使用顺序
46             if (lm.accessOrder ) {
47                 lm. modCount++;
48                 // 先删除，再添加，也就相当于移动了
49                 // 删除当前元素
50                 remove();
51                 // 将当前元素加入到header前（也就是链表尾部）
52                 addBefore(lm. header);
53             }
54         }
55 
56         // 当从Map中删除元素的时候调动这个方法
57         void recordRemoval(HashMap<K,V> m) {
58             remove();
59         }
60 }

 1 /**
 2      * Constructs an empty <tt>HashMap</tt> with the specified initial
 3      * capacity and load factor.
 4      *
 5      * @param  initialCapacity the initial capacity
 6      * @param  loadFactor      the load factor
 7      * @throws IllegalArgumentException if the initial capacity is negative
 8      *         or the load factor is nonpositive
 9      */
10     public HashMap( int initialCapacity, float loadFactor) {
11         if (initialCapacity < 0)
12             throw new IllegalArgumentException( "Illegal initial capacity: " +
13                                                initialCapacity);
14         if (initialCapacity > MAXIMUM_CAPACITY)
15             initialCapacity = MAXIMUM_CAPACITY;
16         if (loadFactor <= 0 || Float.isNaN(loadFactor))
17             throw new IllegalArgumentException( "Illegal load factor: " +
18                                                loadFactor);
19 
20         // Find a power of 2 >= initialCapacity
21         int capacity = 1;
22         while (capacity < initialCapacity)
23             capacity <<= 1;
24 
25         this.loadFactor = loadFactor;
26         threshold = (int)(capacity * loadFactor);
27         table = new Entry[capacity];
28         init();
29     }
30 
31     /**
32      * Initialization hook for subclasses. This method is called
33      * in all constructors and pseudo -constructors (clone, readObject)
34      * after HashMap has been initialized but before any entries have
35      * been inserted.  (In the absence of this method, readObject would
36      * require explicit knowledge of subclasses.)
37      */
38     void init() {
39     

 1     /**
 2      * Called by superclass constructors and pseudoconstructors (clone,
 3      * readObject) before any entries are inserted into the map.  Initializes
 4      * the chain.
 5      */
 6     void init() {
 7         // 初始化话header，将hash设置为-1，key、value、next设置为null
 8         header = new Entry<K,V>(-1, null, null, null);
 9         // header的before和after都指向header自身
10         header.before = header. after = header ;
11     

 1 import java.util.LinkedHashMap;
 2 import java.util.Map;
 3 
 4 public class MyLocalCache extends LinkedHashMap<String, Object> {
 5 
 6         private static final long serialVersionUID = 7182816356402068265L;
 7 
 8         private static final int DEFAULT_MAX_CAPACITY = 1024;
 9 
10         private static final float DEFAULT_LOAD_FACTOR = 0.75f;
11 
12         private int maxCapacity;
13 
14         public enum Policy {
15                FIFO, LRU
16        }
17 
18         public MyLocalCache(Policy policy) {
19                super(DEFAULT_MAX_CAPACITY, DEFAULT_LOAD_FACTOR, Policy.LRU .equals(policy));
20                this.maxCapacity = DEFAULT_MAX_CAPACITY;
21        }
22 
23         public MyLocalCache(int capacity, Policy policy) {
24                super(capacity, DEFAULT_LOAD_FACTOR, Policy. LRU.equals(policy));
25                this.maxCapacity = capacity;
26        }
27 
28         @Override
29         protected boolean removeEldestEntry(Map.Entry<String, Object> eldest) {
30                return this.size() > maxCapacity;
31        }
32        
33         public static void main(String[] args) {
34               MyLocalCache cache = new MyLocalCache(5, Policy.LRU);
35               cache.put( "k1", "v1" );
36               cache.put( "k2", "v2" );
37               cache.put( "k3", "v3" );
38               cache.put( "k4", "v4" );
39               cache.put( "k5", "v5" );
40               cache.put( "k6", "v6" );
41               
42               System. out.println("size=" + cache.size());
43               
44               System. out.println("----------------------" );
45                for (Map.Entry<String, Object> entry : cache.entrySet()) {   
46             　　　　System. out.println(entry.getValue());   
47         　　　　}
48               
49               System. out.println("----------------------" );
50               
51               System. out.println("k3=" + cache.get("k3"));
52               
53               System. out.println("----------------------" );
54                for (Map.Entry<String, Object> entry : cache.entrySet()) {   
55             　　　　System. out.println(entry.getValue());   
56         　　　　}
57        }
58 
59 }