1  Map map = Collections.synchronizedMap(new HashMap());

 1 static class Entry<K,V> implements Map.Entry<K,V> {2         final K key;3         V value;4         Entry<K,V> next;5         final int hash;6 7         /**8          * Creates new entry.9          */
10         Entry(int h, K k, V v, Entry<K,V> n) {
11             value = v;
12             next = n; //hash值冲突后存放在链表的下一个
13             key = k;
14             hash = h;
15         }
16
17         .........
18     }

1 transient Entry[] table;//存储元素的实体数组
2
3 transient int size;//存放元素的个数
4
5 int threshold; //临界值   当实际大小超过临界值时，会进行扩容threshold = 加载因子*容量
6
7 final float loadFactor; //加载因子
8
9 transient int modCount;//被修改的次数

 1 public HashMap(int initialCapacity, float loadFactor) {2         //确保数字合法3         if (initialCapacity < 0)4             throw new IllegalArgumentException("Illegal initial capacity: " +5                                                initialCapacity);6         if (initialCapacity > MAXIMUM_CAPACITY)7             initialCapacity = MAXIMUM_CAPACITY;8         if (loadFactor <= 0 || Float.isNaN(loadFactor))9             throw new IllegalArgumentException("Illegal load factor: " +
10                                                loadFactor);
11
12         // Find a power of 2 >= initialCapacity
13         int capacity = 1;   //初始容量
14         while (capacity < initialCapacity)   //确保容量为2的n次幂，使capacity为大于initialCapacity的最小的2的n次幂
15             capacity <<= 1;
16
17         this.loadFactor = loadFactor;
18         threshold = (int)(capacity * loadFactor);
19         table = new Entry[capacity];
20         init();
21     }
22
23     public HashMap(int initialCapacity) {
24         this(initialCapacity, DEFAULT_LOAD_FACTOR);
25     }
26
27     public HashMap() {
28         this.loadFactor = DEFAULT_LOAD_FACTOR;
29         threshold = (int)(DEFAULT_INITIAL_CAPACITY * DEFAULT_LOAD_FACTOR);
30         table = new Entry[DEFAULT_INITIAL_CAPACITY];
31         init();
32     }

 1 public V put(K key, V value) {2         if (key == null) //如果键为null的话，调用putForNullKey(value)3             return putForNullKey(value);4         int hash = hash(key.hashCode());//根据键的hashCode计算hash码5         int i = indexFor(hash, table.length);6         for (Entry<K,V> e = table[i]; e != null; e = e.next) { //处理冲突的，如果hash值相同，则在该位置用链表存储7             Object k;8             if (e.hash == hash && ((k = e.key) == key || key.equals(k))) { //如果key相同则覆盖并返回旧值9                 V oldValue = e.value;
10                 e.value = value;
11                 e.recordAccess(this);
12                 return oldValue;
13             }
14         }
15
16         modCount++;
17         addEntry(hash, key, value, i);
18         return null;
19     }

1 static int hash(int h) {
2         h ^= (h >>> 20) ^ (h >>> 12);
3         return h ^ (h >>> 7) ^ (h >>> 4);
4   }  

1 static int indexFor(int h, int length) {
2        return h & (length-1);
3    }  

1 void addEntry(int hash, K key, V value, int bucketIndex) {
2         Entry<K,V> e = table[bucketIndex]; //如果要加入的位置有值，将该位置原先的值设置为新entry的next,也就是新entry链表的下一个节点
3         table[bucketIndex] = new Entry<>(hash, key, value, e);
4         if (size++ >= threshold) //如果大于临界值就扩容
5             resize(2 * table.length); //以2的倍数扩容
6     }

 1 void resize(int newCapacity) {2         Entry[] oldTable = table;3         int oldCapacity = oldTable.length;4         if (oldCapacity == MAXIMUM_CAPACITY) {5             threshold = Integer.MAX_VALUE;6             return;7         }8 9         Entry[] newTable = new Entry[newCapacity];
10         transfer(newTable);//用来将原先table的元素全部移到newTable里面
11         table = newTable;  //再将newTable赋值给table
12         threshold = (int)(newCapacity * loadFactor);//重新计算临界值
13     }