不管是在我们的开发过程中还是在日后的面试过程中，常常不可避免的会遇到String、StringBuffer与StringBuilder之间区别，看源码无疑是我们去理解代码最直接的一种方式，之后在去探讨JVM原理

---

🎋🎋 随着做开发的时间越久，越来越能体会到 “站在巨人的肩膀上前行，避免重复造轮子” 这句话，但仔细想想，为什么我们不能自己造轮子呢

嗨，谁让自己菜呢，菜的抠脚，那就只能看看人家是怎么造轮子的……

三者关系图：

String	StringBuilder	StringBuffer
private final char value[]	char[] value	char[] value
String类被final所修饰	StringBuilder类被final所修饰	StringBuffer类被final所修饰	皆不能被继承
[] 被final修饰不可变	[] 可变	[] 可变
implements java.io.Serializable, Comparable, CharSequence接口	extends AbstractStringBuilder类，implements java.io.Serializable接口/CharSequence接口	extends AbstractStringBuilder类，implements Serializable接口/CharSequence接口
内部结构 [] 被final所修饰，为线程安全	线程不安全	内部方法被synchronized所修饰，为线程安全（常在多线程中使用）
由于String是不可变的，每次对 String类型进行改变的时候，都会生成一个新的String对象，然后将指针指向新的String对象，性能是最低下的	StringBuffer和StringBuilder每次都会对对象本身进行操作，而不是生成新的对象并改变对象引用，同情况下使用StringBuilder相比使用StringBuffer仅能获得 10%~15% 左右的性能提升（网上都这么说性能）	StringBuffer和StringBuilder每次都会对对象本身进行操作，而不是生成新的对象并改变对象引用
操作少量数据，适用String	单线程操作字符串缓冲区下操作大量数据：适用StringBuilder	多线程操作字符串缓冲区下操作大量数据：适用StringBuffer

Java中处理字符串的常用的三个类（ 以下源码来自于JDK8）；

1. java.lang.String
2. java.lang.StringBuffer
3. java.lang.StrungBuilder

看String部分源码：

public final class Stringimplements java.io.Serializable, Comparable<String>, CharSequence {/** 该值用于字符存储 */private final char value[];/** 缓存字符串的哈希码 */private int hash; //  to 0/** 使用JDK 1.0.2中的serialVersionUID进行互操作 */private static final long serialVersionUID = -6849794470754667710L;}/*** 返回一个字符串，该字符串是该字符串的子字符串。子字符串以指定索引处的字符开头，并延伸到该字符串的末尾。<p>. <p>* 举例:* <blockquote><pre>* "unhappy".substring(2) returns "happy"* "Harbison".substring(3) returns "bison"* "emptiness".substring(9) returns "" (an empty string)* </pre></blockquote>** @param      beginIndex   the beginning index, inclusive.* @return     指定的子字符串.* @exception  IndexOutOfBoundsException如果{@code beginIndex}为负数或大于此{acode string}对象的长度。*/public String substring(int beginIndex) {if (beginIndex < 0) {throw new StringIndexOutOfBoundsException(beginIndex);}int subLen = value.length - beginIndex;if (subLen < 0) {throw new StringIndexOutOfBoundsException(subLen);}return (beginIndex == 0) ? this : new String(value, beginIndex, subLen);}
}

1. 实现 java.io.Serializable接口；
            序列化接口没有任何方法和域，仅用于标识序列化。
2. 实现Comparable<String>接口；
            只有一个compareTo(T 0)方法，用于对两个实例化对象比较大小。
3. .String类是用final修饰的不能被继承的，但，String内部是用private final char value[] 也就是说底层还是是一个数组结构，通过String类定义的字符串的所有字符都是存储在final修饰的char[] 数组当中，好像在JDK9中 char 换成了byte ，记不清是JDK几来着，
4. String的对象是不可变的(final修饰)，说明是安全的，同时每当对String的类型发生改变时，意味着都会生成一个新的对象，然后指针指向新的对象，可以在操作少量的数据来使用；
5. subString()方法是String截取字符串用的， (beginIndex == 0) ? this : new String(value, beginIndex, subLen);当我们对字符串从beginIndex(beginIndex>0)个字符开始进行截取时，返回的是重新new出来的对象，所以在对String类的字符串进行大量的插入和删除操作时会产生大量的临时变量；

看StringBuffer部分源码：

 public final class StringBufferextends AbstractStringBuilderimplements java.io.Serializable, CharSequence
{//toString返回的最后一个值的缓存。每当修改StringBuffer时清除。private transient char[] toStringCache;//使用JDK 1.0.2中的serialVersionUID来实现互操作性static final long serialVersionUID = 3388685877147921107L;//构造一个不带字符且初始容量为16个字符的字符串缓冲区。public StringBuffer() {super(16);}/** 构造一个没有字符且具有指定初始容量的字符串缓冲区。* @param      容量初始容量。.* @exception  如果{@code Capacity}参数小于{acode 0}，则返回NegativeArraysizeException。*/public StringBuffer(int capacity) {super(capacity);}/*** 构造一个初始化为指定字符串内容的字符串缓冲区。字符串缓冲区的初始容量为{acode 16}加上字符串参数的长度。* @param   str   缓冲区的初始内容.*/public StringBuffer(String str) {super(str.length() + 16);append(str);}/*** 构造一个字符串缓冲区，该字符串包含与指定的{@code CharSequence}相同的字符。字符串缓冲区的初始容量为{@code 16}加上字符串的长度 {@code CharSequence}参数。.* <p>* 如果指定的{@code CharSequence}的长度小于或等于零，则返回容量为{@code 16}的空缓冲区。* @param      CharSequence为序列   复制顺序.  * @since 1.5*/public StringBuffer(CharSequence seq) {this(seq.length() + 16);append(seq);}@Overridepublic synchronized String toString() {if (toStringCache == null) {toStringCache = Arrays.copyOfRange(value, 0, count);}return new String(toStringCache, true);}/*** @throws StringIndexOutOfBoundsException {@inheritDoc}* @since      1.2* 实际上还是AbstractStringBuilder类中的方法insert（）*/@Overridepublic synchronized StringBuffer insert(int index, char[] str, int offset,int len){toStringCache = null;super.insert(index, str, offset, len);return this;}}

1. StringBuffer 也实现了java.io.Serializable接口，表示对象可以被序列化和CharSequence字符序列接口，提供了几个对字符序列化只读访问的方法，比如：lenth()，charAt()，su Sequence()，toString()方法等
2. extends继承了AbstractStringBuilder类 ，实际上，AbstractStringBuilder类具体实现了可变字符序列的一系列操作，比如append（），delete（），inset（），replace（），charAt()方法等

「final意义：最终的，不可改变的。
1、修饰变量，为常量,值不可变；
2、修饰对象，值可变,引用不变；
3、修饰方法，方法不可重写；
4、修饰类，无子类，不可以被继承,更不可能被重写。」

3. StringBuffer类被final所修饰，不能被继承，String和StringBuffer都是final类，两者生成的对象在堆中都是不可变的，那为什么说StringBuffet是可变的呢，String的内部结构是用 private final char value[];来修饰 StringBuffer的内部是用 private transient char[] toStringCache;来定义的，没有被final修饰，StringBuffer在对象中追加字符串是靠父类AbstractStringBuilder来实现的，AbstractStringBuilder内的char 数组是变量，可以用append追加或者delete；

5. 在这在看一段源码就截图了，翻译实在太困难了
   

可以看到StringBuffer 的所有公开方法都是 synchronized 修饰的，众所周知，synchronized修饰的意味为加锁，资源同步串行化处理，所以为线程安全的

看StringBuilder部分源码：

public final class StringBuilderextends AbstractStringBuilderimplements java.io.Serializable, CharSequence
{/** 使用serialVersionUID进行互操作 */static final long serialVersionUID = 4383685877147921099L;/*** 构造一个不包含任何字符且初始容量为16个字符的字符串生成器。*/public StringBuilder() {super(16);}/*** 构造一个字符串构建器，其中不包含任何字符，并且初始容量由{@code Capacity}参数指定。** @param      初始容量.* @throws     NegativeArraySizeException如果{acode capacity}参数小于{acode 0}。*/public StringBuilder(int capacity) {super(capacity);}/*** 构造一个字符串构建器，初始化为指定字符串的内容。字符串生成器的初始容量为{@code 16}加上字符串参数的长度。* @param   str   缓冲区的初始内容。*/public StringBuilder(String str) {super(str.length() + 16);append(str);}/*** 构造一个字符串生成器，其中包含与指定的{@code CharSequence}相同的字符。
字符串生成器的初始容量为{@code 16}加上字符串长度{acode CharSequence}参数。** @param      seq   复制顺序。.*/public StringBuilder(CharSequence seq) {this(seq.length() + 16);append(seq);}}

1. 同样，StringBuilder类被final所修饰，不能被继承；
2. StringBuilder类继承于AbstractStringBuilder类，于StringBuffer类相同，AbstractStringBuilder类也具体实现了可变字符序列的一系列操作，如append（），inset（），delete（），replace（）；
3. StringBuilder实现了java.io.Serializable序列化接口，表示对象可以被序列化，实现了CharSequence字符序列化接口，提供了几个对字符序列进行只读的方法，如length（），charAt(),subSequence(),toString()方法等。
4. StringBuilder实际上继承于AbstractStringBuilder类，所new出来的对象仍然是调用的AbstractStringBuilder类中的变量；
5. 再来看StringBuilder的其他方法：

与StringBuffer不同的是，在StringBuilder类中的方法并没有被synchronized或final所修饰，这意味着StringBuilder是不安全的；

注：StringBuffer和StringBuilder两者都继承于AbstractStringBuilder类，内部结构都是一个char[]的一个数组，这个数组并没有没有被final修饰，看上述源码的初始容量皆为16，当存储满之后会进行一个扩容，调用了System.arraycopy()扩容；