“+“ 的底层实现

1. 常量与常量的拼接结果在常量池，原理是编译期优化
2. 常量池中不会存在相同内容的变量
3. 拼接前后，只要其中有一个是变量，结果就在堆中。变量拼接的原理是StringBuilder
4. 如果拼接的结果调用intern()方法，根据该字符串是否在常量池中存在，分为：
   • 如果存在，则返回字符串在常量池中的地址
   • 如果字符串常量池中不存在该字符串，则在常量池中创建一份，并返回此对象的地址

1、常量与常量的拼接结果在常量池，原理是编译期优化

@Test
    public void test1(){
        String s1 = "a" + "b" + "c";//编译期优化：等同于"abc"
        String s2 = "abc"; //"abc"一定是放在字符串常量池中，将此地址赋给s2
        /*
         * 最终.java编译成.class,再执行.class
         * String s1 = "abc";
         * String s2 = "abc"
         */
        System.out.println(s1 == s2); //true
        System.out.println(s1.equals(s2)); //true
    }

2、拼接前后，只要其中有一个是变量，结果就在堆中

@Test
    public void test2(){
        String s1 = "javaEE";
        String s2 = "hadoop";

        String s3 = "javaEEhadoop";
        String s4 = "javaEE" + "hadoop";//编译期优化
        //如果拼接符号的前后出现了变量，则相当于在堆空间中new String()，具体的内容为拼接的结果：javaEEhadoop
        String s5 = s1 + "hadoop";
        String s6 = "javaEE" + s2;
        String s7 = s1 + s2;

        System.out.println(s3 == s4);//true
        System.out.println(s3 == s5);//false
        System.out.println(s3 == s6);//false
        System.out.println(s3 == s7);//false
        System.out.println(s5 == s6);//false
        System.out.println(s5 == s7);//false
        System.out.println(s6 == s7);//false
        //intern():判断字符串常量池中是否存在javaEEhadoop值，如果存在，则返回常量池中javaEEhadoop的地址；
        //如果字符串常量池中不存在javaEEhadoop，则在常量池中加载一份javaEEhadoop，并返回次对象的地址。
        String s8 = s6.intern();
        System.out.println(s3 == s8);//true
    }

从字节码角度来看：拼接前后有变量，都会使用到 StringBuilder 类

0 ldc #6 
2 astore_1
3 ldc #7 
5 astore_2
6 ldc #8 
8 astore_3
9 ldc #8 
11 astore 4
13 new #9 
16 dup
17 invokespecial #10 >
20 aload_1
21 invokevirtual #11 
24 ldc #7 
26 invokevirtual #11 
29 invokevirtual #12 
32 astore 5
34 new #9 
37 dup
38 invokespecial #10 >
41 ldc #6 
43 invokevirtual #11 
46 aload_2
47 invokevirtual #11 
50 invokevirtual #12 
53 astore 6
55 new #9 
58 dup
59 invokespecial #10 >
62 aload_1
63 invokevirtual #11 
66 aload_2
67 invokevirtual #11 
70 invokevirtual #12 
73 astore 7
75 getstatic #3 
78 aload_3
79 aload 4
81 if_acmpne 88 (+7)
84 iconst_1
85 goto 89 (+4)
88 iconst_0
89 invokevirtual #4 
92 getstatic #3 
95 aload_3
96 aload 5
98 if_acmpne 105 (+7)
101 iconst_1
102 goto 106 (+4)
105 iconst_0
106 invokevirtual #4 
109 getstatic #3 
112 aload_3
113 aload 6
115 if_acmpne 122 (+7)
118 iconst_1
119 goto 123 (+4)
122 iconst_0
123 invokevirtual #4 
126 getstatic #3 
129 aload_3
130 aload 7
132 if_acmpne 139 (+7)
135 iconst_1
136 goto 140 (+4)
139 iconst_0
140 invokevirtual #4 
143 getstatic #3 
146 aload 5
148 aload 6
150 if_acmpne 157 (+7)
153 iconst_1
154 goto 158 (+4)
157 iconst_0
158 invokevirtual #4 
161 getstatic #3 
164 aload 5
166 aload 7
168 if_acmpne 175 (+7)
171 iconst_1
172 goto 176 (+4)
175 iconst_0
176 invokevirtual #4 
179 getstatic #3 
182 aload 6
184 aload 7
186 if_acmpne 193 (+7)
189 iconst_1
190 goto 194 (+4)
193 iconst_0
194 invokevirtual #4 
197 aload 6
199 invokevirtual #13 
202 astore 8
204 getstatic #3 
207 aload_3
208 aload 8
210 if_acmpne 217 (+7)
213 iconst_1
214 goto 218 (+4)
217 iconst_0
218 invokevirtual #4 
221 return

字符串拼接的底层细节

@Test
public void test3(){
    String s1 = "a";
    String s2 = "b";
    String s3 = "ab";
    /*
    如下的s1 + s2 的执行细节：(变量s是我临时定义的）
    ① StringBuilder s = new StringBuilder();
    ② s.append("a")
    ③ s.append("b")
    ④ s.toString()  --> 约等于 new String("ab")，但不等价

    补充：在jdk5.0之后使用的是StringBuilder,在jdk5.0之前使用的是StringBuffer
     */
    String s4 = s1 + s2;//
    System.out.println(s3 == s4);//false
}

字节码指令：

0 ldc #14 
2 astore_1
3 ldc #15 
5 astore_2
6 ldc #16 
8 astore_3
9 new #9 
12 dup
13 invokespecial #10 >
16 aload_1
17 invokevirtual #11 
20 aload_2
21 invokevirtual #11 
24 invokevirtual #12 
27 astore 4
29 getstatic #3 
32 aload_3
33 aload 4
35 if_acmpne 42 (+7)
38 iconst_1
39 goto 43 (+4)
42 iconst_0
43 invokevirtual #4 
46 return

final修饰的情况：

/*
    1. 字符串拼接操作不一定使用的是StringBuilder!
       如果拼接符号左右两边都是字符串常量或常量引用，则仍然使用编译期优化，即非StringBuilder的方式。
    2. 针对于final修饰类、方法、基本数据类型、引用数据类型的量的结构时，能使用上final的时候建议使用上。
     */
    @Test
    public void test4(){
        final String s1 = "a";
        final String s2 = "b";
        String s3 = "ab";
        String s4 = s1 + s2;
        System.out.println(s3 == s4);//true
    }

字节码：

0 ldc #14 
2 astore_1
3 ldc #15 
5 astore_2
6 ldc #16 
8 astore_3
9 ldc #16 
11 astore 4
13 getstatic #3 
16 aload_3
17 aload 4
19 if_acmpne 26 (+7)
22 iconst_1
23 goto 27 (+4)
26 iconst_0
27 invokevirtual #4 
30 return

拼接操作与 append 操作的效率对比

    @Test
    public void test6(){

        long start = System.currentTimeMillis();

//        method1(100000);//4014
        method2(100000);//7

        long end = System.currentTimeMillis();

        System.out.println("花费的时间为：" + (end - start));
    }

    public void method1(int highLevel){
        String src = "";
        for(int i = 0;i < highLevel;i++){
            src = src + "a";//每次循环都会创建一个StringBuilder、String
        }
//        System.out.println(src);

    }

    public void method2(int highLevel){
        //只需要创建一个StringBuilder
        StringBuilder src = new StringBuilder();
        for (int i = 0; i < highLevel; i++) {
            src.append("a");
        }
//        System.out.println(src);
    }

1. 体会执行效率：通过StringBuilder的append()的方式添加字符串的效率要远高于使用String的字符串拼接方式！
2. 原因：
   1. StringBuilder的append()的方式：
      • 自始至终中只创建过一个StringBuilder的对象
   2. 使用String的字符串拼接方式：
      • 创建过多个StringBuilder和String（调的toString方法）的对象，内存占用更大；
      • 如果进行GC，需要花费额外的时间（在拼接的过程中产生的一些中间字符串可能永远也用不到，会产生大量垃圾字符串）。
3. 改进的空间：
   • 在实际开发中，如果基本确定要前前后后添加的字符串长度不高于某个限定值highLevel的情况下，建议使用构造器实例化：
   • StringBuilder s = new StringBuilder(highLevel); //new char[highLevel]
   • 这样可以避免频繁扩容