1、前言
在Java语言中，==、equals()、hashCode()这三个方法都和对象的比较有关，但这三个方法各有什么用处，也就是说为什么要设计三种对象的比较方法呢？
2、关于==
==设计的目的就是为比较两个对象是否是同一个对象。比较对象的相等不仅要比较对象内容相等，还要比较对象引用地址是否相等。
对于基本数据类型而言，比较就是判断这两个数值是否相等，（基本数据类型没有方法），不存在equals()和hashCode()比较的问题，下面的讨论都是针对引用数据类型展开的。
对于引用对象而言，比较两个引用变量的引用的是否是统一个对象，即比较的是两个引用存储中的对象地址是不是一样。
3、关于equals()
==比较的是两个对象是否是同一个对象，这并不能满足很多需求。有时候当两个对象不==的时候，我们仍然会认为两者是“相等”的，比如对于String对象，当两个对象的字符串序列是一致的，我们就认为他们是“相等”的。对于这样的需求，需要equals()来实现。对于有这种需求的对象的类，重写其equals()方法便可，具体的“相等”逻辑可以根据需要自己定义。
equals()和hashCode()都是从Object类中继承而来的，而Object中equals()默认实现的是比较两个对象是否==，即默认的equals()和==的效果是一样的。equals()方法在Object类中定义如下：
public boolean equals(Object obj) {
return (this == obj);
} 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;
}我们还应该注意，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()方法时，必须遵守的准则，如果违反会出现意想不到的结果，请大家一定要遵守。
4、关于hashCode()
hashCode()方法返回的是一个数值，称之为hashCode。hashCode()方法在Object类中的定义如下：
public native int hashCode();当然我们可以再自定义类中覆盖hashCode()方法，比如String、Integer、Double等等这些类都是覆盖了hashCode()方法的。例如在String类中定义的hashcode()方法如下：
public int hashCode() {
int h = hash;
if (h == 0) {
int off = offset;
char val[] = value;
int len = count;
for (int i = 0; i < len; i++) {
h = 31*h + val[off++];
}
hash = h;
}
return h;
} s[0]*31^(n-1) + s[1]*31^(n-2) + ... + s[n-1]
使用 int 算法，这里 s[i] 是字符串的第 i 个字符，n 是字符串的长度，^ 表示求幂。（空字符串的哈希码为 0。）
5、equals()和hashCode()千丝万缕的关系
hashCode()方法常被设计用来提高性能，其两者的关系在于：①若两个对象相等（equals），那么这两个对象一定有相同的哈希值（hashCode）；②若两个对象的哈希值相同，但这两个对象并不一定相等。
上述两点说明，通过equals()方法判断两个对象相等，那么这两个对象的hashCode()方法返回的hashCode一定相等；但equals()方法不相等的两个对象，却不一定他们的hashCode()不相等，也就是说，equals()方法不相等的两个对象，hashcode()有可能相等。（我的理解是由于哈希码在生成的时候产生冲突造成的）。反之，hashCode()不相等，一定能推出equals()也不等；hashCode()相等，并不能说明equals()相等或不等。
解释下上述关系的使用范围，我的理解是在object、String等类中都能使用。在object类中，hashCode()方法是本地方法，返回的是对象的地址值，而object类中的equals()方法比较的也是两个对象的地址值，如果equals()相等，说明两个对象地址值也相等，当然hashCode()也就相等了；在String类中，equals()返回的是两个对象内容的比较，当两个对象内容相等时，hashCode()方法根据String类的重写（前面关于hashCode()已经说明）代码的分析，也可知道hashCode()返回结果也会相等。以此类推，可以知道Integer、Double等封装类中经过重写的equals()和hashCode()方法也同样适合于这个原则。当然没有经过重写的类，在继承了object类的equals()和hashCode()方法后，也会遵守这个原则。
6、equals()和hashCode()方法在HashSet、HashMap、Hashtable中的应用
以HashSet集合为例具体说明：
Hashset是继承Set接口，Set接口又实现Collection接口，这是层次关系。那么hashset是根据什么原理来存取对象的呢？
在hashset中不允许出现重复对象，元素的位置也是不确定的。在hashset中又是怎样判定元素是否重复的呢？这就是问题的关键所在，在java的集合中，判断两个对象是否相等的规则是：
1) 判断两个对象的hashCode是否相等。如果不相等，认为两个对象也不相等，完毕； 如果相等，转入2)
（这一点只是为了提高存储效率而要求的，其实理论上没有也可以，但如果没有，实际使用时效率会大大降低，所以我们这里将其做为必需的。后面会重点讲到这个问题。）
2) 判断两个对象用equals运算是否相等 。如果不相等，认为两个对象也不相等；如果相等，认为两个对象相等（equals()是判断两个对象是否相等的关键）
为什么是两条准则，难道用第一条不行吗？不行，因为前面已经说了，hashCode()相等时，equals()方法也可能不等，所以必须用第2条准则进行限制，才能保证加入的为非重复元素。
参看程序1：
String s1 = new String("zhaoxudong");
String s2 = new String("zhaoxudong");
System.out.println(s1 == s2);// false
System.out.println(s1.equals(s2));// true
System.out.println(s1.hashCode());
System.out.println(s2.hashCode());// s1.hashcode()等于s2.hashcode()
Set<String> hashset = new HashSet<String>();
hashset.add(s1);
hashset.add(s2);
/* 实质上在添加s1,s2时，运用上面说到的两点准则，
* 可以知道hashset认为s1和s2是相等的，是在添加重复元素，
* 所以让s2覆盖了s1; */
Iterator<String> it = hashset.iterator();
while (it.hasNext()) {
System.out.println(it.next());
}false
true
-967303459
-967303459
zhaoxudong参看程序2：
public class Test {
public static void main(String[] args) {
HashSet<Student> hs = new HashSet<Student>();
hs.add(new Student(1, "zhangsan"));
hs.add(new Student(2, "lisi"));
hs.add(new Student(3, "wangwu"));
hs.add(new Student(1, "zhangsan"));
Iterator<Student> it = hs.iterator();
while (it.hasNext()) {
System.out.println(it.next());
}
}
}
class Student {
int num;
String name;
Student(int num, String name) {
this.num = num;
this.name = name;
}
public String toString() {
return num + ":" + name;
}
}
2:lisi
1:zhangsan
1:zhangsan
3:wangwu因为在根据hashcode()对两次建立的new Student(1,"zhangsan")对象进行比较时，生成的是不同的哈希码值，所以hashset把他当作不同的对象对待了，当然此时的equals()方法返回的值也不等（这个不用解释了吧）。那么为什么会生成不同的哈希码值呢？上面我们在比较s1和s2的时候不是生成了同样的哈希码吗？原因就在于我们自己写的Student类并没有重新自己的hashcode()和equals()方法，所以在比较时，是继承的object类中的hashcode()方法，呵呵，各位还记得object类中的hashcode()方法比较的是什么吧！！
它是一个本地方法，比较的是对象的地址（引用地址），使用new方法创建对象，两次生成的当然是不同的对象了（这个大家都能理解吧。。。），造成的结果就是两个对象的hashcode()返回的值不一样。所以根据第一个准则，hashset会把它们当作不同的对象对待，自然也用不着第二个准则进行判定了。那么怎么解决这个问题呢？？
答案是：在Student类中重新hashcode()和equals()方法。
参考代码：
class Student {
int num;
String name;
Student(int num, String name) {
this.num = num;
this.name = name;
}
/*hashCode()方法重写*/
public int hashCode() {
return num * name.hashCode();
}
/*这里用num和name作为条件来进行比较，
* 若num和name都相同的对象就被视为相等的对象*/
public boolean equals(Object o) {
Student s = (Student) o;
return num == s.num && name.equals(s.name);
}
public String toString() {
return num + ":" + name;
}
}
当然根据equals()方法我们也可判断是相同的。所以在向hashset集合中添加时把它们当作重复元素看待了。所以运行修改后的程序时，我们会发现运行结果是：
1:zhangsan
3:wangwu
2:lisi关于在hibernate的pojo类中，重新equals()和hashcode()的问题：
1) 重点是equals，重写hashCode只是技术要求（为了提高效率）
2) 为什么要重写equals呢，因为在java的集合框架中，是通过equals来判断两个对象是否相等的
3) 在hibernate中，经常使用set集合来保存相关对象，而set集合是不允许重复的。我们再来谈谈前面提到在向hashset集合中添加元素时,怎样判断对象是否相同的准则，前面说了两条，其实只要重写equals()这一条也可以。
但当hashset中元素比较多时，或者是重写的equals()方法比较复杂时，我们只用equals()方法进行比较判断，效率也会非常低，所以引入了hashcode()这个方法，只是为了提高效率，但是我觉得这是非常有必要的（所以我们在前面以两条准则来进行hashset的元素是否重复的判断）。
参考链接
http://jingyan.baidu.com/article/ff41162582507512e5823763.html
http://www.iteye.com/topic/257191
4045
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
