String类的对象是不可变的！
在使用String类的时候要始终记着这个观念。一旦创建了String对象，它就不会改变。
String类中也有可以改变String中字符串的方法，但只要是涉及改变的方法，都是通过创造并返回一个全新的String对象来实现的。而原先那个String对象是没有被改动过的。
String对操作符“+”的重载
String对象是不可变的，而这个不可变性往往会带来性能上、效率上的问题。
Java中，为String类重载的“+”操作符就是一个例子。 操作符的重载的意思是，一个操作符作用于一个特定的类的时候，被赋予了特殊的意义。用于String的“+”和“+=”是Java中仅有的l两个重载过的操作符，而且Java并不允许程序员重载任何操作符。
我们知道操作符“+”可以用来连接String，并且当操作符的另一边不是String的时候，会尝试把它变成String。
public class Concatenation {
public static void main(String[] args) {
String mango = "mango";
String s = "abc" + mango + "def" + 47;
System.out.println(s);
}
/* Output:
abcmangodef47这个我们可能会想象，它是这样工作的：
String中应该有个append()方法，一开始String“abc”会调用这个append方法，然后创建一个新的String对象，连接abc和Stringmango，然后再创建新的String对象，以此类推。
因为String对象是不能改变的嘛。意味着这几个String的+运算，会产生好几个String对象，这样的猜想确实没错。
这个猜想确实行得通，但这样的话，垃圾回收器就要回收一堆中间的String对象。很浪费资源噢。
为了看Java底层真正是怎么实现这个Java的Stirng加法的，我们用到了jdk自带的反编译工具——Javap工具。
输入命令行：
javap -c Concatenation-c代表着生成JVMz字节码，下面是删减后的g关键字节码：
public static void main(java.lang.String[]);
Code:
Stack=2, Locals=3, Args_size=1
0: ldc #2; //String mango
2: astore_1
3: new #3; //class StringBuilder
6: dup
7: invokespecial #4; //StringBuilder."<init>":()
10: ldc #5; // String abc
12 invokevirtual #6; //StringBuilder.append:(String)
15 aload_1
16 invokevirtual #6; //StringBuilder.append:(String)
19 ldc #7; //String def
21 invokevirtual #6; //StringBuilder.append:(String)
24 bipush 47
26 invokevirtual #8; //StringBuilder.append:(I)
29 invokevirtual #9; //StringBuilder.toString:()
32 astore_2
33 getstatic #10; //Field System.out:PrintStream;
36 aload_2
37 invokevirtual #11; // PrintStream.println:(String)
40 return这上面是我们的JVM的汇编语言。
我们可以看到，虽然我们在自己写的的源代码中完全没有提到StringBuilder类，但编译器却自作主张自己引入了!!——因为它大大地提高了效率！
在这个例子中，编译器创建了一个StringBuilderd对象来实现这个s的String的加法。调用了StringBuilder的append()方法四次，然后最后调用了StringBuilder对象的toString()方法来产生一个String对象并存在s中返回。
可见Java编译器对String的加法操作是会自动优化的！
现在我们可以随意地使用String了，但有时候编译器的优化工作做的不是很好，需要我们手动地优化，看个例子：
//: strings/WhitherStringBuilder.java
public class WhitherStringBuilder {
public String implicit(String[] fields) {
String result = "";
for(int i = 0; i < fields.length; i++)
result += fields[i];
return result;
}
public String explicit(String[] fields) {
StringBuilder result = new StringBuilder();
for(int i = 0; i < fields.length; i++)
result.append(fields[i]);
return result.toString();
}
} ///:~这两个方法的目的都一样，把一个String数组中的元素都加起来，最后返回一个String对象。
然后我们用上面一样的方法来看看它的执行过程：
implicit方法的执行汇编字节码：
public java.lang.String implicit(java.lang.String[]);
Code:
0: ldc #2; //String
2: astore_2
3: iconst_0
4: istore_3
5: iload_3
6: aload_1
7: arraylength
8: if_icmpge 38
11: new #3; //class StringBuilder
14: dup
15: invokespecial #4; // StringBuilder.”<init>”:()
18: aload_2
19: invokevirtual #5; // StringBuilder.append:()
22: aload_1
23 iload_3
24 aaload
25: invokevirtual #5; // StringBuilder.append:()
28: invokevirtual #6; // StringBuiIder.toString:()
31: astore_2
32: iinc 3, 1
35: goto 5
38: aload_2
39 areturn书上的小解析：
大概意思就是第八行到第35行构成了循环：
然后我们要关注的重点是：
在循环中，一个StringBuilder的构造器被调用了，说明你每次进入循环都会创建一个新的StringBuilder对象。
然后是explicit的执行字节码：
public java.lang.String explicit(java.lang.String[]);
Code:
0: new #3; //class StringBuilder
3: dup
4: invokespecial #4; // StringBuilder.”<init>”:()
7: astore_2
8: iconst_0
9: istore_3
10: iload_3
11: aload_1
12: arraylength
13: if_icmpge 30
16: aload_2
17: aload_1
18: iload_3
19: aaload
20 invokevirtual #5; // StringBuilder.append:()
23 pop
24: iinc 3,1
27: goto 10
30: aload_2
31: invokevirtual #6; // StringBuiIder.toString:()
34: areturn
可以看到：
这里只创建了一个StringBuilder对象，显然效率更好！
如果你知道字符串的长度，还可以体现分配好size，这样还避免了多次重新分配缓存。
所以说，如果你要重写一个类的toString方法，如果字符串操作不是很复杂，就可以依赖编译器本身的优化；如果很复杂的话，建议自己创建一个StringBuilder类。
StringBuilder是jdk5后引入的。之前用的是StringBuffer，是线程安全的，所以开销也更大，显然StringBuilder效率更高。
无意识的递归
下面例子是基于这样的一个想法：
你想在某个类的toString中打印出这个对象的地址，然后你想到了关键字this于是就写出了这样的代码：
但是，当你尝试去打印这个对象的话，你会看到很长的一个异常报错。
为什么会这样呢？因为发生了递归调用。
当编译器看到String后面跟了个加号“+”，会尝试将后面的this变成String类型，这就变成调用toString方法，然后就递归了……
正确的做法应该是调用根类Object的toString()方法，也就是super.toString()。
