StringBuilder线程不安全，效率高；StringBuffer线程安全，效率低
new StringBuilder创建长度为16的字符串数组
下面看程序实例：
package testString; public class stringBuilder { public static void main(String[] args) { StringBuilder stringBuilder = new StringBuilder();//字符数组初始长度为16 StringBuilder stringBuilder1 = new StringBuilder(32);//指定字符数组初始长度是32 StringBuilder stringBuilder2 = new StringBuilder("tyuiop");//字符数组初始长度是"tyuiop"+16=6+16=22 stringBuilder2.append("#fghjkl"); System.out.println(stringBuilder2); stringBuilder2.append("#1").append("#fada").append("#发达");//通过return this实现方法链 System.out.println(stringBuilder2); for (int i = 0; i < 10; i++) { stringBuilder.append(i); } System.out.println(stringBuilder); } }运行结果：
程序分析：StringBuilder是位于package java.lang;包下的类，是可变长数组的类。
其中super(16);调用父类的构造方法，并传参16，我们看父类的有参构造器源码：
abstract class AbstractStringBuilder implements Appendable, CharSequence { /** * The value is used for character storage. */ char[] value; /** * The count is the number of characters used. */ int count; /** * This no-arg constructor is necessary for serialization of subclasses. */ AbstractStringBuilder(int capacity) { value = new char[capacity]; } }由此可见，这个可变长字符数组的初始长度是16。
调用父类的有参构造方法，并传递参数用户指定长度capacity。
其中super();方法
/** * Creates an AbstractStringBuilder of the specified capacity. */ AbstractStringBuilder(int capacity) { value = new char[capacity]; }其中append()方法：
@Override public StringBuilder append(String str) { super.append(str); return this; }其中super.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; } append方法的功能就是拼接字符串：把给定字符串拼接到引用对象的后面。 观察发现每个append方法里面最后面都有return this 语句，this代表当前调用这个方法的对象，也就是谁调用这个方法就返回谁，使用this关键字的好处是可以支持方法链。当程序运行到断点处时，进入位于StringBuilder类中的append方法,传递的参数是字符”#“，下面看这个append方法的源码：
@Override public StringBuilder append(String str) { super.append(str); return this; }可以看到在此处有调用StringBuilder类的父类的append方法，此时传递的参数是字符”#“那么我们进入StringBuilder类的父类的append方法中：
/** * Appends the specified string to this character sequence. * <p> * The characters of the {@code String} argument are appended, in * order, increasing the length of this sequence by the length of the * argument. If {@code str} is {@code null}, then the four * characters {@code "null"} are appended. * <p> * Let <i>n</i> be the length of this character sequence just prior to * execution of the {@code append} method. Then the character at * index <i>k</i> in the new character sequence is equal to the character * at index <i>k</i> in the old character sequence, if <i>k</i> is less * than <i>n</i>; otherwise, it is equal to the character at index * <i>k-n</i> in the argument {@code str}. * * @param str a string. * @return a reference to this object. */ 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; }从上述的源码中发现，这个方法的功能就是先进行原来的字符数组的空间判断，如果空间足够就直接追加，如果不够就按照一定的规则进行扩展，然后再添加。获取完新增字符串的长度之后，进入校验方法ensureCapacityInternal()进行校验原字符数组的空间够不够，源码如下：
/** * For positive values of {@code minimumCapacity}, this method * behaves like {@code ensureCapacity}, however it is never * synchronized. * If {@code minimumCapacity} is non positive due to numeric * overflow, this method throws {@code OutOfMemoryError}. */ private void ensureCapacityInternal(int minimumCapacity) { // overflow-conscious code if (minimumCapacity - value.length > 0) { value = Arrays.copyOf(value, newCapacity(minimumCapacity)); } }当for循环执行第一次的时候，len = str.length()=1，count=0，所以传递给ensureCapacityInternal() 方法的参数minimumCapacity=1，显然minimumCapacity不可能大于value.length（=16，初始大小）， 那么就不创建新的字符数组。下一步执行str.getChars(0, len, value, count)方法，并传递复制字符串的相关参数，下面是getChars()源码：
/** * Copies characters from this string into the destination character * array. * <p> * The first character to be copied is at index {@code srcBegin}; * the last character to be copied is at index {@code srcEnd-1} * (thus the total number of characters to be copied is * {@code srcEnd-srcBegin}). The characters are copied into the * subarray of {@code dst} starting at index {@code dstBegin} * and ending at index: * <blockquote><pre> * dstBegin + (srcEnd-srcBegin) - 1 * </pre></blockquote> * * @param srcBegin index of the first character in the string * to copy. * @param srcEnd index after the last character in the string * to copy. * @param dst the destination array. * @param dstBegin the start offset in the destination array. * @exception IndexOutOfBoundsException If any of the following * is true: * <ul><li>{@code srcBegin} is negative. * <li>{@code srcBegin} is greater than {@code srcEnd} * <li>{@code srcEnd} is greater than the length of this * string * <li>{@code dstBegin} is negative * <li>{@code dstBegin+(srcEnd-srcBegin)} is larger than * {@code dst.length}</ul> */ public void getChars(int srcBegin, int srcEnd, char dst[], int dstBegin) { if (srcBegin < 0) { throw new StringIndexOutOfBoundsException(srcBegin); } if (srcEnd > value.length) { throw new StringIndexOutOfBoundsException(srcEnd); } if (srcBegin > srcEnd) { throw new StringIndexOutOfBoundsException(srcEnd - srcBegin); } System.arraycopy(value, srcBegin, dst, dstBegin, srcEnd - srcBegin); }前面三个if语句是进行安全性校验，防止传入不合法的索引数据，如果所有的数据都合法，那么就执行System.arraycopy()方法，这个方法是把新增加的那个字符串追加到原来的字符数组中。具体分析一下System.arraycopy()方法：value是原来创建的字符数组（还未扩容），srcBegin=0，dst是getChar方法传递的参数value[]，srcEnd是getsChar方法传递的参数len,每次追加的都是一个#，所以len=1=srcEnd，dstBegin是getChar方法传递的参数count，随着循环次数增加而增加，srcEnd - srcBegin表示的是len-0,也即是追加的字符串的长度，那么这个方法就是把value[]（是String类里面的value[]）的从srcBegin索引开始的元素复制到dst[]的从dstBegin索引开始共srcEnd - srcBegin个字符的储存空间中。注意：dst[]是形参，它的实参是value[]（是StringBuilder里面的value[] ;）。下面我理解的是，每次循环（StringBuilder类的对象存储空间足够）都会调用一次System.arraycopy()方法进行复制，就是新创建一个String类的字符数组对象存储传递过来的字符串常量（待添加的字符串），然后从头直接复制到StringBuilder类的对象value[]中。
当循环到第17次时（i=16），此时的可变长字符数组的存储空间已经不够用了，需要拓展空间，进入ensureCapacityInternal（）方法中
private void ensureCapacityInternal(int minimumCapacity) { // overflow-conscious code if (minimumCapacity - value.length > 0) { value = Arrays.copyOf(value, newCapacity(minimumCapacity)); } }newCapacity()方法的源码是：
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; }(value.length << 1)中的“<<”是把这个数的二进制左移一位，左移一位就是数值乘以2，右移一位就是数字除以2，也就是说这里把原来的字符数组的长度扩大为原来的2倍加2，最后返回值处使用的是一个三元运算符：简单分析，返回值是newCapacity，就是新的字符数组长度。
PS：移位运算
二进制十进制0000 00102左移一位：0000 010040000 110012右移一位：0000 01106然后调用Arrays.copyOf（）方法，源码如下：
public static char[] copyOf(char[] original, int newLength) { char[] copy = new char[newLength]; System.arraycopy(original, 0, copy, 0, Math.min(original.length, newLength)); return copy; }可以看到直接创建一个大小为newLength（newCapacity）的新的字符数组copy[]，然后还是调用System.arraycopy()方法，把原来的value[]数组里面的所有元素复制到copy[]数组中，最终赋值给value[]数组。
StringBuilder线程不安全，效率高；StringBuffer线程安全，效率低
StringBuffer类的方法种类与StringBuilder类的方法完全相同，用法也相同，只是StringBuffer类的方法都被synchronized关键词修饰，表示线程安全，调用这里的方法必须要有对象锁，涉及到多线程问题，后续再学习。
您可能会好奇为什么博客标题前面要加上数字？是这样的：本人之前在博客园发布自己的学习java的过程，标号以前的博客都那里了，为了不做无用功就不一一搬运，所以就在这边沿用那里的标号，欢迎您去博客园阅读并指出我的博客内容的不足之处。
我的博客园地址：https://www.cnblogs.com/fanfada/记录了一个小白自学java的旅程