解读equals()和hashCode()
前面部分摘自：https://blog.csdn.net/javazejian/article/details/51348320
一：Object中equals方法的实现原理
public boolean equals(Object obj) { return (this == obj); }
每个对象都有内存地址和数据，“==”比较2个对象的地址，Object类中的equals（）比较的是2个对象的地址是否相同，object1.equals(object2) 为 true，则表示 equals1 和 equals2 实际上是引用同一个对象。
二：equals与“==”的区别
equals比较的是内容，“==”比较的是地址。
很明显，这个说法是不完全的
来看个例子
package com.zejian.test;
public class Car {
private int batch;
public Car(int batch) {
this.batch = batch;
}
public static void main(String[] args) {
Car c1 = new Car(1);
Car c2 = new Car(1);
System.out.println(c1.equals(c2));
System.out.println(c1 == c2);
}
}
console
false
false
分析：“==”比较的是地址，所以是false,这个不用多说.但是为什么equals也是false呢？因为所以类都集成Object类，Car类没有重写Object类里面的equals方法，所以是使用父类的equals方法，return (this == obj); 比较的亦是对象的地址，那么怎么解决这个问题呢？
那就是重写equals方法（比较内容）
@Override
public boolean equals(Object obj) {
if (obj instanceof Car) {
Car = (Car) obj;
return batch == c.batch;
}
return false;
}
三：equals的重写规则
自反性。对于任何非null的引用值x，x.equals(x)应返回true。
对称性。对于任何非null的引用值x与y，当且仅当：y.equals(x)返回true时，x.equals(y)才返回true。
传递性。对于任何非null的引用值x、y与z，如果y.equals(x)返回true，y.equals(z)返回true，那么x.equals(z)也应返回true。
一致性。对于任何非null的引用值x与y，假设对象上equals比较中的信息没有被修改，则多次调用x.equals(y)始终返回true或者始终返回false。
对于任何非空引用值x，x.equal(null)应返回false。
package com.zejian.test; public class Car { private int batch; public Car(int batch) { this.batch = batch; } public static void main(String[] args) { Car c1 = new Car(1); Car c2 = new Car(1); Car c3 = new Car(1); System.out.println("自反性->c1.equals(c1)：" + c1.equals(c1)); System.out.println("对称性："); System.out.println(c1.equals(c2)); System.out.println(c2.equals(c1)); System.out.println("传递性："); System.out.println(c1.equals(c2)); System.out.println(c2.equals(c3)); System.out.println(c1.equals(c3)); System.out.println("一致性："); for (int i = 0; i < 50; i++) { if (c1.equals(c2) != c1.equals(c2)) { System.out.println("equals方法没有遵守一致性！"); break; } } System.out.println("equals方法遵守一致性！"); System.out.println("与null比较："); System.out.println(c1.equals(null)); } @Override public boolean equals(Object obj) { if (obj instanceof Car) { Car c = (Car) obj; return batch == c.batch; } return false; } }
自反性->c1.equals(c1)：true 对称性： true true 传递性： true true true 一致性： equals方法遵守一致性！ 与null比较： false
子类与父类混合比较
package com.zejian.test; public class BigCar extends Car { int count; public BigCar(int batch, int count) { super(batch); this.count = count; } @Override public boolean equals(Object obj) { if (obj instanceof BigCar) { BigCar bc = (BigCar) obj; return super.equals(bc) && count == bc.count; } return false; } public static void main(String[] args) { Car c = new Car(1); BigCar bc = new BigCar(1, 20); System.out.println(c.equals(bc)); System.out.println(bc.equals(c)); } }
console:
true
false
对于这样的结果，自然是我们意料之中的啦。因为BigCar类型肯定是属于Car类型，所以c.equals(bc)肯定为true，对于bc.equals(c)返回false，是因为Car类型并不一定是BigCar类型（Car类还可以有其他子类）。嗯，确实是这样。但如果有这样一个需求，只要BigCar和Car的生产批次一样，我们就认为它们两个是相当的，在这样一种需求的情况下，父类（Car）与子类（BigCar）的混合比较就不符合equals方法对称性特性了。很明显一个返回true，一个返回了false，根据对称性的特性，此时两次比较都应该返回true才对。那么该如何修改才能符合对称性呢？其实造成不符合对称性特性的原因很明显，那就是因为Car类型并不一定是BigCar类型（Car类还可以有其他子类），在这样的情况下(Car instanceof BigCar)永远返回false，因此，我们不应该直接返回false，而应该继续使用父类的equals方法进行比较才行（因为我们的需求是批次相同，两个对象就相等，父类equals方法比较的就是batch是否相同）。因此BigCar的equals方法应该做如下修改：
@Override public boolean equals(Object obj) { if (obj instanceof BigCar) { BigCar bc = (BigCar) obj; return super.equals(bc) && count == bc.count; } return super.equals(obj); }
这样运行的结果就都为true了。但是到这里问题并没有结束，虽然符合了对称性，却还没符合传递性，实例如下：
package com.zejian.test; public class BigCar extends Car { int count; public BigCar(int batch, int count) { super(batch); this.count = count; } @Override public boolean equals(Object obj) { if (obj instanceof BigCar) { BigCar bc = (BigCar) obj; return super.equals(bc) && count == bc.count; } return super.equals(obj); } public static void main(String[] args) { Car c = new Car(1); BigCar bc = new BigCar(1, 20); BigCar bc2 = new BigCar(1, 22); System.out.println(bc.equals(c)); System.out.println(c.equals(bc2)); System.out.println(bc.equals(bc2)); } }
console:
true
true
false
bc，bc2，c的批次都是相同的，按我们之前的需求应该是相等，而且也应该符合equals的传递性才对。但是事实上运行结果却不是这样，违背了传递性。出现这种情况根本原因在于：
父类与子类进行混合比较。
子类中声明了新变量，并且在子类equals方法使用了新增的成员变量作为判断对象是否相等的条件。
只要满足上面两个条件，equals方法的传递性便失效了。而且目前并没有直接的方法可以解决这个问题。因此我们在重写equals方法时这一点需要特别注意。虽然没有直接的解决方法，但是间接的解决方案还说有滴，那就是通过组合的方式来代替继承,还有一点要注意的是组合的方式并非真正意义上的解决问题（只是让它们间的比较都返回了false，从而不违背传递性，然而并没有实现我们上面batch相同对象就相等的需求），而是让equals方法满足各种特性的前提下，让代码看起来更加合情合理，代码如下：
package com.zejian.test; public class Combination4BigCar { private Car c; private int count; public Combination4BigCar(int batch, int count) { c = new Car(batch); this.count = count; } @Override public boolean equals(Object obj) { if (obj instanceof Combination4BigCar) { Combination4BigCar bc = (Combination4BigCar) obj; return c.equals(bc.c) && count == bc.count; } return false; }
}
四：equals深入解读
前面我们一再强调了equals方法重写必须遵守的规则，接下来我们就是分析一个反面的例子，看看不遵守这些规则到底会造成什么样的后果。
package com.zejian.test; import java.util.ArrayList; import java.util.List; /** * 反面例子 * @author zejian */ public class AbnormalResult { public static void main(String[] args) { List<A> list = new ArrayList<A>(); A a = new A(); B b = new B(); list.add(a); System.out.println("list.contains(a)->" + list.contains(a)); System.out.println("list.contains(b)->" + list.contains(b)); list.clear(); list.add(b); System.out.println("list.contains(a)->" + list.contains(a)); System.out.println("list.contains(b)->" + list.contains(b)); } static class A { @Override public boolean equals(Object obj) { return obj instanceof A; } } static class B extends A { @Override public boolean equals(Object obj) { return obj instanceof B; } } }
console:
list.contains(a)->true
list.contains(b)->false
list.contains(a)->true
list.contains(b)->true
19行和24行的输出没什么好说的，将a，b分别加入list中，list中自然会含有a，b。但是为什么20行和23行结果会不一样呢？我们先来看看contains方法内部实现
@Override public boolean contains(Object o) { return indexOf(o) != -1; }
进入indexof方法
@Override public int indexOf(Object o) { E[] a = this.a; if (o == null) { for (int i = 0; i < a.length; i++) if (a[i] == null) return i; } else { for (int i = 0; i < a.length; i++) if (o.equals(a[i])) return i; } return -1; }
可以看出最终调用的是对象的equals方法，所以当调用20行代码list.contains(b)时，实际上调用了
b.equals(a[i]),a[i]是集合中的元素集合中的类型而且为A类型(只添加了a对象)，虽然B继承了A,但此时
a[i] instanceof B
结果为false，equals方法也就会返回false；而当调用23行代码list.contains(a)时，实际上调用了a.equal(a[i]),其中a[i]是集合中的元素而且为B类型(只添加了b对象)，由于B类型肯定是A类型（B继承了A），所以
a[i] instanceof A
结果为true，equals方法也就会返回true，这就是整个过程。但很明显结果是有问题的，因为我们的 list的泛型是A,而B又继承了A，此时无论加入了a还是b，都属于同种类型，所以无论是contains(a),还是contains(b)都应该返回true才算正常。而最终却出现上面的结果，这就是因为重写equals方法时没遵守对称性原则导致的结果，如果没遵守传递性也同样会造成上述的结果。当然这里的解决方法也比较简单，我们只要将B类的equals方法修改一下就可以了。
static class B extends A{ @Override public boolean equals(Object obj) { if(obj instanceof B){ return true; } return super.equals(obj); } }
到此，我们也应该明白了重写equals必须遵守几点原则的重要性了。当然这里不止是list，只要是java集合类或者java类库中的其他方法，重写equals不遵守5点原则的话，都可能出现意想不到的结果。
五.为什么重写equals()的同时还得重写hashCode()
一个很常见的错误根源在于没有覆盖hashCode方法。在每个覆盖了equals方法的类中，也必须覆盖hashCode方法。如果不这样做的话，就会违反Object.hashCode的通用约定，从而导致该类无法结合所有基于散列的集合一起正常运作，这样的集合包括HashMap、HashSet和Hashtable。
1.在应用程序的执行期间，只要对象的equals方法的比较操作所用到的信息没有被修改，那么对这同一个对象调用多次，hashCode方法都必须始终如一地返回同一个整数。在同一个应用程序的多次执行过程中，每次执行所返回的整数可以不一致。
2.如果两个对象根据equals()方法比较是相等的，那么调用这两个对象中任意一个对象的hashCode方法都必须产生同样的整数结果。
3.如果两个对象根据equals()方法比较是不相等的，那么调用这两个对象中任意一个对象的hashCode方法，则不一定要产生相同的整数结果。但是程序员应该知道，给不相等的对象产生截然不同的整数结果，有可能提高散列表的性能。
六、eqauls方法和hashCode方法关系
(1)同一对象上多次调用hashCode()方法，总是返回相同的整型值。
(2)如果a.equals(b)，则一定有a.hashCode() 一定等于 b.hashCode()。
(3)如果!a.equals(b)，则a.hashCode() 不一定等于 b.hashCode()。此时如果a.hashCode() 总是不等于 b.hashCode()，会提高hashtables的性能。
(4)a.hashCode()==b.hashCode() 则 a.equals(b)可真可假
(5)a.hashCode()！= b.hashCode() 则 a.equals(b)为假。
关于这两个方法的重要规范：
规范1：若重写equals(Object obj)方法，有必要重写hashcode()方法，确保通过equals(Object obj)方法判断结果为true的两个对象具备相等的hashcode()返回值。说得简单点就是：“如果两个对象相同，那么他们的hashcode应该相等”。不过请注意：这个只是规范，如果你非要写一个类让equals(Object obj)返回true而hashcode()返回两个不相等的值，编译和运行都是不会报错的。不过这样违反了Java规范，程序也就埋下了BUG。
规范2：如果equals(Object obj)返回false，即两个对象“不相同”，并不要求对这两个对象调用hashcode()方法得到两个不相同的数。说的简单点就是：“如果两个对象不相同，他们的hashcode可能相同”。
