1 public V put(K key, V value) {
 2         // 如果key为null，调用putForNullKey方法进行存储
 3         if (key == null)
 4             return putForNullKey(value);
 5         // 使用key的hashCode计算key对应的hash值
 6         int hash = hash(key.hashCode());
 7         // 通过key的hash值查找在数组中的index位置
 8         int i = indexFor(hash, table.length );
 9         // 取出数组index位置的链表，遍历链表找查看是有已经存在相同的key
10         for (Entry<K,V> e = table [i]; e != null; e = e. next) {
11             Object k;
12             // 通过对比hash值、key判断是否已经存在相同的key
13             if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
14                 // 如果存在，取出当前key对应的value，供返回
15                 V oldValue = e. value;
16                 // 用新value替换之旧的value
17                 e. value = value;
18                 e.recordAccess( this);
19                 // 返回旧value，退出方法
20                 return oldValue;
21             }
22         }
23 
24         // 如果不存在相同的key
25         // 修改版本+1
26         modCount++;
27         // 在数组i位置处添加一个新的链表节点
28         addEntry(hash, key, value, i);
29         // 没有相同key的情况，返回null
30         return null;
31     }
32 
33     private V putForNullKey(V value) {
34         // 取出数组第1个位置（下标等于0）的节点，如果存在则覆盖不存在则新增，和上面的put一样不多讲，
35         for (Entry<K,V> e = table [0]; e != null; e = e. next) {
36             if (e.key == null) {
37                 V oldValue = e. value;
38                 e. value = value;
39                 e.recordAccess( this);
40                 return oldValue;
41             }
42         }
43         modCount++;
44         // 如果key等于null，则hash值等于0
45         addEntry(0, null, value, 0);
46         return null;
47 }

 1 /**
 2      * Applies a supplemental hash function to a given hashCode, which
 3      * defends against poor quality hash functions.  This is critical
 4      * because HashMap uses power -of- two length hash tables, that
 5      * otherwise encounter collisions for hashCodes that do not differ
 6      * in lower bits. Note: Null keys always map to hash 0, thus index 0.
 7      */
 8     static int hash(int h) {
 9         // This function ensures that hashCodes that differ only by
10         // constant multiples at each bit position have a bounded
11         // number of collisions (approximately 8 at default load factor).
12         h ^= (h >>> 20) ^ (h >>> 12);
13         return h ^ (h >>> 7) ^ (h >>> 4);
14     }
15 
16     /**
17      * Returns index for hash code h.
18      */
19     static int indexFor(int h, int length) {
20         return h & (length-1);
21 }

 1     /**
 2      * Rehashes the contents of this map into a new array with a
 3      * larger capacity.  This method is called automatically when the
 4      * number of keys in this map reaches its threshold.
 5      *
 6      * If current capacity is MAXIMUM_CAPACITY, this method does not
 7      * resize the map, but sets threshold to Integer.MAX_VALUE.
 8      * This has the effect of preventing future calls.
 9      *
10      * @param newCapacity the new capacity, MUST be a power of two;
11      *        must be greater than current capacity unless current
12      *        capacity is MAXIMUM_CAPACITY (in which case value
13      *        is irrelevant).
14      */
15     void resize( int newCapacity) {
16         // 当前数组
17         Entry[] oldTable = table;
18         // 当前数组容量
19         int oldCapacity = oldTable.length ;
20         // 如果当前数组已经是默认最大容量MAXIMUM_CAPACITY ，则将临界值改为Integer.MAX_VALUE 返回
21         if (oldCapacity == MAXIMUM_CAPACITY) {
22             threshold = Integer.MAX_VALUE;
23             return;
24         }
25 
26         // 使用新的容量创建一个新的链表数组
27         Entry[] newTable = new Entry[newCapacity];
28         // 将当前数组中的元素都移动到新数组中
29         transfer(newTable);
30         // 将当前数组指向新创建的数组
31         table = newTable;
32         // 重新计算临界值
33         threshold = (int)(newCapacity * loadFactor);
34     }
35 
36     /**
37      * Transfers all entries from current table to newTable.
38      */
39     void transfer(Entry[] newTable) {
40         // 当前数组
41         Entry[] src = table;
42         // 新数组长度
43         int newCapacity = newTable.length ;
44         // 遍历当前数组的元素，重新计算每个元素所在数组位置
45         for (int j = 0; j < src. length; j++) {
46             // 取出数组中的链表第一个节点
47             Entry<K,V> e = src[j];
48             if (e != null) {
49                 // 将旧链表位置置空
50                 src[j] = null;
51                 // 循环链表，挨个将每个节点插入到新的数组位置中
52                 do {
53                     // 取出链表中的当前节点的下一个节点
54                     Entry<K,V> next = e. next;
55                     // 重新计算该链表在数组中的索引位置
56                     int i = indexFor(e. hash, newCapacity);
57                     // 将下一个节点指向newTable[i]
58                     e. next = newTable[i];
59                     // 将当前节点放置在newTable[i]位置
60                     newTable[i] = e;
61                     // 下一次循环
62                     e = next;
63                 } while (e != null);
64             }
65         }
66 }

 1 /**
 2      * Returns <tt>true</tt> if this map contains a mapping for the
 3      * specified key.
 4      *
 5      * @param   key   The key whose presence in this map is to be tested
 6      * @return <tt> true</tt> if this map contains a mapping for the specified
 7      * key.
 8      */
 9     public boolean containsKey(Object key) {
10         return getEntry(key) != null;
11     }
12  
13     /**
14      * Returns the entry associated with the specified key in the
15      * HashMap.  Returns null if the HashMap contains no mapping
16      * for the key.
17      */
18     final Entry<K,V> getEntry(Object key) {
19         int hash = (key == null) ? 0 : hash(key.hashCode());
20         for (Entry<K,V> e = table [indexFor (hash, table .length)];
21              e != null;
22              e = e. next) {
23             Object k;
24             if (e.hash == hash &&
25                 ((k = e. key) == key || (key != null && key.equals(k))))
26                 return e;
27         }
28         return null;
29 }

 1 /**
 2      * Returns <tt>true</tt> if this map maps one or more keys to the
 3      * specified value.
 4      *
 5      * @param value value whose presence in this map is to be tested
 6      * @return <tt> true</tt> if this map maps one or more keys to the
 7      *         specified value
 8      */
 9     public boolean containsValue(Object value) {
10         if (value == null)
11             return containsNullValue();
12 
13        Entry[] tab = table;
14        // 遍历整个table查询是否有相同的value值
15         for (int i = 0; i < tab. length ; i++)
16             // 遍历数组的每个链表
17             for (Entry e = tab[i] ; e != null ; e = e.next)
18                 if (value.equals(e.value ))
19                     return true;
20         return false;
21     }
22 
23     /**
24      * Special -case code for containsValue with null argument
25      */
26     private boolean containsNullValue() {
27        Entry[] tab = table;
28         for (int i = 0; i < tab. length ; i++)
29             for (Entry e = tab[i] ; e != null ; e = e.next)
30                 if (e.value == null)
31                     return true;
32         return false;
33 }

 1     /**
 2      * Returns the number of key -value mappings in this map.
 3      *
 4      * @return the number of key- value mappings in this map
 5      */
 6     public int size() {
 7         return size ;
 8     }
 9 
10     /**
11      * Returns <tt>true</tt> if this map contains no key -value mappings.
12      *
13      * @return <tt> true</tt> if this map contains no key -value mappings
14      */
15     public boolean isEmpty() {
16         return size == 0;
17 }