深度浅析 == 和 equals 的区别

如果你没有深度分析过的话，那么这可能是一个非常灵异的事件。

灵异事件一：

        Integer a = 111;  // 相当于 Integer a = Integer.valueOf(111);        Integer b = 111;        Integer c = 1111;        Integer d = 1111;        int e = 11111;        int f = 11111;        System.out.println(a==b);  // true        System.out.println(c==d);  // false        System.out.println(e==f);  // true

灵异事件二：

        double a = 1.0;        double b = 1.0;        Double c = 1.0;        Double d = 1.0;        System.out.println(a==b);  // true        System.out.println(c==d);  // false

灵异事件三：

        Character a = 'A';        Character b = 'A';        Character c = '√';        Character d = '√';        System.out.println(a==b);  // true        System.out.println(c==d);  // false

灵异事件四：

        String a = "abc";        String b = "abc";        String c = new String("abc");        String d = String.valueOf("abc");        System.out.println(a==b);  // true        System.out.println(b==c);  // false        System.out.println(b==d);  // true        System.out.println(c==d);  // false

NO.1 “==”

总所周知，== 就是比较两个变量所指向的地址和值是否一样（当然指向的地址相等，那么值也必然相等）。当然如果是基本数据类型的比较的话，值相等，就返回 true

所以，想要弄清楚这些灵异事件，我们有必要了解一下它们在内存中的存放以及实现的源码。

基本数据类型之间的比较

Q：int e = 1111; int f = 1111; 分别在内存中做了什么事情？

A：①、int e = 1111； 在栈内存中定义了一个变量 e，然后这个变量去栈内存中找 1111，结果可想而知（没有找到，因为前面没有定义），于是就把这个 1111 加入到栈内存中；

②、int f = 1111 ; 此时呢，又在栈内存中定义了一个变量 f，然后这个变量又去栈内存中找 1111，结果找到了（因为前面 int e = 1111 时，放进去了），于是就指向 1111。

所以：e == f 为 true

引用数据类型之间的比较

注：以下内容解密灵异事件 1~3

主要看引用数据类型源码中对自动装箱方法（valueOf）的具体实现，对其实现过程进行分析。

Q：Integer a = 111; Integer b = 111; 做了什么事？
A：这里涉及到了自动装箱的过程。相当于调用 Integer.valueOf(int); 方法

查看一下 Integer.valueOf(int) 的源码：

    public static Integer valueOf(int i) {        // 如果 -128 <= i <= 127，就返回缓存中的对象        if (i >= IntegerCache.low && i <= IntegerCache.high)            return IntegerCache.cache[i + (-IntegerCache.low)];        return new Integer(i);    }

所以，变量 a、b 都是指向缓存中的同一个对象。a==b 为 true

然而变量 c、d 由于超过了 [-128-127] 的缓存范围，所以会在堆内存中，分别创建新的 Integer 对象。所以 c == d 为 false。

重点如下：

注：这里直接给出结论（可自行去查阅各个封装类自动封装的 valueOf 方法）
Boolean：直接比较值；Byte：全部找缓存；
Character：ascii码值 <= 127 的去找缓存；
Short、Long、Integer： [-128,127] 区间的值，找缓存；
Float、Double：不找缓存，直接创建新对象

对于 Stirng 类型（针对灵异事件四）
String 也提供了缓存机制（常量池）；

Q：String a = “abc”;String b = “abc”; String c = new String(“abc”); 分别做了什么事？

A：①、String a = “abc”; 在栈内存中定义了一个变量 a，然后去常量池中找 “abc”，如果没有找到，则将 “abc”，存放到常量池中；

②、String b = “abc”; 又栈内存中定义了一个变量 b，然后又去常量池中找 “abc” ，结果找到了，然后就变量 b 引用常量池中的 “abc”。

③、String c = new String(“abc”); 又栈内存中定义了一个变量 c，然后又去常量池中找 “abc”，
i、如果找到，那么只需在堆内存中 new 一个 String 对象，将常量池中 “abc” 引用传进去；
ii、如果没有找到，则创建一个对象 “abc” 存入常量池中，然后在堆内存中创建一个对象，并将常量池中 “abc” 引用传进去；

所以 a == b 为 true；a == c && b == c 为 false

针对：String d = String.valueOf(“abc”); ，我们查看源码来解密。

    public static String valueOf(Object obj) {        // 调用 String 类本身的 toString() 方法，返回本身        return (obj == null) ? "null" : obj.toString();    }    public String toString() {        return this;    }

所以此处变量 d 是指向常量池中的 “abc”，那么 a == d 为 true。

NO.2 “equals”

总所周知，Object 是所有类的父类，也就是说，要么调用的是 Object 的 equals() 方法，要么调用的就是该类重写的 equals() 方法。

Object.equlas()：返回的是 == 的比较结果（地址和值的比较）

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

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

结论

①、== 比较的是比较两个变量所指向的地址和值是否一样；基本数据类型比较的是值。
②、Object.equals()：返回的是 == 的比较结果（地址和值的比较）；
③、其他重写了 equals() 方法的：需要查看具体实现。比如 String 重写的 equals() 方法，比较的就是值。