1.如果想把持久类的实例放入set中(多值关联时,1对多),建议实现equals和hashcode
2.想重用托管实例时,也要实现equals和hashcode3.多个字段组合作为联合主键,必须实现equals和hashcode方法
equals()和hashCode()这两个方法属于Object类,而Object类是所有类的父类,因此所有的类都继承了这两个方法。其中有一些类重写了这两个方法。
例如:Object类的equals()方法代码如下:
public boolean equals(Object obj) {
return (this == obj);
}
这两个方法都来自于Object对象,根据API文档查看下原意。
(1)public boolean equals(Objectobj),对于任何非空引用值 x 和 y,当且仅当 x 和 y 引用同一个对象时,此方法才返回 true;
注意:当此方法被重写时,通常有必要重写 hashCode 方法,以维护 hashCode 方法的常规协定,该协定声明相等对象必须具有相等的哈希码。
(2)public int hashCode() 返回该对象的哈希码值。支持该方法是为哈希表提供一些优点
我们知道,如果不重写equals,那么比较的将是对象的引用是否指向同一块内存地址,重写之后目的是为了比较两个对象的value值是否相等。特别指出,此时,利用equals比较八大包装对象(如int,float等)和String类(因为该类已重写了equals和hashcode方法)对象时,默认比较的是值,在比较其它对象都是比较的引用地址。那产生了一个问题,为什么jdk中希望我们在重写equals时,非常有必要重写hashcode呢?我的理解是hashcode是用于散列数据的快速存取,如利用HashSet/HashMap/Hashtable类来存储数据时,都是根据存储对象的hashcode值来进行判断是否相同的。这样如果我们对一个对象重写了euqals,意思是只要对象的成员变量值都相等那么euqals就等于true,但不重写hashcode,那么我们再new一个新的对象,当原对象.equals(新对象)等于true时,两者的hashcode却是不一样的,由此将产生了理解的不一致,如在存储散列集合时(如Set类),将会存储了两个值一样的对象,导致混淆,因此,就也需要重写hashcode。
在集合类(HashMap,HashSet等)中判断两个对象是否相等有如下规则:
如果两个对象哈希值不同,那么这两个对象不相等。如果相同,则调用equals()方法判断,如果equals()方法返回true,则这两个对象相等,否则不相等。为了保证这种一致性,必须满足以下两个条件:(1)当obj1.equals(obj2)为true时,obj1.hashCode() == obj2.hashCode()必须为true
(2)当obj1.hashCode() == obj2.hashCode()为false时,obj1.equals(obj2)必须为false
在实体类中重写equals方法和hashcode方法:
package org.test.entity; public class User { private int id; private String uname; private int age; private String sex; private String city; public int getId() { return id; } public void setId(int id) { this.id = id; } public String getUname() { return uname; } public void setUname(String uname) { this.uname = uname; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } public String getSex() { return sex; } public void setSex(String sex) { this.sex = sex; } public String getCity() { return city; } public void setCity(String city) { this.city = city; } //重写Object类下的toString()方法 public String toString(){ return "User [id="+id+",uname="+uname+",age="+age+",sex="+sex+",city="+city+"]"; } //第一步分析 /*@Override public boolean equals(Object obj) { *//** * 这里要改进,根据这里的比较成员变量来决定返回true还是false * 这里其实要比较的就是name,age和sex,city * 但是,name是String类型的,而String是引用类型的,所以,在这里不能直接用==比较, * 应该用equals()比较 * this -- s1 * obj -- s2 *//* if(obj == null){ return false; } //要使用的是用户类的特有成员,所以要向下转型 User s = (User)obj; // s -- obj -- s2 if(this.age == s.age && this.uname.equals(s.uname) && this.sex.equals(s.sex) && this.city.equals(s.city)){ return true; }else{ return false; } }*/ //第二步优化 /* @Override public boolean equals(Object obj) { //为了提高效率 if(this == obj){ return true; } //为了提供程序的健壮性 //我先判断一下,obj是不是用户的一个对象,如果是,再做向下转型,如果不是,直接返回false //这个时候,我们要判断的是对象是否是某个类的对象? if (!(obj instanceof User)) { return false; } //如果是就继续 User user = (User)obj; System.out.println("同一个对象,还需要向下转型比较吗?"); return this.uname.equals(s.uname) && this.age==s.age && this.sex.equals(s.sex)this.city.equals(s.city); }*/ //重写equals要实现hachCode() @Override public int hashCode() { final int prime = 31; int result = 1; result = prime * result + age; result = prime * result + ((uname == null) ? 0 : uname.hashCode()); result = prime * result + ((sex == null) ? 0 : sex.hashCode()); result = prime * result + ((city == null) ? 0 : city.hashCode()); return result; } //第三步 @Override public boolean equals(Object obj) { if (this == obj) //判断对象地址是否相等,如果是就不用判断,提高效率 return true; if (obj == null) //对象为空,则不往下走了 return false; if (getClass() != obj.getClass()) //判断两个对象是否一样:class july.star.equals.Student--class july.star.equals.Student return false; User user = (User) obj; //向下转型 /** 判断成员变量是否一样 */ if (age != user.age) return false; //判断年龄,int类型,直接比较 //String类型,equals()比较 if (uname == null) { if (user.uname != null) return false; } else if (!uname.equals(user.uname)) return false; if (sex == null) { if (user.sex != null) return false; } else if (!sex.equals(user.sex)) return false; if (city == null) { if (user.city != null) return false; } else if (!city.equals(user.city)) return false; return true; } } |
测试类:
package org.test.demo; @Test public void equalsTest() { User user1=new User(); User user2=new User(); try { session=HibernateUtils.getSession(); //4.开始事务 transaction=session.beginTransaction(); //5.操作 user1=(User)session.get(User.class, 1); //6.提交事务 transaction.commit(); //7.关闭资源 session.close(); } catch (HibernateException e) { // TODO Auto-generated catch block e.printStackTrace(); } try { session=HibernateUtils.getSession(); //4.开始事务 transaction=session.beginTransaction(); //5.操作 user2=(User)session.get(User.class, 1); //6.提交事务 transaction.commit(); //7.关闭资源 session.close(); } catch (HibernateException e) { // TODO Auto-generated catch block e.printStackTrace(); } System.out.println(user1==user2);//重写前:false 重写后: false System.out.println(user1.equals(user2));//false true User user3 = user1; //地址引用,指向同一个地址 System.out.println( user1 == user3); //true true //false:this==obj 也是对地址的比较,所以要重写equals System.out.println(user1.equals(user3)); //true true System.out.println(user1.equals(user2)); //false true System.out.println("--------------"); User user4 = new User(); //重写后 System.out.println(user1.equals(user2)); //true System.out.println(user1.equals(user3)); //true System.out.println(user1.equals(user4)); //false UserTest d = new UserTest (); System.out.println(user1.equals(d)); //false 判断是否为同一个对象 } } |
在重写之前结果为:
重写后结果为: