前段时间在面试的过程中发现，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。
