Java基础——字符串常量池遇到的坑

原来学java的时候，这块就没怎么看，最近学多线程稍微仔细看了一下，遇到不少疑惑。

问题一：String str1 = new String("abc"); 到底创建了几个对象？

一般的回答

2个，一个是在堆中new的String("abc")对象，一个是字符串常量池创建的"abc"。

更严谨的说法

1. 严谨的问法：

• String str1 = new String("abc"); 运行时（包括类加载和程序执行）涉及几个String实例？

1. 回答

• 2个。一个是字符串字面量"abc"对应的，驻留在字符串常量池的实例（类加载时创建）；一个是new String("abc")在堆中创建的，内容和"abc"相同的实例（程序运行时）

hide code

	Code:
	stack=3, locals=2, args_size=1
	0: new #2 // class java/lang/String
	3: dup
	4: ldc #3 // String abc
	6: invokespecial #4 // Method java/lang/String."":(Ljava/lang/String;)V
	9: astore_1
	10: return

可以看到只有一个new，在堆中创建了String对象（Code:0:new）,
"abc"字面量实例在常量池中已经存在，所以只是把先前类加载中创建好的String("abc")实例的一个引用压入操作栈顶，并没有创建String对象。(Code:4:ldc)

问题二：String str1 = new String("A"+"B"); 在字符串常量池中创建几个实例？

错误的回答

• 3个。"A"、"B"、"AB"。

正确的回答

• 1个。只有"AB"。

查看字符串常量池：
方法:javap -verbose XXX.class

hide code

	Constant pool:
	#1 = Methodref #6.#15 // java/lang/Object."":()V
	#2 = Class #16 // java/lang/String
	#3 = String #17 // AB
	#4 = Methodref #2.#18 // java/lang/String."":(Ljava/lang/String;)V
	#5 = Class #19 // Test7
	#6 = Class #20 // java/lang/Object
	#7 = Utf8
	#8 = Utf8 ()V
	#9 = Utf8 Code
	#10 = Utf8 LineNumberTable
	#11 = Utf8 main
	#12 = Utf8 ([Ljava/lang/String;)V
	#13 = Utf8 SourceFile
	#14 = Utf8 Test7.java
	#15 = NameAndType #7:#8 // "":()V
	#16 = Utf8 java/lang/String
	#17 = Utf8 AB
	#18 = NameAndType #7:#21 // "":(Ljava/lang/String;)V
	#19 = Utf8 Test7
	#20 = Utf8 java/lang/Object
	#21 = Utf8 (Ljava/lang/String;)V

可以看到只有一个"AB"。
也可以通过字节码看到：

hide code

	Code:
	stack=3, locals=2, args_size=1
	0: new #2 // class java/lang/String
	3: dup
	4: ldc #3 // String AB
	6: invokespecial #4 // Method java/lang/String."":(Ljava/lang/String;)V
	9: astore_1
	10: return

只有一个的原因

• 编译时优化，会把"A"和"B"合并成一个"AB"保留到常量池。

问题三：String str1 = new String("ABC") + "ABC"; 在字符串常量池中创建几个实例？

错误的回答

• 2个。"ABC"和"ABCABC"。

正确的回答

• 1个。只有"ABC"。

hide code

	Code:
	stack=4, locals=2, args_size=1
	0: new #2 // class java/lang/StringBuilder
	3: dup
	4: invokespecial #3 // Method java/lang/StringBuilder."":()V
	7: new #4 // class java/lang/String
	10: dup
	11: ldc #5 // String ABC
	13: invokespecial #6 // Method java/lang/String."":(Ljava/lang/String;)V
	16: invokevirtual #7 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
	19: ldc #5 // String ABC
	21: invokevirtual #7 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
	24: invokevirtual #8 // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
	27: astore_1
	28: return

实际是创建了一个StringBuilder对象（Code:0:new）,然后又创建了一个String对象（Code:7:new），
接着把已经驻留在常量池中的"ABC"压入操作栈(Code:11:ldc)，调用append方法。（重复1次）。
最后调用toString方法获得合并后的String对象。
也就是说创建了2个对象，在常量池中驻留了一个"ABC"字面量实例。

在问题三的基础上，添上intern()方法会不会在常量池中创建"ABCABC"实例？

答案

不会。

hide code

	public class Test {
	public static void main(String[] args) {
	String str1 = new String("ABC") + "ABC";
	System.out.println(str1.intern() == str1);
	}
	}

结果是true，可见并没有在常量池中创建"ABCABC"字面量实例。

intern()方法

• 如果在常量池当中没有字符串的引用，那么就会生成一个在常量池当中的引用，否则直接返回常量池中字符串引用。

分析上面的代码：

hide code

	public class Test {
	public static void main(String[] args) {
	String str1 = new String("ABC") + "ABC"; //str1指向堆中合并后的String("ABCABC")对象
	System.out.println(str1.intern() == str1); //intern()方法：在常量池中找不到“ABCABC”这个常量对象（问题三已经说明），所以生成常量引用，和堆中那个对象的地址相同，也就是str1
	}
	}

• 把代码稍作修改，intern()方法能找到"ABCABC"常量对象吗？

hide code

	public class Test {
	public static void main(String[] args) {
	String str1 = new String("ABC") + "ABC";
	System.out.println(str1.intern() == str1);
	String str2 = "ABCABC";
	System.out.println(str1 == str2);
	}
	}

结果是

hide code

	true
	true

也就是说intern()方法仍然找不到"ABCABC"常量对象，并且str2随后在常量池中找到了"ABCABC"的引用，所以str1和str2都指向了一开始堆中合并后的String("ABCABC")对象。

• 换一种写法，让intern()方法找到"ABCABC"常量对象
  把String str2 = "ABCABC";移动到第一行：

hide code

	public class Test {
	public static void main(String[] args) {
	String str2 = "ABCABC";
	String str1 = new String("ABC") + "ABC";
	System.out.println(str1.intern() == str1);
	System.out.println(str1 == str2);
	}
	}

结果是：

hide code

	false
	false

原因：

hide code

	public class Test {
	public static void main(String[] args) {
	String str2 = "ABCABC"; //在常量池创建了"ABCABC"字面量实例，str2指向该实例
	String str1 = new String("ABC") + "ABC"; //在堆中得到一个合并的String("ABCABC")对象，str1指向它
	System.out.println(str1.intern() == str1); //intern()方法在常量池能找到"ABCABC"常量对象，直接返回它的引用，也就是str2，所以str1.intern() != str1
	System.out.println(str1 == str2); //str1.intern()和str2指向同一个对象，str1和str2指向不同对象
	}
	}

总结

网络上有很多人写博客，但是良莠不齐，有的写的很误导人，而且可能有错误，不认真思考的话很容易掉坑里。
希望大家保持质疑的态度，多动手多思考，不要人云亦云。