站稳马步——（1）重写 equals 和 hashCode 方法

站稳马步

——整理 Object 类（为什么重写 equals 和 hashCode 方法）

一．             关键字：

Object 、 equals() 、 hashCode （）

二．             为什么需要重写：

众所周知， Object 是所有类的父类。但，我们在实际开发中自定义自己类时，往往需要重写 Object 中 equals 和 hashCode 方法。为什么呢？首先看看 Object 的 API 吧。

Object 类中原始写法是：

public boolean equals ( Object obj ) {

              return ( this == obj ) ;

  }

可见，原始 equals 比较的是 2 个对象的“内存地址”。但，我们往往是需要判断的是“逻辑上的内容”是否相等，如： String 、 Integer 、 Math... 等等，时而我们关心是逻辑内容上是否相等，而不关心是否指向同一对象，所以所要重写。

再者，尽管 Object 是一个具体的类，但是设计它主要是为了扩展。它所要的非 final 方法（ equals hashCode toString clone 和 finalize ）都有通用约定（ general contract ），因为它们被设计成要被覆盖（ override ）的。任何一个类，它在覆盖这些方法的时候，都有责任遵守这些通用的约定；如果不能做到这一点，其它依赖这些约定的类（例如 HashMap 和 HashSet ）就无法结合该类一起正常运行。

       JDK API 上重写 equals 约定如下：

自反性 ：

对于任何非空引用值 x ，x.equals(x) 都应返回 true 。

对称性 ：

对于任何非空引用值 x 和 y ，当且仅当 y.equals(x) 返回 true 时，x.equals(y) 才应返回 true 。

传递性 ：

对于任何非空引用值 x 、y 和 z ，如果 x.equals(y) 返回 true ，并且 y.equals(z) 返回 true ，那么 x.equals(z) 应返回 true 。

一致性 ：

对于任何非空引用值 x 和 y ，多次调用 x.equals(y) 始终返回 true 或始终返回 false ，前提是对象上 equals 比较中所用的信息没有被修改。

对于任何非空引用值 x ，x.equals(null) 都应返回 false

同时， API 规定“ 当此方法被重写时，通常有必要重写 hashCode 方法，以维护 hashCode 方法的常规协定，该协定声明相等对象必须具有相等的哈希码 “所以也要重写 hashCode 方法。

    public native int hashCode () ;

说明是一个本地方法，它的实现是根据本地机器相关的，方法返回的是对象的地址值。时而重写 hashCode 一是为了遵守 API 约定，二是重点提高对象比较时效率。

因为，在 java 集合对象中比较对象是这样的，如 HashSet 中是不可以放入重复对象的，那么在 HashSet 中又是怎样判定元素是否重复的呢？让我们看看源代码（首先要知道 HashSet 内部实际是通过 HashMap 封装的）：

public boolean add ( Object o ) { //HashSet 的 add 方法

           return map.put ( o, PRESENT ) == null ;

    }

 

public Object put ( Object key, Object value ) { //HashMap 的 put 方法

        Object k = maskNull ( key ) ;

        int hash = hash ( k ) ;

        int i = indexFor ( hash , table.length ) ;

         for ( Entry e = table [ i ] ; e != null ; e = e.next ) {

            if ( e.hash == hash && eq ( k, e.key )) { // 从这里可见先比较 hashcode

                Object oldValue = e.value;

                e.value = value;

                e.recordAccess ( this ) ;

                return oldValue;

            }

        }

        modCount++;

        addEntry ( hash , k, value, i ) ;

        return null ;

    }

 

所以在 java 的集合中，判断两个对象是否相等的规则是：
1 ，判断两个对象的 hashCode 是否相等
      如果不相等，认为两个对象也不相等，完毕
      如果相等，转入 2
2 ，判断两个对象用 equals 运算是否相等
      如果不相等，认为两个对象也不相等
      如果相等，认为两个对象相等

 

为什么是两条准则，难道用第一条不行吗？不行，因为 hashCode() 相等时， equals() 方法也可能不等 ，所以必须用第 2 条准则进行限制，才能保证加入的为非重复元素。

 

 

 

三．             例子：

1. 首先

class Student {

    String name ;

    int age ;

   

    Student ( String name , int age ){

       this . name =name ;

       this . age =age ;

    }

// 没有重写 equals 和 hashCode

}

 

/**

  * @author ydj

  * @version Apr 28, 2010 3:12:42 PM

  */

public class OverEqualsHashcodeTest {

 

    public static void main ( String [] args ){

       Set < Student > set= new HashSet < Student > () ;

      

       Student stu1= new Student ( "ydj" ,26 ) ;

       Student stu2= new Student ( "ydj" ,26 ) ;

       set.add ( stu1 ) ;

       set.add ( stu2 ) ;

      

       System .out . println ( "set.size():" +set.size ()) ;

    }

}

结果是： 2. （这个无须解释）

 

 

2. 现在重写 equals 方法如下：

    public boolean equals ( Object obj ){

       System .out . println ( "--------equals()-----------:" +obj ) ;

       if ( obj == null ){

           return false ;

       }

       if ( ! ( obj instanceof Student )){

           return false ;

       } else {

           Student oth= ( Student ) obj ;

           return this . age ==oth. age && this . name ==oth. name ;

       }

//     return true;

   }

结果是： 2. （为什么依然是 2 呢？！为什么连 equals 方法都没调用呢）

分析： 这就是为什么要重写 hashCode 的原因（ 相等对象必须具有相等的哈希码 ）。因为现在的 hashCode 依然返回各自对象的地址，就是说明此时的 hashCode 肯定不相等，故根本不会调用 equals （）。

 

3. 重写 hashCode 方法如下：

public int hashCode (){

          int res=17;

         res=31*res+ age ;

         res=31*res+ name . hashCode () ;

        

         return res;

   }

结果是： 1.

 

如果这样重写 hashCode ：

public int hashCode (){

         int res= ( int )( Math.random () *100 ) ;

         return res;

   }

这样的话，就等于没有重写了。

 

 

四．             设计 equals （）和 hashCode （）：

A ．设计equals()

[1] 使用instanceof 操作符检查“实参是否为正确的类型”。

[2] 对于类中的每一个“关键域”，检查实参中的域与当前对象中对应的域值。

[2.1] 对于非float 和double 类型的原语类型域，使用== 比较；

[2.2] 对于对象引用域，递归调用equals 方法；

[2.3] 对于float 域，使用 Float.floatToIntBits ( afloat ) 转换为int ，再使用== 比较；

[2.4] 对于double 域，使用 Double.doubleToLongBits ( adouble ) 转换为int ，再使用== 比较；

[2.5] 对于数组域，调用Arrays.equals 方法。

 

 

B. 设计hashCode()

[1] 把某个非零常数值，例如17 ，保存在int 变量result 中；

[2] 对于对象中每一个关键域f （指equals 方法中考虑的每一个域）：

[2.1]boolean 型，计算(f ? 0 : 1);

[2.2]byte,char,short 型，计算(int);

[2.3]long 型，计算(int) (f ^ (f>>>32));

[2.4]float 型，计算 Float.floatToIntBits ( afloat ) ;

[2.5]double 型，计算 Double.doubleToLongBits ( adouble ) 得到一个long ，再执行[2.3];

[2.6] 对象引用，递归调用它的hashCode 方法;

[2.7] 数组域，对其中每个元素调用它的hashCode 方法。

[3] 将上面计算得到的散列码保存到int 变量c ，然后执行 result=37*result+c;

[4] 返回result 。

 

例子：

class Unit {

    private short ashort ;

    private char achar ;

    private byte abyte ;

    private boolean abool ;

    private long along ;

    private float afloat ;

    private double adouble ;

    private Unit aObject ;

    private int [] ints ;

    private Unit [] units ;

 

    public boolean equals ( Object o ) {

       if ( ! ( o instanceof Unit ))

           return false ;

        Unit unit = ( Unit ) o ;

       return unit. ashort == ashort

              && unit. achar == achar

              && unit. abyte == abyte

              && unit. abool == abool

              && unit. along == along

              && Float.floatToIntBits ( unit. afloat ) == Float

                     .floatToIntBits ( afloat )

              && Double.doubleToLongBits ( unit. adouble ) == Double

                     .doubleToLongBits ( adouble )

              && unit. aObject . equals ( aObject ) && equalsInts ( unit. ints )

              && equalsUnits ( unit. units ) ;

    }

 

    private boolean equalsInts ( int [] aints ) {

       return Arrays.equals ( ints , aints ) ;

    }

 

    private boolean equalsUnits ( Unit [] aUnits ) {

       return Arrays.equals ( units , aUnits ) ;

    }

 

    public int hashCode () {

       int result = 17;

       result = 31 * result + ( int ) ashort ;

       result = 31 * result + ( int ) achar ;

       result = 31 * result + ( int ) abyte ;

       result = 31 * result + ( abool ? 0 : 1 ) ;

       result = 31 * result + ( int ) ( along ^ ( along >>> 32 )) ;

       result = 31 * result + Float.floatToIntBits ( afloat ) ;

       long tolong = Double.doubleToLongBits ( adouble ) ;

       result = 31 * result + ( int ) ( tolong ^ ( tolong >>> 32 )) ;

       result = 31 * result + aObject . hashCode () ;

       result = 31 * result + intsHashCode ( ints ) ;

       result = 31 * result + unitsHashCode ( units ) ;

       return result;

    }

 

    private int intsHashCode ( int [] aints ) {

       int result = 17;

       for ( int i = 0; i < aints . length ; i++ )

           result = 31 * result + aints [ i ] ;

       return result;

    }

 

    private int unitsHashCode ( Unit [] aUnits ) {

       int result = 17;

       for ( int i = 0; i < aUnits . length ; i++ )

           result = 31 * result + aUnits [ i ] . hashCode () ;

       return result;

    }

}

 

为什么要用 31 这个数呢？因为它是个奇素数。如果乘以偶数，并且乘法溢出的话，信息就会丢失，因为与 2 相乘等价于移位运算。使用素数效果不是很明显，但是习惯上都是使用素数计算散列结果。 31 有个好处的特性，即用移位代替乘法，可以得到更好的性能： 31*I = = （ I << 5 ） - I 。现代的 VM 可以自动完成这样优化。 ——《 Effctive java SE 》

 

 

五．             注意：

1.equals （）不相等的两个对象，却并不能证明他们的hashcode() 不相等。

换句话说，equals() 方法不相等的两个对象，hashcode() 有可能相等

2.hashcode() 不等，一定能推出equals() 也不等；hashcode() 相等，equals() 可能相等，也可能不等。

 

六．             参考：

1.       http://www.cnjm.net/tech/article4731.html

2.       http://zhangjunhd.blog.51cto.com/113473/71571