知行合一，止于至善
千里之行，始于足下；合抱之木，生于毫末；九层之台，起于累土从字节码角度看String的连接操作
假设有如下的示例代码
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 |
public class TestString { private static final String welcome = "welcome"; private static final String to = " to"; private static final String javacoder = " javacoder"; private static final String cn = ".cn"; /** * 使用'+'链式操作 */ public String test1() { String s1 = welcome + to + javacoder + cn; return s1; } /** * 使用非链式操作 */ public String test2() { String s1 = welcome + to; s1 += javacoder; s1 += cn; return s1; } /** * 对传入的参数进程连接操作 */ public String test3(String welcome, String to, String javacoder, String cn) { String s1 = welcome + to + javacoder + cn; return s1; } /** * 完全不用链式操作 */ public String test4() { StringBuffer sb = new StringBuffer(); sb.append(welcome); sb.append(to); sb.append(javacoder); sb.append(cn); return sb.toString(); } /** * 完全使用链式操作 */ public String test5() { return new StringBuffer().append(welcome).append(to).append(javacoder) .append(cn).toString(); } } |
使用“javap -v TestString.class”进行反编译，逐个函数分析如下：
test1的字节码
public java.lang.String test1();
flags: ACC_PUBLIC
Code:
stack=1, locals=2, args_size=1
0: ldc #29 // String welcome to javacoder.cn
2: astore_1
3: aload_1
4: areturn
这种写法是最简洁的，由于参加'+'操作的各个字符串的值都是确定的，编译器直接生成了值为'welcome to javacoder.cn'的常量字符串，将其加载到内存放回即可
test2的字节码
public java.lang.String test2();
flags: ACC_PUBLIC
Code:
stack=3, locals=2, args_size=1
0: ldc #33 // String welcome to
2: astore_1
3: new #35 // class java/lang/StringBuilder
6: dup
7: aload_1
8: invokestatic #37 //String String.valueOf:(Object);
11: invokespecial #43 //void StringBuilder.""(String)
14: ldc #13 // String javacoder
16: invokevirtual #46 // StringBuilder StringBuilder.append(String;);
19: invokevirtual #50 // String StringBuilder.toString();
22: astore_1
23: new #35 // class java/lang/StringBuilder
26: dup
27: aload_1
28: invokestatic #37 // String String.valueOf:(Object);
31: invokespecial #43 // void StringBuilder.""(String)
34: ldc #16 // String .cn
36: invokevirtual #46 // StringBuilder StringBuilder.append:(String);
39: invokevirtual #50 // String StringBuilder.toString()
42: astore_1
43: aload_1
44: areturn
对于这种写法，先从常量池加载字符串"welcome to",为什么会有这个字符串请看test1的解释，防止"+"操作的第一个操作数不是字符串，所以先调用String.valueOf(),然后调用StringBuilder(String arg)构造函数初始化一个StringBuilder对象，然后append（"javacoder"）,调用StringBuilder.toString()生成一个新的String对象赋值给s1;然后将s1（"welcome to javacoder"）的值传给String.valueOf()确保"+"的第一个参数是String 对象，调用StringBuilder(String arg)版本的构造函数初始化StringBuilder对象，append上'.cn',调用StringBuilder.toString()生成一个新的String对象返回。
test3的字节码
public java.lang.String test3(java.lang.String, java.lang.String, java.lang.String, java.lang.String);
flags: ACC_PUBLIC
Code:
stack=3, locals=6, args_size=5
0: new #35 // class java/lang/StringBuilder
3: dup
4: aload_1
5: invokestatic #37 // String String.valueOf:(Object);
8: invokespecial #43 // void StringBuilder."":(String)
11: aload_2
12: invokevirtual #46 // StringBuilder StringBuilder.append:(String;);
15: aload_3
16: invokevirtual #46 // StringBuilder StringBuilder.append:(String);
19: aload 4
21: invokevirtual #46 // StringBuilder StringBuilder.append:(String);
24: invokevirtual #50 // String StringBuilder.toString:();
27: astore 5
29: aload 5
31: areturn
当使用写成这种方式时，只会产生一个StringBuilder对象，依次将传入的参数append到StringBuilder对象，然后调用StringBuilder.toString()产生一个新的String对象返回。
test4的字节码
public java.lang.String test4();
flags: ACC_PUBLIC
Code:
stack=2, locals=2, args_size=1
0: new #56 // class java/lang/StringBuffer
3: dup
4: invokespecial #58 // void StringBuffer."":()
7: astore_1
8: aload_1
9: ldc #8 // String welcome
11: invokevirtual #59 // StringBuffer StringBuffer.append:(String)
14: pop
15: aload_1
16: ldc
#10 // String to
18: invokevirtual #59 // StringBuffer StringBuffer.append:(String)
21: pop
22: aload_1
23: ldc #13 // String javacoder
25: invokevirtual #59 // StringBuffer StringBuffer.append:(String)
28: pop
29: aload_1
30: ldc #16 // String .cn
32: invokevirtual #59 // StringBuffer StringBuffer.append:(String)
35: pop
36: aload_1
37: invokevirtual #62 // String StringBuffer.toString()
40: areturn
虽然我们要链接的每个字符串都是常量，但是编译器并不会想test1那样帮我们优化，这个代码的字节码和test3差不多，最主要的变化是由StringBuilder变成了StringBuffer，同时每一次append之后都会伴随着依次pop出栈操作，将append的返回值（StringBuffer本身）丢弃掉，下一次append操作之前先将StringBuffer对象的引用推到栈顶。
test5的字节码
public java.lang.String test5();
flags: ACC_PUBLIC
Code:
stack=2, locals=1, args_size=1
0: new #56 // class java/lang/StringBuffer
3: dup
4: invokespecial #58 // void StringBuffer.""()
7: ldc #8 // String welcome
9: invokevirtual #59 // StringBuffer StringBuffer.append:(String)
12: ldc #10 // String to
14: invokevirtual #59 // StringBuffer StringBuffer.append(String)
17: ldc #13 // String javacoder
19: invokevirtual #59 // StringBuffer StringBuffer.append:(String)
22: ldc #16 // String .cn
24: invokevirtual #59 // StringBuffer StringBuffer.append:(String;)
27: invokevirtual #62 // String StringBuffer.toString:()
30: areturn
这个版本的代码和test4很像，唯一的区别是少了pop(append的返回值出栈操作)和aload_1（将StringBuffer对象的引用推到栈顶）。说明通过使用链式操作确实可以获得一些优化。
结束语
- 使用"+"进行字符串连接操作使用的是StringBuilder对象，那么该操作是非线程安全的
- 如果"+"的各个操作数都是常量，那么编译器将计算该操作的值，然后将值存为一个常量
- 使用"+"进行字符串连接操作时最好进行链式操作，这样产生的临时对象才会更少
- 使用StringBuffer或者StringBuilder对象进行字符串连接操作，最好使用链式操作写法，能减少出栈和入栈操作
Posted in: java基础
Comments are closed.