==运算符与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