前段时间在面试的过程中发现，String,StringBuffer,StringBuilder的区别这个问题几乎是面试必问的题，而且在以后的开发中使用的频率极高，懂得底层原理对以后的开发效率会有大大的提高，所以在此进行总结。

三者间关系

很多同学在刚接触到这三个类的时候，总是搞不清楚他们三个间的关系，下面我们从JDK源码分析一下：

public final class String
    implements java.io.Serializable, Comparable<String>, CharSequence,
               Constable, ConstantDesc {
		}

 public final class StringBuffer
    extends AbstractStringBuilder
    implements java.io.Serializable, Comparable<StringBuffer>, CharSequence{
    }

public final class StringBuilder
    extends AbstractStringBuilder
    implements java.io.Serializable, Comparable<StringBuilder>, CharSequence{
    }

abstract class AbstractStringBuilder implements Appendable, CharSequence {}

StringBuffer和StringBuilder都继承自AbstractStringBuilder这个类，而AbstractStringBuilder和String都继承自Object这个类（Object是所有java类的超类）。所以这三个类之间的关系可以大致表示为：

String

从上图可以看出：String 底层实际上是由 char 数组构成的，而且有 final 关键字修饰，这说明 String 类型的对象是不可以改变的，也是不可以被继承的。原始字符串永远不会更改。而是复制一份，并将要连接的文本被添加到复制的字符串之后，最后返回一个新的字符串。对大量字符串进行操作时 String 类可能会导致严重的内存泄漏和时间延迟。

那么，平时我们使用“+”来拼接字符串是什么实现的？
如上面的代码，首先创建一个 String 对象 a，再把“abc”赋值给它，后面Java虚拟机又创建了一个 String 对象 a，然后再把原来的 a 的值和 hello 加起来再赋值给新的 a，而原来的a 就会被Java虚拟机的垃圾回收机制（GC）给回收掉了，所以，a 实际上并没有被更改，也就是前面说的String 对象一旦创建之后就不可更改了。从这里可以看出对于频繁操作的字符串，不建议使用 String 类型，这将会是一个不断创建新的对象并且将旧的对象回收的一个过程，所以执行速度很慢。

StringBuffer

从源码中我们可以看出，对 StringBuffer 来说，底层也是 char 数组。StringBuffer 默认初始空间是16。对于 StringBuffer 的扩容，从下面可以看出，是在旧的数组的2倍上面，再加2进行扩容。

  public void ensureCapacity(int minimumCapacity) {
        if (minimumCapacity > 0) {
            ensureCapacityInternal(minimumCapacity);
        }
    }

    private void ensureCapacityInternal(int minimumCapacity) {
        // overflow-conscious code
        int oldCapacity = value.length >> coder;
        if (minimumCapacity - oldCapacity > 0) {
            value = Arrays.copyOf(value,
                    newCapacity(minimumCapacity) << coder);
        }
    }

    private int newCapacity(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = value.length >> coder;
        int newCapacity = (oldCapacity << 1) + 2;
        if (newCapacity - minCapacity < 0) {
            newCapacity = minCapacity;
        }
        int SAFE_BOUND = MAX_ARRAY_SIZE >> coder;
        return (newCapacity <= 0 || SAFE_BOUND - newCapacity < 0)
            ? hugeCapacity(minCapacity)
            : newCapacity;
    }

    private int hugeCapacity(int minCapacity) {
        int SAFE_BOUND = MAX_ARRAY_SIZE >> coder;
        int UNSAFE_BOUND = Integer.MAX_VALUE >> coder;
        if (UNSAFE_BOUND - minCapacity < 0) { // overflow
            throw new OutOfMemoryError();
        }
        return (minCapacity > SAFE_BOUND)
            ? minCapacity : SAFE_BOUND;
    }

==下面我们在来看下 StringBuffer 的操作函数append，append 方法是由 synchronized 修饰的，是线程安全的。适合于多线程环境中==

  @Override
    public synchronized StringBuffer append(Object obj) {
        toStringCache = null;
        super.append(String.valueOf(obj));
        return this;
    }

    @Override
    @HotSpotIntrinsicCandidate
    public synchronized StringBuffer append(String str) {
        toStringCache = null;
        super.append(str);
        return this;
    }

StringBuilder

public StringBuilder() {
    super(16);
}
public StringBuilder(int capacity) {
    super(capacity);
}
public StringBuilder(String str) {
    super(str.length() + 16);
    append(str);
}
public StringBuilder(CharSequence seq) {
    this(seq.length() + 16);
    append(seq);
}

通过和 StringBuffer 的源码比较，我们发现初始空间也是16。当然也可以指定初始容量，或者以一个已有的字符序列给StringBuilder对象赋初始值。StringBuilder 和 StringBuffer 都是从 AbstractStringBuilder 继承来的，所以对于其初始空间和扩容都是相同的。

    @Override
    public StringBuilder append(Object obj) {
        return append(String.valueOf(obj));
    }

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

对于 StringBuilder 和 StringBuffer 的区别可以从上看出，对于append()方法，缺少了synchronized 修饰，这使得 StringBuilder 不是线程安全。==StringBuilder适合于单线程环境中==

性能比较

public class Text1 {
    public static void main(String[] args) {
   
        int num = 100000;
        String a = "abc";
        long time = System.currentTimeMillis();
        for (int i = 1; i < num; i++) {
            a = a + i;
        }
        System.out.println(System.currentTimeMillis() - time);

        long time1 = System.currentTimeMillis();
        StringBuffer bf = new StringBuffer();
        for (int i = 1; i < num; i++) {
            bf.append(i);
        }
        System.out.println(System.currentTimeMillis() - time1);

        StringBuilder builder = new StringBuilder();
        long time2 = System.currentTimeMillis();
        for (int i = 1; i < num; i++) {
            builder.append(i);
        }
        System.out.println(System.currentTimeMillis() - time2);
    }
}

运行结果如下：

4134
4
3

Process finished with exit code 0

==这三者的效率是：StringBuilder > StringBuffer > String。==

总结

• String 类被 final 关键字所修饰 String 是不可变类型
• 原始字符串永远不会更改。而是复制一份，并将要连接的文本被添加到复制的字符串之后，最后返回一个新的字符串
• 对大量字符串进行操作时 String 类可能会导致严重的内存泄漏和时间延迟。
• StringBuilder和StringBuffer都是可变字符串，前者线程不安全，后者线程安全。
• StringBuilder和StringBuffer的大部分方法均调用父类AbstractStringBuilder的实现。其扩容机制首先是把容量变为原来容量的2倍加2。最大容量是Integer.MAX_VALUE，也就是0x7fffffff。
• StringBuilder和StringBuffer的默认容量都是16，最好预先估计好字符串的大小避免扩容带来的时间消耗。
  -性能方面 StringBuilder > StringBuffer > String。