日常开发中，不会刻意去重写equals和hashCode方法，随着业务代码越写越多，对于这两个方法的记忆就消退了，然而底层知识才能撑起上层建筑，所以拿出来复习下；
这里两个方法都来自于Object；
1.equals：这里equals是一个native方法，返回这个对象的hash code，HashMap受益于该方法；
/**
* Returns a hash code value for the object. This method is
* supported for the benefit of hash tables such as those provided by
* {@link java.util.HashMap}.
*/
public native int hashCode();
2.hashCode：可以看到equals方法其实就是比较了地址；
public boolean equals(Object obj) {
return (this == obj);
}
辣么，问题来啦，为什么要重写equals？
当我们在比较两个自定义对象是否相等时候，往往是比较他们的字段值是否都相等；而equals本身比较的是地址，创建两个自定义对象，对象被分配在堆中，地址是不同的。所以重写equals方法让对象比较成为了可能；
然后呢？为什么要重写hashCode方法呢？
根据上面源码的注释，我们可以看到，hashCode方法收益与HashMap，这里就从HashMap的put和contains方法来了解：
public V put(K key, V value) {
if (table == EMPTY_TABLE) {
inflateTable(threshold);
}
if (key == null)
return putForNullKey(value);
int hash = hash(key);
int i = indexFor(hash, table.length);
for (Entry<K,V> e = table[i]; e != null; e = e.next) {
Object k;
if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
V oldValue = e.value;
e.value = value;
e.recordAccess(this);
return oldValue;
}
}
modCount++;
addEntry(hash, key, value, i);
return null;
}
final int hash(Object k) {
int h = hashSeed;
if (0 != h && k instanceof String) {
return sun.misc.Hashing.stringHash32((String) k);
}
h ^= k.hashCode();
// This function ensures that hashCodes that differ only by
// constant multiples at each bit position have a bounded
// number of collisions (approximately 8 at default load factor).
h ^= (h >>> 20) ^ (h >>> 12);
return h ^ (h >>> 7) ^ (h >>> 4);
}
可以看到这里在存入值得时候，会调用hashCode来获取对应Entry数组所在位置，并循环查找，怎么查找呢？调用了自定义对象的equals方法来查找，这样来实现对Map的操作；
是不是有点小疑问？这里解释一下，两个不同的对象可能hashCode相同，但是绝对不equals，而hashCode的计算效率最高，equals方法还需要去走自己重写的内部逻辑，所以，根据这个特性，先比较hashCode，如果相同，再比较equals，从而提高了HashMap的效率。
而HashMap的contains方法也是如此实现的：
public boolean containsKey(Object key) {
return getEntry(key) != null;
}
final Entry<K,V> getEntry(Object key) {
if (size == 0) {
return null;
}
int hash = (key == null) ? 0 : hash(key);
for (Entry<K,V> e = table[indexFor(hash, table.length)];
e != null;
e = e.next) {
Object k;
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
return e;
}
return null;
}
同样，HashSet内部实现就是基于HashMap；
所以：什么场景下需要重写这两个方法呢？
1.使用Set集合操作自定义对象的时候；
2.使用自定义对象作为HashMap的key时（当然很少，而Set就是其中一个实现）；
虽然这些很基础，但都是通往上层的基石；
