Java基础之equals和==的区别深入解析

Java基础之equals和==的区别深入解析

---

以下是本文目录大纲

1. equals 和 == 的区别
2. equals 的重写
3. 复写hashCode方法，有31这个数字的作用

---

1. equals 和 == 的区别

// object类下的equals
public boolean equals(Object obj) {
        return (this == obj);
    }

//String类下的euqals
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;
    }

• 首先，我们知道 == 既可以比较基本类型也可以比较引用类型。对于基本类型就是比较值，对于引用类型就是比较内存地址。
• 通过equals源码可以看出，equals是java.lang.Object类里面的方法，如果该方法没有被重写过默认也是==，String类的equals方法是被重写过的，先比length是否相同，相同再比较value是否相同，且String类在日常开发中用的比较多，久而久之，形成了equals是比较值的错误观点

接下来我们再看个代码加深理解

public class stringTest {
        public static void main(String[] args) {
            String s1 = new String("abc");
	        String s2 = new String("abc");
	        System.out.println(s1==s2);
	        System.out.println(s1.equals(s2));
	        System.out.println("======================");
	        Set<String> set = new HashSet<>();
	        set.add(s1);
	        set.add(s2);
	        System.out.println(s1.hashCode()+"\t"+s2.hashCode());
	        System.out.println(set.size());

	        System.out.println("============");
	
	        Person p1 = new Person("abc");
	        Person p2 = new Person("abc");
	        System.out.println(p1 == p2);
	        System.out.println(p1.equals(p2));
	
	        Set<Person> set2 = new HashSet<Person>();
	        set2.add(p1);
	        set2.add(p2);
	        System.out.println(p1.hashCode()+"\t"+p2.hashCode());
	        System.out.println(set2.size());
        }
    }

结果：

false
true
======================
96354	96354
1
============
false
false
1163157884	1956725890
2

---

解释：

• s1，s2是引用类型且是String类型（即equals方法有重写）
• s1==s2 比较的是内存地址，所以 false
• s1.equals(s2) 的equals重写过，先比较length，再比较value，所以true
• 复写后s1，s2是同一个对象，所以hashCore值相同
• 即能解释 set.size() = 1

同理可以解释p1和p2

• p1，p2为引用类型且是Person类型（即equals没有重写）
• p1==p2 比较的是内存地址，所以 false
• s1.equals(s2) 的equals没有重写过等价于==，所以false
• p1，p2是两个对象，所以hashCore值不相同
• 即能解释 set2.size() = 2

---

画图：

画图如上，自我理解，有错误请指出。

---

总结

1. == 既可以比较基本类型也可以比较引用类型。对于基本类型就是比较值，对于引用类型就是比较内存地址

2. Equals的话，它是属于java.lang.Object类里面的方法，如果该方法没有被重写过默认也是==;我们可以看到String类的equals方法是被重写过的，而且String类在日常开发中用的比较多，久而久之，形成了equals是比较值的错误观点。

3. 具体要看这有没有重写Object的hashCode方法和equals方法来判断。

---

2. equals 的重写

可以看出，重写equals，重写就要同时重写equals()和hashCode()。

当一个类有自己特有的“逻辑相等”概念,当改写equals()的时候，总是要改写hashCode()，根据一个类的equals方法（改写后），两个截然不同的实例有可能在逻辑上是相等的，但是，根据Object.hashCode方法，它们仅仅是两个对象。以Person为例，两个人都叫张三，但不是同一个人（equals），需要看的不是名字，而是身份证号码（hashCode）

因此，违反了“相等的对象必须具有相等的散列码”。

结论：复写equals方法的时候一般都需要同时复写hashCode方法。

---

3. 复写hashCode方法，31这个数字的作用

源码：

public int hashCode() {
        int h = hash;
        if (h == 0 && value.length > 0) {
            char val[] = value;

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

计算机的乘法涉及到移位计算。当一个数乘以2时，就直接拿该数左移一位即可！选择31原因是因为31是一个素数。（素数：质数又称素数，在一个大于1的自然数中，除了1和此整数自身外，没法被其他自然数整除的数）

在存储数据计算hash地址的时候，我们希望尽量减少有同样的hash地址，所谓“冲突”。

因为任何数n * 31就可以被JVM优化为 (n << 5) -n,移位和减法的操作效率要比乘法的操作效率高的多，对左移虚拟机里面都有做相关优化，并且31只占用5bits。