一文详解java中的==和equals()
目录
一、"=="运算符
二、"equals()"方法
三、举例说明和解释
3.1、例子
3.2、基本数据类型的比较
3.3、引用数据类型的比较
3.3.1 String类
3.3.2 未重写equals方法的类
四、为什么重写equals方法就一定要重写hashCode方法
4.1 为什么要重写equals方法
4.2 hashCode
4.3 为什么equas和hashCode要一起重写？
4.3.1 Set集合正常使用
4.3.2 Set集合的"异常"使用
4.4 原因分析
4.5 总结
五、练手举例
"=="和equals 最大的区别是
1."=="是运算符，如果是基本数据类型，则比较存储的值；如果是引用数据类型，则比较所指向对象的地址值。
2.equals是Object的方法，比较的是所指向的对象的地址值，一般情况下，重写之后比较的是对象的值。
一、"=="运算符
1.如果比较的对象是基本数据类型，则比较的是其存储的值是否相等;
2.如果比较的是引用数据类型，则比较的是所指向对象的地址值是否相等(是否是同一个对象)。
二、"equals()"方法
equals是Object的方法，用来比较两个对象的地址值是否相等。
方法如下:
public boolean equals(Object obj) {
return (this == obj);
}
注意：
equals 方法不能用于比较基本数据类型，如果没有对 equals 方法进行重写，则相当于“==”，比较的是引用类型的变
量所指向的对象的地址值。
一般情况下，类会重写equals方法用来比较两个对象的内容是否相等。比如String类中的equals()是被重写了，比较的是对象的值。
三、举例说明和解释
3.1、例子
public static void main(String[] args) {
//基本数据类型的比较
int num1 = 10;
int num2 = 10;
System.out.println(num1 == num2); //true//引用数据类型的比较
//String类（重写了equals方法）中==与equals的比较
String s1 = "hello";
String s2 = "hello";
System.out.println(s1 == s2); //true，比较地址值：内容相同，因为常量池中只有一个“hello”，所以它们的地址值相同
System.out.println(s1.equals(s2));//true，比较内容：内容相同，因为常量池中只有一个“hello”，所以它们的地址值相同
System.out.println(s1.equals("hello")); //true
String s3 = new String("hello");
String s4 = new String("hello");
System.out.println(s3 == s4); //false,比较地址值：s3和s4在堆内存中的地址值不同
System.out.println(s3.equals(s4)); //true，比较内容：内容相同//没有重写equals方法的类中==与equals的比较
People p1 = new People();
People p2 = new People();
People p = p2;
System.out.println(p1);//People@135fbaa4
System.out.println(p2);//People@45ee12a7
System.out.println(p); //People@45ee12a7
System.out.println(p1.equals(p2)); //false，p1和p2的地址值不同
System.out.println(p.equals(p2)); //true，p和p2的地址值相同
}
3.2、基本数据类型的比较
"=="正常比较其值。equals不用于基本数据类型的比较。
3.3、引用数据类型的比较
3.3.1 String类
String类对equals()方法进行了重写。
1.创建字符串对象一般有如下两种写法:
String s1 = "hello";//在字符串常量池中创建"hello"，并将地址值赋值给s1。
String s2 = new String("world");//通过new关键字在堆中创建对象，并将对象地址值赋值给s2。
• 对于String s2 = new String(“world”);
首先在堆内存中申请内存存储String类型的对象，将地址值赋给s2；
在方法区的常量池中找，有无hello：
若没有，则在常量池中开辟空间存储hello，并将该空间的地址值赋给堆中存储对象的空间；
若有，则直接将hello所在空间的地址值给堆中存储对象的空间。
• 对于String s1 = “hello”;
在方法区的常量池中找，有无hello，如果没有，就在常量池中开辟空间存储hello。
然后只需要将hello所在空间的地址值赋给 s1。
字符串作为最基础的数据类型，使用非常频繁，如果每次都通过 new 关键字进行创建，会耗费高昂的时间和空间代价。Java 虚拟机为了提高性能和减少内存开销，就设计了字符串常量池. 在JDK1.7之前字符串常量池是存储在方法区的。JDK1.7之后存储在堆中了。
2.String类对equals的重写如下：
public boolean equals(Object anObject) {
if (this == anObject) {
return true;
}
if (anObject instanceof String) {
String anotherString = (String)anObject;
int n = value.length;
if (n == anotherString.value.length) {
char v1[] = value;
char v2[] = anotherString.value;
int i = 0;
while (n-- != 0) {
if (v1[i] != v2[i])
return false;
i++;
}
return true;
}
}
return false;
}
代码解释
• 若当前对象和比较的对象是同一个对象，即return true。也就是Object中的equals方法。
• 若当前传入的对象是String类型，则比较两个字符串的长度，即value.length的长度。
• 若长度不相同，则return false。
• 若长度相同，则按照数组value中的每一位进行比较。若不同，则返回false。若每一位都相同，则返回true。
• 若当前传入的对象不是String类型，则直接返回false。
• 此外StringBuffer和StringBuilder并没有重写equals方法，其比较的还是引用类型的地址。
3.3.2 未重写equals方法的类
如果类没有重写equals方法，其比较的还是引用类型的地址。
四、为什么重写equals方法就一定要重写hashCode方法
先放结论：
hashCode 和 equals 两个方法是用来协同判断两个对象是否相等的，采用这种方式的原因是可以提高程序插入和查询的速度。
如果只重写equals方法，不重写hashCode方法，就有可能导致a.equals(b)这个表达式成立，但是hashCode却不同。会造成一个完全相同的对象会存储在hash表的不同位置。
4.1 为什么要重写equals方法
Object 类中的 equals 方法用于检测一个对象是否等于另外一个对象。在 Object 类中，这个方法将判断两个对象是否具有相同的引用。如果两个对象具有相同的引用，它们一定是相等的。大多数情况下不重写equals方法，直接使用Object中的equals方法是没有任何意义的，不如直接使用==运算符，二者是等价的。
以下代码示例，就可以说明这个问题：
package com.hulei.studyproject.blogtest;
import lombok.Getter;
/**
* @Title: EqualsMyClassExample
* @Description: TODO
* @author: hulei
* @date: 2023/8/4 13:52
* @Version: 1.0
*/
public class EqualsMyClassExample {
public static void main(String[] args) {
Person u1 = new Person();
u1.setName("Java");
u1.setAge(18);
Person u2 = new Person();
u2.setName("Java");
u2.setAge(18);
System.out.println(u1.equals(u2));
}
}
@Getter
class Person{
private String name;
private int age;
public void setName(String name) {
this.name = name;
}
public void setAge(int age) {
this.age = age;
}
}
输出结果如下图所示：
可以看到两个不同的引用，不重写equals，直接调用Object类中的原始equals方法，比较结果一定是false，这种比较没有意义，因为内存地址不同，即使两个对象的内容完全相同，因此通常情况下，我们要判断两个对象是否相等，一定要重写 equals 方法，这就是为什么要重写 equals 方法的原因。
4.2 hashCode
hashCode 翻译为中文是散列码，它是由对象推导出的一个整型值，并且这个值为任意整数，包括正数或负数。
需要注意的是：散列码是没有规律的。
• 如果 x 和 y 是两个不同的对象，x.hashCode() 与 y.hashCode() 基本上不会相同；但是也有例外
• 但如果 a 和 b 相等，则 a.hashCode() 一定等于 b.hashCode()。
hashCode使用
package com.hulei.studyproject.blogtest;
/**
* @Title: EqualsMyClassExample
* @Description: TODO
* @author: hulei
* @date: 2023/8/4 13:52
* @Version: 1.0
*/
public class EqualsMyClassExample {
public static void main(String[] args) {
String s1 = "Hello";
String s2 = "Hello";
String s3 = "Java";
System.out.println("s1 hashCode" + s1.hashCode());
System.out.println("s2 hashCode" + s2.hashCode());
System.out.println("s3 hashCode" + s3.hashCode());
// 在一些特殊情况下是相同的
String t1 = "Aa";
String t2 = "BB";
System.out.println("t1 hashCode" + t1.hashCode());
System.out.println("t2 hashCode" + t2.hashCode());
}
}
结果如下:
在java中，equals和hashcode是有设计要求的，equals相等，则hashcode一定相等，反之则不然。 为何会有这样的要求？ 在集合中，比如HashSet中，要求放入的对象不能重复，怎么判定呢？ 首先会调用hashode，如果hashcode相等，则继续调用equals。
4.3 为什么equas和hashCode要一起重写？
下面看几个示例:
4.3.1 Set集合正常使用
package com.hulei.studyproject.blogtest;
import java.util.HashSet;
import java.util.Set;
/**
* @Title: EqualsMyClassExample
* @Description: TODO
* @author: hulei
* @date: 2023/8/4 13:52
* @Version: 1.0
*/
public class EqualsMyClassExample {
public static void main(String[] args) {
Set set = new HashSet();
set.add("Java");
set.add("Java");
set.add("MySQL");
set.add("MySQL");
set.add("Redis");
System.out.println("Set 集合长度:" + set.size());
System.out.println();
// 打印 Set 中的所有元素
set.forEach(System.out::println);
}
}
执行结果如下：
从上述结果可以看出，重复的数据已经被 Set 集合"合并"了，这也是 Set 集合最大的特点：去重。
4.3.2 Set集合的"异常"使用
只重写equals方法
package com.hulei.studyproject.blogtest;
import lombok.Getter;
import java.util.HashSet;
import java.util.Objects;
import java.util.Set;
/**
* @Title: EqualsMyClassExample
* @Description: TODO
* @author: hulei
* @date: 2023/8/4 13:52
* @Version: 1.0
*/
public class EqualsMyClassExample {
public static void main(String[] args) {
Person u1 = new Person();
u1.setName("Java");
u1.setAge(18);
Person u2 = new Person();
u2.setName("Java");
u2.setAge(18);
System.out.println("equals result = " + u1.equals(u2));
// 创建 Set 集合
Set set = new HashSet<>();
set.add(u1);
set.add(u2);
// 打印 Set 中的所有数据
set.forEach(System.out::println);
}
}
@Getter
class Person{
private String name;
private int age;
public void setName(String name) {
this.name = name;
}
public void setAge(int age) {
this.age = age;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Person person = (Person) o;
return age == person.age && Objects.equals(name,person.name);
}
/*@Override
public int hashCode() {
int result = name != null ? name.hashCode() : 0;
result = 31 * result + age;
return result;
}*/
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
执行结果如下所示:
这就造成了equals比较结果明明是相同值，为什么Set却重复存储呢？
再放开代码中重写的hashCode方法注释，执行结果如下所示:
此时可以看到Set集合进行了去重。
4.4 原因分析
默认情况下，Set 进行去重操作时，会先判断两个对象的 hashCode 是否相同，此时因为没有重写 hashCode 方法，所以会直接执行 Object 中的 hashCode 方法，而 Object 中的 hashCode 方法对比的是两个不同引用地址的对象，所以结果是 false，那么 equals 方法就不用执行了，直接返回的结果就是 false：两个对象不是相等的，于是就在 Set 集合中插入了两个相同的对象。
但是，如果在重写 equals 方法时，也重写了 hashCode 方法，那么在执行判断时会去执行重写的 hashCode 方法，此时对比的是两个对象的所有属性的 hashCode 是否相同，于是调用 hashCode 返回的结果就是 true，再去调用 equals 方法，发现两个对象确实是相等的，于是就返回 true 了，因此 Set 集合就不会存储两个一模一样的数据了，于是整个程序的执行就正常了。
4.5 总结
• hashCode 和 equals 两个方法是用来协同判断两个对象是否相等的，采用这种方式的原因是可以提高程序插入和查询的速度。
• 如果只重写equals方法，不重写hashCode方法，就有可能导致a.equals(b)这个表达式成立，但是hashCode却不同。会造成一个完全相同的对象会存储在hash表的不同位置。
五、练手举例
1.下面的代码将创建几个字符串对象？3个
String s1 = new String(“Hello”);
String s2 = new String(“Hello”);分别创建了s1堆内存上的实例，s2内存上的实例，以及字符串常量池
2.在java中，String s=new String(“xyz”)创建了几个对象？C
A 1个 B 1个或2个 C 2个 D 以上都不对
3.下面的代码输出什么？
String s1 = new String(“abc”);
String s2 = new String(“abc”);
System.out.println(s1 == s2);//false
System.out.println(s1.equals(s2)); // true
4.下面的代码输入什么？
String s1 = "abc";
String s2 = new String("abc");//可以拿到s2的常量
s2.intern();
System.out.println(s1 ==s2);//false
5.下面的代码输出什么？
String s1= "abc";
String s2= "abc";
String s3 = new String("abc");
String s4 = new String("abc");System.out.println("s3 == s4 : "+(s3==s4)); //false
System.out.println("s3.equals(s4) : "+(s3.equals(s4))); //true
System.out.println("s1 == s3 : "+(s1==s3)); //false
System.out.println("s1.equals(s3) : "+(s1.equals(s3))); //true
System.out.println(s1==s2); //true
6.下面的代码输出什么？
String str1 = “ab” + “cd”;
String str11 = “abcd”;
System.out.println("str1 = str11 : "+ (str1 == str11)); //true
7.下面的代码输出什么？
String str2 = “ab”;
String str3 = “cd”;
String str4 = str2+str3;
String str5 = “abcd”;
System.out.println("str4 = str5 : " + (str4==str5));//false!
8.下面的代码输出什么？
final String str2 = “ab”;
final String str3 = “cd”;
String str4 = str2+str3;
String str5 = “abcd”;
System.out.println("str4 = str5 : " + (str4==str5));//true
9.下面的代码输入什么？
String str6 = “b”;
String str7 = “a” + str6;
String str67 = “ab”;
System.out.println("str7 = str67 : "+ (str7 == str67)); //false
10.下面的代码输入什么？
final String str8 = “b”;
String str9 = “a” + str8;
String str89 = “ab”;
System.out.println("str9 = str89 : "+ (str9 == str89)); //true
11.下面选项结果为true的是：C
String s1="Hello";
String s2="hello";
String s3=s1.toLowerCase();
String s4=s2.toLowerCase();A.S1==s3
B.S2==s3
C.S2==s4
D.S3==s4