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