存储结构
hashmap底层是以数组方式进行存储。将key-value对作为数组中的一个元素进行存储。
key-value都是Map.Entry中的属性。其中将key的值进行hash之后进行存储，即每一个key都是计算hash值，然后再存储。每一个Hash值对应一个数组下标，数组下标是根据hash值和数组长度计算得来。
由于不能的key有可能hash值相同，即该位置的数组中的元素出现两个，对于这种情况，hashmap采用链表形式进行存储。
下图描述了hashmap的存储结构图
hashmap结构
Entry结构分析
Entry是hashMap中封装key-value键值对的，主要包括如下属性
static class Entry<K,V> implements Map.Entry<K,V> {
final K key;// map中key值，可以为null。
V value; // map中的value值，可以为null。
Entry<K,V> next;// 链表引用，防止key值不同，hash值相同。
int hash; // 每个key的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;
}
// 同一个key时，新值替换旧值，返回旧值
public final V setValue(V newValue) {
V oldValue = value;
value = newValue;
return oldValue;
}
// key值重写equals方法
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;
}
// 重写hashCode值
public final int hashCode() {
return Objects.hashCode(getKey()) ^ Objects.hashCode(getValue());
}
public final String toString() {
return getKey() + "=" + getValue();
}
// 其他方法省略
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
HashMap属性分析
HashMap的属性分析
public class HashMap<K,V>
extends AbstractMap<K,V>
implements Map<K,V>, Cloneable, Serializable
{
/**
*默认情况下，hashmap大小为16.即1<<4就是1乘以2的4次幂=16
*/
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
/**
* hashMap的最大值
*/
static final int MAXIMUM_CAPACITY = 1 << 30;
/**
* 默认加载加载因子，即使用空间达到总空间的0.75时，需要扩容。
*/
static final float DEFAULT_LOAD_FACTOR = 0.75f;
/**
* 声明hashmap一个空数组。
*/
static final Entry<?,?>[] EMPTY_TABLE = {};
/**
* 最开始时，hashmap是一个空数组。
*/
transient Entry<K,V>[] table = (Entry<K,V>[]) EMPTY_TABLE;
/**
* map的元素的个数
*/
transient int size;
/*
* hashmap的实际存储空间大小。这个空间是总空间*加载因子得出的大小。
* 比如默认是16，加载因子是0.74。则threshold就是12。
*/
int threshold;
/**
* 加载因子，即使用空间达到总空间的0.75时，需要扩容。
*/
final float loadFactor;
/**
*
*/
transient int modCount;
/**
* threshold这个值的最大值就是Integer.MAX_VALUE
*/
static final int ALTERNATIVE_HASHING_THRESHOLD_DEFAULT = Integer.MAX_VALUE;
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
put方法
put（key,value）方法是hashmap中最重要的方法，使用hashmap最主要的就是使用put,get两个方法。put方法底层存储又是什么呢，我们可以从put方法的源码进行分析
public V put(K key, V value) {
// 首次存储元素，初始化存储空间
if (table == EMPTY_TABLE) {
inflateTable(threshold);
}
// 如果key为null，则将null放入元素的第一个位置
if (key == null)
return putForNullKey(value);
// 计算key的hash值
int hash = hash(key);
// 根据key的hash值，数组长度计算该Entry<key,value>的数组下标
int i = indexFor(hash, table.length);
/**
**如果当前key的已经存在于map中，则将新值替换成旧值。
**/
for (Entry<K,V> e = table[i]; e != null; e = e.next) {
Object k;
// 判断同一个key，既要判断hash值相同，还要判断key是同一个key，因为
// 相同的key有可能hash值也相同。双重判断保证是同一个key。
if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
V oldValue = e.value;
e.value = value;
e.recordAccess(this);
return oldValue;
}
}
// 如果是新的key需要存储，则增加操作次数modCount++
modCount++;
// 将新增key-value键值对添加中map中。
addEntry(hash, key, value, i);
return null;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
addEntry方法
addEntry方法是将新增的key-value键值对存入到map中。该方法主要完成两个功能：
1.1. 添加新元素前， 判断是否需要对map的数组进行扩容，如果需要扩容，则扩容空间大小是多少?
1.2. 对于新增key-value键值对，如果key的hash值相同，则构造单向列表。
从源码分析结果如下：
/**
** hash:key的hash值
** key:存储的键
** value：存储的value对象值
*** bucketIndex：数组下标位置，即key-value在数组中的位置。
**/
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);
}
// 往数组中添加新的key-value键值对
createEntry(hash, key, value, bucketIndex);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
createEntry
该方法主要完成两个功能，第一是添加新的key到Entry数组中，第二就是对于不同key的hash值相同的情况下，在同一个数组下标处，构建单向链表进行存储。
void createEntry(int hash, K key, V value, int bucketIndex) {
// 取出当前位置的元素，如果是新添加的key,则e为null，已经有的元素为不为空。
Entry<K,V> e = table[bucketIndex];
// 添加新的key-value值或构建链表
table[bucketIndex] = new Entry<>(hash, key, value, e);
size++;
}
1
2
3
4
5
6
7
8
