String的小笔记

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