初涉继承，关于java中重写hashcode()方法的问题

问题描述

问 题

public class Idiophones extends MusicalInstrument{
    
    public Idiophones(String origin, String hsNumber, String imageUrl,String classificationName){
        this.origin = origin;
        this.hsNumber = hsNumber;
        this.imageUrl = imageUrl;
        this.classificationName = classificationName;
    }

    public String getOrigin(){
        return origin;
    }

    public String getHsNumber(){
        return hsNumber;
    }

    public String getImageUrl(){
        return imageUrl;
    }

    public String getClassificationName(){
        return classificationName;
    }

    @Override public boolean equals(Object o) {
        if (this == o) {
            return true;
        }
        if (o == null || getClass() != o.getClass()) {
            return false;
        }

        Idiophones idiophones = (Idiophones) o;
        if (idiophones.origin.compareTo(origin) != 0) {
            return false;
        }
        else if (idiophones.hsNumber.compareTo(hsNumber) != 0){
            return false;
        }
        else if(idiophones.imageUrl.compareTo(imageUrl) != 0){
            return false;
        }
        else{
        return (idiophones.classificationName.compareTo(classificationName) == 0);
        }
    }

代码如上。
初涉继承，自己重写了一个.equals()方法，但是面对重写hashcode()方法时产生了疑惑，看到一个使用>>>32位移的解法，如下

public class Gps {

    private final double latitude;

    private final double longitude;

    public Gps(double latitude, double longitude) {
        this.latitude = latitude;
        this.longitude = longitude;
    }

    public double getLatitude() {
        return latitude;
    }

    public double getLongitude() {
        return longitude;
    }

    @Override public boolean equals(Object o) {
        if (this == o) {
            return true;
        }
        if (o == null || getClass() != o.getClass()) {
            return false;
        }

        Gps gps = (Gps) o;
        if (Double.compare(gps.latitude, latitude) != 0) {
            return false;
        }
        return (Double.compare(gps.longitude, longitude) == 0);
    }

    @Override public int hashCode() {
        int result;
        long temp;
        temp = Double.doubleToLongBits(latitude);
        result = (int) (temp ^ (temp >>> 32));
        temp = Double.doubleToLongBits(longitude);
        return 31 * result + (int) (temp ^ (temp >>> 32));
    }
}

hashcode究竟其值范围为多少，二进制是多少位？如何理解这段代码？（latitude和longtitude都是64bit的2进制序列，感觉这个解法比较取巧？并非是一个比较通用的解法）？

另外希望各位前辈能指教一下Idiophones这个class的hashcode写法，能有完整代码解释一下就最好了
还希望请各位前辈验证一下我的Idiophones中的 .equals()方法重写的是否正确，谢谢！

P.S.哪位前辈能按照代码1的内容写一下这里hashcode()方法究竟是如何重写的啊，感觉还是不知道自己理解的对不对

解决方案

实现hashCode方法的通用约定

1. 在应用程序的执行期间，只要对象的equals方法的比较操作所用到的信息没有被修改，那么对这个同一对象调用多次，hashCode方法必须始终如一地返回同一个整数。在同一个应用程序的多次执行过程中，每次执行所返回的整数可以不一致。

2. 如果两个对象根据equals(Object)方法比较是相等的，那么调用这两个对象中任意一个对象的hashCode方法都必须产生同样的整数结果。反之，如果两个对象hashCode方法返回整数结果一样，则不代表两个对象相等，因为equals方法可以被重载。

3. 如果两个对象根据equals(Object)方法比较是不相等的，那么调用这两个对象中任意一个对象的hashCode方法，则不一定要产生不同的整数结果。但，如果能让不同的对象产生不同的整数结果，则有可能提高散列表的性能。

hashCode散列码计算（来自：Effective Java）

1. 把某个非零的常数值，比如17，保存在一个名为result的int类型的变量中。

2. 对于对象中每个关键域f(指equals方法中涉及的每个域)，完成以下步骤：

   1. 为该域计算int类型的散列码c：

      1. 如果该域是boolean类型，则计算(f?1:0)。

      2. 如果该域是byte，char，short或者int类型，则计算(int)f。

      3. 如果该域是long类型，则计算(int)(f^(f>>>32))。

      4. 如果该域是float类型，则计算Float.floatToIntBits(f)。

      5. 如果该域是double类型，则计算Double.doubleToLongBits(f)，然后按照步骤2.1.3，为得到的long类型值计算散列值。

      6. 如果该域是一个对象引用，并且该类的equals方法通过递归地调用equals的方式来比较这个域，则同样为这个域递归地调用hashCode。如果需要更复杂的比较，则为这个域计算一个范式(canonical representation)，然后针对这个范式调用hashCode。如果这个域的值为null，则返回0(其他常数也行)。

      7. 如果该域是一个数组，则要把每一个元素当做单独的域来处理。也就是说，递归地应用上述规则，对每个重要的元素计算一个散列码，然后根据步骤2.2中的做法把这些散列值组合起来。如果数组域中的每个元素都很重要，可以利用发行版本1.5中增加的其中一个Arrays.hashCode方法。

   2. 按照下面的公式，把步骤2.1中计算得到的散列码c合并到result中：result = 31 * result + c; //此处31是个奇素数，并且有个很好的特性，即用移位和减法来代替乘法，可以得到更好的性能：`31*i == (i<<5) - i， 现代JVM能自动完成此优化。

3. 返回result

4. 检验并测试该hashCode实现是否符合通用约定。

---

示例实现

@Override
public int hashCode() {
    int result = 17;
    result = 31 * result + (origin == null ? 0 : origin.hashCode());
    result = 31 * result + (hsNumber == null ? 0 : hsNumber.hashCode());
    result = 31 * result + (imageUrl == null ? 0 : imageUrl.hashCode());
    result = 31 * result + (classificationName == null ? 0 : classificationName.hashCode());
    return result;
}

这篇关于初涉继承，关于java中重写hashcode()方法的问题的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！