在重新equals方法時爲啥要重寫hashCode方法？
重寫的原則是：兩個對象根據equals方法相等，則兩個對象hashCode產生同樣的整數結
果。
其實重寫hashCode方法是爲了保證一些基於散列的集合能正常工作，這樣集合包括
（HahsMap,HashSet,HashTable）。因爲此類集合是利用hash算法與equals來區分對象的等同性。比如：對類 Test重寫了equals方法，沒有重寫hashCode方法，意味着當Test類的兩個實例a和b，在邏輯上相同（a.equals(b)==true），但是兩個實例的hashCode不同。當定義一個Map對象：
Map<Test,String> map=new HashMap<Test,String>();
map.put(a,"this is Test object");
此時若系統通過map.get(b);來獲得“this is Test object”，但返回的確是null。這是因爲
map對象將a對象放入一個散列桶中，而get方法卻在另一個散列桶中查詢，即便兩個散列碼同時在一個散列桶中，也會因爲散列碼不同而找不到。散列碼不匹配就沒有必要驗證對象的等同性，所以此處找不到返回null。由此可見，重寫hashCode方法是很有必要的，因爲你不知道你定義的類不會被別人放入hash機制的集合中。
下面是重寫equals和hashCode通用的方式：
此處摘錄《Effective java》 和轉載：http://zhangjunhd.blog.51cto.com/113473/71571/
1.設計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方法。
2.設計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。
示例：
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;
}
}