第9条：覆盖equals时总要覆盖hashCode

每个覆盖了equals方法的类中，也必须覆盖hashCode方法。 
如果不这样的话，就会违反Object.hashCode的通用约定，从而导致该类无法结合所有基于散列的集合一起正常运作，这样的集合包括HashMap、HashSet和Hashtable。

在引用程序的执行期间，只要对象的equals方法的比较操作所用到的信息没有被修改，那么对这同一个对象调用多次，hashCode方法都必须始终如一的返回同一个整数。在一个应用程序的多次执行过程中，每次执行所返回的整数可以不一致。 
如果连个对象根绝equals方法比较是相等的，那么调用这两个对象中任意一个对象的hashCode方法都必须产生同样的整数结果。 
如果两个对象根据equals方法比较是不相等的，那么调用这两个对象中任意一个对象的hashCode方法，则不一定要蚕声不同的整数结果。但是程序员应该知道，给不相等的对象产生截然不同的整数结果，有可能提高散列表（hash table）的性能。（比如，当你一个entity只根据id比较是否相等，但是在没实例化之前，没有id数值，那么默认的equals返回false，但是hashCode返回的值却相等。） 

demo:

1. // Shows the need for overriding hashcode when you override equals - Pages 45-46  
2.   
3. import java.util.*;  
4.   
5. public final class PhoneNumber {  
6.     private final short areaCode;  
7.     private final short prefix;  
8.     private final short lineNumber;  
9.   
10.     public PhoneNumber(int areaCode, int prefix,  
11.                        int lineNumber) {  
12.         rangeCheck(areaCode,    999, "area code");  
13.         rangeCheck(prefix,      999, "prefix");  
14.         rangeCheck(lineNumber, 9999, "line number");  
15.         this.areaCode  = (short) areaCode;  
16.         this.prefix  = (short) prefix;  
17.         this.lineNumber = (short) lineNumber;  
18.     }  
19.   
20.     private static void rangeCheck(int arg, int max,  
21.                                    String name) {  
22.         if (arg < 0 || arg > max)  
23.            throw new IllegalArgumentException(name +": " + arg);  
24.     }  
25.   
26.     @Override public boolean equals(Object o) {  
27.         if (o == this)  
28.             return true;  
29.         if (!(o instanceof PhoneNumber))  
30.             return false;  
31.         PhoneNumber pn = (PhoneNumber)o;  
32.         return pn.lineNumber == lineNumber  
33.             && pn.prefix  == prefix  
34.             && pn.areaCode  == areaCode;  
35.     }  
36.   
37.     // Broken - no hashCode method!  
38.   
39.     // A decent hashCode method - Page 48  
40. //  @Override public int hashCode() {  
41. //      int result = 17;  
42. //      result = 31 * result + areaCode;  
43. //      result = 31 * result + prefix;  
44. //      result = 31 * result + lineNumber;  
45. //      return result;  
46. //  }  
47.   
48.   
49.     // Lazily initialized, cached hashCode - Page 49  
50. //  private volatile int hashCode;  // (See Item 71)  
51. //  
52. //  @Override public int hashCode() {  
53. //      int result = hashCode;  
54. //      if (result == 0) {  
55. //          result = 17;  
56. //          result = 31 * result + areaCode;  
57. //          result = 31 * result + prefix;  
58. //          result = 31 * result + lineNumber;  
59. //          hashCode = result;  
60. //      }  
61. //      return result;  
62. //  }  
63.   
64.     public static void main(String[] args) {  
65.         Map<PhoneNumber, String> m  
66.             = new HashMap<PhoneNumber, String>();  
67.         m.put(new PhoneNumber(707, 867, 5309), "Jenny");  
68.         System.out.println(m.get(new PhoneNumber(707, 867, 5309)));  
69.     }  
70. }  

结果却返回了null，是因为即使两个equals的PhoneNumber，但是，他们的hashCode却不相等。 

一个好的散列函数通常倾向于“为不相等的对象产生不相等的散列码”。 

必须排除equals比较计算中没有用到的任何域，否则很有可能违反hashCode约定的第二条。 


不要试图从散列码计算中排除掉一个对象的关键部分来提高性能。