大家都知道 hashmap的数据结构 链表(Node<Key,Value>)组成的数组(Node[] table)，同一个链表中的数据，key的hashcode相同，Capacity 为table数组的容量（并不是hashmap里面拥有元素的容量），size为所有元素的和。网上找的图片
先看几个成员变量 很简单的英文
/**
* The table, initialized on first use, and resized as
* necessary. When allocated, length is always a power of two.
* 在第一次用的时候初始化，长度是2的幂
*/
transient Node<K,V>[] table;
/**
* The number of key-value mappings contained in this map.
*/
transient int size;
// size大于这个值的时候 resize (capacity * load factor).
int threshold;
// 加载因子 默认0.75
final float loadFactor;
构造函数 初始化值
public HashMap(int initialCapacity) {
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
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);
}
通过方法tableSizeFor可知 初始化时 capacity(构造函数传参 容量) 不会存到HashMap的成员变量中，threshold初始值为不小于capacity最小的2的n次幂 如1->1 2->2 3->4 4->4 5->8...8->8 9->16。仅仅初始化的时候 threshold为2的n次幂，第一次调用put前，则为2的n次幂乘以loadFactor， 如 3 6 12 24 48
static final int tableSizeFor(int cap) {
int n = cap - 1;
n |= n >>> 1;
n |= n >>> 2;
n |= n >>> 4;
n |= n >>> 8;
n |= n >>> 16;
return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
}
put 方法 当初始化完成后 第一次调用put方法，因为(table==null) 所以第一次put会resize()，通过这次resize() threshold 即变为原先threshold的loadFactor倍(默认0.75)
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
Node<K,V>[] tab; Node<K,V> p; int n, i;
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
else {
···
}
++modCount;
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}
上面说过 capacity不作为一个成员变量存到HashMap中，但如何取到capacity的值呢？通过 table.length, table为空 代表刚刚初始化，还有么put值，所以可以直接返回threshold，table不为空，返回table.length
final int capacity() {
return (table != null) ? table.length :
(threshold > 0) ? threshold :
DEFAULT_INITIAL_CAPACITY;
}
resize方法可以归纳为 table(capacity)大小（4 8 16 32 64）增大一倍，threshold（3 6 12 24 48）增大一倍
重点---- 上面已经说过 HashMap容量为table的大小，并不是拥有元素的上界，但resize的判定条件却是以++size>threshold 来判断的 所以有极端的情况，当所有的key的hashcode为一样时，所有key-value数据都存到了table[]的一个链表中，其他 capacity-1个链表都为空，但是，当size>threshold时，还是会把threshold与table扩容一倍，造成非常大的容量浪费 例子如下
public class DemoMain {
public static void main(String[] args) {
Map<Key, Object> map = new HashMap<>(5);
for (int i = 1; i <= 10000; i++) {
map.put(new Key("key-" + i), "value-" + i);
}
System.err.println(map);
}
static class Key {
private String name;
public Key(String name) {
this.name = name;
}
@Override
public int hashCode() {
return 1; //代表所有的key-value数据都会放到hashmap的同一个链表中
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Key other = (Key) obj;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}
}
}
