概述
StringBuilder和StringBuffer是兩個容易混淆的概念，本文從源碼入手，簡單看二者的異同。
容易知道的是，這兩者有一個是線程安全的，而且線程安全的那個效率低。
java doc裡面的說明
java doc是寫源碼的人寫的註釋，先看java doc。
StringBuilder
A mutable sequence of characters. This class provides an API compatible with StringBuffer, but with no guarantee of synchronization. This class is designed for use as a drop-in replacement for StringBuffer in places where the string buffer was being used by a single thread (as is generally the case). Where possible, it is recommended that this class be used in preference to StringBuffer as it will be faster under most implementations.
The principal operations on a StringBuilder are the append and insert methods, which are overloaded so as to accept data of any type. Each effectively converts a given datum to a string and then appends or inserts the characters of that string to the string builder. The append method always adds these characters at the end of the builder; the insert method adds the characters at a specified point.
For example, if z refers to a string builder object whose current contents are "start", then the method call z.append("le") would cause the string builder to contain "startle", whereas z.insert(4, "le") would alter the string builder to contain "starlet".
In general, if sb refers to an instance of a StringBuilder, then sb.append(x) has the same effect as sb.insert(sb.length(), x).
Every string builder has a capacity. As long as the length of the character sequence contained in the string builder does not exceed the capacity, it is not necessary to allocate a new internal buffer. If the internal buffer overflows, it is automatically made larger.
Instances of StringBuilder are not safe for use by multiple threads. If such synchronization is required then it is recommended that java.lang.StringBuffer be used.
Unless otherwise noted, passing a null argument to a constructor or method in this class will cause a NullPointerException to be thrown.
Since:
1.5
Author:
Michael McCloskey
See Also:
java.lang.StringBuffer
java.lang.String
StringBuffer
A thread-safe, mutable sequence of characters. A string buffer is like a String, but can be modified. At any point in time it contains some particular sequence of characters, but the length and content of the sequence can be changed through certain method calls.
String buffers are safe for use by multiple threads. The methods are synchronized where necessary so that all the operations on any particular instance behave as if they occur in some serial order that is consistent with the order of the method calls made by each of the individual threads involved.
The principal operations on a StringBuffer are the append and insert methods, which are overloaded so as to accept data of any type. Each effectively converts a given datum to a string and then appends or inserts the characters of that string to the string buffer. The append method always adds these characters at the end of the buffer; the insert method adds the characters at a specified point.
For example, if z refers to a string buffer object whose current contents are "start", then the method call z.append("le") would cause the string buffer to contain "startle", whereas z.insert(4, "le") would alter the string buffer to contain "starlet".
In general, if sb refers to an instance of a StringBuffer, then sb.append(x) has the same effect as sb.insert(sb.length(),
Whenever an operation occurs involving a source sequence (such as appending or inserting from a source sequence), this class synchronizes only on the string buffer performing the operation, not on the source. Note that while StringBuffer is designed to be safe to use concurrently from multiple threads, if the constructor or the append or insert operation is passed a source sequence that is shared across threads, the calling code must ensure that the operation has a consistent and unchanging view of the source sequence for the duration of the operation. This could be satisfied by the caller holding a lock during the operation's call, by using an immutable source sequence, or by not sharing the source sequence across threads.
Every string buffer has a capacity. As long as the length of the character sequence contained in the string buffer does not exceed the capacity, it is not necessary to allocate a new internal buffer array. If the internal buffer overflows, it is automatically made larger.
Unless otherwise noted, passing a null argument to a constructor or method in this class will cause a NullPointerException to be thrown.
As of release JDK 5, this class has been supplemented with an equivalent class designed for use by a single thread, StringBuilder. The StringBuilder class should generally be used in preference to this one, as it supports all of the same operations but it is faster, as it performs no synchronization.
Since:
JDK1.0
Author:
Arthur van Hoff
See Also:
java.lang.StringBuilder
java.lang.String
javadoc小結
從上面可以看出：
StringBuffer和StringBuilder都可以認為是可變的String。
StringBuffer是線程安全的，先出現，在JDK1.0的時候就有了。
StringBuilder是非線程安全的，後出現，在JDK1.5才有。
二者的接口完全一樣，StringBuilder更快。
其實，正常的用，知道這幾點就好了，不過還是想看看源碼裡面怎麼實現的。
源碼
如何實現線程安全
看源碼可以知道，這二者都繼承了一個抽像類AbstractStringBuilder
public final class StringBuffer extends AbstractStringBuilder implements java.io.Serializable, CharSequencepublic final class StringBuilder extends AbstractStringBuilder implements java.io.Serializable, CharSequence
代碼量也不是很大，StringBuilder440行代碼，StringBuffer718行代碼，最多的是AbstractStringBuilder，一共1440行代碼。
看代碼從幾個角度看，一是一些關鍵的內部結構是怎麼樣的，二是我們常用的函數是怎麼實現的。因為String是不可變的，是放在常量池裡面的。猜測StringBuilder和StringBuffer應該是用char數組實現的。
/** * The value is used for character storage. */ char[] value; /** * The count is the number of characters used. */ int count;
可以看出，用value存數據，用一個count表示長度。
看幾個常見方法的不同實現。
StringBuffer
@Override public synchronized StringBuffer append(String str) { toStringCache = null; super.append(str); return this; } /** * @throws StringIndexOutOfBoundsException {@inheritDoc} */ @Override public synchronized StringBuffer insert(int offset, String str) { toStringCache = null; super.insert(offset, str); return this; } @Override public synchronized String toString() { if (toStringCache == null) { toStringCache = Arrays.copyOfRange(value, 0, count); } return new String(toStringCache, true); }StringBuilder
@Override public StringBuilder append(String str) { super.append(str); return this; } /** * @throws StringIndexOutOfBoundsException {@inheritDoc} */ @Override public StringBuilder insert(int offset, String str) { super.insert(offset, str); return this; } @Override public String toString() { // Create a copy, don't share the array return new String(value, 0, count); }由代碼可知，大部分情況想，StrinbBuffer只是增加了一個synchronized關鍵字來保證線程安全。但toString方法不同，這個後面再說。
初始化大小和如何增長
既然實際上是一個數組，那麼數組開始的大小和增長的方法就很重要，我們通過代碼看一下。
/** * Constructs a string buffer with no characters in it and an * initial capacity of 16 characters. */ public StringBuffer() { super(16); } /** * Constructs a string builder with no characters in it and an * initial capacity of 16 characters. */ public StringBuilder() { super(16); }可以看到，這兩個默認構造函數都說明默認的數組大小是16。
為什麼是16呢？我沒想明白。
接下來關心如何增長的？我們看看append的實現
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; } /** * This method has the same contract as ensureCapacity, but is * never synchronized. */ private void ensureCapacityInternal(int minimumCapacity) { // overflow-conscious code if (minimumCapacity - value.length > 0) expandCapacity(minimumCapacity); } /** * This implements the expansion semantics of ensureCapacity with no * size check or synchronization. */ void expandCapacity(int minimumCapacity) { int newCapacity = value.length * 2 + 2; if (newCapacity - minimumCapacity < 0) newCapacity = minimumCapacity; if (newCapacity < 0) { if (minimumCapacity < 0) // overflow throw new OutOfMemoryError(); newCapacity = Integer.MAX_VALUE; } value = Arrays.copyOf(value, newCapacity); }上面三個方法說明瞭如何擴容。
把當前的容量*2+2
如果新增加的長度大於這個值，則設為新增加的值
如果溢出，則拋出OutOfMemoryError
StringBuffer中toString的實現
/** * A cache of the last value returned by toString. Cleared * whenever the StringBuffer is modified. */ private transient char[] toStringCache; @Override public synchronized StringBuffer append(String str) { toStringCache = null; super.append(str); return this; } @Override public synchronized String toString() { if (toStringCache == null) { toStringCache = Arrays.copyOfRange(value, 0, count); } return new String(toStringCache, true); }可以看到，定義了一個數組toStringCache，每次數據有變化，都把這個設置為null。在toString的時候，再重新從當前數據裡面拿。
transient關鍵字是為了避免這個數組被序列化。
小結
其實java本身的源碼寫的還是比較簡單的，學習知識如果能從源碼入手，能夠更深入的理解很多原理。本文只是簡單的列舉了一部分源碼，簡單說明StringBuffer和StringBuilder的異同。有興趣的朋友可以自己看一下。
以上這篇從源碼角度簡單看StringBuilder和StringBuffer的異同(全面解析)就是小編分享給大家的全部內容了，希望能給大家一個參考，也希望大家多多支持武林網。