以下內容總結自《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()。
<td 230,="" 230)="" none="" repeat="" scroll="" 0%="" 50%;="" width:="" 426.1pt;="" -moz-background-clip:="" -moz-initial;="" -moz-background-origin:="" -moz-background-inline-policy:="" -moz-initial;"="" valign="top" width="568" style="padding: 0cm 5.4pt;
margin: 0px; background-color: white; border: 1pt solid windowtext; ">
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; }}
