学步园

########################   Write according the following steps########################
1、 把某个非零常数值，比如17，保存在一个叫result的int类型的变量中。
2、 对于对象中的关键域f(指equals方法中考虑的每一个域)，完成以下步骤：
A、为该域计算int类型的散列码c:
    I、 如果该域是boolean类型，则计算(f ? 0 : 1)。
    II、 如果该域是byte、char、short或者int类型，则计算(int)f。
    III、如果该域是long类型，则计算(int)(f ^ f ( f >> 32 ) )。
    IV、 如果该域是float类型，则计算Float.floatToInitBits( f )。
    V、 如果该域是double类型，则计算Double.doubleToLongBits( f )得到一个long类型的值，再执行步骤III。
    VI、 如果该域是一个对象引用，并且该类的equals方法通过递归调用equals的方式来比较这个域，则同样对这个递归调用hashCode。
         如果要求一个更为复杂的比较，则为这个域计算一个规范表示，然后针对这个范式表示调用hashCode。
         如果这个域为NULL，则返回0或者其他常数。
    VII、如果该域是一个数组，则把每个元素当作单独的域来处理。 
        也就是说，递归地应用上述规则，对每个重要的元素计算一个散列码，
         然后根据步骤B中的做法把这些散列码组合起来。
B、 按照下面的公式，把上面步骤的C组合到result中：

   result = 17 * result + c;
3、 返回result。
4、 写完后测试是否相等的实例具有相同的散列码。
5. 例子：

import java.math.BigInteger;

public class HashCodeTest {

    private boolean boolean1;
    private byte byte1;
    private char char1;
    private short short1;
    private int int1;
    private long long1;
    private float float1;
    private double double1;
    private String string1;
    private BigInteger bigInteger1;

    @Override
    public int hashCode() {

        final int PRIME = 31;
        int result = 1;        
        result = PRIME * result + (boolean1 ? 1231 : 1237);
        result = PRIME * result + char1;
        result = PRIME * result + short1;
        result = PRIME * result + int1;
        
        long temp;
        temp = Double.doubleToLongBits(double1);
        result = PRIME * result + (int) (temp ^ (temp >>> 32));
        result = PRIME * result + Float.floatToIntBits(float1);
        
        result = PRIME * result + (int) (long1 ^ (long1 >>> 32));
        
        result = PRIME * result + ((string1 == null) ? 0 : string1.hashCode());
        result = PRIME * result + ((bigInteger1 == null) ? 0 : bigInteger1.hashCode());
        return result;
    }

    @Override
    public boolean equals(Object obj) {

        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        final HashCodeTest other = (HashCodeTest) obj;
        if (bigInteger1 == null) {
            if (other.bigInteger1 != null)
                return false;
        } else if (!bigInteger1.equals(other.bigInteger1))
            return false;
        if (boolean1 != other.boolean1)
            return false;
        if (byte1 != other.byte1)
            return false;
        if (char1 != other.char1)
            return false;
        if (Double.doubleToLongBits(double1) != Double.doubleToLongBits(other.double1))
            return false;
        if (Float.floatToIntBits(float1) != Float.floatToIntBits(other.float1))
            return false;
        if (int1 != other.int1)
            return false;
        if (long1 != other.long1)
            return false;
        if (short1 != other.short1)
            return false;
        if (string1 == null) {
            if (other.string1 != null)
                return false;
        } else if (!string1.equals(other.string1))
            return false;
        return true;
    }
}