HashMap源码阅读

题外话：

HashMap线程不安全，Hashtable线程安全。

Hashtable的线程安全性体现在一些put get方法都用synchronized关键字修饰。

ConcurrentHashMap的源码实现采用了不同的加锁机制，称为分段锁。

最近读了hdfs的部分源码和设计思想，先说几句源码阅读心得，先理解设计思想，再进行源码阅读，所有的数据结构和算法都是需求驱动。

1 HashMap设计思想

我们在使用HashMap时，都知道这是key-value的存储形式，那么怎么做到key不重样，又能根据key很快的找到对应的value值呢，怎么才能做到很快的插入一个元素呢？这些需求驱动了HashMap的设计，HashMap的源码实际上是实现了哈希表这种数据结构，我们在数据结构课中学过，数组和链表是两种基本的数据结构，数组的特点是空间连续（大小固定）、寻址迅速，但是插入和删除时需要移动元素，所以查询快，增加删除慢。而链表恰好相反，可动态增加或减少空间以适应新增和删除元素，但查找时只能顺着一个个节点查找，所以增加删除快，查找慢，而哈希表是结合了两者的优点形成的一种数据结构，如下图所示：



现在来回答上面问题，怎么判断key的相同与不同，通过Object的方法hashcode和equals来保证，比如String的hashcode和equals方法，见String源码阅读，怎么保证快速查找和插入，先散列key的hashcode值，找到对应的桶，缩小范围，采用链表结构快速插入元素。

2 属性值，可以发现在jdk源码中，很喜欢用位运算，左移<<，右移>>，异或^。动态增长容量策略：先设置默认值，不满足时再扩充容量。

size是实际key-value键值对个数，这个值是加入一个元素增加一个

CAPACITY是能存储多少个键值对，这个值是动态增加

// 默认初始容量，必须是2的幂
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16

/**
* 最大容量，必须是2的幂且小于2的30次方，传入容量过大将被这个值替换
*/
static final int MAXIMUM_CAPACITY = 1 << 30;
//装载因子，默认0.75
static final float DEFAULT_LOAD_FACTOR = 0.75f;

static final Entry<?,?>[] EMPTY_TABLE = {};

/**
* 存储数据的Entry数组，长度是2的幂
*/
transient Entry<K,V>[] table = (Entry<K,V>[]) EMPTY_TABLE;

/**
* map中实际的key-value的键值对个数
*/
transient int size;
//需要调整大小的极限值（容量*装载因子）
int threshold;
// 装载因子
final float loadFactor;
// map被修改次数
transient int modCount;

3 HashMap的构造方法

//初始容量值小于0，抛异常，大于最大值，就强制改成最大值，MAXIMUM_CAPACITY
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();
}

/**
* 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 default initial capacity
* (16) and the default load factor (0.75).
*/
public HashMap() {
this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR);
}

到这里有个疑问，table是什么时候初始化的？长度是多少，怎么增长，增长策略是什么？

4 HashMap.Entry类的具体实现

Entry

static class Entry<K,V> implements Map.Entry<K,V> {
final K key;//key值
V value;//value值
Entry<K,V> next;//下一个Entry对象
int hash;//hash值

// 构造方法，在链式结构中，可以用指定下个Entry的方法将链表连成一个大链表
Entry(int h, K k, V v, Entry<K,V> 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;
}
//重写equals方法
public final boolean equals(Object o) {
if (!(o instanceof Map.Entry))
return false;
Map.Entry e = (Map.Entry)o;
// Key相等且Value相等则两个Entry相等
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;
}
//key的hashcode和value的hashcode做异或运算
public final int hashCode() {
return Objects.hashCode(getKey()) ^ Objects.hashCode(getValue());
}
//重写toString方法，使输出更清晰
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) {
}
}

5 put方法，直到put方法，才看到了用来存储数据的table的初始化工作

public V put(K key, V value) {
if (table == EMPTY_TABLE) {
//在这里初始化一个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;
}
/**
* Inflates the table.
*/
private void inflateTable(int toSize) {
// 找到一个size，是2的幂，且要大于toSize
int capacity = roundUpToPowerOf2(toSize);

threshold = (int) Math.min(capacity * loadFactor, MAXIMUM_CAPACITY + 1);
table = new Entry[capacity];
initHashSeedAsNeeded(capacity);
}
//在bucketIndex处添加新的Entry
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);
}

PS：threshold 的作用到底是什么 在源码中可以得到，threshold 的下一个值等于capacity * load factor. 即容量是16时，load factor是0.75，threshold 的值是12。为什么这个值不等于capacity呢？

例如initially default capacity = 16 , load factor = 0.75 那么threshold = (capacity * load factor) = (16 * 0.75) = 12. 当添加第13个元素时 HashMap 会resize，为什么要维持一个这样的值？ 这是查找时间和空间的tradeoff，这个问题等价于load factor的存在意义，可参见 “The Art of Computer Programming” vol 3. 因为当一个map很满时，散列和开放式寻址就会停止工作。

参考：https://stackoverflow.com/questions/27384261/in-hashmap-why-threshold-value-the-next-size-value-at-which-to-resize-is-capac

为什么要有load factor，意义在哪？

https://stackoverflow.com/questions/10901752/what-is-the-significance-of-load-factor-in-hashmap

如果确定数据的位置

int hash = hash(k.hashCode());
int i = indexFor(hash, table.length);

第一行，是得到哈希值，第二行，则是根据哈希指计算元素在数组中的位置了，位置的计算是将哈希值和数组长度按位与运算。

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

“h & (length-1)”其实这里是很有讲究的，为什么是和(length-1)进行按位与运算呢？这样做是为了提高HashMap的效率。什么？这样能提高效率？且听我细细道来。

首先我们要确定一下，HashMap的数组长度永远都是偶数，即使你在初始化的时候是这样的new HashMap(15,0.75);因为在构造函数内部，上面也讲过，有这样的一段代码

while (capacity < initialCapacity)
capacity <<= 1;

所以length-1一定是个奇数，假设现在长度为16，减去1后就是15，对应的二进制是：1111。

假设有两个元素，一个哈希值是8，二进制是1000，一个哈希值是9，二进制是1001。和1111与运算后，分别还是1000和1001，它们被分配在了数组的不同位置，这样，哈希的分布非常均匀。

那么，如果数组长度是奇数，减去1后就是偶数了，偶数对应的二进制最低位一定是0了，例如14二进制1110。对上面两个数子分别与运算，得到1000和1000。看到了吗？都是一样的值，哈希值8和9的元素多被存储在数组同一个位置的链表中。在操作的时候，链表中的元素越多，效率越低，因为要不停的对链表循环比较。所以，一定要哈希均匀分布，尽量减少哈希冲突，减少了哈希冲突，就减少了链表循环，就提高了效率。

HashMap的扩容

元素个数超过阈值，那么hashentry大小成为原来的两倍，并新建一个hashentry保存所有的元素，其中每个元素的hash值不重新计算，index会重新计算。见如下代码：

void resize(int newCapacity) {
Entry[] oldTable = table;
int oldCapacity = oldTable.length;
if (oldCapacity == MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return;
}

Entry[] newTable = new Entry[newCapacity];
transfer(newTable, initHashSeedAsNeeded(newCapacity));
table = newTable;
threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);
}
/**
* Transfers all entries from current table to newTable.
*/
void transfer(Entry[] newTable, boolean rehash) {
int newCapacity = newTable.length;
for (Entry<K,V> e : table) {
while(null != e) {
Entry<K,V> next = e.next;
if (rehash) {
e.hash = null == e.key ? 0 : hash(e.key);
}
int i = indexFor(e.hash, newCapacity);
e.next = newTable[i];
newTable[i] = e;
e = next;
}
}
}