/**
* The default initial capacity - MUST be a power of two.
* 預設初始容量-必須是2的冪。
*/
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
複製程式碼
MAXIMUM_CAPACITY 預設最大容量 常量
/**
* The maximum capacity, used if a higher value is implicitly specified
* by either of the constructors with arguments.
* MUST be a power of two <= 1<<30.
*如果有一個更大的值被用於構造HashMap,則使用最大值
*/
static final int MAXIMUM_CAPACITY = 1 << 30;
複製程式碼
DEFAULT_LOAD_FACTOR 負載因子(預設0.75) 常量
/**
* The load factor used when none specified in constructor.
* 載入因子，如果建構函式中沒有指定，則使用預設的
*/
static final float DEFAULT_LOAD_FACTOR = 0.75f;
複製程式碼
EMPTY_TABLE 預設的空表
/**
* An empty table instance to share when the table is not inflated.
* 當表不膨脹時共享的空表例項。
*/
static final Entry<?,?>[] EMPTY_TABLE = {};
複製程式碼
table 表，必要時調整大小。長度必須是兩個冪。
這個也是hashmap中的核心的儲存結構
/**
* The table, resized as necessary. Length MUST Always be a power of two.
*/
transient Entry<K,V>[] table = (Entry<K,V>[]) EMPTY_TABLE;
複製程式碼
size 表示HashMap中存放KV的數量（為連結串列/樹中的KV的總和）
/**
* The number of key-value mappings contained in this map.
*/
transient int size;
複製程式碼
/**
* The next size value at which to resize (capacity * load factor).
* @serial
*/
// If table == EMPTY_TABLE then this is the initial capacity at which the
// table will be created when inflated.
int threshold;
複製程式碼
/**
* The number of times this HashMap has been structurally modified
* Structural modifications are those that change the number of mappings in
* the HashMap or otherwise modify its internal structure (e.g.,
* rehash). This field is used to make iterators on Collection-views of
* the HashMap fail-fast. (See ConcurrentModificationException).
*/
transient int modCount;
複製程式碼
/**
* A randomizing value associated with this instance that is applied to
* hash code of keys to make hash collisions harder to find. If 0 then
* alternative hashing is disabled.
*/
transient int hashSeed = 0;
複製程式碼
結構分析
static class Entry<K,V> implements Map.Entry<K,V>
複製程式碼
static class Entry<K,V> implements Map.Entry<K,V> {
final K key; //鍵物件
V value; //值物件
Entry<K,V> next; //指向連結串列中下一個Entry物件，可為null，表示當前Entry物件在連結串列尾部
int hash; //鍵物件的hash值
/**
* 構造物件
*/
Entry(int h, K k, V v, Entry<K,V> n) {
value = v;
next = n;
key = k;
hash = h;
}
/**
* 獲取key
*/
public final K getKey() {
return key;
}
/**
* 獲取value
*/
public final V getValue() {
return value;
}
/**
* 設定value，這裡返回的是oldValue(這個不太明白，哪位大佬清楚的可以留言解釋下，非常感謝)
*/
public final V setValue(V newValue) {
V oldValue = value;
value = newValue;
return oldValue;
}
/**
* 重寫equals方法
*/
public final boolean equals(Object o) {
if (!(o instanceof Map.Entry))
returnfalse;
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)))
returntrue;
}
returnfalse;
}
/**
* 重寫hashCode方法
*/
public final int hashCode() {
return Objects.hashCode(getKey()) ^ Objects.hashCode(getValue());
}
public final String toString() {
return getKey() + "=" + getValue();
}
/**
* This method is invoked whenever the value in an entry is
* overwritten by an invocation of put(k,v) for a key k that's already
* in the HashMap.
*/
void recordAccess(HashMap<K,V> m) {
}
/**
* This method is invoked whenever the entry is
* removed from the table.
*/
void recordRemoval(HashMap<K,V> m) {
}
}
複製程式碼
/**
final int hash(Object k) {
int h = hashSeed;
if (0 != h && k instanceof String) {
return sun.misc.Hashing.stringHash32((String) k);
}
h ^= k.hashCode();
//這個函式確保在每個位元位置上僅以恆定倍數不同
//的雜湊碼具有有限數量的衝突（在預設載入因子下大約為8）。
h ^= (h >>> 20) ^ (h >>> 12);
return h ^ (h >>> 7) ^ (h >>> 4);
}
複製程式碼