字符串拼接
"+"的实现
两个字符串"+"的底层实现是StringBuilder，通过javap -c命令反编译代码之后可以很清楚的看到
public class StringTest2 {
public static void main(String[] args) {
String a = "a";
String b = "b";
System.out.println(a + b);
}
}
javap -c StringTest2.class 结果输出
public class com.junhua.base.StringTest2 {
public com.junhua.base.StringTest2();
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: getstatic #4 // Field java/lang/System.out:Ljava/io/PrintStream;
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: invokevirtual #8 // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
27: invokevirtual #9 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
30: return
}
字面量相加的时候，在编译的时候会做优化，不会新建StringBuilder，而是直接将字符串拼接好，然后去新建String对象
String c = "a" + "b";// 不会产生StringBuilder对象
concat字符串拼接
concat字符串拼接使用的是字符数组扩容，形成新的字符数组的方式实现
public String concat(String str) {
int otherLen = str.length();
if (otherLen == 0) {
return this;
}
int len = value.length;
char buf[] = Arrays.copyOf(value, len + otherLen);
str.getChars(buf, len);
return new String(buf, true);
}
字符串常量池
字符串常量池的功能类事于一个StringTable，是一个Hash表的实现，被所有的类共享。在jDK1.7以后，由于可以支持的字符串常量池的长度增加，放在方法区已经不太适合了，就挪到了堆中。同时，新增了常量池大小的设置
-XX:StringTableSize=66666
String s1 = "String";
String s2 = "String";
s1 == s2;
java首先会在缓冲区查找是否有"String"这个常量对象，有就直接将其地址赋给s1，没有就创建一个"String"，然后将其赋给s1;然后String s2 = "String";
java同样会在缓冲区中查找"String"，这次能查找到了，因为s1创建了一个"String",所以会将其地址赋给s2，如此，s1和s2便有了相同的地址。
只有在新建字面量的时候才存在使用常量迟到概念，如果直接新建一个String对象，则是直接开辟一块内存，保持该字符串。
String a1 = new String("String");
intern 方法
如果常量池中有某个字符串对象了，就将该引用返回；否则将创建一个字符串对象放到常量池中，并返回这个引用。intern()方法的关键是始终是用的常量池中的字符串对象，而不是使用堆中的对象。
String b = new String("a").intern();
String a = new String("a");
System.out.println(a == b); //false
String c = "a";
System.out.println(a == c); //true
String对象的创建
String a = new String("String");这个过程会在内存中创建两个对象，一个在heap中，一个在常量池中（如果常量池中已经有了该字符串，则不需要在常量池中创建）。a这个引用指向的是heap中的这个内存区域(对象)。
String b = "String";这个过程首先会去字符串常量池中查找，如果字符串常量池中有值，则直接指向字符串常量池中的地址，如果不存在，则在字符串常量池中新建一个该字符串，并指向该字符串所对应的内存区域。
String的不可变性
String对象是不可变的，一旦生成了，就无法直接修改，每次都会创建新的字符串对象。String内部的用一个char[]来保存，这个属性是一个私有的属性，并不对外提供修改的方法，进而也就无法实现对这个string对象的修改。
StringBuffer vs StringBuilder
字符串是不可变的，每次对字符串的操作都回生成新的对象，舍弃掉老的对象，会造成很多额外的开销。StringBuffer和StringBuilder就是为了解决这个问题而生的。不同点在于StringBuffer是线程安全的，StringBuilder是线程不安全的。append()方法都是采用字符串复制的方法，不同点在于StringBuffer在每个方法上都会加synchronized
StringBuffer和StringBuilder的核心方法append(String)
public AbstractStringBuilder append(String str) {
if (str == null)
return appendNull();
int len = str.length();
// 对原始数组长度进行扩容
ensureCapacityInternal(count + len);
// 将str中的char复制到value这个char数组中
str.getChars(0, len, value, count);
count += len;
return this;
}
