static class Entry<K,V> implements Map.Entry<K,V> {
final K key;
V value;
Entry<K,V> next;
final int hash;
/**
 * Creates new entry.
 */
Entry(int h, K k, V v, Entry<K,V> n) {
 value = v;
 next = n; // hash值冲突后存放在链表的下一个
 key = k;
 hash = h;
}
.........
}

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

 public HashMap(int initialCapacity, float loadFactor) {
 // 确保数字合法
 if (initialCapacity < 0)
  throw new IllegalArgumentException("Illegal initial capacity: " +
      initialCapacity);
 if (initialCapacity > MAXIMUM_CAPACITY)
  initialCapacity = MAXIMUM_CAPACITY;
 if (loadFactor <= 0 || Float.isNaN(loadFactor))
  throw new IllegalArgumentException("Illegal load factor: " +
     loadFactor);

 // Find a power of 2 >= initialCapacity
 int capacity = 1; // 初始容量
 while (capacity < initialCapacity) // 确保容量为2的n次幂，使capacity为大于initialCapacity的最小的2的n次幂
 capacity <<= 1;

 this.loadFactor = loadFactor;
 threshold = (int)(capacity * loadFactor);
 table = new Entry[capacity];
 init();
}

public HashMap(int initialCapacity) {
 this(initialCapacity, DEFAULT_LOAD_FACTOR);
}

public HashMap() {
 this.loadFactor = DEFAULT_LOAD_FACTOR;
 threshold = (int)(DEFAULT_INITIAL_CAPACITY * DEFAULT_LOAD_FACTOR);
 table = new Entry[DEFAULT_INITIAL_CAPACITY];
 init();
}

public V put(K key, V value) {
 if (key == null) // 如果键为null的话，调用putForNullKey(value)
  return putForNullKey(value);
 int hash = hash(key.hashCode()); // 根据键的hashCode计算hash码
 int i = indexFor(hash, table.length);
 for (Entry<K,V> e = table[i]; e != null; e = e.next) { // 处理冲突的，如果hash值相同，则在该位置用链表存储
  Object k;
  if (e.hash == hash && ((k = e.key) == key || key.equals(k))) { //如果key相同则覆盖并返回旧值
  V oldValue = e.value;
  e.value = value;
  e.recordAccess(this);
  return oldValue;
 }
 }

 modCount++;
 addEntry(hash, key, value, i);
 return null;
}

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

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

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

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

public V get(Object key) { 
if (key == null)
return getForNullKey();
int hash = hash(key.hashCode());
// 找到数组的下标，进行遍历
for (Entry<K,V> e = table[indexFor(hash, table.length)]; e != null; e = e.next) {
Object k;
if (e.hash == hash && ((k = e.key) == key || key.equals(k)))
 return e.value; // 找到则返回
}
return null; // 否则，返回null
}