详解Java中的equals()和==

1. 先来讲一讲equals()

很多类中都有自己的equals()方法，但他们其实都是覆写的java.lang.Object类中的equals()方法。
因为Java中所有的类都是继承于java.lang.Object这个类的，而equals()方法是定义在java.lang.Object这个类中的，定义描述如下：

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

即，这个方法的作用是比较其他的对象与这个对象是否“equals”。同时，要求在重写这个方法时必须重写hashCode()方法（不明白的同学可以看我之前写的java.lang.Object源码阅读笔记）

我们要明白Java给我们这个方法是为了什么

其实是交给开发者自己去覆写这个方法，自己去定义什么才是“equals”

比如，在String这个类中就覆写了equals()方法，当然，同时也必须覆写了hashCode()（详见java.lang.String源码阅读笔记）

摘取其中的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;
    }

String类为什么要重新该方法呢？因为String类想重新定义什么是“equals”！

在String类重写该方法后，该方法的作用发生了变化。
在String中这个方法的作用变成了比较两个字符串是否相同。
同样的，在其他很多类中的equals()方法一般也都有着自己对”equals”的定义

2. 接下来讲讲equals()和==

先看一段代码

    public static void main(String[] args) {
        String str0 = "abc";
        String str = "abcTest";
        String new_str1 = str0 + "Test";
        String new_str2 = "abc" + "Test";
        System.out.println(str.equals(new_str1));
        System.out.println(str.equals(new_str2));
    }

输出结果：

true
true

我们调用的是String类中的equals()，结果是可以理解的，因为字符串str与new_str1、new_str2的内容是一样的，说明equals()完成了字符串的比较的任务

如果我们把它改成==呢？

    public static void main(String[] args) {
        String str0 = "abc";
        String str = "abcTest";
        String new_str1 = str0 + "Test";
        String new_str2 = "abc" + "Test";
        System.out.println(str==new_str1);
        System.out.println(str==new_str2);
    }

输出结果：

false
true

可以看到，str和new_str2无论是用equals()还是用== 比较结果都是true
这是因为在JDK1.6之后，常量字符串的“+”操作，编译阶段直接会合成为一个字符串，所以用“+”连接两个字符串常量，和直接放入这两个字符串的和是一样的。

但是，为什么比较str和new_str1时，用equals()和==输出结果是不一样的呢？

我们看一下反编译的结果：

    public static void main(String args[])
    {
        String str0 = "abc";
        String str = "abcTest";
        String new_str1 = (new StringBuilder()).append(str0).append("Test").toString();
        String new_str2 = "abcTest";
        System.out.println(str == new_str1);
        System.out.println(str == new_str2);
    }

摘出来new_str1看一下

        String new_str1 = (new StringBuilder()).append(str0).append("Test").toString();

我们发现，源码中String new_str1 = str0 + "Test";的操作，实际上是创建了一个新的StringBuilder对象，并调用了其append和toString方法，而 new_str1实际上是引用了这个新的对象。

因此，用==判断时，结果为false，同时这也侧面说明了，==判断的是两个对象的引用是否为同一个，或者说是比较的是对象在内存中的地址

比如：有这么一个类

public class Dog {
    private String name;
    private String sex;
    private String owner;

    public Dog() {
        name = "qiuqiu";
        sex = "male";
        owner = "Amanda";
    }

    public Dog(String name, String sex, String owner) {
        this.name = name;
        this.sex = sex;
        this.owner = owner;
    }
}

这么使用

    public static void main(String[] args) {
        Dog dog1 = new Dog();
        Dog dog2 = new Dog("Henry", "male", "Jack");
        Dog dog3 = dog1;
        Dog dog4 = new Dog();
        System.out.println("dog1 == dog2: " + (dog1 == dog2));//#1
        System.out.println("dog1 == dog3: " + (dog1 == dog3));//#2
        System.out.println("dog1 == dog4: " + (dog1 == dog4));//#3
    }

输出结果：

dog1 == dog2: false
dog1 == dog3: true
dog1 == dog4: false

对于#1和#3结果为flase很好理解，因为比较的很明显是不同的对象，因此比较的两个对象在内存中的位置肯定是不同，所以用==判断是false。

对于#2，因为dog3实际上是引用了dog1，即dog3指向的也是dog1指向的内存地址，也即dog1和dog3指向了同一个对象，因此用==判断是true。

3. 总结一下equals()和==

• equals()呐，如果想达到某种“equals”的效果，就必须要重写该方法，并且同时重写hashCode()方法。如果是使用JDK中的equals()，建议要看一下源码，看看别人是怎么定义的这个equals()，然后再使用不容易出错~（注意对于基本数据类型是没有equals()方法的哟）
• ==呐（不是表情），就是比较的对象的内存地址~

4. 最后要注意一下String

看一段代码：

    public static void main(String[] args) {
        String str0 = "abc";
        String str1 = "abc";

        System.out.println("str0.equals(str1): " + str0.equals(str1));
        System.out.println("str0 == str1: "+ (str0 == str1));
    }

输出结果：

str0.equals(str1): true
str0 == str1: true

诶>_ < ?
用equals()判断结果为true是可以理解的，因为String的equals()比较的是字符串。可是
==不是判断的对象的内存地址吗？str0和str1是两个不同的对象，地址肯定不一样啊。
但是输出结果却说明，str0和str1指向的是同一个对象。
先莫捉急啦~ 看另一段代码

    public static void main(String[] args) {
        String str0 = "abc";
        String str1 = new String("abc");

        System.out.println("str0.equals(str1): " + str0.equals(str1));
        System.out.println("str0 == str1: "+ (str0 == str1));
    }

输出结果：

str0.equals(str1): true
str0 == str1: false

输出结果说明str0和str1指向的是不同的对象。

解释一下，是这样的，文本字符串属于字面量，而字面量是会放在常量池中的，程序运行时，会在常量池中找有没有”abc“,对于第一段代码，str1在常量池中找到了，所以就指向这个找到的常量，因此在第一段代码中，str0和str1指向的是同一个对象的内存地址。
在第二段代码中，我们要求重新new一个对象，因此，str0和str1指向的是不同的对象。