JAVA源码解读之StringBuffer

/**
 * A thread-safe, mutable sequence of characters.
 * A string buffer is like a {@link 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.
 * <p>
 * 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.
 * <p>
 * The principal operations on a <code>StringBuffer</code> are the
 * <code>append</code> and <code>insert</code> 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
 * <code>append</code> method always adds these characters at the end
 * of the buffer; the <code>insert</code> method adds the characters at
 * a specified point.
 * <p>
 * For example, if <code>z</code> refers to a string buffer object
 * whose current contents are "<code>start</code>", then
 * the method call <code>z.append("le")</code> would cause the string
 * buffer to contain "<code>startle</code>", whereas
 * <code>z.insert(4, "le")</code> would alter the string buffer to
 * contain "<code>starlet</code>".
 * <p>
 * In general, if sb refers to an instance of a <code>StringBuffer</code>,
 * then <code>sb.append(x)</code> has the same effect as
 * <code>sb.insert(sb.length(), x)</code>.
 * <p>
 * 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.
 * <p>
 * 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.
 *
 * As of  release JDK 5, this class has been supplemented with an equivalent
 * class designed for use by a single thread, {@link StringBuilder}.  The
 * <tt>StringBuilder</tt> 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.
 *
 * @author      Arthur van Hoff
 * @see     java.lang.StringBuilder
 * @see     java.lang.String
 * @since   JDK1.0
 */

• 这是一个线程安全的，可变的字符串
• StringBuffer类似于String，但是他是可以修改的。这个字符串可以通过调用方法来修改其长度与内容。
• StringBuffer是线程安全的，可以线程同步使用，在一些必要的同步方法中是使用synchronized的修饰的。
• StringBuffer的基本操作就是插入，insert和append。他们是被重载的，因此可以使用与任何数据类型的插入，每一个重载方法都有效地将给定数据类型转化为字符类型，然后再插入到StringBuffer中。其中append插入数据到字符串的串尾，insert插入数据到字符串的指定位置
• 举例子，z是一个StringBuffer对象，z代表的字符串是start，如果调用z.append("le")，现在的字符串是startle。如果调用的是z.insert(4,"le")，现在的字符串就是starlet
• sb是一个StringBuffer对象，sb.append(x)等价于sb.insert(sb.length(),x)
• 当操作源字符串时，这时候的操作将是被同步修饰执行的，而不是同步源字符串
• 每一个StringBuffer都有一个容量。如果这个容量可以容纳字符串的话，将不会扩容，但是容量不够存储字符串的话，sb对象将会自动扩容
• jdk1.5 发行之后，有一个等价的对象被补充-StringBuilder。但是StringBuilder不支持线程同步，他支持StringBuffer的所有方法，速度更快。推荐使用StringBuilder