为什么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类实例对象是否相等。代码如下:
1 public classPerson {2 privateString name;3
4 publicPerson(String name) {5 this.name =name;6 }7
8 publicString getName() {9 returnname;10 }11
12 public voidsetName(String name) {13 this.name =name;14 }15
16 @Override17 public booleanequals(Object obj) {18 if (obj instanceofPerson) {19 Person person =(Person) obj;20 returnname.equalsIgnoreCase(person.getName().trim());21 }22 return false;23 }24
25 public static voidmain(String[] args) {26 Person p1 = new Person("张三");27 Person p2 = new Person("张三 ");28 List list = new ArrayList();29 list.add(p1);30 list.add(p2);31 System.out.println("是否包含张三:" +list.contains(p1));32 System.out.println("是否包含张三:" +list.contains(p2));33 }34 }
list中含有这个生成的person对象,结果应该为true,但是实际结果:这里考虑了字符串空格的问题,去除前后的空格。
是否包含张三:true
是否包含张三:false
第二个为什么会是false呢?
原因在于list中检查是否含有元素时是通过调用对象的equals方法来判断的,也就是说 contains(p2)传递进去会依次执行p2.equals(p1)、p2.equals(p2),只要一个返回true,结果就是true。但是这里p2.equals(p2)返回的是false?由于我们对字符前后进行了空格的切割造成p2.equals(p2)的比较实际上是:“张三 ”.equals(“张三”),一个有空格,一个没有空格就出错了。
这个违背了equals的自反性原则:对于任何非空引用x,x.equals(x)应该返回true。
这里只要去掉trim方法就可以解决。
2、对称性原则
上面这个例子,还并不是很好,如果我们传入null值,会怎么样呢?增加一条语句:Person p2=new Person(null);
结果:
是否包含张三:trueException 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 @Override2 public booleanequals(Object obj) {3 if (obj instanceofPerson) {4 Person person=(Person) obj;5 if (person.getName() == null || name == null) {6 return false;7 }else{8 returnname.equalsIgnoreCase(person.getName());9 }10 }11 return false;12 }
3、传递性原则
现在我们有一个Employee类继承自person类:
1 public class Employee extendsPerson{2 private intid;3
4
5 public intgetId() {6 returnid;7 }8 public void setId(intid) {9 this.id =id;10 }11 public Employee(String name,intid) {12 super(name);13 this.id =id;14 //TODO Auto-generated constructor stub
15 }16 @Override17 public booleanequals(Object obj) {18 if(obj instanceofEmployee){19 Employee e =(Employee)obj;20 return super.equals(obj) && e.getId() ==id;21 }22 return super.equals(obj);23 }24
25 public static voidmain(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 @Override2 public booleanequals(Object obj) {3 if (obj != null && obj.getClass() == this.getClass()) {4 Person person=(Person) obj;5 if (person.getName() == null || name == null) {6 return false;7 }else{8 returnname.equalsIgnoreCase(person.getName());9 }10 }11 return false;12 }
4、必须覆写hashCode方法这样结果就是三个false。
覆写equals方法就必须覆写hashCode方法,这是Javaer都知道的。
原因就是HashMap的底层处理机制是以数组的方式保存map条目的,这其中的关键是这个数组下标的处理机制:
依据传入元素的hashCode方法的返回值决定其数组的下标,如果该数组位置上已经有了map条目,且与传入的键值相等则不处理,若不相等则覆盖;如果数组位置没有条目,则插入,并加入到map条目的链表中。同理检查键是否存在也是根据哈希吗确定文职,然后遍历查找键值的。
那么对象的hashCode方法返回的是什么呢?
他是一个对象的哈希码,是有Object类的本地方法生成的,确保每个对象有一个哈希码。
1、重写equals方法实例 部分代码参考http://blog.csdn.net/wangloveall/article/details/7899948
重写equals方法的目的是判断两个对象的内容(内容可以有很多,比如同时比较姓名和年龄,同时相同的才是用一个对象)是否相同。
如果不重写equals,那么比较的将是对象的引用是否指向同一块内存地址,重写之后目的是为了比较两个对象的value值是否相等。特别指出利用equals比较八大包装对象,(如int,float等)和String类(因为该类已重写了equals和hashcode方法)对象时,默认比较的是值,在比较其它自定义对象时都是比较的引用地址。
packagecom.lk.C;classUser {privateString name;private intage;public intgetAge() {returnage;
}public void setAge(intage) {this.age =age;
}public voidsetName(String name) {this.name =name;
}publicString getName() {returnname;
}public booleanequals(Object obj) {if(this ==obj) {return true;
}if(null ==obj) {return false;
}if(this.getClass() !=obj.getClass()) {return false;
}
User user=(User) obj;if(this.name.equals(user.name)&&this.age ==user.age) {return true;
}return false;
}
}public classTest6 {public static voidmain(String[] args) {
User userA= newUser();
userA.setName("王明");
userA.setAge(10);
User userB= newUser();
userB.setName("王明");
userB.setAge(10);
User userC= newUser();
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:trueuserA 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、看看下面的三段程序
packagecom.lk.C;public classTest7 {public static voidmain(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("-----");
}
}classA{inti;public A(inti){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
-----
packagecom.lk.C;public classTest8 {public static voidmain(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
-----String类型的new String()的equals方法:true
-----String用==赋值和用new String()赋值的比较:true
-----包装类的equals方法:true
-----包装类的new Integer()用equals方法:true
-----Integer用==赋值和用new Integer()赋值的比较:true
-----
packagecom.lk.C;public classTest9 {public static voidmain(String[] args) {//TODO Auto-generated method stub
Student s1 = new Student("阿坤",21);
Student s2= new Student("阿坤",21);
Student s3= newStudent();
Student s4= newStudent();
Student s5=s1;
System.out.print("普通类对象的==非默认构造:");
System.out.println(s1==s2);
System.out.println(s1==s5);
System.out.println("-----");
System.out.print("普通类对象的equals非默认构造:");
System.out.println(s1.equals(s2));
System.out.println(s1.equals(s5));
System.out.println("-----");
System.out.print("普通类对象的==默认构造:");
System.out.println(s3==s4);
System.out.println("-----");
System.out.print("普通类对象的equals默认构造:");
System.out.println(s3.equals(s4));
System.out.println("-----");
System.out.print("对普通对象的属性进行比较equals:");
System.out.println(s1.name.equals(s2.name));
System.out.print("对普通对象的属性进行比较==:");
System.out.println(s1.name==s2.name);
}
}classStudent{publicString name;public intage;publicStudent(){
}public Student(String name,intage){this.name =name;this.age =age;
}public voidtest(){
System.out.println(this.name);
System.out.println(this.age);
}
}
普通类对象的==非默认构造:false
true
-----普通类对象的equals非默认构造:false
true
-----普通类对象的==默认构造:false
-----普通类对象的equals默认构造:false
-----对普通对象的属性进行比较equals:true对普通对象的属性进行比较==:true
从以上的三个程序可以看出:
1)对于==:在简单类型中(int等),这能使用该方法进行比较,这种类型没有equals方法,int的值是存在栈中的,==比较的是栈的内容是否相同。在String类型中,比较特殊,用String=“”;这种进行赋值时,两个相同的值用==比较也是相同的。但是用new String(),赋值就不相同。说明String=“”时,java会检查在堆中是否由相同的值,如果有,把新对象的地址也同老对象的地址赋为相同,因此==比较会相同。但是new String()开辟的就是两个栈,因此用==比较不会相同。对于包装类,如Integer=“”;时,在-128-127会有缓存,请看上面程序。其他的情况与String类似。
2)对于equals:当时String类型或者是包装类,如Integer时,比较的就是堆中的值,Integer也无缓存之说。对于普通类,equals比较的内存的首地址,这时候和==是一样的,即比较两边指向的是不是同一个对象。详细请见程序三。
原文链接:http://blog.csdn.net/likesetaria/article/details/51281498
原文链接:http://www.cnblogs.com/silence-hust/p/4510574.html
很好,很详细的文章,感谢网友的分享,记录下来只为学习。
以上程序都是亲自测试过。希望能对大家有帮助。
以下是一些在百度中找到的说法:http://zhidao.baidu.com/link?url=AMYxGo3NunWY7irH5XLPlHUa0ywvyqgYEAdDUMKJlQvklm686MC_D7ZjT3dX9BmuZWXXjWRV2QHelGJ8GzAxBK
java中,
(1)对于字符串变量来说,equal比较的两边对象的内容,所以内容相同返回的是true。
至于你没问到的“==”,比较的是内存中的首地址,所以如果不是同一个对象,“==”不会返回true 而是false。
举个简单的例子,
String s1="abc", s2="abc";
String s3=new String("abc");
String s4=new String("abc");
s1==s2 //true,
s1.equals(s2) //true,
s3.equals(s3) //true,equal比较的是内容
s3==s4//false,==比较的是首地址,所以是false
(2)对于非字符串变量,equals比较的内存的首地址,这时候和==是一样的,即比较两边指向的是不是同一个对象,
即
Sample sa1= newSample();
Sample sa2= newSample();
sa1.equals(sa2)//false,因为不是同一对象
注意,如果加上
sa1=sa2;
那么
sa1.equals(sa2)//true