Map m = Collections.synchronizedMap(new HashMap(...)); 

// Entry是單向鏈表。 它是 “HashMap鏈式存儲法”對應的鏈表。 
// 實現(xiàn)了Map.Entry接口，即getKey(),getValue(),setValue(V value),equals(Object o),hashCode()這些函數(shù) 
static class Entry implements Map.Entry { 
 final K key; 
 V value; 
 // 指向下一個節(jié)點 
 Entry next; 
 final int hash; 
 
 // 構(gòu)造函數(shù)
 // 輸入?yún)?shù)包括"哈希值(h)", "鍵(k)", "值(v)", "下一節(jié)點(n)" 
 Entry(int h, K k, V v, Entry n) { 
  value = v; 
  next = n; 
  key = k; 
  hash = h; 
 } 
 
 public final K getKey() { 
  return key; 
 } 
 public final V getValue() { 
  return value; 
 } 
 public final V setValue(V newValue) { 
  V oldValue = value; 
  value = newValue; 
  return oldValue; 
 } 
 // 判斷兩個Entry是否相等 
 // 若兩個Entry的“key”和“value”都相等，則返回true。 
 // 否則，返回false 
 public final boolean equals(Object o) { 
  if (!(o instanceof Map.Entry)) 
   return false; 
  Map.Entry e = (Map.Entry)o; 
  Object k1 = getKey(); 
  Object k2 = e.getKey(); 
  if (k1 == k2 || (k1 != null && k1.equals(k2))) { 
   Object v1 = getValue(); 
   Object v2 = e.getValue(); 
   if (v1 == v2 || (v1 != null && v1.equals(v2))) 
    return true; 
  } 
  return false; 
 } 
 // 實現(xiàn)hashCode() 
 public final int hashCode() { 
  return (key==null ? 0 : key.hashCode()) ^ 
    (value==null ? 0 : value.hashCode()); 
 } 
 public final String toString() { 
  return getKey() + "=" + getValue(); 
 } 
 // 當向HashMap中添加元素時，繪調(diào)用recordAccess()。 
 // 這里不做任何處理 
 void recordAccess(HashMap m) { 
 } 
 // 當從HashMap中刪除元素時，繪調(diào)用recordRemoval()。 
 // 這里不做任何處理 
 void recordRemoval(HashMap m) { 
 } 
}

// 找出“大于Capacity”的最小的2的冪,使Hash表的容量保持為2的次方倍
 // 算法的思想：通過使用邏輯運算來替代取余，這里有一個規(guī)律，就是當N為2的次方（Power of two），那么X％N==X&(N-1)。
 static final int tableSizeFor(int cap) {
  int n = cap - 1;
  n |= n >>> 1; // >>> 無符號右移,高位補0
  n |= n >>> 2; // a|=b的意思就是把a和b按位或然后賦值給a
  n |= n >>> 4;
  n |= n >>> 8;
  n |= n >>> 16;
  return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
 }
 // 構(gòu)造一個帶指定初始容量和加載因子的空HashMap
 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;
  this.threshold = tableSizeFor(initialCapacity);
 }
 // 構(gòu)造一個帶指定初始容量和默認加載因子(0.75)的空 HashMap
 public HashMap(int initialCapacity) {
  this(initialCapacity, DEFAULT_LOAD_FACTOR);
 }
 // 構(gòu)造一個具有默認初始容量 (16)和默認加載因子 (0.75)的空 HashMap
 public HashMap() {
  this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
 }
 // 構(gòu)造一個映射關(guān)系與指定 Map相同的新 HashMap,容量與指定Map容量相同，加載因子為默認的0.75
 public HashMap(Map m) {
  this.loadFactor = DEFAULT_LOAD_FACTOR;
  putMapEntries(m, false);
 } 

// Entry是單向鏈表。 
 // 它是 “HashMap鏈式存儲法”對應的鏈表。 
 // 它實現(xiàn)了Map.Entry 接口，即實現(xiàn)getKey(), getValue(), setValue(V value), equals(Object o), hashCode()這些函數(shù) 
 static class Entry implements Map.Entry { 
  final K key; 
  V value; 
  // 指向下一個節(jié)點 
  Entry next; 
  final int hash; 
   // 構(gòu)造函數(shù)。 
  // 輸入?yún)?shù)包括"哈希值(h)", "鍵(k)", "值(v)", "下一節(jié)點(n)" 
  Entry(int h, K k, V v, Entry n) { 
   value = v; 
   next = n; 
   key = k; 
   hash = h; 
  } 
  ......
 }