以下內容總結自《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;
}
}
本文出自 “子 孑” 博客，請務必保留此出處http://zhangjunhd.blog.51cto.com/113473/71571
