如果你没有深度分析过的话，那么这可能是一个非常灵异的事件。
灵异事件一：
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() 方法，比较的就是值。
