《Java面试题系列》：一个长常识又很有意思的专栏。深刻开掘、剖析源码、汇总原理、图文联合，打造公众号系列文章，面试与否均可晋升Level。欢送继续关注【程序新视界】。本篇为第4篇。
外围问题：重写了equals办法，为什么还要重写hashCode办法？
这不仅仅是一道面试题，而且是关系到咱们的代码是否强壮和正确的问题。在后面两篇文章波及到了equals办法的底层解说：《说说==和equals的区别？你的答复可能是谬误的》和《Integer等号判断的底细，你可能不晓得？》。
本篇文章，带大家从底层来剖析一下hashcode办法重写的意义以及如何实现。
回顾equals办法
咱们先回顾一下Object的equals办法实现，并简略汇总一下应用equals办法的法则。
public boolean equals(Object obj) {
return (this == obj);
}通过下面Object的源代码，能够得出一个论断：如果一个类未重写equals办法，那么实质上通过“==”和equals办法比拟的成果是一样的，都是比拟两个对象的的内存地址。
后面两篇文章讲到String和Integer在比拟时的区别，关键点也是它们对equals办法的实现。
面试时总结一下就是：默认状况下，从Object类继承的equals办法与“==”齐全等价，比拟的都是对象的内存地址。但咱们能够重写equals办法，使其依照须要进行比拟，如String类重写了equals办法，比拟的是字符的序列，而不再是内存地址。
与hashCode办法的关系
那么equals办法与hashCode办法又有什么关系呢？咱们来看Object上equals办法的一段正文。
Note that it is generally necessary to override the hashCode method whenever this method is overridden, so as to maintain the general contract for the hashCode method, which states that equal objects must have equal hash codes.
大抵意思是：当重写equals办法后有必要将hashCode办法也重写，这样做能力保障不违反hashCode办法中“雷同对象必须有雷同哈希值”的约定。
此处只是揭示了咱们重写hashCode办法的必要性，那其中提到的hashCode办法设计约定又是什么呢？相干的内容定义在hashCode办法的注解局部。
hashCode办法约定
对于hashCode办法的约定原文比拟多，大家间接看源码即可看到，这里汇总一下，共三条：
（1）如果对象在应用equals办法中进行比拟的参数没有批改，那么屡次调用一个对象的hashCode()办法返回的哈希值应该是雷同的。
（2）如果两个对象通过equals办法比拟是相等的，那么要求这两个对象的hashCode办法返回的值也应该是相等的。
（3）如果两个对象通过equals办法比拟是不同的，那么也不要求这两个对象的hashCode办法返回的值是不雷同的。然而咱们应该晓得对于不同对象产生不同的哈希值对于哈希表(HashMap等)可能进步性能。
其实，看到这里咱们理解了hashCode的实现规约，但还是不分明为什么实现equals办法须要重写hashCode办法。但咱们能够得出一条法则：hashCode办法实际上必须要实现的一件事件就是，为equals办法认定为雷同的对象返回雷同的哈希值。
其实在下面规约中提到了哈希表，这也正是hashCode办法使用的场景之一，也是咱们为什么要重写的外围。
hashCode利用场景
如果理解HashMap的数据结构，就会晓得它用到“键对象”的哈希码，当咱们调用put办法或者get办法对Map容器进行操作时，都是依据键对象的哈希码来计算存储地位的。如果咱们对哈希码的获取没有相干保障，就可能会得不到预期的后果。
而对象的哈希码的获取正是通过hashCode办法获取的。如果自定义的类中没有实现该办法，则会采纳Object中的hashCode()办法。
在Object中该办法是一个本地办法，会返回一个int类型的哈希值。能够通过将对象的外部地址转换为整数来实现的，然而Java中没有强制要求通过该形式实现。
具体实现网络上有不同的说法，有说通过内置地址转换得来，也有说“OpenJDK8默认hashCode的计算方法是通过和以后线程无关的一个随机数+三个确定值，使用Marsaglia’s xorshift scheme随机数算法失去的一个随机数”取得。
无论默认实现是怎么的，大多数状况下都无奈满足equals办法雷同，同时hashCode后果也雷同的条件。比方上面的示例重写与否差距很大。
public void test1() {
String s = "ok";
StringBuilder sb = new StringBuilder(s);
System.out.println(s.hashCode() + " " + sb.hashCode());
String t = new String("ok");
StringBuilder tb = new StringBuilder(s);
System.out.println(t.hashCode() + " " + tb.hashCode());
}下面这段代码打印的后果为：
3548 1833638914
3548 1620303253String实现了hashCode办法，而StringBuilder并没有实现，这就导致即便值是一样的，hashCode也不同。
上个示例中问题还不太显著，上面咱们以HashMap为例，看看如果没有实现hashCode办法会导致什么重大的结果。
@Test
public void test2() {
String hello = "hello";
Map<String, String> map1 = new HashMap<>();
String s1 = new String("key");
String s2 = new String("key");
map1.put(s1, hello);
System.out.println("s1.equals(s2):" + s1.equals(s2));
System.out.println("map1.get(s1):" + map1.get(s1));
System.out.println("map1.get(s2):" + map1.get(s2));
Map<Key, String> map2 = new HashMap<>();
Key k1 = new Key("A");
Key k2 = new Key("A");
map2.put(k1, hello);
System.out.println("k1.equals(k2):" + s1.equals(s2));
System.out.println("map2.get(k1):" + map2.get(k1));
System.out.println("map2.get(k2):" + map2.get(k2));
}
class Key {
private String k;
public Key(String key) {
this.k = key;
}
@Override
public boolean equals(Object obj) {
if (obj instanceof Key) {
Key key = (Key) obj;
return k.equals(key.k);
}
return false;
}
}实例中定义了外部类Key，其中实现了equals办法，但未实现hashCode办法。寄存于Map中的value值都是字符串“hello”。
代码分两段，第一段演示当Map的key通过实现了hashCode的String时是什么成果；第二段演示了当Map的key通过未实现hashCode办法的Key对象时是什么成果。
执行上述代码，打印后果如下：
s1.equals(s2):true
map1.get(s1):hello
map1.get(s2):hello
k1.equals(k2):true
map2.get(k1):hello
map2.get(k2):null剖析后果能够看出，对于String作为key的s1和s2来说，通过equals比拟相等是天然的，取得的值也是雷同的。但k1和k2通过equals比拟是相等，但为什么在Map中取得的后果却不一样？实质上就是因为没有重写hashCode办法导致Map在存储和获取过程中调用hashCode办法取得的值不统一。
此时在Key类中增加hashCode办法：
@Override
public int hashCode(){
return k.hashCode();
}再次执行，便可失常取得对应的值。
s1.equals(s2):true
map1.get(s1):hello
map1.get(s2):hello
k1.equals(k2):true
map2.get(k1):hello
map2.get(k2):hello通过下面的典型实例演示了不重写hashCode办法的潜在结果。简略看一下HashMap中的put办法。
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
Node<K,V>[] tab; Node<K,V> p; int n, i;
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
// 通过哈希值来查找底层数组位于该地位的元素p，如果p不为null，则应用新的键值对来笼罩旧的键值对
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
else {
Node<K,V> e; K k;
// (二者哈希值相等)且(二者地址值相等或调用equals认定相等)。
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
else if (p instanceof TreeNode)
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);
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
break;
}
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
// 如果底层数组中存在传入的Key，那么应用新传入的笼罩掉查到的
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
++modCount;
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}在上述办法中，put办法在拿到key的第一步就对key对象调用了hashCode办法。暂且不看前面的代码，如果没有重写hashCode办法，就无奈确保key的hash值统一，后续操作就是两个key的操作了。
重写hashCode办法
理解了重写hashCode办法的重要性，也理解了对应的规约，那么上面咱们就聊聊如何优雅的重写hashCode办法。
首先，如果应用IDEA的话，那么间接应用快捷键即可。
生成的成果如下：
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (o == null || getClass() != o.getClass()) {
return false;
}
Key key = (Key) o;
return Objects.equals(k, key.k);
}
@Override
public int hashCode() {
return Objects.hash(k);
}依据须要可对生成的办法外部实现进行批改。在下面的实例中用到了java.util.Objects类，它的hash办法的长处是如果参数为null，就只返回0，否则返回对象参数调用的hashCode的后果。Objects.hash办法源码如下：
public static int hash(Object... values) {
return Arrays.hashCode(values);
}其中Arrays.hashCode办法源码如下：
public static int hashCode(Object a[]) {
if (a == null)
return 0;
int result = 1;
for (Object element : a)
result = 31 * result + (element == null ? 0 : element.hashCode());
return result;
}当然此处只有一个参数，也能够间接应用Objects类hashCode办法：
public static int hashCode(Object o) {
return o != null ? o.hashCode() : 0;
}如果是多个属性都参加hash值的状况倡议可应用第一个办法。只不过须要留神，在类构造（成员变量）变动时，同步增减办法外面的参数值。
小结
当咱们筹备面试时，始终在背诵“实现equals办法的同时也要实现hashCode办法”，牢记这些论断并没有错。但咱们也不能因为匆忙筹备面试题，而遗记了这些面试题之所以频繁呈现的起因是什么。当深刻摸索之后，会发现在那些干燥的论断背地还有这么多不容忽视的知识点，还有这么多有意思的设计与陷阱。
我是感觉越钻研越有意思，越钻研越发现自己已经的无知。你呢？关注一下，期待下一篇文章吧。
<center>程序新视界：精彩和成长都不容错过</center>
发表回复