详解HashMap

最新推荐文章于 2025-07-22 23:09:56 发布

原创最新推荐文章于 2025-07-22 23:09:56 发布 · 348 阅读

本内容遵循CC 4.0 BY-SA版权协议

HashMap是基于哈希表的Map接口的实现，以key-value的形式存在；
在hashmap中，key-value会当做一个整体来处理，系统会根据hash算法计算key-value的存储位置，可以通过key快速的存、取value。
从结构上讲，在JDK1.8之前是用数组（Node[],存放键值对）+链表的方式实现；jdk1.8后加了红黑树，hashmap数组的默认初始长度是16，
hashmap只允许一个key为null，允许多个value为null。
hashmap是用hash表来存储的，在hashmap里为解决hash冲突，使用链地址法（数组+链表的形式：当数据被hash后，得到数组下标，把数据放在对应下表的链表中）

HashMap的定义：

hashmap实现了map接口，继承AbstractMap。结构如下：
public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>,Cloneable,Serializable

构造函数：
HashMap提供了三个构造函数：

HashMap():构造一个具有默认初始容量（initialCapacity: 16）和默认加载因子（loadFactory:0.75）的空HashMap；
HashMap（int initialCapacity）:构造一个带指定初始容量和默认加载因子是0.75的空HashMap；
HashMap（int initialCapacity,float loadFactory）:构造一个带指定初始容量和加载因子的空HashMap；

初始容量和加载因子是影响HashMap性能的重要参数；
容量：哈希表中桶的数量；
加载因子：哈希表在其容量自动增加之前可以达到多满的一种尺度；衡量的是散列表的空间的使用程度。
负载因子越大，对空间的利用率更充分，但是查找小效率降低；
负载因子太小，会造成对空间的浪费。

HashMap的数据结构：

HashMap是一个“链表散列”，内部结构：是数组和链表结合的复合结构；
数组被分为一个个桶（bucket），通过哈希值决定了键值对在这个数组中的寻址；
哈希值相同的键值对，则以链表的形式存储；若链表大小超过阈值（TREEIFY_THRESHOLD，8）图中的链表改为树形结构。

HashMap构造函数的源码：
public HashMap(int initialCapacity, float loadFactor) {
        //初始容量不能<0
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal initial capacity: "+ initialCapacity);
        //初始容量不能 > 最大容量值，HashMap的最大容量值为2^30
        if (initialCapacity > MAXIMUM_CAPACITY)
            initialCapacity = MAXIMUM_CAPACITY;
        //负载因子不能 < 0
        if (loadFactor <= 0 || Float.isNaN(loadFactor))
            throw new IllegalArgumentException("Illegal load factor: "+ loadFactor);
 // 计算出大于 initialCapacity 的最小的 2 的 n 次方值。
        int capacity = 1;
        while (capacity < initialCapacity)
            capacity <<= 1;

	this.loadFactor = loadFactor;
        //设置HashMap的容量极限，当HashMap的容量达到该极限时就会进行扩容操作
        threshold = (int) (capacity * loadFactor);
        //初始化table数组
        table = new Entry[capacity];
        init();
每次新建一个 HashMap，都会初始化一个table数组，table数组的元素为Entry节点；
Entry是HashMap的内部类，它包含了key，value，下一个节点next，以及hash值。
正是因为Entry才构成了table数组的项是链表。

结构如下：

在这里插入图片描述

HashMap的存取实现：
1.put(K key,V value)；

public V put(K key, V value) {
 	return putVal(hash(key), key, value, false, true);
}
putVal中的hash(key)，是将key的hashcode（由native方法计算）再与该值的高16位进行异或运算得到最终的hash值。目的是：通常的hash算法总是碰撞，这样做可以使hash值较为分散，减少碰撞。

2.解析putVal方法：

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                 boolean evict) {
      Node<K,V>[] tab; Node<K,V> p; int n, i;
// 如果map还是空的，则先开始初始化，table是map中用于存放索引的表
     if ((tab = table) == null || (n = tab.length) == 0) {
         n = (tab = resize()).length;
      }
 // 异或得到的数组下标表示计算现在的key会存放到这个位置；hash值获取的结点为空，则新建一个结点； 其中n是一个2的幂次数；      
  if ((p = tab[i = (n - 1) & hash]) == null)     
   tab[i] = newNode(hash, key, value, null);        
 // 如果走到else这一步，说明key索引到的数组位置上已经存在内容，即出现了碰撞，这个时候需要更为复杂处理碰撞的方式来处理，如链表和树
 else {          
   Node<K,V> e; K k;            
//其中p已经在上面通过计算索引找到了，即发生碰撞的那个节点；如果新插入的结点和table中p结点的hash值，而且key值也相同的话或者是key不等于null的情况下key值也相同，则说明两个key是一样的，则当前节点p用临时节点e保存。            
   if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k))))               
    e = p;
// 如果当前节点p是（红黑）树类型的节点，则需要特殊处理；如果是树，则说明碰撞已经开始用树来处理，后续的数据结构都是树而非列表了
 else if (p instanceof TreeNode)      
 //其中this表示当前hashmap,tab为map中的数组。          
 e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);            
 else {                
 for (int binCount = 0; ; ++binCount{                    // 如果当前碰撞的节点没有后续节点，则直接新建节点并追加。               
 if ((e = p.next) == null) {                       
  p.next = newNode(hash, key, value, null);                        
  // 链表长度大于TREEIFY_THRESHOLD（8）时，将链表转红黑树，                       
   if (binCount >= TREEIFY_THRESHOLD - 1)                          
   treeifyBin(tab, hash);                        	break;                    
   }  
   //找到了碰撞节点中，key完全相同的节点，则用新节点替换老节点。                 
    if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k))))                        	break;                    
          p = e;              
 	}            
}
//此时的e是保存的被碰撞的那个节点，即老节点。
 if (e != null) { 
        V oldValue = e.value;               
      // 判断是否允许覆盖，并且value是否为空     ；onlyIfAbsent是方法的调用参数，表示是否替换已存在的值，          
        if (! onlyIfAbsent || oldValue == null)                    
        e.value = value;   
        afterNodeAccess(e);     
        // 回调以允许LinkedHashMap后置操作                
        return oldValue;           
         }       
  } 
// map变更性操作计数器         
  ++modCount;     // 更改操作次数
// size即map中包括key-value数量的多少； 当map中的内容大小已经触及到扩容阈值时，则需要扩容了
if (++size > threshold)     // 大于临界值          
  // 将数组大小设置为原来的2倍，并将原先的数组中的元素放到新数组中; 因为有链表，红黑树之类，因此还要调整他们           
   resize();          
   // 回调以允许LinkedHashMap后置操作        
   afterNodeInsertion(evict);       
    return null;   
     }

3.解析扩充数组长度方法resize()方法，会将整个map中的key-value对进行重新的散列存储，会消耗性能；

final Node<K,V>[] resize() { 
// 获取旧元素数组的各种信息        
	Node<K,V>[] oldTab = table;       
// 长度            
	int oldCap = (oldTab == null) ? 0 : oldTab.length;        
// 扩容的临界值       
	int oldThr = threshold;        
// 定义新数组的长度及扩容的临界值        
	int newCap, newThr = 0;        
	if (oldCap > 0) {   
// 如果原table不为空            
//如果已经到了最大容量了，那么就调整扩容的threshold阈值
	 if (oldCap >= MAXIMUM_CAPACITY) {               
	threshold=Integer.MAX_VALUE;                	return oldTab;           
}            
// 否则的话，如果将目前的容量扩充2倍还在允许范围之内，则将容量扩充为原来的两倍，并且阈值也为原来的两倍；
	 else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY && oldCap >= DEFAULT_INITIAL_CAPACITY)               
	    newThr = oldThr << 1;      
}
// 如果原始（或者初始）容量不大于0，且之前的阈值大于0，则将容量初始化为之前阈值的大小；
 	else if (oldThr > 0) 
 	 newCap = oldThr;        
 	 else {              
// 执行这里的方法说明，初始参数中容量大小和阈值都不大于0，那么就用map中的缺省值；
	newCap=DEFAULT_INITIAL_CAPACITY;              	
	newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);        
	}        
如果新的阈值没有重新计算，那么先用加载因子计算出值;如果新的容量大小和阈值大小都未超过限定值，则计算出的值可用，否则阈值就限定为容量真正允许的上限即Integer.MAX_VALUE
	if (newThr == 0) { 
	   float ft = (float)newCap * loadFactor;            
	   newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?  (int)ft : Integer.MAX_VALUE);       
	    }        
	    threshold = newThr; // 更新填充因子                
	    Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];  
	    //// table已经是扩容好的新table了;老的table存在了oldTab中
 	table = newTab;
// 以下就是一个重新散列存储的过程了;将老的tab中的node，按照key重新散列得到新得存储地址来存储，以此来完成扩充.这是扩容的一个主要开销来源。

HashMap的put方法流程总结：

1. put(key,value)中直接调用了内部的putVal()方法，并且对key进行了hash操作；
2. putVal()方法中，先检查hashmap数据结构中的索引数组表是否为空，如果是的话则进行一次resize()扩容操作；
3. 以hashmap索引数组表的长度-1余key的hash值进行按位与运算，得出在数组中的索引，如果索引指定的位置值为空，则创建一个key-value的新节点；
4. 如果不满足3，则表示索引指定的数组位置已经存在内容，这时候会出现碰撞。
5. 之后计算hashmap全局的modCount值，以便对外部并发的迭代操作提供修改的fail-fast判断提供依据，与此同时增加map中的记录数，并判断记录数是否触及到容量扩充的阈值，触及的话则进行一次resize()操作；
6. 若在步骤4中出现碰撞的情况，从步骤7则开启新一轮逻辑处理；
7. 判断key索引到的节点（碰撞节点）的hash值、key是否与当前新节点一致，若一致的话，则保存记录该节点；
	若新旧节点的内容不同时，则看碰撞节点是否是树类型，如果是树的话，则按照树的操作取追加新节点内容；如果不是树的类型，则说明当前发生的碰撞在链表中（链表尚未转为红黑树），此时进入步骤8一组循环操作；
8. 循环中，先判断被碰撞的节点的后继节点是否为空，为空则将新节点作为后继节点，作为后继节点后判断当前链表长度是否超过最大允许链表长度8，如果大于的话，则需要进行一轮是否转树的操作；
如果被碰撞的节点的后继节点不为空，则先判断后继节点是否与新节点相同，相同的话就记录并跳出循环；若后继节点不为空，且后继节点与新节点不同的话，则继续循环，直到进入某一个条件然后跳出循环；
9. 步骤8中的转树的操作treeifBin，如果map的索引表为空或当前索引长度小于64（最大转红黑树的索引数组表长度），那么进行resize()操作，否则，如果被碰撞节点不为空，那么就顺着被撞节点的这条树往后新增该新节点；
10.最后，被碰撞的节点，若不为空，默认情况下，新节点的值会替换被碰撞节点的值。同时返回被碰撞节点的值。

为什么么我们需要在乎容量和
负载因子呢？

这是因为容量和负载系数决定了可用的桶的数量，空桶太多会浪费空间，如果使用的太满则会严重影响操作的性能。极端情况下，假设只有一个桶，那么它就退化成了链表，完全不能提供所谓常数时间存的性能。
负载因子 * 容量 > 元素数量
所以，预先设置的容量需要满足，大于“预估元素数量 / 负载因子”，同时它是 2 的幂数，

树化：

final void treeifyBin(Node<K,V>[] tab, int hash) { 			   		        		    
		int n, index; 
		Node<K,V> e; 
       if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY) 
       resize(); 
       else if ((e = tab[index = (n - 1) & hash]) != null) { 
       // 树化改造逻辑
        }

树化逻辑：
当 bin 的数量大于 TREEIFY_THRESHOLD 时：
如果容量小于 MIN_TREEIFY_CAPACITY，只会进行简单的扩容。
如果容量大于 MIN_TREEIFY_CAPACITY ，则会进行树化改造。

为什么要进行树化？
本质是个安全问题；因为在元素放置过程中，如果一个对象哈希冲突，都被放置到同一个桶里，则会形成一个链表，链表查询是线性的会严重影响存取的性能。

hashmap大小为什么是2的幂次方？

在putVal方法中，计算插入元素在hash桶数组的索引时，为了使元素分布的更加均匀，用取模操作； 优化为 (n - 1) & hash，设置为2的幂次方，是因为2的幂次方-1后的值每一位上都是1，然后与前面计算得到的hash值进行与运算的时候，最终的结果只和key的hashcode值本身有关；这样不会造成空间浪费并且分布均匀；
 if ((p = tab[i = (n - 1) & hash]) == null) 

如果length不为2的幂，比如15。那么length-1的2进制就会变成1110。在h为随机数的情况下，和1110做&操作。尾数永远为0。那么0001、1001、1101等尾数为1的位置就永远不可能被entry占用。这样会造成浪费，不随机等问题。