java.lang.Object类的hashCode()和equals()方法详解[结合集合的原理]

1. 首先equals()和hashcode()这两个方法都是从object类中继承过来的。
equals()方法在object类中定义如下：

 public boolean equals(Object obj) {
	return (this == obj);
}

很明显是对两个对象的地址值进行的比较（即比较引用是否相同）。但是我们必需清楚，当String 、Math、还有Integer、Double。。。。等这些封装类在使用equals()方法时，已经覆盖了object类的equals（）方法。

比如在String类中如下：

public boolean equals(Object anObject) {
	if (this == anObject) {
	    return true;
	}
	if (anObject instanceof String) {
	    String anotherString = (String)anObject;
	    int n = count;
	    if (n == anotherString.count) {
		char v1[] = value;
		char v2[] = anotherString.value;
		int i = offset;
		int j = anotherString.offset;
		while (n-- != 0) {
		    if (v1[i++] != v2[j++])
			return false;
		}
		return true;
	    }
	}
	return false;
    }

 

很明显，这是进行的内容比较，而已经不再是地址的比较。依次类推Double、Integer、Math。。。。等等这些类都是重写了equals()方法的，从而进行的是内容的比较。当然了基本类型是进行值的比较，这个没有什么好说的。
我们还应该注意，Java语言对equals()的要求如下，这些要求是必须遵循的：
• 对称性：如果x.equals(y)返回是“true”，那么y.equals(x)也应该返回是“true”。
• 反射性：x.equals(x)必须返回是“true”。
• 类推性：如果x.equals(y)返回是“true”，而且y.equals(z)返回是“true”，那么z.equals(x)也应该返回是“true”。
• 还有一致性：如果x.equals(y)返回是“true”，只要x和y内容一直不变，不管你重复x.equals(y)多少次，返回都是“true”。
• 任何情况下，x.equals(null)，永远返回是“false”；x.equals(和x不同类型的对象)永远返回是“false”。
以上这五点是重写equals()方法时，必须遵守的准则，如果违反会出现意想不到的结果，请大家一定要遵守。 这个也是java重新equals()方法时的规范！

2. 其次是hashcode() 方法，在object类中定义如下：

public native int hashCode();

说明是一个本地方法，它的实现是根据本地机器相关的。当然我们可以在自己写的类中覆盖hashcode()方法，比如String、Integer、Double。。。。等等这些类都是覆盖了hashcode()方法的。

例如在String类中定义的hashcode()方法如下：

  public int hashCode() {
	int h = hash;
        int len = count;
	if (h == 0 && len > 0) {
	    int off = offset;
	    char val[] = value;

            for (int i = 0; i < len; i++) {
                h = 31*h + val[off++];
            }
            hash = h;
        }
        return h;
    }

 

解释一下这个程序（String的API中写到）：
s[0]*31^(n-1) + s[1]*31^(n-2) + ... + s[n-1]
使用 int 算法，这里 s[i] 是字符串的第 i 个字符，n 是字符串的长度，^ 表示求幂。（空字符串的哈希码为 0。）

3.这里我们首先要明白一个问题：
equals()相等的两个对象，hashcode()一定相等；

java.lang.Object规范：

1 在一个应用执行期间，如果一个对象的equals方法所比较用到的信息没有被修改的话，那么，对该对象调用hashCode方法多次，它始终如一返回同一个整数.

在同一个应用程序的多次执行过程中，这个整数可以不同，即这个应用程序这次执行返回的整数和下一次执行返回的整数可以不一致。

2 如果两个对象equals(object)方法是相等的，那么调用这个对象中任何一个对象的hashCode方法必须产生同样的整数效果。

3 如果两个对象根据equals(object)方法是不相等的，那么调用这两个对象中任意一个对象的hashCode方法，不要求必须产生不同的整数结果。对于不相等的对象

产生截然不同的整数接口,可以提高散列表(hashTable)的性能。

也就是说，equals(object)不相等，有可能它们的hashCode相同,

所以反过来说，

两个对象hashCode相同，equals(object)不一定相等。而其他对于不相等的对象，。
反过来：

hashcode()不等，一定能推出equals()也不等；

hashcode()相等，equals()可能相等，也可能不等。解释下第3点的使用范围，我的理解是在object、String等类中都能使用。在object类中，hashcode()方法是本地方法，返回的是对象的地址值，而object类中的equals()方法比较的也是两个对象的地址值，如果equals()相等，说明两个对象地址值也相等，当然hashcode()也就相等了；在String类中，equals()返回的是两个对象内容的比较，当两个对象内容相等时，
Hashcode()方法根据String类的重写（第2点里面已经分析了）代码的分析，也可知道hashcode()返回结果也会相等。以此类推，可以知道Integer、Double等封装类中经过重写的equals()和hashcode()方法也同样适合于这个原则。当然没有经过重写的类，在继承了object类的equals()和hashcode()方法后，也会遵守这个原则。

4.hashcode()和equals()在HashSet和HashMap,Hashtable中的使用：
Hashset是继承Set接口，Set接口又实现Collection接口，这是层次关系。那么hashset是根据什么原理来存取对象的呢？

 

HashSet底层的实现依赖的是HashMap<K,V>，下面是它的构造函数:

     public HashSet() {
	          map = new HashMap<E,Object>();
     }

在HashMap中，key是唯一的，在HashSet中不允许出现重复对象，元素的位置也是不确定的，由 散列码 hashCode控制。

HashSet.add()方法：

 public boolean add(E e) {
	return map.put(e, PRESENT)==null;
    }

再去看看HashMap.put()方法

 public V put(K key, V value) {
        if (key == null)
            return putForNullKey(value);
        int hash = hash(key.hashCode());
        int i = indexFor(hash, table.length);
        for (Entry<K,V> e = table[i]; e != null; e = e.next) {
            Object k;
            if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
                V oldValue = e.value;
                e.value = value;
                e.recordAccess(this);
                return oldValue;
            }
        }

        modCount++;
        addEntry(hash, key, value, i);
        return null;
    }

 

从上面的代码中我们可以看出,在hashset中是怎样判定元素是否重复的，在Hashmap的集合中，判断两个对象是否相等的规则是：
1) 判断两个对象的hashCode是否相等
如果不相等，认为两个对象也不相等，完毕
如果相等，转入2)
（这一点只是为了提高存储效率而要求的，其实理论上没有也可以，但如果没有，实际使用时效率会大大降低，所以我们这里将其做为必需的。后面会重点讲到这个问题。）
2) 判断两个对象用equals运算是否相等
如果不相等，认为两个对象也不相等
如果相等，认为两个对象相等（equals()是判断两个对象是否相等的关键）
为什么是两条准则，难道用第一条不行吗？不行，因为前面已经说了，hashcode()相等时，equals()方法也可能不等，所以必须用第2条准则进行限制，才能保证加入的为非重复元素。

比如下面的代码：

public static void main(String[] args) {
		String s1 = new String("zhaoxudong");
		String s2 = new String("zhaoxudong");
		System.out.println("对象是否相等:"+(s1==s2));
		System.out.println("内容是否相等："+s1.equals(s2));
		
		System.out.println("s1 对象的hashCode:"+s1.hashCode());
		System.out.println("s2 对象的hashCode:"+s2.hashCode());
		
		//添加到Set
		Set<String> set= new HashSet<String>();
		set.add(s1);
		set.add(s2);
		//循环遍历
		for (String string : set) {
			System.out.println(string);
		}
	}

输出的结果:
对象是否相等:false
内容是否相等：true
s1 对象的hashCode:-967303459
s2 对象的hashCode:-967303459
zhaoxudong

 

 

//循环遍历
		for (String string : set) {
			System.out.println(string);
		}

 

最后在循环的时候只打印出了一个”zhaoxudong”。

这是因为String类已经重写了equals()方法和hashcode()方法，所以在根据上面的第1.2条原则判定时，hashset认为它们是相等的对象，进行了重复添加。
但是看下面的程序：

 

/**
 * 学生对象
 * @author haibo.hehb
 *
 */
class Student {
	private int num;
	private String name;

	public Student(int num, String name) {
		this.num = num;
		this.name = name;
	}

	public String toString() {
		return num + ":" + name;
	}


	public static void main(String [] args){
		Set<Student> set = new HashSet<Student>();
		set.add(new Student(1, "zhangsan"));
		set.add(new Student(2, "lisi"));
		set.add(new Student(3, "wangwu"));
		set.add(new Student(1,"zhangsan"));
		
		for (Student student : set) {
			System.out.println(student);
		}
		
	}
}
输出的结果：
1:zhangsan
3:wangwu
2:lisi
1:zhangsan

问题出现了，为什么hashset添加了相等的元素呢，这是不是和hashset的原则违背了呢？回答是：没有
因为在根据hashcode()对两次建立的new Student(1,"zhangsan")对象进行比较时，生成的是不同的哈希码值，所以hashset把他当作不同的对象对待了，当然此时的equals()方法返回的值也不等（这个不用解释了吧）。那么为什么会生成不同的哈希码值呢？上面我们在比较s1和s2的时候不是生成了同样的哈希码吗？原因就在于我们自己写的Student类并没有重新自己的hashcode()和equals()方法，所以在比较时，是继承的object类中的hashcode()方法，呵呵，各位还记得object类中的hashcode()方法比较的是什么吧！！
它是一个本地方法，比较的是对象的地址（引用地址），使用new方法创建对象，两次生成的当然是不同的对象了（这个大家都能理解吧。。。），造成的结果就是两个对象的hashcode()返回的值不一样。所以根据第一个准则，hashset会把它们当作不同的对象对待，自然也用不着第二个准则进行判定了。那么怎么解决这个问题呢？？
答案是：在Student类中重新hashcode()和equals()方法。
例如：

/**
 * 学生对象
 * 
 * @author haibo.hehb
 * 
 */
class Student {
	private Integer num;
	private String name;
	/**
	 * 默认构造函数
	 */
	public Student() {
	}
	/**
	 * 带参数的构造函数
	 */
	public Student(Integer num, String name) {
		this.num = num;
		this.name = name;
	}
	public Integer getNum() {
		return num;
	}
	public void setNum(Integer num) {
		this.num = num;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public boolean equals(Object otherObject) {
		if (otherObject == this) {
			return true;
		}
		if (otherObject instanceof Student) {
			Student otherStudent = (Student) otherObject;
			//注意空指针异常
			return  (this.num==null? otherStudent.num==null:this.num.equals(otherStudent.num))
					&& (this.name==null ? otherStudent.name==null : this.name.equals(otherStudent.name));
		}
		return false;
	}
	public int hashCode() {
		int result = 31;
		//注意空指针异常
		result = this.num == null ? 31 : this.num * result;
		result = this.name == null ? 31 : this.name.hashCode() * result;
		return result;
	}
	public String toString() {
		return num + ":" + name;
	}
}

 

根据重写的方法，即便两次调用了new Student(1,"zhangsan")，我们在获得对象的哈希码时，根据重写的方法hashcode()，获得的哈希码肯定是一样的（这一点应该没有疑问吧）。
当然根据equals()方法我们也可判断是相同的。所以在向hashset集合中添加时把它们当作重复元素看待了。

public static void testStudeng(){
		//业务上重复的学生对象
		Student stu1 =new Student(1,"zhangsan");
		Student repeatStu1 =new Student(1,"zhangsan");

		Set<Student> set = new HashSet<Student>();
		set.add(stu1);
		set.add(new Student(2, "lisi"));
		set.add(new Student(3, "wangwu"));
		set.add(repeatStu1);
		set.add(new Student());
		for (Student student : set) {
			System.out.println(student);
		}
		
		System.out.println("业务上重复的学生内容是否一致："+stu1.equals(repeatStu1));
		System.out.println("hashCode是否一致："+(stu1.hashCode()==repeatStu1.hashCode()));
		System.out.println();
		System.out.println("      stu1 hashCode值:"+stu1.hashCode());
		System.out.println("repeatStu1 hashCode值:"+repeatStu1.hashCode());
		
	}

输出结果:

1:zhangsan
3:wangwu
null:null
2:lisi
业务上重复的学生内容是否一致：true
hashCode是否一致：true

     stu1 hashCode值:-1461068276
repeatStu1 hashCode值:-1461068276

 

可以看到重复元素的问题已经消除。

重复的对象不会被覆盖，只会添加第一个。

关于在hibernate的pojo类中，重新equals()和hashcode()的问题：
1)，重点是equals，重写hashCode只是技术要求（为了提高效率）
2)，为什么要重写equals呢，因为在java的集合框架中，是通过equals来判断两个对象是否相等的
3)，在hibernate中，经常使用set集合来保存相关对象，而set集合是不允许重复的。我们再来谈谈前面提到在向hashset集合中添加元素时,怎样判断对象是否相同的准则，前面说了两条，其实只要重写equals()这一条也可以，按照规范也要重写hashCode()方法。
但当hashset中元素比较多时，或者是重写的equals()方法比较复杂时，我们只用equals()方法进行比较判断，效率也会非常低，所以引入了hashcode()这个方法，只是为了提高效率，但是我觉得这是非常有必要的（所以我们在前面以两条准则来进行hashset的元素是否重复的判断）。
比如可以这样写：
public int hashCode(){
return 1;

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

综合完整示例 ：

package com.hhb;

import java.util.HashSet;
import java.util.Set;

/**
 * Equals 和hashCode
 * 
 */
public class EqualsAndHashCode {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		testString();
		testStudeng();
		testEqualValidator();
	}
	
	public static void testString(){
		String s1 = new String("hehaibo");
		String s2 = new String("hehaibo");
		System.out.println("对象是否相等:" + (s1 == s2));
		System.out.println("内容是否相等：" + s1.equals(s2));

		System.out.println("s1 对象的hashCode:" + s1.hashCode());
		System.out.println("s2 对象的hashCode:" + s2.hashCode());

		// 添加到Set
		Set<String> set = new HashSet<String>();
		set.add(s1);
		set.add(s2);

		for (String string : set) {
			System.out.println(string);
		}
	}
	
	/**
	 * 验证特性
	 */
	public static void testEqualValidator(){
		
		Student stu1 = new Student(1,"zhangsan");
		Student stu2 = new Student(1,"zhangsan");
		Student stu3 = new Student(1,"zhangsan");
		//验证自反性
		System.out.println("自反性是否成立:"+stu1.equals(stu1));
		//验证对称性
		System.out.println("对称性是否成立:"+(stu1.equals(stu2) && stu2.equals(stu1) ));
		//验证传递性
		System.out.println("传递性是否成立:"+(stu1.equals(stu2) && stu2.equals(stu3) && stu1.equals(stu3)));
		//验证一致性
		for (int i = 0; i < 1; i++) {
			stu1.equals(stu2);
		}
		System.out.println("验证一致性:"+(stu1.equals(stu2)));
		
		System.out.println(new Student().equals(null));
		System.out.println(new Student().equals(new Student()));
		System.out.println(new Student().equals(new Student(1,null)));
		
		
		Student stu4=new Student(2,null);
		Student stu5 = new Student(3,"");
		Student stu6=new Student(4,"lisi");
		Student stu7=new Student(null,"wangwu");
		System.out.println(stu1.equals(stu4));
		System.out.println(stu4.equals(stu5));
		System.out.println(stu6.equals(stu7));
		
		System.out.println("-------------------------------");
		
		//添加到集合
		HashSet<Student> set = new HashSet<Student>();
		set.add(stu1);
		set.add(stu2);
		set.add(stu3);
		System.out.println("遍历集合:");
		for (Student student : set) {
			System.out.println(student);
		}
		System.out.println("修改前stu1的hashCode信息["+stu1.hashCode()+"]");
		stu1.setName("张三");
		System.out.println("修改后stu1的hashCode信息["+stu1.hashCode()+"]");
		/**
		 * 添加到集合：HashSet底层维护了一个HashMap<K,V>
		 * key 是我们的添加的对象,value 就是一个Object对象，
		 * 一个Set 有多个对象的时候，value始终是一个 
		 * 上面我们修改了stu1对象的name属性，通过程查看HashMap.put方法我们就知道，
		 * hashmap会首先获得key的hashCode值，可想而知，stu1对象的name属性已经被我们更改，hashCode肯定不同了，
		 * 去hashMap里面hash索引的时候，肯定不会索引到，通过源码可以知道，就会添加一个新的对象
		 */
		set.add(stu1);
		System.out.println("修改再次遍历集合:");
		for (Student student : set) {
			System.out.println("集合对象："+student);
		}
	}

	public static void testStudeng() {
		// 业务上重复的学生对象
		Student stu1 = new Student(1, "zhangsan");
		Student repeatStu1 = new Student(1, "zhangsan");

		Set<Student> set = new HashSet<Student>();
		set.add(stu1);
		set.add(new Student(2, "lisi"));
		set.add(new Student(3, "wangwu"));
		set.add(repeatStu1);
		set.add(new Student());
		for (Student student : set) {
			System.out.println(student);
		}

		System.out.println("业务上重复的学生内容是否一致：" + stu1.equals(repeatStu1));
		System.out.println("hashCode是否一致："
				+ (stu1.hashCode() == repeatStu1.hashCode()));
		System.out.println();
		System.out.println("      stu1 hashCode值:" + stu1.hashCode());
		System.out.println("repeatStu1 hashCode值:" + repeatStu1.hashCode());
		
	}
}

/**
 * 学生对象
 * 
 * @author haibo.hehb
 * 
 */
class Student {
	private Integer num;
	private String name;
	/**
	 * 默认构造函数
	 */
	public Student() {
	}
	/**
	 * 带参数的构造函数
	 */
	public Student(Integer num, String name) {
		this.num = num;
		this.name = name;
	}
	public Integer getNum() {
		return num;
	}
	public void setNum(Integer num) {
		this.num = num;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public boolean equals(Object otherObject) {
		if (otherObject == this) {
			return true;
		}
		if (otherObject instanceof Student) {
			Student otherStudent = (Student) otherObject;
			//注意空指针异常
			return  (this.num==null? otherStudent.num==null:this.num.equals(otherStudent.num))
					&& (this.name==null ? otherStudent.name==null : this.name.equals(otherStudent.name));
		}
		return false;
	}
	public int hashCode() {
		String name=getClass().getName()+"@"+Integer.toHexString(super.hashCode());
		System.out.println("对象原始的地址:"+name);
		int result = 31;
		//注意空指针异常
		result = this.num == null ? 31 : this.num * result;
		result = this.name == null ? 31 : this.name.hashCode() * result;
		return result;
	}
	public String toString() {
		return num + ":" + name;
	}
}