本文深入探讨了HashMap的工作原理，包括其内部结构、初始化参数选择、扩容机制、hash碰撞处理等内容。
关于hashmap在平时写代码的时候经常用，但是hashmap的一些原理貌似知道的不是很多，翻了下代码，得出如下结论。
（1）HashMap是啥？
HashMap是基于哈希表的Map实现，能够满足所有的Map操作，同时支持空的key和空的value，非线程安全的，
不保证map中键值的顺序，特别是不保证顺序是不变的（翻译自java 源代码）。
（2）如果Map<K,V> map = new HashMap<K,V>()这种情况，容器默认参数是啥？
源代码查看，有三个常量，
static final int DEFAULT_INITIAL_CAPACITY = 16;
static final int MAXIMUM_CAPACITY = 1 << 30;
static final float DEFAULT_LOAD_FACTOR = 0.75f;
三个常量中可以看出，默认的容器大小是16，最大长度是2的30次方，load factor默认是0.75，扩充的临界值是16*0.75=12
（3）如果已经知道Map的大小，如何提升性能？
HashMap的实例有两个参数影响着他的性能，
一个是initial capacity
（初始化容量，容量是哈希表中的空间数，初始化容量是HashMap创建的时候的大小，当然，后面是会自动扩容的）；
一个是load factor
（负荷系数，当目前的容量达到负荷系数的时候，重新build，扩充到原来的两倍）。
通用的规则，laod factor默认是0.75，在空间和时间上面一个不错的权衡。
如果确定有很多mapping的数据放在HashMap的实例里面，初始化的时候创建一个大一点的容量比hashmap自己去扩容要有效的多。
因为在数组扩充的时候，会重新new一个数组出来，然后老数组数据重新赋值到新数组，转换成本消耗资源。
（4）如果自定义initial capacity的大小，如果保证Map大小是2的指数次方？
这个看HashMap的构造行数，
如下，通过while循环，初始值1的移位来使大小始终是2的指数次，初始化的数组大小是小于入参的最大的2的指数次。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
|
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)){//如果laodFactor小于等于零或者不是number，抛异常 throw new IllegalArgumentException("Illegal
load factor: " +
loadFactor); } /** *
这里设计比较巧妙了，保证HashMap的大小始终是2的指数次 *
经过这个while处理后，初始化的数组是大于这个值的最小的2的指数 *
例子：如果initialCapacity=13,则2进制数值有2、4、8、16，大约13的是16，则此时初始化的数组大小是16 */ int capacity
= 1; while (capacity
< initialCapacity){ capacity
<<= 1; } this.loadFactor
= loadFactor; threshold
= (int)(capacity
* loadFactor); table
= new Entry[capacity]; init(); } |
（5）为什么HashMap的大小要是2的指数次呢？
key经过hash后，可以取模来进行放入数组，也不会出现越界的情况，
之所以没有使用取模，而是按位与的形式，是因为计算机的二进制运算效率比取模效率高。
如果Map的大小不是2的进制，我们设置为7
7的二进制是：111，（length-1）大小是6，按位与是和6进行，6的二进制是：110
结果如下，有些数组中的位置没有被设置，有些重复了，一是导致空间浪费，同时增加了碰撞的几率。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
for(int i=0;i<10;i++){ System.out.println ("数值i="+i+",
二进制="+Integer.toBinaryString(i)+"（"+Integer.toBinaryString(6)+"）"+"
,和6按位与="+(i&6));} 数值i=0,
二进制=0（110）
,和6按位与=0数值i=1,
二进制=1（110）
,和6按位与=0数值i=2,
二进制=10（110）
,和6按位与=2数值i=3,
二进制=11（110）
,和6按位与=2数值i=4,
二进制=100（110）
,和6按位与=4数值i=5,
二进制=101（110）
,和6按位与=4数值i=6,
二进制=110（110）
,和6按位与=6数值i=7,
二进制=111（110）
,和6按位与=6数值i=8,
二进制=1000（110）
,和6按位与=0数值i=9,
二进制=1001（110）
,和6按位与=0 |
然后我们设置8，（length-1）大小是7,7的二进制是111，打印看结果，空间充分利用，并且减少了碰撞的几率。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
for(int i=0;i<10;i++){ System.out.println( "数值i="+i+",
二进制="+Integer.toBinaryString(i)+"（"+Integer.toBinaryString(7)+"）"+"
,和7按位与="+(i&7));}数值i=0,
二进制=0（111）
,和7按位与=0数值i=1,
二进制=1（111）
,和7按位与=1数值i=2,
二进制=10（111）
,和7按位与=2数值i=3,
二进制=11（111）
,和7按位与=3数值i=4,
二进制=100（111）
,和7按位与=4数值i=5,
二进制=101（111）
,和7按位与=5数值i=6,
二进制=110（111）
,和7按位与=6数值i=7,
二进制=111（111）
,和7按位与=7数值i=8,
二进制=1000（111）
,和7按位与=0数值i=9,
二进制=1001（111）
,和7按位与=1 |
（6）HashMap的整体结构啥样？
整体情况见下图，包括继承实现关系以及属性等。
1、HashMap中包含了一个Entry的数组，是存放数据的地方，每一个数组元素是一个Entry对象，Entry中有属性next，
如果两个key经过hash后，在数组中index相同，则会保存在同一个位置，通过next属性来形成链表结构。
2、size是数组的大小，threshold是数组扩充的阀值，modCount是table被修改的次数，这个在迭代器中有用，
loadFactor是数组扩充阀值系数，threshold=loadFactor*table.length。
（7）HashMap的添加属性以及扩容是如何进行的？
废话少说，直接上代码。
1、添加属性的时候，如果两个key的index位置相同，则会通过链表保存在同一个数据元素中，而后添加的在链表的前面
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
void addEntry(int hash,
K key, V value, int bucketIndex)
{ /** *
首先把index中的值赋予一个对象e， *
从这里能够看出，如果两个key的hash值相同，那么在数组中的位置index会相同， *
那此时这两个key就需要组成链条来同时保存在这一个位置中， *
后一个添加的Entry总是在链条的第一个 */ Entry<K,V>
e = table[bucketIndex]; table[bucketIndex]
= new Entry<K,V>(hash,
key, value, e); //如果目前数组的长度大于阀值，则进行resize，扩充为原来的2倍 if (size++
>= threshold){ resize(2 *
table.length); } } |
2、在添加属性的时候，每次都会判断一下是否需要扩容，若果达到了阀值，则进行扩容，
扩容的时候会重新new一个table出来，然后新老数据数据进行转换，
调用transfer方法，transfer方法通过循环遍历的形式记性数据的“交接”，
注意一点，while里面的代码会造车在多线程并发下put出现死循环情况，如果涉及到多线程put情况，不要使用HashMap。
|
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
|
void resize(int newCapacity)
{//table的数组容量大于了阀值threshold,则进行扩充，变为原来的2倍； Entry[]
oldTable = table; int oldCapacity
= oldTable.length; if (oldCapacity
== MAXIMUM_CAPACITY) {//如果已经达到了最大值，则threshold为Integer最大值，数组不进行扩充 threshold
= Integer.MAX_VALUE; return; } Entry[]
newTable = new Entry[newCapacity]; //新老数组数据转换，将老数组中的数据赋予新的table transfer(newTable); //将新的table赋值给引用，每次扩充，需要重新new一个数组，抛弃原先的数组 table
= newTable; threshold
= (int)(newCapacity
* loadFactor); } void transfer(Entry[]
newTable) { Entry[]
src = table; int newCapacity
= newTable.length; //循环遍历数组中的每个Entry for (int j
= 0;
j < src.length; j++) { Entry<K,V>
e = src[j]; if (e
!= null)
{ src[j]
= null; /** *
while循环遍历一个数组元素的链表，把原来链表的顺序反置了 *
多线程并发put下，在进行扩充的时候，会造成死循环； *
Entry1-->Entry2-->null 正常情况下，顺序反置回事Entry2-->Entry1-->null *
多线程下会出现：Entry1-->Entry2，Entry2-->Entry1的情况，在while处造成死循环 */ do { Entry<K,V>
next = e.next; //从这里看出，元素在数组中的位置重新进行了计算 int i
= indexFor(e.hash, newCapacity); e.next
= newTable[i]; newTable[i]
= e; e
= next; } while (e
!= null); } } } |
（8）hash碰撞问题HashMap如何解决的？
传入的数据，会出现key经过hash后，hash值相同，这就是hash碰撞问题，
HashMap如何解决这种碰撞问题的呢，看代码可以得出结论。
每个数组元素是一个Entry对象，对象中有个next的应用，指向下一个，对于hash值相同，则在Entry中以链表的形式进行存储。
见put函数代码：
|
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
|
public V
put(K key, V value) { //如果key是null，则调用单独的方法 if (key
== null){ return putForNullKey(value); } //获取key的hash值，通过key值的hashCode值来进行高位转换 int hash
= hash(key.hashCode()); //通过hash值和数组长度进行按位与，获取这个key值在数据中的位置 int i
= indexFor(hash, table.length); /** *
获取数组中index为i的Entry，如果entry不为空，则进行判断是否相同，如果相同则新老value进行替换； *
这里有个for循环，因为一个数据元素中可能保存了一个Entry的链表 */ for (Entry<K,V>
e = table[i]; e != null;
e = e.next) { Object
k; //hash值相同，并且==或者equals，则表明两个对象相同 if (e.hash
== hash && ((k = e.key) == key || key.equals(k))) { V
oldValue = e.value; e.value
= value; e.recordAccess(this); return oldValue; } } //如果index为i的数组中是null，则调用addEntry来添加新的Entry modCount++; //传入这个entry的hash值，KV，以及在数组中的位置 addEntry(hash,
key, value, i); return null; } |
扫一扫
43万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
