字符串相加
字符串相加在Java中使用非常頻繁，通常情況下使用＂＋＂就可以方便快捷的完成目標(biāo)，但是你可能聽過＂＋＂在有些時候效率不高,需要用StringBuilder代替．但是這種說法的背后原因是什么呢，哪種情況下適用呢？下面結(jié)合Jdk命令Javap解釋這倆問題．
一個普通的字符串相加：
public class StringTest {
public static void main(String[] args){
String a = "a";
String b = "b";
String c = "c";
String d = a + b + c;
System.out.println(d);
}
}
使用javap查看編譯后的字節(jié)碼：
zeal@zeal-ThinkPad:~/tobenew$ javap -c StringTest
Picked up JAVA_TOOL_OPTIONS: -javaagent:/usr/share/java/jayatanaag.jar
Compiled from "StringTest.java"
public class StringTest {
public StringTest();
Code:
0: aload_0
1: invokespecial #1 // Method java/lang/Object."<init>":()V
4: return
public static void main(java.lang.String[]);
Code:
0: ldc #2 // String a
2: astore_1
3: ldc #3 // String b
5: astore_2
6: ldc #4 // String c
8: astore_3
9: new #5 // class java/lang/StringBuilder
12: dup
13: invokespecial #6 // Method java/lang/StringBuilder."<init>":()V
16: aload_1
17: invokevirtual #7 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
20: aload_2
21: invokevirtual #7 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
24: aload_3
25: invokevirtual #7 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
28: invokevirtual #8 // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
31: astore 4
33: getstatic #9 // Field java/lang/System.out:Ljava/io/PrintStream;
36: aload 4
38: invokevirtual #10 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
41: return
}
我們并不討論具體的指令含義，簡單來看＂＋＂在編譯中被StringBuilder替換，所以說＂＋＂只是一個語法上的簡化，最后通過編譯器編譯成了StringBuilder的append實現(xiàn)．可以發(fā)現(xiàn)在這里＂＋＂和手寫append其實是一樣的，＂＋＂更易讀些．
循環(huán)中的字符串相加：
public class StringTest {
public static void main(String[] args){
final String a = "a";
String b = "b";
for(int i=0; i<5; i++) {
b = b + a;
}
System.out.println(b);
}
}
使用javap查看編譯后的字節(jié)碼：
zeal@zeal-ThinkPad:~/tobenew$ javap -c StringTest
Picked up JAVA_TOOL_OPTIONS: -javaagent:/usr/share/java/jayatanaag.jar
Compiled from "StringTest.java"
public class StringTest {
public StringTest();
Code:
0: aload_0
1: invokespecial #1 // Method java/lang/Object."<init>":()V
4: return
public static void main(java.lang.String[]);
Code:
0: ldc #2 // String b
2: astore_2
3: iconst_0
4: istore_3
5: iload_3
6: iconst_5
7: if_icmpge 36
10: new #3 // class java/lang/StringBuilder
13: dup
14: invokespecial #4 // Method java/lang/StringBuilder."<init>":()V
17: aload_2
18: invokevirtual #5 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
21: ldc #6 // String a
23: invokevirtual #5 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
26: invokevirtual #7 // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
29: astore_2
30: iinc 3, 1
33: goto 5
36: getstatic #8 // Field java/lang/System.out:Ljava/io/PrintStream;
39: aload_2
40: invokevirtual #9 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
43: return
}
仔細(xì)看可以發(fā)現(xiàn)StringBuilder對象創(chuàng)建被放在了循環(huán)里面(goto語句)，所以如果循環(huán)次數(shù)特別多就不適合用＂＋＂了，要不然會創(chuàng)建大量的StringBuilder對象．正確的用法是這樣：
public class StringTest {
public static void main(String[] args){
String a = "a";
StringBuilder builder = new StringBuilder("b");
for(int i=0; i<5; i++) {
builder.append(a);
}
System.out.println(builder.toString());
}
}
final字符串的相加：
public class StringTest {
public static void main(String[] args){
final String a = "a";
final String b = "b";
final String c = "c";
String d = a + b + c;
System.out.println(d);
}
}
使用javap查看編譯后的字節(jié)碼：
zeal@zeal-ThinkPad:~/tobenew$ javap -c StringTest
Picked up JAVA_TOOL_OPTIONS: -javaagent:/usr/share/java/jayatanaag.jar
Compiled from "StringTest.java"
public class StringTest {
public StringTest();
Code:
0: aload_0
1: invokespecial #1 // Method java/lang/Object."<init>":()V
4: return
public static void main(java.lang.String[]);
Code:
0: ldc #2 // String abc
2: astore 4
4: getstatic #3 // Field java/lang/System.out:Ljava/io/PrintStream;
7: aload 4
9: invokevirtual #4 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
12: return
}
我們發(fā)現(xiàn)根本沒有StringBuilder對象被創(chuàng)建，因為a,b,c值不會改變，所以d是一個確定值．Java在編譯期就進行了優(yōu)化．
字符串常量池的位置
常量池的位置在Jdk1.6之前(包括1.6)屬于永久區(qū)的一部分，而在1.7之后(包括1.7)被移到了堆中管理．
import java.util.List;
import java.util.ArrayList;
public class StringTest {
public static void main(String[] args){
List<String> strList = new ArrayList<String>();
int i=0;
while(true){
strList.add((i+"").intern());
i++;
}
}
}
zeal@zeal-pc:~$ ./soft/jdk/jdk1.6.0_45/bin/java -Xmx10m -XX:MaxPermSize=5m -XX:-UseGCOverheadLimit StringTest
Exception in thread "main" java.lang.OutOfMemoryError: PermGen space
at java.lang.String.intern(Native Method)
at StringTest.main(StringTest.java:8)
zeal@zeal-pc:~$ ./soft/jdk/jdk1.7.0_65/bin/java -Xmx10m -XX:MaxPermSize=5m -XX:-UseGCOverheadLimit StringTest
Exception in thread "main" java.lang.OutOfMemoryError: Java heap space
at StringTest.main(StringTest.java:8)
字符串比較
這個在整理的時候遇到一個奇葩情況解釋不了，請大神回復(fù)一下
首先來看一波符合預(yù)期的例子：
//In Jdk1.7
public class StringTest {
public static void main(String[] args){
String str1 = new String("world");
String str2 = str1.intern();
String str3 = "world";
System.out.println(str1 == str2); //false
System.out.println(str2 == str3); //true
}
}
//In Jdk1.7
public class StringTest {
public static void main(String[] args){
String str0 = "world";
String str1 = new String("world");
String str2 = str1.intern();
String str3 = "world";
System.out.println(str0 == str1); //false
System.out.println(str0 == str2); //true
System.out.println(str1 == str2); //false
System.out.println(str2 == str3); //true
System.out.println(str0 == str3); //true
}
}
看一下intern的源碼注釋：(Jdk1.6和Jdk1.7是完全一樣的)
When the intern method is invoked, if the pool already contains a
string equal to this <code>String</code> object as determined by
the {@link #equals(Object)} method, then the string from the pool is
returned. Otherwise, this <code>String</code> object is added to the
pool and a reference to this <code>String</code> object is returned.
如果常量池中存在和當(dāng)前對象equals相等的對象則返回常量池中的對象引用，否則將當(dāng)前對象(應(yīng)該是當(dāng)前對象的拷貝)加入常量池并返回引用．
從這里可以看出，＂world＂這種創(chuàng)建字符串的方式會被加入到常量池，而new對象的方式是不會添加到常量池或者從常量池中獲取的．
不符合預(yù)期的情況
//In Jdk1.7
public class StringTest {
public static void main(String[] args){
String str1=new String("hell")+new String("o");
String str2 = str1.intern();
String str3 = "hello";
String str4 = new String("hello");
System.out.println(str1==str2);
System.out.println(str2==str3);
System.out.println(str1==str3);
System.out.println(str3==str4);
}
}
zeal@zeal-pc:~$ java StringTest
true
true
true
false
根據(jù)前文可以看到str1是由StringBuilder的toString方法構(gòu)造出來的，查看源碼可以發(fā)現(xiàn)toString其實是new了一個新的String對象出來．按照之前理解str1==str2應(yīng)為false.
madan坑好深,誰來解釋一下
public class StringTest {
public static void main(String[] args){
String str1 = new String("hell")+new String("o");
String str2 = str1.intern();
String str3 = new String("java");
String str4 = str3.intern();
String str5 = new String("world");
String str6 = str5.intern();
String str7 = "cat";
String str8 = str7.intern();
String str9 = new StringBuffer("hello").append("world").toString();
String str10 = str9.intern();
String str11 = new StringBuilder("hellojava").toString();
String str12 = str11.intern();
String str13=new StringBuilder("hello").append("2").toString();
String str14 = "hello2";
String str15=str13.intern();
//Jdk1.7 //Jdk1.6
System.out.println(str1 == str2); //true? //false
System.out.println(str3 == str4); //false //false
System.out.println(str5 == str6); //false //false
System.out.println(str7 == str8); //true //true
System.out.println(str9 == str10); //true? //false
System.out.println(str11 == str12);//false //false
System.out.println(str13==str14); //false //false
System.out.println(str13==str15); //false //false
System.out.println(str14==str15); //true //true
}
}
之后進行了一系列測試，發(fā)現(xiàn)append和intern在一起的時候(＂＋＂等同于append)在1.7中會發(fā)生奇妙的現(xiàn)象．表面來看就好像append存在的時候往常量池中存放的不是String對象的拷貝而是String對象的引用．
只能把鍋給append了.... 誰來解釋一下！
