什么是哈希表？
在讨论哈希表之前，我们先大概了解下其他数据结构在新增，查找等基础操作执行性能
数组：采用一段连续的存储单元来存储数据。对于指定下标的查找，时间复杂度为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继承关系
绿色虚线箭头是指接口实现关系
字段属性
//默认 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;
//初始化使用，长度总是 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 容量是之前容量的两倍
构造函数
①、无参构造函数
/** * 默认构造函数，初始化加载因子loadFactor = 0.75 */ public HashMap() { this.loadFactor = DEFAULT_LOAD_FACTOR; }
②、指定初始容量的构造函数
/** * * @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; }
添加元素
//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中数组是无法自动扩容的，我们采用的方法是用一个更大的数组代替这个小的数组
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。
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
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; }
删除元素
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; }
遍历元素
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会发生什么样的问题
/** * 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可以相同（只不过会发生哈希冲突，应尽量避免）。