深度浅析 == 和 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() 方法，比较的就是值。