重写equals和hashCode

1.何时需要重写equals()

当一个类有自己特有的“逻辑相等概念”（不同于对象身份的概念）

2.设计equals()

1. 使用instanceof操作符检查“实参是否为正确的类型”。
   
2. 对于类中的每一个“关键域”，检查实参中的域与当前对象中对应的域值。

• 对于非float和double类型的原语类型域，使用==比较；
• 对于对象引用域，递归调用equals方法；
• 对于float域，使用Float.floatToIntBits(afloat)转换为int,再使用==比较；
• 对于数组域调用Arrays.equals()方法

3.当改写equals()的时候，总是要改写hashCode()

根据一个类的equals方法（改写后），两个截然不同的实例有可能在逻辑上是相等的,但是根据Object.hashCode()方法，它们仅仅是两个对象。因此，违反了“相等的对象必须具有相等的散列码”。

4.设计hashCode()

1. 把某个非零常数值，例如17，保存在int变量result中；
2. 对于对象中每一个关键域f(指equals方法中考虑的每一个域)；

• boolean型，计算（f ? 0:1）;
• byte,char,short型计算（int）;
• long型，计算(int) (f (f>>>32)）；
• float型，计算Float.floatToIntBits(afloat);
• double型，计算Double.doubleToLongBits(adouble)得到一个long,然后执行long的计算规则；
• 对象引用，递归调用它的hashCod（）方法；
  -数组域，对其中每个元素调用它的hashCode（）方法；

3. 将上面计算得到的散列码保存到int变量c,,然后执行result=17*result+c;
4. 返回result.

5.demo

    public class Testeq {
	private int age;
	private String name;
	    public int hashCode()
		{
			final int base=31;
			int  result=1;
			result=result*base+age;
			result=result*base+(name==null?1:name.hashCode());
			return result;
		}
	    public boolean equals(Object obj)
		{
			if(this==obj) 
			{
				return true;
			}
			if (obj==null) 
			{
				return false;
			}
			if(!this.getClass().equals(obj.getClass()))
			{
				return false;
			}
			Testeq  thisObj=(Testeq) obj;
			if(this.age!=thisObj.age)
			{
				return false;
			}
			if(!this.name.equals(thisObj.name))
			{
				return false;
			}
			return true;
		}
	}

6.equals 方法在非空对象引用上实现相等关系：

1、自反性：对于任何非空引用值 x，x.equals(x) 都应返回 true。

2、对称性：对于任何非空引用值 x 和 y，当且仅当 y.equals(x) 返回 true 时，x.equals(y) 才应返回 true。

3、传递性：对于任何非空引用值 x、y 和 z，如果 x.equals(y) 返回 true，并且 y.equals(z) 返回 true，那么 x.equals(z) 应返回 true。

4、一致性：对于任何非空引用值 x 和 y，多次调用 x.equals(y) 始终返回 true 或始终返回 false，前提是对象上 equals 比较中所用的信息没有被修改。

5、 对于任何非空引用值 x，x.equals(null) 都应返回 false。

对于上面几个规则，我们在使用的过程中最好遵守，否则会出现意想不到的错误。

7.在java中进行比较，我们需要根据比较的类型来选择合适的比较方式：

1. 对象域，使用equals方法 。
   
2. 类型安全的枚举，使用equals或== 。
   
3. 可能为null的对象域 : 使用 == 和 equals 。
   
4. 数组域 : 使用 Arrays.equals 。
   
5. 除float和double外的原始数据类型 : 使用 == 。
   
6. float类型: 使用Float.foatToIntBits转换成int类型，然后使用==。
   
7. double类型: 使用Double.doubleToLongBit转换成long类型，然后使用==。
   

8.重写equals() 和 hashCode()方法

1.经典方式

这种17和31散列码的想法来自经典的Java书籍——《Effective Java》第九条。

public class User {  
private String name;  
private int age;  
private String passport;  
//getters and setters, constructor  
@Override  
public boolean equals(Object o) {  
    if (o == this) return true;  
    if (!(o instanceof User)) {  
        return false;  
    }  
    User user = (User) o;  
    return user.name.equals(name) &&  
            user.age == age &&  
            user.passport.equals(passport);  
}  
//Idea from effective Java : Item 9  
@Override  
public int hashCode() {  
    int result = 17;  
    result = 31 * result + name.hashCode();  
    result = 31 * result + age;  
    result = 31 * result + passport.hashCode();  
    return result;  
}  
}

2.对于JDK7及以上版本，可使用java.util.Objects 来重写 equals 和 hashCode 方法

import java.util.Objects; 
public class User {  
private String name;  
private int age;  
private String passport;  
@Override  
public boolean equals(Object o) {  
    if (o == this) return true;  
    if (!(o instanceof User)) {  
        return false;  
    }  
    User user = (User) o;  
    return age == user.age &&  
            Objects.equals(name, user.name) &&  
            Objects.equals(passport, user.passport);  
}  

@Override  
public int hashCode() {  
    return Objects.hash(name, age, passport);  
}  

}

3.使用Apache Commons Lang或者Apache Commons LangEqualsBuilder 和HashCodeBuilder 方法。

import org.apache.commons.lang3.builder;  
public class User {  
private String name;  
private int age;  
private String passport;  
//getters and setters, constructor  

 @Override  
public boolean equals(Object o) {  

    if (o == this) return true;  
    if (!(o instanceof User)) {  
        return false;  
    }  
    User user = (User) o;  

    return new EqualsBuilder()  
            .append(age, user.age)  
            .append(name, user.name)  
            .append(passport, user.passport)  
            .isEquals();  
}  
@Override  
public int hashCode() {  
    return new HashCodeBuilder(17, 37)  
            .append(name)  
            .append(age)  
            .append(passport)  
            .toHashCode();  
}  
}  

9. hashCode 的常规协定

1. 在 Java 应用程序执行期间，在对同一对象多次调用 hashCode 方法时，必须一致地返回相同的整数，前提是将对象进行 equals 比较时所用的信息没有被修改。从某一应用程序的一次执行到同一应用程序的另一次执行，该整数无需保持一致。
2. 如果根据 equals(Object) 方法，两个对象是相等的，那么对这两个对象中的每个对象调用 hashCode 方法都必须生成相同的整数结果。
3. 如果根据 equals(java.lang.Object) 方法，两个对象不相等，那么对这两个对象中的任一对象上调用 hashCode 方法不 要求一定生成不同的整数结果。但是，程序员应该意识到，为不相等的对象生成不同整数结果可以提高哈希表的性能。
4. 实际上，由 Object 类定义的 hashCode 方法确实会针对不同的对象返回不同的整数。（这一般是通过将该对象的内部地址转换成一个整数来实现的，但是 JavaTM 编程语言不需要这种实现技巧。）