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

╰+攻爆jí腚メ 2022-02-02 07:53 244阅读 0赞

# 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**

--------------------

##### 画图： #####

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTkxMDY5NA_size_16_color_FFFFFF_t_70]  
画图如上，自我理解，有错误请指出。

--------------------

##### 总结 #####

1.  == 既可以比较基本类型也可以比较引用类型。对于基本类型就是比较值，对于引用类型就是比较内存地址
2.  Equals的话，它是属于java.lang.Object类里面的方法，如果该方法没有被重写过默认也是==;我们可以看到String类的equals方法是被重写过的，而且String类在日常开发中用的比较多，久而久之，形成了equals是比较值的错误观点。
3.  具体要看这有没有重写Object的hashCode方法和equals方法来判断。

--------------------

## 2. equals 的重写 ##

![在这里插入图片描述][20190511012647458.png]  
**可以看出，重写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。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTkxMDY5NA_size_16_color_FFFFFF_t_70]: /images/20220202/80b8e3e4a6e740418c696effaae42b86.png
[20190511012647458.png]: /images/20220202/c8bbdd55b812435e8ca690431bbd23d2.png