本篇文章主要是看Java核心卷和Effective Java，从中提取出的一些总结性的方法，希望可以后续可以复习，对其进行反复理解。
一、 总论
总的来说，要想写出好的equals方法和hashcode方法是以它们的规约（Java规范中规定的）为基础的，遵循了它们的规约才能算上写出好的equals和hashcode方法,因此有必要来看看它们的规约。
一、 equals方法
在覆盖equals方法的时候，需要遵守以下几个约定：
- 自反性（reflexive），对于任何非null的引用值x，x.equals(x)必须返回true。
- 对称性（symmetric），对于任何非空null的引用x和y，当且仅当x.equals(y)为true时，y.equals(x)也为true。
- 传递性（transitive），对于任何非null的引用值x，y和z，如果x.equals(y)返回true，并且y.equals(z)也返回true，那么x.equals(z)必须返回true。
- 一致性（consistent），对于任何非null的引用x和y，只要equals的比较操作在对象中所用的信息没有被修变，多次调用x.equals(y)就会一致（直）地返回true，或者一致地返回false。
- 对于任何非null的引用值x，x.equals(null)必须返回false。
为什么会时这些规约了？可以将equals理解为数学中的等号，那么这些约定也就理所应当。
自反性和非null x有x.equals(null)一般都是成立的，我们用代码演示以下对称性和传递性的情况：
- 违背了对称性,即x.equals(y)为true，y.equals(x)为false：
class Point{
private final int x;
private final int y;
public Point(int x,int y){
this.x = x;
this.y = y;
}
@Override
public boolean equals(Object o){
if(!(o instanceof Point)) return false;
Point p = (Point)o;
return p.x==x&&p.y==y;
}
}
class ColorPoint extends Point{
private final Color color;
public ColorPoint(int x,int y,Color color){
super(x,y);
this.color = color;
}
@Override
public boolean equals(Object o){
if(!(o instanceof ColorPoint)) return false;
return super.equals(o)&&((ColorPoint)o).color == color;
}
}
public class equalsTest {
public static void main(String[] args){
Point p = new Point(2,2);
ColorPoint cp = new ColorPoint(2,2,Color.BLACK);
System.out.println(p.equals(cp));//打印为true
System.out.println(cp.equals(p));//打印为false
}
}
- 违背传递性,在上述代码中将ColorPoint类的equals方法改为如下：
class Point{
private final int x;
private final int y;
public Point(int x,int y){
this.x = x;
this.y = y;
}
@Override
public boolean equals(Object o){
if(!(o instanceof Point)) return false;
Point p = (Point)o;
return p.x==x&&p.y==y;
}
}
class ColorPoint extends Point{
private final Color color;
public ColorPoint(int x,int y,Color color){
super(x,y);
this.color = color;
}
@Override
public boolean equals(Object o){
if(!(o instanceof Point)) return false;
if(!(o instanceof ColorPoint)) return o.equals(this);
return super.equals(o)&&((ColorPoint)o).color == color;
}
}
public class equalsTest {
public static void main(String[] args){
ColorPoint cp = new ColorPoint(2,2,Color.BLACK);
Point p = new Point(2,2);
ColorPoint cp1 = new ColorPoint(2,2,Color.BLUE);
System.out.println(cp.equals(p));//打印true
System.out.println(p.equals(cp1));//打印true
System.out.println(cp.equals(cp1));//打印false
}
}
- 对于一致性的话，不要使equals方法依赖不可靠资源，例如：java.net.URL的equals方法依赖于对URL中主机IP地址的比较。将一个主机名转变成IP地址可能需要访问网络，随着时间的推移，不确保会产生相同的结果。
编写一个完美的equals方法的建议：
- 检测this与otherObject是否引用同一个对象（先执行它是对equals方法的一个优化，用最不消耗性能的判断条件去过滤掉一部分）：
if(this==otherObject) return true;
- 检测otherObject是否为null，如果为null，返回false：
if(otherObject == null) return false;
- 比较this与thisObject是否为同一个类。如果equals的语义在每个子类对象中有所改变（子类和超类使用不同的equals方法，很容易违背上述规约，而getClass就使得必须是同一个类的对象才返回true,可以避免违背规约），就使用getClass检测（但违背了里氏替换原则）：
if(getClass() != otherObject.getClass()) return false;
如果所有子类的equals都不会修改的话，就使用instanceof:
if(!(otherObject instanceof ClassName)) return false;
- 将otherObject转换为相应的类类型变量：
ClassName other = (ClassName)otherObject
- 现在开始对所有需要比较的域进行比较了。使用== 比较基本类型域，使用 equals 比较对象域。如果所有的域都匹配， 就返回 true; 否 则 返 回 false。
return fieldl == other.field
&& Objects.equa1s(fie1d2, other.field2)
&&...
如果在子类中重新定义 equals, 就要在其中包含调用 super.equals(other)。
Tips:
- 两个对象引用字段x，y进行比较的时候，为了防止为null，可以调用Objects.equals方法，当两者都为null，返回true；当其中一个为空，则返回false；当两者都不为空时，则返回x.equals(y)的结果。
- 对于数组类型的字段（域）， 可以使用静态的 Arrays.equals 方法检测相应的数组元素是否相等。
- 重写equals方法时，加上@override注解，否则，容易变成重载equals方法，而加上注解会提示是否为重写。如：
public boolean equals(Employee other)
{
return other != null
&& getClassO == other.getClass0
&& Objects.equals(name, other. name)
&& salary
&& Objects—.equals other(hireDay , sal ary , other.hireDa)
}
- 写完equals方法需要对其进行编写用例进行测试，看是否违反了其规约。
其参数应该为Object。
重写完equals方法一定需要重写hashcode方法
重写hashcode方法主要是为对象存放到散列表（hashtable,hashmap,hashset等）中做准备的，因为在散列表中涉及到大量的比较，而直接使用hashcode比较代价往往小于直接使用equals的代价，而hashcode的中也明确规定了两个对象根据equals方法比较相等，则二者hashcode必须相等，如果不重写就会违背这条，如：
class Point{
private final int x;
private final int y;
public Point(int x,int y){
this.x = x;
this.y = y;
}
@Override
public boolean equals(Object o){
if(!(o instanceof Point)) return false;
Point p = (Point)o;
return p.x==x&&p.y==y;
}
}
public class equalsTest {
public static void main(String[] args){
Point p1 = new Point(2,2);
Point p2 = new Point(2,2);
System.out.println(p1.equals(p2));//打印为true
System.out.println(p1.hashCode());//本地打印为460141958
System.out.println(p2.hashCode());//本地打印为1163157884
}
}
二、 hashcode方法
在重写hashcode方法时，需要遵循的Object（hashcode方法来自与Obejct中）规范：
- 在应用程序执行期间，只要equals方法的比较操作所用到的信息没有被修改，那么对同一个对象调用多次，hashcode方法都必须始终如一的返回同一个整数。在同一个应用程序的多次执行过程中，每次执行所返回的整数可以不一致。
- 如果两个对象根据equals方法比较时相等的，那么调用这两个对象中任意一个对象的hashcode方法都必须产生同样的整数。
- 如果两个对象根据equals方法比较时不相等的，那么调用这两个对象中任意一个对象的hashcode方法，不一定产生不同的整数。但不同的对象，产生不同整数，有可能提高散列表的性能。
编写一个好散列表的解决办法：
- 把某个非零的常数值，如17，保存在一个名为result的int类型变量中。
- 对于对象中的每个关键域f（指equals方法中涉及的每个域），完成以下步骤：
- 如果字段为boolean类型，则计算（f?1:0）
- 如果字段为byte，char，short，或者int类型，则计算（int）f
- 如果字段为long类型，则计算（int）（f^(f>>>32)）。
- 如果字段为float类型，则计算Float.floatToIntBits(f)。
- 如果字段为double类型，则计算Double.doubleToLongBits(f)，然后为计算出的long类型值计算散列值。
- 如果字段为对象引用，并且该类的equals方法通过递归地调用equals的方式来比较这个域，则同样为这个域递归的调用hashcode。如果需要更复杂的比较，则为这个字段计算一个范式（解释范式），然后针对这个范式调用hashcode，如果这个字段为null，则返回0（或者其他某个常数，但通常是0）。
- 如果字段为一个数组，则把每一个元素当中单独的字段来处理，递归应用上面的规则。
- 将上面计算的所有散列码c合并到result中：
result = 31*result + c;
- 返回result即可。
Tips:
- 计算完之后，要测试一下相同的实例是否具有相等的散列码，如果不具有，请修正它。
- 在散列码的计算过程中，必须排除在equals比较计算中没有用到的所有字段。否会违反hashcode的第二条规约，即equals相同，而hashcode却不一定相同。
- 有些散列码计算起来比较复杂，则可以将其缓存在对象中。
