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，则这两个对象相等，否则不相等。为了保证这种一致性，必须满足以下两个条件：(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 判断是否为同一个对象 } } |
在重写之前结果为：
重写后结果为：
