Java学习笔记：(09)覆盖equals时总要覆盖hashCode

每个覆盖了equals方法的类中，也必须覆盖hashCode方法。

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

在引用程序的执行期间，只要对象的equals方法的比较操作所用到的信息没有被修改，那么对这同一个对象调用多次，hashCode方法都必须始终如一的返回同一个整数。在一个应用程序的多次执行过程中，每次执行所返回的整数可以不一致。

如果连个对象根绝equals方法比较是相等的，那么调用这两个对象中任意一个对象的hashCode方法都必须产生同样的整数结果。

如果两个对象根据equals方法比较是不相等的，那么调用这两个对象中任意一个对象的hashCode方法，则不一定要蚕声不同的整数结果。但是程序员应该知道，给不相等的对象产生截然不同的整数结果，有可能提高散列表（hash table）的性能。（比如，当你一个entity只根据id比较是否相等，但是在没实例化之前，没有id数值，那么默认的equals返回false，但是hashCode返回的值却相等。）

    // Shows the need for overriding hashcode when you override equals - Pages 45-46  
      
    import java.util.*;  
      
    public final class PhoneNumber {  
        private final short areaCode;  
        private final short prefix;  
        private final short lineNumber;  
      
        public PhoneNumber(int areaCode, int prefix,  
                           int lineNumber) {  
            rangeCheck(areaCode,    999, "area code");  
            rangeCheck(prefix,      999, "prefix");  
            rangeCheck(lineNumber, 9999, "line number");  
            this.areaCode  = (short) areaCode;  
            this.prefix  = (short) prefix;  
            this.lineNumber = (short) lineNumber;  
        }  
      
        private static void rangeCheck(int arg, int max,  
                                       String name) {  
            if (arg < 0 || arg > max)  
               throw new IllegalArgumentException(name +": " + arg);  
        }  
      
        @Override public boolean equals(Object o) {  
            if (o == this)  
                return true;  
            if (!(o instanceof PhoneNumber))  
                return false;  
            PhoneNumber pn = (PhoneNumber)o;  
            return pn.lineNumber == lineNumber  
                && pn.prefix  == prefix  
                && pn.areaCode  == areaCode;  
        }  
      
        // Broken - no hashCode method!  
      
        // A decent hashCode method - Page 48  
    //  @Override public int hashCode() {  
    //      int result = 17;  
    //      result = 31 * result + areaCode;  
    //      result = 31 * result + prefix;  
    //      result = 31 * result + lineNumber;  
    //      return result;  
    //  }  
      
      
        // Lazily initialized, cached hashCode - Page 49  
    //  private volatile int hashCode;  // (See Item 71)  
    //  
    //  @Override public int hashCode() {  
    //      int result = hashCode;  
    //      if (result == 0) {  
    //          result = 17;  
    //          result = 31 * result + areaCode;  
    //          result = 31 * result + prefix;  
    //          result = 31 * result + lineNumber;  
    //          hashCode = result;  
    //      }  
    //      return result;  
    //  }  
      
        public static void main(String[] args) {  
            Map<PhoneNumber, String> m  
                = new HashMap<PhoneNumber, String>();  
            m.put(new PhoneNumber(707, 867, 5309), "Jenny");  
            System.out.println(m.get(new PhoneNumber(707, 867, 5309)));  
        }  
    }  

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

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

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