前段时间在面试的过程中发现，String,StringBuffer,StringBuilder的区别这个问题几乎是面试必问的题，而且在以后的开发中使用的频率极高，懂得底层原理对以后的开发效率会有大大的提高，所以在此进行总结。
三者间关系
很多同学在刚接触到这三个类的时候，总是搞不清楚他们三个间的关系，下面我们从JDK源码分析一下：
代码语言：javascript复制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进行扩容。
代码语言：javascript复制 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 修饰的，是线程安全的。适合于多线程环境中
代码语言：javascript复制 @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
代码语言：javascript复制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 继承来的，所以对于其初始空间和扩容都是相同的。
代码语言：javascript复制 @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适合于单线程环境中
性能比较
代码语言：javascript复制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);
}
}运行结果如下：
代码语言：javascript复制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。
2021 年 12 月 7 日 百思不得小赵。 —— 新时代的农民工
