Java重写equals⽅法（重点讲解）
为什么equals()⽅法要重写？
判断两个对象在逻辑上是否相等，如根据类的成员变量来判断两个类的实例是否相等，⽽继承Object中的equals⽅法只能判断两个引⽤变量是否是同⼀个对象。这样我们往往需要重写equals()⽅法。
我们向⼀个没有重复对象的集合中添加元素时，集合中存放的往往是对象，我们需要先判断集合中是否存在已知对象，这样就必须重写equals⽅法。
怎样重写equals()⽅法？
重写equals⽅法的要求：
1、⾃反性：对于任何⾮空引⽤x，x.equals(x)应该返回true。
2、对称性：对于任何引⽤x和y，如果x.equals(y)返回true，那么y.equals(x)也应该返回true。
3、传递性：对于任何引⽤x、y和z，如果x.equals(y)返回true，y.equals(z)返回true，那么x.equals(z)也应该返回true。
4、⼀致性：如果x和y引⽤的对象没有发⽣变化，那么反复调⽤x.equals(y)应该返回同样的结果。
5、⾮空性：对于任意⾮空引⽤x，x.equals(null)应该返回false。
1、⾃反性原则
在JavaBean中，经常会覆写equals⽅法，从⽽根据实际业务情况来判断两个对象是否相等，⽐如我们写⼀个person类，根据姓名来判断两个person类实例对象是否相等。代码如下：
1public class Person {
2private String name;
3
4public Person(String name) {
5this.name = name;
6 }
java怎么编写7
8public String getName() {
9return name;
10 }
11
12public void setName(String name) {
13this.name = name;
14 }
15
16 @Override
17public boolean equals(Object obj) {
18if (obj instanceof Person) {
19 Person person = (Person) obj;
20return name.Name().trim());
21 }
22return false;
23 }
24
25public static void main(String[] args) {
26 Person p1 = new Person("张三");
27 Person p2 = new Person("张三 ");
28 List<Person> list = new ArrayList<Person>();
29 list.add(p1);
30 list.add(p2);
31 System.out.println("是否包含张三：" + ains(p1));
32 System.out.println("是否包含张三：" + ains(p2));
33 }
34 }
list中含有这个⽣成的person对象，结果应该为true，但是实际结果：这⾥考虑了字符串空格的问题，去除前后的空格。
是否包含张三：true
是否包含张三：false
第⼆个为什么会是false呢？
原因在于list中检查是否含有元素时是通过调⽤对象的equals⽅法来判断的，也就是说 contains（p2）传递进去会依次执⾏p2.equals(p1)、p2.equals(p2)，只要⼀个返回true，结果就是true。但是这⾥p2.e
quals(p2)返回的是false？由于我们对字符前后进⾏了空格的切割造成
p2.equals(p2)的⽐较实际上是：“张三 ”.equals（“张三”），⼀个有空格，⼀个没有空格就出错了。
这个违背了equals的⾃反性原则：对于任何⾮空引⽤x，x.equals(x)应该返回true。
这⾥只要去掉trim⽅法就可以解决。
2、对称性原则
上⾯这个例⼦，还并不是很好，如果我们传⼊null值，会怎么样呢？增加⼀条语句：Person p2=new Person(null);
结果：
是否包含张三：true
Exception in thread "main" java.lang.NullPointerException//空指针异常
原因在执⾏p2.equals(p1)时，由于p2的name是⼀个null值，所以调⽤name.equalsIgnoreCase()⽅法时就会报空指针异常。
这是在覆写equals⽅法时没有遵循对称性原则：对于任何应⽤x,y的情形，如果想x.equals(y)返回true，那么y.equals(x)，也应该返回true。
应该在equals⽅法⾥加上是否为null值的判断：
1 @Override
2public boolean equals(Object obj) {
3if (obj instanceof Person) {
4 Person person= (Person) obj;
5if (Name() == null || name == null) {
6return false;
7 }else{
8return name.Name());
9 }
10 }
11return false;
12 }
3、传递性原则
现在我们有⼀个Employee类继承⾃person类：
1public class Employee extends Person{
2private int id;
3
4
5public int getId() {
6return id;
7 }
8public void setId(int id) {
9this.id = id;
10 }
11public Employee(String name,int id) {
12super(name);
13this.id = id;
14// TODO Auto-generated constructor stub
15 }
16 @Override
17public boolean equals(Object obj) {
18if(obj instanceof Employee){
19 Employee e = (Employee)obj;
20return super.equals(obj) && e.getId() == id;
21 }
22return super.equals(obj);
23 }
24
25public static void main(String[] args){
26 Employee e1=new Employee("张三",12);
27 Employee e2=new Employee("张三",123);
28 Person p1 = new Person("张三");
29
30 System.out.println(p1.equals(e1));
31 System.out.println(p1.equals(e2));
32 System.out.println(e1.equals(e2));
33 }
34 }
只有在name和ID都相同的情况下才是同⼀个员⼯，避免同名同姓的。在main⾥定义了，两个员⼯和⼀个社会闲杂⼈员，虽然同名同姓但肯定不是同⼀个⼈。运⾏结果应该三个都是false才对。但是：
true
true
false
p1尽然等于e1，也等于e2，不是同⼀个类的实例也相等了？
因为p1.equals(e1)是调⽤⽗类的equals⽅法进⾏判断的它使⽤instanceof关键字检查e1是否是person的实例，由于employee和person是继
承关系，结果就是true了。但是放过来就不成⽴，e1,e2就不等于p1，这也是违反对称性原则的⼀个典型案例。
e1竟然不等于e2？
e1.equals(e2)调⽤的是Employee的equals⽅法，不仅要判断姓名相同还有判断⼯号相同，两者的⼯号不同，不相等时对的。但是p1等于e1，也等于e2，e1却不等于e2，这⾥就存在⽭盾，等式不传递是因为违反了equals的传递性原则：对于实例对象x、y、z；如果x.equals(y)返回true，y.equals(z)返回true，那么x.equals(z)也应该返回true。
上述情况会发⽣是因为⽗类使⽤instanceof关键字(是否是这个特定类或者是它的⼦类的⼀个实例)，⽤来判断是否是⼀个类的实例对象的，这很容易让⼦类“钻空⼦”。
想要解决也很简单，使⽤getClass进⾏类型的判断，person类的equals⽅法修改如下：
1 @Override
2public boolean equals(Object obj) {
3if (obj != null && Class() == Class()) {
4 Person person= (Person) obj;
5if (Name() == null || name == null) {
6return false;
7 }else{
8return name.Name());
9 }
10 }
11return false;
12 }
4、必须覆写hashCode⽅法这样结果就是三个false。
覆写equals⽅法就必须覆写hashCode⽅法，这是Javaer都知道的。
原因就是HashMap的底层处理机制是以数组的⽅式保存map条⽬的，这其中的关键是这个数组下标的处理机制：
依据传⼊元素的hashCode⽅法的返回值决定其数组的下标，如果该数组位置上已经有了map条⽬，且与传⼊的键值相等则不处理，若不相等则覆盖；如果数组位置没有条⽬，则插⼊，并加⼊到map条⽬的链表中。同理检查键是否存在也是根据哈希吗确定⽂职，然后遍历查键值的。
那么对象的hashCode⽅法返回的是什么呢？
他是⼀个对象的哈希码，是有Object类的本地⽅法⽣成的，确保每个对象有⼀个哈希码。
1、重写equals⽅法实例部分代码参考blog.csdn/wangloveall/article/details/7899948
重写equals⽅法的⽬的是判断两个对象的内容(内容可以有很多，⽐如同时⽐较姓名和年龄，同时相同的才是⽤⼀个对象)是否相同。
如果不重写equals，那么⽐较的将是对象的引⽤是否指向同⼀块内存地址，重写之后⽬的是为了⽐较两个对象的value值是否相等。特别指出利⽤equals⽐较⼋⼤包装对象，（如int，float等）和String类
（因为该类已重写了equals和hashcode⽅法）对象时，默认⽐较的是值，在⽐较其它⾃定义对象时都是⽐较的引⽤地址。
package com.lk.C;
class User {
private String name;
private int age;
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
public boolean equals(Object obj) {
if(this == obj) {
return true;
}
if(null == obj) {
return false;
}
Class() != Class()) {
return false;
}
User user = (User) obj;
if(this.name.equals(user.name)&&this.age == user.age) {
return true;
}
return false;
}
}
public class Test6 {
public static void main(String[] args) {
User userA = new User();
userA.setName("王明");
userA.setAge(10);
User userB = new User();
userB.setName("王明");
userB.setAge(10);
User userC = new User();
userC.setName("王亮");
userC.setAge(10);
System.out.println("userA equals userB:" + userA.equals(userB));
System.out.println("userA equals userC:" + userA.equals(userC));
}
}
userA equals userB:true
userA equals userC:false
在Java中，问什么说重写了equals⽅法都要进⽽重写Hashcode⽅法呢？
原因如下：当equals此⽅法被重写时，通常有必要重写 hashCode ⽅法，以维护 hashCode ⽅法的常规协定，该协定声明相等对象必须具有相等的哈希码。如下：
(1)当obj1.equals(obj2)为true时，obj1.hashCode() == obj2.hashCode()必须为true
(2)当obj1.hashCode() == obj2.hashCode()为false时，obj1.equals(obj2)必须为false
hashcode是⽤于散列数据的快速存取，如利⽤HashSet/HashMap/Hashtable类来存储数据时，都是根据存储对象的hashcode值来进⾏判断是否相同的。
这样如果我们对⼀个对象重写了euqals，意思是只要对象的成员变量值都相等那么euqals就等于true，但不重写hashcode，那么我们再new ⼀个新的对象，当原对象.equals（新对象）等于true时，两者的hashcode却是不⼀样的，由此将产⽣了理解的不⼀致。
2、看看下⾯的三段程序
package com.lk.C;
public class Test7 {
public static void main(String[] args) {
int a = 10;
int b = 10;
System.out.print("基本类型a==b:");
System.out.println(a == b);
System.out.println("-----");
String s1 = "abc";
String s2 = "abc";
System.out.print("String类型是s1==s2:");
System.out.println(s1 == s2);
System.out.println("-----");
String s3 = new String("abc");
String s4 = new String("abc");//可以看出==⽐较的是栈的地址是否相同
System.out.print("String类型⽤new String()是s1==s2:");
System.out.println(s3 == s4);
System.out.println(s1 == s3);
System.out.println("-----");
Integer i1 = 1;
Integer i2 = 1;
System.out.print("包装类型是i1==i2:");
System.out.println(i1 == i2);
System.out.println("-----");
Integer i3 = 128;
Integer i4 = 128;//此时输出false是因为Integer在-128-127之间会缓存，超出这个范围就不会缓存了
System.out.print("包装类型是i3==i4:");
System.out.println(i3 == i4);
System.out.println("-----");
Integer i5 = new Integer("1");
Integer i6 = new Integer("1");
System.out.print("包装类型⽤new Integer()是i5==i6:");
System.out.println(i5 == i6);//⽤new Integer()多少都不会缓存
System.out.println("-----");
A a1 = new A(1);
A a2 = new A(1);
A a3 = a2;
System.out.print("普通引⽤类型a1 == a2：");
System.out.println(a1 == a2);
System.out.println(a2 == a3);//对象赋给新对象连地址都是相同的
System.out.println("-----");
}
}
class A{
int i;
public A(int i){
this.i = i;
}
}
基本类型a==b:true
-
----
String类型是s1==s2:true
-----
String类型⽤new String()是s1==s2:false
false
-----
包装类型是i1==i2:true
-----
包装类型是i3==i4:false
-----
包装类型⽤new Integer()是i5==i6:false
-
----
普通引⽤类型a1 == a2：false
true
-----
package com.lk.C;
public class Test8 {
public static void main(String[] args) {
// TODO Auto-generated method stub
System.out.println("基本类型没有equals⽅法");
System.out.println("-----");
String s1 = "abc";
String s2 = "abc";
System.out.print("String类型的equals⽅法:");
System.out.println(s1.equals(s2));
System.out.println("-----");
String s3 = new String("abc");
String s4 = new String("abc");//可以看出⽐较equals⽅法⽐较的是堆⾥的值是否相同 System.out.print("String类型的new String()的equals⽅法：");
System.out.println(s3.equals(s4));
System.out.println("-----");
System.out.print("String⽤==赋值和⽤new String()赋值的⽐较：");
System.out.println(s1.equals(s3));
System.out.println("-----");
Integer i1 = 1;
Integer i2 = 1;
System.out.print("包装类的equals⽅法：");
System.out.println(i1.equals(i2));
System.out.println("-----");
Integer i3 = new Integer(1);
Integer i4 = new Integer(1);
System.out.print("包装类的new Integer()⽤equals⽅法：");
System.out.println(i3.equals(i4));
System.out.println("-----");
System.out.print("Integer⽤==赋值和⽤new Integer()赋值的⽐较：");
System.out.println(i1.equals(i3));
System.out.println("-----");
}
}
基本类型没有equals⽅法
-----
String类型的equals⽅法:true
版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。
发表评论