详解Java中==和equals()的区别

Posted 2020-12-16 smallmin

众所周知，在 Java 编程中，程序员通常会使用==或equals()来简单的比较地址，内容是否相等。而这两者之间的使用区别，对于初学 Java 的同学来说可能会比较迷糊。我将根据下面的几段示例程序，来对这两种比较方法进行分析，供大家参考：

	private static void method1() {
		Integer n1 = new Integer(5);
		Integer n2 = new Integer(5);

		System.out.println(n1.equals(n2));// true
		System.out.println(n1 == n2);// false
	}

在method1()中，第一个的输出打印结果如我所料，equals()比较两者的内容，输出结果会是true，但是第二个打印输出结果，如果是在我刚接触 Java 时，肯定会毅然决然的认为这条输出的结果应该是true。但事实是，尽管n1 和 n2 看起来内容相同，但是程序执行出来的结果却是false 。

翻阅《 Java 编程思想（第四版）》，在书中有这么一段话：

== 和 != 比较的就是对象的引用。

如果想比较两个对象的实际内容是否相同，必须使用所有对象都使用的特殊方法 equals() 方法。但这个方法不适用于“基本类型”，基本类型直接使用 == 或 != 即可。

通过书里的这段话我们进行分析，在method1()方法里，尽管 n1，n2 两个对象的内容是相等的，但是它们本质上是属于两个创建出来的不同的对象。因此，在method1()中，两个不同的对象它们所引用的地址当然是不相同的，故method1()的第二个输出结果为false。

	private static void method2() {
		Integer n3 = 127;
		Integer n4 = 127;
        
		Integer n5 = 128;
		Integer n6 = 128;
        
		System.out.println(n3 == n4);// true
		System.out.println(n5 == n6);// false
	}

在method2()中可以看到，这里的写法不是通过 new 形式来创建 Integer 对象了 ，而是通过自动装箱方式创建一个 Integer 对象。何谓自动装箱，通俗的解释就是自动将基本数据类型转换为包装器类型。记得我在method1()中写道：== 比较的就是对象的引用。在这里 n3 ，n4 属于两个不同的对象，通过 ==比较的是两个对象的引用，理应输出的结果是false。那么结果为什么是true呢？

为了便于分析，我们可以仅在代码里保留一行代码。

public class Equivalence {
	public static void main(String[] args) {
		Integer n3 = 127;
	}
}

通过编译该 java 文件后，在控制台窗口中切换到其编译后输出的 *.class字节码文件的位置，输入javap -c "文件名.class"对其进行反编译。我们来看看保留的这段代码执行编译中干了什么事情：

从打印输出的内容截图里，我们可以知道系统当使用 Integer 自动装箱时，系统会帮我们会调用Integer.valueOf()方法，我们可以查看下该方法的源码。

public final class Integer extends Number implements Comparable<Integer> {

		// ...
		public static Integer valueOf(int i) {
            // 对传进来的数值进行比较
        if (i >= IntegerCache.low && i <= IntegerCache.high)
            return IntegerCache.cache[i + (-IntegerCache.low)];
        return new Integer(i);
    }
        /**
        * Integer的内部类，用于缓存 -128 ~ 127的数值
        */
        private static class IntegerCache {
        static final int low = -128;
        static final int high;
        static final Integer cache[];

        static {
            // high value may be configured by property
            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);
                    // Maximum array size is Integer.MAX_VALUE
                    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++);

            // range [-128, 127] must be interned (JLS7 5.1.7)
            assert IntegerCache.high >= 127;
        }

        private IntegerCache() {}
    }
}

通过查阅源码注释（本文未展示），这个方法是在JDK 1.5时加入的。当执行Integer.valueOf()方法时，会将传进来的数值与IntegerCache.low和IntegerCache.high进行比较。为了避免多次创建浪费资源，通过IntegerCache这个 Integer 的缓存内部类，将-128 ~ 127的数值缓存起来。

也就是说，当我们使用 Integer 进行自动装箱操作时，会将装箱的数值与缓存的数值进行比较，如果在该缓存范围内，则会返回一个已经创建好的 Integer 对象，反之将会重新创建一个 Integer 对象。这么一来，也就可以解释的通：为什么 n3 、n4数值相等，n4、n5数值也同样相等，输出的结果却是不同的原因了。

上述内容，我们仅是通过 Integer 包装类的源码对==和equals()两种比较方式进行分析。实际上，不同的包装类，所执行出的效果也不尽相同。若想深入了解，大家可以查看我文末附上的参考文章链接。

接下来我们再通过代码示例，对equals()进行分析。

public class Equivalence {
	public static void main(String[] args) {
		method3();
	}
	private static void method3() {
		Value v1 = new Value(100);
		Value v2 = new Value(100);
		String s1 = new String("smallmin");
		String s2 = new String("smallmin");
		System.out.println(v1.equals(v2));// false
		System.out.println(s1.equals(s2));// true
	}

}
class Value {
	int i;

	public Value(int i) {
		super();
		this.i = i;
	}

}

记得我们在method1()中讲过，比较两个对象的实际内容是否相同，必须使用所有对象都使用的特殊方法 equals() 方法。那么上面示例代码中，为什么v1 与 v2 比较输出结果会是false，而 s1 与 s2 比较出的结果却是true呢？

在method1()中我们 Integer 对象之间通过equals()比较以及本例中，String对象间通过equals()输出的比较结果都是true（对象内容相等的前提下）的原因是，Integer 和 String 等类中，都对equals()进行了重写，因文章篇幅原因故不再逐一附上源码。

而v1 与 v2 是我们自己创建的对象，没有重写equals()方法，当调用该方法时执行的是父类Object 的equals()方法。而Object 的equals()方法通过查看源码可得知，其实它是比较两者之间的引用地址。v1 和 v2 尽管对象的内容相同，但是它们分别来自不同的对象，引用地址当然不同，故两者比较的结果是false。

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

总结：

• 基本数据类型之间比较，可直接使用==进行比较。
• 当比较两个对象引用地址是否为同个地址时，使用==进行比较。
• 在重写了equals()的前提下，比较对象内容或者其他自定义的比较方法时，使用equals()比较。

本文参考文章：https://www.cnblogs.com/wang-yaz/p/8516151.html

关于自动装箱与拆箱的细节可以看看这篇文章，感谢作者提供好的思路和讲解。