Android 编码规范:(九)覆盖equals时总要覆盖hashCode

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

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

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

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

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

  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(7078675309), "Jenny");    
  68.         System.out.println(m.get(new PhoneNumber(7078675309)));    
  69.     }    
  70. }    
结果却返回了null,是因为即使两个equals的PhoneNumber,但是,他们的hashCode却不相等。 

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

必须排除equals比较计算中没有用到的任何域,否则很有可能违反hashCode约定的第二条。
posted @ 2012-06-04 20:24  移动应用开发  阅读(255)  评论(0编辑  收藏  举报