几个例子说明JAVA中的equals和==区别

女爷i 2022-07-13 08:58 96阅读 0赞

先说一下java的数据类型：

可以分为基础数据类型和引用类型。引用类型一般是用户自定义的类型如People,或是java自带的引用类型如String等等。

包装类型可以看作是基本数据类型的引用类型。Java为每一个基本数据类型提供了一个封装类，除了int（Integer）和char（Character）其余类型首字母大写即成封装类的类型名。如double (Double), float(Float),long(Long), short(Short),byte(Byte),boolean(Boolean).

以int和Integer为例，Java中int和Integer区别是：

int是基本的数据类型,默认值可以为0；

Integer是int的封装类,默认值为null；

int和Integer都可以表示某一个数值；

int和Integer不能够互用，因为他们是两种不同的数据类型。

\--------------------------

JAVA的API文档，Object类的equals方法是这样描述的：

对于任何非空引用值 x 和 y，当且仅当 x 和 y 引用同一个**对象**时，此方法才返回 true，也就是说比较的是对象x和y在内存中的区域是否一致,如果不是同一块区域则返回false.

其他类怎么使用equals和==呢？

基本类型的==比的是值,而不是对象，判断二者的内容是否相同。引用类型的==比较的是对象(内存地址)。

在JAVA的API里的大部分类(例如Integer、String)都重写了equals方法，重写后的equals就不是比较对象了,而是比较值(内容)。

没有重写equals()的类一般是我们自定义的类。如果想比较自定义类的对象，那么使用equals和使用==是一样的,都是比较句柄地址，因为自定义的类都默认继承于Object,而Object中的equals就是用==来实现的。

示例代码如下：

public class EqualsComparation \{

public static void main(String\[\] args) \{  
comparation01();  
comparation02();  
\}  
  
public static void comparation01() \{  
byte b1 = 4, b2 = 4; char c1 =  '你', c2 = '你'; double d1 = 4.0, d2 = 4.0; long lg1=100, lg2=200; boolean b3=true, b4=true;  
if (b1==b2)\{  
System.out.println( "==比较俩基本型：byte型的值相同");\}  
if (c1==c2)\{  
System.out.println( "==比较俩基本型：char型的值相同");\}  
if(d1==d2)\{  
System.out.println( "==比较俩基本型：double型的值相同");\}  
if(b3 == b4)\{  
System.out.println( "==比较俩基本型：boolean型的值相同");\}  
if(lg1 != lg2)\{  
System.out.println( "==比较俩基本型：两个long型的值不同!");\}  
  
String s1= "写作业呢", s2= "写作业呢"; // 位于方法区中的常量池，常量就意味着只有一个对象  
String s5=new String(), s6=new String(), s7=s6;  
if(s1 == s2)\{  
System.out.println( "String引用型s1==s2比较俩对象地址的结果：是同一个对象(常量)");\}  
  
Integer itg3=new Integer( "10"), itg4=new Integer( "10") ;  
if(itg3 != itg4)\{  
System.out.println( "==结果: 引用型itg3=new Integer(10)和itg4=new Integer(10)不是同一个对象(堆内存地址)!");\}  
if (itg3.equals(itg4))\{  
System.out.println( "Integer引用类型的itg3.equals(itg4)比较的是值：结果为true");\}  
  
if(s5.equals(s6))\{  
System.out.println( "String型重写了equals(), 比较俩值结果：是相同的");\}  
if(s6 == s7)\{  
System.out.println( "String引用型s6=new String(), s7=s6，==比较的结果：是同一个对象");\}  
\}  
  
public static void comparation02()\{  
int a1=1; int a2=1;  
Integer b1 =new Integer (1); Integer b2 =new Integer (1);  
 // 基本型的==比较的是值而不是对象  
System.out.println("int a1=1; int a2=1; a1==a2：\\t"+(a1==a2));  
 // 比的是对象(内存地址)  
System.out.println("Integer b1 =new Integer (1); Integer b2 =new Integer (1); b1==b2：\\t"+(b1==b2));  
 // 俩对象地址不同 。但是Integer已重写equals, 比较的是内容:相同  
System.out.println("Integer b1 =new Integer (1); Integer b2 =new Integer (1); bi.equals(b2)：\\t"+ (b1.equals(b2)));  
\}  
\}

运行结果：

==比较俩基本型：byte型的值相同  
==比较俩基本型：char型的值相同  
==比较俩基本型：double型的值相同  
==比较俩基本型：boolean型的值相同  
==比较俩基本型：两个long型的值不同!  
String引用型s1==s2比较俩对象地址的结果：是同一个对象(常量)  
==结果: 引用型itg3=new Integer(10)和itg4=new Integer(10)不是同一个对象(堆内存地址)!  
Integer引用类型的itg3.equals(itg4)比较的是值：结果为true  
String型重写了equals(), 比较俩值结果：是相同的  
String引用型s6=new String(), s7=s6，==比较的结果：是同一个对象  
int a1=1; int a2=1; a1==a2： true  
Integer b1 =new Integer (1); Integer b2 =new Integer (1); b1==b2： false  
Integer b1 =new Integer (1); Integer b2 =new Integer (1); bi.equals(b2)： true