JDK1.8源码(三)——java.util.HashMap
什么是哈希表?
在讨论哈希表之前,我们先大概了解下其他数据结构在新增,查找等基础操作执行性能
数组:采用一段连续的存储单元来存储数据。对于指定下标的查找,时间复杂度为O(1);通过给定值进行查找,需要遍历数组,逐一比对给定关键字和数组元素,时间复杂度为O(n),当然,对于有序数组,则可采用二分查找,插值查找,斐波那契查找等方式,可将查找复杂度提高为O(logn);对于一般的插入删除操作,涉及到数组元素的移动,其平均复杂度也为O(n)
线性链表:对于链表的新增,删除等操作(在找到指定操作位置后),仅需处理结点间的引用即可,时间复杂度为O(1),而查找操作需要遍历链表逐一进行比对,复杂度为O(n)
二叉树:对一棵相对平衡的有序二叉树,对其进行插入,查找,删除等操作,平均复杂度均为O(logn)。
哈希表:相比上述几种数据结构,在哈希表中进行添加,删除,查找等操作,性能十分之高,不考虑哈希冲突的情况下,仅需一次定位即可完成,时间复杂度为O(1),接下来我们就来看看哈希表是如何实现达到惊艳的常数阶O(1)的。
我们知道,数据结构的物理存储结构只有两种:顺序存储结构和链式存储结构(像栈,队列,树,图等是从逻辑结构去抽象的,映射到内存中,也这两种物理组织形式),而在上面我们提到过,在数组中根据下标查找某个元素,一次定位就可以达到,哈希表利用了这种特性,哈希表的主干就是数组。
比如我们要新增或查找某个元素,我们通过把当前元素的关键字 通过某个函数映射到数组中的某个位置,通过数组下标一次定位就可完成操作。
存储位置 = f(关键字)
其中,这个函数f一般称为哈希函数,这个函数的设计好坏会直接影响到哈希表的优劣。举个例子,比如我们要在哈希表中执行插入操作:
查找操作同理,先通过哈希函数计算出实际存储地址,然后从数组中对应地址取出即可。
哈希冲突
然而万事无完美,如果两个不同的元素,通过哈希函数得出的实际存储地址相同怎么办?也就是说,当我们对某个元素进行哈希运算,得到一个存储地址,然后要进行插入的时候,发现已经被其他元素占用了,其实这就是所谓的哈希冲突,也叫哈希碰撞。前面我们提到过,哈希函数的设计至关重要,好的哈希函数会尽可能地保证 计算简单和散列地址分布均匀,但是,我们需要清楚的是,数组是一块连续的固定长度的内存空间,再好的哈希函数也不能保证得到的存储地址绝对不发生冲突。那么哈希冲突如何解决呢?哈希冲突的解决方案有多种:开放定址法(发生冲突,继续寻找下一块未被占用的存储地址),再散列函数法,链地址法,而HashMap即是采用了链地址法,也就是数组+链表的方式。
什么是HashMap?
HashMap 是一个利用哈希表原理来存储元素的集合。遇到冲突时,HashMap 是采用的链地址法来解决,在 JDK1.7 中,HashMap 是由 数组+链表构成的。但是在 JDK1.8 中,HashMap 是由 数组+链表+红黑树构成,新增了红黑树作为底层数据结构,结构变得复杂了,但是效率也变的更高效。下面我们来具体介绍在 JDK1.8 中 HashMap 是如何实现的。
HashMap定义
HashMap 是一个散列表,它存储的内容是键值对(key-value)映射,而且 key 和 value 都可以为 null。
public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable
蓝色实线箭头是指Class继承关系
绿色实线箭头是指interface继承关系
绿色虚线箭头是指接口实现关系
字段属性
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
//默认 HashMap 集合初始容量为16(必须是 2 的倍数) static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16 //集合的最大容量,如果通过带参构造指定的最大容量超过此数,默认还是使用此数 static final int MAXIMUM_CAPACITY = 1 << 30; //默认的填充因子 static final float DEFAULT_LOAD_FACTOR = 0.75f; //当桶(bucket)上的结点数大于这个值时会转成红黑树(JDK1.8新增) static final int TREEIFY_THRESHOLD = 8; //当桶(bucket)上的节点数小于这个值时会转成链表(JDK1.8新增) static final int UNTREEIFY_THRESHOLD = 6; /**(JDK1.8新增) * 当集合中的容量大于这个值时,表中的桶才能进行树形化 ,否则桶内元素太多时会扩容, * 而不是树形化 为了避免进行扩容、树形化选择的冲突,这个值不能小于 4 * TREEIFY_THRESHOLD */ static final int MIN_TREEIFY_CAPACITY = 64;
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
//初始化使用,长度总是 2的幂 transient Node<K,V>[] table; //保存缓存的entrySet() transient Set<Map.Entry<K,V>> entrySet; //此映射中包含的键值映射的数量。(集合存储键值对的数量) transient int size; /** * 跟前面ArrayList和LinkedList集合中的字段modCount一样,记录集合被修改的次数 * 主要用于迭代器中的快速失败 */ transient int modCount; //调整大小的下一个大小值(容量*加载因子)。capacity * load factor int threshold; //散列表的加载因子。 final float loadFactor;
①、Node<K,V>[] table
我们说 HashMap 是由数组+链表+红黑树组成,这里的数组就是 table 字段。后面对其进行初始化长度默认是 DEFAULT_INITIAL_CAPACITY= 16。
②、size
集合中存放key-value 的实时对数。
③、loadFactor
装载因子,是用来衡量 HashMap 满的程度,计算HashMap的实时装载因子的方法为:size/capacity,而不是占用桶的数量去除以capacity。capacity 是桶的数量,也就是 table 的长度length。
默认的负载因子0.75 是对空间和时间效率的一个平衡选择,建议大家不要修改,除非在时间和空间比较特殊的情况下,如果内存空间很多而又对时间效率要求很高,可以降低负载因子loadFactor 的值;相反,如果内存空间紧张而对时间效率要求不高,可以增加负载因子 loadFactor 的值,这个值可以大于1。
④、threshold
计算公式:capacity * loadFactor。这个值是当前已占用数组长度的最大值。过这个数目就重新resize(扩容),扩容后的 HashMap 容量是之前容量的两倍
构造函数
①、无参构造函数
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
/** * 默认构造函数,初始化加载因子loadFactor = 0.75 */ public HashMap() { this.loadFactor = DEFAULT_LOAD_FACTOR; }
②、指定初始容量的构造函数
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
/** * * @param initialCapacity 指定初始化容量 * @param loadFactor 加载因子 0.75 */ public HashMap(int initialCapacity, float loadFactor) { //初始化容量不能小于 0 ,否则抛出异常 if (initialCapacity < 0) throw new IllegalArgumentException("Illegal initial capacity: " + initialCapacity); //如果初始化容量大于2的30次方,则初始化容量都为2的30次方 if (initialCapacity > MAXIMUM_CAPACITY) initialCapacity = MAXIMUM_CAPACITY; //如果加载因子小于0,或者加载因子是一个非数值,抛出异常 if (loadFactor <= 0 || Float.isNaN(loadFactor)) throw new IllegalArgumentException("Illegal load factor: " + loadFactor); this.loadFactor = loadFactor; //tableSizeFor()的主要功能是返回一个比给定整数大且最接近的2的幂次方整数,如给定10,返回2的4次方16. this.threshold = tableSizeFor(initialCapacity); } // 返回大于等于initialCapacity的最小的二次幂数值。 // >>> 操作符表示无符号右移,高位取0。 // | 按位或运算 static final int tableSizeFor(int cap) { int n = cap - 1; n |= n >>> 1; n |= n >>> 2; n |= n >>> 4; n |= n >>> 8; n |= n >>> 16; return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1; }
添加元素
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
//hash(key)获取Key的哈希值,equls返回为true,则两者的hashcode一定相等,意即相等的对象必须具有相等的哈希码。 public V put(K key, V value) { return putVal(hash(key), key, value, false, true); } /** * * @param hash Key的哈希值 * @param key 键 * @param value 值 * @param onlyIfAbsent true 表示不要更改现有值 * @param evict false表示table处于创建模式 * @return */ final V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict) { Node<K,V>[] tab; Node<K,V> p; int n, i; //如果table为null或者长度为0,则进行初始化 //resize()方法本来是用于扩容,由于初始化没有实际分配空间,这里用该方法进行空间分配,后面会详细讲解该方法 if ((tab = table) == null || (n = tab.length) == 0) n = (tab = resize()).length; //(n - 1) & hash:确保索引在数组范围内,相当于hash % n 的值 //通过 key 的 hash code 计算其在数组中的索引:为什么不直接用 hash 对 数组长度取模?因为除法运算效率低 if ((p = tab[i = (n - 1) & hash]) == null) tab[i] = newNode(hash, key, value, null);//tab[i] 为null,直接将新的key-value插入到计算的索引i位置 else {//tab[i] 不为null,表示该位置已经有值了 Node<K,V> e; K k; //e节点表示已经存在Key的节点,需要覆盖value的节点 //table[i]的首个元素是否和key一样,如果相同直接覆盖value if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k)))) e = p;//节点key已经有值了,将第一个节点赋值给e //该链是红黑树 else if (p instanceof TreeNode) e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value); //该链是链表 else { //遍历链表 for (int binCount = 0; ; ++binCount) { //先将e指向下一个节点,然后判断e是否是链表中最后一个节点 if ((e = p.next) == null) { 创建一个新节点加在链表结尾 p.next = newNode(hash, key, value, null); //链表长度大于8,转换成红黑树 if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st treeifyBin(tab, hash); break; } //key已经存在直接终止,此时e的值已经为 p.next if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k)))) break; p = e; } } if (e != null) { // existing mapping for key V oldValue = e.value; if (!onlyIfAbsent || oldValue == null) //修改已经存在Key的节点的value e.value = value; afterNodeAccess(e); //返回key的原始值 return oldValue; } } ++modCount;//用作修改和新增快速失败 if (++size > threshold)//超过最大容量,进行扩容 resize(); afterNodeInsertion(evict); return null; }
①、判断键值对数组 table 是否为空或为null,否则执行resize()进行扩容;
②、根据键值key计算hash值得到插入的数组索引i,如果table[i]==null,直接新建节点添加,转向⑥,如果table[i]不为空,转向③;
③、判断table[i]的首个元素是否和key一样,如果相同直接覆盖value,否则转向④,这里的相同指的是hashCode以及equals;
④、判断table[i] 是否为treeNode,即table[i] 是否是红黑树,如果是红黑树,则直接在树中插入键值对,否则转向⑤;
⑤、遍历table[i],判断链表长度是否大于8,大于8的话把链表转换为红黑树,在红黑树中执行插入操作,否则进行链表的插入操作;遍历过程中若发现key已经存在直接覆盖value即可;
⑥、插入成功后,判断实际存在的键值对数量size是否超过了最大容量threshold,如果超过,进行扩容。
if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k)))) 此处先判断p.hash == hash是为了提高效率,仅通过(k = e.key) == key || key.equals(k)其实也可以进行判断,但是equals方法相当耗时!如果两个key的hash值不同,那么这两个key肯定不相同,进行equals比较是扯淡的! 所以先通过p.hash == hash该条件,将桶中很多不符合的节点pass掉。然后对剩下的节点继续判断。
h& (length-1)运算等价于对length取模,也就是h%length,但是&比%具有更高的效率。
数组的长度按规定一定是2的幂。因此,数组的长度的二进制形式是:10000…000, 1后面有偶数个0。 那么,length - 1 的二进制形式就是01111.111, 0后面有偶数个1。
这看上去很简单,其实比较有玄机的,我们举个例子来说明:
假设数组长度分别为15和16,优化后的hash码分别为8和9,那么&运算后的结果如下:
h & (table.length-1) hash table.length-1
8 & (15-1): 0100 & 1110 = 0100
9 & (15-1): 0101 & 1110 = 0100
---------------------------------------------------
8 & (16-1): 0100 & 1111 = 010
9 & (16-1): 0101 & 1111 = 0101
从上面的例子中可以看出:当它们和15-1(1110)“与”的时候,产生了相同的结果,也就是说它们会定位到数组中的同一个位置上去,这就产生了碰撞,8和9会被放到数组中的同一个位置上形成链表,那么查询的时候就需要遍历这个链
表,得到8或者9,这样就降低了查询的效率。同时,我们也可以发现,当数组长度为15的时候,hash值会与15-1(1110)进行“与”,那么最后一位永远是0,而0001,0011,0101,1001,1011,0111,1101这几个位置永远都不能存放元素了,空间浪费相当大,更糟的是 这种情况中,数组可以使用的位置比数组长度小了很多,这意味着进一步增加了碰撞的几率,减慢了查询的效率!
当n为2次幂时,会满足一个公式:(n - 1) & hash = hash % n,计算更加高效。
只有是2的幂数的数字经过n-1之后,二进制肯定是 ...11111111 这样的格式,这种格式计算的位置的时候,完全是由产生的hash值类决定
奇数n-1为偶数,偶数2进制的结尾都是0,经过&运算末尾都是0,会 增加hash冲突。
扩容
扩容(resize),我们知道集合是由数组+链表+红黑树构成,向 HashMap 中插入元素时,如果HashMap 集合的元素已经大于了最大承载容量threshold(capacity * loadFactor),这里的threshold不是数组的最大长度。那么必须扩大数组的长度,Java中数组是无法自动扩容的,我们采用的方法是用一个更大的数组代替这个小的数组
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
final Node<K,V>[] resize() { //将原始数组数据缓存起来 Node<K,V>[] oldTab = table; int oldCap = (oldTab == null) ? 0 : oldTab.length;//原数组如果为null,则长度赋值0 int oldThr = threshold; int newCap, newThr = 0; if (oldCap > 0) {//如果原数组长度大于0 if (oldCap >= MAXIMUM_CAPACITY) {//数组大小如果已经大于等于最大值(2^30) threshold = Integer.MAX_VALUE;//修改阈值为int的最大值(2^31-1),这样以后就不会扩容了 return oldTab; } //原数组长度扩大1倍(此时将原数组扩大一倍后的值赋给newCap)也小于2^30次方,并且原数组长度大于等于初始化长度16 else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY && oldCap >= DEFAULT_INITIAL_CAPACITY) newThr = oldThr << 1; // 阀值扩大1倍 //如果原数组长度扩大一倍后大于MAXIMUM_CAPACITY后,newThr还是0 } else if (oldThr > 0) //旧容量为0,旧阀值大于0,则将新容量直接等于就阀值 //在第一次带参数初始化时候会有这种情况 //newThr在面算 newCap = oldThr; else { //阀值等于0,oldCap也等于0(集合未进行初始化) //在默认无参数初始化会有这种情况 newCap = DEFAULT_INITIAL_CAPACITY;//数组长度初始化为16 newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);//阀值等于16*0.75=12 } //计算新的阀值上限 //此时就是上面原数组长度扩大一倍后大于MAXIMUM_CAPACITY和旧容量为0、旧阀值大于0的情况 if (newThr == 0) { float ft = (float)newCap * loadFactor; newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ? (int)ft : Integer.MAX_VALUE); } //将阀值上限设置为新阀值上限 threshold = newThr; //用于抑制编译器产生警告信息 @SuppressWarnings({"rawtypes","unchecked"}) //创建容器大小为newCap的新数组 Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap]; //将新数组赋给table table = newTab; //如果是第一次,扩容的时候,也就是原来没有元素,下面的代码不会运行,如果原来有元素,则要将原来的元素,进行放到新扩容的里面 if (oldTab != null) { //把每个bucket都移动到新的buckets中 for (int j = 0; j < oldCap; ++j) { Node<K,V> e; if ((e = oldTab[j]) != null) { oldTab[j] = null;//元数据j位置置为null,便于垃圾回收 if (e.next == null)//数组没有下一个引用(不是链表) //直接将e的key的hash与新容量重新计算下标,新下标的元素为e newTab[e.hash & (newCap - 1)] = e; else if (e instanceof TreeNode)//红黑树 ((TreeNode<K,V>)e).split(this, newTab, j, oldCap); else { // preserve order Node<K,V> loHead = null, loTail = null; Node<K,V> hiHead = null, hiTail = null; Node<K,V> next; do { next = e.next; //原索引 if ((e.hash & oldCap) == 0) { if (loTail == null) loHead = e; else loTail.next = e; loTail = e; } //原索引+oldCap else { if (hiTail == null) hiHead = e; else hiTail.next = e; hiTail = e; } } while ((e = next) != null); //原索引放到bucket里 if (loTail != null) { loTail.next = null; newTab[j] = loHead; } //原索引+oldCap放到bucket里 if (hiTail != null) { hiTail.next = null; newTab[j + oldCap] = hiHead; } } } } } return newTab; }
if ((e.hash & oldCap) == 0)如果判断成立,那么该元素的地址在新的数组中就不会改变。因为oldCap的最高位的1,在e.hash对应的位上为0,所以扩容后得到的地址是一样的,位置不会改变 ,在后面的代码的执行中会放到loHead中去,最后赋值给newTab[j];如果判断不成立,那么该元素的地址变为 原下标位置+oldCap,也就是lodCap最高位的1,在e.hash对应的位置上也为1,所以扩容后的地址改变了,在后面的代码中会放到hiHead中,最后赋值给newTab[j + oldCap] 举个栗子来说一下上面的两种情况:
设:oldCap=16 二进制为:0001 0000
oldCap-1=15 二进制为:0000 1111
e1.hash=10 二进制为:0000 1010
e2.hash=26 二进制为:0101 1010
e1在扩容前的位置为:e1.hash & oldCap-1 结果为:0000 1010
e2在扩容前的位置为:e2.hash & oldCap-1 结果为:0000 1010
结果相同,所以e1和e2在扩容前在同一个链表上,这是扩容之前的状态。 现在扩容后,需要重新计算元素的位置,在扩容前的链表中计算地址的方式为e.hash & oldCap-1 那么在扩容后应该也这么计算呀,扩容后的容量为oldCap*2=32 0010 0000 newCap=32,新的计算 方式应该为
e1.hash & newCap-1
即:0000 1010 & 0001 1111
结果为0000 1010与扩容前的位置完全一样。
e2.hash & newCap-1
即:0101 1010 & 0001 1111
结果为0001 1010,为扩容前位置+oldCap。
而这里却没有e.hash & newCap-1
而是 e.hash & oldCap,其实这两个是等效的,都是判断倒数第五位是0,还是1。如果是0,则位置不变,是1则位置改变为扩容前位置+oldCap。
查找元素
①、get(Object key)
通过 key 查找 value:首先通过 key 找到计算索引,找到桶元素的位置,先检查第一个节点,如果是则返回,如果不是,则遍历其后面的链表或者红黑树。其余情况全部返回 null。
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
public V get(Object key) { Node<K,V> e; return (e = getNode(hash(key), key)) == null ? null : e.value; } final Node<K,V> getNode(int hash, Object key) { Node<K,V>[] tab; Node<K,V> first, e; int n; K k; if ((tab = table) != null && (n = tab.length) > 0 && (first = tab[(n - 1) & hash]) != null) { //根据key计算的索引检查第一个索引 if (first.hash == hash && // always check first node ((k = first.key) == key || (key != null && key.equals(k)))) return first; //不是第一个节点 if ((e = first.next) != null) { if (first instanceof TreeNode)//遍历树查找元素 return ((TreeNode<K,V>)first).getTreeNode(hash, key); do { //遍历链表查找元素 if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k)))) return e; } while ((e = e.next) != null); } } return null; }
②、判断是否存在给定的 key 或者 value
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
public boolean containsKey(Object key) { return getNode(hash(key), key) != null; } public boolean containsValue(Object value) { Node<K,V>[] tab; V v; if ((tab = table) != null && size > 0) { //遍历数组 for (int i = 0; i < tab.length; ++i) { //遍历数组中的每个节点元素 for (Node<K,V> e = tab[i]; e != null; e = e.next) { if ((v = e.value) == value || (value != null && value.equals(v))) return true; } } } return false; }
删除元素
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
public V remove(Object key) { Node<K,V> e; return (e = removeNode(hash(key), key, null, false, true)) == null ? null : e.value; } final Node<K,V> removeNode(int hash, Object key, Object value, boolean matchValue, boolean movable) { Node<K,V>[] tab; Node<K,V> p; int n, index; //(n - 1) & hash找到桶的位置 if ((tab = table) != null && (n = tab.length) > 0 && (p = tab[index = (n - 1) & hash]) != null) { Node<K,V> node = null, e; K k; V v; //如果键的值与链表第一个节点相等,则将 node 指向该节点 if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k)))) node = p; //如果桶节点存在下一个节点 else if ((e = p.next) != null) { //节点为红黑树 if (p instanceof TreeNode) node = ((TreeNode<K,V>)p).getTreeNode(hash, key);//找到需要删除的红黑树节点 else { do {//遍历链表,找到待删除的节点 if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k)))) { node = e; //找到就停止,如果此时是第一次遍历就找到,则node指向链表中第二个元素,p还是第一个元素 //第一次没找到,第二次找到,则node指向链表中第三个元素,p指向第二个元素,p是找到元素节点的父节点 //所以需要遍历的时候p和node 是不相等的,只有链表第一个元素就判断相等时,p和node 相等 break; } //第一次遍历没找到, 此时p指向第二个元素 p = e; } while ((e = e.next) != null); } } //删除节点,并进行调节红黑树平衡 if (node != null && (!matchValue || (v = node.value) == value || (value != null && value.equals(v)))) { if (node instanceof TreeNode) ((TreeNode<K,V>)node).removeTreeNode(this, tab, movable); else if (node == p) //如果键的值与链表第一个节点相等,则将元素位置指向 node的下一个节点(链表的第二个节点),有可能node.next 为null tab[index] = node.next; else //如果键的值与链表第一个节点不相等,node的父节点的next指向node的next p.next = node.next; ++modCount; --size; afterNodeRemoval(node); return node; } } return null; }
遍历元素
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
HashMap<String, String> map = new HashMap<>(); map.put("1", "A"); map.put("2", "B"); map.put("3", "C"); map.put("4", "D"); map.put("5", "E"); map.put("6", "F"); for(String str : map.keySet()){ System.out.print(map.get(str)+" "); } for(HashMap.Entry entry : map.entrySet()){ System.out.print(entry.getKey()+" "+entry.getValue()); }
重写equals方法需同时重写hashCode方法
各种资料上都会提到,“重写equals时也要同时覆盖hashcode”,我们举个小例子来看看,如果重写了equals而不重写hashcode会发生什么样的问题
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
/** * Created by chenhao on 2018/9/28. */ public class MyTest { private static class Person{ int idCard; String name; public Person(int idCard, String name) { this.idCard = idCard; this.name = name; } @Override public boolean equals(Object o) { if (this == o) { return true; } if (o == null || getClass() != o.getClass()){ return false; } Person person = (Person) o; //两个对象是否等值,通过idCard来确定 return this.idCard == person.idCard; } } public static void main(String []args){ HashMap<Person,String> map = new HashMap<Person, String>(); Person person = new Person(123,"乔峰"); //put到hashmap中去 map.put(person,"天龙八部"); //get取出,从逻辑上讲应该能输出“天龙八部” System.out.println("结果:"+map.get(new Person(123,"萧峰"))); } }
如果我们已经对HashMap的原理有了一定了解,这个结果就不难理解了。尽管我们在进行get和put操作的时候,使用的key从逻辑上讲是等值的(通过equals比较是相等的),但由于没有重写hashCode方法,所以put操作时,key(hashcode1)-->hash-->indexFor-->最终索引位置 ,而通过key取出value的时候 key(hashcode2)-->hash-->indexFor-->最终索引位置,由于hashcode1不等于hashcode2,导致没有定位到一个数组位置而返回逻辑上错误的值null(也有可能碰巧定位到一个数组位置,但是也会判断其entry的hash值是否相等,上面get方法中有提到。)
再想象一下,假如两个Java对象A和B,A和B相等(eqauls结果为true),但A和B的哈希码不同,则A和B存入HashMap时的哈希码计算得到的HashMap内部数组位置索引可能不同,那么A和B很有可能允许同时存入HashMap,显然相等/相同的元素是不允许同时存入HashMap,HashMap不允许存放重复元素。
所以,在重写equals的方法的时候,必须注意重写hashCode方法,同时还要保证通过equals判断相等的两个对象,调用hashCode方法要返回同样的整数值。而如果equals判断不相等的两个对象,其hashCode可以相同(只不过会发生哈希冲突,应尽量避免)。