Java中HashCode是啥？3大重写规则超详细解读

## Java中HashCode有啥用？3大重写原则详解 HashCode在Java中扮演着关键角色，尤其在HashMap、HashSet等集合类中，它能显著提升对象比较和查找的效率。本文深入解析HashCode的作用，将其比作对象的指纹，帮助快速定位。重点讲解HashCode方法的三大重写原则：一致性、相等性和不等性，确保相同对象拥有相同HashCode，不同对象尽量拥有不同HashCode，从而优化哈希表性能。同时，详细阐述HashCode与equals方法的关系，通过实例演示不重写HashCode可能导致的逻辑错误，并提供重写HashCode的最佳实践，助你写出高效、健壮的Java代码。掌握HashCode，让你的Java程序性能更上一层楼！

hashCode在Java中主要用于快速比较对象是否相等，尤其是在集合类如HashMap、HashSet中，通过hashCode可以大幅提升查找效率。1. 一致性：只要对象的属性没有改变，无论调用多少次hashCode方法，都应该返回相同的值；2. 相等性：如果两个对象通过equals方法比较是相等的，那么它们的hashCode值必须相等；3. 不等性：如果两个对象通过equals方法比较是不相等的，它们的hashCode值最好也不同，这样可以提高哈希表的性能，减少冲突。hashCode和equals的关系是：若两个对象相等（equals返回true），则它们的hashCode必须相同；但若hashCode相同，它们不一定相等。如果不重写hashCode，可能导致使用哈希表时出现逻辑错误，例如内容相同但hashCode不同的对象会被视为不同键。最佳实践包括：基于关键属性生成hashCode、避免使用可变属性、使用Objects.hash()方法、考虑性能、进行单元测试验证正确性。只有在对象永远不会放入哈希表、对象不可变且未重写equals、或性能要求极高时，才可以不重写hashCode方法，否则始终应重写以确保程序正确性和性能。

hashCode在Java中主要用于快速比较对象是否相等，尤其是在集合类如HashMap、HashSet中，通过hashCode可以大幅提升查找效率。简单来说，hashCode就像是对象的指纹，可以快速定位对象。

hashCode方法的3个重写原则是：

1. 一致性： 只要对象的属性没有改变，无论调用多少次hashCode方法，都应该返回相同的值。
2. 相等性： 如果两个对象通过equals方法比较是相等的，那么它们的hashCode值必须相等。
3. 不等性： 如果两个对象通过equals方法比较是不相等的，它们的hashCode值最好也不同，这样可以提高哈希表的性能，减少冲突。

hashCode和equals方法到底是什么关系？

hashCode和equals方法是Java中用于比较对象是否相等的两个重要方法。它们之间的关系是：如果两个对象相等（equals方法返回true），那么它们的hashCode值必须相等。反过来，如果两个对象的hashCode值相等，它们不一定相等（equals方法可能返回false）。

这个关系非常重要，尤其是在使用哈希表（如HashMap、HashSet）时。哈希表通过hashCode值来快速定位对象，如果两个相等的对象的hashCode值不同，那么在哈希表中就可能出现逻辑错误。

举个例子，假设你有一个自定义的类Person，并且重写了equals方法，只比较name和age属性。如果你没有重写hashCode方法，那么即使两个Person对象的name和age相同，它们的hashCode值也可能不同，因为默认的hashCode方法是基于对象的内存地址生成的。

class Person {
    String name;
    int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null || getClass() != obj.getClass()) return false;
        Person person = (Person) obj;
        return age == person.age && Objects.equals(name, person.name);
    }

    // 缺少 hashCode 方法
}

public class Main {
    public static void main(String[] args) {
        Person p1 = new Person("Alice", 30);
        Person p2 = new Person("Alice", 30);

        System.out.println(p1.equals(p2)); // true
        System.out.println(p1.hashCode() == p2.hashCode()); // 很有可能 false，因为没有重写hashCode
    }
}

在这种情况下，如果你将p1和p2放入HashSet中，HashSet会认为它们是两个不同的对象，因为它们的hashCode值不同，即使它们的name和age相同。这显然是不符合预期的。

因此，当你重写equals方法时，一定要同时重写hashCode方法，以保证相等的对象具有相同的hashCode值。一个简单的hashCode方法实现可以使用Objects.hash()：

import java.util.Objects;

class Person {
    String name;
    int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null || getClass() != obj.getClass()) return false;
        Person person = (Person) obj;
        return age == person.age && Objects.equals(name, person.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
}

public class Main {
    public static void main(String[] args) {
        Person p1 = new Person("Alice", 30);
        Person p2 = new Person("Alice", 30);

        System.out.println(p1.equals(p2)); // true
        System.out.println(p1.hashCode() == p2.hashCode()); // true，因为重写了hashCode
    }
}

重写hashCode方法时有哪些最佳实践？

重写hashCode方法需要遵循一些最佳实践，以确保其性能和正确性：

1. 使用对象的关键属性： hashCode方法应该基于对象中用于equals方法比较的关键属性来生成hashCode值。这意味着如果两个对象的这些关键属性相同，那么它们的hashCode值也应该相同。
2. 避免使用可变属性： 尽量避免使用可变属性来生成hashCode值。如果对象的hashCode值在其生命周期内发生改变，那么在使用哈希表时可能会导致问题。
3. 使用Objects.hash()： Java 7引入了Objects.hash()方法，可以方便地为多个属性生成hashCode值。这个方法可以处理null值，并且可以生成一个相对均匀分布的hashCode值。
4. 考虑性能： hashCode方法的性能也很重要，因为它会被频繁调用。避免在hashCode方法中进行复杂的计算或IO操作。
5. 测试hashCode方法： 编写单元测试来验证hashCode方法的正确性。确保相等的对象具有相同的hashCode值，并且hashCode值在对象的生命周期内不会发生改变。

举个例子，假设你有一个自定义的类Product，它有name、price和description三个属性。其中，只有name和price用于equals方法比较。那么，你可以这样重写hashCode方法：

import java.util.Objects;

class Product {
    String name;
    double price;
    String description;

    public Product(String name, double price, String description) {
        this.name = name;
        this.price = price;
        this.description = description;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null || getClass() != obj.getClass()) return false;
        Product product = (Product) obj;
        return Double.compare(product.price, price) == 0 && Objects.equals(name, product.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, price);
    }
}

在这个例子中，hashCode方法只使用了name和price属性，因为它们是equals方法中用于比较的关键属性。description属性被忽略了，因为它不影响对象的相等性。

不重写hashCode方法会怎么样？

如果不重写hashCode方法，那么对象将使用默认的hashCode方法，该方法通常是基于对象的内存地址生成的。这意味着即使两个对象的内容相同，它们的hashCode值也可能不同。

这会导致在使用哈希表（如HashMap、HashSet）时出现问题。例如，如果你将一个对象放入HashSet中，然后修改了该对象的内容，那么HashSet可能无法找到该对象，因为它计算出的hashCode值已经发生了改变。

更糟糕的是，如果你将两个内容相同的对象放入HashMap中，它们会被认为是两个不同的键，因为它们的hashCode值不同。这会导致HashMap的行为变得不可预测。

因此，如果你重写了equals方法，那么一定要同时重写hashCode方法，以保证相等的对象具有相同的hashCode值。这可以避免在使用哈希表时出现问题，并且可以提高程序的性能。

什么时候可以不重写hashCode方法？

在极少数情况下，可以不重写hashCode方法：

1. 永远不会将对象放入哈希表中： 如果你确定你的对象永远不会被用作HashMap或HashSet的键，那么可以不重写hashCode方法。但是，这通常是一个坏主意，因为你无法保证将来不会改变这个决定。
2. 对象是不可变的： 如果你的对象是不可变的，并且你没有重写equals方法，那么可以不重写hashCode方法。因为默认的hashCode方法是基于对象的内存地址生成的，而不可变对象的内存地址在其生命周期内不会发生改变。
3. 性能要求极高： 在某些性能要求极高的场景下，可以考虑牺牲hashCode的正确性来提高性能。但是，这通常是一个非常危险的做法，因为它可能会导致难以调试的错误。

总的来说，重写hashCode方法是一个良好的编程习惯。它可以避免在使用哈希表时出现问题，并且可以提高程序的性能。除非你有非常充分的理由，否则应该始终重写hashCode方法。

今天关于《Java中HashCode是啥？3大重写规则超详细解读》的内容介绍就到此结束，如果有什么疑问或者建议，可以在golang学习网公众号下多多回复交流；文中若有不正之处，也希望回复留言以告知！