【搞定Java基础】第8篇：Java 中的 == 、equals 、hashCode 的区别与联系

本文转发自：Java 中的 ==, equals 与 hashCode 的区别与联系

本文目录：

一、概述

二、关系操作符 ==

三、equals 方法

四、hashCode 方法

五、小结

这里再推荐阅读另外一篇文章：重写equal()时为什么也得重写hashCode()之深度解读equal方法与hashCode方法渊源

---

一、概述

1、概念

1、== ： 该操作符生成的是一个boolean结果，它计算的是操作数的值之间的关系；

2、equals ： Object 的 实例方法，比较两个对象的 content（属性） 是否相同；

3、hashCode ： Object 的 native 方法 , 获取对象的哈希值，用于确定该对象在哈希表中的索引位置，它实际上是一个 int 型整数。

---

二、关系操作符 ==

1、操作数的值

• 基本数据类型变量

在 Java 中有八种基本数据类型：

浮点型：float(4 byte)、double(8 byte)

整型：byte(1 byte)、short(2 byte)、int(4 byte) 、long(8 byte)

字符型: char(2 byte)

布尔型: boolean(JVM 规范没有明确规定其所占的空间大小，仅规定其只能够取字面值 ”true” 和 ”false”)

对于这八种基本数据类型的变量，变量直接存储的是“值”。因此，在使用关系操作符 == 来进行比较时，比较的就是“值”本身。要注意的是，浮点型和整型都是有符号类型的（最高位仅用于表示正负，不参与计算【以 byte 为例，其范围为 -2^7 ~ 2^7 - 1，-0 即 -128】），而 char 是无符号类型的（所有位均参与计算，所以 char 类型取值范围为 0 ~ 2^16-1）。

• 引用类型变量 

在 Java 中，引用类型的变量存储的并不是“值”本身，而是与其关联的对象在内存中的地址。比如下面这行代码，

String str1;

这句话声明了一个引用类型的变量，此时它并没有和任何对象关联。 而通过 new 来产生一个对象，并将这个对象和 str1 进行绑定：

str1 = new String("hello");

那么 str1 就指向了这个对象，此时引用变量 str1 中存储的是它指向的对象在内存中的存储地址，并不是“值”本身，也就是说并不是直接存储的字符串”hello”。这里面的引用和 C/C++ 中的指针很类似。

2、小结

因此，对于关系操作符 ==：

1、若操作数的类型是基本数据类型，则该关系操作符判断的是左右两边操作数的值是否相等

2、若操作数的类型是引用数据类型，则该关系操作符判断的是左右两边操作数的内存地址是否相同。也就是说，若此时返回 true，则该操作符作用的一定是同一个对象。

---

三、equals 方法

1、来源 

equals 方法是基类Object中的实例方法，因此对所有继承于Object的类都会有该方法。 在 Object 中的声明：

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

2、equals 方法的作用 

初衷 ： 判断两个对象的 content 是否相同。

为了更直观地理解 equals 方法的作用，我们先看 Object 类中 equals 方法的实现：

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

很显然，在Object类中，equals方法是用来比较两个对象的引用是否相等，即是否指向同一个对象。

但我们都知道，下面代码输出为 true：

public class Main {
    public static void main(String[] args) {
        String str1 = new String("hello");
        String str2 = new String("hello");

        System.out.println(str1.equals(str2));
    }
}

原来是 String 类重写了 equals 方法：

// 方法签名与 Object类 中的一致
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;
}

即对于诸如“字符串比较时用的什么方法，内部如何实习？”之类问题的回答即为：

使用 equals 方法，内部实现分为三个步骤：

1、先比较引用是否相同（是否为同一对象）；

2、再判断类型是否一致（是否为同一类型）；

3、最后比较内容是否一致；

Java 中所有内置的类的 equals 方法的实现步骤均是如此，特别是诸如 Integer，Double 等包装器类。

3、equals 重写原则

对象内容的比较才是设计 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(y)返回是“true”，那么y.equals(x)也应该返回是“true”。

任何情况下，x.equals(null)【应使用关系比较符 ==】，永远返回是“false”；x.equals(和x不同类型的对象)永远返回是“false”

4、小结 

因此，对于 equals 方法：

其本意是：比较两个对象的 content 是否相同。必要的时候，我们需要重写该方法，避免违背本意，且要遵循上述原则。

---

四、hashCode 方法

1、hashCode 的来源 

hashCode 方法是基类 Object 中的实例 native 方法，因此对所有继承于 Object 的类都会有该方法。 

在 Object类 中的声明（native 方法暗示这些方法是有实现体的，但并不提供实现体，因为其实现体是由非 Java 语言在外面实现的）：

public native int hashCode();

2、哈希相关概念 

我们首先来了解一下哈希表：

概念 ： Hash 就是把任意长度的输入(又叫做预映射， pre-image)，通过散列算法，变换成固定长度的输出(int)，该输出就是散列值。这种转换是一种 压缩映射，也就是说，散列值的空间通常远小于输入的空间。不同的输入可能会散列成相同的输出，从而不可能从散列值来唯一的确定输入值。简单的说，就是一种将任意长度的消息压缩到某一固定长度的消息摘要的函数。

应用–数据结构 ： 数组的特点是：寻址容易，插入和删除困难; 而链表的特点是：寻址困难，插入和删除容易。那么我们能不能综合两者的特性，做出一种寻址容易，插入和删除也容易的数据结构？答案是肯定的，这就是我们要提起的哈希表，哈希表有多种不同的实现方法，我接下来解释的是最常用的一种方法——拉链法，我们可以理解为 “链表的数组”，如图：

哈希表示例

左边很明显是个数组，数组的每个成员是一个链表。该数据结构所容纳的所有元素均包含一个指针，用于元素间的链接。我们根据元素的自身特征把元素分配到不同的链表中去，也是根据这些特征，找到正确的链表，再从链表中找出这个元素。其中，将根据元素特征计算元素数组下标的方法就是散列法。

拉链法的适用范围 ： 快速查找，删除的基本数据结构，通常需要总数据量可以放入内存。

• 要点 ： 

hash 函数选择，针对字符串，整数，排列，具体相应的 hash 方法； 

碰撞处理，一种是 open hashing，也称为拉链法，另一种就是closed hashing，也称开地址法，opened addressing。

3、hashCode 简述 

在 Java 中，由 Object 类定义的 hashCode 方法会针对不同的对象返回不同的整数。（这是通过将该对象的内部地址转换成一个整数来实现的，但是 JavaTM 编程语言不需要这种实现技巧）。

• hashCode 的常规协定是：

1、在 Java 应用程序执行期间，在对同一对象多次调用 hashCode 方法时，必须一致地返回相同的整数，前提是将对象进行 equals 比较时所用的信息没有被修改。从某一应用程序的一次执行到同一应用程序的另一次执行，该整数无需保持一致。

2、如果根据 equals(Object) 方法，两个对象是相等的，那么对这两个对象中的每个对象调用 hashCode 方法都必须生成相同的整数结果。

3、如果根据 equals(java.lang.Object) 方法，两 个对象不相等，那么对这两个对象中的任一对象上调用 hashCode 方法 不要求 一定生成不同的整数结果。但是，程序员应该意识到，为不相等的对象生成不同整数结果可以提高哈希表的性能。 

要想进一步了解 hashCode 的作用，我们必须先要了解 Java 中的容器，因为 HashCode 只是在需要用到哈希算法的数据结构中才有用，比如 HashSet, HashMap 和 Hashtable。

Java中的集合（Collection）有三类，一类是 List，一类是 Queue，再有一类就是 Set。 前两个集合内的元素是有序的，元素可以重复；最后一个集合内的元素无序，但元素不可重复。

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

这就是 Object.equals 方法了。但是，如果每增加一个元素就检查一次，那么当元素很多时，后添加到集合中的元素比较的次数就非常多了。 也就是说，如果集合中现在已经有1000个元素，那么第1001个元素加入集合时，它就要调用1000次equals方法。这显然会大大降低效率。于是，Java采用了哈希表的原理。 这样，我们对每个要存入集合的元素使用哈希算法算出一个值，然后根据该值计算出元素应该在数组的位置。所以，当集合要添加新的元素时，可分为两个步骤： 

1、先调用这个元素的 hashCode 方法，然后根据所得到的值计算出元素应该在数组的位置。如果这个位置上没有元素，那么直接将它存储在这个位置上；

2、如果这个位置上已经有元素了，那么调用它的 equals 方法与新元素进行比较：key 相同的话就更新 value，否则，将其存在这个位置对应的链表中（Java 中 HashSet, HashMap 和 Hashtable的实现总将元素放到链表的表头）。

4、equals 与 hashCode

前提： 谈到 hashCode 就不得不说 equals 方法，二者均是 Object 类里的方法。由于 Object 类是所有类的基类，所以一切类里都可以重写这两个方法。

原则 1 ： 如果 x.equals(y) 返回 “true”，那么 x 和 y 的 hashCode() 必须相等 ；

原则 2 ： 如果 x.equals(y) 返回 “false”，那么 x 和 y 的 hashCode() 有可能相等，也有可能不等 ；

原则 3 ： 如果 x 和 y 的 hashCode() 不相等，那么 x.equals(y) 一定返回 “false” ；

原则 4 ： 一般来讲，equals 这个方法是给用户调用的，而 hashcode 方法一般用户不会去调用 ；

原则 5 ： 当一个对象类型作为集合对象的元素时，那么这个对象应该拥有自己的 equals() 和 hashCode() 设计，而且要遵守前面所说的几个原则。

5、实现例证

hashCode() 在 Object 类中定义如下：

public native int hashCode();

说明是一个本地方法，它的实现是根据本地机器相关的。

String 类是这样重写它的：

public final class Stringimplements java.io.Serializable, Comparable<String>, CharSequence{
	
	// 用来保存字符串中字符的数组
	private final char value[];          // 成员变量1

	// 第一个字符下标
	private final int offset;            // 成员变量2

	// 该字符串中字符的个数
	private final int count;             // 成员变量3

	// 该字符串哈希值的缓存
	private int hash;                    // 非成员变量

	public int hashCode() {
	int h = hash;
		int len = count;                 // 用到成员变量3
	if (h == 0 && len > 0) {
		int off = offset;                // 用到成员变量2
		char val[] = value;              // 用到成员变量1
			for (int i = 0; i < len; i++) {
				h = 31 * h + val[off++];       // 递推公式
			}
			hash = h;
		}
		return h;
	}
}

对程序的解释：h = s[0]*31^(n-1) + s[1] * 31^(n-2) + ... + s[n-1]，由此可以看出，对象的 hash 地址不一定是实际的内存地址。

---

五、小结

1、hashCode 是系统用来快速检索对象而使用。

2、equals 方法本意是用来判断引用的对象是否一致。

3、重写 equals 方法和 hashCode 方法时，equals 方法中用到的成员变量也必定会在 hashCode 方法中用到，只不过前者作为比较项，后者作为生成摘要的信息项，本质上所用到的数据是一样的，从而保证二者的一致性。