Java7/8中的HashMap和ConcurrentHashMap全解析

 1 public V put(K key, V value) {
 2     // 当插入第一个元素的时候，需要先初始化数组大小
 3     if (table == EMPTY_TABLE) {
 4         inflateTable(threshold);
 5     }
 6     // 如果 key 为 null，感兴趣的可以往里看，最终会将这个 entry 放到 table[0] 中
 7     if (key == null)
 8         return putForNullKey(value);
 9     // 1. 求 key 的 hash 值
10     int hash = hash(key);
11     // 2. 找到对应的数组下标
12     int i = indexFor(hash, table.length);
13     // 3. 遍历一下对应下标处的链表，看是否有重复的 key 已经存在，
14     //    如果有，直接覆盖，put 方法返回旧值就结束了
15     for (Entry e = table[i]; e != null; e = e.next) {
16         Object k;
17         if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
18             V oldValue = e.value;
19             e.value = value;
20             e.recordAccess(this);
21             return oldValue;
22         }
23     }
24 
25     modCount++;
26     // 4. 不存在重复的 key，将此 entry 添加到链表中，细节后面说
27     addEntry(hash, key, value, i);
28     return null;
29 }

 1 private void inflateTable(int toSize) {
 2     // 保证数组大小一定是 2 的 n 次方。
 3     // 比如这样初始化：new HashMap(20)，那么处理成初始数组大小是 32
 4     int capacity = roundUpToPowerOf2(toSize);
 5     // 计算扩容阈值：capacity * loadFactor
 6     threshold = (int) Math.min(capacity * loadFactor, MAXIMUM_CAPACITY + 1);
 7     // 算是初始化数组吧
 8     table = new Entry[capacity];
 9     initHashSeedAsNeeded(capacity); //ignore
10 }

 1 void addEntry(int hash, K key, V value, int bucketIndex) {
 2     // 如果当前 HashMap 大小已经达到了阈值，并且新值要插入的数组位置已经有元素了，那么要扩容
 3     if ((size >= threshold) && (null != table[bucketIndex])) {
 4         // 扩容，后面会介绍一下
 5         resize(2 * table.length);
 6         // 扩容以后，重新计算 hash 值
 7         hash = (null != key) ? hash(key) : 0;
 8         // 重新计算扩容后的新的下标
 9         bucketIndex = indexFor(hash, table.length);
10     }
11     // 往下看
12     createEntry(hash, key, value, bucketIndex);
13 }
14 // 这个很简单，其实就是将新值放到链表的表头，然后 size++
15 void createEntry(int hash, K key, V value, int bucketIndex) {
16     Entry e = table[bucketIndex];
17     table[bucketIndex] = new Entry(hash, key, value, e);
18     size++;
19 }

 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     // 将原来数组中的值迁移到新的更大的数组中
11     transfer(newTable, initHashSeedAsNeeded(newCapacity));
12     table = newTable;
13     threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);
14 }