Java中 ==，equals以及hascode的区别

==

基本数据类型：

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

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

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

对象是放在堆中的，栈中存放的是对象的引用（地址）。由此可见’==’是对栈中的值进行比较的。如果要比较堆中对象的内容是否相同，那么就要重写equals方法了

private static String TAG = "NKEqualsTest";
public static void equals1(){
int a1 = 11;
int a2 = 11;

Integer b1 = new Integer(11);
Integer b2 = new Integer(11);
Integer b3 = new Integer(127);

Integer c1 = 127;
Integer c2 = 127;

Integer d1 = 128;
Integer d2 = 128;

Log.e(TAG, "a1 == a2 : " + (a1 == a2)); //比较常量类型的时候，就比较数值
Log.e(TAG, "b1 == b2 : " + (b1 == b2)); //Integer是一个对象，比较包装类型（类，数组等）的时候，比较的是对象的地址
Log.e(TAG, "a1 == b1 : " + (a1 == b1)); //通过new的方式产生的Integer会自动拆箱为int，所以为true
Log.e(TAG, "b3 == c1 : " + (b3 == c1)); //对象的地址不同，所以结果为false
Log.e(TAG, "c1 == c2 : " + (c1 == c2)); //看下方解析
Log.e(TAG, "d1 == d2 : " + (d1 == d2));

String s1 = "str";
String s2 = "str";
String str1 = new String("str");
String str2 = new String("str");

Log.e(TAG, "s1==s2:" + (s1 == s2));      //比较的两个都是资本类型，所以相等
Log.e(TAG, "s1==str1:" + (s1 == str1));  //String不是自动拆箱，所以是不同
Log.e(TAG, "str1==str2:" + (str1 == str2)); //不同的对象
}

比较结果如下：

a1 == a2 : true
b1 == b2 : false
a1 == b1 : true
b3 == c1 : false

c1 == c2 : true
d1 == d2 : false

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

解析

为什么c1 == c2 为：true

为什么d1 == d2为: false

首先要了解一下：

Integer c1 = 127的编译过程。java在编译这句代码的时候，其实就是相当于：

Integer c1 = Integer.valueOf(127)；以下是Integer.valueOf（）的源码：

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

IntegerCache.low = -128;

IntegerCache.high = 127;

也就是说：

* -128到127的数值会被缓存在IntegerCache中的，取出来的时候，都是在IntegerCache中读取的。所以c1 == c2 为ture

* 不是-128到127的数值，都是通过new Integer（）得到的，所以的d1 == d2为false

* Equals*

Java8的API解释

equals方法在非空对象引用上实现等价关系：

自反性 ：对于任何非空的参考值x ， x.equals(x)应该返回true 。

对称性 ：对于任何非空引用值x和y ， x.equals(y)应该返回true当且仅当y.equals(x)回报true 。

传递性 ：对于任何非空引用值x ， y和z ，如果x.equals(y)回报true个y.equals(z)回报true ，然后x.equals(z)应该返回true 。

一致性 ：对于任何非空引用值x和y ，多次调用x.equals(y)始终返回true或始终返回false ，没有设置中使用的信息equals比较上的对象被修改。对于任何非空的参考值x ， x.equals(null)应该返回false 。该equals类方法Object实现对象上差别可能性最大的相等关系; 也就是说，对于任何非空的参考值x和y ，当且仅当x和y引用相同的对象（ x == y具有值true ）时，该方法返回true 。

请注意，无论何时覆盖该方法，通常需要覆盖hashCode方法，以便维护hashCode方法的通用合同，该方法规定相等的对象必须具有相等的哈希码。

[b]1. 默认情况（没有重写equals方法）[/b]

默认情况下，没有重写equals方法的就是调用Object中的equlas方法，Object的equlas方法源码如下：

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

也就是Object中的equals（）方法中是通过 == 来比较的，而 == 中对于包装类型的比较，是比较其对象的地址是否相等，也就是是否引用了同一个对象。

[b]2. 重写equals方法[/b]

那么就要根据具体的代码来确定equals方法的作用了，重写后一般都是通过对象的内容是否相等来判断对象是否相等。下面是String类对equals进行了重写:

public boolean equals(Object anObject) {
//如果== 是true，说明两个equals一定是相同
if (this == anObject) {
return true;
}
//查看是否是字符串类型，否则返回false
if (anObject instanceof String) {
String anotherString = (String) anObject;
int n = length();
//比较两个字符串长度是否相等,否者返回false
if (n == anotherString.length()) {
int i = 0;
//在这里去比较字符串中的每一个字符是否相等
while (n-- != 0) {
//一旦发现有一个字符串不同，则直接返回false
if (charAt(i) != anotherString.charAt(i))
return false;
i++;
}
return true;
}
}
return false;
}

从上面的String的equals（）中看到String 比较的是两个字符串的内容是否相等，因为String重写了Object中的equals（）方法

hasCode方法

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方法的源码，是怎样得到hashCode的

public int hashCode() {
return identityHashCode(this);
}

static int identityHashCode(Object obj) {
int lockWord = obj.shadow$_monitor_;
final int lockWordStateMask = 0xC0000000;  // Top 2 bits.
final int lockWordStateHash = 0x80000000;  // Top 2 bits are value 2 (kStateHash).
final int lockWordHashMask = 0x0FFFFFFF;  // Low 28 bits.
if ((lockWord & lockWordStateMask) == lockWordStateHash) {
return lockWord & lockWordHashMask;
}
return identityHashCodeNative(obj);
}

//最终是调用了底层的函数去生成hashCode
@FastNative
private static native int identityHashCodeNative(Object obj);

[b]hashCode的作用[/b]

想要明白，必须要先知道Java中的集合。　　

总的来说，Java中的集合（Collection）有两类，一类是List，再有一类是Set。前者集合内的元素是有序的，元素可以重复；后者元素无序，但元素不可重复。

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

这就是Object.equals方法了。但是，如果每增加一个元素就检查一次，那么当元素很多时，后添加到集合中的元素比较的次数就非常多了。也就是说，如果集合中现在已经有1000个元素，那么第1001个元素加入集合时，它就要调用1000次equals方法。这显然会大大降低效率。

于是，Java采用了哈希表的原理。

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

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

如果这个位置上没有元素，它就可以直接存储在这个位置上，不用再进行任何比较了；

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

equalse()和hasCode()的关系

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

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

如果a.equals(b)，则一定有a.hashCode() 一定等于 b.hashCode()。

如果!a.equals(b)，则a.hashCode() 不一定不等于 b.hashCode()。此时如果a.hashCode() 总是不等于 b.hashCode()，会提高hashtables的性能。

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

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

上面结论简记：

1、如果两个对象equals，Java运行时环境会认为他们的hashcode一定相等。

2、如果两个对象不equals，他们的hashcode有可能相等。

3、如果两个对象hashcode相等，他们不一定equals。

4、如果两个对象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方法，则不一定要产生相同的整数结果。但是程序员应该知道，给不相等的对象产生截然不同的整数结果，有可能提高散列表的性能。

总结

1、equals方法用于比较对象的内容是否相等（覆盖以后）

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

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

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