==和equals()区别(操作符==与对象equals方法的不同)

来源：互联网发布：qqiphone6s在线软件编辑：程序博客网时间：2024/06/06 00:19

转载文章 http://xinxinyin666.i.sohu.com/blog/view/220894999.htm

1、操作符“==”
用来比较两个操作元是否相等，这两个操作元既可以是基本类型，也可以是引用类型。
实例1：
public class Demo01 {
public static void f1() {
int a1 = 1, a2 = 3;
boolean b1 = a1 == a2; // "=="的操作元为基本类型，b1变量值为false
System.out.println(b1);
String str1 = "Hello", str2 = "World";
boolean b2 = str1 == str2; // "=="的操作元为引用类型，b2变量值为false
System.out.println(b2);

String str3 = "Hello", str4 = "Hello";
boolean b3 = str3 == str4; // "=="的操作元为引用类型，b3变量值为true
System.out.println(b3);
}

//当操作符“==”两边都是引用类型时，这两个引用变量必须都引用同一个对象，结果才为true。
public static void f2() {
Integer int1 = new Integer(1);
Integer int2 = new Integer(1);
Integer int3 = int1; // int3和int1引用同一个对象
int[] array1 = new int[1];
int[] array2 = new int[1];
int[] array3 = array1; // array3和array1引用同一个对象
System.out.println("int1==int2 is " + (int1 == int2));//false
System.out.println("int1==int3 is " + (int1 == int3));//true
System.out.println("array1==array2 is " + (array1 == array2));//false
System.out.println("array1==array3 is " + (array1 == array3));//true
}
//主函数
public static void main(String[] args) {
System.out.println("-----------f1()-----------");
Demo01.f1();
System.out.println("-----------f2()-----------");
Demo01.f2();
}
}

2、操作符“==”与多态性
a、对于引用类型变量，Java编译器根据变量被显式声明的类型去编译。当“==”用于比较引用类型变量时，“==”两边的变量被显式声明的类型必须是同种类型或有继承关系，即位于继承树的同一个继承分支上，否则编译出错。
b、在运行时，Java 虚拟机将根据两边的引用变量实际引用的对象进行比较。
假设有4个类--Creature、Animal、Dog和Cat类，它们的继承关系如图所示：

实例2：
public class Demo02 {
public static void f1() {
Dog dog = new Dog(); // dog变量被声明为Dog类型
Creature creature = dog; // 变量creature和dog引用同一个Dog对象
Animal animal = new Cat(); // animal 变量被声明为 Animal 类型
System.out.println(dog == animal); // 合法，打印false
System.out.println(dog == creature);// 合法，打印true
}
public static void f2() {
//这里变量dog被声明为Dog类型，变量cat被声明为Cat类型，Dog类和Cat类之间没有继承关系，因此这两个变量不能用“==”比较。
B dog = new B();
C cat = new C();
// System.out.println(dog == cat);// 编译出错
}
//主函数
public static void main(String[] args) {
Demo02.f1();
}
}
**************************************************
class Creature {
}
class Animal extends Creature {
}
class Dog extends Animal {
}
class Cat extends Animal {
}
**************************************************

3、操作符“==”用于数组类型
数组类型也是引用类型，可以用“==”进行比较
实例3：
public class Demo01 {
public static void f1() {
// boolean b1 = new int[4] == new long[5];//编译出错，两边类型不一致
boolean b2 = new int[4] == new int[4];// 合法，b2的值为false
System.out.println(b2);
int[] array1 = new int[4];
int[] array2 = array1;
boolean b3 = array1 == array2; // 合法，b3的值为true
System.out.println(b3);
}
//主函数
public static void main(String[] args) {
Demo01.f1();
}
}

4、在用户自定义的类中也可以覆盖Object类的equals()方法，重新定义比较规则。
实例5：
public class Demo01 {
private String name;
public Demo01(String name) {
this.name = name;
}
public boolean equals(Object o) {
//默认定义的equals方法
if (this == o) {
return true;
}
//重新定义equals()方法
final Demo01 other = (Demo01) o;
if (this.name.equals(other.name)) {
return true;
} else {
return false;
}
}
//主函数
public static void main(String[] args) {
Demo01 p1 = new Demo01("Tom");
Demo01 p2 = new Demo01("Tom");
System.out.println(p1 == p2); // 打印 false
System.out.println(p1.equals(p2)); // 打印 true
}
}

5、equals() 方法
equals() 方法是在 Object 类中定义的方法，它的声明格式如下：
public boolean equals(Object obj)
(1) Object 类的 equals() 方法的比较规则为：当参数 obj 引用的对象与当前对象为同一个对象时，就返回true，否则返回false。
(2) 在JDK中有一些类覆盖了 Object 类的equal()方法，它们的比较规则为：如果两个对象的类型一致，并且内容一致，则返回true。
这些类包括：java.io.File、java.util.Date、java.lang.String、包装类(如java.lang.Integer和java.lang.Double类)。
(3) Boolean 类是包装类，只要两个Boolean对象的布尔值内容一样，equals()方法的比较结果就为true。
(4) b1和obj1被声明为不同的类型，但它们实际引用的是同一个Dog对象，因此用“==”或equals()方法比较的结果都为true。
(5) Float 和 Double 类型是包装类型，只要两个 Float 对象或两个 Double对象的内容一样，equals()方法比较的结果就为true。
(6) 变量a和b引用不同的String对象，但它们包含的内容都是“helle”，所以a.equals(b)的结果为true；而变量c是字符串数组类型，因此a.equals(c)的结果为false。

实例(1):
public class Demo01 {
//Object 类的 equals() 方法的比较规则为：当参数 obj 引用的对象与当前对象为同一个对象时，就返回true，否则返回false。
public boolean equals(Object obj) {
if (this == obj) {
return true;
} else {
return false;
}
}
public static void f1() {
//类B和类C均集成A
A a1 = new B();
A a2 = new C();
A a3 = a1;
//a1和a2变量引用不同的对象，因此用“==”或 equals() 方法比较的结果都为 false
System.out.println(a1 == a2); // 打印false
System.out.println(a1.equals(a2)); // 打印false
//a1和a3变量都引用同一个Dog对象，因此用“==”或equals()方法比较的结果都为true；
System.out.println(a1 == a3); // 打印true
System.out.println(a1.equals(a3)); // 打印true
}
//主函数
public static void main(String[] args) {
Demo01.f1();
}
}
实例(2):
public class Demo01 {
//在JDK中有一些类覆盖了 Object 类的equal()方法，它们的比较规则为：如果两个对象的类型一致，并且内容一致，则返回true。
public static void f2() {
Integer int1 = new Integer(1);
Integer int2 = new Integer(1);
String str1 = new String("Hello");
String str2 = new String("Hello");
System.out.println(int1 == int2); // 打印false
System.out.println(int1.equals(int2)); // 打印true
System.out.println(str1 == str2); // 打印false
System.out.println(str1.equals(str2)); // 打印true
}
//主函数
public static void main(String[] args) {
Demo01.f2();
}
}

实例(3):
public class Demo01 {
//Boolean 类是包装类，只要两个Boolean对象的布尔值内容一样，equals()方法的比较结果就为true。
public static void f3() {
Boolean b1 = new Boolean(true);
Boolean b2 = new Boolean(true);
//b1==b2 false 和b1.equals(b2) true
if (b1 == b2) {
if (b1.equals(b2)) {
System.out.println("a");
} else {
System.out.println("b");
}
} else {
if (b1.equals(b2)) {
System.out.println("c"); // 执行这段代码
} else {
System.out.println("d");
}
}
}
//主函数
public static void main(String[] args) {
Demo01.f3();
}
}

实例(4):
public class Demo01 {
//b1和obj1被声明为不同的类型，但它们实际引用的是同一个对象，因此用“==”或equals()方法比较的结果都为true。
public static void f4() {
Boolean b1 = new Boolean(true);
Object obj1 = (Object) b1;
//b1 == obj1 true 和 b1.equals(obj1) true
if (b1 == obj1) {
if (b1.equals(obj1)) {
System.out.println("a"); // 执行这段代码
} else {
System.out.println("b");
}
} else {
if (b1.equals(obj1)) {
System.out.println("c");
} else {
System.out.println("d");
}
}
}
//主函数
public static void main(String[] args) {
Demo01.f4();
}
}

实例(5):
public class Demo01 {
//Float 和 Double 类型是包装类型，只要两个 Float 对象或两个 Double对象的内容一样，equals()方法比较的结果就为true。
public static void f5() {
Float f1 = new Float("10F");
Float f2 = new Float("10F");
Double d1 = new Double("10D");
System.out.println(f1 == f2); // 打印false
System.out.println(f1.equals(f2)); // 打印true
System.out.println(f1.equals(d1)); // 打印false,因为f2和d1不是相同类型
System.out.println(f1.equals(new Float("10"))); // 打印true
}
//主函数
public static void main(String[] args) {
Demo01.f5();
}
}

实例(6):
public class Demo01 {
//变量a和b引用不同的String对象，但它们包含的内容都是“helle”，所以a.equals(b)的结果为true；而变量c是字符串数组类型，因此a.equals(c)的结果为false。
public static void f6() {
String a = "hello";
String b = new String(a);
char[] c = { 'h', 'e', 'l', 'l', 'o' };
//变量a和b引用不同的String对象
System.out.println(a == "hello"); // 打印true
System.out.println(a == b); // 打印false
System.out.println(a.equals(b)); // 打印true
System.out.println(a.equals(c)); // 打印false
}
//主函数
public static void main(String[] args) {
Demo01.f6();
}
}