深入理解Java的==操作符与equals()方法

==操作符

对于8种基本类型（即boolean/char/byte/short/int/long/float/double）：比较两个变量的值是否相等；
对于引用类型（即除去8种基本类型外的其他所有类型）：比较两个变量的引用内存地址是否相等。

equals()方法

Object类中的默认实现是直接用==的，也就是比较this和obj的引用内存地址是否相等。

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

但是在多数情况下，==的实现方式显然不是我们想要的，因此equals()方法往往会被覆写为比较两个引用的内容。比如String类中的equals()方法如下。

    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;
    }

Java语言中，equals()方法必须具有如下几个特性：

• 自反性：对非空引用x，x.equals(x)恒为true；
• 对称性：对任意引用x和y，若x.equals(y)为true，那么y.equals(x)也为true；
• 传递性：对任意引用x、y、z，若x.equals(y)与y.equals(z)都为true，那么x.equals(z)也为true；
• 一致性：如果引用x和y引用的对象没有发生变化，那么x.equals(y)应一直返回同样的结果；
• 对非空引用x，x.equals(null)恒为false。

举个栗子

以整形为例。

        int i1 = 200;
        Integer i2 = 200;
        Integer i3 = 200;
        Integer i4 = new Integer(200);
        System.out.println(i1 == i2);      // true
        System.out.println(i2 == i3);      // false
        System.out.println(i3 == i4);      // false
        System.out.println(i3.equals(i4)); // true

返回结果是true、false、false、true。为什么会是这样？
执行javap -c EqualsExample.class命令，查看字节码如下。

       0: sipush        200
       3: istore_1
       4: sipush        200
       7: invokestatic  #2                  // Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;
      10: astore_2
      11: sipush        200
      14: invokestatic  #2                  // Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;
      17: astore_3
      18: new           #3                  // class java/lang/Integer
      21: dup
      22: sipush        200
      25: invokespecial #4                  // Method java/lang/Integer."<init>":(I)V
      28: astore        4
      30: getstatic     #5                  // Field java/lang/System.out:Ljava/io/PrintStream;
      33: iload_1
      34: aload_2
      35: invokevirtual #6                  // Method java/lang/Integer.intValue:()I
      38: if_icmpne     45
      41: iconst_1
      42: goto          46
      45: iconst_0
      46: invokevirtual #7                  // Method java/io/PrintStream.println:(Z)V
      49: getstatic     #5                  // Field java/lang/System.out:Ljava/io/PrintStream;
      52: aload_2
      53: aload_3
      54: if_acmpne     61
      57: iconst_1
      58: goto          62
      61: iconst_0
      62: invokevirtual #7                  // Method java/io/PrintStream.println:(Z)V
      65: getstatic     #5                  // Field java/lang/System.out:Ljava/io/PrintStream;
      68: aload_3
      69: aload         4
      71: if_acmpne     78
      74: iconst_1
      75: goto          79
      78: iconst_0
      79: invokevirtual #7                  // Method java/io/PrintStream.println:(Z)V
      82: getstatic     #5                  // Field java/lang/System.out:Ljava/io/PrintStream;
      85: aload_3
      86: aload         4
      88: invokevirtual #8                  // Method java/lang/Integer.equals:(Ljava/lang/Object;)Z
      91: invokevirtual #7                  // Method java/io/PrintStream.println:(Z)V

由上可见，i2与i3的赋值过程都触发了自动装箱，也就是将基本类型int自动转化成了对应的包装类Integer，调用Integer.valueOf()方法。而i4这种显式new的写法完全没有必要，只是拉出来做对比而已。

• i1 == i2为true

在基本类型与包装类做比较时，包装类会先自动拆箱，也就是执行了Integer.intValue()方法，所以最终变为两个值相同的int比较，自然为真。同样地，如果包装类要进行运算，也会先自动拆箱，因为Java的数学运算全部在栈上进行，+、-等操作符不适用于包装类。

• i2 == i3为false

看一看Integer.valueOf()方法的源码。

    public static Integer valueOf(int i) {
        if (i >= IntegerCache.low && i <= IntegerCache.high)
            return IntegerCache.cache[i + (-IntegerCache.low)];
        return new Integer(i);
    }

另外还有一个静态内部类IntegerCache。

    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() {}
    }

可见，IntegerCache正如其名，是一个整形缓存类，其中的cache数组默认缓存了[-128, 127]之间的数。如果调用valueOf()时的参数i恰好在这个区间内，那么就会直接返回cache数组中的对应值，否则就会再new一个Integer对象出来。
除Integer之外，非浮点型其他包装类Byte、Short、Long等也都有类似的缓存机制。JDK认为[-128, 127]区间内的整形值可能非常常用，因此将它们缓存下来可以提高效率。这种机制在Java规范中还有一个更通用的名字，叫做常量池（constant pool）。
上面示例中的取值200不在这个区间内，因此i2和i3是分别new出来的两个对象，它们在堆内存中的地址不同，故i2 == i3为假。假若取值为100，那么它们的地址相同，i2 == i3就会为真。

在这里回忆一下JVM内存模型的相关知识：
基本类型的数据是存放在Java虚拟机栈中的局部变量表里。这里除了基本类型外，还有reference类型和returnAddress类型。reference就是对象的引用，可以认为包含了对象的起始内存地址。所有对象实例（也就是所谓new出来的东西）和数组则是存放在Java堆里，也是GC发生的主要区域。

• i3 == i4为false

这就是很自然的了，它们两个在堆内存中的地址也是不同的。

• i3.equals(i4)为true

看一下Integer.equals()方法的源码。

    public boolean equals(Object obj) {
        if (obj instanceof Integer) {
            return value == ((Integer)obj).intValue();
        }
        return false;
    }

很简单，就是将两个Integer拆箱成int然后比较值。这也是我们真正需要的方法。

如果换成String呢

        String s1 = "LittleMagic";
        String s2 = new String("LittleMagic");
        String s3 = s2;
        System.out.println(s1 == s2);       // false
        System.out.println(s2 == s3);       // true
        System.out.println(s1.equals(s2));  // true
        System.out.println(s1.equals(s3));  // true

这里如果再展开讲的话，就会涉及到String常量池与String.intern()等东西的细节。字符串本身就是一个复杂的话题，为了避免本文篇幅过长，应该专门另写一篇文章来记录了。