String、StringBuffer、StringBuilder的相关Q&A

Q1：是否可变？

A1：结论：String不可变，StringBuffer和StringBuilder可变。理由如下：

看jdk的源码，String类的源码如下：

public final class String
    implements java.io.Serializable, Comparable<String>, CharSequence {
/** The value is used for character storage. */
private final char value[];

因为有final修饰符，所以显然，String是不可变的；
接着看AbstractStringBuilder的源码：

abstract class AbstractStringBuilder implements Appendable, CharSequence {
    /**
     * The value is used for character storage.
     */
    char[] value;

StringBuilder与StringBuffer都继承自AbstractStringBuilder类，在AbstractStringBuilder中是使用字符数组保存字符串，所以StringBuffer和StringBuilder都是可变的。StringBuffer源代码如下，StringBuilder源代码就不贴了，大同小异。

public final class StringBuffer
    extends AbstractStringBuilder
    implements java.io.Serializable, CharSequence
{
    /**
     * Constructs a string buffer with no characters in it and an
     * initial capacity of 16 characters.
     */
    public StringBuffer() {
        super(16);
    }

Q2：是否线程安全

A2：结论：String、StringBuffer是线程安全的，StringBuilder是非线程安全的。理由如下：

String对象不可变啊，显然线程安全。
StringBuffer和StringBuilder都继承自AbstractStringBuilder，而该类已经实现了很多关于字符串的方法，以append方法为例：

public AbstractStringBuilder append(String str) {
        if (str == null) str = "null";
        int len = str.length();
        ensureCapacityInternal(count + len);
        str.getChars(0, len, value, count);
        count += len;
        return this;
    }

StringBuffer和StringBuilder很多方法直接调用父类方法，但是StringBuffer添加了添加了synchronized关键字：

public synchronized StringBuffer append(String str) {
        super.append(str);
        return this;
    }

而StringBuilder类中没有加synchronized关键字

public StringBuilder append(String str) {
        super.append(str);
        return this;
    }

Q3：使用场景问题

A3：String是不可变的，每次对 String 类型进行改变的时候其实都等同于生成了一个新的 String 对象，然后将指针指向新的 String 对象，所以经常改变内容的字符串最好不要用 String。

以下是实验的情况：

public class Test0 {
    public static void main(String[] args) {
        long beginTime = System.currentTimeMillis();
        String str = new String();
        for (int i = 0; i < 100000; i++) {
            str = str + i;
        }
        long endTime = System.currentTimeMillis();
        System.out.println("time1:" + (endTime - beginTime));
        beginTime = System.currentTimeMillis();
        StringBuffer sbf = new StringBuffer();
        for (int i = 0; i < 100000; i++) {
            sbf.append(i);
        }
        endTime = System.currentTimeMillis();
        System.out.println("time2:" + (endTime - beginTime));
    }
}

结果：

time1:15606
time2:6

StringBuffer和StringBuilder主要区别在于一个是线程安全的，另一个则不是，显然非线程安全的StringBuilder在效率上更高。所以StringBuffer适合需要保证线程安全的场景中，而没有此要求的则用StringBuilder来提高效率。

补充知识：

String类覆盖了equals方法和hashCode方法，而StringBuffer没有覆盖equals方法和hashCode方法。StringBuilder也没有覆盖这两个方法。所以下面的代码输出是false。

StringBuffer sb = new StringBuffer("abc");
StringBuffer sb2 = new StringBuffer("abc");
System.out.println(sb.equals(sb2));

Q4：下面这条语句一共创建了多少个对象：

String s="a"+"b"+"c"+"d";

A4：对于如下代码：

String s1 = "a";
String s2 = s1 + "b";
String s3 = "a" + "b";
System.out.println(s2 == "ab");
System.out.println(s3 == "ab");

第一条语句打印的结果为false，第二条语句打印的结果为true，这说明javac编译可以对字符串常量直接相加的表达式进行优化，不必要等到运行期去进行加法运算处理，而是在编译时去掉其中的加号，直接将其编译成一个这些常量相连的结果。
题目中的第一行代码被编译器在编译时优化后，相当于直接定义了一个”abcd”的字符串，所以，上面的代码应该只创建了一个String对象。写如下两行代码，

String s = "a" + "b" + "c" + "d";
System.out.println(s == "abcd");

最终打印的结果应该为true。