Java中“==”和equals的区别？最详细的介绍

àì夳堔傛蜴生んèń 2023-03-06 03:46 45阅读 0赞

1.  ==是基本运算符，可以对基本类型进行比较，比较的是对象的引用是否指向同一块内存地址。
2.  equals()是一个方法，它不可以可以对基本类型进行比较。见源码1，**equals()默认的方法中也使用了==，比较的也是对象的地址**。见源码2，只不过equals()是一个方法可以对其进行重写，像String、Date、Math、File、包装类等大部分类都重写了Object的equals()方法。重写后的equals()将每个值取出依次对比其内存地址，也可以把它理解为比较整体值是否相等。

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

**源码2. String类源码中重写的equals方法如下：**

public boolean equals(Object anObject) { 
    // 1. 检查是否为同一个对象的引用，如果是直接返回 true；
            if (this == anObject) { 
                return true;
            }
    /*2.判断anObject是否为String类的实例，如果不是直接返回false，如果是则取值比较大小。 注：instanceof 测试一个对象是否为一个类的实例 **/
            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;
        }

**为什么会出现以下现象？**

//1. 比较基本类型
            int m=1;
            int n=1;
            // System.out.println(m.equals(n)); // 报错
            System.out.println(m == n);  // true
            //System.out.println(m.hashCode()); // 报错
            //System.out.println(n.hashcode()); // 报错
    
            //2. 比较new出来的封装类型
            Integer x = new Integer(1);
            Integer y = new Integer(1);
            System.out.println(x.equals(y)); // true
            System.out.println(x == y);      // false
    
            //3. 比较非new封装类型 [-128, 127] 
            Integer x1 = 127;
            Integer y1 = 127;
            System.out.println(x1.equals(y1)); // true
            System.out.println(x1 == y1);      // true
    
            //4. 比较非new封装类型非[-128, 127] 
            Integer x2 = 128;
            Integer y2 = 128;
            System.out.println(x2.equals(y2)); // true
            System.out.println(x2 == y2);      // false
            
           //5. 比较非new字符串
            String s1="abc";
            String s2="abc";
            System.out.println(s1==s2);  // true
            System.out.println(s1.equals(s2));  // true
    
            //6. 比较new字符串
            String str1 = new String("hello");
            String str2 = new String("hello");
            System.out.println(str1.equals(str2)); //true
            System.out.println(str1==str2); //false

**1. 比较基本类型**  
对于基本数据类型（byte，short，char，int，float，double，long，boolean）来说，他们是作为常量在方法区中的常量池里面以HashSet策略（HashSet中不允许有重复的元素）存储起来的。因此在常量池，一个常量只会对应一个地址。所以不管是再多的 1，其内存地址都为同一个。  
**2. 比较new出来的封装类型**  
new String(“hello”)会在堆内存中创建一个实例，开辟新的内存空间，故==为falsie。但是源码2中，String类源码中重写了equals方法，对单个值的进行比较。  
**3. 比较非new封装类型 \[-128, 127\]**  
**4. 比较非new封装类型非\[-128, 127\]**  
对于两个非 new 生成的 Integer 对象进行比较时，如果两个变量的值在区间 \[-128, 127\] 之间，则比较结果为 true，否则为 false。Java 在编译 Integer i = 100 时，会编译成 Integer i = Integer.valueOf(100)，而 Integer 类型的 valueOf 的源码如下所示：

public static Integer valueOf(int var0) {     
           return var0 >= -128 && var0 <= Integer.IntegerCache.high ? Integer.IntegerCache.cache[var0 + 128] : new Integer(var0);
    }

从上面的代码中可以看出：Java 对于 \[-128, 127\] 之间的数会进行缓存，比如：Integer i = 127，会将 127 进行缓存，下次再写 Integer j = 127 的时候，就会直接从缓存中取出，而对于这个区间之外的数就需要 new 了。  
**5. 比较字符串**  
在Java执行时会维护一个String池（pool），对于一些可以共享的字符串对象，会先在String池中查找是否存在相同的String内容（字符相同），如果有就直接返回，不创建新对象。  
**6. 比较非new字符串常量**  
new String(“hello”)会在堆内存中创建一个实例，开辟新的内存空间，故==为falsie。但是，String类源码中重写了equals方法，对单个值的进行比较。

**如何使用？**

在java虚拟机中，基本类型存储在方法区中的常量池中，同属性同地址，用==即可。但是对于new出来的对象它们存储在堆中，==仅能比较其地址首相等。无法比较真正意义上的相等，用重写的equals方法即可。