程序博客网 > 木油漆哪个品牌好 知乎

Java中==、equals()和hashCode()的比较分析

来源：互联网 发布：木油漆哪个品牌好 知乎 编辑：程序博客网 时间：2024/06/15 17:46

1、前言

在Java语言中，==、equals()、hashCode()这三个方法都和对象的比较有关，但这三个方法各有什么用处，也就是说为什么要设计三种对象的比较方法呢？

2、关于==

==设计的目的就是为比较两个对象是否是同一个对象。比较对象的相等不仅要比较对象内容相等，还要比较对象引用地址是否相等。

对于基本数据类型而言，比较就是判断这两个数值是否相等，（基本数据类型没有方法），不存在equals()和hashCode()比较的问题，下面的讨论都是针对引用数据类型展开的。

对于引用对象而言，比较两个引用变量的引用的是否是统一个对象，即比较的是两个引用存储中的对象地址是不是一样。

3、关于equals()

==比较的是两个对象是否是同一个对象，这并不能满足很多需求。有时候当两个对象不==的时候，我们仍然会认为两者是“相等”的，比如对于String对象，当两个对象的字符串序列是一致的，我们就认为他们是“相等”的。对于这样的需求，需要equals()来实现。对于有这种需求的对象的类，重写其equals()方法便可，具体的“相等”逻辑可以根据需要自己定义。

equals()和hashCode()都是从Object类中继承而来的，而Object中equals()默认实现的是比较两个对象是否==，即默认的equals()和==的效果是一样的。equals()方法在Object类中定义如下：

[java] view plain copy
print?
  1. public boolean equals(Object obj) {   
  2. return (this == obj);   
  3. }   
很明显是对两个对象的地址值进行的比较（即比较引用是否相同）。但是我们必需清楚，当String 、Math、还有Integer、Double。。。。等这些封装类在使用equals()方法时，已经覆盖了object类的equals（）方法。比如在String类中如下：

[java] view plain copy
print?
  1. public boolean equals(Object anObject) {  
  2.     if (this == anObject) {  
  3.         return true;  
  4.     }  
  5.     if (anObject instanceof String) {  
  6.         String anotherString = (String)anObject;  
  7.         int n = count;  
  8.         if (n == anotherString.count) {  
  9.         char v1[] = value;  
  10.         char v2[] = anotherString.value;  
  11.         int i = offset;  
  12.         int j = anotherString.offset;  
  13.         while (n-- != 0) {  
  14.             if (v1[i++] != v2[j++])  
  15.             return false;  
  16.         }  
  17.         return true;  
  18.         }  
  19.     }  
  20.     return false;  
  21.     }  
String类中的equals()方法很明显是仅仅进行了对象内容的比较，而没有比较对象存储地址。同理我们可知，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()方法时，必须遵守的准则，如果违反会出现意想不到的结果，请大家一定要遵守。

4、关于hashCode()

hashCode()方法返回的是一个数值，称之为hashCode。hashCode()方法在Object类中的定义如下：

[java] view plain copy
print?
  1. public native int hashCode();  
这是一个本地方法，其实现根据本地机器相关。

当然我们可以再自定义类中覆盖hashCode()方法，比如String、Integer、Double等等这些类都是覆盖了hashCode()方法的。例如在String类中定义的hashcode()方法如下：

[java] view plain copy
print?
  1. public int hashCode() {   
  2. int h = hash;   
  3. if (h == 0) {   
  4.     int off = offset;   
  5.     char val[] = value;   
  6.     int len = count;   
  7.   
  8.             for (int i = 0; i < len; i++) {   
  9.                 h = 31*h + val[off++];   
  10.             }   
  11.             hash = h;   
  12.         }   
  13.         return h;   
  14. }   
解释一下这个程序（String的API中写到）： 
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：

[java] view plain copy
print?
  1. String s1 = new String("zhaoxudong");  
  2.         String s2 = new String("zhaoxudong");  
  3.         System.out.println(s1 == s2);// false  
  4.         System.out.println(s1.equals(s2));// true  
  5.         System.out.println(s1.hashCode());  
  6.         System.out.println(s2.hashCode());// s1.hashcode()等于s2.hashcode()  
  7.         Set<String> hashset = new HashSet<String>();  
  8.         hashset.add(s1);  
  9.         hashset.add(s2);  
  10.         /* 实质上在添加s1,s2时，运用上面说到的两点准则， 
  11.          * 可以知道hashset认为s1和s2是相等的，是在添加重复元素， 
  12.          * 所以让s2覆盖了s1; */  
  13.         Iterator<String> it = hashset.iterator();  
  14.         while (it.hasNext()) {  
  15.             System.out.println(it.next());  
  16.         }  
输出结果：

[java] view plain copy
print?
  1. false  
  2. true  
  3. -967303459  
  4. -967303459  
  5. zhaoxudong  
分析：这是因为String类重写了equals()方法和hashCode()方法，所以根据上述两条原则进行判定时，HashSet认为s1和s2是两个相等的对象，故而不会进行重复添加，s2会直接覆盖掉s1。

参看程序2：

[java] view plain copy
print?
  1. public class Test {  
  2.     public static void main(String[] args) {  
  3.         HashSet<Student> hs = new HashSet<Student>();  
  4.         hs.add(new Student(1, "zhangsan"));  
  5.         hs.add(new Student(2, "lisi"));  
  6.         hs.add(new Student(3, "wangwu"));  
  7.         hs.add(new Student(1, "zhangsan"));  
  8.   
  9.         Iterator<Student> it = hs.iterator();  
  10.         while (it.hasNext()) {  
  11.             System.out.println(it.next());  
  12.         }  
  13.     }  
  14. }  
  15.   
  16. class Student {  
  17.     int num;  
  18.     String name;  
  19.   
  20.     Student(int num, String name) {  
  21.         this.num = num;  
  22.         this.name = name;  
  23.     }  
  24.   
  25.     public String toString() {  
  26.         return num + ":" + name;  
  27.     }  
  28. }  
输出结果：

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

参考代码：

[java] view plain copy
print?
  1. class Student {  
  2.     int num;  
  3.     String name;  
  4.   
  5.     Student(int num, String name) {  
  6.         this.num = num;  
  7.         this.name = name;  
  8.     }  
  9.     /*hashCode()方法重写*/  
  10.     public int hashCode() {  
  11.         return num * name.hashCode();  
  12.     }  
  13.     /*这里用num和name作为条件来进行比较， 
  14.      * 若num和name都相同的对象就被视为相等的对象*/  
  15.     public boolean equals(Object o) {  
  16.         Student s = (Student) o;  
  17.         return num == s.num && name.equals(s.name);  
  18.     }  
  19.   
  20.     public String toString() {  
  21.         return num + ":" + name;  
  22.     }  
  23. }  
根据重写的方法，即便两次调用了new Student(1,"zhangsan")，我们在获得对象的哈希码时，根据重写的方法hashcode()，获得的哈希码肯定是一样的（这一点应该没有疑问吧）。 
当然根据equals()方法我们也可判断是相同的。所以在向hashset集合中添加时把它们当作重复元素看待了。所以运行修改后的程序时，我们会发现运行结果是：

[java] view plain copy
print?
  1. 1:zhangsan  
  2. 3:wangwu  
  3. 2:lisi  
通过结果可知，重复的元素问题已经消除。

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

    阅读全文
    0 0
    木油漆哪个品牌好 知乎 木油漆哪个品牌好 知乎
    原创粉丝点击
    热门IT博客
    诺基亚c6 01视频软件诺基亚c6 01视频软件
    听音识曲软件下载听音识曲软件下载
    手机淘宝如何买东西
    linux 开机进入text
    秦火火 知乎
    淘宝评论领券是真的吗
    阿里云个人备案要多久
    mac 卸载软件
    软件说明文档
    什么是移动数据
    汕头宠物店软件
    win7怎样关闭网络共享
    unix高级编程视频教程
    淘宝订单险如何使用
    lvs负载均衡算法
    apache下载32位
    动易软件电话
    车工钳工 知乎
    淘宝模特一分钟摆姿势
    开黑用什么软件
    热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 德国人英语复数 德国多少人 德国人的性格 日耳曼人是德国人吗 德国人长相 德国人性格 德国人 英语 德国人的英文 德国人的英语 德国人的特征 钢琴师怎么不救德国人 德国刀具 德国指甲刀品牌 德国刮胡刀品牌排行榜 德国铣刀价格 德国超声刀 德国刀品牌 日本刀具品牌 索林根 日本刀具 德国铁元不能乱吃 德国真空泵 德国大陆集团 德国队吧 德国之声 德国展 德国k展 德国阴展 启德国际教育展 德国第一装甲师战歌 德国man 德国曼瑞德 德国曼集团 德国曼卡车 德国菲斯曼 德国曼恩集团 德国柏曼台灯 德国曼发动机 德国曼发动机优点 德国曼牵引车 德国曼房车

    程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里