【Java面试题】3 Java的"==","equals()"和

1. “==”比较的是什么

• ==是一个运算符
• 对于8种基本的数据类型，比较的是变量所对应内存存储的数值
• 对于指向对象的变量，比较的也是变量所对应内存存储的数值(即指向的对象占用堆内存的首地址)，也就是比较变量是否指向同一个对象。

public class Test {
    public static void main(String[] args) {
        int a = 1, b = 1, c = 2;
        String s1 = "hello";
        String s2 = "hello";
        String s3 = new String("hello");
        System.out.println("a==b:" + (a == b));
        System.out.println("a==c:" + (a == c));

        System.out.println("s1==s2:" + (s1 == s2));
        System.out.println("s1==s3:" + (s1 == s3));
    }
}

输出结果：

a==b:true
a==c:false
s1==s2:true
s1==s3:false

上述代码中：
如果一个变量指向的数据是对象类型的，那么就涉及两块内存，变量占用的栈内存和对象占用的堆内存。例如Object obj = new Object();变量obj是存储在栈内存，new Object()存储在堆内存，此时，变量obj所对应的内存中存储的数值就是对象占用的那块内存的首地址。

2. “equals”比较的是什么

• equals是根类Object中的方法
  源代码如下：

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

• equals方法是用于比较两个独立对象的内容是否相同，需要为类重写equals方法。

例如，对于下面的代码：

String a=new String("foo");
String b=new String("foo");

两条new语句创建了两个对象，然后用a与b这两个变量分别指向了其中一个对象，这是两个不同的对象，它们的首地址是不同的，即a和b中存储的数值是不相同的，所以，表达式a==b将返回false，而String类重写了equals方法，两个变量中的内容是相同的。所以，表达式a.equals(b)将返回true。

在实际开发中，我们经常要比较传递进行来的字符串内容是否等，
例如，

String input = "xxxxx";
input.equals("quit");

许多人稍不注意就使用==进行比较了，记住，字符串的比较基本上都是使用equals方法。

如果一个类没有自己定义equals方法，那么它将继承Object类的equals方法，Object类的equals方法的实现代码如下：

boolean equals(Object o){
  return this==o;
}

总结：
如果一个类没有定义自己的的equals方法，它默认的equals方法就是从Object继承来的equals方法，就相当于“==”操作符。也是在比较两个变量指向的对象是否是同一对象，这时候使用equals和使用==会得到同样的结果，如果你编写的类希望能够比较该类创建的两个实例对象的内容是否相同，那么你必须覆盖equals方法，由你自己写代码来决定在什么情况即可认为两个对象的内容是相同的。

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类中重写的equals()是按照下面顺序判断的:

1. 先判断地址是否相同，若想等执行2，否则返回false，
2. 然后判断是否是String类型，否则返回false，
3. 然后依次判断每一个字符是否相等，全部相等返回true，否则返回false，

3. “hashcode()”

• hashcode是Object的方法。
• 默认情况下，Object中的hashCode() 返回对象的32位jvm内存地址。也就是说如果对象不重写该方法，则返回相应对象的32为JVM内存地址。

String类源码中重写的hashCode方法如下：

public int hashCode() {
    int h = hash;    //Default to 0 ### String类中的私有变量，
    if (h == 0 && value.length > 0) {    //private final char value[]; ### Sting类中保存的字符串内容的的数组
        char val[] = value;

        for (int i = 0; i < value.length; i++) {
            h = 31 * h + val[i];
        }
        hash = h;
    }
    return h;
}

String源码中使用private final char value[];保存字符串内容，因此String是不可变的。

下面的例子，没有重写ComHashcode类的···hashCode···方法，所以直接返回32位对象在JVM中的地址；Long类重写了hashCode方法，返回计算出的hashCode数值，String重写了hashCode方法，返回了相同的数值。

public class ComHashcode {
    public static void main(String[] args) throws Exception {
        ComHashcode a = new ComHashcode();
        ComHashcode b = new ComHashcode();
        System.out.println(a.hashCode()); // 366712642
        System.out.println(b.hashCode()); // 1829164700
        String s1="helloworld";
        String s2="helloworld";
        String s3=new String("helloworld");
        System.out.println("s1:"+s1.hashCode());    //s1:-1524582912
        System.out.println("s2:"+s2.hashCode());    //s2:-1524582912
        System.out.println("s3:"+s3.hashCode());    //s3:-1524582912
        Long num1 = new Long(8);
        Long num2 = new Long(8);
        System.out.println(num1.hashCode()); // 8
        System.out.println(num2.hashCode()); // 8
    }
}

总结：

1. 绑定。当equals方法被重写时，通常有必要重写hashCode方法，以维护 hashCode方法的常规协定，协定声明相等对象必须具有相等的哈希码。

2. 绑定原因。Hashtable实现一个哈希表，为了成功地在哈希表中存储和检索对象，用作键的对象必须实现 hashCode 方法和 equals 方法。
   equals()方法和hashCode()方法存在如下契约：
   如果两个对象是相等的，那么他们的hashCode必须是相同的。
   如果两个对象具有相同的hashCode，它们可以相等，也可以不相等。

3. 默认。
   ==默认比较对象在JVM中的地址。
   hashCode 默认返回对象在JVM中的存储地址。
   equal比较对象，默认也是比较对象在JVM中的地址，同==

重写equals()方法而没有重写hashcode()方法造成的错误：

import java.util.HashMap;

public class Cat {
    private String color;

    public Cat(String color) {
        this.color = color;
    }

    public boolean equals(Object obj) {
        if (obj == null) {
            return false;
        }
        if (!(obj instanceof Cat)) {
            return false;
        }
        if (this == obj) {
            return true;
        }
        return (this.color.equals(((Cat) obj).color));
    }

    public static void main(String[] args) {
        Cat cat1 = new Cat("白色");
        Cat cat2 = new Cat("黑色");
        System.out.println(cat1.equals(cat2));  //false，因为重写了equals方法，且他们的颜色不一样，所以返回false。
        HashMap<Cat, String> maps = new HashMap<>();
        maps.put(cat1, "白色");
        maps.put(cat2, "黑色");
        System.out.println(maps.get(new Cat("白色")));    //null，因为没有重写hashcode方法，所以在查找的时候计算的hashcode值不一样，无法找到，所以返回null。
    }
}

造成该错误的原因就在于重写equals方法后没有重写hashcode方法。

对于Java中所有类的超级父类java.lang.Object而言，其hashCode()的默认实现是：对于不同的对象就返回不同的整型值。上述示例代码中，Cat类没有重写Object的hashCode()方法。所以，这条代码System.out.println(maps.get(new Cat("白色")));创建的Cat类和cat1的hasncode值不一样，所以无法找到。

最后给出重写hashcode()方法后的代码：

import java.util.HashMap;

public class Cat {
    private String color;

    public Cat(String color) {
        this.color = color;
    }

    public boolean equals(Object obj) {
        if (obj == null) {
            return false;
        }
        if (!(obj instanceof Cat)) {
            return false;
        }
        if (this == obj) {
            return true;
        }
        return (this.color.equals(((Cat) obj).color));
    }

    @Override
    public int hashCode() {
        return this.color.hashCode();
    }

    public static void main(String[] args) {
        Cat cat1 = new Cat("白色");
        Cat cat2 = new Cat("黑色");
        System.out.println(cat1.equals(cat2)); // false
        HashMap<Cat, String> maps = new HashMap<>();
        maps.put(cat1, "白色");
        maps.put(cat2, "黑色");
        System.out.println(maps.get(new Cat("白色"))); // 白色
    }
}