重写hashcode()与equal()

equals()与==的区别：没有重写的equals()与==都是对象地址的比较，重写后的equals()应该是对象值的比较；

//自定义class Person{name, age}
Person a = new Person("zhang",16);
Person b = new Person("zhang",16);
print(a==b);//这里将会返回false,因为它们是不同的对象（即地址不同）
print(a.equals(b));//在person重写了equals()的条件下，这里将会返回true,因为值相同

重写equals()要遵循的规则：
自反性：对于一切非null的引用值x, x.equals(x)都将返回true;
对称性：对于一切非null的引用值x,y, x.equals(y) 与y.equals(x) 的返回结果应该是相同的；
传递性：对于一切非null的引用值x,y,z, 如果x.equals(y)返回true, y.equals(z) 返回true, 那么x.equals(z) 也返回true;
一致性：对于任何非null的引用值x与y，假设对象上equals比较中的信息没有被修改，则多次调用x.equals(y)始终返回true或者始终返回false。
非空性：对于任何非空引用值x，x.equal(null)应返回false。

//重写equal的person
package cn.zzf.test;

public class Person {
    private String name;
    private int age;

    public Person(String name,int age){
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public int hashCode() {
        // TODO Auto-generated method stub
        return super.hashCode();
    }

    @Override
    public boolean equals(Object obj) {
        // TODO Auto-generated method stub
        //非空性
        if(obj == null)
            return false;
        //自反性
        if(this == obj)
            return true;
        //判断类型是否相同
        if(this.getClass() != obj.getClass())
            return false;
        //进行的值的比较
        Person person = (Person)obj;
        return name.equals(person.name) && age==person.age;//String 重写了equals(),StringBuilder没有重写 
    }
    @Override
    public String toString() {
        // TODO Auto-generated method stub
        return "("+this.name+","+this.age+")";
    }



}

//test1
package cn.zzf.test;

import static org.junit.Assert.*;

import org.junit.BeforeClass;
import org.junit.Test;

public class TestPerson {

    @Test
    public void test() {
        Person p1 = new Person("eee", 100);
        Person p2 = new Person("eee", 100);
        System.out.printf("p1.equals(p2) : %s\n", p1.equals(p2));
        System.out.printf("p1==p2 : %s\n", p1 == p2);
    }

}

//结果
/*p1.equals(p2) : true
p1==p2 : false*/

hashcode()详解：
hashCode()方法给对象返回一个hash code值。这个方法被用于hash tables，例如HashMap。
它的性质是：
在一个Java应用的执行期间，如果一个对象提供给equals做比较的信息没有被修改的话，该对象多次调用hashCode()方法，该方法必须始终如一返回同一个integer。
如果两个对象根据equals(Object)方法是相等的，那么调用二者各自的hashCode()方法必须产生同一个integer结果。
并不要求根据equals(java.lang.Object)方法不相等的两个对象，调用二者各自的hashCode()方法必须产生不同的integer结果。然而，程序员应该意识到对于不同的对象产生不同的integer结果，有可能会提高hash table的性能。

hashCode的作用：　　
总的来说，Java中的集合（Collection）有两类，一类是List，再有一类是Set。前者集合内的元素是有序的，元素可以重复；后者元素无序，但元素不可重复。这里就引出一个问题：要想保证元素不重复，可两个元素是否重复应该依据什么来判断呢？
这就是Object.equals方法了。但是，如果每增加一个元素就检查一次，那么当元素很多时，后添加到集合中的元素比较的次数就非常多了。也就是说，如果集合中现在已经有1000个元素，那么第1001个元素加入集合时，它就要调用1000次equals方法。这显然会大大降低效率。
于是，Java采用了哈希表的原理。哈希（Hash）实际上是个人名，由于他提出一哈希算法的概念，所以就以他的名字命名了。哈希算法也称为散列算法，是将数据依特定算法直接指定到一个地址上，初学者可以简单理解，hashCode方法实际上返回的就是对象存储的物理地址（实际可能并不是）。
这样一来，当集合要添加新的元素时，先调用这个元素的hashCode方法，就一下子能定位到它应该放置的物理位置上。如果这个位置上没有元素，它就可以直接存储在这个位置上，不用再进行任何比较了；如果这个位置上已经有元素了，就调用它的equals方法与新元素进行比较，相同的话就不存了，不相同就散列其它的地址。所以这里存在一个冲突解决的问题。这样一来实际调用equals方法的次数就大大降低了，几乎只需要一两次。

简而言之，在集合查找时，hashcode能大大降低对象比较次数，提高查找效率！

//test1,在没有重写hashcode时，
package cn.zzf.test;

import static org.junit.Assert.*;

import java.util.HashSet;
import java.util.Iterator;

import org.junit.BeforeClass;
import org.junit.Test;

public class TestPerson {

    @Test
    public void test() {
        HashSet hs = new HashSet();
        hs.add(new Person("zhang", 1));
        hs.add(new Person("li", 2));
        hs.add(new Person("wang", 3));
        hs.add(new Person("zhang", 1));

        Iterator it = hs.iterator();
        while (it.hasNext()) {
            System.out.println(it.next());
        }
    }

}
//结果是:
/*(li,2)
(zhang,1)
(zhang,1)
(wang,3)*/
/*分析：
为什么hashset添加了相等的元素呢，这是不是和hashset的原则违背了呢？回答是：没有。因为在根据hashcode()对两次建立的new Student(1,“zhangsan”)对象进行比较时，生成的是不同的哈希码值，所以hashset把他当作不同的对象对待了，当然此时的equals()方法返回的值也不等。
*/


//重写hashcode的person
package cn.zzf.test;

public class Person {
    private String name;
    private int age;

    public Person(String name,int age){
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public int hashCode() {
        // TODO Auto-generated method stub
        return age*name.hashCode();
    }

    @Override
    public boolean equals(Object obj) {
        // TODO Auto-generated method stub
        //非空性
        if(obj == null)
            return false;
        //自反性
        if(this == obj)
            return true;
        //判断类型是否相同
        if(this.getClass() != obj.getClass())
            return false;
        //进行的值的比较
        Person person = (Person)obj;
        return name.equals(person.name) && age==person.age;//String 重写了equals(),StringBuilder没有重写 
    }
    @Override
    public String toString() {
        // TODO Auto-generated method stub
        return "("+this.name+","+this.age+")";
    }



}
//test2
//结果
/*(li,2)
(zhang,1)
(wang,3)*/

重写equals()和hashcode()小结：

　　1.重点是equals，重写hashCode只是技术要求（为了提高效率）
2.为什么要重写equals呢？因为在java的集合框架中，是通过equals来判断两个对象是否相等的
3.在hibernate中，经常使用set集合来保存相关对象，而set集合是不允许重复的。在向HashSet集合中添加元素时，其实只要重写equals()这一条也可以。但当hashset中元素比较多时，或者是重写的equals()方法比较复杂时，我们只用equals()方法进行比较判断，效率也会非常低，所以引入了hashCode()这个方法，只是为了提高效率，且这是非常有必要的。比如可以这样写：

public int hashCode(){  
   return 1; //等价于hashcode无效  
}  

这样做的效果就是在比较哈希码的时候不能进行判断，因为每个对象返回的哈希码都是1，每次都必须要经过比较equals()方法后才能进行判断是否重复，这当然会引起效率的大大降低。

文章参考：http://www.cnblogs.com/Qian123/p/5703507.html