为什么我需要重写Java中的equals和hashCode方法?

让我用非常简单的话来解释这个概念。

首先，从更广泛的角度来看，我们有集合，而hashmap是集合中的数据结构之一。

要理解为什么我们必须重写equals和hashcode方法，如果需要的话，首先要理解什么是hashmap以及它的功能。

hashmap是一种以数组方式存储键值对数据的数据结构。假设是a[]，其中'a'中的每个元素都是一个键值对。

此外，上述数组中的每个索引都可以是链表，因此在一个索引上有多个值。

为什么要使用hashmap呢?

如果我们必须在一个大数组中搜索，那么搜索每个数组，如果它们不是有效的，那么哈希技术告诉我们，让我们用一些逻辑预处理数组，并根据该逻辑对元素进行分组，即哈希

例如:我们有数组1、2、3、4、5、6、7、8、9、10、11，我们应用哈希函数mod 10，所以1、11将被分组在一起。因此，如果我们必须在前一个数组中搜索11，那么我们必须迭代整个数组，但当我们对它进行分组时，我们限制了迭代的范围，从而提高了速度。为了简单起见，用于存储所有上述信息的数据结构可以看作是一个2d数组

现在除了上面的hashmap还告诉它不会在其中添加任何duplicate。这就是为什么我们要重写等号和hashcode的主要原因

因此，当我们说要解释hashmap的内部工作时，我们需要找到hashmap有什么方法，以及它如何遵循上面我解释过的规则

所以hashmap有一个方法叫as put(K,V)，根据hashmap，它应该遵循上面的规则，有效地分配数组，不添加任何重复

put所做的是首先为给定的键生成hashcode来决定值应该放在哪个索引中。如果那个下标处什么都没有，那么新值就会被加到那里，如果那里已经有了，那么新值就会被加到链表末尾那个下标处。但是请记住，不应该根据期望的hashmap行为添加重复项。假设你有两个整数对象aa=11 bb=11。

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());
}
}

考虑在一个桶中收集所有黑色的球。你的工作是像下面这样给这些球上色，并将其用于适当的游戏，

为网球-黄色，红色。 对于Cricket - White

现在水桶有三种颜色的球黄色，红色和白色。现在只有你自己知道哪个颜色适合哪个游戏。

着色球-哈希。 选择比赛用的球-等于。

如果你给球上色，然后有人选了板球或网球，他们不会介意颜色的!!

class A {
int i;
// Hashing Algorithm
if even number return 0 else return 1
// Equals Algorithm,
if i = this.i return true else false
}

• put('key'，'value')将使用hashCode()计算哈希值来确定 桶，并使用equals()方法来查找该值是否已经 出现在桶里。否则将被替换为当前值
• get('key')将使用hashCode()首先找到条目(桶) equals()来查找条目
中的值

如果两者都被覆盖，

Map< 一个 >

Map.Entry 1 --> 1,3,5,...
Map.Entry 2 --> 2,4,6,...

If =没有被覆盖

Map< 一个 >

Map.Entry 1 --> 1,3,5,...,1,3,5,... // Duplicate values as equals not overridden
Map.Entry 2 --> 2,4,6,...,2,4,..

如果hashCode没有被覆盖

Map< 一个 >

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. 根据equal方法，两个相等的键应该生成相同的hashCode
2. 生成相同hashCode的两个key不需要相等(在上面的例子中，所有偶数生成相同的hashCode)

身份不是平等。

• =操作符==测试标识符。
• equals(Object obj)方法比较相等性检验(即我们需要通过重写方法来告诉相等)

为什么我需要重写Java中的equals和hashCode方法?

首先我们要理解等号法的用法。

为了识别两个对象之间的差异，我们需要重写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的override equals方法，

customer1.equals(customer2);  // returns true by our own logic

在处理数据结构时，我们将对象存储在桶中(桶是文件夹的花哨名称)。如果我们使用内置哈希技术，对于以上两个客户，它会生成两个不同的哈希码。所以我们把相同的对象存储在两个不同的地方。为了避免这类问题，我们也应该基于以下原则重写hashCode方法。

• 不相等的实例可能具有相同的hashcode。
• 相同的实例应该返回相同的hashcode。

Bah -“你必须在每个重写equals()的类中重写hashCode()。”

[出自Joshua Bloch的《Effective Java》?］

这不是反了吗?重写hashCode可能意味着您正在编写一个哈希键类，但重写equals肯定不会。有许多类没有用作散列键，但由于其他原因确实需要逻辑相等性测试方法。如果您为它选择“等于”，那么您可能会被要求通过过度应用此规则来编写hashCode实现。这样做所实现的只是在代码库中添加未经测试的代码，这是一个等待在未来绊倒某人的恶魔。编写你不需要的代码也是反敏捷的。这是错误的(并且ide生成的函数可能与您手工制作的函数不兼容)。

他们肯定应该在被写来用作键的对象上强制设置一个接口吗?无论如何，Object永远不应该提供默认的hashCode()和equals() imho。它可能鼓励了许多破碎的散列集合。

但无论如何，我认为“规则”是前后颠倒的。与此同时，我将继续避免使用“等号”进行相等性测试方法:-(

在下面的例子中，如果您注释掉Person类中equals或hashcode的覆盖，此代码将无法查找Tom的订单。使用哈希码的默认实现可能会导致哈希表查找失败。

下面是一个简化的代码，它按Person提取人们的订单。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);
}
}
}

Java中的Equals和Hashcode方法

它们是java.lang. object类的方法，object类是所有类(自定义类以及java API中定义的其他类)的超类。

实现:

public boolean equals(对象obj)

hashCode()

public boolean equals(对象obj)

这个方法只是检查两个对象引用x和y是否引用同一个对象。例如，它检查x是否== y。

它是反射性的:对于任何参考值x, x = (x)应该返回true。

是对称的:对于任何参考值x和y，当且仅当y = (x)返回true时，x = (y)应该返回true。

它是可传递的:对于任何参考值x、y和z，如果x.x = (y)返回true，而y.y = (z)返回true，则x.x = (z)应该返回true。

它是一致的:对于任何参考值x和y, x.equals(y)的多次调用一致返回true或一致返回false，前提是对象上的等号比较中使用的信息没有被修改。

对于任何非空参考值x, x = (null)应该返回 假的。< / p >

hashCode()

此方法返回调用此方法的对象的哈希码值。此方法以整数形式返回哈希码值，支持基于哈希的集合类，如Hashtable、HashMap、HashSet等。必须在重写equals方法的每个类中重写此方法。

hashCode的一般契约是:

在Java应用程序的执行过程中，只要在同一个对象上多次调用hashCode方法，hashCode方法必须一致地返回相同的整数，前提是该对象上的等号比较中使用的信息没有被修改。

这个整数不需要在应用程序的一次执行和同一应用程序的另一次执行之间保持一致。

如果根据equals(Object)方法，两个对象相等，那么在这两个对象上调用hashCode方法必须产生相同的整数结果。

如果根据equals(java.lang.Object)方法，两个对象是不相等的，那么对每个对象调用hashCode方法必须产生不同的整数结果，这是不要求的。然而，程序员应该意识到，为不相等的对象生成不同的整数结果可能会提高哈希表的性能。

相等的对象必须产生相同的哈希码，只要它们是 相等的，但是不相等的对象不需要产生不同的哈希码

资源:

JavaRanch

图片 .

恕我冒昧，这是根据规则说的-如果两个对象相等，那么它们应该具有相同的哈希值，即相等的对象应该产生相同的哈希值。

如上所述，Object is ==中的默认equals()对地址进行比较，hashCode()返回整数形式的地址(对实际地址进行哈希)，这对于不同的Object来说也是不同的。

如果你需要在基于哈希的集合中使用自定义对象，你需要覆盖equals()和hashCode()，例如如果我想维护员工对象的HashSet，如果我不使用更强的hashCode和equals，我可能最终会覆盖两个不同的员工对象，这发生在我使用年龄作为hashCode()时，但是我应该使用唯一的值，可以是员工ID。

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()之间的契约是:

1. 如果两个对象相等，那么它们必须具有相同的哈希码。
2. 如果两个对象具有相同的哈希码，它们可能相等，也可能不相等。

   public int hashCode(){
   return this.color.hashCode();
   }
   

String类和包装器类的equals()和hashCode()方法的实现与Object类不同。Object类的equals()方法比较对象的引用，而不是内容。Object类的hashCode()方法为每个对象返回不同的hashCode，无论内容是否相同。

你必须重写hashCode()方法和equals()，因为equals()根据hashCode工作。

此外，与equals()一起重写hashCode()方法有助于完好无损equals()-hashCode()契约:“如果两个对象相等，那么它们必须具有相同的哈希码。”

什么时候需要为hashCode()编写自定义实现?

put(k, v){
hash(k);
index=hash & (n-1);
}

意思是，它生成索引，索引是基于特定键对象的hashcode生成的。所以让这个方法根据你的需求生成哈希码，因为相同的哈希码条目集将存储在相同的桶或索引中。

就是这样!

为了帮助你检查重复的对象，我们需要一个自定义的等号和hashCode。

由于hashcode总是返回一个数字，它总是快速检索使用数字而不是字母键的对象。它会怎么样?假设我们通过传递一个已经在其他对象中可用的值来创建一个新对象。现在，新对象将返回与另一个对象相同的哈希值，因为传递的值是相同的。一旦返回相同的哈希值，JVM将每次访问相同的内存地址，如果有多个对象存在相同的哈希值，它将使用equals()方法来识别正确的对象。

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)用于比较地址比较，这就是为什么在Test类中，如果你比较两个对象，则equals method给出false，但当我们重写hashcode()时，它可以比较内容并给出正确的结果。

考虑一个类，它的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

在这个回答中没有提到测试equals/hashcode契约。

我发现EqualsVerifier库非常有用和全面。它也很容易使用。

此外，从头构建equals()和hashCode()方法涉及大量样板代码。Apache Commons Lang库提供了EqualsBuilder和HashCodeBuilder类。这些类极大地简化了复杂类的equals()和hashCode()方法的实现。

顺便说一句，值得考虑重写toString()方法来帮助调试。Apache Commons Lang库提供了ToStringBuilder类来帮助实现这一点。

为什么要重写equals()方法

在Java中，我们不能重载==、+=、-+等操作符的行为。他们的行为是特定的。让我们关注一下这里的运算符==。

operator ==如何工作。

它检查我们比较的两个引用是否指向内存中的同一个实例。只有当这两个引用表示内存中的同一个实例时，运算符==才会解析为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!

这两个对象从商业角度看是一样的，对吧?对于JVM，它们是不一样的。因为它们都是用new关键字创建的，所以这些实例位于内存中的不同段中。因此运算符==将返回假

但是如果我们不能重写==操作符，我们怎么能对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()(又名重写)在我们的类中，那么预定义的.equals()来自Object类和==操作符将表现完全相同。

默认的equals()方法继承自Object，它将检查两个比较实例在内存中是否相同!

为什么要重写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中。该键将存储在哪个linkedList中，由该键上的hashCode()方法的结果显示。因此，如果key1.hashCode()的结果是4，那么key1将存储在数组的第4个桶中，在那里存在的linkedList中。

默认情况下，hashCode()方法为每个不同的实例返回不同的结果。如果我们有默认的equals()，它的行为类似于==，将内存中的所有实例视为不同的对象，我们就没有任何问题。

但在前面的示例中，我们说过，如果Person实例的年龄和名字匹配，则认为Person实例是相等的。

    Person person1 = new Person("Mike", 34);
Person person2 = new Person("Mike", 34);
System.out.println ( person1.equals(person2) );  --> will print true!

现在让我们创建一个映射，将这些实例存储为键，并使用一些字符串作为pair值

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不允许有多个相等的键!

但我们现在有了，原因是从对象类继承的默认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会转到bucket 0, LinkedList会将person1保存为值为“;1”的键。对于第二次放置HashMap是足够智能的，当它再次进入0桶时保存person2键值“;2”;它会看到另一个相等的键已经存在。它会覆盖之前的键。最后HashMap中只有person2键。

现在我们与哈希映射规则保持一致，该规则说不允许有多个相等的键!