equals&&==详解和区别以及对equals方法的重写

== 是一个比较运算符

1. 既可以判断基本类型，又可以判断引用类型
2. 如果判断基本类型，则判断值是否相等
3. 如果判断引用类型，则判断地址是否相等，即判断是不是同一个对象

equals方法

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

Obejct类的equals

Object的equals方法默认就是比较对象的地址是否相同，也就是判断两个对象是不是同一个对象

public boolean equals(Object obj) {
    
    
    return (this == obj);
}

String类的equals

重写了Object的equals的方法，比较两个字符串的值是否相等

public boolean equals(Object anObject) {
    
    
        if (this == anObject) {
    
      // 如果是同一个对象,==在引用类型中比较的是地址是否相等
            return true;
        }
        if (anObject instanceof String) {
    
      // 判断类型
            String anotherString = (String)anObject;  // 向下转型
            int n = value.length;
            if (n == anotherString.value.length) {
    
       // 如果长度相同
                char v1[] = value;   // 注意这里的value在定义字符串的时候，构造方法已经将字符串值赋值给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
    }

Interger类的equals

从源码上可以看到Integer也重写了Object的equals方法，变成判断两个值是否相等

public boolean equals(Object obj) {
    
    
    if (obj instanceof Integer) {
    
      // 是同一个类型
        return value == ((Integer)obj).intValue();  // 值判断
    }
    return false;
}

测试案例

public class Equals {
    
    
    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

        int num1 = 10;
        double num2 = 10.0;
        System.out.println(num1==num2);  // true

        "hello".equals("abc");

        Integer integer2 = 128;
        Integer integer22 = 128;
        boolean b1 = integer2 == integer22;
        System.out.println("integer2==integer22:"+b1); // true 这是因为在java的缓存机制中，[-128,127]的Intger会指向同一个地方

        Integer integer1 = new Integer(1000);
        Integer integer11 = new Integer(1000);

        System.out.println(integer1==integer1);  // false  比较的是两个Integer对象的地址是否相等

        System.out.println(integer11.equals(integer1));  // Integer重写了equals方法比较值是否相等

        String xs = new String("xs");
        String xs1 = new String("xs");

        System.out.println(xs == xs1);   // false 比较的是两个对象的地址是否相等
        System.out.println(xs.equals(xs1));  // false  比较的是地址是否相等
    }
}