前言
相信很多程序員在使用String、StringBuilder和StringBuffer的時候都知道怎麼使用，卻並不會去看其原理，
在學習這三個類之前先認識一下CharSequence接口和Appendable接口：
CharSequence接口，出自於JDK1.4，有如下幾個常用的方法：
int length(); 返回字符序列長度
char charAt(int index); 返回字符序列在指定索引處的字符
CharSequence subSequence(int start, int end); 截取字符序列從索引start到end之間的值。包括start不包括end。例如：長度爲5的字符序列“12345”，截圖0到3的值爲“123”，即真正的返回值爲索引start到end-1之間的值。
Appendable接口，出自JDK1.5，有如下幾個常用方法：
Appendable append(CharSequence csq) throws IOException; 拼接字符序列
Appendable append(CharSequence csq, int start, int end) throws IOException; 拼接字符序列指定區間內的字符序列，包括start不包括end。即真正拼接的值爲索引start到end-1之間的值。
Appendable append(char c) throws IOException; 拼接字符
概括
String類是耳熟能詳的類了，沒什麼可以介紹了的，只是在這裏做一下簡單的對比，String類適合很少量的字符串操作，做大量操作時相對其他StringBuilder和StringBuffer消耗時間和內存，而後面兩者則都是適合做大量的拼接，截取，替換一類的操作，並且StringBuffer是線程安全的，StringBuilder是不安全的，值得一提的是這兩者都繼承於AbstractStringBuilder，兩者本身並沒有做太多的實際性工作，幾乎所有的邏輯操作都在父類AbstractStringBuilder中，除了toString，toString是AbstractStringBuilder類的唯一的抽象方法。
StringBuffer類
StringBuffer類，繼承AbstractStringBuilder，實現Serializable序列化，操作上是線程安全的，線程安全的原因就是該類進行數據操作的相關方法都加了synchronized關鍵字，而StringBuilder則都沒有加。
toStringCache變量：使用transient修飾，不參與序列化，作爲toString方法緩存用
默認構造器：調用父類構造器，傳遞一個默認的長度值16，父類構造器創建一個長度爲16的字符數組;
參數爲int的構造器：參數爲int的構造器意思是構造一個指定長度的字符數組
參數爲String和CharSequence的構造器：會構造一個長度爲(16+CharSequence字符長度)或者(16+String字符串長度)的字符數組。然後再拼接一下參數中的字符或者字符串，如果參數爲null會拋出空指針異常(NullPointerException)。
length方法：返回實際數據長度
capacity方法：返回父類構造器的字符數組長度
public final class StringBuffer extends AbstractStringBuilder
implements java.io.Serializable, CharSequence{
private transient char[] toStringCache;
/** use serialVersionUID from JDK 1.0.2 for interoperability */
static final long serialVersionUID = 3388685877147921107L;
public StringBuffer() {
super(16);
}
public StringBuffer(int capacity) {
super(capacity);
}
public StringBuffer(String str) {
super(str.length() + 16);
append(str);
}
public StringBuffer(CharSequence seq) {
this(seq.length() + 16);
append(seq);
}
@Override
public synchronized int length() {
return count;
}
@Override
public synchronized int capacity() {
return value.length;
}
接下來看一看一些相關操作的方法：
可以看到如拼接，插入，刪除，替換之類的操作都是調用父類的方法，並且返回的是調用該方法的類對象，這就表明StringBuffer類在進行數據改變的操作後返回類對象本身，原因就是父類中儲存數據的字符數組value沒有final所修飾，所以可以做到修改數據而不改變類對象。
而String類中儲存數據的字符數組變量value是被final修飾的，也就說明無法對String類對象的值進行直接的修改，所以對其進行數據改變操作的返回值都是new String(XXX),也就是每個返回值都是一個新的String對象，所以String類不適合大量的數據值改變的操作。
toStringCache變量：只有在調用toString方法的時候給予賦值操作，臨時儲存數據，然後轉換爲Sting對象當做返回值。而每次對數據進行改變的時候都會重置變量值，保證每次toString之前該變量都是空。
@Override
public synchronized StringBuffer append(String str) {
toStringCache = null;
super.append(str);
return this;
}
@Override
public synchronized StringBuffer delete(int start, int end) {
toStringCache = null;
super.delete(start, end);
return this;
}
@Override
public synchronized StringBuffer replace(int start, int end, String str) {
toStringCache = null;
super.replace(start, end, str);
return this;
}
@Override
public synchronized StringBuffer insert(int index, char[] str, int offset,
int len)
{
toStringCache = null;
super.insert(index, str, offset, len);
return this;
}
@Override
public int indexOf(String str) {
// Note, synchronization achieved via invocations of other StringBuffer methods
return super.indexOf(str);
}
@Override
public synchronized int indexOf(String str, int fromIndex) {
return super.indexOf(str, fromIndex);
}
@Override
public int lastIndexOf(String str) {
// Note, synchronization achieved via invocations of other StringBuffer methods
return lastIndexOf(str, count);
}
@Override
public synchronized int lastIndexOf(String str, int fromIndex) {
return super.lastIndexOf(str, fromIndex);
}
@Override
public synchronized StringBuffer reverse() {
toStringCache = null;
super.reverse();
return this;
}
@Override
public synchronized String toString() {
if (toStringCache == null) {
toStringCache = Arrays.copyOfRange(value, 0, count);
}
return new String(toStringCache, true);
}
StringBuilder類
StringBuilder類和StringBuffer差不多，少了一個toStringCache變量，所以的操作方法都沒有添加sybchronized關鍵字，所以StringBuilder是線程不安全的類。就不多說了哈(*^▽^*)。
AbstractStringBuilder
AbstractStringBuilder產於JDK1.5，實現Appendable接口和CharSequence接口
該類只能被繼承，有兩個子類StringBuffer和StringBuilder，會默認調用有參構造器，指定初始化的字符串數據長度
value： 實例化時創建出來的字符數組
count： 實際數據包含的字符的長度
length方法：返回實際數據包含的字符的長度
capacity方法：返回字符數組的大小
代碼如下：
abstract class AbstractStringBuilder implements Appendable, CharSequence {
char[] value;
int count;
AbstractStringBuilder() {
}
AbstractStringBuilder(int capacity) {
value = new char[capacity];
}
@Override
public int length() {
return count;
}
public int capacity() {
return value.length;
}
數據儲存空間操作相關方法：
ensureCapacityInternal：每次進行數據改變操作之前都會調用的方法，其意在於確保數組變量value有能力承受接下來的改變，說白了就是對數據操作的之前改變字符數組大小，使其容量能足夠接下來的操作使用而不出現錯誤。
MAX_ARRAY_SIZE：私有靜態常量，值爲 Integer.MAX_VALUE - 8，按照文檔翻譯來說，就是字符數組的最大容量，但是卻沒有達到Integer的最大值，原因是某些JVM虛擬機會在一個數組中保留一些標題詞，如果強行嘗試區分配超過這個容量的數組可能會導致拋出異常OutOfMemoryError：請求的數組大小超過VM限制。
newCapacity：重新設置字符數組的容量，並作爲返回值。參數表示字符數組的最小容量，首先要知道字符串數組初始長度爲16，擴容方式爲原字符數組長度左移一位後再加2(原字符數組長度乘以2，再加2)。該方法就是比較一次擴容後value長度值newCapacity和參數指定的最小值minCapacity，如果一次擴容滿足最小值需求，則使用newCapacity，如果不滿於則直接使用minCapacity並且賦值於newCapacity，最後判斷minCapacity的大小是否大於0並小於指定的MAX_ARRAY_SIZE的值，如果滿足則返回minCapacity的值，如果不滿足則表示要求的最小值超過了建議的最大值容量，那將把minCapacity傳遞給爲hugeCapacity方法，並以該方法的返回值作爲本方法的返回值，如下。鄭州專業婦科醫院 http://www.hnzzkd.com/
hugeCapacity：如果參數給定值超過Integer的類型最大值，拋出內存溢出異常，如果小於Integer的最大值，則和AbstractStringBuilder類的建議值對比，哪一個值大，則使用哪一個值作爲返回值。
trimToSize：去除多餘的數組儲存空間，提高空間利用率。比較數組空間value的大小和實際數據count大小，如果實際數據元素小於value，則表示實際數據並未佔滿分配的空間，調用Arrays.copyOf方法把value中的空間鋪滿，返回鋪滿後的value值，
setLength：設置當前序列的長度爲指定的參數長度newLength，如果當前序列的長度超出指定長度newLength，就把已有序列的前面長度爲newLength的字符拷貝到新字符序列裏，多出來的一部分捨棄。如果不超過newLegth，原有數據不變，就把缺少的幾個位置的數據設置爲空字符。
private void ensureCapacityInternal(int minimumCapacity) {
// overflow-conscious code
if (minimumCapacity - value.length > 0) {
value = Arrays.copyOf(value,
newCapacity(minimumCapacity));
}
}
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
private int newCapacity(int minCapacity) {
// overflow-conscious code
int newCapacity = (value.length << 1) + 2;
if (newCapacity - minCapacity < 0) {
newCapacity = minCapacity;
}
return (newCapacity <= 0 || MAX_ARRAY_SIZE - newCapacity < 0)
? hugeCapacity(minCapacity)
: newCapacity;
}
private int hugeCapacity(int minCapacity) {
if (Integer.MAX_VALUE - minCapacity < 0) { // overflow
throw new OutOfMemoryError();
}
return (minCapacity > MAX_ARRAY_SIZE)
? minCapacity : MAX_ARRAY_SIZE;
}
public void trimToSize() {
if (count < value.length) {
value = Arrays.copyOf(value, count);
}
}
public void setLength(int newLength) {
if (newLength < 0)
throw new StringIndexOutOfBoundsException(newLength);
ensureCapacityInternal(newLength);
if (count < newLength) {
Arrays.fill(value, count, newLength, '\0');
}
count = newLength;
}
接下來看一下實際的數據操作，這裏以最常用的拼接和替換爲例：
appendNull：先擴容，然後依次拼接字符n u l l，拼接的同時進行count++;
append：先判斷字符串是否爲null，如果是執行appendNull，如果不是空，則獲取目標對象的長度，然後進行擴容，然後把目標對象拷貝到value的後面。然後更新數據的大小count。返回類對象
replace：先判斷一系列索引越界問題，如果都沒問題檢查end是否超出count，超出了則修改end的值爲count，獲取目標字符串的長度，計算經過替換後的數據長度。原長度減去要被替換的長度加上要替換成的字符串長度：count-(end-start)+len。計算完成後更新字符數組大小，拷貝字符後更新count的值。返回類對象
private AbstractStringBuilder appendNull() {
int c = count;
ensureCapacityInternal(c + 4);
final char[] value = this.value;
value[c++] = 'n';
value[c++] = 'u';
value[c++] = 'l';
value[c++] = 'l';
count = c;
return this;
}
public AbstractStringBuilder append(String str) {
if (str == null)
return appendNull();
int len = str.length();
ensureCapacityInternal(count + len);
str.getChars(0, len, value, count);
count += len;
return this;
}
public AbstractStringBuilder replace(int start, int end, String str) {
if (start < 0)
throw new StringIndexOutOfBoundsException(start);
if (start > count)
throw new StringIndexOutOfBoundsException("start > length()");
if (start > end)
throw new StringIndexOutOfBoundsException("start > end");
if (end > count)
end = count;
int len = str.length();
int newCount = count + len - (end - start);
ensureCapacityInternal(newCount);
System.arraycopy(value, end, value, start + len, count - end);
str.getChars(value, start);
count = newCount;
return this;
}
public AbstractStringBuilder delete(int start, int end) {
if (start < 0)
throw new StringIndexOutOfBoundsException(start);
if (end > count)
end = count;
if (start > end)
throw new StringIndexOutOfBoundsException();
int len = end - start;
if (len > 0) {
System.arraycopy(value, start+len, value, start, count-end);
count -= len;
}
return this;
}