Java中==和equals的区别联系

朴灿烈づ我的快乐病毒、 2022-03-19 10:49 264阅读 0赞

==和equals的区别联系  
1、“==”运算符  
（1）比较基本数据类型变量  
当两个基本数据类型的操作元通过“==”运算符比较是否相等时，比较的是这两个操作元的值是否相等，如果相等结果为True，否则为False，在比较时不考虑操作元的数据类型。  
例如：  
Java代码  
int i = 98;  
int j = -98;  
float f = 98.0f;  
System.out.println(i==j); //输出结果：false  
System.out.println(i==f); //输出结果：true  
System.out.println(i=='b'); //输出结果：true  
System.out.println(j==-'b'); //输出结果：true  
（2）比较引用类型变量  
当两个引用类型的变量通过“==”运算符比较是否相等时，比较的是这两个变量是否引用同一个对象，如果是结果为True，否则为False。  
例如：  
Java代码  
Integer num1 = new Integer(100); //创建一个Integer对象，并通过num1变量进行引用  
Integer num2 = new Integer(100);//创建另一个Integer对象，并通过num2变量进行引用  
System.out.println(num1==num2);//输出结果：false  
System.out.println(num1!=num2);//输出结果：true  
Integer num1 = new Integer(100); //创建一个Integer对象，并通过num1变量进行引用Integer num2 = new Integer(100);//创建另一个Integer对象，并通过num2变量进行引用代码中虽然变量num1与num2引用的Integer对象的值都为100，但它们却是两个不同的对象，因此表达式“num1==num2”进行比较的结果为False。  
下面将以上的代码进行修改：  
Java代码  
Integer num1 = new Integer(100);  
Integer num2 = new Integer(100);  
num1 = num2; //将num2引用的对象赋值给num1,使得这两个变量引用同一个对象  
System.out.println(num1==num2); //输出结果：true  
System.out.println(num1!=num2); //输出结果：false  
Integer num1 = new Integer(100);Integer num2 = new Integer(100);num1 = num2; //将num2引用的对象赋值给num1,使得这两个变量引用同一个对象

下面通过“==”运算符向读者介绍Java包装类的自动装箱与拆箱的相关知识。先来看下面的代码：  
Java代码  
Integer num1 = 280;//将自动进行280转换为Integer对象的装箱操作  
Integer num2 = 280;//将自动进行280转换为Integer对象的装箱操作  
System.out.println(num1==num2);//输出结果：false  
Integer num1 = 280;//将自动进行280转换为Integer对象的装箱操作

代码中的变量num1与num2分别引用了两个对象，根据“==”运算符的比较规则，只有两个变量引用的是同一个对象时，比较的结果才为True，因此结果为False是正确的。  
下面将代码进行如下修改：  
Java代码  
Integer num1 = 80;//将自动进行80转换为Integer对象的装箱操作  
Integer num2 = 80;//将自动进行80转换为Integer对象的装箱操作  
System.out.println(num1==num2);//输出结果：true  
这两段代码几乎是一样的，只不过改动了后者的数值，返回的结果却是True，这是因为Java包装类在进行自动装箱及拆箱时隐藏了一些细节上的操作。  
Java在执行包装类的自动装箱功能时，对于-128~127之间的整数（包括-128与127）被装箱为Integer对象后，该对象会被另一个对该整数进行自动装箱的操作重复使用，即多次对同一个-128~127范围内的整数进行Integer装箱的操作，使用的都是第一次进行装箱操作时生成的对象，因此在进行“==”比较时，返回的结果是True。如果对超出这个范围内的整数进行装箱操作，那么对该整数的每次的Integer装箱操作都会生成一个新的Integer对象，因此在进行“==”比较时，比较的是不同的对象，返回的结果为False。  
应用“==”运算符进行比较的两个引用类型的变量，其被显式声明的类型必须相同或者具有继承关系，否则编译会出错。  
例如：存在A、B、C3个类，B、C类都继承自类A。变量myA被显式声明为A类型，变量myB被显式声明为B类型，变量myC被显式声明为C类型，变量D被显式声明为A类型但引用了类B的对象，变量myE被显式声明为A类型但与变量myB引用了同一个对象。  
Java代码  
A myA = new A();//变量myA被显式声明为A类型  
B myB = new B();//变量myB被显式声明为B类型  
C myC = new C();//变量myC被显式声明为C类型  
A myD = new B();//变量D被显式声明为A类型但引用了类B的对象  
A myE = myB;//变量myE被显式声明为A类型但与变量myB引用了同一个对象  
System.out.println(myA==myB);//输出结果：false  
System.out.println(myA==myD);//输出结果：false  
System.out.println(myC==myD);//输出结果：false  
System.out.println(myB==myD);//输出结果：false  
System.out.println(myB==myE);//输出结果：true  
如果在上述代码中加入如下代码来输出变量myB与变量myC的比较结果，则编译出错。  
Java代码  
System.out.println(myB==myC);//编译出错  
System.out.println(myB==myC);//编译出错

因为变量myB与变量myC分别引用的是类B与类C的对象，而类B与类C的类型不同，并且没有继承关系，所以不能通过“==”运算符进行比较运算。  
数组引用类型间也可以通过“==”运算符进行比较，例如：  
Java代码  
float f1\[\] = \{1.1F,2.2F,3.3F\};  
float f2\[\] = \{1.1F,2.2F,3.3F\};  
float f2\[\] = null;  
double d\[\] = \{1.1,2.2,3.3\};  
System.out.println(f1==d);//编译出错，类型不同  
System.out.println(f1==f2);//编译成功，结果为false  
System.out.println(f3==f1);// 编译成功，结果为false  
f3 = f1;  
System.out.println(f3==f1);// 编译成功，结果为true  
2、equals()方法  
通常，Java中的类都继承自java.lang.Object类，在Object类中定义了一个equals()方法，其源代码如下：  
Java代码  
public boolean equals(Object obj)\{  
return (this == obj);  
\}  
public boolean equals(Object obj)\{ return (this == obj);\}

根据源代码可知，equals()方法的比较规则实际上就是“==”运算符的比较，当参数obj引用的对象与当前对象（即调用equals()方法的对象）为同一个对象时，返回True值，否则返回False值。  
例如：  
Java代码  
A objA1 = new A();  
A objA2 = new A();  
A objA3 = objA1; //变量objA3与变量objA1引用同一个对象  
System.out.println(objA1==objA2); //输出结果：false  
System.out.println(objA1.equals(objA2)); //输出结果：false  
System.out.println(objA1==objA3); //输出结果：true  
System.out.println(objA1.equals(objA3)); //输出结果：true  
在JDK中提供的一些类重写了Object类中的equals()方法，重新定制了比较规则，如果两个对象的类型一致，并且内容相同（不能同时为null），则返回True。这些类包括包装类、String和java.util.Data等。  
下面给出Integer包装类中equals()方法的源代码：  
Java代码  
public boolean equals(Object obj)\{  
if(obj instanceof Integer)\{//判断obj引用的对象是否为Integer类的实例  
return value == ((Integer)obj).inValue();//判断obj引用的对象是否与当前对象的内容相同  
\}  
return false;  
\}  
public boolean equals(Object obj)\{ if(obj instanceof Integer)\{//判断obj引用的对象是否为Integer类的实例 return value == ((Integer)obj).inValue();//判断obj引用的对象是否与当前对象的内容相同\}return false;\}

其中，instanceof用来判断一个引用变量所引用的对象是否为一个类的实例。  
例如：变量num1与num2分别引用了两个不同的Integer对象，但它们的内容都是100，因此使用“==”运算符进行比较的结果为False，使用equals()方法进行比较的结果为True；变量date1与date2分别引用了两个不同的java.util.Data类对象，但它们的内容都是当前系统时间，因此结果同上。  
Java代码  
Integer num1 = new Integer(100);  
Integer num2 = new Integer(100);  
Date date1 = new Date(); //创建一个Date()对象，值为系统当前时间  
Date date2 = new Date(); //创建另一个Date()对象，值为系统当前时间  
System.out.println(num1==num2); //输出结果：false  
System.out.println(num1.equals(num2)); //输出结果：true  
System.out.println(date1==date2); //输出结果：false  
System.out.println(date1.equals(date2)); //输出结果：true  
在比较字符串是否相等时，为了能够正确得到预期的运行结果，应该采用equals()方法进行比较。  
例如：  
Java代码  
String name = "liqiong";  
if(name=="liqiong")  
System.out.println("登陆成功！");  
else  
System.out.println("登陆失败！");  
String name = "liqiong";if(name=="liqiong") System.out.println("登陆成功！");else System.out.println("登陆失败！");

运行结果如下：  
登陆成功！  
虽然上述代码的运行结果与预期的相同，但如果将代码中的第一行进行修改：  
Java代码  
String name = new String("liqiong");  
String name = new String("liqiong");

则得到如下结果：  
登陆失败！  
在实际编程中，变量name的值很可能是通过参数传递的，并且该参数可能是一个String型的字面常量或者是String型对象，因此通过“==”进行比较时会得到两种结果，需要应用equals()方法来比较字符串是否相等。

在自定义的类中也可以重写Object类中的equals()方法，重新定制比较规则。例如创建了一个Student类用来封装学生信息，其中包含一个String型的number属性，该属性存储学生学号。如果想定义两个Student类对象的number属性内容相同，则表示这两个对象存储的是同一个学生的信息的比较规则，通过equals()方法实现时，就可进行如下定义：  
Java代码  
public class Student\{  
private String number;  
public Student(String number)\{  
this.number = number;  
\}  
public boolean equals(Object obj)\{  
if(this == obj)\{  
return true;  
\}  
if(obj instanceof Student)\{  
if((this.number).equals(((Student)obj).number))  
return true;  
\}  
return false;  
\}  
\}  
然后通过构造方法创建两个Student类对象，它们的number属性都被赋值为字符串“1001”，并分别通过变量st1与st2引用这两个对象，则应用equals()方法比较这两个对象的结果为True。  
Java代码  
Student st1 = new Student("1001");  
Student st2 = new Student("1001");  
System.out.println(st1==st2); //输出结果：false  
System.out.println(st1.equals(st2)); //输出结果：true