//------------------------------------------------------------------------
写篇博客不easy。请尊重作者劳动成果。
转载请注明出处：http://blog.csdn.net/chdjj
//------------------------------------------------------------------------
我认为要通过源代码研究一个类，应该先从总体上了解这个类。比方说这个类的继承体系，有哪些超类，继承了那些接口，提供了什么样的方法。然后。我们再去源代码中了解详细的实现过程，这样才不会乱~
注：下面源代码基于jdk1.7.0_11
我们来看看StringBuilder和StringBuffer的继承关系:
public final class StringBuilder//1.5開始 extends AbstractStringBuilder implements java.io.Serializable, CharSequencepublic final class StringBuffer//1.0就有了 extends AbstractStringBuilder implements java.io.Serializable, CharSequence惊人的一致，两个类都 继承了AbstractStringBuilder，而且实现CharSequence和Serializable接口 ，Serializable接口大家都熟悉，是一个序列化的标志。那么我们 先来看CharSquence接口：
package java.lang;/** * @author Mike McCloskey * @since 1.4 * @spec JSR-51 */public interface CharSequence { int length(); char charAt(int index); CharSequence subSequence(int start, int end); public String toString();} 仅仅有四个方法。这个接口为不同的字符序列类提供了统一的规范。看到这个类有个toString的方法。说明它 强制子类去实现toString，而不使用默认的toString。其它三个方法也比較好理解。甚至大家在String中还常常使用这些方法。这里就不提了。
分析完了Charsequence接口。以下再看看AbstractStringBuilder类吧。听名字就知道是个抽象类。 这个类是到1.5才有的。非常显然是因为添加了StringBuilder，设计者觉着能够将StringBuilder和StringBuffer进行泛化。抽取共同部分，这体现了面向对象的设计理念。
abstract class AbstractStringBuilder implements Appendable, CharSequenceAbstractStringBuilder又实现了CharSequence和Appendable接口， Appendable看名字就知道肯定跟StringBuilder和StringBuffer的可变性有关 ， 我们果断看看Appendable接口：
package java.lang;import java.io.IOException;public interface Appendable { Appendable append(CharSequence csq) throws IOException; Appendable append(CharSequence csq, int start, int end) throws IOException; Appendable append(char c) throws IOException;} 果然。这个接口提供了append方法的不同重载形式,返回值均为自己（注：看到这里，我想到了一句话， 抽象类是对类进行抽象，而接口是对行为进行抽象，想想确实如此呢）。既然AbstractStringBuilder实现了此接口，必定提供了实现，以下我们回到 AbstractStringBuilder类中看看这个类都干了啥。
先看成员变量：
/** * The value is used for character storage. */ char[] value;//用于存放字符的数组 /** * The count is the number of characters used. */ int count;//当前字符总数
注意，这里的value数组并没有声明为final（String类的value数组是final的），说明此数组可改变。
再看构造器：
AbstractStringBuilder() {} AbstractStringBuilder(int capacity) { value = new char[capacity]; } 一个无參构造器。一个构造器提供char数组初始容量,value数组依据此容量创建对象。
接下来看几个重要的方法。
首先是扩容的方法：
public void ensureCapacity(int minimumCapacity) { if (minimumCapacity > 0) ensureCapacityInternal(minimumCapacity); } /** * 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); } ensureCapacity方法确保当前字符数组的容量最小为minimumCapacity,首先推断这个參数是否为负，若是，则返回。否则调用ensureCapacityInternal方法，这种方法内部将推断当前容量是否小于 minimumCapacity。若是，则进行扩容。否则返回。扩容是通过调用expandCapacity方法来实现的，这种方法内部实现逻辑是这种： 首先试着将当前数组容量扩充为原数组容量的2倍加上2。假设这个新容量仍然小于最小值（minimumCapacity），那么就将新容量定为（minimumCapacity），最后推断是否溢出。若溢出，则将容量定为整型的最大值0x7fffffff。
容量定好之后，进行一次数组拷贝。
通过这一系列步骤。应该对我们有所启示，在创建StringBuilder或StringBuffer时。尽量估算下串的长度，给一个合理的初始值，避免多次扩容带来的效率问题。
接下来看append方法（重载太多，这里仅仅列举1个）：
public AbstractStringBuilder append(String str) { if (str == null) str = "null"; int len = str.length(); ensureCapacityInternal(count + len); str.getChars(0, len, value, count); count += len; return this; } 上面这个append方法接受一个String类型的參数。也是我们最常使用的重载形式.内部逻辑比較简单，首先进行參数推断（ 我们写代码的时候也应该时刻注意代码的鲁棒性，注意參数的取值），若參数为空（null）。则将null这几个字符作为參数，接下来推断是否须要扩容，完了之后进行一次复制，最后更新count。
还有个方法叫trimToSize。这种方法能够降低内存空间的使用。内部会进行数组复制，释放那些尚未使用的空间：
public void trimToSize() { if (count < value.length) { value = Arrays.copyOf(value, count); } } 至此，AbstractStringBuilder分析完成。
好吧， 如今我们能够分析StringBuilder和StringBuffer了！先来看看这个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); } 通过这个构造器我们知道了 StringBuilder的默认大小为16，这个非常关键哦，大家应该可以记住。假设能在面试中说出来，那也是极好的~
构造器除了有默认容量，也能够 手动设置容量，为避免扩容。强烈建议大家估摸下串的大致长度~
接下来是append方法，我们猜測应该调用的是AbstractStringBuilder中的append：
public StringBuilder append(Object obj) { return append(String.valueOf(obj)); } public StringBuilder append(String str) { super.append(str); return this; } 其实也正是这样。
再来看下这个toString方法：
public String toString() { // Create a copy, don't share the array return new String(value, 0, count); } 注意哦，这里返回的是一个新的字符串对象！
最后看下readObject和writeObject这两个方法。这两个方法都是私有的，方法的作用应该跟序列化有关。
private void writeObject(java.io.ObjectOutputStream s) throws java.io.IOException { s.defaultWriteObject(); s.writeInt(count); s.writeObject(value); } private void readObject(java.io.ObjectInputStream s) throws java.io.IOException, ClassNotFoundException { s.defaultReadObject(); count = s.readInt(); value = (char[]) s.readObject(); } 到这。StringBuilder分析完成，能够看出，StringBuilder中并没有什么复杂的逻辑，实现代码主要在AbstractStringBuilder中。
以下该分析StringBuffer了，大家都知道，StringBuffer和StringBuilder的最大差别就是StringBuffer线程安全。那么可想而知，StringBuffer的方法应该加锁了，带着这个猜想，打开StringBuffer源代码：
构造器就略过了，由于 StringBuffer跟StringBuilder全然一样，默认容量也是16.
以下随便来几个方法：
public synchronized int length() { return count; }public synchronized void trimToSize() { super.trimToSize(); } public synchronized StringBuffer append(String str) { super.append(str); return this; } 看，都加锁了吧。
你可能看到这种方法没加锁：
public StringBuffer append(CharSequence s) { // Note, synchronization achieved via other invocations if (s == null) s = "null"; if (s instanceof String) return this.append((String)s); if (s instanceof StringBuffer) return this.append((StringBuffer)s); return this.append(s, 0, s.length()); } 恩，确实没加，但注意到凝视没。设计者说了。加锁的操作是通过它内部调用的其他方法实现的，所以这里不是必需再进行一次加锁（锁须要浪费资源）。
剩下的代码都没啥说的了。除了加了synchronizedkeyword修饰，跟StringBuilder是一样一样的。
分析到此完成，以下做个总结：
1.StringBuilder是jdk1.5引进的，而StringBuffer在1.0就有了；
2.StringBuilder和StringBuffer都是可变的字符串。能够通过append或者insert等方法改动串的内容；
3.StringBuffer是线程安全的而StringBuilder不是，因而在多线程的环境下优先使用StringBuffer，而其它情况下推荐使用StringBuilder，由于它更快。
4.StringBuilder和StringBuffer都继承自AbstractStringBuilder类，AbStractStringBuilder主要实现了扩容、append、insert方法。StrngBuilder和StringBuffer的相关方法都直接调用的父类。
5.StringBuilder和StringBuffer的初始容量都是16,程序猿尽量手动设置初始值。以避免多次扩容所带来的性能问题；
6.StringBuilder和StringBuffer的扩容机制是这种：首先试着将当前数组容量扩充为原数组容量的2倍加上2，假设这个新容量仍然小于预定的最小值（minimumCapacity），那么就将新容量定为（minimumCapacity），最后推断是否溢出，若溢出，则将容量定为整型的最大值0x7fffffff。