为什么用==的效果与equals()的效果不一样

深碍√TFBOYSˉ_ 2024-05-06 23:01 64阅读 0赞

#### **初步了解在JVM中的内存分配知识** ####

在JVM中，内存分为堆内存跟栈内存。他们二者的区别是： 当我们创建一个对象（new Object）时，就会调用对象的构造函数来开辟空间，将对象数据存储到堆内存中，与此同时在栈内存中生成对应的引用，当我们在后续代码中调用的时候用的都是栈内存中的引用。还需注意的一点，基本数据类型是存储在栈内存中。

#### ==与equals()的区别 ####

**对于==**

*  比较的是值是否相等
 *  如果作用于基本数据类型的变量，则直接比较其存储的 “值”是否相等；
 *  如果作用于引用类型的变量，则比较的是所指向的对象的地址

**对于equals方法**

1.  equals方法不能作用于基本数据类型的变量，equals继承Object类，比较的是是否是同一个对象
2.  如果没有对equals方法进行重写，则比较的是引用类型的变量所指向的对象的地址，默认也是==；
3.  对于String、Date等类对equals方法进行了重写的话，比较的是所指向的对象的内容。
4.  具体要看自定义类（比如实体类等）里有没有重写Object的equals方法来判断
5.  通常情况下，重写equals方法，会比较类中的相应属性是否都相等

#### 重写equals()方法的原则 ####

对称性： 如果x.equals(y)返回是“ true ”， 那么y.equals(x) 也应该返回是\\n“true”。

自反性：x.equals(x)必须返回是“true”。

传递性：如果x.equals(y)返回是“true”，而且y.equals(z)返回是“true”，\\n那么z.equals(x)也应该返回是“true”。

一致性：如果x.equals(y)返回是“true”，只要x和y内容一直不变，不管你 重复x.equals(y)多少次，返回都是“true”。

任何情况下，x.equals(null)，永远返回是“false”；x.equals(和x不同类型的对象)永远返回是“false”。

#### ==的特点及使用 ####

**= =**：

*  基本类型比较值:只要两个变量的值相等，即为true。
 *  引用类型比较引用(是否指向同一个对象)：只有指向同一个对象时，= =才返回true。
 *  用“= =”进行比较时，符号两边的数据类型必须兼容(可自动转换的基本 数据类型除外)，否则编译出错

/* 
     *  == 的使用：
     * == ：运算符
     * 1. 可以使用在基本数据类型变量和引用数据类型变量中
     * 2. 如果比较的是基本数据类型变量：比较两个变量保存的数据是否相等。（不一定类型要相同）
     *    如果比较的是引用数据类型变量：比较两个对象的地址值是否相同.即两个引用是否指向同一个对象实体
     * 补充： == 符号使用时，必须保证符号左右两边的变量类型一致。
     */
    public class EqualsTest {
    	public static void main(String[] args) {
    		
    		//基本数据类型
    		int i = 10;
    		int j = 10;
    		double d = 10.0;
    		System.out.println(i == j);//true
    		System.out.println(i == d);//true
    		
    		boolean b = true;
    //		System.out.println(i == b);
    		
    		char c = 10;
    		System.out.println(i == c);//true
    		
    		char c1 = 'A';
    		char c2 = 65;
    		System.out.println(c1 == c2);//true
    	}
    }

#### equals()的特点和使用 ####

**equals()：**

*  所有类都继承了Object，也就获得了equals()方法。还可以重写。
 *  只能比较引用类型，其作用与“==”相同,比较是否指向同一个对象。格式:obj1.equals(obj2)
 *  特例：当用equals() 方法进行比较时， 对类File 、String 、Date 及包装类（Wrapper Class）来说，是比较类型及内容而不考虑引用的是否是同一个对 象；原因：在这些类中重写了Object类的equals()方法。
 *  当自定义使用equals()时，可以重写。用于比较两个对象的“内容”是否都相等

package com.atguigu.java1;
    import java.util.Date;
    /* 
     * 二、equals()方法的使用：
     * 1. 是一个方法，而非运算符
     * 2. 只能适用于引用数据类型
     * 3. Object类中equals()的定义：
     *    public boolean equals(Object obj) {
    	        return (this == obj);
    	  }
     *    说明：Object类中定义的equals()和==的作用是相同的：比较两个对象的地址值是否相同.即两个引用是否指向同一个对象实体
     * 
     * 4. 像String、Date、File、包装类等都重写了Object类中的equals()方法。重写以后，比较的不是
     *    两个引用的地址是否相同，而是比较两个对象的"实体内容"是否相同。
     *    
     * 5. 通常情况下，我们自定义的类如果使用equals()的话，也通常是比较两个对象的"实体内容"是否相同。那么，我们就需要对Object类中的equals()进行重写.
     *    重写的原则：比较两个对象的实体内容是否相同.
     */
    public class EqualsTest {
    	public static void main(String[] args) {	
    		//引用类型：
    		Customer cust1 = new Customer("Tom",21);
    		Customer cust2 = new Customer("Tom",21);
    		System.out.println(cust1 == cust2);//false
    		
    		String str1 = new String("atguigu");
    		String str2 = new String("atguigu");
    		System.out.println(str1 == str2);//false
    		System.out.println("****************************");
    		System.out.println(cust1.equals(cust2));//false--->true
    		//调用Object类中定义的equals()和==的作用是相同的
    
    		System.out.println(str1.equals(str2));//true
    		//像String、Date、File、包装类等都重写了Object类中的equals()方法。重写以后，比较的不是两个引用的地址是否相同，而是比较两个对象的"实体内容"是否相同。
    		
    		Date date1 = new Date(32432525324L);
    		Date date2 = new Date(32432525324L);
    		System.out.println(date1.equals(date2));//true			
    	}
    }

#### 重写equals() ####

Object 的[equals方法][equals]，本质为==

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

**拿String重写的的equals进行举例**

1.  先判断引用地址是否相等，相等直接返回true
2.  判断传入的anObject是否为String类型
3.  向下转型，强转为String
4.  得到长度n
5.  拿长度n和传入形参anObject进行对比吗，不相同返回false
6.  循环进行数组内数据的比较，相同返回true，否则返回false

public boolean equals(Object anObject) {
    		//判断引用地址
            if (this == anObject) {
                return true;
            }
            if (anObject instanceof String) {//判断是否为String    
            
    			//向下转型，强转为String
    			//形参是anObject，实参是String类型，传入类型会自动类型提升，不强转的话，“编译”的时候点不出来String的结构
    			//“运行”的时候，实际上anObject形参收到的是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()的实质，为我们的知识储备又加上一笔。

![20201213121345281.gif_pic_center][]

> 如果这篇文章有帮助到你，希望可以给作者点个赞?，创作不易，如果有对后端技术、前端领域感兴趣的，也欢迎关注 ，我将会给你带来巨大的收获与惊喜???！

[equals]: https://so.csdn.net/so/search?q=equals%E6%96%B9%E6%B3%95&spm=1001.2101.3001.7020
[20201213121345281.gif_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/06/89856e362bd24fc388ca4937a18be5a8.gif