Java的==和equals()的区别-个人总结

一、写这个原因

看了网上很多文章，写的很乱，干脆自己总结了下。

二、== 和 equals()意义

2.1 == 运算符

在《java核心技术卷 1》中将 == 归类于关系运算符；
== 常用于相同的基本数据类型之间的比较，也可用于相同类型的对象之间的比较；

1. 如果 == 比较的是基本数据类型，那么比较的是两个基本数据类型的值是否相等；
2. 如果 == 是比较的两个对象，那么比较的是两个对象的引用，也就是两个对象是否为同一个对象，并不是比较的对象的内容；

2.2 equals()方法

在《java核心技术卷 1》中对 Object 类的描述：Object 类是java中所有类的始祖，在java中每个类都是由Object类扩展而来；每个类都默认继承Object类，所以每一个类都有Object类中的方法；从而每一个类都有equals方法；

1. equals方法主要用于两个对象之间，检测一个对象是否等于另一个对象；

2. equals方法在Object的代码如下，在代码上可以看出Object的实现类里面equals方法其实也是 == 的关系运算符。

所以问题的关键就是将 == 运算符说明白就好了。

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

三、== 运算符见解与例子

3.1 个人见解

== 运算符是比较栈上数据是否相等，比如基础类型的数据和对象的引用地址都是栈上的数据。

3.2 例子

3.2.1 基础数据类型

代码例子

public void basicDataTest(){
        int intValue1 = 188;
        int intValue2 = 188;
        float floatValue1 = 188;
        char charValue1 = 188;
        System.out.println(intValue1 == intValue2);
        System.out.println(intValue1 == floatValue1);
        System.out.println(intValue1 == charValue1);
    }

结果

true
true
true

3.2.2 引用类型

代码例子

public void yinYongDataTest(){
        Object obj1 = new Object();
        Object obj2 = new Object();
        Object obj3 = obj1;

        System.out.println(obj1 == obj2);
        System.out.println(obj1 == obj3);
    }

结果

false
true

3.2.3 基础类型和引用类型

代码例子

public class MyTestMain {

    public static void main(String[] args) {
        Integer integer1 = new Integer(1024);
        int intValue1 = 1024;

        boolean b = integer1 == intValue1;
        System.out.println(b);
    }
}

结果

true

代码反编译

public class top.san.es.MyTestMain {
  public top.san.es.MyTestMain();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."":()V
       4: return

  public static void main(java.lang.String[]);
    Code:
       0: new           #2                  // class java/lang/Integer
       3: dup
       4: sipush        1024
       7: invokespecial #3                  // Method java/lang/Integer."":(I)V
      10: astore_1
      11: sipush        1024
      14: istore_2
      15: aload_1
      16: invokevirtual #4                  // Method java/lang/Integer.intValue:()I
      19: iload_2
      20: if_icmpne     27
      23: iconst_1
      24: goto          28
      27: iconst_0
      28: istore_3
      29: getstatic     #5                  // Field java/lang/System.out:Ljava/io/PrintStream;
      32: iload_3
      33: invokevirtual #6                  // Method java/io/PrintStream.println:(Z)V
      36: return
}

3.3 结果分析

通过过3.2.1和3.2.2的例子是支持基础类型的数据和对象的引用地址都是栈上的数据 这个结论的。但是3.2.3这个例子需要反编译分析,通过反编译可以看到第16行指令就是做一个拆箱操作，其实就是基本类型（int）和对象类型（Integer）做比较时会有一个对象类型拆箱的一个过程，然后两者都已基本类型进行比较了。

四、equals()方法总结与例子

4.1 总结

上述展示了equals方法在Object中实现，内部就是一个 == 运算符，又因为只有引用类型才有 equals 方法，所以在对于所有未重写equals方法的类的对象调用equals方法，都是比较其所在的堆内存地址（栈上存的值）是否一致。
但是Java中很多类都重写了equals方法，所以对于重写了equals方法的类，其对象调用equals方法时都需要根据其内部实现而定。

4.2 常见重写equals方法的java类

4.2.1 String

1. 重写实现代码

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

2. 例子

代码

public void stringDataTest() {
        String str1 = new String("hello");
        String str2 = new String("hello");
        String str3 = str1;
        String str4 = "hello";

        System.out.println(str1.equals(str2));
        System.out.println(str1.equals(str3));
        System.out.println(str1.equals(str4));

        System.out.println(str1 == str2);
        System.out.println(str1 == str4);
    }

结果

true
true
true
false
false

3. 分析
   String 的 equals方法的源码很简单，就是先比较栈上指向的内存地址是否一致，然后再去比价其内部对应的字符串值。例子的前三个输出都是支持这一结论的。第四和五个输出说明了使用==运算符去做比较，只是比较了其栈上的内存地址。

4.2.2 基本类型的各个包装类

4.2.2.1 Integer

1. 源码

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

2. 例子
   代码

 public void integerDataTest() {
        Integer integer1 = new Integer(1024);
        Integer integer2 = new Integer(1024);
        Integer integer3 = integer1;
        Integer integer4 = 1024;

        System.out.println(integer1.equals(integer2));
        System.out.println(integer1.equals(integer3));
        System.out.println(integer1.equals(integer4));
    }

结果

true
true
true

3. 分析
   Integer的equals方法重写实现就是做了其成员属性的value（int）的 == 运算符，也就是基本类型的值的比较，例子输出都是支持结论的。

4.2.2.2 Character

1. 源码

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

4.2.2.3 Boolean

1. 源码

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

4.2.2.4 Short

1. 源码

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

4.2.2.5 Byte

1. 源码

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

4.2.2.6 Long

1. 源码

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

4.2.2.7 Float

1. 源码

   public boolean equals(Object obj) {
        return (obj instanceof Float)
               && (floatToIntBits(((Float)obj).value) == floatToIntBits(value));
    }

4.2.2.8 Double

1. 源码

      public boolean equals(Object obj) {
        return (obj instanceof Double)
               && (doubleToLongBits(((Double)obj).value) ==
                      doubleToLongBits(value));
    }

五、 基本类型包装类的初始缓存 （需要额外注意）

所有的包装类型都有一个初始缓存，这里Integer为例子。

1. 代码

public void integerDataTest() {
        Integer integer1 = new Integer(10);
        Integer integer2 = new Integer(10);

        Integer integer3 = 10;
        Integer integer4 = 10;

        Integer integer5 = 128;
        Integer integer6 = 128;


        System.out.println(integer1 == integer2);
        System.out.println(integer1.equals(integer2));
        System.out.println(integer3 == integer4);
        System.out.println(integer5 == integer6);
    }

2. 结果

false
true
true
false

3. 分析

• 第一个结果为false，是因为integer1和integer2是两个不同的对象，都是运行时自己调用Integer的构造方法实例化出来，两个对象 == 比较的是对象所在的堆地址，肯定是不等的。
• 第二个结果为true，是因为两个Integer调用来equals方法来比较时，参考4.2.2.1的源码例子，可以知道这个操作会来比较其值是否相等，明显是相等的。
• 第三个结果为true，是因为Integer3和Integer4是通过Integer的自动包装方法获取到的对象的，参考下面的源码，可以知道valueOf方法会先判断是否获取能获取到初始缓存的Integer对象，这个初始缓存的Integer对象，参考IntegerCache类可以知道是会初始-128～127数值范围的Integer对象。
  所以integer3和Integer4都是在 -128～127之间，所有其获得的对象都是初始的缓存对象，又因为它们的值是一样的，所有它们得到的对象是同一个。故这时其使用 == 比较，其对象堆地址是一样的，所以相等。
• 第四个结果为false，是因为integer5和integer6也是通过valueOf方法进行自动包装的，但是注意128已经不在 -128～127的范围了，所以integer5和integer6都是被new出来的不同的对象，所以使用 == 比较对象堆地址是不一样的。

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内部一个静态内部类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() {}
    }