53.String的intern()方法、new String()到底创建了几个对象、intern()面试难题
目录
1.intern方法解释
1.任意的字符串调用String.intern()方法，都会先去字符串常量池中寻找有没有相同的字符串，如果找到，则直接返回字符串常量池中的引用。
如果没有找到，JDK6和JDK7及以后的处理存在区别：
a)JDK6会直接复制一个String对象的副本放到常量池
b)JDK7及以后则是生成一个对原字符串对象的引用放在字符串常量池中。
2.new String()到底创建了几个对象
下面的Java代码创建了几个对象：
package jvm; /** * 题目： * new String("ab")会创建几个对象？看字节码，就知道是两个。 * 一个对象是：new关键字在堆空间创建的 * 另一个对象是：字符串常量池中的对象"ab"。 字节码指令：ldc，是从常量池中获取值 * * * 思考： * new String("a") + new String("b")呢？ * 对象1：new StringBuilder() * 对象2： new String("a") * 对象3： 常量池中的"a" * 对象4： new String("b") * 对象5： 常量池中的"b" * * 深入剖析： StringBuilder的toString(): * 对象6 ：new String("ab") * 强调一下，toString()的调用，在字符串常量池中，没有生成"ab" * */ public class StringNewTest { public static void main(String[] args) { String str = new String("ab"); // String str = new String("a") + new String("b"); } }
字节码分析：
1.注释掉// String str = new String("a") + new String("b");，使用javap -v -p StringNewTest反编译上面的java代码产生的class文件，得到下面的字节码输出：
可以看到，总共创建了两个对象，一个是new关键字在堆空间中创建出来的对象(0: new #16 // class java/lang/String)；另一个是字符串常量池中的对象(4: ldc #18 // String ab)。
值得注意的是：如果单独问String str = new String("ab");这句代码创建了几个对象，答案不一定是2个，也有可能是1个，因为字符串常量池中如果已经存在了字符串"ab"，是不会再创建的。这里是main函数的第一行代码，显然常量池中是不存在"ab"的，所以会创建。
Code: stack=3, locals=2, args_size=1 0: new #16 // class java/lang/String 3: dup 4: ldc #18 // String ab 6: invokespecial #20 // Method java/lang/String."<init>":(Ljava/lang/String;)V 9: astore_1 10: return
2.注释掉String str = new String("ab");，使用javap -v -p StringNewTest反编译上面的java代码产生的class文件，得到下面的字节码输出：
Code: stack=5, locals=2, args_size=1 0: new #16 // class java/lang/StringBuilder 3: dup 4: new #18 // class java/lang/String 7: dup 8: ldc #20 // String a 10: invokespecial #22 // Method java/lang/String."<init>":(Ljava/lang/String;)V 13: invokestatic #25 // Method java/lang/String.valueOf:(Ljava/lang/Object;)Ljava/lang/String; 16: invokespecial #29 // Method java/lang/StringBuilder."<init>":(Ljava/lang/String;)V 19: new #18 // class java/lang/String 22: dup 23: ldc #30 // String b 25: invokespecial #22 // Method java/lang/String."<init>":(Ljava/lang/String;)V 28: invokevirtual #32 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder; 31: invokevirtual #36 // Method java/lang/StringBuilder.toString:()Ljava/lang/String; 34: astore_1 35: return
可以看到总共创建了6个对象：
* 对象1：new StringBuilder() // 0: new #16 // class java/lang/StringBuilder * 对象2： new String("a") // 4: new #18 // class java/lang/String * 对象3： 常量池中的"a" // 8: ldc #20 // String a * 对象4： new String("b") // 19: new #18 // class java/lang/String * 对象5： 常量池中的"b" // 23: ldc #30 // String b * * 深入剖析： StringBuilder的toString(): 最后调用StringBuilder的toString方法，生成 * 新的字符串返回。toString方法底层使用的是new String的方式创建的新的字符串。 // 31: invokevirtual #36 // Method java/lang/StringBuilder.toString:()Ljava/lang/String; * 对象6 ：new String("ab") * 强调一下，toString()的调用，在字符串常量池中，没有生成字符串，因为字节码文件中没有看见ldc
3.intern()面试难题
1.如何保证变量String s指向的是字符串常量池中的数据呢？
有两种方式：
- 方式一：
String s = "shkstart";//字面量定义的方式 - 方式二： 调用
intern()方法
1)String s = new String("shkstart").intern();
2)String s = new StringBuilder("shkstart").toString().intern();
2.JDK6和JDK7及以上下面代码的输出是什么？
package jvm; public class StringIntern { public static void main(String[] args) { String s = new String("1");// 调用new，总共创建了两个对象，一个是通过new在堆空间中创建的对象；另一个是在字符串常量池中创建的对象。s指向的是堆空间中的对象 s.intern();//调用此方法之前，字符串常量池中已经存在了"1" String s2 = "1";// 由于字符串常量池中已经存在了"1"，所以s2直接指向了字符串常量池中的"1" System.out.println(s == s2);//jdk6：false jdk7/8：false 原因：s指向的是堆空间中的对象，s2指向的是字符串常量池中的对象，显然不相等 String s3 = new String("1") + new String("1");//s3变量记录的地址为堆空间中的对象"11", 因为最终调用的StringBuilder的toString方法的底层调用的是new String("11") //执行完上一行代码以后，字符串常量池中，是否存在"11"呢？答案：不存在！！（toString方法不在常量池中创建对象） s3.intern();//字符串常量池中不存在11，所以intern方法会在字符串常量池中生成"11"。 /*JDK6与JDK7及以上的intern()在字符串常量池中生成11的区别：*/ //jdk6:在字符串常量池中创建了一个新的对象"11",也就有新的地址。 //jdk7及以上:此时常量池中并没有创建"11",而是创建一个指向堆空间中new String("11")的地址，也就是s3指向的堆空间中的对象 String s4 = "11";//会先去常量池中找。s4变量记录的地址：使用的是上一行代码代码执行时，在常量池中生成的"11"的地址 System.out.println(s3 == s4);//jdk6：s3指向的是堆空间中new出来的对象，s4指向的是字符串常量池中创建的字符串的地址，所以结果为false jdk7/8：s3指向的还是堆空间中new出来的对象，s4的值是堆空间中new出来的是对象"11"的地址，所以为true } }
上面代码的图解：JDK6：字符串常量池在永久代。调用s3.intern()之后，会在字符串常量池生成一个字符串对象的拷贝。
JDK7及以上：字符串常量池在堆区。调用s3.intern()之后，会在字符串常量池生成一个对于堆区字符串对象的引用。
3.变型题
在JDK7及以上的环境下，下列代码的输出为？
public class StringIntern1 { public static void main(String[] args) { //StringIntern.java中练习的拓展： String s3 = new String("1") + new String("1");//new String("11") //执行完上一行代码以后，字符串常量池中，是否存在"11"呢？答案：不存在！！ String s4 = "11";//在字符串常量池中生成对象"11" String s5 = s3.intern();// 会将s3指向的对象的地址放到常量池中 System.out.println(s3 == s4);//false，因为s3指向的是堆空间中的对象，s4指向的是字符串常量池中的对象 System.out.println(s5 == s4);//true，s5最终也是指向的堆空间中的对象 } }
4.intern()总结
1.在JDK6中，调用String的intern()方法，如果字符串常量池中存在改字符串，则直接返回已有字符串的地址；如果没有，会把该字符串对象复制一份放到字符串常量池中，并返回对象地址。
2.在JDK7及以后中，调用String的intern()方法，如果字符串常量池中存在改字符串，则直接返回已有字符串的地址；如果没有，会把该字符串对象的引用地址复制一份放到字符串常量池中，并返回字符串常量池中的该引用地址。
5.intern()练习题
题1：下面代码在JDK6和JDK7及以上的输出为？
public class StringExer1 { public static void main(String[] args) { //String x = "ab"; String s = new String("a") + new String("b");//new String("ab") //在上一行代码执行完以后，字符串常量池中并没有"ab" String s2 = s.intern();//jdk6中：在串池中创建一个字符串"ab" //jdk8中：串池中没有创建字符串"ab",而是创建一个引用，指向new String("ab")，将此引用返回 System.out.println(s2 == "ab");//jdk6:true jdk8:true // 需要注意的是这里的"ab"并不会再去常量池中重新创建一个字符串变量。因为在常量池中"ab"已经存在(JDK6中复制的对象，是JDK7及以上，创建的堆空间中"ab"对象的引用)，为了节约空间，不会重新创建 System.out.println(s == "ab");//jdk6:false jdk8:true } }
上面代码的图解：JDK6中:
JDK7及以上：
如果打开//String x = "ab";的注释：
题2：下面代码的输出为？
public class StringExer2 { public static void main(String[] args) { String s1 = new String("ab");//执行完以后，会在字符串常量池中会生成"ab" // String s1 = new String("a") + new String("b");执行完以后，不会在字符串常量池中会生成"ab" s1.intern(); String s2 = "ab"; System.out.println(s1 == s2); // false, s1指向的是new出来的对象；s2指向的是常量池中的对象 } }
6.intern()空间效率
对于程序中大量存在存在的字符串，尤其其中存在很多重复字符串时，使用intern()可以节省内存空间。
