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的方式创建的新的字符串。 
 *  对象6 ：new String("ab")  // 31: invokevirtual #36   // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
 *  强调一下，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()可以节省内存空间。

更多JVM文章请访问我的JVM专栏：
https://blog.csdn.net/u011069294/category_10113093.html