1. 先从一道面试题说起
请问下面的
public class Demo {
public static void main(String args[]){
String a = "a" + "b" + 1;
String b = "ab1";
System.out.println(a == b);
}
}
要了解这个问题，需要回答下面的几个问题：
- 关于“ ==”是做什么的？
- equals 呢？
- a和b在内存中是什么样的？
- 编译时优化方案。
2. 关于==
在Java语言中，“”就是对比两个内存单元的内容是否一样。
如果是原始类型byte，boolean，short，char，int，long，float，double，就是直接比较它们的值。
如果是引用，比较的就是引用的值，“引用的值”可以被认为对象的逻辑地址。如果两个引用发生“”操作，就是比较相应的两个对象的地址值是否一样。换句话说，如果两个引用所保存的对象是同一个对象，则返回true，否则返回false（如果引用指向的是null，其实这也是一个jvm赋予给它的某个指定的值）。
看下面的代码：
public class Demo {
public static void main(String args[]){
List<String> a = null;
List<String> b = null;
System.out.println(a == b);
}
}
// 输出结果
true
3. 关于“equals()”方法
“equals()”方法，首先是在Object类中被定义的，它的定义中就是使用“==”方式来匹配的。
//equals在Object类中的源码
public boolean equals(Object obj) {
return (this == obj);
}
也就是说，如果不去重写equals()方法，并且对应的类其父类中没有重写过equals()方法，那么默认的equals()操作就是对比对象的地址。
equals()方法之所以存在，是希望子类去重写这个方法，实现对比值的功能。
3. a和b在内存中是什么样的？
a和b在内存中是指向同一块内存空间的。这就得益于Java的编译时优化方案。
我们用反编译软件jd-gui看看编译后的代码是怎么样的？
import java.io.PrintStream;
public class Demo
{
public static void main(String[] args)
{
String a = "ab1";
String b = "ab1";
System.out.println(a == b);
}
}
看到这里结果应该就一目了然了。JVM会把常量叠加在编译时进行优化，因为常量叠加得到的是固定的值，无须运行时再进行计算，所以会这样优化。
看到这里别着急，JVM只会优化它可以帮你优化的部分，它并不是对所有的内容都可以优化。例如，就拿上面叠加字符串来说，如果几个字符串叠加出现了变量，即在编译时还不确定具体的值是多少，那么JVM是不会去做这样的编译时合并的。
如果上面的这段话你理解了，我们再来看一个例子：
public class Demo {
public static void main(String args[]){
String a = "a";
final String c ="a";
String b = a + "b";
String d = c + "b";
String e = getA() + "b";
String compare = "ab";
System.out.println( b == compare);
System.out.println( d == compare);
System.out.println( e == compare);
}
private static String getA(){
return "a";
}
}
//输出结果：
false
true
false
根据我们上面的解释，判断bcompare和ecompare输出结果为false，这个比较容易理解，因为a和getA()并不是一个常量，编译时并不会对此进行优化，我们用jd-gui可靠编译后的代码：
import java.io.PrintStream;
public class Demo
{
public static void main(String[] args)
{
String a = "a";
String c = "a";
String b = a + "b";
String d = "ab";
String e = getA() + "b";
String compare = "ab";
System.out.println(b == compare);
System.out.println(d == compare);
System.out.println(e == compare);
}
private static String getA()
{
return "a";
}
}
从编译后的代码，我们可以验证我们的结论，b和e并没有被JVM优化。
比较奇怪的是变量d，被JVM优化了。区别在于对叠加的变量c有一个final修饰符。从定义上强制约束了c是不允许被改变的，由于final不可变，所以编译器自然认为结果是不可变的。
4. 内存中的字符串（详细解释）
字符串对象内部是用字符数组存储的，那么看下面的例子：
String m = "hello,world";
String n = "hello,world";
String u = new String(m);
String v = new String("hello,world");
这些语句会发生什么事情？大概是这样的：
- 会分配一个11长度的char数组，并在常量池分配一个由这个char数组组成的字符串，然后由m去引用这个字符串。
- 用n去引用常量池里边的字符串，所以和m引用的是同一个对象
- 生成一个新的字符串，单内部的字符数组引用着m内部的字符数组。
- 同样会生成一个新的字符串，但内部的字符数组引用常量池里边的字符串内部的字符数组，意思是和u是同样的字符数组。
我们使用图来表示的话，情况就大概是这样的：
结论就是，m和n是同一个对象，但m，u，v都是不同的对象，但都使用了同样的字符数组，并且用equal判断的话也会返回true。
我们可以使用反射修改字符数组来验证一下效果：
public class Demo {
public static void main(String args[]) throws NoSuchFieldException, IllegalAccessException {
String m = "hello,world";
String n = "hello,world";
String u = new String(m);
String v = new String("hello,world");
Field f = m.getClass().getDeclaredField("value");
f.setAccessible(true);
char[] cs = (char[]) f.get(m);
cs[0] = 'H';
String p = "Hello,world";
System.out.println(m.equals(p));
System.out.println(n.equals(p));
System.out.println(u.equals(p));
System.out.println(v.equals(p));
}
}
//输出结果：
true
true
true
true
从上面的例子可以看到，经常说的字符串是不可变的，其实和其他final类没有什么区别，还是引用不可变的意思。虽然String类不开放value，但同样是可以通过反射进行修改。
5. 关于String中的intern方法
public class Demo {
public static void main(String args[]){
String a = "a";
String b = a + "b";
String c = "ab";
String d = new String(b);
System.out.println(b == c);
System.out.println(c == d);
System.out.println(c == d.intern());
System.out.println(b.intern() == d.intern());
}
}
//输出结果
false
false
true
true
String引用所指向的对象，它们存储在常量池中，同一个值的字符串保证全局唯一。
如何保证全局唯一呢？ 当调用intern()方法时，JVM会在这个常量池中通过equals()方法查找是否存在等值的String，如果存在，则直接返回常量池中这个String对象的地址；若没有找到，则会创建等值的字符串，然后再返回这个新创建空间的地址。只要是同样的字符串，当调用intern()方法时，都会得到常量池中对应String的引用，所以两个字符串通过intern()操作后用等号是可以匹配的。