`
supportopensource
  • 浏览: 521961 次
  • 性别: Icon_minigender_1
  • 来自: 杭州
社区版块
存档分类
最新评论

==运算符与equals()方法

阅读更多
1、“==”运算符
(1)比较基本数据类型变量
当两个基本数据类型的操作元通过“==”运算符比较是否相等时,比较的是这两个操作元的值是否相等,如果相等结果为True,否则为False,在比较时不考虑操作元的数据类型。
例如:
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。
例如:
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

代码中虽然变量num1与num2引用的Integer对象的值都为100,但它们却是两个不同的对象,因此表达式“num1==num2”进行比较的结果为False。
下面将以上的代码进行修改:
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

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

代码中的变量num1与num2分别引用了两个对象,根据“==”运算符的比较规则,只有两个变量引用的是同一个对象时,比较的结果才为True,因此结果为False是正确的。
下面将代码进行如下修改:
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引用了同一个对象。
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的比较结果,则编译出错。
System.out.println(myB==myC);//编译出错

因为变量myB与变量myC分别引用的是类B与类C的对象,而类B与类C的类型不同,并且没有继承关系,所以不能通过“==”运算符进行比较运算。
数组引用类型间也可以通过“==”运算符进行比较,例如:
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()方法,其源代码如下:
public boolean equals(Object obj){
	return (this == obj);
}

根据源代码可知,equals()方法的比较规则实际上就是“==”运算符的比较,当参数obj引用的对象与当前对象(即调用equals()方法的对象)为同一个对象时,返回True值,否则返回False值。
例如:
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()方法的源代码:
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类对象,但它们的内容都是当前系统时间,因此结果同上。
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()方法进行比较。
例如:
String name = "liqiong";
if(name=="liqiong")
		System.out.println("登陆成功!");
else
		System.out.println("登陆失败!");

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

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

在自定义的类中也可以重写Object类中的equals()方法,重新定制比较规则。例如创建了一个Student类用来封装学生信息,其中包含一个String型的number属性,该属性存储学生学号。如果想定义两个Student类对象的number属性内容相同,则表示这两个对象存储的是同一个学生的信息的比较规则,通过equals()方法实现时,就可进行如下定义:
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。
Student st1 = new Student("1001");
Student st2 = new Student("1001");
System.out.println(st1==st2);       //输出结果:false
System.out.println(st1.equals(st2));  //输出结果:true

分享到:
评论

相关推荐

    ==运算符和Equals()方法区别

    "运算符和Equals()方法区别" 在C#语言中,`==`运算符和`Equals()`方法都是用来比较两个对象是否相等,但是它们之间存在着很大的区别。 对于值类型来说,`==`运算符和`Equals()`方法的行为是一致的,都会比较两个...

    Java中==运算符与equals方法的区别及intern方法详解

    "Java中==运算符与equals方法的区别及intern方法详解" Java中==运算符与equals方法的区别是Java程序设计语言中的一個非常重要的概念,它們兩者都是用來比较字符串是否相等,但是它们的比较方式完全不同。 ==运算符...

    ==与equals的比较

    在Java中,`==`运算符和`equals`方法有着不同的比较方式。`==`运算符比较引用地址,而`equals`方法比较对象的实际内容。在比较对象的实际内容时,应该使用`equals`方法,而不是`==`运算符。 此外,还需要注意的是,...

    C#中的==运算符

    在String类型中,==运算符执行的结果与Equals方法的结果是一样的。这是因为,String类型提供了==运算符的重载。 下面是一个简单的示例代码: ```csharp class Program { static void Main(string[] args) { ...

    java中的比较运算符== 与 equals()方法 ..doc

    ### Java中的比较运算符==与equals()方法 在Java编程语言中,经常需要对变量进行比较,这涉及到了两种常见的比较方式:`==`运算符和`equals()`方法。这两种方式有着本质的区别,并且适用于不同类型的数据。下面将...

    ==和equals的比较

    对于值类型,`==` 运算符和 `equals` 方法都是比较值的大小,而对于引用类型,`==` 运算符比较的是引用是否相同,而 `equals` 方法比较的是值是否相同。 例如: ```csharp int a = 5; int b = 5; bool result1 = a...

    Java中的==和equals区别

    在Java编程中,比较对象的相等性是一个常见的需求,但很多初学者对于`==`运算符与`equals`方法的区别容易混淆。本文将深入探讨两者之间的差异,以及它们在不同场景下的应用。 #### `==` 运算符 `==`运算符主要用于...

    equals(Object) 与 == 的区别

    因此,如果我们没有覆盖 equals(Object) 方法,那么它的行为与 == 运算符相同。 但是,equals(Object) 方法的特殊之处在于它可以被覆盖。这意味着,我们可以通过覆盖 equals(Object) 方法来让它比较两个对象的内容...

    知识点 比较运算符==和equals方法的比较

    默认情况下,`equals()`方法的行为与`==`相同,即比较对象的引用。但是,许多类(如String、Integer等)重写了`equals()`方法,使其能够比较对象的值。例如,在String类中,`equals()`方法会比较两个字符串的字符...

    ==和equals方法究竟有什么区别

    在Java编程语言中,`==`和`equals()`方法是用来比较对象之间关系的两种常见方式,但它们在使用上有着显著的区别。 首先,`==`运算符主要用于比较基本类型(如int、char、byte等)的值是否相等,或者比较引用类型...

    字符串比较之 “==”和 “equals”

    此外,String类还有一个与"equals()"相关的静态方法"compareTo()",它基于Unicode值对字符串进行字典顺序比较。如果两个字符串完全相等,"compareTo()"将返回0;如果第一个字符串小于第二个,返回负数;如果大于,则...

    详解java==运算符和equals()方法的区别

    Java编程语言中有两种主要的方法来比较对象的平等性:`==`运算符和`equals()`方法。理解这两者的区别对于编写正确和可靠的代码至关重要。 1. `==`运算符: `==`运算符主要用于比较基本类型(如int、char等)的值,...

    String中==与equals区别验证

    在Java编程语言中,`==` 运算符与 `equals()` 方法被广泛用于比较对象,尤其是当处理字符串(`String` 类)时。这两者之间的区别是理解Java内存管理和对象引用的关键。以下是对给定代码片段中所展示概念的详细解析。...

    Java常见笔试、面试题目深度剖析 相等性(==及equals方法)详解

    本篇文章将深入剖析“==”运算符和equals()方法的区别与联系,帮助你在Java的笔试和面试中更好地应对相关问题。 首先,“==”运算符在Java中用于比较基本类型变量的值是否相等,例如int、char或boolean。对于引用...

    C#程序设计-3期(KC008) KC008110100003-错误的认为==和Equals作用相同.docx

    在C#编程语言中,`==`运算符和`Equals`方法经常被用来比较对象的相等性,但它们在工作原理和使用场景上存在显著差异。错误地将两者混为一谈可能导致程序逻辑出错,因此理解它们的区别至关重要。 首先,`Equals`方法...

    java 资料 equals 与== 的区别

    Java 中的equals和==的区别 Java 是一种面向对象的编程语言,其中有两种数据类型:基本数据类型和引用数据类型。基本数据类型包括整数...在编写 Java 代码时,需要根据具体情况选择使用 == 运算符或 equals 方法。

    java中"==" 与equals方法的使用

    默认的equals()方法行为与"=="相同,即比较对象的引用。但是,对于许多类,如String、Integer等,equals()已被重写以比较对象的实际内容。在上述的IntegerDemo示例中,`Integer i1 = 127;` 和 `Integer i2 = 127;` ...

    java中equals和==的区别.doc

    Java 中的 equals 和 == 是两个不同的运算符,它们之间的区别是非常重要的。 首先,我们需要了解 Java 中的内存模型。在 Java 中,变量可以分为两种:基本类型(primitive type)和引用类型(reference type)。...

    C#中重载相等(==)运算符示例

    为了解决这个问题,我们需要避免在`==`运算符中直接比较`null`,而是使用`object`的`Equals`方法来判断引用是否相等: ```csharp public static bool operator ==(A a, A b) { if (ReferenceEquals(a, b)) { ...

Global site tag (gtag.js) - Google Analytics