java重寫hashCode

如下內容總結自《 Effective Java 》。

1. 什麼時候須要重寫 equals()

當一個類有本身特有的「邏輯相等」概念（不一樣於對象身份的概念）。

2. 設計 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 方法。

3. 當改寫 equals() 的時候，老是要改寫 hashCode()

根據一個類的 equals 方法（改寫後），兩個大相徑庭的實例有可能在邏輯上是相等的，可是，根據 Object.hashCode 方法，它們僅僅是兩個對象。所以，違反了「相等的對象必須具備相等的散列碼」。

4. 設計 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 。

5. 示例

下面的這個類遵循上面的設計原則，重寫了類的 equals() 和 hashCode() 。

package com.zj.unit;

import java.util.Arrays;

 

public 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 = 37 * result + ( int ) ashort ;

       result = 37 * result + ( int ) achar ;

       result = 37 * result + ( int ) abyte ;

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

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

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

       long tolong = Double.doubleToLongBits( adouble );

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

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

       result = 37 * result + intsHashCode( ints );

       result = 37 * result + unitsHashCode( units );

       return result;

    }

 

    private int intsHashCode( int [] aints) {

       int result = 17;

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

           result = 37 * result + aints[i];

       return result;

    }

 

    private int unitsHashCode(Unit[] aUnits) {

       int result = 17;

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

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

       return result;

    }

}