Java hashCode()和equals()的几个问题
副标题#e#
本章的内容主要办理下面几个问题：
1 equals() 的浸染是什么？
2 equals() 与 == 的区别是什么？
3 hashCode() 的浸染是什么？
4 hashCode() 和 equals() 之间有什么接洽？
第1部门 equals() 的浸染
equals() 的浸染是 用来判定两个工具是否相等。
equals() 界说在JDK的Object.java中。通过判定两个工具的地点是否相等(即，是否是同一个工具)来区分它们是否相等。源码如下：
public boolean equals(Object obj) {
return (this == obj);
}
既然Object.java中界说了equals()要领，这就意味着所有的Java类都实现了equals()要领，所有的类都可以通过equals()去较量两个工具是否相等。 可是，我们已经说过，利用默认的“equals()”要领，等价于“==”要领。因此，我们凡是会重写equals()要领：若两个工具的内容相等，则equals()要领返回true；不然，返回fasle。
下面按照“类是否包围equals()要领”，将它分为2类。
(01) 若某个类没有包围equals()要领，当它的通过equals()较量两个工具时，实际上是较量两个工具是不是同一个工具。这时，等价于通过“==”去较量这两个工具。
(02) 我们可以包围类的equals()要领，来让equals()通过其它方法较量两个工具是否相等。凡是的做法是：若两个工具的内容相等，则equals()要领返回true；不然，返回fasle。
下面，举例对上面的2种环境举办说明。
1. “没有包围equals()要领”的环境
代码如下 (EqualsTest1.java)：
import java.util.*;
import java.lang.Comparable;
/**
* @desc equals()的测试措施。
*
* @author skywang
* @emai [email protected]
*/
public class EqualsTest1{
public static void main(String[] args) {
// 新建2个沟通内容的Person工具，
// 再用equals较量它们是否相等
Person p1 = new Person("eee", 100);
Person p2 = new Person("eee", 100);
System.out.printf("%sn", p1.equals(p2));
}
/**
* @desc Person类。
*/
private static class Person {
int age;
String name;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public String toString() {
return name + " - " +age;
}
}
}
运行功效：
false
功效阐明：
我们通过 p1.equals(p2) 来“较量p1和p2是否相等时”。实际上，挪用的Object.java的equals()要领，即挪用的 (p1==p2) 。它是较量“p1和p2是否是同一个工具”。
而由 p1 和 p2 的界说可知，它们固然内容沟通；但它们是两个差异的工具！因此，返回功效是false。
2. "包围equals()要领"的环境
我们修改上面的EqualsTest1.java：包围equals()要领。
代码如下 (EqualsTest2.java)：
import java.util.*;
import java.lang.Comparable;
/**
* @desc equals()的测试措施。
*
* @author skywang
* @emai [email protected]
*/
public class EqualsTest2{
public static void main(String[] args) {
// 新建2个沟通内容的Person工具，
// 再用equals较量它们是否相等
Person p1 = new Person("eee", 100);
Person p2 = new Person("eee", 100);
System.out.printf("%sn", p1.equals(p2));
}
/**
* @desc Person类。
*/
private static class Person {
int age;
String name;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public String toString() {
return name + " - " +age;
}
/**
* @desc 包围equals要领
*/
@Override
public boolean equals(Object obj){
if(obj == null){
return false;
}
//假如是同一个工具返回true，反之返回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;
}
}
}
运行功效：
true
功效阐明：
我们在EqualsTest2.java 中重写了Person的equals()函数：当两个Person工具的 name 和 age 都相等，则返回true。
因此，运行功效返回true。
讲到这里，顺便说一下java对equals()的要求。有以下几点：
#p#分页标题#e#
1. 对称性：假如x.equals(y)返回是"true"，那么y.equals(x)也应该返回是"true"。
2. 反射性：x.equals(x)必需返回是"true"。
3. 类推性：假如x.equals(y)返回是"true"，并且y.equals(z)返回是"true"，那么z.equals(x)也应该返回是"true"。
4. 一致性：假如x.equals(y)返回是"true"，只要x和y内容一直稳定，不管你反复x.equals(y)几多次，返回都是"true"。
5. 非空性，x.equals(null)，永远返回是"false"；x.equals(和x差异范例的工具)永远返回是"false"。
此刻，再回首一下equals()的浸染：判定两个工具是否相等。当我们重写equals()的时候，可千万欠好将它的浸染给改变了！
第2部门 equals() 与 == 的区别是什么？
== : 它的浸染是判定两个工具的地点是不是相等。即，判定两个工具是不试同一个工具。
equals() : 它的浸染也是判定两个工具是否相等。但它一般有两种利用环境(前面第1部门已具体先容过)：
环境1，类没有包围equals()要领。则通过equals()较量该类的两个工具时，等价于通过“==”较量这两个工具。
环境2，类包围了equals()要领。一般，我们都包围equals()要领来两个工具的内容相等；若它们的内容相等，则返回true(即，认为这两个工具相等)。
下面，通过示例较量它们的区别。
#p#副标题#e#
代码如下：
import java.util.*;
import java.lang.Comparable;
/**
* @desc equals()的测试措施。
*
* @author skywang
* @emai [email protected]
*/
public class EqualsTest3{
public static void main(String[] args) {
// 新建2个沟通内容的Person工具，
// 再用equals较量它们是否相等
Person p1 = new Person("eee", 100);
Person p2 = new Person("eee", 100);
System.out.printf("p1.equals(p2) : %sn", p1.equals(p2));
System.out.printf("p1==p2 : %sn", p1==p2);
}
/**
* @desc Person类。
*/
private static class Person {
int age;
String name;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public String toString() {
return name + " - " +age;
}
/**
* @desc 包围equals要领
*/
@Override
public boolean equals(Object obj){
if(obj == null){
return false;
}
//假如是同一个工具返回true，反之返回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;
}
}
}
运行功效：
p1.equals(p2) : true
p1==p2 : false
功效阐明：
在EqualsTest3.java 中：
(01) p1.equals(p2)
这是判定p1和p2的内容是否相等。因为Person包围equals()要领，而这个equals()是用来判定p1和p2的内容是否相等，恰恰p1和p2的内容又相等；因此，返回true。
(02) p1==p2
这是判定p1和p2是否是同一个工具。由于它们是各自新建的两个Person工具；因此，返回false。
第3部门 hashCode() 的浸染
hashCode() 的浸染是获取哈希码，也称为散列码；它实际上是返回一个int整数。这个哈希码的浸染是确定该工具在哈希表中的索引位置。
hashCode() 界说在JDK的Object.java中，这就意味着Java中的任何类都包括有hashCode() 函数。
固然，每个Java类都包括hashCode() 函数。可是，仅仅当建设并某个“类的散列表”(关于“散列表”见下面说明)时，该类的hashCode() 才有用(浸染是：确定该类的每一个工具在散列表中的位置；其它环境下(譬喻，建设类的单个工具，可能建设类的工具数组等等)，类的hashCode() 没有浸染。
上面的散列表，指的是：Java荟萃中本质是散列表的类，如HashMap，Hashtable，HashSet。
也就是说：hashCode() 在散列表中才有用，在其它环境下没用。在散列表中hashCode() 的浸染是获取工具的散列码，进而确定该工具在散列表中的位置。
#p#分页标题#e#
OK！至此，我们搞清楚了：hashCode()的浸染是获取散列码。可是，散列码是用来干什么的呢？为什么散列表需要散列码呢？要办理这些问题，就需要理遣散列表！关于散列表的内容，非三言两语道的大白。
为了能领略后头的内容，这里简朴的先容一下散列码的浸染。
我们都知道，散列表存储的是键值对(key-value)，它的特点是：能按照“键”快速的检索出对应的“值”。这个中就操作到了散列码！
散列表的本质是通过数组实现的。当我们要获取散列表中的某个“值”时，实际上是要获取数组中的某个位置的元素。而数组的位置，就是通过“键”来获取的；更进一步说，数组的位置，是通过“键”对应的散列码计较获得的。
下面，我们以HashSet为例，来深入说明hashCode()的浸染。
假设，HashSet中已经有1000个元素。当插入第1001个元素时，需要怎么处理惩罚？因为HashSet是Set荟萃，它答允有反复元素。
“将第1001个元素逐个的和前面1000个元素举办较量”？显然，这个效率是相等低下的。散列表很好的办理了这个问题，它按照元素的散列码计较出元素在散列表中的位置，然后将元素插入该位置即可。对付沟通的元素，自然是只生存了一个。
由此可知，若两个元素相等，它们的散列码必然相等；但反过来确不必然。在散列表中，
1、假如两个工具相等，那么它们的hashCode()值必然要沟通；
2、假如两个工具hashCode()相等，它们并不必然相等。
留意：这是在散列表中的环境。在非散列表中必然如此！
对“hashCode()的浸染”就谈这么多。
第4部门 hashCode() 和 equals() 的干系
接下面，我们接头别的一个话题。网上许多文章将 hashCode() 和 equals 关联起来，有的讲的不透彻，有误导读者的嫌疑。在这里，我本身梳理了一下 “hashCode() 和 equals()的干系”。
我们以“类的用途”来将“hashCode() 和 equals()的干系”分2种环境来说明。
1. 第一种 不会建设“类对应的散列表”
这里所说的“不会建设类对应的散列表”是说：我们不会在HashSet, Hashtable, HashMap等等这些本质是散列表的数据布局中，用到该类。譬喻，不会建设该类的HashSet荟萃。
在这种环境下，该类的“hashCode() 和 equals() ”没有半毛钱干系的！
这种环境下，equals() 用来较量该类的两个工具是否相等。而hashCode() 则基础没有任何浸染，所以，不消剖析hashCode()。
下面，我们通过示例查察类的两个工具相等 以及 不等时hashCode()的取值。
源码如下 (NormalHashCodeTest.java)：
import java.util.*;
import java.lang.Comparable;
/**
* @desc 较量equals() 返回true 以及 返回false时， hashCode()的值。
*
* @author skywang
* @emai [email protected]
*/
public class NormalHashCodeTest{
public static void main(String[] args) {
// 新建2个沟通内容的Person工具，
// 再用equals较量它们是否相等
Person p1 = new Person("eee", 100);
Person p2 = new Person("eee", 100);
Person p3 = new Person("aaa", 200);
System.out.printf("p1.equals(p2) : %s; p1(%d) p2(%d)n", p1.equals(p2), p1.hashCode(), p2.hashCode());
System.out.printf("p1.equals(p3) : %s; p1(%d) p3(%d)n", p1.equals(p3), p1.hashCode(), p3.hashCode());
}
/**
* @desc Person类。
*/
private static class Person {
int age;
String name;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public String toString() {
return name + " - " +age;
}
/**
* @desc 包围equals要领
*/
public boolean equals(Object obj){
if(obj == null){
return false;
}
//假如是同一个工具返回true，反之返回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;
}
}
}
运行功效：
p1.equals(p2) : true; p1(1169863946) p2(1901116749)
p1.equals(p3) : false; p1(1169863946) p3(2131949076)
从功效也可以看出：p1和p2相等的环境下，hashCode()也不必然相等。
2. 第二种 会建设“类对应的散列表”
#p#分页标题#e#
这里所说的“会建设类对应的散列表”是说：我们会在HashSet, Hashtable, HashMap等等这些本质是散列表的数据布局中，用到该类。譬喻，会建设该类的HashSet荟萃。
在这种环境下，该类的“hashCode() 和 equals() ”是有干系的：
1)、假如两个工具相等，那么它们的hashCode()值必然沟通。
这里的相等是指，通过equals()较量两个工具时返回true。
2)、假如两个工具hashCode()相等，它们并不必然相等。
因为在散列表中，hashCode()相等，即两个键值对的哈希值相等。然而哈希值相等，并不必然能得出键值对相等。增补说一句：“两个差异的键值对，哈希值相等”，这就是哈希斗嘴。
另外，在这种环境下。若要判定两个工具是否相等，除了要包围equals()之外，也要包围hashCode()函数。不然，equals()无效。
譬喻，建设Person类的HashSet荟萃，必需同时包围Person类的equals() 和 hashCode()要领。
假如单单只是包围equals()要领。我们会发明，equals()要领没有到达我们想要的结果。
参考代码 (ConflictHashCodeTest1.java)：
import java.util.*;
import java.lang.Comparable;
/**
* @desc 较量equals() 返回true 以及 返回false时， hashCode()的值。
*
* @author skywang
* @emai [email protected]
*/
public class ConflictHashCodeTest1{
public static void main(String[] args) {
// 新建Person工具，
Person p1 = new Person("eee", 100);
Person p2 = new Person("eee", 100);
Person p3 = new Person("aaa", 200);
// 新建HashSet工具
HashSet set = new HashSet();
set.add(p1);
set.add(p2);
set.add(p3);
// 较量p1 和 p2， 并打印它们的hashCode()
System.out.printf("p1.equals(p2) : %s; p1(%d) p2(%d)n", p1.equals(p2), p1.hashCode(), p2.hashCode());
// 打印set
System.out.printf("set:%sn", set);
}
/**
* @desc Person类。
*/
private static class Person {
int age;
String name;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public String toString() {
return "("+name + ", " +age+")";
}
/**
* @desc 包围equals要领
*/
@Override
public boolean equals(Object obj){
if(obj == null){
return false;
}
//假如是同一个工具返回true，反之返回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;
}
}
}
查察本栏目
运行功效：
p1.equals(p2) : true; p1(1169863946) p2(1690552137)
set:[(eee, 100), (eee, 100), (aaa, 200)]
功效阐明：
我们重写了Person的equals()。可是，很奇怪的发明：HashSet中仍然有反复元素：p1 和 p2。为什么会呈现这种环境呢？
这是因为固然p1 和 p2的内容相等，可是它们的hashCode()不等；所以，HashSet在添加p1和p2的时候，认为它们不相等。
下面，我们同时包围equals() 和 hashCode()要领。
参考代码 (ConflictHashCodeTest2.java)：
import java.util.*;
import java.lang.Comparable;
/**
* @desc 较量equals() 返回true 以及 返回false时， hashCode()的值。
*
* @author skywang
* @emai [email protected]
*/
public class ConflictHashCodeTest2{
public static void main(String[] args) {
// 新建Person工具，
Person p1 = new Person("eee", 100);
Person p2 = new Person("eee", 100);
Person p3 = new Person("aaa", 200);
Person p4 = new Person("EEE", 100);
// 新建HashSet工具
HashSet set = new HashSet();
set.add(p1);
set.add(p2);
set.add(p3);
// 较量p1 和 p2， 并打印它们的hashCode()
System.out.printf("p1.equals(p2) : %s; p1(%d) p2(%d)n", p1.equals(p2), p1.hashCode(), p2.hashCode());
// 较量p1 和 p4， 并打印它们的hashCode()
System.out.printf("p1.equals(p4) : %s; p1(%d) p4(%d)n", p1.equals(p4), p1.hashCode(), p4.hashCode());
// 打印set
System.out.printf("set:%sn", set);
}
/**
* @desc Person类。
*/
private static class Person {
int age;
String name;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public String toString() {
return name + " - " +age;
}
/**
* @desc重写hashCode
*/
@Override
public int hashCode(){
int nameHash = name.toUpperCase().hashCode();
return nameHash ^ age;
}
/**
* @desc 包围equals要领
*/
@Override
public boolean equals(Object obj){
if(obj == null){
return false;
}
//假如是同一个工具返回true，反之返回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;
}
}
}
运行功效：
p1.equals(p2) : true; p1(68545) p2(68545)
p1.equals(p4) : false; p1(68545) p4(68545)
set:[aaa – 200, eee – 100]
功效阐明：
#p#分页标题#e#
这下，equals()生效了，HashSet中没有反复元素。
较量p1和p2，我们发明：它们的hashCode()相等，通过equals()较量它们也返回true。所以，p1和p2被视为相等。
较量p1和p4，我们发明：固然它们的hashCode()相等；可是，通过equals()较量它们返回false。所以，p1和p4被视为不相等。
