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

转载文章  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();
 }
}