java中的==操作符和equals函数

基本规则

“==”操作符的使用需要分成两种情况

• 判值类型相等

1. 这一点很好理解，两个值类型代表的数值相等，则“==”表达式返回true
2. “==”可以用与不同值类型的比较，语言会自动进行类型转换

• 判引用类型相等

1. 对于引用类型，“==”比较的是引用地址。对于两个相同类型的引用变量来说，如果他们指向同一个对象，则“==”返回true；如果指向不同的对象，即使对象的内容相等，“==”也会返回false
2. "=="不能用在不同类型的引用类型上，编译报错，但两个类型之间有继承关系时可以（子类和父类在“==”两边的位置可以互换）

　　

equals方法在Object中定义，可以被重载

• 没有重载的情况下和“==”的行为相同
• 重载的情况下要看equals的具体实现
• equals源码如下

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

举一个小栗子

Person定义如下，需要注意的是重写了equals方法，这点很重要！！！

public class Person {
    private String name;
    private int age;

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

    public int getAge() {
        return age;
    }

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

    public String getName() {
        return name;
    }

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

    @Override
    public boolean equals(Object obj) {
        if (this == obj) {
            return true;
        }
        if (obj == null || getClass() != obj.getClass()){
            return false;
        }

        Person persion = (Person) obj;

        if (age != persion.age || !name.equals(persion.name)){
            return false;
        }
        return true;
    }

    @Override
    public int hashCode() {
        int result = name != null ? name.hashCode() : 0;
        result = 31 * result + age;
        return result;
    }
}

　　测试代码如下：

        Person persion1 = new Person("foo",18);
        Person persion2 = new Person("foo",18);

        System.out.println( persion1 == persion2 );
        System.out.println( persion1.equals(persion2));

　　运行结果如下，可以看到虽然persion1和persion2的各字段均相等，但由于两个变量引用的对象在堆上的地址不同，persion1 == persion2会返回false；由于重载了equals函数，所以persion1.equals(persion2)返回true

false
true　　

关于String

　　String类重载了equals方法，进行了逐字符比较，且该方法的重载方式可以当做标准的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;
                char v2[] = anotherString.value;
                int i = 0;
                while (n-- != 0) {
                    if (v1[i] != v2[i])
                            return false;
                    i++;
                }
                return true;
            }
        }
        return false;
    }

　　重载函数的实现：

1. 比较两个对象的引用地址是否相同，相同则马上返回true
2. 比较两个对象的类型是否相等，如果不相等则返回false
3. 比较两个对象的具体字段是否相等，只要不想等则马上返回false

　　tips：

        String str1 = new String("123");
        String str2 = new String("123");

        System.out.println(str1==str2);
        System.out.println(str1.equals(str2));

        String str3 = "123";
        String str4 = "123";

        System.out.println(str3==str4);
        System.out.println(str3.equals(str4));

　　 　　System.out.println(str2==str3);

　　运行结果是

　　false

　　true

　　true

　　true

　　false

　　原因：

　　对于 String str3 = "123"; 这种写法，虚拟机会将字面量字符串“123”存储到String pool中，再次使用相同的字面量字符串时，会直接将该字符串的地址付给 str4，所以str3==str4会返回true。

　　对于String str1 = new String("123");这种写法，每次都会在堆上创建一个新对象，不论对象内容是否相等，地址总是不一样的 所以str1==str2会返回false

　　

结论：

• 对于值类型：

　　　　“==”比较数值是否相等，值类型没有equals方法

• 对于引用类型：

1. 如果该类型没有重载equals方法，则“==”和“equals”方法返回的结果一致，即比较两个变量引用的地址是否相等
2. 如果重载了equals方法，则equals方法的行为需要看重载方法的具体定义，“==”依然比较的是两个变量的引用地址

• 如果则“==”返回true则equals应该也会返回true（正确实现了equals），反之则不一定

题外话

　　java中没有运算符重载机制，唯一的例外是String类的“+”操作符，且该操作符已经由语言本身实现。

　　C#中“==”和equals的行为要比java复杂很多，转向java后忽然有种幸福感