1. equals 方法

• == 和 equals 的对比【面试题】
• == 是一个比较运算符

1. ==：既可以判断基本类型，又可以判断引用类型
2. ==：如果判断的是基本类型，判断的是值是否相等。示例: int i=10; double d=10.0;
3. ==：如果判断的是引用类型，判断的是地址是否相等，即判定是不是同一个对象【案例说明】

public class Equals01 {
    public static void main(String[] args) {
        A a = new A();
        A b = a;
        A c = b;
        System.out.println(a == c);//true
        System.out.println(b == c);//true
        B bObj = a; //指向同一个对象
        System.out.println(bObj == c);//true
    }
}

class B{}

class A extends B{}

1. equals: 是Object类中的方法，只能判断引用类型。
2. Object 默认判断的是地址是否相等，子类中往往重写该方法，用于判断内容是否相等。比如

lnteger,String【看看String和 Integer的equals源代码】

• Object 类中的 equals 方法

//Object 的equals方法默认就是比较对象的地址是否相同,也就是判断两个对象是不是同一个对象
public boolean equals(Object obj) { 
    return (this == obj);
}

• String 类中的 equals 方法

// String 类中把 Object 的 equals 方法重写了，变成了比较两个字符串的值是否相同
public boolean equals (Object anObject){
   if (this == anObject) {//如果是同一个对象
       return true;//返回true
   }
   if (anObject instanceof String) {//判断类型
       String anotherString = (String) anObject;
       int n = value.length;
       if (n == anotherString.value.length) {//如果长度相等
           char v1[] = value;
           char v2[] = anotherString.value;
           int i = 0;
           while (n-- != 0) {//然后一个一个比较字符
               if (v1[i] != v2[i])
                   return false;
               i++;
           }
           return true;//如果两个字符串的所有字符都相等，返回true
       }
   }
   return false;//如果比较的不是字符串，直接返回 false
}

• Integer 类中的 equals 方法

//从源码中可以看到 Integer 也重写了 equals 方法
//变成了判断两个值是否相等
public boolean equals(Object obj) {
    if (obj instanceof Integer) {
        return value == ((Integer)obj).intValue();
    }
    return false;
}

2. 测试案例

• 测试 Integer 类型

    Integer integer1 = new Integer(1000);
    Integer integer2 = new Integer(1000);
    System.out.println(integer1 == integer2);
    System.out.println(integer1.equals(integer2));

• 测试 String 类型

    String str1 = new String("xdr");
    String str2 = new String("xdr");
    System.out.println(str1 == str2);
    System.out.println(str1.equals(str2));

3. 如何重写 equals 方法

• 应用实例: 判断两个 Person 对象的内容是否相等，如果两个 Person 对象的各个属性值都一样，则返回 true，反之 false。

public class EqualsExercise01 {
    public static void main(String[] args) {
        Person person1 = new Person("jack",10,'男');
        Person person2 = new Person("jack",10,'男');

        System.out.println(person1.equals(person2));//false
    }
}

class Person{
    private String name;
    private int age;
    private char gender;

    //重写 Object 的 equals 方法
    public boolean equals(Object obj) {
        //判断如果比较的两个对象是同一个对象，则直接返回 true
        if (this == obj){
            return true;
        }
        //类型判断
        if (obj instanceof Person){//是Person才作比较
            //进行 向下转型,因为需要得到obj的各个属性
            Person p = (Person) obj;
            return this.name.equals(p.name) && this.age == p.age && this.gender == p.gender;
        }
        //如果不是 Person ，则直接返回 false
        return false;
    }

    public Person(String name, int age, char gender) {
        this.name = name;
        this.age = age;
        this.gender = gender;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public char getGender() {
        return gender;
    }

    public void setGender(char gender) {
        this.gender = gender;
    }
}

4. 练习题

• 判断1
• 因为 p1.name 是字符串，所以已经把 equals 方法重写了，所以比较的是内容，所以

p1.name.equals(p2.name)为 true

public class EqualsExercise02 {
    public static void main(String[] args) {
        Person p1 = new Person();
        Person p2 = new Person();
        p1.name = "xdr";
        p2.name = "xdr";

        System.out.println(p1 == p2);//false
        System.out.println(p1.name.equals(p2.name));//true
        System.out.println(p1.equals(p2));//false

        String s1 = new String("asdf");
        String s2 = new String("asdf");
        System.out.println(s1.equals(s2));//true
        System.out.println(s1 == s2);//false
    }
}

class Person{
    public String name;

}

• 判断2

public class EqualsExercise03 {
    public static void main(String[] args) {
        int it = 65;
        float f1 = 65.0f;
        System.out.println("65和65.0f是否相等?" +(it == f1));

        char ch1 = 'A';
        char ch2 = 12;
        System.out.println("65和'A'是否相等 ?" + (it == ch1));
        System.out.println("12和ch2是否相等?" +(12 == ch2));

        String str1 = new String(" hello");
        String str2 = new String("hello");
        System.out.println("str1和str2是否相等?" + (str1 == str2));
        System.out.println("str1是否equals str2? " + (str1.equals(str2)));


    }
}

5. 小节

1. ==：

• 既可以判断基本类型，又可以判断引用类型。
• 如果是基本类型，判断的是值是否相等。

如: int i=10; double d=10.0;

• 如果判断的是引用类型，判断的是地址是否相等，即判定是不是同一个对象。【上面有举例】

1. equals：

• equals是Object类中的方法，只能判断引用类型。
• Object 默认判断的是地址是否相等，子类中往往重写该方法，用于判断内容是否相等。

比如：lnteger，String。【上面有举例】