为什么要重写java中对象的equals方法和hashCode方法以及如何重写

 当我们写了一个类的时候，我们一般要重写这个类的equals方法，因为所有类都继承Object，而Object中的equals方法是这么写的：

   

1. public boolean equals(Object obj){

2. return this==obj;

3. }

    也就是Object中的equals方法实际上比较的是两个对象是否是同一个（包含内存地址的相等），显然当我们只想比较两个对象的数值是否相等的时候这不是我们所想要的。

    假如现在我们有一个类PersonWithOverride，有private int age和private String name两个属性，我们想要比较两个PersonWithOverride类生成的对象是否相等，我们就需要重写equals方法，看看这个equals方法是如何重写的：

1. @Override

2. public boolean equals(Object obj) {

3. if (this == obj)//如果是同一个对象 直接返回true

4. return true;

5. if (obj == null)//如果比较的为null 直接返回false

6. return false;

7. if (getClass() != obj.getClass())//两者类类型不一样直接返回false

8. return false;

9. PersonWithOverride other = (PersonWithOverride) obj;//类型转换

10. if (age != other.age)//判断数据是否相等

11. return false;

12. if (name == null) {//对于对象内的对象比较 由于要使用equals 也要注意避免出现空指针异常

13. if (other.name != null)

14. return false;

15. } else if (!name.equals(other.name))//不会出现空指针异常 因为前面判断了

16. return false;

17. return true;

18. }

    这样就重写了一个考虑得比较全面的equals方法，但是我们知道重写equals方法还需要重写hashCode方法，这是为什么呢？

    首先我们需要知道hashCode的作用，java中的hashCode的作用主要是用增加哈希存储结构（HashMap HashTable之流）的查找速度，这些哈希存储结构可以通过hashCode来确定对象在哈希存储结构中的存储位置。通过这么一个作用的描述，我们应该get到以下几点：

1、hashCode作用主要在于增加数据在哈希家族中的查询速度。

2、如果hashCode相等，他们在哈希结构中存储位置相等，但是不是同一个对象！换句话说hashCode相等，调用equals不一定相等。

3、如果equals相等，那么他们的存储位置当然相等，所以hashCode一定也是相等的。

4、根据2、3两条，重写equals方法就一定要重写hashCode方法。

  

    嗯，看到了这里，我要就是重写了equals但是就是不重写hashCode呢？我们来测试下：

    首先写一个PersonWithoutOverride类，重写equals，但是不重写hashCode：

1. package test;

2.  

3. public class PersonWithoutOverride {

4. private int age;

5. private String name;

6. public int getAge() {

7. return age;

8. }

9. public void setAge(int age) {

10. this.age = age;

11. }

12. public String getName() {

13. return name;

14. }

15. public void setName(String name) {

16. this.name = name;

17. }

18. public PersonWithoutOverride() {

19. super();

20. }

21. public PersonWithoutOverride(int age, String name) {

22. super();

23. this.age = age;

24. this.name = name;

25. }

26. @Override

27. public boolean equals(Object obj) {

28. if (this == obj)//如果是同一个对象 直接返回true

29. return true;

30. if (obj == null)//如果比较的为null 直接返回false

31. return false;

32. if (getClass() != obj.getClass())//两者类类型不一样直接返回false

33. return false;

34. PersonWithoutOverride other = (PersonWithoutOverride) obj;//类型转换

35. if (age != other.age)//判断数据是否相等

36. return false;

37. if (name == null) {//对于对象内的对象比较 也要注意避免出现空指针异常

38. if (other.name != null)

39. return false;

40. } else if (!name.equals(other.name))//不会出现空指针异常 因为前面判断了

41. return false;

42. return true;

43. }

44. }

    然后我们在测试类里用HashMap测试一下:

1. package test;

2.  

3. import java.util.HashMap;

4. import java.util.Map;

5.  

6. public class Test {

7. public static void main(String[] args) {

8. PersonWithoutOverride pn1 = new PersonWithoutOverride(1,"test");

9. PersonWithoutOverride pn2 = new PersonWithoutOverride(1,"test");

10. Map<Object,String> testMap = new HashMap<Object,String>();

11. testMap.put(pn1, "1");

12. System.out.println(testMap.get(pn2));//null

13. }

14. }

    然后我们就会发现testMap.get(pn2)竟然是null。为什么呢？因为在java的哈希系列存储结构中，get(Object obj)方法首先会根据obj.hashCode()找到obj这个对象在这个哈希存储结构中的存储位置，然后比较obj和这个存储位置上的元素是否相等，这样就增加了效率，如果hashCode不一样，说明这个key值和obj不对应（毕竟存储位置都不一样，对象当然不一样）；如果hashCode一样，然后才调用equals方法，判断这个位置存储的哪个元素是自己要寻找的，或者这个位置存储的所有元素都不是要找的obj。所以当我们没有重写hashCode方法的时候，虽然get(Object obj)中的obj和需要判断的key对象是相等的，但是hashCode不一样，于是便不能找到obj这个key的位置，当然也就找不到对应的value。

    那么正确的方法是什么样的呢：

1. @Override

2. public int hashCode() {

3. final int prime = 31;//为什么是31？因为这个数需要是质数 31是经验验证的一个能够很好地减小哈希碰撞的质数

4. int result = 1;

5. result = prime * result + age;

6. result = prime * result + ((name == null) ? 0 : name.hashCode());

7. return result;

8. }

    把这个重写的hashCode方法放到类下就可以了，这样就能保证equals返回为true的两个对象一定是hashCode相等的。这里为什么有一个final in prime = 31呢？ 因为需要一个质数来进行类似的计算，以此来减小哈希碰撞机会。设想一下，如果许多对象的hashCode都是相等的，那么一个存储地址就会有许多不同的对象，而其他地方却是空着的，这是很不合理的，而31就是一个很好地减小哈希碰撞次数的数值。