重写equals()方法

1.如果想把持久类的实例放入set中（多值关联时，1对多），建议实现equals和hashcode

2.想重用托管实例时，也要实现equals和hashcode

3.多个字段组合作为联合主键，必须实现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; import org.hibernate.HibernateException; import org.hibernate.Session; import org.hibernate.SessionFactory; import org.hibernate.Transaction; import org.hibernate.cfg.Configuration; import org.junit.After; import org.junit.Before; import org.junit.Test; import org.test.entity.User; public class UserTest {   //定义变量     Configuration config=null;     SessionFactory sessionFactory=null;     Session session=null;     Transaction transaction=null; @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 判断是否为同一个对象   } }

在重写之前结果为：

重写后结果为：