Java基础篇：equals()方法与==的区别 equals()与hashCode()方法
目录：
一、equals()方法与 “=="号 的区别：
1、超类Object的equals()底层原理：
2、equals()与"==" 的区别：
3、equals()的重写规则：
4、有关equals()与 == 号的小例子：
二、equals()与hashCode()方法：
1、认识HashCode()方法：
2、equals()与hashCode()的联系：
3、hashCode()方法的作用：
4、为什么重写equals()的同时要重写hashCode()方法：
5、重写equals()中 getClass 与 instaceof 的区别：
6、由hashCode()造成的内存泄露问题：
7、基本数据类型和String类型的hashCode()方法和equals()方法：
一、equals()方法与 “=="号 的区别：
1、超类Object的equals()底层原理：
在超类Object中有一个equals()的基本方法，源码如下：
public boolean equals(Object obj) { return (this == obj); }
实际上我们知道所有的对象都拥有标识（内存地址）和状态（数据），同时“==”比较的是两个对象的内存地址，在Object的equals方法底层调用的是==号，所以说Object的equals()方法是比较两个对象的内存地址是否相等，如果为true，则表示的引用的是同一个对象。
2、equals()与"==" 的区别：
（1）== 号在比较基本数据类型时比较的是数据的值，而用 == 号比较两个对象时比较的是两个对象的地址值；
（2）equals()不能用于基本的数据类型，对于基本的数据类型要用其包装类。
（3）默认情况下，也就是从Object继承而来的 equals 方法与 “==” 是完全等价的，比较的都是对象的内存地址，因为底层调用的是 “==” 号，但我们可以重写equals方法，使其按照我们的需求方式进行比较，如String类重写equala()方法，使其比较的是字符的内容，而不再是内存地址。
3、equals()的重写规则：
我们在重写equals方法时，还是需要注意如下几点规则的。
-
自反性。对于任何非null的引用值x，x.equals(x)应返回true。
-
对称性。对于任何非null的引用值x与y，当且仅当：y.equals(x)返回true时，x.equals(y)才返回true。
-
传递性。对于任何非null的引用值x、y与z，如果y.equals(x)返回true，y.equals(z)返回true，那么x.equals(z)也应返回true。
-
一致性。对于任何非null的引用值x与y，假设对象上equals比较中的信息没有被修改，则多次调用x.equals(y)始终返回true或者始终返回false。
-
对于任何非空引用值x，x.equal(null)应返回false。
4、有关equals()与 == 号的小例子：
public class Test {
public static void main(String[] args) {
String str1 = new String("abc");
String str2 = new String("abc");
System.out.println(str1 == str2);//false
System.out.println(str1.equals(str2));//true
String str3 = "123";
String str4 = "123";
System.out.println(str3 == str4);//true
System.out.println(str3.equals(str4));//true
}
}根据上面的demo输出结果可以看到，前面的输出结果是false、true，后面的输出结果是true、true。为什么两次==的输出结果不一样呢？这其实涉及到了内存中的常量池，常量池属于方法区的一部分，当运行到创建str3对象时，如果常量池中没有“123”，则在常量池中创建一个"123"对象，运行到str4对象时，由于“123”已经存在常量池，就直接使用，所以str3和str4对象其实是同一个对象，他们的地址引用相同。
而对于str1和str2，它们其实创建了两次对象，一次在常量池创建了对象“abc”，所以str1和str2的地址值是不相等的。
二、equals()与hashCode()方法：
1、认识HashCode()方法：
hashCode的意思就是散列码，也就是哈希码，是由对象导出的一个整型值，散列码是没有规律的，如果x与y是两个不同的对象，那么x.hashCode()与y.hashCode()基本是不会相同的，下面通过String类的hashCode()计算一组散列码：
package com.zejian.test;
public class HashCodeTest {
public static void main(String[] args) {
int hash=0;
String s="ok";
StringBuilder sb =new StringBuilder(s);
System.out.println(s.hashCode()+" "+sb.hashCode());
String t = new String("ok");
StringBuilder tb =new StringBuilder(s);
System.out.println(t.hashCode()+" "+tb.hashCode());
}
}
运行结果：
3548 1829164700
3548 2018699554我们可以看出，字符串s与t拥有相同的散列码，这是因为字符串的散列码是由内容导出的。而字符串缓冲sb与tb却有着不同的散列码，这是因为StringBuilder没有重写hashCode方法，它的散列码是由Object类默认的hashCode方法计算出来的对象存储地址，所以散列码自然也就不同了。那么我们该如何重写出一个较好的hashCode方法呢，其实并不难，我们只要合理地组织对象的散列码，就能够让不同的对象产生比较均匀的散列码。例如下面的例子：
package com.zejian.test;
public class Model {
private String name;
private double salary;
private int sex;
@Override
public int hashCode() {
return name.hashCode()+new Double(salary).hashCode()
+ new Integer(sex).hashCode();
}
}
上面的代码我们通过合理的利用各个属性对象的散列码进行组合，最终便能产生一个相对比较好的或者说更加均匀的散列码，当然上面仅仅是个参考例子而已，我们也可以通过其他方式去实现，只要能使散列码更加均匀（所谓的均匀就是每个对象产生的散列码最好都不冲突）就行了。不过这里有点要注意的就是java 7中对hashCode方法做了两个改进，首先java发布者希望我们使用更加安全的调用方式来返回散列码，也就是使用null安全的方法Objects.hashCode（注意不是Object而是java.util.Objects）方法，这个方法的优点是如果参数为null，就只返回0，否则返回对象参数调用的hashCode的结果。Objects.hashCode 源码如下：
public static int hashCode(Object o) {
return o != null ? o.hashCode() : 0;
}
因此我们修改后的代码如下：
package com.zejian.test;
import java.util.Objects;
public class Model {
private String name;
private double salary;
private int sex;
@Override
public int hashCode() {
return Objects.hashCode(name)+new Double(salary).hashCode()
+ new Integer(sex).hashCode();
}
}
java 7还提供了另外一个方法java.util.Objects.hash(Object... objects),当我们需要组合多个散列值时可以调用该方法。进一步简化上述的代码：
package com.zejian.test;
import java.util.Objects;
public class Model {
private String name;
private double salary;
private int sex;
// @Override
// public int hashCode() {
// return Objects.hashCode(name)+new Double(salary).hashCode()
// + new Integer(sex).hashCode();
// }
@Override
public int hashCode() {
return Objects.hash(name,salary,sex);
}
}
好了，到此hashCode()该介绍的我们都说了，还有一点要说的，如果我们提供的是一个数组类型的变量的话，那么我们可以调用Arrays.hashCode()来计算它的散列码，这个散列码是由数组元素的散列码组成的。
2、equals()与hashCode()的联系：
Java中的equals()方法和hashCode()方法是Object超类中的，所以每个对象都有这两个方法的，有时候我们实现特定的需求，可能要重写这两个方法，下面介绍一下这两个方法的作用。
equals()和hashCode()方法是用来在同一类中做比较用的，尤其是在容器里如set存放同一类对象时用来判断放入的对象是否重复。
如果两个对象根据equals()方法比较是相等的，那么调用这两个对象中任意一个对象的hashCode方法都必须产生同样的整数结果。
如果两个对象根据equals()方法比较是不相等的，那么调用这两个对象中任意一个对象的hashCode方法，则不一定要产生相同的整数结果。
3、hashCode()方法的作用：
想要明白Java中hashCode()方法的作用，就必须先知道Java中的集合。下面先通过一个问题逐步说明：
如果想查找一个集合中是否包含有某个对象，大概的程序代码怎样写呢？
你通常是逐一取出每个元素与要查找的对象进行比较，当发现某个元素与要查找的对象进行equals方法比较的结果相等时，则停止继续查找并返回肯定的信息，否则，返回否定的信息。如果一个集合中有很多个元素，比如有一万个元素，并且没有包含要查找的对象时，则意味着你的程序需要从集合中取出一万个元素进行逐一比较才能得到结论。
这时，有人发明了一种哈希算法来提高从集合中查找元素的效率，这种方式将集合分成若干个存储区域，每个对象可以计算出一个哈希码，可以将哈希码分组(使用不同的hash函数来计算的)，每组分别对应某个存储区域，根据一个对象的哈希码就可以确定该对象应该存储在哪个区域，HashSet就是采用哈希算法存取对象的集合，它内部采用对某个数字n进行取余的方式对哈希码进行分组和划分对象的存储区域；Object类中定义了一个hashCode()方法来返回每个Java对象的哈希码，当从HashSet集合中查找某个对象时，Java系统首先调用对象的hashCode()方法获得该对象的哈希码，然后根据哈希吗找到相应的存储区域，最后取得该存储区域内的每个元素与该对象进行equals方法比较；这样就不用遍历集合中的所有元素就可以得到结论，可见，HashSet集合具有很好的对象检索性能。
所以，总结一下，hashCode的存在主要是用于查找的快捷性，如Hashtable，HashMap，HashSet等，hashCode是用来在散列存储结构中确定对象的存储地址的；
4、为什么重写equals()的同时要重写hashCode()方法：
在将这个问题的答案之前，我们先了解一下将元素放入集合的流程，如下图：
将对象放入到集合中时，首先判断要放入对象的hashcode值与集合中的任意一个元素的hashcode值是否相等，如果不相等直接将该对象放入集合中。如果hashcode值相等，然后再通过equals方法判断要放入对象与集合中的任意一个对象是否相等，如果equals判断不相等，直接将该元素放入到集合中，否则不放入。回过来说，在get的时候，集合类也先调key.hashCode()算出数组下标，然后看equals()的结果，如果是true就是找到了，否则就是没找到。
以上面的第2节的HashSet为例可知，HashSet集合具有很好的对象检索性能，但是，HashSet集合存储对象的效率相对要低些，因为向HashSet集合中添加一个对象时，要先计算出对象的哈希码和根据这个哈希码确定对象在集合中的存放位置，为了保证一个类的实例对象能在HashSet正常存储，要求这个类的两个实例对象用equals()方法比较的结果相等时，他们的哈希码也必须相等；也就是说，如果 obj1.equals(obj2) 的结果为true,那么obj1.hashCode() == obj2.hashCode() 表达式的结果也要为true；
换句话说：当我们重写一个对象的equals方法，就必须重写他的hashCode方法，如果不重写他的hashCode方法的话，Object对象中的hashCode方法始终返回的是一个对象的hash地址，而不同对象的这个地址是永远不相等的。所以这时候即使是重写了equals方法，也不会有特定的效果的，因为hashCode方法如果都不想等的话，就不会调用equals方法进行比较了，所以重写equals()就没有意义了。
如果一个类的hashCode()方法没有遵循上述要求，那么，当这个类的两个实例对象用equals()方法比较的结果相等时，他们本来应该无法被同时存储进set集合中，但是，如果将他们存储进HashSet集合中时，由于他们的hashCode()方法的返回值不同(Object中的hashCode方法返回值是永远不同的)，第二个对象首先按照哈希码计算可能被放进与第一个对象不同的区域中，这样，它就不可能与第一个对象进行equals方法比较了，也就可能被存储进HashSet集合中了；所以，Object类中的hashCode()方法不能满足对象被存入到HashSet中的要求，因为它的返回值是通过对象的内存地址推算出来的，同一个对象在程序运行期间的任何时候返回的哈希值都是始终不变的，所以，只要是两个不同的实例对象，即使他们的equals方法比较结果相等，他们默认的hashCode方法的返回值是不同的。
接下来，我们就举几个小例子测试一下：
测试一：覆盖equals（Object obj）但不覆盖hashCode（）,导致数据不唯一性。
public class HashCodeTest {
public static void main(String[] args) {
Collection set = new HashSet();
Point p1 = new Point(1, 1);
Point p2 = new Point(1, 1);
System.out.println(p1.equals(p2));
set.add(p1); //(1)
set.add(p2); //(2)
set.add(p1); //(3)
Iterator iterator = set.iterator();
while (iterator.hasNext()) {
Object object = iterator.next();
System.out.println(object);
}
}
}
class Point {
private int x;
private int y;
public Point(int x, int y) {
super();
this.x = x;
this.y = y;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Point other = (Point) obj;
if (x != other.x)
return false;
if (y != other.y)
return false;
return true;
}
@Override
public String toString() {
return "x:" + x + ",y:" + y;
}
}
输出结果：
true
x:1,y:1
x:1,y:1 原因分析：
（1）当执行set.add(p1)时（1），集合为空，直接存入集合；
（2）当执行set.add(p2)时（2），首先判断该对象（p2）的hashCode值所在的存储区域是否有相同的hashCode，因为没有覆盖hashCode方法，所以jdk使用默认Object的hashCode方法，返回内存地址转换后的整数，因为不同对象的地址值不同，所以这里不存在与p2相同hashCode值的对象，因此jdk默认不同hashCode值，equals一定返回false，所以直接存入集合。
（3）当执行set.add(p1)时（3），时，因为p1已经存入集合，同一对象返回的hashCode值是一样的，继续判断equals是否返回true，因为是同一对象所以返回true。此时jdk认为该对象已经存在于集合中，所以舍弃。
测试二：覆盖hashCode方法，但不覆盖equals方法，仍然会导致数据的不唯一性。
修改Point类：
class Point {
private int x;
private int y;
public Point(int x, int y) {
super();
this.x = x;
this.y = y;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + x;
result = prime * result + y;
return result;
}
@Override
public String toString() {
return "x:" + x + ",y:" + y;
}
} 输出结果：
false
x:1,y:1
x:1,y:1 原因分析：
（1）当执行set.add(p1)时（1），集合为空，直接存入集合；
（2）当执行set.add(p2)时（2），首先判断该对象（p2）的hashCode值所在的存储区域是否有相同的hashCode，这里覆盖了hashCode方法，p1和p2的hashCode相等，所以继续判断equals是否相等，因为这里没有覆盖equals，默认使用'=='来判断，所以这里equals返回false，jdk认为是不同的对象，所以将p2存入集合。
（3）当执行set.add(p1)时（3），时，因为p1已经存入集合，同一对象返回的hashCode值是一样的，并且equals返回true。此时jdk认为该对象已经存在于集合中，所以舍弃。
综合上述两个测试，要想保证元素的唯一性，必须同时覆盖hashCode和equals才行。
（注意：在HashSet中插入同一个元素（hashCode和equals均相等）时，会被舍弃，而在HashMap中插入同一个Key（Value 不同）时，原来的元素会被覆盖。）
5、重写equals()中 getClass 与 instaceof 的区别：
在重写equals() 方法时，一般都是推荐使用 getClass 来进行类型判断（除非所有的子类有统一的语义才使用instanceof），不是使用 instanceof。我们都知道 instanceof 的作用是判断其左边对象是否为其右边类的实例，返回 boolean 类型的数据。可以用来判断继承中的子类的实例是否为父类的实现。
下来我们来看一个例子：父类Person
public class Person {
protected String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Person(String name){
this.name = name;
}
public boolean equals(Object object){
if(object instanceof Person){
Person p = (Person) object;
if(p.getName() == null || name == null){
return false;
}
else{
return name.equalsIgnoreCase(p.getName ());
}
}
return false;
}
}
子类 Employee：
public class Employee extends Person{
private int id;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public Employee(String name,int id){
super(name);
this.id = id;
}
/**
* 重写equals()方法
*/
public boolean equals(Object object){
if(object instanceof Employee){
Employee e = (Employee) object;
return super.equals(object) && e.getId() == id;
}
return false;
}
}
上面父类 Person 和子类 Employee 都重写了 equals(),不过 Employee 比父类多了一个id属性,而且这里我们并没有统一语义。测试代码如下：
public class Test {
public static void main(String[] args) {
Employee e1 = new Employee("chenssy", 23);
Employee e2 = new Employee("chenssy", 24);
Person p1 = new Person("chenssy");
System.out.println(p1.equals(e1));//true
System.out.println(p1.equals(e2));//true
System.out.println(e1.equals(e2));//false
}
}
上面代码我们定义了两个员工和一个普通人，虽然他们同名，但是他们肯定不是同一人，所以按理来说结果应该全部是 false，但是事与愿违，结果是：true、true、false。对于那 e1!=e2 我们非常容易理解，因为他们不仅需要比较 name,还需要比较 ID。但是 p1 即等于 e1 也等于 e2，这是非常奇怪的，因为 e1、e2 明明是两个不同的类，但为什么会出现这个情况？首先 p1.equals(e1)，是调用 p1 的 equals 方法，该方法使用 instanceof 关键字来检查 e1 是否为 Person 类，这里我们再看看 instanceof：判断其左边对象是否为其右边类的实例，也可以用来判断继承中的子类的实例是否为父类的实现。他们两者存在继承关系，肯定会返回 true 了，而两者 name 又相同，所以结果肯定是 true。所以出现上面的情况就是使用了关键字 instanceof，这是非常容易导致我们“钻牛角尖”。故在覆写 equals 时推荐使用 getClass 进行类型判断。而不是使用 instanceof（除非子类拥有统一的语义）。
6、由hashCode()造成的内存泄露问题：
package com.weijia.demo;
public class RectObject {
public int x;
public int y;
public RectObject(int x,int y){
this.x = x;
this.y = y;
}
@Override
public int hashCode(){
final int prime = 31;
int result = 1;
result = prime * result + x;
result = prime * result + y;
return result;
}
@Override
public boolean equals(Object obj){
if(this == obj)
return true;
if(obj == null)
return false;
if(getClass() != obj.getClass())
return false;
final RectObject other = (RectObject)obj;
if(x != other.x){
return false;
}
if(y != other.y){
return false;
}
return true;
}
}
我们重写了父类Object中的hashCode和equals方法，看到hashCode和equals方法中，如果两个RectObject对象的x,y值相等的话他们的hashCode值是相等的，同时equals返回的是true;
package com.weijia.demo;
import java.util.HashSet;
public class Demo {
public static void main(String[] args){
HashSet set = new HashSet();
RectObject r1 = new RectObject(3,3);
RectObject r2 = new RectObject(5,5);
RectObject r3 = new RectObject(3,3);
set.add(r1);
set.add(r2);
set.add(r3);
r3.y = 7;
System.out.println("删除前的大小size:"+set.size());//3
set.remove(r3);
System.out.println("删除后的大小size:"+set.size());//3
}
}
运行结果：
删除前的大小size:3
删除后的大小size:3在这里，我们发现了一个问题，当我们调用了remove删除r3对象，以为删除了r3,但事实上并没有删除，这就叫做内存泄露，就是不用的对象但是他还在内存中。所以我们多次这样操作之后，内存就爆了。看一下remove的源码：
public boolean remove(Object o) {
return map.remove(o)==PRESENT;
}
然后再看一下map的remove方法的源码：
public V remove(Object key) {
Entry e = removeEntryForKey(key);
return (e == null ? null : e.value);
}
再看一下removeEntryForKey方法源码：
/**
* Removes and returns the entry associated with the specified key
* in the HashMap. Returns null if the HashMap contains no mapping
* for this key.
*/
final Entry removeEntryForKey(Object key) {
int hash = (key == null) ? 0 : hash(key);
int i = indexFor(hash, table.length);
Entry prev = table[i];
Entry e = prev;
while (e != null) {
Entry next = e.next;
Object k;
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k)))) {
modCount++;
size--;
if (prev == e)
table[i] = next;
else
prev.next = next;
e.recordRemoval(this);
return e;
}
prev = e;
e = next;
}
return e;
}
我们看到，在调用remove方法的时候，会先使用对象的hashCode值去找到这个对象，然后进行删除，这种问题就是因为我们在修改了 r3 对象的 y 属性的值，又因为RectObject对象的hashCode()方法中有y值参与运算,所以r3对象的hashCode就发生改变了，所以remove方法中并没有找到 r3，所以删除失败。即 r3的hashCode变了，但是他存储的位置没有更新，仍然在原来的位置上，所以当我们用他的新的hashCode去找肯定是找不到了.
上面的这个内存泄露告诉我一个信息：如果我们将对象的属性值参与了hashCode的运算中，在进行删除的时候，就不能对其属性值进行修改，否则会导致内存泄露问题。
7、基本数据类型和String类型的hashCode()方法和equals()方法：
其中8中基本类型的hashCode很简单就是直接返回他们的数值大小，String对象是通过一个复杂的计算方式，但是这种计算方式能够保证，如果这个字符串的值相等的话，他们的hashCode就是相等的。8种基本类型的equals方法就是直接比较数值，String类型的equals方法是比较字符串的值的。
参考博客：
https://blog.csdn.net/jiangwei0910410003/article/details/22739953
https://blog.csdn.net/javazejian/article/details/51348320