字符串拼接原理以及字符串常见面试题

第一种情况

　　　　/*
        * 第一种情况
        * 证明：是否在编译的时候完成拼接
        * */
        String str = "a" + "b";

常量池信息：

查看常量池信息必须通过 javap -v 命令来查看Class文件（java文件编译后的文件）

Constant pool:
   #1 = Methodref          #4.#20         // java/lang/Object."<init>":()V
   #2 = String             #21            // ab
   #3 = Class              #22            // com/test/StringTest2
   #4 = Class              #23            // java/lang/Object
   #5 = Utf8               <init>
   #6 = Utf8               ()V
   #7 = Utf8               Code
   #8 = Utf8               LineNumberTable
   #9 = Utf8               LocalVariableTable
  #10 = Utf8               this
  #11 = Utf8               Lcom/test/StringTest2;
  #12 = Utf8               main
  #13 = Utf8               ([Ljava/lang/String;)V
  #14 = Utf8               args
  #15 = Utf8               [Ljava/lang/String;
  #16 = Utf8               str
  #17 = Utf8               Ljava/lang/String;
  #18 = Utf8               SourceFile
  #19 = Utf8               StringTest2.java
  #20 = NameAndType        #5:#6          // "<init>":()V
  #21 = Utf8               ab
  #22 = Utf8               com/test/StringTest2
  #23 = Utf8               java/lang/Object

可以看到 #21 是字符串"ab"且没有单独的 "a" 和 "b"，说明String str = "a" + "b" 在编译时期就已经拼接在一块了，效果与 String str = "ab" 相同。

进一步说明，第一种情况只在字符串常量池中创建了一个"ab"对象，没有"a"对象和"b"对象。（类加载过程中Class文件的常量池内容会进入字符串常量池）。

第二种情况

      /*
        * 第二种情况
        * 证明：是否是在编译的时候完成拼接,如果不是,那么是按照什么方式进行的拼接。
        * */
        String str = "a";
        String str1 = "b";
        String str3 = str + str1;

常量池信息

Constant pool:
   #1 = Methodref          #9.#27         // java/lang/Object."<init>":()V
   #2 = String             #28            // a
   #3 = String             #29            // b
   #4 = Class              #30            // java/lang/StringBuilder
   #5 = Methodref          #4.#27         // java/lang/StringBuilder."<init>":()V
   #6 = Methodref          #4.#31         // java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
   #7 = Methodref          #4.#32         // java/lang/StringBuilder.toString:()Ljava/lang/String;
   #8 = Class              #33            // com/test/StringTest2
   #9 = Class              #34            // java/lang/Object
  #10 = Utf8               <init>
  #11 = Utf8               ()V
  #12 = Utf8               Code
  #13 = Utf8               LineNumberTable
  #14 = Utf8               LocalVariableTable
  #15 = Utf8               this
  #16 = Utf8               Lcom/test/StringTest2;
  #17 = Utf8               main
  #18 = Utf8               ([Ljava/lang/String;)V
  #19 = Utf8               args
  #20 = Utf8               [Ljava/lang/String;
  #21 = Utf8               str
  #22 = Utf8               Ljava/lang/String;
  #23 = Utf8               str1
  #24 = Utf8               str3
  #25 = Utf8               SourceFile
  #26 = Utf8               StringTest2.java
  #27 = NameAndType        #10:#11        // "<init>":()V
  #28 = Utf8               a
  #29 = Utf8               b
  #30 = Utf8               java/lang/StringBuilder
  #31 = NameAndType        #35:#36        // append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
  #32 = NameAndType        #37:#38        // toString:()Ljava/lang/String;
  #33 = Utf8               com/test/StringTest2
  #34 = Utf8               java/lang/Object
  #35 = Utf8               append
  #36 = Utf8               (Ljava/lang/String;)Ljava/lang/StringBuilder;
  #37 = Utf8               toString
  #38 = Utf8               ()Ljava/lang/String;

从常量池中我们可以看到 #28 和 #29 分别为字符串 "a" 和 "b"，并且不存在字符串 "ab"，所以可以排除第二种情况是在编译期完成的拼接。

那么不是编译器完成拼接那么是通过什么方式进行拼接的呢？我们可以通过查看反汇编指令，来进一步了解拼接的执行过程。

反汇编指令可以通过 javap -v 或者 java -c 查看Class文件（java编译后的文件）得到。

stack=2, locals=4, args_size=1
         0: ldc           #2                  // String a
         2: astore_1
         3: ldc           #3                  // String b
         5: astore_2
         6: new           #4                  // class java/lang/StringBuilder
         9: dup
        10: invokespecial #5                  // Method java/lang/StringBuilder."<init>":()V
        13: aload_1
        14: invokevirtual #6                  // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
        17: aload_2
        18: invokevirtual #6                  // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
        21: invokevirtual #7                  // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
        24: astore_3
        25: return

反汇编指令详解可以百度，这里不做过多解释

我们可以看到 第6行new了一个StringBuilder对象，之后执行了两次append()方法，把字符串 "a" 和 "b" 拼接到一块，然后通过StringBuilder.toString()方法返回一个String对象，该String 对象就是完成拼接后的对象。

这也意味着，通过这种方式将来在类加载的过程字符串常量池中只会保存 "a" 和 "b" 这两个对象，而没有保存 "ab" 这个对象。

当然从编译角度看，编译时期无法识别变量的具体值的，所以 "ab" 这个字符串自然也不会保存到Class文件的常量池中。

这里再提一点：StringBuilder.toString()方法返回的是一个拼接后的String对象，如果字符串很长的时候，尽量不要多次使用StringBuilder.toString()方法,否则会浪费空间甚至造成内存溢出。 

第三种情况

　　　　/*
        * 第三种情况
        * 与第二种差不多
        * */
        String str = new String("a") + new String("b");

常量池：

Constant pool:
   #1 = Methodref          #11.#27        // java/lang/Object."<init>":()V
   #2 = Class              #28            // java/lang/StringBuilder
   #3 = Methodref          #2.#27         // java/lang/StringBuilder."<init>":()V
   #4 = Class              #29            // java/lang/String
   #5 = String             #30            // a
   #6 = Methodref          #4.#31         // java/lang/String."<init>":(Ljava/lang/String;)V
   #7 = Methodref          #2.#32         // java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
   #8 = String             #33            // b
   #9 = Methodref          #2.#34         // java/lang/StringBuilder.toString:()Ljava/lang/String;
  #10 = Class              #35            // com/test/StringTest2
  #11 = Class              #36            // java/lang/Object
  #12 = Utf8               <init>
  #13 = Utf8               ()V
  #14 = Utf8               Code
  #15 = Utf8               LineNumberTable
  #16 = Utf8               LocalVariableTable
  #17 = Utf8               this
  #18 = Utf8               Lcom/test/StringTest2;
  #19 = Utf8               main
  #20 = Utf8               ([Ljava/lang/String;)V
  #21 = Utf8               args
  #22 = Utf8               [Ljava/lang/String;
  #23 = Utf8               str
  #24 = Utf8               Ljava/lang/String;
  #25 = Utf8               SourceFile
  #26 = Utf8               StringTest2.java
  #27 = NameAndType        #12:#13        // "<init>":()V
  #28 = Utf8               java/lang/StringBuilder
  #29 = Utf8               java/lang/String
  #30 = Utf8               a
  #31 = NameAndType        #12:#37        // "<init>":(Ljava/lang/String;)V
  #32 = NameAndType        #38:#39        // append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
  #33 = Utf8               b
  #34 = NameAndType        #40:#41        // toString:()Ljava/lang/String;
  #35 = Utf8               com/test/StringTest2
  #36 = Utf8               java/lang/Object
  #37 = Utf8               (Ljava/lang/String;)V
  #38 = Utf8               append
  #39 = Utf8               (Ljava/lang/String;)Ljava/lang/StringBuilder;
  #40 = Utf8               toString
  #41 = Utf8               ()Ljava/lang/String;

反汇编

   Code:
      stack=4, locals=2, args_size=1
         0: new           #2                  // class java/lang/StringBuilder
         3: dup
         4: invokespecial #3                  // Method java/lang/StringBuilder."<init>":()V
         7: new           #4                  // class java/lang/String
        10: dup
        11: ldc           #5                  // String a
        13: invokespecial #6                  // Method java/lang/String."<init>":(Ljava/lang/String;)V
        16: invokevirtual #7                  // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
        19: new           #4                  // class java/lang/String
        22: dup
        23: ldc           #8                  // String b
        25: invokespecial #6                  // Method java/lang/String."<init>":(Ljava/lang/String;)V
        28: invokevirtual #7                  // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
        31: invokevirtual #9                  // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
        34: astore_1
        35: return

第三种情况和第二种情况不同点：第三种情况会在堆里面多创建两个对象，其它的都一样

———————————————————————————————————————————————————————————————————————————————————————————————————

下面再介绍一下String类型的intern()方法，在jdk1.8中 intern()方法会先去判断字符串常量池中是否存在想要查找的字符串对象，如果存在则返回字符串常量池中对象的地址；如果不存在则返回当前对象（谁调用这个方法，谁就是当前对象）的引用，并且在字符串常量池中创建指向当前对象的引用。注：jdk 1.6与jdk1.8有所不同，有兴趣的可以了解下jdk1.6的intern()方法。

举个例子：

        String str = new String("ab");
        System.out.println(str.intern()==str);    //false
        String str1 = new String("c") + new String("d");
        System.out.println(str1.intern()==str1);  //true    

第一种情况，会同时在字符串常量池和堆空间中各生成一个对象，所以str.intern返回的是字符串常量池中 "ab" 的地址,str返回的是堆空间中 "ab" 的地址。

第二种情况，只会在堆空间中生成一个对象，所以str1.intern()返回的是str1对象即堆空间对象的地址，并且会在字符串常量池中创建一个指向堆空间对象的引用。

那么也就是说，如果创建一个引用指向 "cd"，比如 String str2 = "cd"，那么str1.intern()==str2 也是成立的，但第一种情况就不成立。

面试题：

        String str = new String("ab");
        String str1 = new String("ab");
        String str2 = "ab";
        String str3 = "ab";
        System.out.println(str==str1);  //false
        System.out.println(str2==str3);  //true
        System.out.println(str2==str);  //false
        System.out.println(str.intern()==str2); //true
        System.out.println(str.intern()==str1.intern());  //true    

        String str = "a";
        String str1 = "b";
        String str2 = str1 + str;
        String str3 = str2.intern();
        String str4 = "ab";
        System.out.println(str2==str4); //false
        System.out.println(str3==str4); //false 因为java文件中含有"ab"字符串，所以编译成Class文件后,常量池会包含 "ab"

　　　　　//问：创建几个对象
        //答：最明显的字符串常量池分别创建了 “a”和"b",堆空间创建了 "a"和"b",然后字符串拼接会创建StringBuilder对象,
        // StringBuilder对象会调用toString()方法产生拼接后的String对象,所以总共创建了6个对象
        String str = new String("a") + new String("b");

如果有大佬发现不正确的地方，欢迎指正，我会第一时间修改。