本文探讨的是老掉牙的基础问题，先建个实体类
package com.demo.tools;
public class User {
private String name;
public User(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}测试：
public static void main(String[] args){
User a = new User("A");
User b = new User("A");
System.out.println(a.equals(b));
}输出 false。明明存的都是A，为啥equal的结果是false呢？不是说【equal比较的是值，==比较的是地址】吗？因为默认创建的类是继承Object的，看一下Object类里面的两个方法：
/**
* 返回对象的哈希码值。
*
* {@code hashCode}的一般约定为：
* 在Java应用程序执行期间对同一对象多次调用{@code hashcode}方法时，只要在对象{@code equals}的比较中使用的信息没有被修改，则该方法必须一致地返回相同的整数。
* 从应用程序的一次执行到同一应用程序的另一次执行，此整数不必保持一致。
*
* 如果调用{@code equals（object）}方法，两个对象相等，那么两个对象调用{@code hashcode}方法必须产生相同的整数结果。
* 根据{@link java.lang.object equals（java.lang.object）}方法，如果两个对象不相等，则这两个对象调用{@code hashcode}方法都必须产生不同的整数结果。
*
* @return a hash code value for this object.
* @see java.lang.Object#equals(java.lang.Object)
* @see java.lang.System#identityHashCode
*/
public native int hashCode(); /**
* {@code equals}方法在非空对象引用上实现等价关系：
*
* 它是自反的：对于任何非空的引用值{@code x}，{@code x.equals（x）}应该返回{@code true}。
* 它是对称的：对于任何非空的引用值{@code x}和{@code y}，{@code x.equals（y）}应该返回{@code true}；反过来也应该一样{@code y.equals（x）}返回{@code true}。
* 它是可传递的：对于任何非空的引用值{@code x}、{@code y}和{@code z}，如果{@code x.equals（y）}返回{@code true}，{@code y.equals（z）}返回{@code true}，则{@code x.equals（z）}应返回{@code true}。
* 它是一致的：对于任何非空的引用值{@code x}和{@code y}，多次调用{@code x.equals（y）}应该一致的返回{@code true}或{@code false}，前提是在{@code equals}比较的对象信息没有被修改。
* 对于任何非空引用值{@code x}，{@code x.equals（null）}应返回{@code false}。
*
*
* 对于任何非空的引用值{@code x}和{@code y}，当且仅当{@code x}和{@code y}引用同一对象，此方法返回{@code true}【此时{@code x==y}的值是{@code true}】。
*
* 注意，通常需要重写{@code hashcode}方法，以便保持{@code hashcode}方法的一般约定，它声明：相等的对象必须有相等的哈希代码。
*
* @param obj the reference object with which to compare.
* @return {@code true} if this object is the same as the obj
* argument; {@code false} otherwise.
* @see #hashCode()
* @see java.util.HashMap
*/
public boolean equals(Object obj) {
return (this == obj);
}
可以看到： 1. 默认的hashcode方法是个本地方法，也就是对象的内存地址。 2. 而equals方法则是直接使用了==操作符，也是比较内存地址。这样看来，equals和hashcode是一样的。
而根据注释所说： 1. 只要equals返回true，那么hashcode一定相等。 2. 只要equals返回false，那么hashcode一定不相等。3. 重写了equals方法，也要重写hashcode方法，因为相等的对象必须有相同的哈希码。
尝试一：仅仅重写equals
package com.demo.tools;
public class User {
public static void main(String[] args){
User a = new User("A");
User b = new User("A");
System.out.println(a.equals(b));
System.out.println(a == b);
System.out.println(a.hashCode() + "," + b.hashCode());
}
private String name;
public User(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public boolean equals(Object obj) {
User user = (User) obj;
return this.name.equals(user.name);
}
}输出：
可以看到，值比较成功了，可是hashcode不一样，这里的hashcode仍然是内存地址。这就违反了约定。
尝试二：重写equals和hashcode方法
package com.demo.tools;
public class User {
public static void main(String[] args){
User a = new User("A");
User b = new User("A");
System.out.println(a.equals(b));
System.out.println(a == b);
System.out.println(a.hashCode() + "," + b.hashCode());
}
private String name;
public User(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public boolean equals(Object obj) {
User user = (User) obj;
return this.name.equals(user.name);
}
@Override
public int hashCode() {
return this.name.hashCode();
}
}输出：
可以看到，值和hashcode一致了，地址不一样很正常，因为这是两个对象。
尝试三：hashcode相同，equals就相等吗？
public static void main(String[] args){
User a = new User("Aa");
User b = new User("BB");
System.out.println(a.equals(b));
System.out.println(a == b);
System.out.println(a.hashCode() + "," + b.hashCode());
}输出：
可以看到，两个不同的字符串，hashcode可能一样。
源码一：Map里的equals方法和hashcode方法
public boolean equals(Object o) {
// 地址一样，返回true
if (o == this)
return true;
// 不是Map的子类，返回false
if (!(o instanceof Map))
return false;
Map<?,?> m = (Map<?,?>) o;
// 大小不同，返回false
if (m.size() != size())
return false;
try {
// 遍历Map内容，一一比较
Iterator<Map.Entry<K,V>> i = entrySet().iterator();
while (i.hasNext()) {
Map.Entry<K,V> e = i.next();
K key = e.getKey();
V value = e.getValue();
// HashMap里允许存储null值
if (value == null) {
// 对方不存在此key，返回false
if (!(m.get(key)==null && m.containsKey(key)))
return false;
} else {
// 都有此key，但是值不一样，返回false
if (!value.equals(m.get(key)))
return false;
}
}
} catch (ClassCastException unused) {
return false;
} catch (NullPointerException unused) {
return false;
}
return true;
}这里能回答一个问题：Map中的对象是自定义的，要不要重写对象的equals方法？
看源码我们能知道，默认Map里的equals方法，在内部仅仅调用了value的equals方法，默认比较的是内存地址。在调用Map的equals方法时：
1. 默认一一比较对象的地址，也就是说，两个Map中每一组比较的对象，都引用同一个地址，那才算两个Map相等。
2. 如果我们业务规定了相等的判定，那么默认的则不符合实际需求，所以要重写value的equals方法，不然调用Map的equals方法可能不符合预期，既然重写了equals，那么也要重写hashcode了。
public int hashCode() {
int h = 0;
Iterator<Entry<K,V>> i = entrySet().iterator();
while (i.hasNext())
h += i.next().hashCode();
return h;
}不难看出，Map的hashcode方法是把内部元素的hashcode加在一起并返回。
源码二：List的equals方法和hashcode方法
public boolean equals(Object o) {
// 本身比较，返回true
if (o == this)
return true;
// 非List的子类，返回false
if (!(o instanceof List))
return false;
ListIterator<E> e1 = listIterator();
ListIterator<?> e2 = ((List<?>) o).listIterator();
// 当两个迭代器的hasNext都为true的时候,进行比较
while (e1.hasNext() && e2.hasNext()) {
E o1 = e1.next();
Object o2 = e2.next();
// 这里很巧妙，利用三目运算符完成值的比较
if (!(o1==null ? o2==null : o1.equals(o2)))
return false;
}
// 当任意一方hasNext为true，返回false；当双方都为false，返回true
return !(e1.hasNext() || e2.hasNext());
}基本逻辑和Map的一样，都是遍历元素进行比较。hashcode也是一样。
public int hashCode() {
int hashCode = 1;
for (E e : this)
hashCode = 31*hashCode + (e==null ? 0 : e.hashCode());
return hashCode;
}源码三：String的equals方法和hashcode方法
public boolean equals(Object anObject) {
// 地址一样，返回true
if (this == anObject) {
return true;
}
// 类型必须是String
if (anObject instanceof String) {
String anotherString = (String)anObject;
int n = value.length;
// 比较两个String的长度
if (n == anotherString.value.length) {
char v1[] = value;
char v2[] = anotherString.value;
int i = 0;
// 遍历比较
while (n-- != 0) {
if (v1[i] != v2[i])
return false;
i++;
}
return true;
}
}
return false;
}hashcode
private final char value[];
private int hash; // Default to 0
public int hashCode() {
int h = hash;
if (h == 0 && value.length > 0) {
char val[] = value;
// 这里并不是把元素的hashcode加在一起，而是把元素的ASCII码加在一起
for (int i = 0; i < value.length; i++) {
h = 31 * h + val[i];
}
hash = h;
}
return h;
}
总结
不管平时有没有重写过equals和hashcode方法，看了Map和Set的源码就可以知道重写的必要性。因为Set也是基于Map实现的（是一个key不一样，value全一样的Map），所以只用Map举证即可。
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
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;
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
else {
Node<K,V> e; K k;
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;
}
}
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;
}首先值的位置是根据hashcode决定的，然后判断值相等的条件是equals为true，hashcode相等。其它都为不相等，有一种情况就是equals为true，hashcode不相等，如果插入Set集合，就不能达到去重的效果：
package com.demo.tools; import java.util.HashSet;
import java.util.Objects;
import java.util.Set; public class Main { public static void main(String[] args) throws Exception {
Set<Foo> set = new HashSet<>();
Foo a = new Foo("A", 12);
Foo b = new Foo("A", 13);
set.add(a);
set.add(b);
set.forEach(e -> System.out.println(e.name));
System.out.println(a.equals(b));
System.out.println(a.hashCode() + "," + b.hashCode());
} static class Foo {
private String name;
private Integer age; public Foo(String name, Integer age) {
this.name = name;
this.age = age;
} @Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Foo foo = (Foo) o;
// 这里我们认为name一样，则相等
return Objects.equals(name, foo.name);
}
} }
equals为true，但是hashcode不一样：
所以，如果重写了equals，一定要重写hashcode，以避免不必要的问题。
小技巧：IDEA里可以自动生成两个方法
快捷键：Alt+Insert
标准equals和hashcode，值得借鉴
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Foo foo = (Foo) o;
return Objects.equals(name, foo.name) &&
Objects.equals(age, foo.age);
} @Override
public int hashCode() { return Objects.hash(name, age);
}