关于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 ;
}
|