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()。