/**
  * 一個空的entry數(shù)組，桶 的默認值
  */
 static final Entry<?,?>[] EMPTY_TABLE = {};
 /**
  * 桶，按需調(diào)整大小，但必須是2的次冪
  */
 transient Entry<K,V>[] table = (Entry<K,V>[]) EMPTY_TABLE;

/**
  * 默認初始化容量，必須為2的次冪The default initial capacity - MUST be a power of two.
  */
 static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
 /**
  * 最大容量，如果通過構(gòu)造函數(shù)參數(shù)中傳遞初始化容量大于該最大容量了，也會使用該容量為初始化容量  * 必須是2的次冪且小于等于2的30次方  */
 static final int MAXIMUM_CAPACITY = 1 << 30;
 /**
  * 默認的負載因子，可以通過構(gòu)造函數(shù)指定
  */
 static final float DEFAULT_LOAD_FACTOR = 0.75f;
 /**
  * 一個空的數(shù)組表，當 桶沒有初始化的時候
  */
 static final Entry<?,?>[] EMPTY_TABLE = {};
 /**
  * 桶 , 存儲所有的鍵值對條目，可以按需調(diào)整大小，長度大小必須為2的次冪 
  */
 transient Entry<K,V>[] table = (Entry<K,V>[]) EMPTY_TABLE;
 /**
  * Map中鍵值對的數(shù)量，在每次新增或刪除的時候都會對size進行+1或者-1操作.
  */
 transient int size;
 /**
  * 負載值，需要調(diào)整大小的臨界值，為：(capacity * load factor).在每次調(diào)整大小后會使用新的容量計算一下
  * @serial
  */
 // If table == EMPTY_TABLE then this is the initial capacity at which the
 // table will be created when inflated.
 int threshold;
 /**
  * 負載因子，如果構(gòu)造函數(shù)中沒有指定，則采用默認的負載因子，
  *
  * @serial
  */
 final float loadFactor;
 /**
  * HashMap結(jié)構(gòu)修改次數(shù)，結(jié)構(gòu)修改時改變HashMap中的映射數(shù)量或修改其內(nèi)部結(jié)構(gòu)（例如，* rehash方法，重建內(nèi)部數(shù)據(jù)結(jié)構(gòu)），此字段用于在  * HashMap的集合視圖上生成的迭代器都處理成快速失敗的
  */
 transient int modCount;

void resize(int newCapacity) {
  Entry[] oldTable = table;
  int oldCapacity = oldTable.length;
  if (oldCapacity == MAXIMUM_CAPACITY) { // 如果容量已達最大限制，則設(shè)置下負載值后直接返回
   threshold = Integer.MAX_VALUE;
   return;
  }
  // 創(chuàng)建新的table存儲數(shù)據(jù)
  Entry[] newTable = new Entry[newCapacity];
  // 將舊table中的數(shù)據(jù)轉(zhuǎn)存到新table中去，這一步會花費比較多的時間
  transfer(newTable, initHashSeedAsNeeded(newCapacity));
  table = newTable;
  // 最后設(shè)置下下次調(diào)整大小的負載值
  threshold = (int) Math.min(newCapacity * loadFactor,
    MAXIMUM_CAPACITY + 1);
}

/**
   * Constructs an empty <tt>HashMap</tt> with the default initial capacity
   * (16) and the default load factor (0.75).
   */
  public HashMap() {
    this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR);
  }
  /**
   * Constructs an empty <tt>HashMap</tt> with the specified initial
   * capacity and the default load factor (0.75).
   *
   * @param initialCapacity the initial capacity.
   * @throws IllegalArgumentException if the initial capacity is negative.
   */
  public HashMap(int initialCapacity) {
    this(initialCapacity, DEFAULT_LOAD_FACTOR);
  }
  /**
   * Constructs an empty <tt>HashMap</tt> with the specified initial
   * capacity and load factor.
   *
   * @param initialCapacity the initial capacity
   * @param loadFactor   the load factor
   * @throws IllegalArgumentException if the initial capacity is negative
   *     or the load factor is nonpositive
   */
  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);
    this.loadFactor = loadFactor;
    threshold = initialCapacity;
    init();
  }

/**
   * 在此映射中關(guān)聯(lián)指定值與指定建。如果該映射以前包含了一個該鍵的映射關(guān)系，則舊值被替換
   *
   * @param 指定將要關(guān)聯(lián)的鍵
   * @param 指定將要關(guān)聯(lián)的值
   * @return 與key關(guān)聯(lián)的舊值，如果key沒有任何映射關(guān)系，則返回null（返回null還可能表示該映射之前將null與key關(guān)聯(lián)）
   */
  public V put(K key, V value) {
    if (table == EMPTY_TABLE) {
      inflateTable(threshold);
    }
    if (key == null)
      return putForNullKey(value);
    int hash = hash(key);
    int i = indexFor(hash, table.length);
    for (Entry<K,V> e = table[i]; e != null; e = e.next) {
      Object k;
      if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
        V oldValue = e.value;
        e.value = value;
        e.recordAccess(this);
        return oldValue;
      }
    }
    modCount++;
    addEntry(hash, key, value, i);
    return null;
  }

void addEntry(int hash, K key, V value, int bucketIndex) {
    if ((size >= threshold) && (null != table[bucketIndex])) {
      resize(2 * table.length);
      hash = (null != key) ? hash(key) : 0;
      bucketIndex = indexFor(hash, table.length);
    }
    createEntry(hash, key, value, bucketIndex);
  }
  void createEntry(int hash, K key, V value, int bucketIndex) {
    Entry<K,V> e = table[bucketIndex];
    table[bucketIndex] = new Entry<>(hash, key, value, e);
    size++;
  }
  /**
  * Entry構(gòu)造方法，創(chuàng)建一個新的Entry.
  */
  Entry(int h, K k, V v, Entry<K,V> n) {
    value = v;
    next = n;
    key = k;
    hash = h;
  }

/**
   * 返回指定鍵所映射的值；如果對于該鍵來說，此映射不包含任何映射關(guān)系，則返回null
   * 返回null值并不一定表明該映射不包含該鍵的映射，也可能改映射將該鍵顯示的映射為null，可使用containsKey操作來區(qū)分這兩種情況
   * @see #put(Object, Object)
   */
  public V get(Object key) {
    if (key == null)
      return getForNullKey();
    Entry<K,V> entry = getEntry(key);
    return null == entry ? null : entry.getValue();
  }
  final Entry<K,V> getEntry(Object key) {
    if (size == 0) {
      return null;
    }
    int hash = (key == null) ? 0 : hash(key);
    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 != null && key.equals(k))))
        return e;
    }
    return null;
}

class User {
  // 身份證號碼
  protected int idNumber;
  public User(int id){
    idNumber = id;
  }
}
public class TestUser{
  public static void main(String[] args) {
    Map<User, String> map = new HashMap<User, String>();
    for (int i=0; i<5; i++) {
      map.put(new User(i), "姓名: " + i);
    }
    System.out.println("User3 的姓名：" + map.get(new User(3)));
  }
}
輸出：
User3 的姓名：null

class User {
  // 身份證號碼
  protected int idNumber;
  public User(int id){
    idNumber = id;
  }
  @Override
  public int hashCode() {
    return idNumber;
  }
  @Override
  public boolean equals(Object obj) {
    return obj instanceof User && (idNumber==((User)obj).idNumber);
  }
}
public class TestUser{
  public static void main(String[] args) {
    Map<User, String> map = new HashMap<User, String>();
    for (int i=0; i<5; i++) {
      map.put(new User(i), "姓名: " + i);
    }
    System.out.println("User3 的姓名：" + map.get(new User(3)));
  }
}
輸出：
User3 的姓名：姓名: 3