equals和==深入浅出

不念不忘少年蓝@ 2022-06-01 10:48 134阅读 0赞

> 一、数据类型

java中的数据类型，可分为两类：

1.  基本数据类型，也称原始数据类型。byte,short,char,int,long,float,double,boolean
    
    他们之间的比较，应用双等号（==）,比较的是他们的值。  
    Integer、Long等不是基本数据类型，而是包装类 对象
2.  复合数据类型(类)
    
    当他们用（==）进行比较的时候，比较的是他们在内存中的存放地址，所以，除非是同一个new出来的对象，他们的比较后的结果为true，否则比较后结果为false。
3.  equals  
    equals是Object类的一个方法，由于java中所以类都继承equals类 ，因此都有equals，一般的类都会重新equals方法

> 二、基本数据类型的比较 ==、equals

基本数据类型：https://www.cnblogs.com/liangxiaofeng/p/5721506.html

Integer a1 = 100, b1 = 100; 
    System.out.println(a1.equals(b1)); //true 
    System.out.println(a1 == b1); // true
    
    Integer a = 1000, b =1000; 
    System.out.println(a.equals(b)); // true 
    System.out.println(a== b); // false

a.equals(b),执行的拆箱方法intValue()，返回的是value值，因此是比较的大小。

a == b：由于a = 1000, b = 1000 这时会执行装箱方法valueOf()  
如果不在-128到127区间范围，返回的是一个new Integer(1000)对象，这时他们存放的地址肯定不一样。因此a!=b1  
如果在-128到127区间范围，则是返回的缓存对象的引用，因此a1==b1

// Integer重新了equals
    public boolean equals(Object obj) {
        // 如果是Integer类型包装类型
        if (obj instanceof Integer) {
            return value == ((Integer)obj).intValue();//
        }
        // 其他类型返回false
        return false;
    }
    
    // 拆箱，直接返回value值
    public int intValue() {
        return value;
    }
    
    // 装箱（将基本数据类型int，转换为Integer包装类）
    public static Integer valueOf(int i) {
    
        // 如果-128<=i<=127，则返回缓存的值
        if (i = IntegerCache.low && i <= IntegerCache.high)
            return IntegerCache.cache[i + (-IntegerCache.low)];
    
        // 不在这个范围，new一个Integer对象返回
        return new Integer(i);
    }

包装类Integer执行缓存的源码

// IntegerCache是Integer的一个内部类(JDK1.8里面的源码)，缓存-128到127
    private static class IntegerCache { 
        static final int low = -128;  //缓存最小值
        static final int high;        //缓存最大值
        static final Integer cache[]; //存放缓存
    
        static {
            int h = 127;
            String integerCacheHighPropValue = sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
            if (integerCacheHighPropValue != null) {
                try {
                    int i = parseInt(integerCacheHighPropValue);
                    i = Math.max(i, 127);
                    h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
                } catch( NumberFormatException nfe) {
                    // If the property cannot be parsed into an int, ignore it.
                }
            }
            high = h;
    
            // 缓存数组的大小
            cache = new Integer[(high - low) + 1];
            int j = low;
            for(int k = 0; k < cache.length; k++)
                cache[k] = new Integer(j++);
    
            // 范围-128，127必须被插入
            assert IntegerCache.high = 127;
        }
        private IntegerCache() {}
    }

**Integer 和int 比较总结：**  
equals 比较的是值是否相等（Integer是调用intValue()，int型直接是比较值）  
==比较的是基本数据类型int，比较的是值是否相等 ，如果是包装类，比较的是内存地址（这里需要注意-128到127Integer缓存在内存当中）

**深入理解：**

Integer a = 1000
    int b = 1000;
    System.out.println(a.equals(b));// true
    System.out.println(a == b);    // true

equals比较的value值，因此a.equals(b)毫无疑问  
a == b为什么等于true？  
\*\*int与Integer比较，Integer首先要做拆箱（intValue），a.intValue == b，这时比较的就是value，这时的a==b等价于a.intValue == b

Integer c = new Integer(10);
    Integer d = new Integer(10);
    System.out.println(d.equals(c));//true
    System.out.println(c == d);    //false

为什么c == d为false？  
虽然Integer缓存了-128到127，但是都是new Integer类，因此是2个不同的对象，==比较的是内存地址，因此为false;

> 三、String类型的比较

查看String类型的源码，发现String类是被final修饰的  
因此String是不可变的

public final class String{}

String a = "asd"; // 初始化一个String对象
    a += "123";       // 返回一个新的对象，a的内存地址发生变化，和原来a="asd"指向的内存地址不一样。这时指向的是"asd123"的内存地址

**String的”==”比较**

首先讲解一下String赋值过程

String a = "asv"; 
    // 先去字符常量池查询是否有"asv"字符，没有的话，在字符串池创建了一个"asv"，将"asv"的内存地址指向a。
    
    
    String b = "asv";
    // 字符常量池查询是否有"asv"字符，查询到了，将"asv"的内存地址指向b。

因此a的值和b的值内存地址都指向同一个，因此a==b

**String的”equals“比较**

String也重新equals方法，下面是String重新equals的源码

public boolean equals(Object anObject) {
        // 首先判断是否"=="，比较的是内存地址
        // 如果内存地址是同一个，返回true
        // String a="qwe",b="qwe",这时this==anObject = true
        if (this == anObject) {
            return true;
        }
    
        // 如果不是指向同一个内存地址，那么比较value值是否相等
        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方法，首先会比较内存地址，如果内存地址不同，再比较value值***

**String比较例子**

String a = "asv", b = "asv";
    System.out.println(a.equals(b)); // true
    System.out.println(a == b); // true

String a = “asv”, b = “asv”;  
a = “asv”：首先java虚拟机会去常量池查询是否有asv字符，没有查询到，那么会执行new String(“asv”),创建一个新的对象，a指向新对象的内存地址。  
b = “asv”：去常量池查询是否有asv字符，查询到了，这时，就会将b的指向asv的内存地址  
因此，这时的a和b都是指向的同一个对象，所以a==b，a.equals(b)都为true

在上面的基础上，继续往下看

String c = new String("asv"); 
    System.out.println(a.equals(c)); // true
    System.out.println(a == c);       // false

String c = new String(“asv”)：创建一个新的对象，这个对象的值为“asv”，c指向的新对象的内存地址。新对象的值，会引用常量的asv字符串。

a.equals(b):因为指向的是同一个内存地址，因此true（qual方法执行的是：this == anObject）  
a == b：因为指向的是同一个内存地址，因此true

a.equals(c):不是指向的同一个内存地址，因此equls执行了（if (anObject instanceof String) ），判断是的a和c的值(value)值是否相等，因此返回的true  
a == c：因为==比较的是内存地址，因此，返回false

**总结：**  
String的==比较的是内存地址  
equal首先会比较内存地址，如果内存地址不同，再比较value值  
String类是final修饰的，不可变的，一旦变化，返回的是一个new String对象  
建议看看java虚拟机内存模型。

> 四、对象的比较

equal:对象之间的比较，如果没有重写equal方法，那么默认调用的是java.lang.Object类的equal方法，这时，比较的内存地址，也就是==  
==：比较的是内存地址

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

因此：对象之间的比较，如果没有重新equals方法，那么equals和==都是比较的内存地址

五、包装类

Java语言是一个面向对象的语言，但是Java中的基本数据类型却是不面向对象的，这在实际使用时存在很多的不便，为了解决这个不足，在设计类时为每个基本数据类型设计了一个对应的类进行代表，这样八个和基本数据类型对应的类统称为包装类(Wrapper Class)，有些地方也翻译为外覆类或数据类型类。  
包装类均位于java.lang包，包装类和基本数据类型的对应关系如下表所示：  
包装类对应表

![这里写图片描述][SouthEast]

包装类的特征

*  a、作为和基本数据类型对应的类类型存在，方便涉及到对象的操作。
 *  b、包含每种基本数据类型的相关属性如最大值、最小值等，以及相关的操作方法
 *  c、包装类的缓存
    
        boolean：(全部缓存)
            byte：(全部缓存)
            character(<= 127缓存)
            short(-128 — 127缓存)
            long(-128 — 127缓存)
            integer(-128 — 127缓存)
            float(没有缓存)
            doulbe(没有缓存)
 *  d、拆箱和装箱  
    拆箱：将包装类转换为基本数据类型  
    装箱：将基本数据类型转换为包装类

其实，JDK自从1.5(5.0)版本以后，就引入了自动拆装箱的语法，也就是在进行基本数据类型和对应的包装类转换时，系统将自动进行，这将大大方便程序员的代码书写。使用示例代码如下：  
int m = 12;  
Integer in = m; //装箱，JDK1.5之前：Integer in = Integer.valueOf(m);  
int n = in; // 拆箱，JDK1.5之前：int n = Integer.intValue(in);

[SouthEast]: /images/20220601/73bfbc196d2145a5be40a6741f9aed77.png