最近我通读了这个 Developer Works Document。
该文档是关于有效且正确地定义hashCode() 和equals()，但是我无法弄清楚为什么我们需要覆盖这两个方法。
我如何才能做出有效实施这些方法的决定？
【问题讨论】：
Joshua Bloch 谈有效的 Java
您必须在每个覆盖 equals() 的类中覆盖 hashCode()。否则将导致违反 Object.hashCode() 的一般约定，这将阻止您的类与所有基于哈希的集合（包括 HashMap、HashSet 和 Hashtable）一起正常运行。
让我们通过一个例子来理解它，如果我们覆盖equals()而不覆盖hashCode()并尝试使用Map会发生什么。
假设我们有一个这样的类，如果importantField 相等，则MyClass 的两个对象相等（由eclipse 生成hashCode() 和equals()）
public class MyClass {
private final String importantField;
private final String anotherField;
public MyClass(final String equalField, final String anotherField) {
this.importantField = equalField;
this.anotherField = anotherField;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result
+ ((importantField == null) ? 0 : importantField.hashCode());
return result;
}
@Override
public boolean equals(final Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
final MyClass other = (MyClass) obj;
if (importantField == null) {
if (other.importantField != null)
return false;
} else if (!importantField.equals(other.importantField))
return false;
return true;
}
}
想象一下你有这个
MyClass first = new MyClass("a","first");
MyClass second = new MyClass("a","second");
仅覆盖 equals
如果只有equals 被覆盖，那么当您调用myMap.put(first,someValue) 时，首先将散列到某个存储桶，当您调用myMap.put(second,someOtherValue) 时，它将散列到其他存储桶（因为它们有不同的hashCode）。所以，虽然它们是相等的，因为它们没有散列到同一个桶，所以地图无法实现，它们都留在地图中。
虽然如果我们覆盖hashCode()，则没有必要覆盖equals()，让我们看看在这种特殊情况下会发生什么，我们知道MyClass的两个对象如果它们的importantField相等但我们不要覆盖equals()。
仅覆盖 hashCode
如果您只覆盖hashCode，那么当您调用myMap.put(first,someValue) 时，它首先计算其hashCode 并将其存储在给定的存储桶中。然后，当您调用 myMap.put(second,someOtherValue) 时，它应该根据 Map Documentation 将 first 替换为 second，因为它们是相等的（根据业务要求）。
但问题是 equals 没有重新定义，所以当映射散列 second 并遍历桶查看是否有对象 k 使得 second.equals(k) 为真时，它不会找到任何 @ 987654350@ 将是false。
希望清楚
【讨论】：
if you think you need to override one, then you need to override both of them 是错误的。如果你的类覆盖了equals，你需要覆盖hashCode，但反向不正确。
equals会违反Object的javadoc中的约定：“如果两个对象根据equals(Object)方法相等，那么对两个对象中的每一个调用 hashCode 方法必须产生相同的整数结果。” 当然，并非所有合约的所有部分都在所有代码中执行，但从形式上讲，这是一种违规行为，我会认为这是一个等待发生的错误。
HashMap 和 HashSet 等集合使用对象的 hashcode 值来确定它应该如何存储在集合中，并使用 hashcode再次为了定位对象
在它的收藏中。
哈希检索是一个两步过程：
hashCode()）equals()）这是一个小例子，说明为什么我们应该覆盖 equals() 和 hashcode()。
考虑一个Employee 类，它有两个字段：年龄和姓名。
public class Employee {
String name;
int age;
public Employee(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public boolean equals(Object obj) {
if (obj == this)
return true;
if (!(obj instanceof Employee))
return false;
Employee employee = (Employee) obj;
return employee.getAge() == this.getAge()
&& employee.getName() == this.getName();
}
// commented
/* @Override
public int hashCode() {
int result=17;
result=31*result+age;
result=31*result+(name!=null ? name.hashCode():0);
return result;
}
*/
}
现在创建一个类，将Employee 对象插入HashSet 并测试该对象是否存在。
public class ClientTest {
public static void main(String[] args) {
Employee employee = new Employee("rajeev", 24);
Employee employee1 = new Employee("rajeev", 25);
Employee employee2 = new Employee("rajeev", 24);
HashSet<Employee> employees = new HashSet<Employee>();
employees.add(employee);
System.out.println(employees.contains(employee2));
System.out.println("employee.hashCode(): " + employee.hashCode()
+ " employee2.hashCode():" + employee2.hashCode());
}
}
它将打印以下内容：
false
employee.hashCode(): 321755204 employee2.hashCode():375890482
现在取消注释 hashcode() 方法，执行相同的，输出将是：
true
employee.hashCode(): -938387308 employee2.hashCode():-938387308
现在你能明白为什么如果两个对象被认为相等，它们的 hashcode 必须
也可以平等？否则，您将永远无法找到该对象，因为默认
Object 类中的 hashcode 方法几乎总是提供一个唯一编号
对于每个对象，即使 equals() 方法被覆盖，使得两个
或多个对象被认为是相等的。如果对象有多相等并不重要
他们的 hashcode 没有反映这一点。再来一次：如果两个对象相等，它们的
hashcodes 也必须相等。
【讨论】：
您必须在每个 覆盖 equals() 的类。失败 这样做将导致违反 总合同 Object.hashCode()，这将防止 你的班级无法正常运作 结合所有基于哈希的 集合，包括 HashMap， HashSet 和 Hashtable。
来自 Effective Java，作者 Joshua Bloch
通过一致地定义equals() 和hashCode()，您可以提高您的类作为基于哈希的集合中的键的可用性。正如 hashCode 的 API 文档所解释的那样：“支持这种方法是为了哈希表，例如 java.util.Hashtable 提供的哈希表。”
关于如何有效实施这些方法的问题的最佳答案是建议您阅读Effective Java 的第 3 章。
【讨论】：
hashCode() 也没关系。
身份不是平等的。
== 测试身份。equals(Object obj) 方法比较相等测试（即我们需要通过覆盖方法来判断相等）为什么我需要覆盖 Java 中的 equals 和 hashCode 方法？
首先我们要了解equals方法的使用。
为了识别两个对象之间的差异，我们需要重写 equals 方法。
例如：
Customer customer1=new Customer("peter");
Customer customer2=customer1;
customer1.equals(customer2); // returns true by JVM. i.e. both are refering same Object
------------------------------
Customer customer1=new Customer("peter");
Customer customer2=new Customer("peter");
customer1.equals(customer2); //return false by JVM i.e. we have two different peter customers.
------------------------------
Now I have overriden Customer class equals method as follows:
@Override
public boolean equals(Object obj) {
if (this == obj) // it checks references
return true;
if (obj == null) // checks null
return false;
if (getClass() != obj.getClass()) // both object are instances of same class or not
return false;
Customer other = (Customer) obj;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name)) // it again using bulit in String object equals to identify the difference
return false;
return true;
}
Customer customer1=new Customer("peter");
Customer customer2=new Customer("peter");
Insteady identify the Object equality by JVM, we can do it by overring equals method.
customer1.equals(customer2); // returns true by our own logic
现在hashCode方法可以很容易理解了。
hashCode 生成整数以便将对象存储在 HashMap、HashSet 等数据结构中。
假设我们如上覆盖Customer的equals方法，
customer1.equals(customer2); // returns true by our own logic
当我们将对象存储在桶中时使用数据结构（桶是文件夹的一个花哨的名称）。如果我们使用内置哈希技术，对于以上两个客户，它会生成两个不同的哈希码。所以我们将同一个相同的对象存储在两个不同的地方。为避免此类问题，我们还应基于以下原则重写 hashCode 方法。
【讨论】：
简单地说，Object 中的 equals 方法检查引用是否相等，因为当属性相等时，您的类的两个实例在语义上仍然可能相等。例如，在将对象放入使用 equals 和哈希码的容器中时，这一点很重要，例如 HashMap 和 Set。假设我们有一个类：
public class Foo {
String id;
String whatevs;
Foo(String id, String whatevs) {
this.id = id;
this.whatevs = whatevs;
}
}
我们创建两个具有相同id的实例：
Foo a = new Foo("id", "something");
Foo b = new Foo("id", "something else");
没有覆盖我们得到的等于：
对吗？好吧，也许，如果这是你想要的。但是假设我们希望具有相同 id 的对象是同一个对象，无论它是否是两个不同的实例。我们覆盖等号（和哈希码）：
public class Foo {
String id;
String whatevs;
Foo(String id, String whatevs) {
this.id = id;
this.whatevs = whatevs;
}
@Override
public boolean equals(Object other) {
if (other instanceof Foo) {
return ((Foo)other).id.equals(this.id);
}
}
@Override
public int hashCode() {
return this.id.hashCode();
}
}
至于实现 equals 和 hashcode 我可以推荐使用Guava's helper methods
【讨论】：
我们为什么要覆盖 equals() 方法
在 Java 中，我们不能重载 ==、+=、-+ 等运算符的行为方式。他们以某种方式行事。因此，让我们在这里关注运算符 ==。
运算符 == 的工作原理。
它检查我们比较的 2 个引用是否指向内存中的同一个实例。只有当这 2 个引用代表内存中的同一个实例时，运算符 == 才会解析为 true。
所以现在让我们考虑下面的例子
public class Person {
private Integer age;
private String name;
..getters, setters, constructors
}
假设在您的程序中，您在不同的地方构建了 2 个 Person 对象，并且您希望对它们进行比较。
Person person1 = new Person("Mike", 34);
Person person2 = new Person("Mike", 34);
System.out.println ( person1 == person2 ); --> will print false!
从业务角度来看，这 2 个对象看起来一样吧？对于 JVM，它们是不一样的。由于它们都是使用new 关键字创建的，因此这些实例位于内存中的不同段中。因此运算符 == 将返回 false
但是如果我们不能覆盖 == 运算符，我们怎么能告诉 JVM 我们希望这两个对象被视为相同。 .equals() 方法在起作用。
您可以覆盖equals() 以检查某些对象是否具有相同的特定字段值以被视为相等。
您可以选择要比较的字段。如果我们说 2 个 Person 对象当且仅当它们具有相同的年龄和相同的名称时才会是相同的，那么 IDE 将创建类似以下的内容来自动生成 equals()
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Person person = (Person) o;
return age == person.age &&
name.equals(person.name);
}
让我们回到之前的例子
Person person1 = new Person("Mike", 34);
Person person2 = new Person("Mike", 34);
System.out.println ( person1 == person2 ); --> will print false!
System.out.println ( person1.equals(person2) ); --> will print true!
所以我们不能重载 == 运算符来按照我们想要的方式比较对象，但是 Java 给了我们另一种方式，equals() 方法，我们可以根据需要重写它。
请记住但是，如果我们不在我们的类中提供自定义版本的 .equals()（也称为覆盖），那么来自 Object 类的预定义 .equals() 和 == 运算符将行为完全相同。
从Object继承的默认equals()方法将检查两个比较实例在内存中是否相同！
我们为什么要覆盖 hashCode() 方法
Java 中的一些数据结构（如 HashSet、HashMap）基于应用于这些元素的哈希函数来存储它们的元素。哈希函数是hashCode()
如果我们可以选择覆盖.equals() 方法，那么我们也必须选择覆盖hashCode() 方法。这是有原因的。
从 Object 继承的 hashCode() 的默认实现认为内存中的所有对象都是唯一的！
让我们回到那些哈希数据结构。这些数据结构有一个规则。
HashSet不能包含重复值，HashMap不能包含重复键
HashSet 在后台使用 HashMap 实现，其中 HashSet 的每个值都作为键存储在 HashMap 中。
所以我们必须了解 HashMap 的工作原理。
简单来说，HashMap 是一个包含一些桶的原生数组。每个桶都有一个linkedList。在该linkedList 中存储了我们的密钥。 HashMap 通过应用hashCode() 方法为每个键定位正确的linkedList，然后遍历该linkedList 的所有元素，并对每个元素应用equals() 方法以检查该元素是否已包含在那里。不允许有重复的键。
当我们在 HashMap 中放入一些东西时，键存储在其中一个链接列表中。该键将存储在哪个linkedList 中，由该键上的hashCode() 方法的结果显示。因此，如果key1.hashCode() 的结果为 4，则该 key1 将存储在数组的第 4 个存储桶中，即存在的linkedList 中。
默认情况下，hashCode() 方法为每个不同的实例返回不同的结果。如果我们有默认的equals()，它的行为类似于 ==，它将内存中的所有实例视为不同的对象，我们没有任何问题。
但在我们之前的示例中，我们说过如果 Person 实例的年龄和名称匹配，我们希望将其视为相等。
Person person1 = new Person("Mike", 34);
Person person2 = new Person("Mike", 34);
System.out.println ( person1.equals(person2) ); --> will print true!
现在让我们创建一个映射来将这些实例存储为键，并将一些字符串作为对值
Map<Person, String> map = new HashMap();
map.put(person1, "1");
map.put(person2, "2");
在 Person 类中，我们没有覆盖 hashCode 方法，但我们已经覆盖了 equals 方法。由于默认的hashCode 为不同的java 实例提供不同的结果person1.hashCode() 和person2.hashCode() 有很大的机会产生不同的结果。
我们的地图可能以不同链接列表中的人结束。
这违背了HashMap的逻辑
一个HashMap不允许有多个相等的键！
但我们现在有，原因是从 Object Class 继承的默认 hashCode() 还不够。不是在我们覆盖了 Person 类的 equals() 方法之后。
这就是为什么我们必须在重写 equals 方法之后再重写 hashCode() 方法的原因。
现在让我们解决这个问题。让我们重写我们的hashCode() 方法来考虑equals() 考虑的相同字段，即age, name
public class Person {
private Integer age;
private String name;
..getters, setters, constructors
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Person person = (Person) o;
return age == person.age &&
name.equals(person.name);
}
@Override
public int hashCode() {
return Objects.hash(name, age);
}
}
现在让我们再次尝试将这些键保存在我们的 HashMap 中
Map<Person, String> map = new HashMap();
map.put(person1, "1");
map.put(person2, "2");
person1.hashCode() 和person2.hashCode() 肯定是一样的。假设它是 0。
HashMap 将转到存储桶 0 并在其中 LinkedList 将 person1 保存为值为“1”的键。对于第二个放置的 HashMap 足够智能，当它再次进入存储桶 0 以保存值为“2”的 person2 键时，它将看到那里已经存在另一个相等的键。所以它会覆盖以前的密钥。所以最终我们的 HashMap 中只会存在 person2 键。
现在我们符合 Hash Map 的规则，即不允许多个相等的键！
【讨论】：
..getters, setters, constructors。您在Objects.hash(name, age) 中使用的字段应始终为final。否则对象的哈希码可能会被更改，这将导致Set/Map 和其他人出现很多问题。见docs.oracle.com/javase/6/docs/api/java/lang/…
让我用非常简单的话来解释这个概念。
首先从更广泛的角度来看，我们有集合，而 hashmap 是集合中的数据结构之一。
要理解为什么我们必须同时覆盖equals和hashcode方法，如果需要先了解什么是hashmap和做什么。
hashmap 是一种数据结构，它以数组方式存储数据的键值对。比方说 a[]，其中 'a' 中的每个元素都是一个键值对。
此外，上述数组中的每个索引都可以是链表，从而在一个索引处具有多个值。
现在为什么要使用哈希图？
如果我们必须在一个大数组中进行搜索，那么在每个数组中搜索它们是否效率不高，那么哈希技术告诉我们，我们可以使用一些逻辑对数组进行预处理，并根据该逻辑对元素进行分组，即散列
EG：我们有数组 1,2,3,4,5,6,7,8,9,10,11，我们应用哈希函数 mod 10，因此 1,11 将组合在一起。因此，如果我们必须在前一个数组中搜索 11，那么我们将不得不迭代整个数组，但是当我们对它进行分组时，我们会限制我们的迭代范围，从而提高速度。为简单起见，用于存储上述所有信息的数据结构可以视为二维数组
现在除了上面的 hashmap 还告诉它不会在其中添加任何 Duplicates。这就是我们必须重写equals和hashcode的主要原因
所以当它说解释hashmap的内部工作时，我们需要找到hashmap有哪些方法以及它是如何遵循我上面解释的上述规则的
所以 hashmap 有一个叫做 put(K,V) 的方法，根据 hashmap 它应该遵循上面的规则，有效地分配数组并且不添加任何重复
所以 put 的作用是首先为给定键生成哈希码，以决定该值应该进入哪个索引。如果该索引处没有任何内容，那么新值将被添加到那里，如果某些东西已经存在存在那里，那么应该在该索引处的链表末尾添加新值。但请记住，不应根据哈希图的所需行为添加重复项。所以假设你有两个 Integer 对象 aa=11,bb=11。
作为从对象类派生的每个对象，比较两个对象的默认实现是比较引用而不是对象内部的值。因此，在上述情况下，尽管语义上相等，但相等性测试都将失败，并且可能存在具有相同哈希码和相同值的两个对象，从而创建重复项。如果我们覆盖，那么我们可以避免添加重复项。 也可以参考Detail working
import java.util.HashMap;
public class Employee {
String name;
String mobile;
public Employee(String name,String mobile) {
this.name = name;
this.mobile = mobile;
}
@Override
public int hashCode() {
System.out.println("calling hascode method of Employee");
String str = this.name;
int sum = 0;
for (int i = 0; i < str.length(); i++) {
sum = sum + str.charAt(i);
}
return sum;
}
@Override
public boolean equals(Object obj) {
// TODO Auto-generated method stub
System.out.println("calling equals method of Employee");
Employee emp = (Employee) obj;
if (this.mobile.equalsIgnoreCase(emp.mobile)) {
System.out.println("returning true");
return true;
} else {
System.out.println("returning false");
return false;
}
}
public static void main(String[] args) {
// TODO Auto-generated method stub
Employee emp = new Employee("abc", "hhh");
Employee emp2 = new Employee("abc", "hhh");
HashMap<Employee, Employee> h = new HashMap<>();
//for (int i = 0; i < 5; i++) {
h.put(emp, emp);
h.put(emp2, emp2);
//}
System.out.println("----------------");
System.out.println("size of hashmap: "+h.size());
}
}
【讨论】：
hashCode()：
如果你只重写 hash-code 方法，什么都不会发生，因为它总是为每个对象返回一个新的 hashCode 作为 Object 类。
equals()：
如果你只重写 equals 方法，如果 a.equals(b) 为真，则意味着 a 和 b 的 hashCode 必须相同，但这不会发生，因为你没有重写 hashCode 方法。
注意：Object 类的hashCode() 方法总是为每个对象返回一个新的hashCode。
因此，当您需要在基于散列的集合中使用您的对象时，您必须同时覆盖 equals() 和 hashCode()。
【讨论】：
Java 制定了一个规则
“如果两个对象使用 Object 类的 equals 方法相等，那么 hashcode 方法应该为这两个对象赋予相同的值。”
因此，如果在我们的类中重写 equals()，我们也应该重写 hashcode() 方法以遵循此规则。
equals() 和 hashcode() 这两种方法都在 Hashtable 中使用，例如，将值存储为键值对。如果我们覆盖一个而不是另一个，如果我们使用这样的对象作为键，Hashtable 可能无法正常工作。
【讨论】：
因为如果您不覆盖它们，您将使用 Object 中的默认实现。
鉴于实例相等性和 hascode 值通常需要了解构成对象的内容，它们通常需要在您的类中重新定义以具有任何实际意义。
【讨论】：
为了使用我们自己的类对象作为 HashMap、Hashtable 等集合中的键，我们应该通过了解集合的内部工作来覆盖这两个方法（hashCode() 和 equals()）。否则，会导致我们意想不到的错误结果。
【讨论】：
添加到@Lombo 的答案
什么时候需要覆盖 equals() ？
Object的equals()的默认实现是
public boolean equals(Object obj) {
return (this == obj);
}
这意味着两个对象只有在它们具有相同的内存地址时才会被认为是相等的，只有当你是 将对象与自身进行比较。
但是如果两个对象的值相同，您可能希望将它们视为相同 或更多属性（请参阅@Lombo 的答案中给出的示例）。
因此，您将在这些情况下覆盖 equals()，并给出自己的平等条件。
我已经成功实现了 equals() 并且效果很好。那么为什么他们还要求覆盖 hashCode() 呢？
好吧。只要你不在你的用户定义的类上使用“Hash” based Collections，就可以了。
但在未来的某个时候，您可能想要使用HashMap 或HashSet，如果您不使用override 和“正确实现”hashCode()，这些基于哈希的集合将不会按预期工作。
仅覆盖等于（添加到 @Lombo 的答案）
myMap.put(first,someValue)
myMap.contains(second); --> But it should be the same since the key are the same.But returns false!!! How?
首先HashMap检查second的hashCode是否与first相同。
只有当值相同时，才会继续检查同一个桶中的相等性。
但是这里这 2 个对象的 hashCode 是不同的（因为它们有不同的内存地址 - 来自默认实现）。 因此，它甚至不会检查是否相等。
如果你在重写的 equals() 方法中有一个断点，如果它们有不同的 hashCode，它就不会介入。
contains() 检查 hashCode() 并且只有当它们相同时才会调用您的 equals() 方法。
为什么我们不能让 HashMap 检查所有桶中的相等性？所以我没有必要重写 hashCode() !!
那么您就错过了基于哈希的集合的要点。 考虑以下几点：
Your hashCode() implementation : intObject%9.
以下是以桶的形式存储的key。
Bucket 1 : 1,10,19,... (in thousands)
Bucket 2 : 2,20,29...
Bucket 3 : 3,21,30,...
...
说，你想知道地图是否包含键 10。 你想搜索所有的桶吗？还是只搜索一个存储桶？
根据 hashCode，您可以确定如果存在 10，则它必须存在于 Bucket 1 中。 所以只有 Bucket 1 会被搜索到！！
【讨论】：
class A {
int i;
// Hashing Algorithm
if even number return 0 else return 1
// Equals Algorithm,
if i = this.i return true else false
}
hashCode() 计算哈希值以确定
bucket 并使用equals() 方法查找该值是否已经存在
存在于桶中。如果不是，它将添加，否则将替换为当前值hashCode() 查找条目（存储桶），然后
equals()在Entry中查找值如果两者都被覆盖，
地图A>
Map.Entry 1 --> 1,3,5,...
Map.Entry 2 --> 2,4,6,...
如果等于没有被覆盖
地图A>
Map.Entry 1 --> 1,3,5,...,1,3,5,... // Duplicate values as equals not overridden
Map.Entry 2 --> 2,4,6,...,2,4,..
如果 hashCode 没有被覆盖
地图A>
Map.Entry 1 --> 1
Map.Entry 2 --> 2
Map.Entry 3 --> 3
Map.Entry 4 --> 1
Map.Entry 5 --> 2
Map.Entry 6 --> 3 // Same values are Stored in different hasCodes violates Contract 1
So on...
HashCode 等价合约
【讨论】：
1) 常见错误如下例所示。
public class Car {
private String color;
public Car(String color) {
this.color = color;
}
public boolean equals(Object obj) {
if(obj==null) return false;
if (!(obj instanceof Car))
return false;
if (obj == this)
return true;
return this.color.equals(((Car) obj).color);
}
public static void main(String[] args) {
Car a1 = new Car("green");
Car a2 = new Car("red");
//hashMap stores Car type and its quantity
HashMap<Car, Integer> m = new HashMap<Car, Integer>();
m.put(a1, 10);
m.put(a2, 20);
System.out.println(m.get(new Car("green")));
}
}
没有找到绿色汽车
2。 hashCode()引起的问题
问题是由未覆盖的方法hashCode()引起的。 equals() 和 hashCode() 之间的合约是：
如果两个对象具有相同的哈希码，它们可能相等也可能不相等。
public int hashCode(){
return this.color.hashCode();
}
【讨论】：
在使用Value Objects 时很有用。以下是Portland Pattern Repository的摘录：
值对象的例子是事物 比如数字、日期、金钱和 字符串。通常，它们很小 使用相当广泛的对象。 他们的身份是基于他们的状态 而不是他们的对象身份。 这样，您可以拥有多个副本 相同的概念值对象。
所以我可以有多个副本 表示 1 月 16 日的对象 1998. 这些副本中的任何一个都将彼此相等。对于一个小 像这样的对象，通常是 更容易创建新的和移动 他们在身边而不是依靠 单个对象来表示日期。
值对象应始终覆盖 Java 中的 .equals() （或 Smalltalk 中的 = ）。 （请记住将 .hashCode() 覆盖为 好吧。）
【讨论】：
假设您有聚合两个其他 (B) (C) 的类 (A)，并且您需要将 (A) 的实例存储在哈希表中。默认实现仅允许区分实例，但不允许区分 (B) 和 (C)。所以 A 的两个实例可能相等，但默认不允许您以正确的方式比较它们。
【讨论】：
考虑在桶中收集所有黑色的球。你的工作是为这些球上色，并将其用于适当的游戏，
对于网球 - 黄色，红色。 板球 - 白色
现在水桶有黄色、红色和白色三种颜色的球。现在你做了着色只有你知道哪个颜色是哪个游戏的。
给球上色 - 散列。 为比赛选择球 - 等于。
如果你做了着色并且有人选择板球或网球的球，他们不会介意颜色！！！
【讨论】：
我正在研究解释“如果您只覆盖 hashCode，那么当您调用 myMap.put(first,someValue) 时，它首先会计算其 hashCode 并将其存储在给定的存储桶中。然后当您调用 myMap.put(first,someOtherValue) 时，它应该将 first 替换为 second根据地图文档，因为它们是平等的（根据我们的定义）。” ：
我认为当我们第二次添加 myMap 时，它应该是像 myMap.put(second,someOtherValue) 这样的“第二个”对象
【讨论】：
方法equals和hashcode在对象类中定义。默认情况下，如果equals方法返回true，那么系统会进一步检查哈希码的值。如果 2 个对象的哈希码也相同，则对象将被视为相同。因此，如果您只覆盖 equals 方法，那么即使覆盖的 equals 方法指示 2 个对象相等，系统定义的哈希码也可能不会指示 2 个对象相等。所以我们也需要覆盖哈希码。
【讨论】：
true 的 equals 不会被视为匹配。另一方面，如果集合注意到事物不能具有相同的哈希码，它们可能不会注意到它们是相等的。
Java 中的 Equals 和 Hashcode 方法
它们是 java.lang.Object 类的方法，该类是所有类的超类（自定义类以及其他在 java API 中定义的类）。
实施：
公共布尔等于（对象 obj）
public int hashCode()
公共布尔等于（对象 obj）
此方法只是检查两个对象引用 x 和 y 是否引用同一个对象。即它检查是否 x == y。
它是自反的： 对于任何参考值 x，x.equals(x) 应该返回 true。
它是对称的： 对于任何参考值 x 和 y，当且仅当 y.equals(x) 返回 true 时，x.equals(y) 才应该返回 true。
它是传递性的： 对于任何参考值 x、y 和 z，如果 x.equals(y) 返回 true 并且 y.equals(z) 返回 true，则 x.equals(z ) 应该返回 true。
这是一致的： 对于任何参考值 x 和 y，x.equals(y) 的多次调用始终返回 true 或始终返回 false，前提是对象上的 equals 比较中没有使用任何信息修改。
对于任何非空引用值 x，x.equals(null) 应该返回 假的。
public int hashCode()
此方法返回调用此方法的对象的哈希码值。此方法以整数形式返回哈希码值，并支持基于哈希的集合类，例如 Hashtable、HashMap、HashSet 等。必须在每个重写 equals 方法的类中重写此方法。
hashCode的通用合约是：
只要在 Java 应用程序执行期间对同一个对象多次调用它，hashCode 方法必须始终返回相同的整数，前提是没有修改对象上相等比较中使用的信息。
这个整数不需要从一个应用程序的一次执行到同一应用程序的另一次执行保持一致。
如果两个对象根据equals(Object)方法相等，那么对两个对象中的每一个调用hashCode方法必须产生相同的整数结果。
如果根据 equals(java.lang.Object) 方法，如果两个对象不相等，则不需要对两个对象中的每一个调用 hashCode 方法都必须产生不同的整数结果。但是，程序员应该意识到，为不相等的对象生成不同的整数结果可能会提高哈希表的性能。
相等的对象必须产生相同的哈希码，只要它们是 相等，但不相等的对象不需要产生不同的哈希码。
资源：
【讨论】：
如果您覆盖equals() 而不是hashcode()，除非您或其他人在像HashSet 这样的散列集合中使用该类类型，否则您不会发现任何问题。
在我之前的人已经多次清楚地解释了记录在案的理论，我只是在这里提供一个非常简单的例子。
考虑一个类，其equals() 需要表示定制的内容：-
public class Rishav {
private String rshv;
public Rishav(String rshv) {
this.rshv = rshv;
}
/**
* @return the rshv
*/
public String getRshv() {
return rshv;
}
/**
* @param rshv the rshv to set
*/
public void setRshv(String rshv) {
this.rshv = rshv;
}
@Override
public boolean equals(Object obj) {
if (obj instanceof Rishav) {
obj = (Rishav) obj;
if (this.rshv.equals(((Rishav) obj).getRshv())) {
return true;
} else {
return false;
}
} else {
return false;
}
}
@Override
public int hashCode() {
return rshv.hashCode();
}
}
现在考虑这个主类：-
import java.util.HashSet;
import java.util.Set;
public class TestRishav {
public static void main(String[] args) {
Rishav rA = new Rishav("rishav");
Rishav rB = new Rishav("rishav");
System.out.println(rA.equals(rB));
System.out.println("-----------------------------------");
Set<Rishav> hashed = new HashSet<>();
hashed.add(rA);
System.out.println(hashed.contains(rB));
System.out.println("-----------------------------------");
hashed.add(rB);
System.out.println(hashed.size());
}
}
这将产生以下输出：-
true
-----------------------------------
true
-----------------------------------
1
我对结果很满意。但是，如果我没有覆盖hashCode()，它将导致噩梦，因为具有相同成员内容的Rishav 对象将不再被视为唯一，因为hashCode 将不同，默认行为生成，这里是输出：-
true
-----------------------------------
false
-----------------------------------
2
【讨论】：
在下面的示例中，如果您在 Person 类中注释掉 equals 或 hashcode 的覆盖，此代码将无法查找 Tom 的订单。使用哈希码的默认实现可能会导致哈希表查找失败。
我下面是一个简化的代码，可以按人提取人们的订单。 Person 被用作哈希表中的键。
public class Person {
String name;
int age;
String socialSecurityNumber;
public Person(String name, int age, String socialSecurityNumber) {
this.name = name;
this.age = age;
this.socialSecurityNumber = socialSecurityNumber;
}
@Override
public boolean equals(Object p) {
//Person is same if social security number is same
if ((p instanceof Person) && this.socialSecurityNumber.equals(((Person) p).socialSecurityNumber)) {
return true;
} else {
return false;
}
}
@Override
public int hashCode() { //I am using a hashing function in String.java instead of writing my own.
return socialSecurityNumber.hashCode();
}
}
public class Order {
String[] items;
public void insertOrder(String[] items)
{
this.items=items;
}
}
import java.util.Hashtable;
public class Main {
public static void main(String[] args) {
Person p1=new Person("Tom",32,"548-56-4412");
Person p2=new Person("Jerry",60,"456-74-4125");
Person p3=new Person("Sherry",38,"418-55-1235");
Order order1=new Order();
order1.insertOrder(new String[]{"mouse","car charger"});
Order order2=new Order();
order2.insertOrder(new String[]{"Multi vitamin"});
Order order3=new Order();
order3.insertOrder(new String[]{"handbag", "iPod"});
Hashtable<Person,Order> hashtable=new Hashtable<Person,Order>();
hashtable.put(p1,order1);
hashtable.put(p2,order2);
hashtable.put(p3,order3);
//The line below will fail if Person class does not override hashCode()
Order tomOrder= hashtable.get(new Person("Tom", 32, "548-56-4412"));
for(String item:tomOrder.items)
{
System.out.println(item);
}
}
}
【讨论】：
hashCode() 方法用于获取给定对象的唯一整数。这个整数用于确定桶的位置，当这个对象需要存储在一些HashTable，HashMap之类的数据结构中。默认情况下，Object 的hashCode() 方法返回和整数表示的对象存储的内存地址。
当我们将对象插入HashTable、HashMap 或HashSet 时，使用对象的hashCode() 方法。更多关于 Wikipedia.org 上的HashTables 的信息供参考。
要在地图数据结构中插入任何条目，我们需要键和值。如果键和值都是用户定义的数据类型，则键的hashCode() 将确定内部存储对象的位置。当还需要从地图中查找对象时，键的哈希码将决定在哪里搜索对象。
哈希码仅在内部指向某个“区域”（或列表、存储桶等）。由于不同的密钥对象可能具有相同的哈希码，因此哈希码本身并不能保证找到正确的密钥。然后HashTable 迭代这个区域（所有具有相同哈希码的键）并使用键的equals() 方法找到正确的键。一旦找到正确的键，就会返回为该键存储的对象。
因此，正如我们所见，hashCode() 和 equals() 方法的组合用于在 HashTable 中存储和查找对象。
注意事项：
始终使用对象的相同属性来生成hashCode() 和equals()。在我们的例子中，我们使用了员工 ID。
equals()必须一致（如果对象没有被修改，那么它必须保持返回相同的值）。
只要a.equals(b)，则a.hashCode() 必须与b.hashCode() 相同。
如果你覆盖了一个，那么你应该覆盖另一个。
http://parameshk.blogspot.in/2014/10/examples-of-comparable-comporator.html
【讨论】：
hashCode() 不用于为每个对象返回唯一的整数。那是不可能的。你自己在第四段的第二句中反驳了这一点。
String 类和包装类具有与 Object 类不同的 equals() 和 hashCode() 方法实现。 Object 类的 equals() 方法比较对象的引用，而不是内容。 Object 类的 hashCode() 方法为每个对象返回不同的哈希码，无论内容是否相同。
当你使用 Map 集合并且 key 是 Persistent 类型，StringBuffer/builder 类型时它会导致问题。由于它们不像 String 类那样覆盖 equals() 和 hashCode()，因此当您比较两个不同的对象时，即使它们具有相同的内容，equals() 也会返回 false。它将使 hashMap 存储相同的内容键。存储相同的内容键意味着它违反了 Map 的规则，因为 Map 根本不允许重复键。 因此，您在类中重写 equals() 和 hashCode() 方法并提供实现（IDE 可以生成这些方法），以便它们与 String 的 equals() 和 hashCode() 工作相同，并防止相同的内容键。
您必须与 equals() 一起覆盖 hashCode() 方法，因为 equals() 根据哈希码工作。
此外，重写 hashCode() 方法和 equals() 有助于完整地完成 equals()-hashCode() 协定：“如果两个对象相等，则它们必须具有相同的哈希码。”
什么时候需要为 hashCode() 编写自定义实现？
我们知道HashMap的内部工作是基于Hashing原理的。有一些存储条目集的存储桶。您可以根据需要自定义 hashCode() 实现，以便可以将相同的类别对象存储到相同的索引中。
当您使用put(k,v)method 将值存储到 Map 集合中时，put() 的内部实现是：
put(k, v){
hash(k);
index=hash & (n-1);
}
意思是，它生成索引，索引是根据特定关键对象的哈希码生成的。因此，请根据您的要求使用此方法生成哈希码，因为相同的哈希码条目集将存储到相同的存储桶或索引中。
就是这样！
【讨论】：
恕我直言，正如规则所说 - 如果两个对象相等，那么它们应该具有相同的哈希值，即相等的对象应该产生相等的哈希值。
如上所述，Object 中的默认 equals() 是 ==，它对地址进行比较，hashCode() 以整数形式返回地址（实际地址上的哈希），这对于不同的 Object 来说也是不同的。
如果需要在基于Hash的集合中使用自定义Objects，则需要同时重写equals()和hashCode()，例如如果我想维护Employee Objects的HashSet，如果我不使用strong hashCode 和 equals 我可能最终会覆盖两个不同的员工对象，当我使用年龄作为 hashCode() 时会发生这种情况，但是我应该使用可以是员工 ID 的唯一值。
【讨论】：
由于哈希码总是返回一个数字，因此使用数字而不是字母键检索对象总是很快。 它会怎么做？假设我们通过传递一些已经在其他对象中可用的值来创建一个新对象。现在新对象将返回与另一个对象相同的哈希值，因为传递的值是相同的。一旦返回相同的哈希值，JVM每次都会去相同的内存地址，如果有多个对象存在相同的哈希值，它会使用equals()方法来识别正确的对象。
【讨论】：
当您想在 Map 中将自定义对象作为键存储和检索时，您应该始终在自定义 Object 中覆盖 equals 和 hashCode。 例如：
Person p1 = new Person("A",23);
Person p2 = new Person("A",23);
HashMap map = new HashMap();
map.put(p1,"value 1");
map.put(p2,"value 2");
这里 p1 和 p2 将仅视为一个对象，map 的大小将仅为 1，因为它们相等。
【讨论】：
public class Employee {
private int empId;
private String empName;
public Employee(int empId, String empName) {
super();
this.empId = empId;
this.empName = empName;
}
public int getEmpId() {
return empId;
}
public void setEmpId(int empId) {
this.empId = empId;
}
public String getEmpName() {
return empName;
}
public void setEmpName(String empName) {
this.empName = empName;
}
@Override
public String toString() {
return "Employee [empId=" + empId + ", empName=" + empName + "]";
}
@Override
public int hashCode() {
return empId + empName.hashCode();
}
@Override
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (!(this instanceof Employee)) {
return false;
}
Employee emp = (Employee) obj;
return this.getEmpId() == emp.getEmpId() && this.getEmpName().equals(emp.getEmpName());
}
}
测试类
public class Test {
public static void main(String[] args) {
Employee emp1 = new Employee(101,"Manash");
Employee emp2 = new Employee(101,"Manash");
Employee emp3 = new Employee(103,"Ranjan");
System.out.println(emp1.hashCode());
System.out.println(emp2.hashCode());
System.out.println(emp1.equals(emp2));
System.out.println(emp1.equals(emp3));
}
}
在对象类中，equals(Object obj) 用于比较地址比较，这就是为什么在测试类中，如果您比较两个对象，然后 equals 方法给出 false，但是当我们覆盖 hashcode() 时，它可以比较内容并给出正确的结果。
【讨论】：
这两种方法都在 Object 类中定义。两者都是最简单的实现。因此，当您需要为这些方法添加更多实现时，您可以在类中覆盖。
例如：对象中的 equals() 方法仅检查其在引用上的相等性。因此，如果您还需要比较它的状态，那么您可以像在 String 类中那样覆盖它。
【讨论】：
这个答案中没有提到测试equals/hashcode合约。
我发现EqualsVerifier 库非常有用且全面。它也很容易使用。
此外，从头开始构建 equals() 和 hashCode() 方法涉及大量样板代码。 Apache Commons Lang 库提供 EqualsBuilder 和 HashCodeBuilder 类。这些类极大地简化了复杂类的 equals() 和 hashCode() 方法的实现。
顺便说一句，值得考虑重写toString() 方法来帮助调试。 Apache Commons Lang 库提供了 ToStringBuilder 类来帮助解决这个问题。
【讨论】：