java中equals，hashcode和==的区别

时间 2019-12-11

标签 java equals hashcode 区别栏目 Java 繁體版

原文原文链接

一、==html

java中的数据类型，可分为两类：java

1.基本数据类型，也称原始数据类型程序员

byte,short,char,int,long,float,double,boolean 他们之间的比较，应用双等号（==）,比较的是他们的值。算法

2.引用类型(类、接口、数组) 数组

当他们用（==）进行比较的时候，比较的是他们在内存中的存放地址，因此，除非是同一个new出来的对象，他们的比较后的结果为true，不然比较后结果为false。缓存

对象是放在堆中的，栈中存放的是对象的引用（地址）。因而可知'=='是对栈中的值进行比较的。若是要比较堆中对象的内容是否相同，那么就要重写equals方法了。性能优化

例：app

[java] view plain copy函数

public static void main(String[] args) {
int int1 = 12;
int int2 = 12;
Integer Integer1 = new Integer(12);
Integer Integer2 = new Integer(12);
Integer Integer3 = new Integer(127);
Integer a1 = 127;
Integer b1 = 127;
Integer a = 128;
Integer b = 128;
String s1 = "str";
String s2 = "str";
String str1 = new String("str");
String str2 = new String("str");
System.out.println("int1==int2:" + (int1 == int2));
System.out.println("int1==Integer1:" + (int1 == Integer1));
System.out.println("Integer1==Integer2:" + (Integer1 == Integer2));
System.out.println("Integer3==b1:" + (Integer3 == b1));
System.out.println("a1==b1:" + (a1 == b1));
System.out.println("a==b:" + (a == b));
System.out.println("s1==s2:" + (s1 == s2));
System.out.println("s1==str1:" + (s1 == str1));
System.out.println("str1==str2:" + (str1 == str2));
}

输出结果：性能

int1==int2:true
int1==Integer1:true //Integer会自动拆箱为int，因此为true
Integer1==Integer2:false//不一样对象，在内存存放地址不一样，因此为false
Integer3==b1:false//Integer3指向new的对象地址，b1指向缓存中127地址，地址不一样，因此为false

a1==b1:true
a==b:false

s1==s2:true
s1==str1:false
str1==str2:false

Integer b1 = 127;java在编译的时候,被翻译成-> Integer b1 = Integer.valueOf(127);

[java] view plain copy

public static Integer valueOf(int i) {
assert IntegerCache.high >= 127;
if (i >= IntegerCache.low && i <= IntegerCache.high)
return IntegerCache.cache[i + (-IntegerCache.low)];
return new Integer(i);
}

看一下源码你们都会明白，对于-128到127之间的数，会进行缓存，Integer b1 = 127时，会将127进行缓存，下次再写Integer i6 = 127时，就会直接从缓存中取，就不会new了。因此a1==b1:true a==b:false

二、equals

一、默认状况（没有覆盖equals方法）下equals方法都是调用Object类的equals方法，而Object的equals方法主要用于判断对象的内存地址引用是否是同一个地址（是否是同一个对象）。下面是Object类中equals方法：

[java] view plain copy

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

定义的equals与==是等效的

2 、要是类中覆盖了equals方法，那么就要根据具体的代码来肯定equals方法的做用了，覆盖后通常都是经过对象的内容是否相等来判断对象是否相等。下面是String类对equals进行了重写:

[java] view plain copy

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;
}

即String中equals方法判断相等的步骤是：

1.若A==B 便是同一个String对象返回true

2.若对比对象是String类型则继续，不然返回false

3.判断A、B长度是否同样，不同的话返回false

4。逐个字符比较，如有不相等字符，返回false

这里对equals从新须要注意五点：
1 自反性：对任意引用值X，x.equals(x)的返回值必定为true.
2 对称性：对于任何引用值x,y,当且仅当y.equals(x)返回值为true时，x.equals(y)的返回值必定为true;
3 传递性：若是x.equals(y)=true, y.equals(z)=true,则x.equals(z)=true
4 一致性：若是参与比较的对象没任何改变，则对象比较的结果也不该该有任何改变
5 非空性：任何非空的引用值X，x.equals(null)的返回值必定为false

实现高质量equals方法的诀窍：
1.使用==符号检查“参数是否为这个对象的引用”。若是是，则返回true。这只不过是一种性能优化，若是比较操做有可能很昂贵，就值得这么作。
2.使用instanceof操做符检查“参数是否为正确的类型”。若是不是，则返回false。通常来讲，所谓“正确的类型”是指equals方法所在的那个类。
3.把参数转换成正确的类型。由于转换以前进行过instanceof测试，因此确保会成功。
4.对于该类中的每一个“关键”域，检查参数中的域是否与该对象中对应的域相匹配。若是这些测试所有成功，则返回true;不然返回false。
5.当编写完成了equals方法以后，检查“对称性”、“传递性”、“一致性”。

三、hashCode

hashCode()方法返回的就是一个数值，从方法的名称上就能够看出，其目的是生成一个hash码。hash码的主要用途就是在对对象进行散列的时候做为key输入，据此很容易推断出，咱们须要每一个对象的hash码尽量不一样，这样才能保证散列的存取性能。事实上，Object类提供的默认实现确实保证每一个对象的hash码不一样（在对象的内存地址基础上通过特定算法返回一个hash码）。Java采用了哈希表的原理。哈希（Hash）其实是我的名，因为他提出一哈希算法的概念，因此就以他的名字命名了。哈希算法也称为散列算法，是将数据依特定算法直接指定到一个地址上。初学者能够这样理解，hashCode方法实际上返回的就是对象存储的物理地址（实际可能并非）。

散列函数,散列算法,哈希函数。
是一种从任何一种数据中建立小的数字“指纹”的方法。
散列函数将任意长度的二进制值映射为较短的固定长度的二进制值，这个小的二进制值称为哈希值。
好的散列函数在输入域中不多出现散列冲突。
=================================================================================
全部散列函数都有以下一个基本特性：
1：若是a=b，则h(a) = h(b)。
2：若是a!=b，则h(a)与h(b)可能获得相同的散列值。

Object 的hashCode方法：返回一个int类型

[java] view plain copy

public native int hashCode();

3.1 hashCode的做用

想要明白，必需要先知道Java中的集合。　　
总的来讲，Java中的集合（Collection）有两类，一类是List，再有一类是Set。前者集合内的元素是有序的，元素能够重复；后者元素无序，但元素不可重复。

那么这里就有一个比较严重的问题了：要想保证元素不重复，可两个元素是否重复应该依据什么来判断呢？

这就是Object.equals方法了。可是，若是每增长一个元素就检查一次，那么当元素不少时，后添加到集合中的元素比较的次数就很是多了。也就是说，若是集合中如今已经有1000个元素，那么第1001个元素加入集合时，它就要调用1000次equals方法。这显然会大大下降效率。
因而，Java采用了哈希表的原理。

这样一来，当集合要添加新的元素时，

先调用这个元素的hashCode方法，就一会儿能定位到它应该放置的物理位置上。

若是这个位置上没有元素，它就能够直接存储在这个位置上，不用再进行任何比较了；

若是这个位置上已经有元素了，就调用它的equals方法与新元素进行比较，相同的话就不存，不相同就散列其它的地址。因此这里存在一个冲突解决的问题。这样一来实际调用equals方法的次数就大大下降了，几乎只须要一两次。

四、eqauls方法和hashCode方法关系

Java对于eqauls方法和hashCode方法是这样规定的：

(1)同一对象上屡次调用hashCode()方法，老是返回相同的整型值。

(2)若是a.equals(b)，则必定有a.hashCode() 必定等于 b.hashCode()。

(3)若是!a.equals(b)，则a.hashCode() 不必定等于 b.hashCode()。此时若是a.hashCode() 老是不等于 b.hashCode()，会提升hashtables的性能。

(4)a.hashCode()==b.hashCode() 则 a.equals(b)可真可假

(5)a.hashCode()！= b.hashCode() 则 a.equals(b)为假。

上面结论简记：

一、若是两个对象equals，Java运行时环境会认为他们的hashcode必定相等。
二、若是两个对象不equals，他们的hashcode有可能相等。
三、若是两个对象hashcode相等，他们不必定equals。
四、若是两个对象hashcode不相等，他们必定不equals。

关于这两个方法的重要规范：

规范1：若重写equals(Object obj)方法，有必要重写hashcode()方法，确保经过equals(Object obj)方法判断结果为true的两个对象具有相等的hashcode()返回值。说得简单点就是：“若是两个对象相同，那么他们的hashcode应该相等”。不过请注意：这个只是规范，若是你非要写一个类让equals(Object obj)返回true而hashcode()返回两个不相等的值，编译和运行都是不会报错的。不过这样违反了Java规范，程序也就埋下了BUG。

规范2：若是equals(Object obj)返回false，即两个对象“不相同”，并不要求对这两个对象调用hashcode()方法获得两个不相同的数。说的简单点就是：“若是两个对象不相同，他们的hashcode可能相同”。

五、为何覆盖equals时总要覆盖hashCode
一个很常见的错误根源在于没有覆盖hashCode方法。在每一个覆盖了equals方法的类中，也必须覆盖hashCode方法。若是不这样作的话，就会违反Object.hashCode的通用约定，从而致使该类没法结合全部基于散列的集合一块儿正常运做，这样的集合包括HashMap、HashSet和Hashtable。

1.在应用程序的执行期间，只要对象的equals方法的比较操做所用到的信息没有被修改，那么对这同一个对象调用屡次，hashCode方法都必须始终如一地返回同一个整数。在同一个应用程序的屡次执行过程当中，每次执行所返回的整数能够不一致。

2.若是两个对象根据equals()方法比较是相等的，那么调用这两个对象中任意一个对象的hashCode方法都必须产生一样的整数结果。

3.若是两个对象根据equals()方法比较是不相等的，那么调用这两个对象中任意一个对象的hashCode方法，则不必定要产生相同的整数结果。可是程序员应该知道，给不相等的对象产生大相径庭的整数结果，有可能提升散列表的性能。

六、总结：
一、equals方法用于比较对象的内容是否相等（覆盖之后）

二、hashcode方法只有在集合中用到

三、当覆盖了equals方法时，比较对象是否相等将经过覆盖后的equals方法进行比较（判断对象的内容是否相等）。

四、将对象放入到集合中时，首先判断要放入对象的hashcode值与集合中的任意一个元素的hashcode值是否相等，若是不相等直接将该对象放入集合中。若是hashcode值相等，而后再经过equals方法判断要放入对象与集合中的任意一个对象是否相等，若是equals判断不相等，直接将该元素放入到集合中，不然不放入。

参考来源：

Integer与int的种种比较你知道多少？

java中hashCode方法与equals方法的用法总结

hashCode与equals的区别与联系

equals和hashCode解析