java中HashMap实现原理

1.Hashmap实现的数据结构

hashmap实现的数据结构是采用数组加链表的方式，它即具有数组的快速查询的寻址特点，又具有链表的删除和添加的快速移动的优点。但是它的效率是介于数组和链表

之间的。实现如图：





hashmap中是以Entry<K,V> 内部类数组形式存储实现，源码：

static class Entry<K,V> implements Map.Entry<K,V> {
final K key;
V value;
Entry<K,V> next;//对下一个节点的引用（看到链表的实现）
final int hash;//哈希值

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;//返回的是之前的Value
}

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();
// Key相等且Value相等则两个Entry相等
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;
}
// hashCode是Key的hashCode和Value的hashCode的异或的结果
public final int hashCode() {
return (key==null   ? 0 : key.hashCode()) ^
(value==null ? 0 : value.hashCode());
}
// 重写toString方法，是输出更清晰
public final String toString() {
return getKey() + "=" + getValue();
}

/**
*当调用put(k,v)方法存入键值对时，如果k已经存在，则该方法被调用（为什么没有内容？）
*/
void recordAccess(HashMap<K,V> m) {
}

/**
* 当Entry被从HashMap中移除时被调用（为什么没有内容？）
*/
void recordRemoval(HashMap<K,V> m) {
}
}

hashmap的put()方法：

public V put(K key, V value) {
if (key == null)
return putForNullKey(value);
int hash = hash(key.hashCode());
int i = indexFor(hash, table.length);//得到对应key值在数组中的位置，（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);//如果不包含key值，则插入到hashmap中
return null;
}

hashmap的get()方法：

public V get(Object key) {
if (key == null)
return getForNullKey();
int hash = hash(key.hashCode());

//遍历table
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.equals(k)))
return e.value;
}
return null;
}

2.hashmap扩容

当HashMap中的元素越来越多的时候，hash冲突的几率也就越来越高，因为数组的长度是固定的。所以为了提高查询的效率，就要对HashMap的数组进行扩容，数组扩容这个操作也会出现在ArrayList中，这是一个常用的操作，而在HashMap数组扩容之后，最消耗性能的点就出现了：原数组中的数据必须重新计算其在新数组中的位置，并放进去，这就是resize。

那么HashMap什么时候进行扩容呢？当HashMap中的元素个数超过数组大小*loadFactor时，就会进行数组扩容，loadFactor的默认值为0.75，这是一个折中的取值。也就是说，默认情况下，数组大小为16，那么当HashMap中元素个数超过16*0.75=12的时候，就把数组的大小扩展为 2*16=32，即扩大一倍，然后重新计算每个元素在数组中的位置，而这是一个非常消耗性能的操作，所以如果我们已经预知HashMap中元素的个数，那么预设元素的个数能够有效的提高HashMap的性能。