为什么要重写hashCode() 和 equals()
equals()
默认的Object类里面equals()方法是根据对象所在的内存来做判断的，如果两个对象引用指向的是同一个内存，则返回true，但是，在某些场景一下，我们不想这么苛刻，比如是String类的equals()，只是判断了String.value的值，String其它的属性是不参与判断的，所以我们比较字符串的时候只是比较其中的内容，下面是String的equals()方法和hashCode()方法。
public boolean equals(Object anObject) {
if (this == anObject) {
return true;
}
if (anObject instanceof String) {
String anotherString = (String)anObject;
int n = value.length;
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;
}
public int hashCode() {
int h = hash;
if (h == 0 && value.length > 0) {
char val[] = value;
for (int i = 0; i < value.length; i++) {
h = 31 * h + val[i];
}
hash = h;
}
return h;
}hashCode()
一般而言，默认的hashCode()方法会返回一个与对象的内存地址相关的值，有时候直接就是内存地址；所以，如何两个对象的hashCode()不相等，则它们肯定是不相等；但反过来，如果两个对象的hashCode(）相等，它们不一定是相等的。
如果我们创建了属于自己的Class，还使用默认的hashCode()方法，那就可以出错，特别是在使用该Class作为HashMap的Key的时候。
重写hashCode()的基本原则
该基本原则是参考《Effective Java》Joshua Bloch's recipe
A、初始化一个整形变量，为此变量赋予一个非零的常数值，比如int result = 17;
B、选取equals方法中用于比较的所有域（之所以只选择equals()中使用的域，是为了保证上述原则的第1条），然后针对每个域的属性进行计算：
(1) boolean，c = f ? 1:0
(2) byte\char\short\int, c= (int)f
(3) long，c = (int)(f ^ (f >>> 32))
(4) float，c = Float.floatToIntBits(f)
(5) double，long l = Double.doubleToLongBits(f)，c = (int)(l ^ (l >>> 32))
(6) Object，对里面的属性采用上面同一的方法来判断
(7) 如果是数组，那么需要为每个元素当做单独的域来处理。java.util.Arrays.hashCode方法包含了8种基本类型数组和引用数组的hashCode计算，算法同上。
(8)、最后，把每个域的散列码合并到对象的哈希码中。
一个具体例子
public class Person {
private String name;
private byte[] password ;
private String nickname ; // ignore the nickname
private int age ;
private double height ;
private long birthYear ;
private float sex ;
private boolean alive;
public Person(String name, byte[] password, int age, double height, long birthYear, float sex, boolean alive , String nickname) {
this.name = name;
this.password = password;
this.nickname = nickname;
this.age = age;
this.height = height;
this.birthYear = birthYear;
this.sex = sex;
this.alive = alive;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public byte[] getPassword() {
return password;
}
public void setPassword(byte[] password) {
this.password = password;
}
public String getNickname() {
return nickname;
}
public void setNickname(String nickname) {
this.nickname = nickname;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public double getHeight() {
return height;
}
public void setHeight(double height) {
this.height = height;
}
public long getBirthYear() {
return birthYear;
}
public void setBirthYear(long birthYear) {
this.birthYear = birthYear;
}
public float getSex() {
return sex;
}
public void setSex(float sex) {
this.sex = sex;
}
public boolean isAlive() {
return alive;
}
public void setAlive(boolean alive) {
this.alive = alive;
}
/**
* Joshua Bloch's recipe
* @return int
*/
@Override
public int hashCode() {
int result = 17 ;
result = 37 * result + name.hashCode();
result = 37 * result + Arrays.hashCode(password);
result = 37 * result + age;
long l = Double.doubleToLongBits(height);
result = 37 * result + (int)(l ^ (l >>> 32));
result = 37 * result + (int)(birthYear ^ (birthYear >>> 32));
result = 37 * result + Float.floatToIntBits(sex);
result = 37 * result + (alive ? 0 : 1 );
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj){
return true;
}
if (obj instanceof Person){
Person anotherPerson = (Person)obj;
if (this.getName().equals(anotherPerson.getName())
&& Arrays.equals(this.getPassword(),anotherPerson.getPassword())
&& this.age == anotherPerson.getAge()
&& this.height == anotherPerson.getHeight()
&& this.birthYear == anotherPerson.getBirthYear()
&& this.sex == anotherPerson.getSex()
&& this.alive == anotherPerson.isAlive()
){
return true;
}else {
return false;
}
}
return false;
}
}
public class Main {
public static void main(String[] args) {
String name = "Tom";
byte [] password = "123".getBytes();
int age = 18 ;
double height = 3.14;
long birthYear = 2000 ;
float sex = 1 ;
boolean alive = true ;
Person Tom = new Person(name,password,age,height,birthYear,sex,alive,"Tom");
Person Deal = new Person(name,password,13,height,birthYear,sex,alive,"Deal");
Person Jack = new Person(name,password,age,height,birthYear,sex,alive,"Jack");
// map是根据hashcode来判断的,然后还有疑惑,尝试把 Person.hashcode函数注释再运行程序,你会明白
Map<Person,String> personStringMap = new HashMap<Person, String>(10);
personStringMap.put(Tom,"Tom");
personStringMap.put(Deal,"Deal");
System.out.println("Tom's nickname is : "+personStringMap.get(Tom));
System.out.println("Jack's nickname is : "+personStringMap.get(Jack));
System.out.println("Deal's nickname is : "+personStringMap.get(Deal));
System.out.println("is Tom equals to Jack : "+Tom.equals(Jack));
// list 的contains 是根据equal方法来判断的
List<Person> persons = new ArrayList<Person>();
persons.add(Tom);
persons.add(Deal);
System.out.println("persons contains Jack: " + persons.contains(Jack));
System.out.println("persons contains Deal: " + persons.contains(Deal));
}
}参考 http://www.cnblogs.com/kismetv/p/7191736.html
参考 https://www.cnblogs.com/dolphin0520/p/3681042.html